summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorRich Trott <rtrott@gmail.com>2021-08-21 07:09:43 -0700
committerMichaël Zasso <targos@protonmail.com>2021-09-04 15:14:55 +0200
commite9b1a006a11c875c5c0f13568f7f081db7e9f01d (patch)
tree1011100ce8ce706bcbe2a289e4ce0db20a44374b
parent67f1bff657634ce3337b83cb31da6bf7d885aab7 (diff)
downloadnode-new-e9b1a006a11c875c5c0f13568f7f081db7e9f01d.tar.gz
tools: fix markdown linting
This updates remark-preset-lint-node to 3.0.1, which actually works unlike the 3.0.0 version we're using. (Sorry about 3.0.0 not actually linting!) It also updates rollup and the rollup config. So this uses the latest everything as of this writing. PR-URL: https://github.com/nodejs/node/pull/39832 Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com> Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Diffstat
-rw-r--r--.eslintignore2
-rw-r--r--Makefile2
-rw-r--r--tools/lint-md.mjs (renamed from tools/lint-md.js)66005
-rw-r--r--tools/node-lint-md-cli-rollup/package-lock.json2922
-rw-r--r--tools/node-lint-md-cli-rollup/package.json2
-rw-r--r--tools/node-lint-md-cli-rollup/rollup.config.js22
-rw-r--r--vcbuild.bat2
7 files changed, 30804 insertions, 38153 deletions
diff --git a/.eslintignore b/.eslintignore
index 19e0fcee9e..e8b8c3f297 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -4,7 +4,7 @@ test/addons/??_*
test/fixtures
test/message/esm_display_syntax_error.mjs
tools/icu
-tools/lint-md.js
+tools/lint-md.mjs
tools/node-lint-md-cli-rollup/dist
benchmark/tmp
doc/**/*.js
diff --git a/Makefile b/Makefile
index f346a4d61f..c25a97750f 100644
--- a/Makefile
+++ b/Makefile
@@ -1201,7 +1201,7 @@ LINT_MD_TARGETS = doc src lib benchmark test tools/doc tools/icu $(wildcard *.md
LINT_MD_FILES = $(shell $(FIND) $(LINT_MD_TARGETS) -type f \
! -path '*node_modules*' ! -path 'test/fixtures/*' -name '*.md' \
$(LINT_MD_NEWER))
-run-lint-md = tools/lint-md.js -q -f --no-stdout $(LINT_MD_FILES)
+run-lint-md = tools/lint-md.mjs -q -f --no-stdout $(LINT_MD_FILES)
# Lint all changed markdown files maintained by us
tools/.mdlintstamp: $(LINT_MD_FILES)
$(info Running Markdown linter...)
diff --git a/tools/lint-md.js b/tools/lint-md.mjs
index 1f865ab809..b614ae37d8 100644
--- a/tools/lint-md.js
+++ b/tools/lint-md.mjs
@@ -1,50 +1,19 @@
-'use strict';
-
-// Don't change this file manually,
-// it is generated from tools/node-lint-md-cli-rollup
-
-var require$$0$a = require('stream');
-var require$$0$7 = require('path');
-var require$$0$5 = require('util');
-var require$$0$6 = require('os');
-var require$$1 = require('tty');
-var require$$0$8 = require('fs');
-var require$$1$1 = require('module');
-var require$$0$9 = require('events');
-var require$$5$2 = require('assert');
-var url = require('url');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
- if (e && e.__esModule) return e;
- var n = Object.create(null);
- if (e) {
- Object.keys(e).forEach(function (k) {
- if (k !== 'default') {
- var d = Object.getOwnPropertyDescriptor(e, k);
- Object.defineProperty(n, k, d.get ? d : {
- enumerable: true,
- get: function () {
- return e[k];
- }
- });
- }
- });
- }
- n['default'] = e;
- return Object.freeze(n);
-}
-
-var require$$0__default$5 = /*#__PURE__*/_interopDefaultLegacy(require$$0$a);
-var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$7);
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$5);
-var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$6);
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-var require$$0__default$3 = /*#__PURE__*/_interopDefaultLegacy(require$$0$8);
-var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
-var require$$0__default$4 = /*#__PURE__*/_interopDefaultLegacy(require$$0$9);
-var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5$2);
+import path$b from 'path';
+import require$$0$3, { realpathSync as realpathSync$1, statSync, Stats } from 'fs';
+import { URL as URL$1, fileURLToPath, pathToFileURL } from 'url';
+import process$2 from 'node:process';
+import stream, { PassThrough } from 'node:stream';
+import require$$0$2 from 'os';
+import tty$1 from 'tty';
+import require$$0$5 from 'events';
+import require$$0$4, { format as format$2, inspect as inspect$1 } from 'util';
+import require$$1 from 'stream';
+import path$c from 'node:path';
+import { pathToFileURL as pathToFileURL$1 } from 'node:url';
+import assert$2 from 'assert';
+import fs$a from 'node:fs';
+import { EventEmitter as EventEmitter$1 } from 'node:events';
+import process$1 from 'process';
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -67,218 +36,8605 @@ function commonjsRequire (path) {
throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
}
-var cliEntry = {};
+var ansiStyles$2 = {exports: {}};
-var vfileStatistics = statistics$2;
+var colorName$1 = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+};
-// Get stats for a file, list of files, or list of messages.
-function statistics$2(files) {
- var result = {true: 0, false: 0, null: 0};
+/* MIT license */
+
+/* eslint-disable no-mixed-operators */
+const cssKeywords$1 = colorName$1;
- count(files);
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+// values that give correct `typeof` results).
+// do not use box values types (i.e. Number(), String(), etc.)
- return {
- fatal: result.true,
- nonfatal: result.false + result.null,
- warn: result.false,
- info: result.null,
- total: result.true + result.false + result.null
+const reverseKeywords$1 = {};
+for (const key of Object.keys(cssKeywords$1)) {
+ reverseKeywords$1[cssKeywords$1[key]] = key;
+}
+
+const convert$4 = {
+ rgb: {channels: 3, labels: 'rgb'},
+ hsl: {channels: 3, labels: 'hsl'},
+ hsv: {channels: 3, labels: 'hsv'},
+ hwb: {channels: 3, labels: 'hwb'},
+ cmyk: {channels: 4, labels: 'cmyk'},
+ xyz: {channels: 3, labels: 'xyz'},
+ lab: {channels: 3, labels: 'lab'},
+ lch: {channels: 3, labels: 'lch'},
+ hex: {channels: 1, labels: ['hex']},
+ keyword: {channels: 1, labels: ['keyword']},
+ ansi16: {channels: 1, labels: ['ansi16']},
+ ansi256: {channels: 1, labels: ['ansi256']},
+ hcg: {channels: 3, labels: ['h', 'c', 'g']},
+ apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+ gray: {channels: 1, labels: ['gray']}
+};
+
+var conversions$5 = convert$4;
+
+// Hide .channels and .labels properties
+for (const model of Object.keys(convert$4)) {
+ if (!('channels' in convert$4[model])) {
+ throw new Error('missing channels property: ' + model);
+ }
+
+ if (!('labels' in convert$4[model])) {
+ throw new Error('missing channel labels property: ' + model);
+ }
+
+ if (convert$4[model].labels.length !== convert$4[model].channels) {
+ throw new Error('channel and label counts mismatch: ' + model);
+ }
+
+ const {channels, labels} = convert$4[model];
+ delete convert$4[model].channels;
+ delete convert$4[model].labels;
+ Object.defineProperty(convert$4[model], 'channels', {value: channels});
+ Object.defineProperty(convert$4[model], 'labels', {value: labels});
+}
+
+convert$4.rgb.hsl = function (rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const min = Math.min(r, g, b);
+ const max = Math.max(r, g, b);
+ const delta = max - min;
+ let h;
+ let s;
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ const l = (min + max) / 2;
+
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
+
+ return [h, s * 100, l * 100];
+};
+
+convert$4.rgb.hsv = function (rgb) {
+ let rdif;
+ let gdif;
+ let bdif;
+ let h;
+ let s;
+
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const v = Math.max(r, g, b);
+ const diff = v - Math.min(r, g, b);
+ const diffc = function (c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ };
+
+ if (diff === 0) {
+ h = 0;
+ s = 0;
+ } else {
+ s = diff / v;
+ rdif = diffc(r);
+ gdif = diffc(g);
+ bdif = diffc(b);
+
+ if (r === v) {
+ h = bdif - gdif;
+ } else if (g === v) {
+ h = (1 / 3) + rdif - bdif;
+ } else if (b === v) {
+ h = (2 / 3) + gdif - rdif;
+ }
+
+ if (h < 0) {
+ h += 1;
+ } else if (h > 1) {
+ h -= 1;
+ }
+ }
+
+ return [
+ h * 360,
+ s * 100,
+ v * 100
+ ];
+};
+
+convert$4.rgb.hwb = function (rgb) {
+ const r = rgb[0];
+ const g = rgb[1];
+ let b = rgb[2];
+ const h = convert$4.rgb.hsl(rgb)[0];
+ const w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+ return [h, w * 100, b * 100];
+};
+
+convert$4.rgb.cmyk = function (rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+
+ const k = Math.min(1 - r, 1 - g, 1 - b);
+ const c = (1 - r - k) / (1 - k) || 0;
+ const m = (1 - g - k) / (1 - k) || 0;
+ const y = (1 - b - k) / (1 - k) || 0;
+
+ return [c * 100, m * 100, y * 100, k * 100];
+};
+
+function comparativeDistance$1(x, y) {
+ /*
+ See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+ */
+ return (
+ ((x[0] - y[0]) ** 2) +
+ ((x[1] - y[1]) ** 2) +
+ ((x[2] - y[2]) ** 2)
+ );
+}
+
+convert$4.rgb.keyword = function (rgb) {
+ const reversed = reverseKeywords$1[rgb];
+ if (reversed) {
+ return reversed;
+ }
+
+ let currentClosestDistance = Infinity;
+ let currentClosestKeyword;
+
+ for (const keyword of Object.keys(cssKeywords$1)) {
+ const value = cssKeywords$1[keyword];
+
+ // Compute comparative distance
+ const distance = comparativeDistance$1(rgb, value);
+
+ // Check if its less, if so set as closest
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
+
+ return currentClosestKeyword;
+};
+
+convert$4.keyword.rgb = function (keyword) {
+ return cssKeywords$1[keyword];
+};
+
+convert$4.rgb.xyz = function (rgb) {
+ let r = rgb[0] / 255;
+ let g = rgb[1] / 255;
+ let b = rgb[2] / 255;
+
+ // Assume sRGB
+ r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
+ g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
+ b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
+
+ const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+ const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+ const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+ return [x * 100, y * 100, z * 100];
+};
+
+convert$4.rgb.lab = function (rgb) {
+ const xyz = convert$4.rgb.xyz(rgb);
+ let x = xyz[0];
+ let y = xyz[1];
+ let z = xyz[2];
+
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+
+ x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+ const l = (116 * y) - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+
+ return [l, a, b];
+};
+
+convert$4.hsl.rgb = function (hsl) {
+ const h = hsl[0] / 360;
+ const s = hsl[1] / 100;
+ const l = hsl[2] / 100;
+ let t2;
+ let t3;
+ let val;
+
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
+
+ const t1 = 2 * l - t2;
+
+ const rgb = [0, 0, 0];
+ for (let i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+ if (t3 < 0) {
+ t3++;
+ }
+
+ if (t3 > 1) {
+ t3--;
+ }
+
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
+
+ rgb[i] = val * 255;
+ }
+
+ return rgb;
+};
+
+convert$4.hsl.hsv = function (hsl) {
+ const h = hsl[0];
+ let s = hsl[1] / 100;
+ let l = hsl[2] / 100;
+ let smin = s;
+ const lmin = Math.max(l, 0.01);
+
+ l *= 2;
+ s *= (l <= 1) ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ const v = (l + s) / 2;
+ const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+
+ return [h, sv * 100, v * 100];
+};
+
+convert$4.hsv.rgb = function (hsv) {
+ const h = hsv[0] / 60;
+ const s = hsv[1] / 100;
+ let v = hsv[2] / 100;
+ const hi = Math.floor(h) % 6;
+
+ const f = h - Math.floor(h);
+ const p = 255 * v * (1 - s);
+ const q = 255 * v * (1 - (s * f));
+ const t = 255 * v * (1 - (s * (1 - f)));
+ v *= 255;
+
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t, p, v];
+ case 5:
+ return [v, p, q];
+ }
+};
+
+convert$4.hsv.hsl = function (hsv) {
+ const h = hsv[0];
+ const s = hsv[1] / 100;
+ const v = hsv[2] / 100;
+ const vmin = Math.max(v, 0.01);
+ let sl;
+ let l;
+
+ l = (2 - s) * v;
+ const lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= (lmin <= 1) ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
+
+ return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert$4.hwb.rgb = function (hwb) {
+ const h = hwb[0] / 360;
+ let wh = hwb[1] / 100;
+ let bl = hwb[2] / 100;
+ const ratio = wh + bl;
+ let f;
+
+ // Wh + bl cant be > 1
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+
+ const i = Math.floor(6 * h);
+ const v = 1 - bl;
+ f = 6 * h - i;
+
+ if ((i & 0x01) !== 0) {
+ f = 1 - f;
+ }
+
+ const n = wh + f * (v - wh); // Linear interpolation
+
+ let r;
+ let g;
+ let b;
+ /* eslint-disable max-statements-per-line,no-multi-spaces */
+ switch (i) {
+ default:
+ case 6:
+ case 0: r = v; g = n; b = wh; break;
+ case 1: r = n; g = v; b = wh; break;
+ case 2: r = wh; g = v; b = n; break;
+ case 3: r = wh; g = n; b = v; break;
+ case 4: r = n; g = wh; b = v; break;
+ case 5: r = v; g = wh; b = n; break;
+ }
+ /* eslint-enable max-statements-per-line,no-multi-spaces */
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert$4.cmyk.rgb = function (cmyk) {
+ const c = cmyk[0] / 100;
+ const m = cmyk[1] / 100;
+ const y = cmyk[2] / 100;
+ const k = cmyk[3] / 100;
+
+ const r = 1 - Math.min(1, c * (1 - k) + k);
+ const g = 1 - Math.min(1, m * (1 - k) + k);
+ const b = 1 - Math.min(1, y * (1 - k) + k);
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert$4.xyz.rgb = function (xyz) {
+ const x = xyz[0] / 100;
+ const y = xyz[1] / 100;
+ const z = xyz[2] / 100;
+ let r;
+ let g;
+ let b;
+
+ r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+ g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+ b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+ // Assume sRGB
+ r = r > 0.0031308
+ ? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
+ : r * 12.92;
+
+ g = g > 0.0031308
+ ? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
+ : g * 12.92;
+
+ b = b > 0.0031308
+ ? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
+ : b * 12.92;
+
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
+
+ return [r * 255, g * 255, b * 255];
+};
+
+convert$4.xyz.lab = function (xyz) {
+ let x = xyz[0];
+ let y = xyz[1];
+ let z = xyz[2];
+
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+
+ x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+ const l = (116 * y) - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+
+ return [l, a, b];
+};
+
+convert$4.lab.xyz = function (lab) {
+ const l = lab[0];
+ const a = lab[1];
+ const b = lab[2];
+ let x;
+ let y;
+ let z;
+
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+
+ const y2 = y ** 3;
+ const x2 = x ** 3;
+ const z2 = z ** 3;
+ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+
+ return [x, y, z];
+};
+
+convert$4.lab.lch = function (lab) {
+ const l = lab[0];
+ const a = lab[1];
+ const b = lab[2];
+ let h;
+
+ const hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ const c = Math.sqrt(a * a + b * b);
+
+ return [l, c, h];
+};
+
+convert$4.lch.lab = function (lch) {
+ const l = lch[0];
+ const c = lch[1];
+ const h = lch[2];
+
+ const hr = h / 360 * 2 * Math.PI;
+ const a = c * Math.cos(hr);
+ const b = c * Math.sin(hr);
+
+ return [l, a, b];
+};
+
+convert$4.rgb.ansi16 = function (args, saturation = null) {
+ const [r, g, b] = args;
+ let value = saturation === null ? convert$4.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+
+ value = Math.round(value / 50);
+
+ if (value === 0) {
+ return 30;
+ }
+
+ let ansi = 30
+ + ((Math.round(b / 255) << 2)
+ | (Math.round(g / 255) << 1)
+ | Math.round(r / 255));
+
+ if (value === 2) {
+ ansi += 60;
+ }
+
+ return ansi;
+};
+
+convert$4.hsv.ansi16 = function (args) {
+ // Optimization here; we already know the value and don't need to get
+ // it converted for us.
+ return convert$4.rgb.ansi16(convert$4.hsv.rgb(args), args[2]);
+};
+
+convert$4.rgb.ansi256 = function (args) {
+ const r = args[0];
+ const g = args[1];
+ const b = args[2];
+
+ // We use the extended greyscale palette here, with the exception of
+ // black and white. normal palette only has 4 greyscale shades.
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
+
+ if (r > 248) {
+ return 231;
+ }
+
+ return Math.round(((r - 8) / 247) * 24) + 232;
+ }
+
+ const ansi = 16
+ + (36 * Math.round(r / 255 * 5))
+ + (6 * Math.round(g / 255 * 5))
+ + Math.round(b / 255 * 5);
+
+ return ansi;
+};
+
+convert$4.ansi16.rgb = function (args) {
+ let color = args % 10;
+
+ // Handle greyscale
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+
+ color = color / 10.5 * 255;
+
+ return [color, color, color];
+ }
+
+ const mult = (~~(args > 50) + 1) * 0.5;
+ const r = ((color & 1) * mult) * 255;
+ const g = (((color >> 1) & 1) * mult) * 255;
+ const b = (((color >> 2) & 1) * mult) * 255;
+
+ return [r, g, b];
+};
+
+convert$4.ansi256.rgb = function (args) {
+ // Handle greyscale
+ if (args >= 232) {
+ const c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+
+ args -= 16;
+
+ let rem;
+ const r = Math.floor(args / 36) / 5 * 255;
+ const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ const b = (rem % 6) / 5 * 255;
+
+ return [r, g, b];
+};
+
+convert$4.rgb.hex = function (args) {
+ const integer = ((Math.round(args[0]) & 0xFF) << 16)
+ + ((Math.round(args[1]) & 0xFF) << 8)
+ + (Math.round(args[2]) & 0xFF);
+
+ const string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+};
+
+convert$4.hex.rgb = function (args) {
+ const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+ if (!match) {
+ return [0, 0, 0];
+ }
+
+ let colorString = match[0];
+
+ if (match[0].length === 3) {
+ colorString = colorString.split('').map(char => {
+ return char + char;
+ }).join('');
+ }
+
+ const integer = parseInt(colorString, 16);
+ const r = (integer >> 16) & 0xFF;
+ const g = (integer >> 8) & 0xFF;
+ const b = integer & 0xFF;
+
+ return [r, g, b];
+};
+
+convert$4.rgb.hcg = function (rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const max = Math.max(Math.max(r, g), b);
+ const min = Math.min(Math.min(r, g), b);
+ const chroma = (max - min);
+ let grayscale;
+ let hue;
+
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
+ }
+
+ if (chroma <= 0) {
+ hue = 0;
+ } else
+ if (max === r) {
+ hue = ((g - b) / chroma) % 6;
+ } else
+ if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma;
+ }
+
+ hue /= 6;
+ hue %= 1;
+
+ return [hue * 360, chroma * 100, grayscale * 100];
+};
+
+convert$4.hsl.hcg = function (hsl) {
+ const s = hsl[1] / 100;
+ const l = hsl[2] / 100;
+
+ const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
+
+ let f = 0;
+ if (c < 1.0) {
+ f = (l - 0.5 * c) / (1.0 - c);
+ }
+
+ return [hsl[0], c * 100, f * 100];
+};
+
+convert$4.hsv.hcg = function (hsv) {
+ const s = hsv[1] / 100;
+ const v = hsv[2] / 100;
+
+ const c = s * v;
+ let f = 0;
+
+ if (c < 1.0) {
+ f = (v - c) / (1 - c);
+ }
+
+ return [hsv[0], c * 100, f * 100];
+};
+
+convert$4.hcg.rgb = function (hcg) {
+ const h = hcg[0] / 360;
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+
+ if (c === 0.0) {
+ return [g * 255, g * 255, g * 255];
+ }
+
+ const pure = [0, 0, 0];
+ const hi = (h % 1) * 6;
+ const v = hi % 1;
+ const w = 1 - v;
+ let mg = 0;
+
+ /* eslint-disable max-statements-per-line */
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+ case 1:
+ pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+ case 2:
+ pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+ case 3:
+ pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+ case 4:
+ pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+ default:
+ pure[0] = 1; pure[1] = 0; pure[2] = w;
+ }
+ /* eslint-enable max-statements-per-line */
+
+ mg = (1.0 - c) * g;
+
+ return [
+ (c * pure[0] + mg) * 255,
+ (c * pure[1] + mg) * 255,
+ (c * pure[2] + mg) * 255
+ ];
+};
+
+convert$4.hcg.hsv = function (hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+
+ const v = c + g * (1.0 - c);
+ let f = 0;
+
+ if (v > 0.0) {
+ f = c / v;
+ }
+
+ return [hcg[0], f * 100, v * 100];
+};
+
+convert$4.hcg.hsl = function (hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+
+ const l = g * (1.0 - c) + 0.5 * c;
+ let s = 0;
+
+ if (l > 0.0 && l < 0.5) {
+ s = c / (2 * l);
+ } else
+ if (l >= 0.5 && l < 1.0) {
+ s = c / (2 * (1 - l));
+ }
+
+ return [hcg[0], s * 100, l * 100];
+};
+
+convert$4.hcg.hwb = function (hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+ const v = c + g * (1.0 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert$4.hwb.hcg = function (hwb) {
+ const w = hwb[1] / 100;
+ const b = hwb[2] / 100;
+ const v = 1 - b;
+ const c = v - w;
+ let g = 0;
+
+ if (c < 1) {
+ g = (v - c) / (1 - c);
+ }
+
+ return [hwb[0], c * 100, g * 100];
+};
+
+convert$4.apple.rgb = function (apple) {
+ return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
+
+convert$4.rgb.apple = function (rgb) {
+ return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
+
+convert$4.gray.rgb = function (args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+
+convert$4.gray.hsl = function (args) {
+ return [0, 0, args[0]];
+};
+
+convert$4.gray.hsv = convert$4.gray.hsl;
+
+convert$4.gray.hwb = function (gray) {
+ return [0, 100, gray[0]];
+};
+
+convert$4.gray.cmyk = function (gray) {
+ return [0, 0, 0, gray[0]];
+};
+
+convert$4.gray.lab = function (gray) {
+ return [gray[0], 0, 0];
+};
+
+convert$4.gray.hex = function (gray) {
+ const val = Math.round(gray[0] / 100 * 255) & 0xFF;
+ const integer = (val << 16) + (val << 8) + val;
+
+ const string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+};
+
+convert$4.rgb.gray = function (rgb) {
+ const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+};
+
+const conversions$4 = conversions$5;
+
+/*
+ This function routes a model to all other models.
+
+ all functions that are routed have a property `.conversion` attached
+ to the returned synthetic function. This property is an array
+ of strings, each with the steps in between the 'from' and 'to'
+ color models (inclusive).
+
+ conversions that are not possible simply are not included.
+*/
+
+function buildGraph$1() {
+ const graph = {};
+ // https://jsperf.com/object-keys-vs-for-in-with-closure/3
+ const models = Object.keys(conversions$4);
+
+ for (let len = models.length, i = 0; i < len; i++) {
+ graph[models[i]] = {
+ // http://jsperf.com/1-vs-infinity
+ // micro-opt, but this is simple.
+ distance: -1,
+ parent: null
+ };
+ }
+
+ return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS$1(fromModel) {
+ const graph = buildGraph$1();
+ const queue = [fromModel]; // Unshift -> queue -> pop
+
+ graph[fromModel].distance = 0;
+
+ while (queue.length) {
+ const current = queue.pop();
+ const adjacents = Object.keys(conversions$4[current]);
+
+ for (let len = adjacents.length, i = 0; i < len; i++) {
+ const adjacent = adjacents[i];
+ const node = graph[adjacent];
+
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+
+ return graph;
+}
+
+function link$2(from, to) {
+ return function (args) {
+ return to(from(args));
+ };
+}
+
+function wrapConversion$1(toModel, graph) {
+ const path = [graph[toModel].parent, toModel];
+ let fn = conversions$4[graph[toModel].parent][toModel];
+
+ let cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path.unshift(graph[cur].parent);
+ fn = link$2(conversions$4[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path;
+ return fn;
+}
+
+var route$3 = function (fromModel) {
+ const graph = deriveBFS$1(fromModel);
+ const conversion = {};
+
+ const models = Object.keys(graph);
+ for (let len = models.length, i = 0; i < len; i++) {
+ const toModel = models[i];
+ const node = graph[toModel];
+
+ if (node.parent === null) {
+ // No possible conversion, or this node is the source model.
+ continue;
+ }
+
+ conversion[toModel] = wrapConversion$1(toModel, graph);
+ }
+
+ return conversion;
+};
+
+const conversions$3 = conversions$5;
+const route$2 = route$3;
+
+const convert$3 = {};
+
+const models$1 = Object.keys(conversions$3);
+
+function wrapRaw$1(fn) {
+ const wrappedFn = function (...args) {
+ const arg0 = args[0];
+ if (arg0 === undefined || arg0 === null) {
+ return arg0;
+ }
+
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+
+ return fn(args);
+ };
+
+ // Preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+}
+
+function wrapRounded$1(fn) {
+ const wrappedFn = function (...args) {
+ const arg0 = args[0];
+
+ if (arg0 === undefined || arg0 === null) {
+ return arg0;
+ }
+
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+
+ const result = fn(args);
+
+ // We're assuming the result is an array here.
+ // see notice in conversions.js; don't use box types
+ // in conversion functions.
+ if (typeof result === 'object') {
+ for (let len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+
+ return result;
+ };
+
+ // Preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+}
+
+models$1.forEach(fromModel => {
+ convert$3[fromModel] = {};
+
+ Object.defineProperty(convert$3[fromModel], 'channels', {value: conversions$3[fromModel].channels});
+ Object.defineProperty(convert$3[fromModel], 'labels', {value: conversions$3[fromModel].labels});
+
+ const routes = route$2(fromModel);
+ const routeModels = Object.keys(routes);
+
+ routeModels.forEach(toModel => {
+ const fn = routes[toModel];
+
+ convert$3[fromModel][toModel] = wrapRounded$1(fn);
+ convert$3[fromModel][toModel].raw = wrapRaw$1(fn);
+ });
+});
+
+var colorConvert$1 = convert$3;
+
+(function (module) {
+
+const wrapAnsi16 = (fn, offset) => (...args) => {
+ const code = fn(...args);
+ return `\u001B[${code + offset}m`;
+};
+
+const wrapAnsi256 = (fn, offset) => (...args) => {
+ const code = fn(...args);
+ return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => (...args) => {
+ const rgb = fn(...args);
+ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
+
+const ansi2ansi = n => n;
+const rgb2rgb = (r, g, b) => [r, g, b];
+
+const setLazyProperty = (object, property, get) => {
+ Object.defineProperty(object, property, {
+ get: () => {
+ const value = get();
+
+ Object.defineProperty(object, property, {
+ value,
+ enumerable: true,
+ configurable: true
+ });
+
+ return value;
+ },
+ enumerable: true,
+ configurable: true
+ });
+};
+
+/** @type {typeof import('color-convert')} */
+let colorConvert;
+const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+ if (colorConvert === undefined) {
+ colorConvert = colorConvert$1;
+ }
+
+ const offset = isBackground ? 10 : 0;
+ const styles = {};
+
+ for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+ const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
+ if (sourceSpace === targetSpace) {
+ styles[name] = wrap(identity, offset);
+ } else if (typeof suite === 'object') {
+ styles[name] = wrap(suite[targetSpace], offset);
+ }
+ }
+
+ return styles;
+};
+
+function assembleStyles() {
+ const codes = new Map();
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ // 21 isn't widely supported and 22 does the same thing
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+
+ // Bright color
+ blackBright: [90, 39],
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
+
+ // Alias bright black as gray (and grey)
+ styles.color.gray = styles.color.blackBright;
+ styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+ styles.color.grey = styles.color.blackBright;
+ styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+ for (const [groupName, group] of Object.entries(styles)) {
+ for (const [styleName, style] of Object.entries(group)) {
+ styles[styleName] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
+
+ group[styleName] = styles[styleName];
+
+ codes.set(style[0], style[1]);
+ }
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ }
+
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+
+ styles.color.close = '\u001B[39m';
+ styles.bgColor.close = '\u001B[49m';
+
+ setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+ setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+ setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+ setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+ setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+ setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+
+ return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
+}(ansiStyles$2));
+
+var hasFlag$4 = (flag, argv = process.argv) => {
+ const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+ const position = argv.indexOf(prefix + flag);
+ const terminatorPosition = argv.indexOf('--');
+ return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};
+
+const os$2 = require$$0$2;
+const tty = tty$1;
+const hasFlag$3 = hasFlag$4;
+
+const {env: env$2} = process;
+
+let forceColor$1;
+if (hasFlag$3('no-color') ||
+ hasFlag$3('no-colors') ||
+ hasFlag$3('color=false') ||
+ hasFlag$3('color=never')) {
+ forceColor$1 = 0;
+} else if (hasFlag$3('color') ||
+ hasFlag$3('colors') ||
+ hasFlag$3('color=true') ||
+ hasFlag$3('color=always')) {
+ forceColor$1 = 1;
+}
+
+if ('FORCE_COLOR' in env$2) {
+ if (env$2.FORCE_COLOR === 'true') {
+ forceColor$1 = 1;
+ } else if (env$2.FORCE_COLOR === 'false') {
+ forceColor$1 = 0;
+ } else {
+ forceColor$1 = env$2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$2.FORCE_COLOR, 10), 3);
+ }
+}
+
+function translateLevel$2(level) {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+}
+
+function supportsColor$2(haveStream, streamIsTTY) {
+ if (forceColor$1 === 0) {
+ return 0;
+ }
+
+ if (hasFlag$3('color=16m') ||
+ hasFlag$3('color=full') ||
+ hasFlag$3('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag$3('color=256')) {
+ return 2;
+ }
+
+ if (haveStream && !streamIsTTY && forceColor$1 === undefined) {
+ return 0;
+ }
+
+ const min = forceColor$1 || 0;
+
+ if (env$2.TERM === 'dumb') {
+ return min;
+ }
+
+ if (process.platform === 'win32') {
+ // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+ // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+ const osRelease = os$2.release().split('.');
+ if (
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env$2) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env$2) || env$2.CI_NAME === 'codeship') {
+ return 1;
+ }
+
+ return min;
+ }
+
+ if ('TEAMCITY_VERSION' in env$2) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0;
+ }
+
+ if (env$2.COLORTERM === 'truecolor') {
+ return 3;
+ }
+
+ if ('TERM_PROGRAM' in env$2) {
+ const version = parseInt((env$2.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env$2.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/-256(color)?$/i.test(env$2.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$2.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env$2) {
+ return 1;
+ }
+
+ return min;
+}
+
+function getSupportLevel$1(stream) {
+ const level = supportsColor$2(stream, stream && stream.isTTY);
+ return translateLevel$2(level);
+}
+
+var supportsColor_1$1 = {
+ supportsColor: getSupportLevel$1,
+ stdout: translateLevel$2(supportsColor$2(true, tty.isatty(1))),
+ stderr: translateLevel$2(supportsColor$2(true, tty.isatty(2)))
+};
+
+const stringReplaceAll$1 = (string, substring, replacer) => {
+ let index = string.indexOf(substring);
+ if (index === -1) {
+ return string;
+ }
+
+ const substringLength = substring.length;
+ let endIndex = 0;
+ let returnValue = '';
+ do {
+ returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+ endIndex = index + substringLength;
+ index = string.indexOf(substring, endIndex);
+ } while (index !== -1);
+
+ returnValue += string.substr(endIndex);
+ return returnValue;
+};
+
+const stringEncaseCRLFWithFirstIndex$1 = (string, prefix, postfix, index) => {
+ let endIndex = 0;
+ let returnValue = '';
+ do {
+ const gotCR = string[index - 1] === '\r';
+ returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+ endIndex = index + 1;
+ index = string.indexOf('\n', endIndex);
+ } while (index !== -1);
+
+ returnValue += string.substr(endIndex);
+ return returnValue;
+};
+
+var util$4 = {
+ stringReplaceAll: stringReplaceAll$1,
+ stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1
+};
+
+const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES$1 = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
+
+function unescape$1(c) {
+ const u = c[0] === 'u';
+ const bracket = c[1] === '{';
+
+ if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+
+ if (u && bracket) {
+ return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+ }
+
+ return ESCAPES$1.get(c) || c;
+}
+
+function parseArguments$1(name, arguments_) {
+ const results = [];
+ const chunks = arguments_.trim().split(/\s*,\s*/g);
+ let matches;
+
+ for (const chunk of chunks) {
+ const number = Number(chunk);
+ if (!Number.isNaN(number)) {
+ results.push(number);
+ } else if ((matches = chunk.match(STRING_REGEX$1))) {
+ results.push(matches[2].replace(ESCAPE_REGEX$1, (m, escape, character) => escape ? unescape$1(escape) : character));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+
+ return results;
+}
+
+function parseStyle$1(style) {
+ STYLE_REGEX$1.lastIndex = 0;
+
+ const results = [];
+ let matches;
+
+ while ((matches = STYLE_REGEX$1.exec(style)) !== null) {
+ const name = matches[1];
+
+ if (matches[2]) {
+ const args = parseArguments$1(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
+
+ return results;
+}
+
+function buildStyle$1(chalk, styles) {
+ const enabled = {};
+
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+
+ let current = chalk;
+ for (const [styleName, styles] of Object.entries(enabled)) {
+ if (!Array.isArray(styles)) {
+ continue;
+ }
+
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+
+ current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+ }
+
+ return current;
+}
+
+var templates$1 = (chalk, temporary) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+
+ // eslint-disable-next-line max-params
+ temporary.replace(TEMPLATE_REGEX$1, (m, escapeCharacter, inverse, style, close, character) => {
+ if (escapeCharacter) {
+ chunk.push(unescape$1(escapeCharacter));
+ } else if (style) {
+ const string = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? string : buildStyle$1(chalk, styles)(string));
+ styles.push({inverse, styles: parseStyle$1(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
+
+ chunks.push(buildStyle$1(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(character);
+ }
+ });
+
+ chunks.push(chunk.join(''));
+
+ if (styles.length > 0) {
+ const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMessage);
+ }
+
+ return chunks.join('');
+};
+
+const ansiStyles$1 = ansiStyles$2.exports;
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor_1$1;
+const {
+ stringReplaceAll,
+ stringEncaseCRLFWithFirstIndex
+} = util$4;
+
+const {isArray: isArray$2} = Array;
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+ 'ansi',
+ 'ansi',
+ 'ansi256',
+ 'ansi16m'
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+ if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+ throw new Error('The `level` option should be an integer from 0 to 3');
+ }
+
+ // Detect level if not set manually
+ const colorLevel = stdoutColor ? stdoutColor.level : 0;
+ object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+class ChalkClass {
+ constructor(options) {
+ // eslint-disable-next-line no-constructor-return
+ return chalkFactory(options);
+ }
+}
+
+const chalkFactory = options => {
+ const chalk = {};
+ applyOptions(chalk, options);
+
+ chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
+
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
+
+ chalk.template.constructor = () => {
+ throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+ };
+
+ chalk.template.Instance = ChalkClass;
+
+ return chalk.template;
+};
+
+function Chalk(options) {
+ return chalkFactory(options);
+}
+
+for (const [styleName, style] of Object.entries(ansiStyles$1)) {
+ styles[styleName] = {
+ get() {
+ const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+ Object.defineProperty(this, styleName, {value: builder});
+ return builder;
+ }
+ };
+}
+
+styles.visible = {
+ get() {
+ const builder = createBuilder(this, this._styler, true);
+ Object.defineProperty(this, 'visible', {value: builder});
+ return builder;
+ }
+};
+
+const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
+
+for (const model of usedModels) {
+ styles[model] = {
+ get() {
+ const {level} = this;
+ return function (...arguments_) {
+ const styler = createStyler(ansiStyles$1.color[levelMapping[level]][model](...arguments_), ansiStyles$1.color.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+}
+
+for (const model of usedModels) {
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const {level} = this;
+ return function (...arguments_) {
+ const styler = createStyler(ansiStyles$1.bgColor[levelMapping[level]][model](...arguments_), ansiStyles$1.bgColor.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+}
+
+const proto = Object.defineProperties(() => {}, {
+ ...styles,
+ level: {
+ enumerable: true,
+ get() {
+ return this._generator.level;
+ },
+ set(level) {
+ this._generator.level = level;
+ }
+ }
+});
+
+const createStyler = (open, close, parent) => {
+ let openAll;
+ let closeAll;
+ if (parent === undefined) {
+ openAll = open;
+ closeAll = close;
+ } else {
+ openAll = parent.openAll + open;
+ closeAll = close + parent.closeAll;
+ }
+
+ return {
+ open,
+ close,
+ openAll,
+ closeAll,
+ parent
+ };
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+ const builder = (...arguments_) => {
+ if (isArray$2(arguments_[0]) && isArray$2(arguments_[0].raw)) {
+ // Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
+ return applyStyle(builder, chalkTag(builder, ...arguments_));
+ }
+
+ // Single argument is hot path, implicit coercion is faster than anything
+ // eslint-disable-next-line no-implicit-coercion
+ return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+ };
+
+ // We alter the prototype because we must return a function, but there is
+ // no way to create a function with a different prototype
+ Object.setPrototypeOf(builder, proto);
+
+ builder._generator = self;
+ builder._styler = _styler;
+ builder._isEmpty = _isEmpty;
+
+ return builder;
+};
+
+const applyStyle = (self, string) => {
+ if (self.level <= 0 || !string) {
+ return self._isEmpty ? '' : string;
+ }
+
+ let styler = self._styler;
+
+ if (styler === undefined) {
+ return string;
+ }
+
+ const {openAll, closeAll} = styler;
+ if (string.indexOf('\u001B') !== -1) {
+ while (styler !== undefined) {
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ string = stringReplaceAll(string, styler.close, styler.open);
+
+ styler = styler.parent;
+ }
+ }
+
+ // We can move both next actions out of loop, because remaining actions in loop won't have
+ // any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+ const lfIndex = string.indexOf('\n');
+ if (lfIndex !== -1) {
+ string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+ }
+
+ return openAll + string + closeAll;
+};
+
+let template;
+const chalkTag = (chalk, ...strings) => {
+ const [firstString] = strings;
+
+ if (!isArray$2(firstString) || !isArray$2(firstString.raw)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return strings.join(' ');
+ }
+
+ const arguments_ = strings.slice(1);
+ const parts = [firstString.raw[0]];
+
+ for (let i = 1; i < firstString.length; i++) {
+ parts.push(
+ String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
+ String(firstString.raw[i])
+ );
+ }
+
+ if (template === undefined) {
+ template = templates$1;
+ }
+
+ return template(chalk, parts.join(''));
+};
+
+Object.defineProperties(Chalk.prototype, styles);
+
+const chalk$1 = Chalk(); // eslint-disable-line new-cap
+chalk$1.supportsColor = stdoutColor;
+chalk$1.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
+chalk$1.stderr.supportsColor = stderrColor;
+
+var source$1 = chalk$1;
+
+var chokidar = {};
+
+var utils$7 = {};
+
+const path$a = path$b;
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR$1 = `${QMARK}*?`;
+
+const POSIX_CHARS = {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ QMARK_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ QMARK,
+ END_ANCHOR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK_NO_DOT,
+ STAR: STAR$1,
+ START_ANCHOR
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+ ...POSIX_CHARS,
+
+ SLASH_LITERAL: `[${WIN_SLASH}]`,
+ QMARK: WIN_NO_SLASH,
+ STAR: `${WIN_NO_SLASH}*?`,
+ DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+ NO_DOT: `(?!${DOT_LITERAL})`,
+ NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+ NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+ START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+ END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE$1 = {
+ alnum: 'a-zA-Z0-9',
+ alpha: 'a-zA-Z',
+ ascii: '\\x00-\\x7F',
+ blank: ' \\t',
+ cntrl: '\\x00-\\x1F\\x7F',
+ digit: '0-9',
+ graph: '\\x21-\\x7E',
+ lower: 'a-z',
+ print: '\\x20-\\x7E ',
+ punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+ space: ' \\t\\r\\n\\v\\f',
+ upper: 'A-Z',
+ word: 'A-Za-z0-9_',
+ xdigit: 'A-Fa-f0-9'
+};
+
+var constants$5 = {
+ MAX_LENGTH: 1024 * 64,
+ POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+
+ // regular expressions
+ REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+ REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+ REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+ REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+ REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+ REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+ // Replace globs with equivalent patterns to reduce parsing time.
+ REPLACEMENTS: {
+ '***': '*',
+ '**/**': '**',
+ '**/**/**': '**'
+ },
+
+ // Digits
+ CHAR_0: 48, /* 0 */
+ CHAR_9: 57, /* 9 */
+
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: 65, /* A */
+ CHAR_LOWERCASE_A: 97, /* a */
+ CHAR_UPPERCASE_Z: 90, /* Z */
+ CHAR_LOWERCASE_Z: 122, /* z */
+
+ CHAR_LEFT_PARENTHESES: 40, /* ( */
+ CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+ CHAR_ASTERISK: 42, /* * */
+
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: 38, /* & */
+ CHAR_AT: 64, /* @ */
+ CHAR_BACKWARD_SLASH: 92, /* \ */
+ CHAR_CARRIAGE_RETURN: 13, /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+ CHAR_COLON: 58, /* : */
+ CHAR_COMMA: 44, /* , */
+ CHAR_DOT: 46, /* . */
+ CHAR_DOUBLE_QUOTE: 34, /* " */
+ CHAR_EQUAL: 61, /* = */
+ CHAR_EXCLAMATION_MARK: 33, /* ! */
+ CHAR_FORM_FEED: 12, /* \f */
+ CHAR_FORWARD_SLASH: 47, /* / */
+ CHAR_GRAVE_ACCENT: 96, /* ` */
+ CHAR_HASH: 35, /* # */
+ CHAR_HYPHEN_MINUS: 45, /* - */
+ CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+ CHAR_LEFT_CURLY_BRACE: 123, /* { */
+ CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+ CHAR_LINE_FEED: 10, /* \n */
+ CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+ CHAR_PERCENT: 37, /* % */
+ CHAR_PLUS: 43, /* + */
+ CHAR_QUESTION_MARK: 63, /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+ CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+ CHAR_SEMICOLON: 59, /* ; */
+ CHAR_SINGLE_QUOTE: 39, /* ' */
+ CHAR_SPACE: 32, /* */
+ CHAR_TAB: 9, /* \t */
+ CHAR_UNDERSCORE: 95, /* _ */
+ CHAR_VERTICAL_LINE: 124, /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+ SEP: path$a.sep,
+
+ /**
+ * Create EXTGLOB_CHARS
+ */
+
+ extglobChars(chars) {
+ return {
+ '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+ '?': { type: 'qmark', open: '(?:', close: ')?' },
+ '+': { type: 'plus', open: '(?:', close: ')+' },
+ '*': { type: 'star', open: '(?:', close: ')*' },
+ '@': { type: 'at', open: '(?:', close: ')' }
+ };
+ },
+
+ /**
+ * Create GLOB_CHARS
+ */
+
+ globChars(win32) {
+ return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
}
+};
- function count(value) {
- if (value) {
- if (value[0] && value[0].messages) {
- // Multiple vfiles
- countInAll(value);
+(function (exports) {
+
+const path = path$b;
+const win32 = process.platform === 'win32';
+const {
+ REGEX_BACKSLASH,
+ REGEX_REMOVE_BACKSLASH,
+ REGEX_SPECIAL_CHARS,
+ REGEX_SPECIAL_CHARS_GLOBAL
+} = constants$5;
+
+exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+exports.removeBackslashes = str => {
+ return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+ return match === '\\' ? '' : match;
+ });
+};
+
+exports.supportsLookbehinds = () => {
+ const segs = process.version.slice(1).split('.').map(Number);
+ if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+ return true;
+ }
+ return false;
+};
+
+exports.isWindows = options => {
+ if (options && typeof options.windows === 'boolean') {
+ return options.windows;
+ }
+ return win32 === true || path.sep === '\\';
+};
+
+exports.escapeLast = (input, char, lastIdx) => {
+ const idx = input.lastIndexOf(char, lastIdx);
+ if (idx === -1) return input;
+ if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+ return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+};
+
+exports.removePrefix = (input, state = {}) => {
+ let output = input;
+ if (output.startsWith('./')) {
+ output = output.slice(2);
+ state.prefix = './';
+ }
+ return output;
+};
+
+exports.wrapOutput = (input, state = {}, options = {}) => {
+ const prepend = options.contains ? '' : '^';
+ const append = options.contains ? '' : '$';
+
+ let output = `${prepend}(?:${input})${append}`;
+ if (state.negated === true) {
+ output = `(?:^(?!${output}).*$)`;
+ }
+ return output;
+};
+}(utils$7));
+
+const utils$6 = utils$7;
+const {
+ CHAR_ASTERISK: CHAR_ASTERISK$1, /* * */
+ CHAR_AT, /* @ */
+ CHAR_BACKWARD_SLASH, /* \ */
+ CHAR_COMMA: CHAR_COMMA$2, /* , */
+ CHAR_DOT: CHAR_DOT$1, /* . */
+ CHAR_EXCLAMATION_MARK, /* ! */
+ CHAR_FORWARD_SLASH, /* / */
+ CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
+ CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
+ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$2, /* [ */
+ CHAR_PLUS, /* + */
+ CHAR_QUESTION_MARK, /* ? */
+ CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
+ CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
+ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$2 /* ] */
+} = constants$5;
+
+const isPathSeparator = code => {
+ return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+const depth = token => {
+ if (token.isPrefix !== true) {
+ token.depth = token.isGlobstar ? Infinity : 1;
+ }
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+const scan$1 = (input, options) => {
+ const opts = options || {};
+
+ const length = input.length - 1;
+ const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+ const slashes = [];
+ const tokens = [];
+ const parts = [];
+
+ let str = input;
+ let index = -1;
+ let start = 0;
+ let lastIndex = 0;
+ let isBrace = false;
+ let isBracket = false;
+ let isGlob = false;
+ let isExtglob = false;
+ let isGlobstar = false;
+ let braceEscaped = false;
+ let backslashes = false;
+ let negated = false;
+ let finished = false;
+ let braces = 0;
+ let prev;
+ let code;
+ let token = { value: '', depth: 0, isGlob: false };
+
+ const eos = () => index >= length;
+ const peek = () => str.charCodeAt(index + 1);
+ const advance = () => {
+ prev = code;
+ return str.charCodeAt(++index);
+ };
+
+ while (index < length) {
+ code = advance();
+ let next;
+
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ code = advance();
+
+ if (code === CHAR_LEFT_CURLY_BRACE$1) {
+ braceEscaped = true;
+ }
+ continue;
+ }
+
+ if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {
+ braces++;
+
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ advance();
+ continue;
+ }
+
+ if (code === CHAR_LEFT_CURLY_BRACE$1) {
+ braces++;
+ continue;
+ }
+
+ if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {
+ isBrace = token.isBrace = true;
+ isGlob = token.isGlob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+
+ break;
+ }
+
+ if (braceEscaped !== true && code === CHAR_COMMA$2) {
+ isBrace = token.isBrace = true;
+ isGlob = token.isGlob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+
+ break;
+ }
+
+ if (code === CHAR_RIGHT_CURLY_BRACE$1) {
+ braces--;
+
+ if (braces === 0) {
+ braceEscaped = false;
+ isBrace = token.isBrace = true;
+ finished = true;
+ break;
+ }
+ }
+ }
+
+ if (scanToEnd === true) {
+ continue;
+ }
+
+ break;
+ }
+
+ if (code === CHAR_FORWARD_SLASH) {
+ slashes.push(index);
+ tokens.push(token);
+ token = { value: '', depth: 0, isGlob: false };
+
+ if (finished === true) continue;
+ if (prev === CHAR_DOT$1 && index === (start + 1)) {
+ start += 2;
+ continue;
+ }
+
+ lastIndex = index + 1;
+ continue;
+ }
+
+ if (opts.noext !== true) {
+ const isExtglobChar = code === CHAR_PLUS
+ || code === CHAR_AT
+ || code === CHAR_ASTERISK$1
+ || code === CHAR_QUESTION_MARK
+ || code === CHAR_EXCLAMATION_MARK;
+
+ if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {
+ isGlob = token.isGlob = true;
+ isExtglob = token.isExtglob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ code = advance();
+ continue;
+ }
+
+ if (code === CHAR_RIGHT_PARENTHESES$1) {
+ isGlob = token.isGlob = true;
+ finished = true;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+ }
+
+ if (code === CHAR_ASTERISK$1) {
+ if (prev === CHAR_ASTERISK$1) isGlobstar = token.isGlobstar = true;
+ isGlob = token.isGlob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+
+ if (code === CHAR_QUESTION_MARK) {
+ isGlob = token.isGlob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+
+ if (code === CHAR_LEFT_SQUARE_BRACKET$2) {
+ while (eos() !== true && (next = advance())) {
+ if (next === CHAR_BACKWARD_SLASH) {
+ backslashes = token.backslashes = true;
+ advance();
+ continue;
+ }
+
+ if (next === CHAR_RIGHT_SQUARE_BRACKET$2) {
+ isBracket = token.isBracket = true;
+ isGlob = token.isGlob = true;
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+ break;
+ }
+ }
+ }
+
+ if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+ negated = token.negated = true;
+ start++;
+ continue;
+ }
+
+ if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {
+ isGlob = token.isGlob = true;
+
+ if (scanToEnd === true) {
+ while (eos() !== true && (code = advance())) {
+ if (code === CHAR_LEFT_PARENTHESES$1) {
+ backslashes = token.backslashes = true;
+ code = advance();
+ continue;
+ }
+
+ if (code === CHAR_RIGHT_PARENTHESES$1) {
+ finished = true;
+ break;
+ }
+ }
+ continue;
+ }
+ break;
+ }
+
+ if (isGlob === true) {
+ finished = true;
+
+ if (scanToEnd === true) {
+ continue;
+ }
+
+ break;
+ }
+ }
+
+ if (opts.noext === true) {
+ isExtglob = false;
+ isGlob = false;
+ }
+
+ let base = str;
+ let prefix = '';
+ let glob = '';
+
+ if (start > 0) {
+ prefix = str.slice(0, start);
+ str = str.slice(start);
+ lastIndex -= start;
+ }
+
+ if (base && isGlob === true && lastIndex > 0) {
+ base = str.slice(0, lastIndex);
+ glob = str.slice(lastIndex);
+ } else if (isGlob === true) {
+ base = '';
+ glob = str;
+ } else {
+ base = str;
+ }
+
+ if (base && base !== '' && base !== '/' && base !== str) {
+ if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+ base = base.slice(0, -1);
+ }
+ }
+
+ if (opts.unescape === true) {
+ if (glob) glob = utils$6.removeBackslashes(glob);
+
+ if (base && backslashes === true) {
+ base = utils$6.removeBackslashes(base);
+ }
+ }
+
+ const state = {
+ prefix,
+ input,
+ start,
+ base,
+ glob,
+ isBrace,
+ isBracket,
+ isGlob,
+ isExtglob,
+ isGlobstar,
+ negated
+ };
+
+ if (opts.tokens === true) {
+ state.maxDepth = 0;
+ if (!isPathSeparator(code)) {
+ tokens.push(token);
+ }
+ state.tokens = tokens;
+ }
+
+ if (opts.parts === true || opts.tokens === true) {
+ let prevIndex;
+
+ for (let idx = 0; idx < slashes.length; idx++) {
+ const n = prevIndex ? prevIndex + 1 : start;
+ const i = slashes[idx];
+ const value = input.slice(n, i);
+ if (opts.tokens) {
+ if (idx === 0 && start !== 0) {
+ tokens[idx].isPrefix = true;
+ tokens[idx].value = prefix;
+ } else {
+ tokens[idx].value = value;
+ }
+ depth(tokens[idx]);
+ state.maxDepth += tokens[idx].depth;
+ }
+ if (idx !== 0 || value !== '') {
+ parts.push(value);
+ }
+ prevIndex = i;
+ }
+
+ if (prevIndex && prevIndex + 1 < input.length) {
+ const value = input.slice(prevIndex + 1);
+ parts.push(value);
+
+ if (opts.tokens) {
+ tokens[tokens.length - 1].value = value;
+ depth(tokens[tokens.length - 1]);
+ state.maxDepth += tokens[tokens.length - 1].depth;
+ }
+ }
+
+ state.slashes = slashes;
+ state.parts = parts;
+ }
+
+ return state;
+};
+
+var scan_1 = scan$1;
+
+const constants$4 = constants$5;
+const utils$5 = utils$7;
+
+/**
+ * Constants
+ */
+
+const {
+ MAX_LENGTH: MAX_LENGTH$4,
+ POSIX_REGEX_SOURCE,
+ REGEX_NON_SPECIAL_CHARS,
+ REGEX_SPECIAL_CHARS_BACKREF,
+ REPLACEMENTS
+} = constants$4;
+
+/**
+ * Helpers
+ */
+
+const expandRange = (args, options) => {
+ if (typeof options.expandRange === 'function') {
+ return options.expandRange(...args, options);
+ }
+
+ args.sort();
+ const value = `[${args.join('-')}]`;
+
+ try {
+ /* eslint-disable-next-line no-new */
+ new RegExp(value);
+ } catch (ex) {
+ return args.map(v => utils$5.escapeRegex(v)).join('..');
+ }
+
+ return value;
+};
+
+/**
+ * Create the message for a syntax error
+ */
+
+const syntaxError$1 = (type, char) => {
+ return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
+
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
+
+const parse$e = (input, options) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ input = REPLACEMENTS[input] || input;
+
+ const opts = { ...options };
+ const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
+
+ let len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+
+ const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+ const tokens = [bos];
+
+ const capture = opts.capture ? '' : '?:';
+ const win32 = utils$5.isWindows(options);
+
+ // create constants based on platform, for windows or posix
+ const PLATFORM_CHARS = constants$4.globChars(win32);
+ const EXTGLOB_CHARS = constants$4.extglobChars(PLATFORM_CHARS);
+
+ const {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK,
+ QMARK_NO_DOT,
+ STAR,
+ START_ANCHOR
+ } = PLATFORM_CHARS;
+
+ const globstar = (opts) => {
+ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+
+ const nodot = opts.dot ? '' : NO_DOT;
+ const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+ let star = opts.bash === true ? globstar(opts) : STAR;
+
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+
+ // minimatch options support
+ if (typeof opts.noext === 'boolean') {
+ opts.noextglob = opts.noext;
+ }
+
+ const state = {
+ input,
+ index: -1,
+ start: 0,
+ dot: opts.dot === true,
+ consumed: '',
+ output: '',
+ prefix: '',
+ backtrack: false,
+ negated: false,
+ brackets: 0,
+ braces: 0,
+ parens: 0,
+ quotes: 0,
+ globstar: false,
+ tokens
+ };
+
+ input = utils$5.removePrefix(input, state);
+ len = input.length;
+
+ const extglobs = [];
+ const braces = [];
+ const stack = [];
+ let prev = bos;
+ let value;
+
+ /**
+ * Tokenizing helpers
+ */
+
+ const eos = () => state.index === len - 1;
+ const peek = state.peek = (n = 1) => input[state.index + n];
+ const advance = state.advance = () => input[++state.index];
+ const remaining = () => input.slice(state.index + 1);
+ const consume = (value = '', num = 0) => {
+ state.consumed += value;
+ state.index += num;
+ };
+ const append = token => {
+ state.output += token.output != null ? token.output : token.value;
+ consume(token.value);
+ };
+
+ const negate = () => {
+ let count = 1;
+
+ while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+ advance();
+ state.start++;
+ count++;
+ }
+
+ if (count % 2 === 0) {
+ return false;
+ }
+
+ state.negated = true;
+ state.start++;
+ return true;
+ };
+
+ const increment = type => {
+ state[type]++;
+ stack.push(type);
+ };
+
+ const decrement = type => {
+ state[type]--;
+ stack.pop();
+ };
+
+ /**
+ * Push tokens onto the tokens array. This helper speeds up
+ * tokenizing by 1) helping us avoid backtracking as much as possible,
+ * and 2) helping us avoid creating extra tokens when consecutive
+ * characters are plain text. This improves performance and simplifies
+ * lookbehinds.
+ */
+
+ const push = tok => {
+ if (prev.type === 'globstar') {
+ const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+ const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+ if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+ state.output = state.output.slice(0, -prev.output.length);
+ prev.type = 'star';
+ prev.value = '*';
+ prev.output = star;
+ state.output += prev.output;
+ }
+ }
+
+ if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
+ extglobs[extglobs.length - 1].inner += tok.value;
+ }
+
+ if (tok.value || tok.output) append(tok);
+ if (prev && prev.type === 'text' && tok.type === 'text') {
+ prev.value += tok.value;
+ prev.output = (prev.output || '') + tok.value;
+ return;
+ }
+
+ tok.prev = prev;
+ tokens.push(tok);
+ prev = tok;
+ };
+
+ const extglobOpen = (type, value) => {
+ const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+ token.prev = prev;
+ token.parens = state.parens;
+ token.output = state.output;
+ const output = (opts.capture ? '(' : '') + token.open;
+
+ increment('parens');
+ push({ type, value, output: state.output ? '' : ONE_CHAR });
+ push({ type: 'paren', extglob: true, value: advance(), output });
+ extglobs.push(token);
+ };
+
+ const extglobClose = token => {
+ let output = token.close + (opts.capture ? ')' : '');
+
+ if (token.type === 'negate') {
+ let extglobStar = star;
+
+ if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+ extglobStar = globstar(opts);
+ }
+
+ if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+ output = token.close = `)$))${extglobStar}`;
+ }
+
+ if (token.prev.type === 'bos' && eos()) {
+ state.negatedExtglob = true;
+ }
+ }
+
+ push({ type: 'paren', extglob: true, value, output });
+ decrement('parens');
+ };
+
+ /**
+ * Fast paths
+ */
+
+ if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+ let backslashes = false;
+
+ let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+ if (first === '\\') {
+ backslashes = true;
+ return m;
+ }
+
+ if (first === '?') {
+ if (esc) {
+ return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ if (index === 0) {
+ return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ return QMARK.repeat(chars.length);
+ }
+
+ if (first === '.') {
+ return DOT_LITERAL.repeat(chars.length);
+ }
+
+ if (first === '*') {
+ if (esc) {
+ return esc + first + (rest ? star : '');
+ }
+ return star;
+ }
+ return esc ? m : `\\${m}`;
+ });
+
+ if (backslashes === true) {
+ if (opts.unescape === true) {
+ output = output.replace(/\\/g, '');
} else {
- // One vfile / messages
- countAll(value.messages || value);
+ output = output.replace(/\\+/g, m => {
+ return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+ });
}
}
+
+ if (output === input && opts.contains === true) {
+ state.output = input;
+ return state;
+ }
+
+ state.output = utils$5.wrapOutput(output, state, options);
+ return state;
}
- function countInAll(files) {
- var length = files.length;
- var index = -1;
+ /**
+ * Tokenize input until we reach end-of-string
+ */
+
+ while (!eos()) {
+ value = advance();
+
+ if (value === '\u0000') {
+ continue;
+ }
+
+ /**
+ * Escaped characters
+ */
+
+ if (value === '\\') {
+ const next = peek();
+
+ if (next === '/' && opts.bash !== true) {
+ continue;
+ }
+
+ if (next === '.' || next === ';') {
+ continue;
+ }
+
+ if (!next) {
+ value += '\\';
+ push({ type: 'text', value });
+ continue;
+ }
+
+ // collapse slashes to reduce potential for exploits
+ const match = /^\\+/.exec(remaining());
+ let slashes = 0;
+
+ if (match && match[0].length > 2) {
+ slashes = match[0].length;
+ state.index += slashes;
+ if (slashes % 2 !== 0) {
+ value += '\\';
+ }
+ }
+
+ if (opts.unescape === true) {
+ value = advance() || '';
+ } else {
+ value += advance() || '';
+ }
+
+ if (state.brackets === 0) {
+ push({ type: 'text', value });
+ continue;
+ }
+ }
+
+ /**
+ * If we're inside a regex character class, continue
+ * until we reach the closing bracket.
+ */
+
+ if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+ if (opts.posix !== false && value === ':') {
+ const inner = prev.value.slice(1);
+ if (inner.includes('[')) {
+ prev.posix = true;
+
+ if (inner.includes(':')) {
+ const idx = prev.value.lastIndexOf('[');
+ const pre = prev.value.slice(0, idx);
+ const rest = prev.value.slice(idx + 2);
+ const posix = POSIX_REGEX_SOURCE[rest];
+ if (posix) {
+ prev.value = pre + posix;
+ state.backtrack = true;
+ advance();
+
+ if (!bos.output && tokens.indexOf(prev) === 1) {
+ bos.output = ONE_CHAR;
+ }
+ continue;
+ }
+ }
+ }
+ }
+
+ if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+ value = `\\${value}`;
+ }
+
+ if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+ value = `\\${value}`;
+ }
- while (++index < length) {
- count(files[index].messages);
+ if (opts.posix === true && value === '!' && prev.value === '[') {
+ value = '^';
+ }
+
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * If we're inside a quoted string, continue
+ * until we reach the closing double quote.
+ */
+
+ if (state.quotes === 1 && value !== '"') {
+ value = utils$5.escapeRegex(value);
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * Double quotes
+ */
+
+ if (value === '"') {
+ state.quotes = state.quotes === 1 ? 0 : 1;
+ if (opts.keepQuotes === true) {
+ push({ type: 'text', value });
+ }
+ continue;
+ }
+
+ /**
+ * Parentheses
+ */
+
+ if (value === '(') {
+ increment('parens');
+ push({ type: 'paren', value });
+ continue;
+ }
+
+ if (value === ')') {
+ if (state.parens === 0 && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError$1('opening', '('));
+ }
+
+ const extglob = extglobs[extglobs.length - 1];
+ if (extglob && state.parens === extglob.parens + 1) {
+ extglobClose(extglobs.pop());
+ continue;
+ }
+
+ push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+ decrement('parens');
+ continue;
+ }
+
+ /**
+ * Square brackets
+ */
+
+ if (value === '[') {
+ if (opts.nobracket === true || !remaining().includes(']')) {
+ if (opts.nobracket !== true && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError$1('closing', ']'));
+ }
+
+ value = `\\${value}`;
+ } else {
+ increment('brackets');
+ }
+
+ push({ type: 'bracket', value });
+ continue;
}
+
+ if (value === ']') {
+ if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+ push({ type: 'text', value, output: `\\${value}` });
+ continue;
+ }
+
+ if (state.brackets === 0) {
+ if (opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError$1('opening', '['));
+ }
+
+ push({ type: 'text', value, output: `\\${value}` });
+ continue;
+ }
+
+ decrement('brackets');
+
+ const prevValue = prev.value.slice(1);
+ if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+ value = `/${value}`;
+ }
+
+ prev.value += value;
+ append({ value });
+
+ // when literal brackets are explicitly disabled
+ // assume we should match with a regex character class
+ if (opts.literalBrackets === false || utils$5.hasRegexChars(prevValue)) {
+ continue;
+ }
+
+ const escaped = utils$5.escapeRegex(prev.value);
+ state.output = state.output.slice(0, -prev.value.length);
+
+ // when literal brackets are explicitly enabled
+ // assume we should escape the brackets to match literal characters
+ if (opts.literalBrackets === true) {
+ state.output += escaped;
+ prev.value = escaped;
+ continue;
+ }
+
+ // when the user specifies nothing, try to match both
+ prev.value = `(${capture}${escaped}|${prev.value})`;
+ state.output += prev.value;
+ continue;
+ }
+
+ /**
+ * Braces
+ */
+
+ if (value === '{' && opts.nobrace !== true) {
+ increment('braces');
+
+ const open = {
+ type: 'brace',
+ value,
+ output: '(',
+ outputIndex: state.output.length,
+ tokensIndex: state.tokens.length
+ };
+
+ braces.push(open);
+ push(open);
+ continue;
+ }
+
+ if (value === '}') {
+ const brace = braces[braces.length - 1];
+
+ if (opts.nobrace === true || !brace) {
+ push({ type: 'text', value, output: value });
+ continue;
+ }
+
+ let output = ')';
+
+ if (brace.dots === true) {
+ const arr = tokens.slice();
+ const range = [];
+
+ for (let i = arr.length - 1; i >= 0; i--) {
+ tokens.pop();
+ if (arr[i].type === 'brace') {
+ break;
+ }
+ if (arr[i].type !== 'dots') {
+ range.unshift(arr[i].value);
+ }
+ }
+
+ output = expandRange(range, opts);
+ state.backtrack = true;
+ }
+
+ if (brace.comma !== true && brace.dots !== true) {
+ const out = state.output.slice(0, brace.outputIndex);
+ const toks = state.tokens.slice(brace.tokensIndex);
+ brace.value = brace.output = '\\{';
+ value = output = '\\}';
+ state.output = out;
+ for (const t of toks) {
+ state.output += (t.output || t.value);
+ }
+ }
+
+ push({ type: 'brace', value, output });
+ decrement('braces');
+ braces.pop();
+ continue;
+ }
+
+ /**
+ * Pipes
+ */
+
+ if (value === '|') {
+ if (extglobs.length > 0) {
+ extglobs[extglobs.length - 1].conditions++;
+ }
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Commas
+ */
+
+ if (value === ',') {
+ let output = value;
+
+ const brace = braces[braces.length - 1];
+ if (brace && stack[stack.length - 1] === 'braces') {
+ brace.comma = true;
+ output = '|';
+ }
+
+ push({ type: 'comma', value, output });
+ continue;
+ }
+
+ /**
+ * Slashes
+ */
+
+ if (value === '/') {
+ // if the beginning of the glob is "./", advance the start
+ // to the current index, and don't add the "./" characters
+ // to the state. This greatly simplifies lookbehinds when
+ // checking for BOS characters like "!" and "." (not "./")
+ if (prev.type === 'dot' && state.index === state.start + 1) {
+ state.start = state.index + 1;
+ state.consumed = '';
+ state.output = '';
+ tokens.pop();
+ prev = bos; // reset "prev" to the first token
+ continue;
+ }
+
+ push({ type: 'slash', value, output: SLASH_LITERAL });
+ continue;
+ }
+
+ /**
+ * Dots
+ */
+
+ if (value === '.') {
+ if (state.braces > 0 && prev.type === 'dot') {
+ if (prev.value === '.') prev.output = DOT_LITERAL;
+ const brace = braces[braces.length - 1];
+ prev.type = 'dots';
+ prev.output += value;
+ prev.value += value;
+ brace.dots = true;
+ continue;
+ }
+
+ if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+ push({ type: 'text', value, output: DOT_LITERAL });
+ continue;
+ }
+
+ push({ type: 'dot', value, output: DOT_LITERAL });
+ continue;
+ }
+
+ /**
+ * Question marks
+ */
+
+ if (value === '?') {
+ const isGroup = prev && prev.value === '(';
+ if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('qmark', value);
+ continue;
+ }
+
+ if (prev && prev.type === 'paren') {
+ const next = peek();
+ let output = value;
+
+ if (next === '<' && !utils$5.supportsLookbehinds()) {
+ throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+ }
+
+ if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+ output = `\\${value}`;
+ }
+
+ push({ type: 'text', value, output });
+ continue;
+ }
+
+ if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+ push({ type: 'qmark', value, output: QMARK_NO_DOT });
+ continue;
+ }
+
+ push({ type: 'qmark', value, output: QMARK });
+ continue;
+ }
+
+ /**
+ * Exclamation
+ */
+
+ if (value === '!') {
+ if (opts.noextglob !== true && peek() === '(') {
+ if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+ extglobOpen('negate', value);
+ continue;
+ }
+ }
+
+ if (opts.nonegate !== true && state.index === 0) {
+ negate();
+ continue;
+ }
+ }
+
+ /**
+ * Plus
+ */
+
+ if (value === '+') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('plus', value);
+ continue;
+ }
+
+ if ((prev && prev.value === '(') || opts.regex === false) {
+ push({ type: 'plus', value, output: PLUS_LITERAL });
+ continue;
+ }
+
+ if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+ push({ type: 'plus', value });
+ continue;
+ }
+
+ push({ type: 'plus', value: PLUS_LITERAL });
+ continue;
+ }
+
+ /**
+ * Plain text
+ */
+
+ if (value === '@') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ push({ type: 'at', extglob: true, value, output: '' });
+ continue;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Plain text
+ */
+
+ if (value !== '*') {
+ if (value === '$' || value === '^') {
+ value = `\\${value}`;
+ }
+
+ const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+ if (match) {
+ value += match[0];
+ state.index += match[0].length;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Stars
+ */
+
+ if (prev && (prev.type === 'globstar' || prev.star === true)) {
+ prev.type = 'star';
+ prev.star = true;
+ prev.value += value;
+ prev.output = star;
+ state.backtrack = true;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+
+ let rest = remaining();
+ if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+ extglobOpen('star', value);
+ continue;
+ }
+
+ if (prev.type === 'star') {
+ if (opts.noglobstar === true) {
+ consume(value);
+ continue;
+ }
+
+ const prior = prev.prev;
+ const before = prior.prev;
+ const isStart = prior.type === 'slash' || prior.type === 'bos';
+ const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+ if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+ push({ type: 'star', value, output: '' });
+ continue;
+ }
+
+ const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+ const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+ if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+ push({ type: 'star', value, output: '' });
+ continue;
+ }
+
+ // strip consecutive `/**/`
+ while (rest.slice(0, 3) === '/**') {
+ const after = input[state.index + 4];
+ if (after && after !== '/') {
+ break;
+ }
+ rest = rest.slice(3);
+ consume('/**', 3);
+ }
+
+ if (prior.type === 'bos' && eos()) {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = globstar(opts);
+ state.output = prev.output;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = `(?:${prior.output}`;
+
+ prev.type = 'globstar';
+ prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+ prev.value += value;
+ state.globstar = true;
+ state.output += prior.output + prev.output;
+ consume(value);
+ continue;
+ }
+
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+ const end = rest[1] !== void 0 ? '|$' : '';
+
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = `(?:${prior.output}`;
+
+ prev.type = 'globstar';
+ prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+ prev.value += value;
+
+ state.output += prior.output + prev.output;
+ state.globstar = true;
+
+ consume(value + advance());
+
+ push({ type: 'slash', value: '/', output: '' });
+ continue;
+ }
+
+ if (prior.type === 'bos' && rest[0] === '/') {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+ state.output = prev.output;
+ state.globstar = true;
+ consume(value + advance());
+ push({ type: 'slash', value: '/', output: '' });
+ continue;
+ }
+
+ // remove single star from output
+ state.output = state.output.slice(0, -prev.output.length);
+
+ // reset previous token to globstar
+ prev.type = 'globstar';
+ prev.output = globstar(opts);
+ prev.value += value;
+
+ // reset output with globstar
+ state.output += prev.output;
+ state.globstar = true;
+ consume(value);
+ continue;
+ }
+
+ const token = { type: 'star', value, output: star };
+
+ if (opts.bash === true) {
+ token.output = '.*?';
+ if (prev.type === 'bos' || prev.type === 'slash') {
+ token.output = nodot + token.output;
+ }
+ push(token);
+ continue;
+ }
+
+ if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+ token.output = value;
+ push(token);
+ continue;
+ }
+
+ if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+ if (prev.type === 'dot') {
+ state.output += NO_DOT_SLASH;
+ prev.output += NO_DOT_SLASH;
+
+ } else if (opts.dot === true) {
+ state.output += NO_DOTS_SLASH;
+ prev.output += NO_DOTS_SLASH;
+
+ } else {
+ state.output += nodot;
+ prev.output += nodot;
+ }
+
+ if (peek() !== '*') {
+ state.output += ONE_CHAR;
+ prev.output += ONE_CHAR;
+ }
+ }
+
+ push(token);
}
- function countAll(messages) {
- var length = messages.length;
- var index = -1;
- var fatal;
+ while (state.brackets > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ']'));
+ state.output = utils$5.escapeLast(state.output, '[');
+ decrement('brackets');
+ }
+
+ while (state.parens > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ')'));
+ state.output = utils$5.escapeLast(state.output, '(');
+ decrement('parens');
+ }
+
+ while (state.braces > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', '}'));
+ state.output = utils$5.escapeLast(state.output, '{');
+ decrement('braces');
+ }
+
+ if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+ push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+ }
+
+ // rebuild the output if we had to backtrack at any point
+ if (state.backtrack === true) {
+ state.output = '';
+
+ for (const token of state.tokens) {
+ state.output += token.output != null ? token.output : token.value;
- while (++index < length) {
- fatal = messages[index].fatal;
- result[fatal === null || fatal === undefined ? null : Boolean(fatal)]++;
+ if (token.suffix) {
+ state.output += token.suffix;
+ }
}
}
-}
-var slice$4 = [].slice;
+ return state;
+};
-var wrap_1 = wrap$3;
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
-// Wrap `fn`.
-// Can be sync or async; return a promise, receive a completion handler, return
-// new values and errors.
-function wrap$3(fn, callback) {
- var invoked;
+parse$e.fastpaths = (input, options) => {
+ const opts = { ...options };
+ const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
+ const len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
- return wrapped
+ input = REPLACEMENTS[input] || input;
+ const win32 = utils$5.isWindows(options);
+
+ // create constants based on platform, for windows or posix
+ const {
+ DOT_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOTS_SLASH,
+ STAR,
+ START_ANCHOR
+ } = constants$4.globChars(win32);
+
+ const nodot = opts.dot ? NO_DOTS : NO_DOT;
+ const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+ const capture = opts.capture ? '' : '?:';
+ const state = { negated: false, prefix: '' };
+ let star = opts.bash === true ? '.*?' : STAR;
+
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+
+ const globstar = (opts) => {
+ if (opts.noglobstar === true) return star;
+ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+
+ const create = str => {
+ switch (str) {
+ case '*':
+ return `${nodot}${ONE_CHAR}${star}`;
+
+ case '.*':
+ return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*.*':
+ return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*/*':
+ return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+ case '**':
+ return nodot + globstar(opts);
+
+ case '**/*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+ case '**/*.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '**/.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
- function wrapped() {
- var params = slice$4.call(arguments, 0);
- var callback = fn.length > params.length;
- var result;
+ default: {
+ const match = /^(.*?)\.(\w+)$/.exec(str);
+ if (!match) return;
- if (callback) {
- params.push(done);
+ const source = create(match[1]);
+ if (!source) return;
+
+ return source + DOT_LITERAL + match[2];
+ }
}
+ };
+
+ const output = utils$5.removePrefix(input, state);
+ let source = create(output);
+
+ if (source && opts.strictSlashes !== true) {
+ source += `${SLASH_LITERAL}?`;
+ }
+
+ return source;
+};
+
+var parse_1$2 = parse$e;
+
+const path$9 = path$b;
+const scan = scan_1;
+const parse$d = parse_1$2;
+const utils$4 = utils$7;
+const constants$3 = constants$5;
+const isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch$3 = (glob, options, returnState = false) => {
+ if (Array.isArray(glob)) {
+ const fns = glob.map(input => picomatch$3(input, options, returnState));
+ const arrayMatcher = str => {
+ for (const isMatch of fns) {
+ const state = isMatch(str);
+ if (state) return state;
+ }
+ return false;
+ };
+ return arrayMatcher;
+ }
+
+ const isState = isObject$3(glob) && glob.tokens && glob.input;
+
+ if (glob === '' || (typeof glob !== 'string' && !isState)) {
+ throw new TypeError('Expected pattern to be a non-empty string');
+ }
+
+ const opts = options || {};
+ const posix = utils$4.isWindows(options);
+ const regex = isState
+ ? picomatch$3.compileRe(glob, options)
+ : picomatch$3.makeRe(glob, options, false, true);
+
+ const state = regex.state;
+ delete regex.state;
+
+ let isIgnored = () => false;
+ if (opts.ignore) {
+ const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+ isIgnored = picomatch$3(opts.ignore, ignoreOpts, returnState);
+ }
+
+ const matcher = (input, returnObject = false) => {
+ const { isMatch, match, output } = picomatch$3.test(input, regex, options, { glob, posix });
+ const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+ if (typeof opts.onResult === 'function') {
+ opts.onResult(result);
+ }
+
+ if (isMatch === false) {
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+
+ if (isIgnored(input)) {
+ if (typeof opts.onIgnore === 'function') {
+ opts.onIgnore(result);
+ }
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+
+ if (typeof opts.onMatch === 'function') {
+ opts.onMatch(result);
+ }
+ return returnObject ? result : true;
+ };
+
+ if (returnState) {
+ matcher.state = state;
+ }
+
+ return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected input to be a string');
+ }
+
+ if (input === '') {
+ return { isMatch: false, output: '' };
+ }
+
+ const opts = options || {};
+ const format = opts.format || (posix ? utils$4.toPosixSlashes : null);
+ let match = input === glob;
+ let output = (match && format) ? format(input) : input;
+
+ if (match === false) {
+ output = format ? format(input) : input;
+ match = output === glob;
+ }
+
+ if (match === false || opts.capture === true) {
+ if (opts.matchBase === true || opts.basename === true) {
+ match = picomatch$3.matchBase(input, regex, options, posix);
+ } else {
+ match = regex.exec(output);
+ }
+ }
+
+ return { isMatch: Boolean(match), match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch$3.matchBase = (input, glob, options, posix = utils$4.isWindows(options)) => {
+ const regex = glob instanceof RegExp ? glob : picomatch$3.makeRe(glob, options);
+ return regex.test(path$9.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch$3.parse = (pattern, options) => {
+ if (Array.isArray(pattern)) return pattern.map(p => picomatch$3.parse(p, options));
+ return parse$d(pattern, { ...options, fastpaths: false });
+};
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ * input: '!./foo/*.js',
+ * start: 3,
+ * base: 'foo',
+ * glob: '*.js',
+ * isBrace: false,
+ * isBracket: false,
+ * isGlob: true,
+ * isExtglob: false,
+ * isGlobstar: false,
+ * negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch$3.scan = (input, options) => scan(input, options);
+
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch$3.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+ if (returnOutput === true) {
+ return parsed.output;
+ }
+
+ const opts = options || {};
+ const prepend = opts.contains ? '' : '^';
+ const append = opts.contains ? '' : '$';
+
+ let source = `${prepend}(?:${parsed.output})${append}`;
+ if (parsed && parsed.negated === true) {
+ source = `^(?!${source}).*$`;
+ }
+
+ const regex = picomatch$3.toRegex(source, options);
+ if (returnState === true) {
+ regex.state = parsed;
+ }
+
+ return regex;
+};
+
+picomatch$3.makeRe = (input, options, returnOutput = false, returnState = false) => {
+ if (!input || typeof input !== 'string') {
+ throw new TypeError('Expected a non-empty string');
+ }
+
+ const opts = options || {};
+ let parsed = { negated: false, fastpaths: true };
+ let prefix = '';
+ let output;
+
+ if (input.startsWith('./')) {
+ input = input.slice(2);
+ prefix = parsed.prefix = './';
+ }
+
+ if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+ output = parse$d.fastpaths(input, options);
+ }
+
+ if (output === undefined) {
+ parsed = parse$d(input, options);
+ parsed.prefix = prefix + (parsed.prefix || '');
+ } else {
+ parsed.output = output;
+ }
+
+ return picomatch$3.compileRe(parsed, options, returnOutput, returnState);
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch$3.toRegex = (source, options) => {
+ try {
+ const opts = options || {};
+ return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+ } catch (err) {
+ if (options && options.debug === true) throw err;
+ return /$^/;
+ }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch$3.constants = constants$3;
+
+/**
+ * Expose "picomatch"
+ */
+
+var picomatch_1 = picomatch$3;
+
+var picomatch$2 = picomatch_1;
+
+const fs$9 = require$$0$3;
+const { Readable } = require$$1;
+const sysPath$3 = path$b;
+const { promisify: promisify$3 } = require$$0$4;
+const picomatch$1 = picomatch$2;
+
+const readdir$1 = promisify$3(fs$9.readdir);
+const stat$3 = promisify$3(fs$9.stat);
+const lstat$2 = promisify$3(fs$9.lstat);
+const realpath$2 = promisify$3(fs$9.realpath);
+
+/**
+ * @typedef {Object} EntryInfo
+ * @property {String} path
+ * @property {String} fullPath
+ * @property {fs.Stats=} stats
+ * @property {fs.Dirent=} dirent
+ * @property {String} basename
+ */
+
+const BANG$2 = '!';
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const FILE_TYPE = 'files';
+const DIR_TYPE = 'directories';
+const FILE_DIR_TYPE = 'files_directories';
+const EVERYTHING_TYPE = 'all';
+const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+
+const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
+
+const normalizeFilter = filter => {
+ if (filter === undefined) return;
+ if (typeof filter === 'function') return filter;
+
+ if (typeof filter === 'string') {
+ const glob = picomatch$1(filter.trim());
+ return entry => glob(entry.basename);
+ }
+
+ if (Array.isArray(filter)) {
+ const positive = [];
+ const negative = [];
+ for (const item of filter) {
+ const trimmed = item.trim();
+ if (trimmed.charAt(0) === BANG$2) {
+ negative.push(picomatch$1(trimmed.slice(1)));
+ } else {
+ positive.push(picomatch$1(trimmed));
+ }
+ }
+
+ if (negative.length > 0) {
+ if (positive.length > 0) {
+ return entry =>
+ positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
+ }
+ return entry => !negative.some(f => f(entry.basename));
+ }
+ return entry => positive.some(f => f(entry.basename));
+ }
+};
+
+class ReaddirpStream extends Readable {
+ static get defaultOptions() {
+ return {
+ root: '.',
+ /* eslint-disable no-unused-vars */
+ fileFilter: (path) => true,
+ directoryFilter: (path) => true,
+ /* eslint-enable no-unused-vars */
+ type: FILE_TYPE,
+ lstat: false,
+ depth: 2147483648,
+ alwaysStat: false
+ };
+ }
+
+ constructor(options = {}) {
+ super({
+ objectMode: true,
+ autoDestroy: true,
+ highWaterMark: options.highWaterMark || 4096
+ });
+ const opts = { ...ReaddirpStream.defaultOptions, ...options };
+ const { root, type } = opts;
+
+ this._fileFilter = normalizeFilter(opts.fileFilter);
+ this._directoryFilter = normalizeFilter(opts.directoryFilter);
+
+ const statMethod = opts.lstat ? lstat$2 : stat$3;
+ // Use bigint stats if it's windows and stat() supports options (node 10+).
+ if (wantBigintFsStats) {
+ this._stat = path => statMethod(path, { bigint: true });
+ } else {
+ this._stat = statMethod;
+ }
+
+ this._maxDepth = opts.depth;
+ this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+ this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+ this._wantsEverything = type === EVERYTHING_TYPE;
+ this._root = sysPath$3.resolve(root);
+ this._isDirent = ('Dirent' in fs$9) && !opts.alwaysStat;
+ this._statsProp = this._isDirent ? 'dirent' : 'stats';
+ this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+
+ // Launch stream with one parent, the root dir.
+ this.parents = [this._exploreDir(root, 1)];
+ this.reading = false;
+ this.parent = undefined;
+ }
+
+ async _read(batch) {
+ if (this.reading) return;
+ this.reading = true;
try {
- result = fn.apply(null, params);
+ while (!this.destroyed && batch > 0) {
+ const { path, depth, files = [] } = this.parent || {};
+
+ if (files.length > 0) {
+ const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
+ for (const entry of await Promise.all(slice)) {
+ if (this.destroyed) return;
+
+ const entryType = await this._getEntryType(entry);
+ if (entryType === 'directory' && this._directoryFilter(entry)) {
+ if (depth <= this._maxDepth) {
+ this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+ }
+
+ if (this._wantsDir) {
+ this.push(entry);
+ batch--;
+ }
+ } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+ if (this._wantsFile) {
+ this.push(entry);
+ batch--;
+ }
+ }
+ }
+ } else {
+ const parent = this.parents.pop();
+ if (!parent) {
+ this.push(null);
+ break;
+ }
+ this.parent = await parent;
+ if (this.destroyed) return;
+ }
+ }
} catch (error) {
- // 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 instead.
- if (callback && invoked) {
- throw error
+ this.destroy(error);
+ } finally {
+ this.reading = false;
+ }
+ }
+
+ async _exploreDir(path, depth) {
+ let files;
+ try {
+ files = await readdir$1(path, this._rdOptions);
+ } catch (error) {
+ this._onError(error);
+ }
+ return { files, depth, path };
+ }
+
+ async _formatEntry(dirent, path) {
+ let entry;
+ try {
+ const basename = this._isDirent ? dirent.name : dirent;
+ const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
+ entry = { path: sysPath$3.relative(this._root, fullPath), fullPath, basename };
+ entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+ } catch (err) {
+ this._onError(err);
+ }
+ return entry;
+ }
+
+ _onError(err) {
+ if (isNormalFlowError(err) && !this.destroyed) {
+ this.emit('warn', err);
+ } else {
+ this.destroy(err);
+ }
+ }
+
+ async _getEntryType(entry) {
+ // entry may be undefined, because a warning or an error were emitted
+ // and the statsProp is undefined
+ const stats = entry && entry[this._statsProp];
+ if (!stats) {
+ return;
+ }
+ if (stats.isFile()) {
+ return 'file';
+ }
+ if (stats.isDirectory()) {
+ return 'directory';
+ }
+ if (stats && stats.isSymbolicLink()) {
+ const full = entry.fullPath;
+ try {
+ const entryRealPath = await realpath$2(full);
+ const entryRealPathStats = await lstat$2(entryRealPath);
+ if (entryRealPathStats.isFile()) {
+ return 'file';
+ }
+ if (entryRealPathStats.isDirectory()) {
+ const len = entryRealPath.length;
+ if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
+ const recursiveError = new Error(
+ `Circular symlink detected: "${full}" points to "${entryRealPath}"`
+ );
+ recursiveError.code = RECURSIVE_ERROR_CODE;
+ return this._onError(recursiveError);
+ }
+ return 'directory';
+ }
+ } catch (error) {
+ this._onError(error);
}
+ }
+ }
+
+ _includeAsFile(entry) {
+ const stats = entry && entry[this._statsProp];
+
+ return stats && this._wantsEverything && !stats.isDirectory();
+ }
+}
+
+/**
+ * @typedef {Object} ReaddirpArguments
+ * @property {Function=} fileFilter
+ * @property {Function=} directoryFilter
+ * @property {String=} type
+ * @property {Number=} depth
+ * @property {String=} root
+ * @property {Boolean=} lstat
+ * @property {Boolean=} bigint
+ */
+
+/**
+ * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+ * @param {String} root Root directory
+ * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+ */
+const readdirp$1 = (root, options = {}) => {
+ let type = options.entryType || options.type;
+ if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
+ if (type) options.type = type;
+ if (!root) {
+ throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+ } else if (typeof root !== 'string') {
+ throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+ } else if (type && !ALL_TYPES.includes(type)) {
+ throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+ }
- return done(error)
+ options.root = root;
+ return new ReaddirpStream(options);
+};
+
+const readdirpPromise = (root, options = {}) => {
+ return new Promise((resolve, reject) => {
+ const files = [];
+ readdirp$1(root, options)
+ .on('data', entry => files.push(entry))
+ .on('end', () => resolve(files))
+ .on('error', error => reject(error));
+ });
+};
+
+readdirp$1.promise = readdirpPromise;
+readdirp$1.ReaddirpStream = ReaddirpStream;
+readdirp$1.default = readdirp$1;
+
+var readdirp_1 = readdirp$1;
+
+var anymatch$2 = {exports: {}};
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var normalizePath$2 = function(path, stripTrailing) {
+ if (typeof path !== 'string') {
+ throw new TypeError('expected path to be a string');
+ }
+
+ if (path === '\\' || path === '/') return '/';
+
+ var len = path.length;
+ if (len <= 1) return path;
+
+ // ensure that win32 namespaces has two leading slashes, so that the path is
+ // handled properly by the win32 version of path.parse() after being normalized
+ // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+ var prefix = '';
+ if (len > 4 && path[3] === '\\') {
+ var ch = path[2];
+ if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+ path = path.slice(2);
+ prefix = '//';
}
+ }
- if (!callback) {
- if (result && typeof result.then === 'function') {
- result.then(then, done);
- } else if (result instanceof Error) {
- done(result);
+ var segs = path.split(/[/\\]+/);
+ if (stripTrailing !== false && segs[segs.length - 1] === '') {
+ segs.pop();
+ }
+ return prefix + segs.join('/');
+};
+
+Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
+
+const picomatch = picomatch$2;
+const normalizePath$1 = normalizePath$2;
+
+/**
+ * @typedef {(testString: string) => boolean} AnymatchFn
+ * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+ * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+ */
+const BANG$1 = '!';
+const DEFAULT_OPTIONS = {returnIndex: false};
+const arrify$1 = (item) => Array.isArray(item) ? item : [item];
+
+/**
+ * @param {AnymatchPattern} matcher
+ * @param {object} options
+ * @returns {AnymatchFn}
+ */
+const createPattern = (matcher, options) => {
+ if (typeof matcher === 'function') {
+ return matcher;
+ }
+ if (typeof matcher === 'string') {
+ const glob = picomatch(matcher, options);
+ return (string) => matcher === string || glob(string);
+ }
+ if (matcher instanceof RegExp) {
+ return (string) => matcher.test(string);
+ }
+ return (string) => false;
+};
+
+/**
+ * @param {Array<Function>} patterns
+ * @param {Array<Function>} negPatterns
+ * @param {String|Array} args
+ * @param {Boolean} returnIndex
+ * @returns {boolean|number}
+ */
+const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+ const isList = Array.isArray(args);
+ const _path = isList ? args[0] : args;
+ if (!isList && typeof _path !== 'string') {
+ throw new TypeError('anymatch: second argument must be a string: got ' +
+ Object.prototype.toString.call(_path))
+ }
+ const path = normalizePath$1(_path);
+
+ for (let index = 0; index < negPatterns.length; index++) {
+ const nglob = negPatterns[index];
+ if (nglob(path)) {
+ return returnIndex ? -1 : false;
+ }
+ }
+
+ const applied = isList && [path].concat(args.slice(1));
+ for (let index = 0; index < patterns.length; index++) {
+ const pattern = patterns[index];
+ if (isList ? pattern(...applied) : pattern(path)) {
+ return returnIndex ? index : true;
+ }
+ }
+
+ return returnIndex ? -1 : false;
+};
+
+/**
+ * @param {AnymatchMatcher} matchers
+ * @param {Array|string} testString
+ * @param {object} options
+ * @returns {boolean|number|Function}
+ */
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
+ if (matchers == null) {
+ throw new TypeError('anymatch: specify first argument');
+ }
+ const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
+ const returnIndex = opts.returnIndex || false;
+
+ // Early cache for matchers.
+ const mtchers = arrify$1(matchers);
+ const negatedGlobs = mtchers
+ .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
+ .map(item => item.slice(1))
+ .map(item => picomatch(item, opts));
+ const patterns = mtchers
+ .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG$1))
+ .map(matcher => createPattern(matcher, opts));
+
+ if (testString == null) {
+ return (testString, ri = false) => {
+ const returnIndex = typeof ri === 'boolean' ? ri : false;
+ return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+ }
+ }
+
+ return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+};
+
+anymatch$1.default = anymatch$1;
+anymatch$2.exports = anymatch$1;
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob$1 = function isExtglob(str) {
+ if (typeof str !== 'string' || str === '') {
+ return false;
+ }
+
+ var match;
+ while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+ if (match[2]) return true;
+ str = str.slice(match.index + match[0].length);
+ }
+
+ return false;
+};
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isExtglob = isExtglob$1;
+var chars$1 = { '{': '}', '(': ')', '[': ']'};
+var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
+
+var isGlob$2 = function isGlob(str, options) {
+ if (typeof str !== 'string' || str === '') {
+ return false;
+ }
+
+ if (isExtglob(str)) {
+ return true;
+ }
+
+ var regex = strictRegex;
+ var match;
+
+ // optionally relax regex
+ if (options && options.strict === false) {
+ regex = relaxedRegex;
+ }
+
+ while ((match = regex.exec(str))) {
+ if (match[2]) return true;
+ var idx = match.index + match[0].length;
+
+ // if an open bracket/brace/paren is escaped,
+ // set the index to the next closing character
+ var open = match[1];
+ var close = open ? chars$1[open] : null;
+ if (open && close) {
+ var n = str.indexOf(close, idx);
+ if (n !== -1) {
+ idx = n + 1;
+ }
+ }
+
+ str = str.slice(idx);
+ }
+ return false;
+};
+
+var isGlob$1 = isGlob$2;
+var pathPosixDirname = path$b.posix.dirname;
+var isWin32 = require$$0$2.platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+var globParent$1 = function globParent(str, opts) {
+ var options = Object.assign({ flipBackslashes: true }, opts);
+
+ // flip windows path separators
+ if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+ str = str.replace(backslash, slash);
+ }
+
+ // special case for strings ending in enclosure containing path separator
+ if (enclosure.test(str)) {
+ str += slash;
+ }
+
+ // preserves full path in case of trailing path separator
+ str += 'a';
+
+ // remove path parts that are globby
+ do {
+ str = pathPosixDirname(str);
+ } while (isGlob$1(str) || globby.test(str));
+
+ // remove escape chars and return result
+ return str.replace(escaped, '$1');
+};
+
+var utils$3 = {};
+
+(function (exports) {
+
+exports.isInteger = num => {
+ if (typeof num === 'number') {
+ return Number.isInteger(num);
+ }
+ if (typeof num === 'string' && num.trim() !== '') {
+ return Number.isInteger(Number(num));
+ }
+ return false;
+};
+
+/**
+ * Find a node of the given type
+ */
+
+exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+/**
+ * Find a node of the given type
+ */
+
+exports.exceedsLimit = (min, max, step = 1, limit) => {
+ if (limit === false) return false;
+ if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+ return ((Number(max) - Number(min)) / Number(step)) >= limit;
+};
+
+/**
+ * Escape the given node with '\\' before node.value
+ */
+
+exports.escapeNode = (block, n = 0, type) => {
+ let node = block.nodes[n];
+ if (!node) return;
+
+ if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+ if (node.escaped !== true) {
+ node.value = '\\' + node.value;
+ node.escaped = true;
+ }
+ }
+};
+
+/**
+ * Returns true if the given brace node should be enclosed in literal braces
+ */
+
+exports.encloseBrace = node => {
+ if (node.type !== 'brace') return false;
+ if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+ node.invalid = true;
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Returns true if a brace node is invalid.
+ */
+
+exports.isInvalidBrace = block => {
+ if (block.type !== 'brace') return false;
+ if (block.invalid === true || block.dollar) return true;
+ if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+ block.invalid = true;
+ return true;
+ }
+ if (block.open !== true || block.close !== true) {
+ block.invalid = true;
+ return true;
+ }
+ return false;
+};
+
+/**
+ * Returns true if a node is an open or close node
+ */
+
+exports.isOpenOrClose = node => {
+ if (node.type === 'open' || node.type === 'close') {
+ return true;
+ }
+ return node.open === true || node.close === true;
+};
+
+/**
+ * Reduce an array of text nodes.
+ */
+
+exports.reduce = nodes => nodes.reduce((acc, node) => {
+ if (node.type === 'text') acc.push(node.value);
+ if (node.type === 'range') node.type = 'text';
+ return acc;
+}, []);
+
+/**
+ * Flatten an array
+ */
+
+exports.flatten = (...args) => {
+ const result = [];
+ const flat = arr => {
+ for (let i = 0; i < arr.length; i++) {
+ let ele = arr[i];
+ Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+ }
+ return result;
+ };
+ flat(args);
+ return result;
+};
+}(utils$3));
+
+const utils$2 = utils$3;
+
+var stringify$6 = (ast, options = {}) => {
+ let stringify = (node, parent = {}) => {
+ let invalidBlock = options.escapeInvalid && utils$2.isInvalidBrace(parent);
+ let invalidNode = node.invalid === true && options.escapeInvalid === true;
+ let output = '';
+
+ if (node.value) {
+ if ((invalidBlock || invalidNode) && utils$2.isOpenOrClose(node)) {
+ return '\\' + node.value;
+ }
+ return node.value;
+ }
+
+ if (node.value) {
+ return node.value;
+ }
+
+ if (node.nodes) {
+ for (let child of node.nodes) {
+ output += stringify(child);
+ }
+ }
+ return output;
+ };
+
+ return stringify(ast);
+};
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isNumber$3 = function(num) {
+ if (typeof num === 'number') {
+ return num - num === 0;
+ }
+ if (typeof num === 'string' && num.trim() !== '') {
+ return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+ }
+ return false;
+};
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+const isNumber$2 = isNumber$3;
+
+const toRegexRange$1 = (min, max, options) => {
+ if (isNumber$2(min) === false) {
+ throw new TypeError('toRegexRange: expected the first argument to be a number');
+ }
+
+ if (max === void 0 || min === max) {
+ return String(min);
+ }
+
+ if (isNumber$2(max) === false) {
+ throw new TypeError('toRegexRange: expected the second argument to be a number.');
+ }
+
+ let opts = { relaxZeros: true, ...options };
+ if (typeof opts.strictZeros === 'boolean') {
+ opts.relaxZeros = opts.strictZeros === false;
+ }
+
+ let relax = String(opts.relaxZeros);
+ let shorthand = String(opts.shorthand);
+ let capture = String(opts.capture);
+ let wrap = String(opts.wrap);
+ let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+ if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) {
+ return toRegexRange$1.cache[cacheKey].result;
+ }
+
+ let a = Math.min(min, max);
+ let b = Math.max(min, max);
+
+ if (Math.abs(a - b) === 1) {
+ let result = min + '|' + max;
+ if (opts.capture) {
+ return `(${result})`;
+ }
+ if (opts.wrap === false) {
+ return result;
+ }
+ return `(?:${result})`;
+ }
+
+ let isPadded = hasPadding(min) || hasPadding(max);
+ let state = { min, max, a, b };
+ let positives = [];
+ let negatives = [];
+
+ if (isPadded) {
+ state.isPadded = isPadded;
+ state.maxLen = String(state.max).length;
+ }
+
+ if (a < 0) {
+ let newMin = b < 0 ? Math.abs(b) : 1;
+ negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+ a = state.a = 0;
+ }
+
+ if (b >= 0) {
+ positives = splitToPatterns(a, b, state, opts);
+ }
+
+ state.negatives = negatives;
+ state.positives = positives;
+ state.result = collatePatterns(negatives, positives);
+
+ if (opts.capture === true) {
+ state.result = `(${state.result})`;
+ } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+ state.result = `(?:${state.result})`;
+ }
+
+ toRegexRange$1.cache[cacheKey] = state;
+ return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+ let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
+ let onlyPositive = filterPatterns(pos, neg, '', false) || [];
+ let intersected = filterPatterns(neg, pos, '-?', true) || [];
+ let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+ return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+ let nines = 1;
+ let zeros = 1;
+
+ let stop = countNines(min, nines);
+ let stops = new Set([max]);
+
+ while (min <= stop && stop <= max) {
+ stops.add(stop);
+ nines += 1;
+ stop = countNines(min, nines);
+ }
+
+ stop = countZeros(max + 1, zeros) - 1;
+
+ while (min < stop && stop <= max) {
+ stops.add(stop);
+ zeros += 1;
+ stop = countZeros(max + 1, zeros) - 1;
+ }
+
+ stops = [...stops];
+ stops.sort(compare$c);
+ return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+ if (start === stop) {
+ return { pattern: start, count: [], digits: 0 };
+ }
+
+ let zipped = zip(start, stop);
+ let digits = zipped.length;
+ let pattern = '';
+ let count = 0;
+
+ for (let i = 0; i < digits; i++) {
+ let [startDigit, stopDigit] = zipped[i];
+
+ if (startDigit === stopDigit) {
+ pattern += startDigit;
+
+ } else if (startDigit !== '0' || stopDigit !== '9') {
+ pattern += toCharacterClass(startDigit, stopDigit);
+
+ } else {
+ count++;
+ }
+ }
+
+ if (count) {
+ pattern += options.shorthand === true ? '\\d' : '[0-9]';
+ }
+
+ return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+ let ranges = splitToRanges(min, max);
+ let tokens = [];
+ let start = min;
+ let prev;
+
+ for (let i = 0; i < ranges.length; i++) {
+ let max = ranges[i];
+ let obj = rangeToPattern(String(start), String(max), options);
+ let zeros = '';
+
+ if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+ if (prev.count.length > 1) {
+ prev.count.pop();
+ }
+
+ prev.count.push(obj.count[0]);
+ prev.string = prev.pattern + toQuantifier(prev.count);
+ start = max + 1;
+ continue;
+ }
+
+ if (tok.isPadded) {
+ zeros = padZeros(max, tok, options);
+ }
+
+ obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+ tokens.push(obj);
+ start = max + 1;
+ prev = obj;
+ }
+
+ return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+ let result = [];
+
+ for (let ele of arr) {
+ let { string } = ele;
+
+ // only push if _both_ are negative...
+ if (!intersection && !contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+
+ // or _both_ are positive
+ if (intersection && contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+ }
+ return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+ let arr = [];
+ for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+ return arr;
+}
+
+function compare$c(a, b) {
+ return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+ return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+ return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+ return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+ let [start = 0, stop = ''] = digits;
+ if (stop || start > 1) {
+ return `{${start + (stop ? ',' + stop : '')}}`;
+ }
+ return '';
+}
+
+function toCharacterClass(a, b, options) {
+ return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+ return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+ if (!tok.isPadded) {
+ return value;
+ }
+
+ let diff = Math.abs(tok.maxLen - String(value).length);
+ let relax = options.relaxZeros !== false;
+
+ switch (diff) {
+ case 0:
+ return '';
+ case 1:
+ return relax ? '0?' : '0';
+ case 2:
+ return relax ? '0{0,2}' : '00';
+ default: {
+ return relax ? `0{0,${diff}}` : `0{${diff}}`;
+ }
+ }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange$1.cache = {};
+toRegexRange$1.clearCache = () => (toRegexRange$1.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+var toRegexRange_1 = toRegexRange$1;
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+const util$3 = require$$0$4;
+const toRegexRange = toRegexRange_1;
+
+const isObject$2 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+const transform$3 = toNumber => {
+ return value => toNumber === true ? Number(value) : String(value);
+};
+
+const isValidValue = value => {
+ return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
+
+const isNumber$1 = num => Number.isInteger(+num);
+
+const zeros = input => {
+ let value = `${input}`;
+ let index = -1;
+ if (value[0] === '-') value = value.slice(1);
+ if (value === '0') return false;
+ while (value[++index] === '0');
+ return index > 0;
+};
+
+const stringify$5 = (start, end, options) => {
+ if (typeof start === 'string' || typeof end === 'string') {
+ return true;
+ }
+ return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+ if (maxLength > 0) {
+ let dash = input[0] === '-' ? '-' : '';
+ if (dash) input = input.slice(1);
+ input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+ }
+ if (toNumber === false) {
+ return String(input);
+ }
+ return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+ let negative = input[0] === '-' ? '-' : '';
+ if (negative) {
+ input = input.slice(1);
+ maxLength--;
+ }
+ while (input.length < maxLength) input = '0' + input;
+ return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options) => {
+ parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+ parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+ let prefix = options.capture ? '' : '?:';
+ let positives = '';
+ let negatives = '';
+ let result;
+
+ if (parts.positives.length) {
+ positives = parts.positives.join('|');
+ }
+
+ if (parts.negatives.length) {
+ negatives = `-(${prefix}${parts.negatives.join('|')})`;
+ }
+
+ if (positives && negatives) {
+ result = `${positives}|${negatives}`;
+ } else {
+ result = positives || negatives;
+ }
+
+ if (options.wrap) {
+ return `(${prefix}${result})`;
+ }
+
+ return result;
+};
+
+const toRange = (a, b, isNumbers, options) => {
+ if (isNumbers) {
+ return toRegexRange(a, b, { wrap: false, ...options });
+ }
+
+ let start = String.fromCharCode(a);
+ if (a === b) return start;
+
+ let stop = String.fromCharCode(b);
+ return `[${start}-${stop}]`;
+};
+
+const toRegex = (start, end, options) => {
+ if (Array.isArray(start)) {
+ let wrap = options.wrap === true;
+ let prefix = options.capture ? '' : '?:';
+ return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+ }
+ return toRegexRange(start, end, options);
+};
+
+const rangeError = (...args) => {
+ return new RangeError('Invalid range arguments: ' + util$3.inspect(...args));
+};
+
+const invalidRange = (start, end, options) => {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+};
+
+const invalidStep = (step, options) => {
+ if (options.strictRanges === true) {
+ throw new TypeError(`Expected step "${step}" to be a number`);
+ }
+ return [];
+};
+
+const fillNumbers = (start, end, step = 1, options = {}) => {
+ let a = Number(start);
+ let b = Number(end);
+
+ if (!Number.isInteger(a) || !Number.isInteger(b)) {
+ if (options.strictRanges === true) throw rangeError([start, end]);
+ return [];
+ }
+
+ // fix negative zero
+ if (a === 0) a = 0;
+ if (b === 0) b = 0;
+
+ let descending = a > b;
+ let startString = String(start);
+ let endString = String(end);
+ let stepString = String(step);
+ step = Math.max(Math.abs(step), 1);
+
+ let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+ let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+ let toNumber = padded === false && stringify$5(start, end, options) === false;
+ let format = options.transform || transform$3(toNumber);
+
+ if (options.toRegex && step === 1) {
+ return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+ }
+
+ let parts = { negatives: [], positives: [] };
+ let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+ let range = [];
+ let index = 0;
+
+ while (descending ? a >= b : a <= b) {
+ if (options.toRegex === true && step > 1) {
+ push(a);
+ } else {
+ range.push(pad(format(a, index), maxLen, toNumber));
+ }
+ a = descending ? a - step : a + step;
+ index++;
+ }
+
+ if (options.toRegex === true) {
+ return step > 1
+ ? toSequence(parts, options)
+ : toRegex(range, null, { wrap: false, ...options });
+ }
+
+ return range;
+};
+
+const fillLetters = (start, end, step = 1, options = {}) => {
+ if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
+ return invalidRange(start, end, options);
+ }
+
+
+ let format = options.transform || (val => String.fromCharCode(val));
+ let a = `${start}`.charCodeAt(0);
+ let b = `${end}`.charCodeAt(0);
+
+ let descending = a > b;
+ let min = Math.min(a, b);
+ let max = Math.max(a, b);
+
+ if (options.toRegex && step === 1) {
+ return toRange(min, max, false, options);
+ }
+
+ let range = [];
+ let index = 0;
+
+ while (descending ? a >= b : a <= b) {
+ range.push(format(a, index));
+ a = descending ? a - step : a + step;
+ index++;
+ }
+
+ if (options.toRegex === true) {
+ return toRegex(range, null, { wrap: false, options });
+ }
+
+ return range;
+};
+
+const fill$2 = (start, end, step, options = {}) => {
+ if (end == null && isValidValue(start)) {
+ return [start];
+ }
+
+ if (!isValidValue(start) || !isValidValue(end)) {
+ return invalidRange(start, end, options);
+ }
+
+ if (typeof step === 'function') {
+ return fill$2(start, end, 1, { transform: step });
+ }
+
+ if (isObject$2(step)) {
+ return fill$2(start, end, 0, step);
+ }
+
+ let opts = { ...options };
+ if (opts.capture === true) opts.wrap = true;
+ step = step || opts.step || 1;
+
+ if (!isNumber$1(step)) {
+ if (step != null && !isObject$2(step)) return invalidStep(step, opts);
+ return fill$2(start, end, 1, step);
+ }
+
+ if (isNumber$1(start) && isNumber$1(end)) {
+ return fillNumbers(start, end, step, opts);
+ }
+
+ return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+};
+
+var fillRange = fill$2;
+
+const fill$1 = fillRange;
+const utils$1 = utils$3;
+
+const compile$1 = (ast, options = {}) => {
+ let walk = (node, parent = {}) => {
+ let invalidBlock = utils$1.isInvalidBrace(parent);
+ let invalidNode = node.invalid === true && options.escapeInvalid === true;
+ let invalid = invalidBlock === true || invalidNode === true;
+ let prefix = options.escapeInvalid === true ? '\\' : '';
+ let output = '';
+
+ if (node.isOpen === true) {
+ return prefix + node.value;
+ }
+ if (node.isClose === true) {
+ return prefix + node.value;
+ }
+
+ if (node.type === 'open') {
+ return invalid ? (prefix + node.value) : '(';
+ }
+
+ if (node.type === 'close') {
+ return invalid ? (prefix + node.value) : ')';
+ }
+
+ if (node.type === 'comma') {
+ return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+ }
+
+ if (node.value) {
+ return node.value;
+ }
+
+ if (node.nodes && node.ranges > 0) {
+ let args = utils$1.reduce(node.nodes);
+ let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
+
+ if (range.length !== 0) {
+ return args.length > 1 && range.length > 1 ? `(${range})` : range;
+ }
+ }
+
+ if (node.nodes) {
+ for (let child of node.nodes) {
+ output += walk(child, node);
+ }
+ }
+ return output;
+ };
+
+ return walk(ast);
+};
+
+var compile_1 = compile$1;
+
+const fill = fillRange;
+const stringify$4 = stringify$6;
+const utils = utils$3;
+
+const append = (queue = '', stash = '', enclose = false) => {
+ let result = [];
+
+ queue = [].concat(queue);
+ stash = [].concat(stash);
+
+ if (!stash.length) return queue;
+ if (!queue.length) {
+ return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+ }
+
+ for (let item of queue) {
+ if (Array.isArray(item)) {
+ for (let value of item) {
+ result.push(append(value, stash, enclose));
+ }
+ } else {
+ for (let ele of stash) {
+ if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+ result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
+ }
+ }
+ }
+ return utils.flatten(result);
+};
+
+const expand$4 = (ast, options = {}) => {
+ let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
+
+ let walk = (node, parent = {}) => {
+ node.queue = [];
+
+ let p = parent;
+ let q = parent.queue;
+
+ while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+ p = p.parent;
+ q = p.queue;
+ }
+
+ if (node.invalid || node.dollar) {
+ q.push(append(q.pop(), stringify$4(node, options)));
+ return;
+ }
+
+ if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+ q.push(append(q.pop(), ['{}']));
+ return;
+ }
+
+ if (node.nodes && node.ranges > 0) {
+ let args = utils.reduce(node.nodes);
+
+ if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+ throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+ }
+
+ let range = fill(...args, options);
+ if (range.length === 0) {
+ range = stringify$4(node, options);
+ }
+
+ q.push(append(q.pop(), range));
+ node.nodes = [];
+ return;
+ }
+
+ let enclose = utils.encloseBrace(node);
+ let queue = node.queue;
+ let block = node;
+
+ while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+ block = block.parent;
+ queue = block.queue;
+ }
+
+ for (let i = 0; i < node.nodes.length; i++) {
+ let child = node.nodes[i];
+
+ if (child.type === 'comma' && node.type === 'brace') {
+ if (i === 1) queue.push('');
+ queue.push('');
+ continue;
+ }
+
+ if (child.type === 'close') {
+ q.push(append(q.pop(), queue, enclose));
+ continue;
+ }
+
+ if (child.value && child.type !== 'open') {
+ queue.push(append(queue.pop(), child.value));
+ continue;
+ }
+
+ if (child.nodes) {
+ walk(child, node);
+ }
+ }
+
+ return queue;
+ };
+
+ return utils.flatten(walk(ast));
+};
+
+var expand_1 = expand$4;
+
+var constants$2 = {
+ MAX_LENGTH: 1024 * 64,
+
+ // Digits
+ CHAR_0: '0', /* 0 */
+ CHAR_9: '9', /* 9 */
+
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: 'A', /* A */
+ CHAR_LOWERCASE_A: 'a', /* a */
+ CHAR_UPPERCASE_Z: 'Z', /* Z */
+ CHAR_LOWERCASE_Z: 'z', /* z */
+
+ CHAR_LEFT_PARENTHESES: '(', /* ( */
+ CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+ CHAR_ASTERISK: '*', /* * */
+
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: '&', /* & */
+ CHAR_AT: '@', /* @ */
+ CHAR_BACKSLASH: '\\', /* \ */
+ CHAR_BACKTICK: '`', /* ` */
+ CHAR_CARRIAGE_RETURN: '\r', /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+ CHAR_COLON: ':', /* : */
+ CHAR_COMMA: ',', /* , */
+ CHAR_DOLLAR: '$', /* . */
+ CHAR_DOT: '.', /* . */
+ CHAR_DOUBLE_QUOTE: '"', /* " */
+ CHAR_EQUAL: '=', /* = */
+ CHAR_EXCLAMATION_MARK: '!', /* ! */
+ CHAR_FORM_FEED: '\f', /* \f */
+ CHAR_FORWARD_SLASH: '/', /* / */
+ CHAR_HASH: '#', /* # */
+ CHAR_HYPHEN_MINUS: '-', /* - */
+ CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+ CHAR_LEFT_CURLY_BRACE: '{', /* { */
+ CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+ CHAR_LINE_FEED: '\n', /* \n */
+ CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+ CHAR_PERCENT: '%', /* % */
+ CHAR_PLUS: '+', /* + */
+ CHAR_QUESTION_MARK: '?', /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+ CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+ CHAR_SEMICOLON: ';', /* ; */
+ CHAR_SINGLE_QUOTE: '\'', /* ' */
+ CHAR_SPACE: ' ', /* */
+ CHAR_TAB: '\t', /* \t */
+ CHAR_UNDERSCORE: '_', /* _ */
+ CHAR_VERTICAL_LINE: '|', /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+};
+
+const stringify$3 = stringify$6;
+
+/**
+ * Constants
+ */
+
+const {
+ MAX_LENGTH: MAX_LENGTH$3,
+ CHAR_BACKSLASH, /* \ */
+ CHAR_BACKTICK, /* ` */
+ CHAR_COMMA: CHAR_COMMA$1, /* , */
+ CHAR_DOT, /* . */
+ CHAR_LEFT_PARENTHESES, /* ( */
+ CHAR_RIGHT_PARENTHESES, /* ) */
+ CHAR_LEFT_CURLY_BRACE, /* { */
+ CHAR_RIGHT_CURLY_BRACE, /* } */
+ CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
+ CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
+ CHAR_DOUBLE_QUOTE: CHAR_DOUBLE_QUOTE$1, /* " */
+ CHAR_SINGLE_QUOTE: CHAR_SINGLE_QUOTE$1, /* ' */
+ CHAR_NO_BREAK_SPACE,
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE
+} = constants$2;
+
+/**
+ * parse
+ */
+
+const parse$c = (input, options = {}) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ let opts = options || {};
+ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3;
+ if (input.length > max) {
+ throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+ }
+
+ let ast = { type: 'root', input, nodes: [] };
+ let stack = [ast];
+ let block = ast;
+ let prev = ast;
+ let brackets = 0;
+ let length = input.length;
+ let index = 0;
+ let depth = 0;
+ let value;
+
+ /**
+ * Helpers
+ */
+
+ const advance = () => input[index++];
+ const push = node => {
+ if (node.type === 'text' && prev.type === 'dot') {
+ prev.type = 'text';
+ }
+
+ if (prev && prev.type === 'text' && node.type === 'text') {
+ prev.value += node.value;
+ return;
+ }
+
+ block.nodes.push(node);
+ node.parent = block;
+ node.prev = prev;
+ prev = node;
+ return node;
+ };
+
+ push({ type: 'bos' });
+
+ while (index < length) {
+ block = stack[stack.length - 1];
+ value = advance();
+
+ /**
+ * Invalid chars
+ */
+
+ if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+ continue;
+ }
+
+ /**
+ * Escaped chars
+ */
+
+ if (value === CHAR_BACKSLASH) {
+ push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+ continue;
+ }
+
+ /**
+ * Right square bracket (literal): ']'
+ */
+
+ if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
+ push({ type: 'text', value: '\\' + value });
+ continue;
+ }
+
+ /**
+ * Left square bracket: '['
+ */
+
+ if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
+ brackets++;
+ let next;
+
+ while (index < length && (next = advance())) {
+ value += next;
+
+ if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
+ brackets++;
+ continue;
+ }
+
+ if (next === CHAR_BACKSLASH) {
+ value += advance();
+ continue;
+ }
+
+ if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
+ brackets--;
+
+ if (brackets === 0) {
+ break;
+ }
+ }
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Parentheses
+ */
+
+ if (value === CHAR_LEFT_PARENTHESES) {
+ block = push({ type: 'paren', nodes: [] });
+ stack.push(block);
+ push({ type: 'text', value });
+ continue;
+ }
+
+ if (value === CHAR_RIGHT_PARENTHESES) {
+ if (block.type !== 'paren') {
+ push({ type: 'text', value });
+ continue;
+ }
+ block = stack.pop();
+ push({ type: 'text', value });
+ block = stack[stack.length - 1];
+ continue;
+ }
+
+ /**
+ * Quotes: '|"|`
+ */
+
+ if (value === CHAR_DOUBLE_QUOTE$1 || value === CHAR_SINGLE_QUOTE$1 || value === CHAR_BACKTICK) {
+ let open = value;
+ let next;
+
+ if (options.keepQuotes !== true) {
+ value = '';
+ }
+
+ while (index < length && (next = advance())) {
+ if (next === CHAR_BACKSLASH) {
+ value += next + advance();
+ continue;
+ }
+
+ if (next === open) {
+ if (options.keepQuotes === true) value += next;
+ break;
+ }
+
+ value += next;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Left curly brace: '{'
+ */
+
+ if (value === CHAR_LEFT_CURLY_BRACE) {
+ depth++;
+
+ let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+ let brace = {
+ type: 'brace',
+ open: true,
+ close: false,
+ dollar,
+ depth,
+ commas: 0,
+ ranges: 0,
+ nodes: []
+ };
+
+ block = push(brace);
+ stack.push(block);
+ push({ type: 'open', value });
+ continue;
+ }
+
+ /**
+ * Right curly brace: '}'
+ */
+
+ if (value === CHAR_RIGHT_CURLY_BRACE) {
+ if (block.type !== 'brace') {
+ push({ type: 'text', value });
+ continue;
+ }
+
+ let type = 'close';
+ block = stack.pop();
+ block.close = true;
+
+ push({ type, value });
+ depth--;
+
+ block = stack[stack.length - 1];
+ continue;
+ }
+
+ /**
+ * Comma: ','
+ */
+
+ if (value === CHAR_COMMA$1 && depth > 0) {
+ if (block.ranges > 0) {
+ block.ranges = 0;
+ let open = block.nodes.shift();
+ block.nodes = [open, { type: 'text', value: stringify$3(block) }];
+ }
+
+ push({ type: 'comma', value });
+ block.commas++;
+ continue;
+ }
+
+ /**
+ * Dot: '.'
+ */
+
+ if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+ let siblings = block.nodes;
+
+ if (depth === 0 || siblings.length === 0) {
+ push({ type: 'text', value });
+ continue;
+ }
+
+ if (prev.type === 'dot') {
+ block.range = [];
+ prev.value += value;
+ prev.type = 'range';
+
+ if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+ block.invalid = true;
+ block.ranges = 0;
+ prev.type = 'text';
+ continue;
+ }
+
+ block.ranges++;
+ block.args = [];
+ continue;
+ }
+
+ if (prev.type === 'range') {
+ siblings.pop();
+
+ let before = siblings[siblings.length - 1];
+ before.value += prev.value + value;
+ prev = before;
+ block.ranges--;
+ continue;
+ }
+
+ push({ type: 'dot', value });
+ continue;
+ }
+
+ /**
+ * Text
+ */
+
+ push({ type: 'text', value });
+ }
+
+ // Mark imbalanced braces and brackets as invalid
+ do {
+ block = stack.pop();
+
+ if (block.type !== 'root') {
+ block.nodes.forEach(node => {
+ if (!node.nodes) {
+ if (node.type === 'open') node.isOpen = true;
+ if (node.type === 'close') node.isClose = true;
+ if (!node.nodes) node.type = 'text';
+ node.invalid = true;
+ }
+ });
+
+ // get the location of the block on parent.nodes (block's siblings)
+ let parent = stack[stack.length - 1];
+ let index = parent.nodes.indexOf(block);
+ // replace the (invalid) block with it's nodes
+ parent.nodes.splice(index, 1, ...block.nodes);
+ }
+ } while (stack.length > 0);
+
+ push({ type: 'eos' });
+ return ast;
+};
+
+var parse_1$1 = parse$c;
+
+const stringify$2 = stringify$6;
+const compile = compile_1;
+const expand$3 = expand_1;
+const parse$b = parse_1$1;
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces$1 = (input, options = {}) => {
+ let output = [];
+
+ if (Array.isArray(input)) {
+ for (let pattern of input) {
+ let result = braces$1.create(pattern, options);
+ if (Array.isArray(result)) {
+ output.push(...result);
} else {
- then(result);
+ output.push(result);
+ }
+ }
+ } else {
+ output = [].concat(braces$1.create(input, options));
+ }
+
+ if (options && options.expand === true && options.nodupes === true) {
+ output = [...new Set(output)];
+ }
+ return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces$1.parse = (input, options = {}) => parse$b(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.stringify = (input, options = {}) => {
+ if (typeof input === 'string') {
+ return stringify$2(braces$1.parse(input, options), options);
+ }
+ return stringify$2(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.compile = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces$1.parse(input, options);
+ }
+ return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.expand = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces$1.parse(input, options);
+ }
+
+ let result = expand$3(input, options);
+
+ // filter out empty strings if specified
+ if (options.noempty === true) {
+ result = result.filter(Boolean);
+ }
+
+ // filter out duplicates if specified
+ if (options.nodupes === true) {
+ result = [...new Set(result)];
+ }
+
+ return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$1.create = (input, options = {}) => {
+ if (input === '' || input.length < 3) {
+ return [input];
+ }
+
+ return options.expand !== true
+ ? braces$1.compile(input, options)
+ : braces$1.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+var braces_1 = braces$1;
+
+var require$$0$1 = [
+ "3dm",
+ "3ds",
+ "3g2",
+ "3gp",
+ "7z",
+ "a",
+ "aac",
+ "adp",
+ "ai",
+ "aif",
+ "aiff",
+ "alz",
+ "ape",
+ "apk",
+ "appimage",
+ "ar",
+ "arj",
+ "asf",
+ "au",
+ "avi",
+ "bak",
+ "baml",
+ "bh",
+ "bin",
+ "bk",
+ "bmp",
+ "btif",
+ "bz2",
+ "bzip2",
+ "cab",
+ "caf",
+ "cgm",
+ "class",
+ "cmx",
+ "cpio",
+ "cr2",
+ "cur",
+ "dat",
+ "dcm",
+ "deb",
+ "dex",
+ "djvu",
+ "dll",
+ "dmg",
+ "dng",
+ "doc",
+ "docm",
+ "docx",
+ "dot",
+ "dotm",
+ "dra",
+ "DS_Store",
+ "dsk",
+ "dts",
+ "dtshd",
+ "dvb",
+ "dwg",
+ "dxf",
+ "ecelp4800",
+ "ecelp7470",
+ "ecelp9600",
+ "egg",
+ "eol",
+ "eot",
+ "epub",
+ "exe",
+ "f4v",
+ "fbs",
+ "fh",
+ "fla",
+ "flac",
+ "flatpak",
+ "fli",
+ "flv",
+ "fpx",
+ "fst",
+ "fvt",
+ "g3",
+ "gh",
+ "gif",
+ "graffle",
+ "gz",
+ "gzip",
+ "h261",
+ "h263",
+ "h264",
+ "icns",
+ "ico",
+ "ief",
+ "img",
+ "ipa",
+ "iso",
+ "jar",
+ "jpeg",
+ "jpg",
+ "jpgv",
+ "jpm",
+ "jxr",
+ "key",
+ "ktx",
+ "lha",
+ "lib",
+ "lvp",
+ "lz",
+ "lzh",
+ "lzma",
+ "lzo",
+ "m3u",
+ "m4a",
+ "m4v",
+ "mar",
+ "mdi",
+ "mht",
+ "mid",
+ "midi",
+ "mj2",
+ "mka",
+ "mkv",
+ "mmr",
+ "mng",
+ "mobi",
+ "mov",
+ "movie",
+ "mp3",
+ "mp4",
+ "mp4a",
+ "mpeg",
+ "mpg",
+ "mpga",
+ "mxu",
+ "nef",
+ "npx",
+ "numbers",
+ "nupkg",
+ "o",
+ "odp",
+ "ods",
+ "odt",
+ "oga",
+ "ogg",
+ "ogv",
+ "otf",
+ "ott",
+ "pages",
+ "pbm",
+ "pcx",
+ "pdb",
+ "pdf",
+ "pea",
+ "pgm",
+ "pic",
+ "png",
+ "pnm",
+ "pot",
+ "potm",
+ "potx",
+ "ppa",
+ "ppam",
+ "ppm",
+ "pps",
+ "ppsm",
+ "ppsx",
+ "ppt",
+ "pptm",
+ "pptx",
+ "psd",
+ "pya",
+ "pyc",
+ "pyo",
+ "pyv",
+ "qt",
+ "rar",
+ "ras",
+ "raw",
+ "resources",
+ "rgb",
+ "rip",
+ "rlc",
+ "rmf",
+ "rmvb",
+ "rpm",
+ "rtf",
+ "rz",
+ "s3m",
+ "s7z",
+ "scpt",
+ "sgi",
+ "shar",
+ "snap",
+ "sil",
+ "sketch",
+ "slk",
+ "smv",
+ "snk",
+ "so",
+ "stl",
+ "suo",
+ "sub",
+ "swf",
+ "tar",
+ "tbz",
+ "tbz2",
+ "tga",
+ "tgz",
+ "thmx",
+ "tif",
+ "tiff",
+ "tlz",
+ "ttc",
+ "ttf",
+ "txz",
+ "udf",
+ "uvh",
+ "uvi",
+ "uvm",
+ "uvp",
+ "uvs",
+ "uvu",
+ "viv",
+ "vob",
+ "war",
+ "wav",
+ "wax",
+ "wbmp",
+ "wdp",
+ "weba",
+ "webm",
+ "webp",
+ "whl",
+ "wim",
+ "wm",
+ "wma",
+ "wmv",
+ "wmx",
+ "woff",
+ "woff2",
+ "wrm",
+ "wvx",
+ "xbm",
+ "xif",
+ "xla",
+ "xlam",
+ "xls",
+ "xlsb",
+ "xlsm",
+ "xlsx",
+ "xlt",
+ "xltm",
+ "xltx",
+ "xm",
+ "xmind",
+ "xpi",
+ "xpm",
+ "xwd",
+ "xz",
+ "z",
+ "zip",
+ "zipx"
+];
+
+var binaryExtensions$1 = require$$0$1;
+
+const path$8 = path$b;
+const binaryExtensions = binaryExtensions$1;
+
+const extensions = new Set(binaryExtensions);
+
+var isBinaryPath$1 = filePath => extensions.has(path$8.extname(filePath).slice(1).toLowerCase());
+
+var constants$1 = {};
+
+(function (exports) {
+
+const {sep} = path$b;
+const {platform} = process;
+const os = require$$0$2;
+
+exports.EV_ALL = 'all';
+exports.EV_READY = 'ready';
+exports.EV_ADD = 'add';
+exports.EV_CHANGE = 'change';
+exports.EV_ADD_DIR = 'addDir';
+exports.EV_UNLINK = 'unlink';
+exports.EV_UNLINK_DIR = 'unlinkDir';
+exports.EV_RAW = 'raw';
+exports.EV_ERROR = 'error';
+
+exports.STR_DATA = 'data';
+exports.STR_END = 'end';
+exports.STR_CLOSE = 'close';
+
+exports.FSEVENT_CREATED = 'created';
+exports.FSEVENT_MODIFIED = 'modified';
+exports.FSEVENT_DELETED = 'deleted';
+exports.FSEVENT_MOVED = 'moved';
+exports.FSEVENT_CLONED = 'cloned';
+exports.FSEVENT_UNKNOWN = 'unknown';
+exports.FSEVENT_TYPE_FILE = 'file';
+exports.FSEVENT_TYPE_DIRECTORY = 'directory';
+exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+
+exports.KEY_LISTENERS = 'listeners';
+exports.KEY_ERR = 'errHandlers';
+exports.KEY_RAW = 'rawEmitters';
+exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+
+exports.DOT_SLASH = `.${sep}`;
+
+exports.BACK_SLASH_RE = /\\/g;
+exports.DOUBLE_SLASH_RE = /\/\//;
+exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+exports.REPLACER_RE = /^\.[/\\]/;
+
+exports.SLASH = '/';
+exports.SLASH_SLASH = '//';
+exports.BRACE_START = '{';
+exports.BANG = '!';
+exports.ONE_DOT = '.';
+exports.TWO_DOTS = '..';
+exports.STAR = '*';
+exports.GLOBSTAR = '**';
+exports.ROOT_GLOBSTAR = '/**/*';
+exports.SLASH_GLOBSTAR = '/**';
+exports.DIR_SUFFIX = 'Dir';
+exports.ANYMATCH_OPTS = {dot: true};
+exports.STRING_TYPE = 'string';
+exports.FUNCTION_TYPE = 'function';
+exports.EMPTY_STR = '';
+exports.EMPTY_FN = () => {};
+exports.IDENTITY_FN = val => val;
+
+exports.isWindows = platform === 'win32';
+exports.isMacos = platform === 'darwin';
+exports.isLinux = platform === 'linux';
+exports.isIBMi = os.type() === 'OS400';
+}(constants$1));
+
+const fs$8 = require$$0$3;
+const sysPath$2 = path$b;
+const { promisify: promisify$2 } = require$$0$4;
+const isBinaryPath = isBinaryPath$1;
+const {
+ isWindows: isWindows$3,
+ isLinux,
+ EMPTY_FN: EMPTY_FN$2,
+ EMPTY_STR: EMPTY_STR$1,
+ KEY_LISTENERS,
+ KEY_ERR,
+ KEY_RAW,
+ HANDLER_KEYS,
+ EV_CHANGE: EV_CHANGE$2,
+ EV_ADD: EV_ADD$2,
+ EV_ADD_DIR: EV_ADD_DIR$2,
+ EV_ERROR: EV_ERROR$2,
+ STR_DATA: STR_DATA$1,
+ STR_END: STR_END$2,
+ BRACE_START: BRACE_START$1,
+ STAR
+} = constants$1;
+
+const THROTTLE_MODE_WATCH = 'watch';
+
+const open = promisify$2(fs$8.open);
+const stat$2 = promisify$2(fs$8.stat);
+const lstat$1 = promisify$2(fs$8.lstat);
+const close = promisify$2(fs$8.close);
+const fsrealpath = promisify$2(fs$8.realpath);
+
+const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
+
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+ if (val instanceof Set) {
+ val.forEach(fn);
+ } else {
+ fn(val);
+ }
+};
+
+const addAndConvert = (main, prop, item) => {
+ let container = main[prop];
+ if (!(container instanceof Set)) {
+ main[prop] = container = new Set([container]);
+ }
+ container.add(item);
+};
+
+const clearItem = cont => key => {
+ const set = cont[key];
+ if (set instanceof Set) {
+ set.clear();
+ } else {
+ delete cont[key];
+ }
+};
+
+const delFromSet = (main, prop, item) => {
+ const container = main[prop];
+ if (container instanceof Set) {
+ container.delete(item);
+ } else if (container === item) {
+ delete main[prop];
+ }
+};
+
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+
+/**
+ * @typedef {String} Path
+ */
+
+// fs_watch helpers
+
+// object to hold per-process fs_watch instances
+// (may be shared across chokidar FSWatcher instances)
+
+/**
+ * @typedef {Object} FsWatchContainer
+ * @property {Set} listeners
+ * @property {Set} errHandlers
+ * @property {Set} rawEmitters
+ * @property {fs.FSWatcher=} watcher
+ * @property {Boolean=} watcherUnusable
+ */
+
+/**
+ * @type {Map<String,FsWatchContainer>}
+ */
+const FsWatchInstances = new Map();
+
+/**
+ * Instantiates the fs_watch interface
+ * @param {String} path to be watched
+ * @param {Object} options to be passed to fs_watch
+ * @param {Function} listener main event handler
+ * @param {Function} errHandler emits info about errors
+ * @param {Function} emitRaw emits raw event data
+ * @returns {fs.FSWatcher} new fsevents instance
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+ const handleEvent = (rawEvent, evPath) => {
+ listener(path);
+ emitRaw(rawEvent, evPath, {watchedPath: path});
+
+ // emit based on events occurring for files from a directory's watcher in
+ // case the file's watcher misses it (and rely on throttling to de-dupe)
+ if (evPath && path !== evPath) {
+ fsWatchBroadcast(
+ sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
+ );
+ }
+ };
+ try {
+ return fs$8.watch(path, options, handleEvent);
+ } catch (error) {
+ errHandler(error);
+ }
+}
+
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param {Path} fullPath absolute path bound to fs_watch instance
+ * @param {String} type listener type
+ * @param {*=} val1 arguments to be passed to listeners
+ * @param {*=} val2
+ * @param {*=} val3
+ */
+const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+ const cont = FsWatchInstances.get(fullPath);
+ if (!cont) return;
+ foreach(cont[type], (listener) => {
+ listener(val1, val2, val3);
+ });
+};
+
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path
+ * @param {String} fullPath absolute path
+ * @param {Object} options to be passed to fs_watch
+ * @param {Object} handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+ const {listener, errHandler, rawEmitter} = handlers;
+ let cont = FsWatchInstances.get(fullPath);
+
+ /** @type {fs.FSWatcher=} */
+ let watcher;
+ if (!options.persistent) {
+ watcher = createFsWatchInstance(
+ path, options, listener, errHandler, rawEmitter
+ );
+ return watcher.close.bind(watcher);
+ }
+ if (cont) {
+ addAndConvert(cont, KEY_LISTENERS, listener);
+ addAndConvert(cont, KEY_ERR, errHandler);
+ addAndConvert(cont, KEY_RAW, rawEmitter);
+ } else {
+ watcher = createFsWatchInstance(
+ path,
+ options,
+ fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+ errHandler, // no need to use broadcast here
+ fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+ );
+ if (!watcher) return;
+ watcher.on(EV_ERROR$2, async (error) => {
+ const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+ cont.watcherUnusable = true; // documented since Node 10.4.1
+ // Workaround for https://github.com/joyent/node/issues/4337
+ if (isWindows$3 && error.code === 'EPERM') {
+ try {
+ const fd = await open(path, 'r');
+ await close(fd);
+ broadcastErr(error);
+ } catch (err) {}
+ } else {
+ broadcastErr(error);
}
+ });
+ cont = {
+ listeners: listener,
+ errHandlers: errHandler,
+ rawEmitters: rawEmitter,
+ watcher
+ };
+ FsWatchInstances.set(fullPath, cont);
+ }
+ // const index = cont.listeners.indexOf(listener);
+
+ // removes this instance's listeners and closes the underlying fs_watch
+ // instance if there are no more listeners left
+ return () => {
+ delFromSet(cont, KEY_LISTENERS, listener);
+ delFromSet(cont, KEY_ERR, errHandler);
+ delFromSet(cont, KEY_RAW, rawEmitter);
+ if (isEmptySet(cont.listeners)) {
+ // Check to protect against issue gh-730.
+ // if (cont.watcherUnusable) {
+ cont.watcher.close();
+ // }
+ FsWatchInstances.delete(fullPath);
+ HANDLER_KEYS.forEach(clearItem(cont));
+ cont.watcher = undefined;
+ Object.freeze(cont);
}
+ };
+};
+
+// fs_watchFile helpers
+
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path to be watched
+ * @param {String} fullPath absolute path
+ * @param {Object} options options to be passed to fs_watchFile
+ * @param {Object} handlers container for event listener functions
+ * @returns {Function} closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+ const {listener, rawEmitter} = handlers;
+ let cont = FsWatchFileInstances.get(fullPath);
+
+ const copts = cont && cont.options;
+ if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+ fs$8.unwatchFile(fullPath);
+ cont = undefined;
}
- // Invoke `next`, only once.
- function done() {
- if (!invoked) {
- invoked = true;
+ /* eslint-enable no-unused-vars, prefer-destructuring */
+
+ if (cont) {
+ addAndConvert(cont, KEY_LISTENERS, listener);
+ addAndConvert(cont, KEY_RAW, rawEmitter);
+ } else {
+ // TODO
+ // listeners.add(listener);
+ // rawEmitters.add(rawEmitter);
+ cont = {
+ listeners: listener,
+ rawEmitters: rawEmitter,
+ options,
+ watcher: fs$8.watchFile(fullPath, options, (curr, prev) => {
+ foreach(cont.rawEmitters, (rawEmitter) => {
+ rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
+ });
+ const currmtime = curr.mtimeMs;
+ if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+ foreach(cont.listeners, (listener) => listener(path, curr));
+ }
+ })
+ };
+ FsWatchFileInstances.set(fullPath, cont);
+ }
+ // const index = cont.listeners.indexOf(listener);
- callback.apply(null, arguments);
+ // Removes this instance's listeners and closes the underlying fs_watchFile
+ // instance if there are no more listeners left.
+ return () => {
+ delFromSet(cont, KEY_LISTENERS, listener);
+ delFromSet(cont, KEY_RAW, rawEmitter);
+ if (isEmptySet(cont.listeners)) {
+ FsWatchFileInstances.delete(fullPath);
+ fs$8.unwatchFile(fullPath);
+ cont.options = cont.watcher = undefined;
+ Object.freeze(cont);
}
+ };
+};
+
+/**
+ * @mixin
+ */
+class NodeFsHandler$1 {
+
+/**
+ * @param {import("../index").FSWatcher} fsW
+ */
+constructor(fsW) {
+ this.fsw = fsW;
+ this._boundHandleError = (error) => fsW._handleError(error);
+}
+
+/**
+ * Watch file for changes with fs_watchFile or fs_watch.
+ * @param {String} path to file or dir
+ * @param {Function} listener on fs change
+ * @returns {Function} closer for the watcher instance
+ */
+_watchWithNodeFs(path, listener) {
+ const opts = this.fsw.options;
+ const directory = sysPath$2.dirname(path);
+ const basename = sysPath$2.basename(path);
+ const parent = this.fsw._getWatchedDir(directory);
+ parent.add(basename);
+ const absolutePath = sysPath$2.resolve(path);
+ const options = {persistent: opts.persistent};
+ if (!listener) listener = EMPTY_FN$2;
+
+ let closer;
+ if (opts.usePolling) {
+ options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+ opts.binaryInterval : opts.interval;
+ closer = setFsWatchFileListener(path, absolutePath, options, {
+ listener,
+ rawEmitter: this.fsw._emitRaw
+ });
+ } else {
+ closer = setFsWatchListener(path, absolutePath, options, {
+ listener,
+ errHandler: this._boundHandleError,
+ rawEmitter: this.fsw._emitRaw
+ });
}
+ return closer;
+}
- // Invoke `done` with one value.
- // Tracks if an error is passed, too.
- function then(value) {
- done(null, value);
+/**
+ * Watch a file and emit add event if warranted.
+ * @param {Path} file Path
+ * @param {fs.Stats} stats result of fs_stat
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @returns {Function} closer for the watcher instance
+ */
+_handleFile(file, stats, initialAdd) {
+ if (this.fsw.closed) {
+ return;
}
+ const dirname = sysPath$2.dirname(file);
+ const basename = sysPath$2.basename(file);
+ const parent = this.fsw._getWatchedDir(dirname);
+ // stats is always present
+ let prevStats = stats;
+
+ // if the file is already being watched, do nothing
+ if (parent.has(basename)) return;
+
+ const listener = async (path, newStats) => {
+ if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+ if (!newStats || newStats.mtimeMs === 0) {
+ try {
+ const newStats = await stat$2(file);
+ if (this.fsw.closed) return;
+ // Check that change event was not fired because of changed only accessTime.
+ const at = newStats.atimeMs;
+ const mt = newStats.mtimeMs;
+ if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+ this.fsw._emit(EV_CHANGE$2, file, newStats);
+ }
+ if (isLinux && prevStats.ino !== newStats.ino) {
+ this.fsw._closeFile(path);
+ prevStats = newStats;
+ this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+ } else {
+ prevStats = newStats;
+ }
+ } catch (error) {
+ // Fix issues where mtime is null but file is still present
+ this.fsw._remove(dirname, basename);
+ }
+ // add is about to be emitted if file not already tracked in parent
+ } else if (parent.has(basename)) {
+ // Check that change event was not fired because of changed only accessTime.
+ const at = newStats.atimeMs;
+ const mt = newStats.mtimeMs;
+ if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+ this.fsw._emit(EV_CHANGE$2, file, newStats);
+ }
+ prevStats = newStats;
+ }
+ };
+ // kick off the watcher
+ const closer = this._watchWithNodeFs(file, listener);
+
+ // emit an add event if we're supposed to
+ if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+ if (!this.fsw._throttle(EV_ADD$2, file, 0)) return;
+ this.fsw._emit(EV_ADD$2, file, stats);
+ }
+
+ return closer;
}
-var wrap$2 = wrap_1;
+/**
+ * Handle symlinks encountered while reading a dir.
+ * @param {Object} entry returned by readdirp
+ * @param {String} directory path of dir being read
+ * @param {String} path of this item
+ * @param {String} item basename of this item
+ * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+ */
+async _handleSymlink(entry, directory, path, item) {
+ if (this.fsw.closed) {
+ return;
+ }
+ const full = entry.fullPath;
+ const dir = this.fsw._getWatchedDir(directory);
-var trough_1 = trough$4;
+ if (!this.fsw.options.followSymlinks) {
+ // watch symlink directly (don't follow) and detect changes
+ this.fsw._incrReadyCount();
+ const linkPath = await fsrealpath(path);
+ if (this.fsw.closed) return;
+ if (dir.has(item)) {
+ if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+ this.fsw._symlinkPaths.set(full, linkPath);
+ this.fsw._emit(EV_CHANGE$2, path, entry.stats);
+ }
+ } else {
+ dir.add(item);
+ this.fsw._symlinkPaths.set(full, linkPath);
+ this.fsw._emit(EV_ADD$2, path, entry.stats);
+ }
+ this.fsw._emitReady();
+ return true;
+ }
+
+ // don't follow the same symlink more than once
+ if (this.fsw._symlinkPaths.has(full)) {
+ return true;
+ }
+
+ this.fsw._symlinkPaths.set(full, true);
+}
-trough$4.wrap = wrap$2;
+_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+ // Normalize the directory name on Windows
+ directory = sysPath$2.join(directory, EMPTY_STR$1);
-var slice$3 = [].slice;
+ if (!wh.hasGlob) {
+ throttler = this.fsw._throttle('readdir', directory, 1000);
+ if (!throttler) return;
+ }
-// Create new middleware.
-function trough$4() {
- var fns = [];
- var middleware = {};
+ const previous = this.fsw._getWatchedDir(wh.path);
+ const current = new Set();
- middleware.run = run;
- middleware.use = use;
+ let stream = this.fsw._readdirp(directory, {
+ fileFilter: entry => wh.filterPath(entry),
+ directoryFilter: entry => wh.filterDir(entry),
+ depth: 0
+ }).on(STR_DATA$1, async (entry) => {
+ if (this.fsw.closed) {
+ stream = undefined;
+ return;
+ }
+ const item = entry.path;
+ let path = sysPath$2.join(directory, item);
+ current.add(item);
- return middleware
+ if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+ return;
+ }
- // Run `fns`. Last argument must be a completion handler.
- function run() {
- var index = -1;
- var input = slice$3.call(arguments, 0, -1);
- var done = arguments[arguments.length - 1];
+ if (this.fsw.closed) {
+ stream = undefined;
+ return;
+ }
+ // Files that present in current directory snapshot
+ // but absent in previous are added to watch list and
+ // emit `add` event.
+ if (item === target || !target && !previous.has(item)) {
+ this.fsw._incrReadyCount();
+
+ // ensure relativeness of path is preserved in case of watcher reuse
+ path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
+
+ this._addToNodeFs(path, initialAdd, wh, depth + 1);
+ }
+ }).on(EV_ERROR$2, this._boundHandleError);
+
+ return new Promise(resolve =>
+ stream.once(STR_END$2, () => {
+ if (this.fsw.closed) {
+ stream = undefined;
+ return;
+ }
+ const wasThrottled = throttler ? throttler.clear() : false;
+
+ resolve();
+
+ // Files that absent in current directory snapshot
+ // but present in previous emit `remove` event
+ // and are removed from @watched[directory].
+ previous.getChildren().filter((item) => {
+ return item !== directory &&
+ !current.has(item) &&
+ // in case of intersecting globs;
+ // a path may have been filtered out of this readdir, but
+ // shouldn't be removed because it matches a different glob
+ (!wh.hasGlob || wh.filterPath({
+ fullPath: sysPath$2.resolve(directory, item)
+ }));
+ }).forEach((item) => {
+ this.fsw._remove(directory, item);
+ });
+
+ stream = undefined;
+
+ // one more time for any missed in case changes came in extremely quickly
+ if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+ })
+ );
+}
+
+/**
+ * Read directory to add / remove files from `@watched` list and re-read it on change.
+ * @param {String} dir fs path
+ * @param {fs.Stats} stats
+ * @param {Boolean} initialAdd
+ * @param {Number} depth relative to user-supplied path
+ * @param {String} target child path targeted for watch
+ * @param {Object} wh Common watch helpers for this path
+ * @param {String} realpath
+ * @returns {Promise<Function>} closer for the watcher instance.
+ */
+async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+ const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+ const tracked = parentDir.has(sysPath$2.basename(dir));
+ if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+ if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
+ }
+
+ // ensure dir is tracked (harmless if redundant)
+ parentDir.add(sysPath$2.basename(dir));
+ this.fsw._getWatchedDir(dir);
+ let throttler;
+ let closer;
+
+ const oDepth = this.fsw.options.depth;
+ if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+ if (!target) {
+ await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+ if (this.fsw.closed) return;
+ }
+
+ closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+ // if current directory is removed, do nothing
+ if (stats && stats.mtimeMs === 0) return;
+
+ this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+ });
+ }
+ return closer;
+}
+
+/**
+ * Handle added file, directory, or glob pattern.
+ * Delegates call to _handleFile / _handleDir after checks.
+ * @param {String} path to file or ir
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @param {Object} priorWh depth relative to user-supplied path
+ * @param {Number} depth Child path actually targeted for watch
+ * @param {String=} target Child path actually targeted for watch
+ * @returns {Promise}
+ */
+async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+ const ready = this.fsw._emitReady;
+ if (this.fsw._isIgnored(path) || this.fsw.closed) {
+ ready();
+ return false;
+ }
+
+ const wh = this.fsw._getWatchHelpers(path, depth);
+ if (!wh.hasGlob && priorWh) {
+ wh.hasGlob = priorWh.hasGlob;
+ wh.globFilter = priorWh.globFilter;
+ wh.filterPath = entry => priorWh.filterPath(entry);
+ wh.filterDir = entry => priorWh.filterDir(entry);
+ }
+
+ // evaluate what is at the path we're being asked to watch
+ try {
+ const stats = await statMethods$1[wh.statMethod](wh.watchPath);
+ if (this.fsw.closed) return;
+ if (this.fsw._isIgnored(wh.watchPath, stats)) {
+ ready();
+ return false;
+ }
+
+ const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
+ let closer;
+ if (stats.isDirectory()) {
+ const absPath = sysPath$2.resolve(path);
+ const targetPath = follow ? await fsrealpath(path) : path;
+ if (this.fsw.closed) return;
+ closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+ if (this.fsw.closed) return;
+ // preserve this symlink's target path
+ if (absPath !== targetPath && targetPath !== undefined) {
+ this.fsw._symlinkPaths.set(absPath, targetPath);
+ }
+ } else if (stats.isSymbolicLink()) {
+ const targetPath = follow ? await fsrealpath(path) : path;
+ if (this.fsw.closed) return;
+ const parent = sysPath$2.dirname(wh.watchPath);
+ this.fsw._getWatchedDir(parent).add(wh.watchPath);
+ this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
+ closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+ if (this.fsw.closed) return;
+
+ // preserve this symlink's target path
+ if (targetPath !== undefined) {
+ this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
+ }
+ } else {
+ closer = this._handleFile(wh.watchPath, stats, initialAdd);
+ }
+ ready();
+
+ this.fsw._addPathCloser(path, closer);
+ return false;
+
+ } catch (error) {
+ if (this.fsw._handleError(error)) {
+ ready();
+ return path;
+ }
+ }
+}
+
+}
+
+var nodefsHandler = NodeFsHandler$1;
+
+var fseventsHandler = {exports: {}};
+
+const fs$7 = require$$0$3;
+const sysPath$1 = path$b;
+const { promisify: promisify$1 } = require$$0$4;
+
+let fsevents;
+try {
+ fsevents = undefined;
+} catch (error) {
+ if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+}
+
+if (fsevents) {
+ // TODO: real check
+ const mtch = process.version.match(/v(\d+)\.(\d+)/);
+ if (mtch && mtch[1] && mtch[2]) {
+ const maj = Number.parseInt(mtch[1], 10);
+ const min = Number.parseInt(mtch[2], 10);
+ if (maj === 8 && min < 16) {
+ fsevents = undefined;
+ }
+ }
+}
+
+const {
+ EV_ADD: EV_ADD$1,
+ EV_CHANGE: EV_CHANGE$1,
+ EV_ADD_DIR: EV_ADD_DIR$1,
+ EV_UNLINK: EV_UNLINK$1,
+ EV_ERROR: EV_ERROR$1,
+ STR_DATA,
+ STR_END: STR_END$1,
+ FSEVENT_CREATED,
+ FSEVENT_MODIFIED,
+ FSEVENT_DELETED,
+ FSEVENT_MOVED,
+ // FSEVENT_CLONED,
+ FSEVENT_UNKNOWN,
+ FSEVENT_TYPE_FILE,
+ FSEVENT_TYPE_DIRECTORY,
+ FSEVENT_TYPE_SYMLINK,
+
+ ROOT_GLOBSTAR,
+ DIR_SUFFIX,
+ DOT_SLASH,
+ FUNCTION_TYPE: FUNCTION_TYPE$1,
+ EMPTY_FN: EMPTY_FN$1,
+ IDENTITY_FN
+} = constants$1;
+
+const Depth = (value) => isNaN(value) ? {} : {depth: value};
+
+const stat$1 = promisify$1(fs$7.stat);
+const lstat = promisify$1(fs$7.lstat);
+const realpath$1 = promisify$1(fs$7.realpath);
+
+const statMethods = { stat: stat$1, lstat };
+
+/**
+ * @typedef {String} Path
+ */
+
+/**
+ * @typedef {Object} FsEventsWatchContainer
+ * @property {Set<Function>} listeners
+ * @property {Function} rawEmitter
+ * @property {{stop: Function}} watcher
+ */
+
+// fsevents instance helper functions
+/**
+ * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+ * @type {Map<Path,FsEventsWatchContainer>}
+ */
+const FSEventsWatchers = new Map();
+
+// Threshold of duplicate path prefixes at which to start
+// consolidating going forward
+const consolidateThreshhold = 10;
+
+const wrongEventFlags = new Set([
+ 69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
+]);
+
+/**
+ * Instantiates the fsevents interface
+ * @param {Path} path path to be watched
+ * @param {Function} callback called when fsevents is bound and ready
+ * @returns {{stop: Function}} new fsevents instance
+ */
+const createFSEventsInstance = (path, callback) => {
+ const stop = fsevents.watch(path, callback);
+ return {stop};
+};
+
+/**
+ * Instantiates the fsevents interface or binds listeners to an existing one covering
+ * the same file tree.
+ * @param {Path} path - to be watched
+ * @param {Path} realPath - real path for symlinks
+ * @param {Function} listener - called when fsevents emits events
+ * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+ * @returns {Function} closer
+ */
+function setFSEventsListener(path, realPath, listener, rawEmitter) {
+ let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
+
+ const parentPath = sysPath$1.dirname(watchPath);
+ let cont = FSEventsWatchers.get(watchPath);
+
+ // If we've accumulated a substantial number of paths that
+ // could have been consolidated by watching one directory
+ // above the current one, create a watcher on the parent
+ // path instead, so that we do consolidate going forward.
+ if (couldConsolidate(parentPath)) {
+ watchPath = parentPath;
+ }
+
+ const resolvedPath = sysPath$1.resolve(path);
+ const hasSymlink = resolvedPath !== realPath;
+
+ const filteredListener = (fullPath, flags, info) => {
+ if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+ if (
+ fullPath === resolvedPath ||
+ !fullPath.indexOf(resolvedPath + sysPath$1.sep)
+ ) listener(fullPath, flags, info);
+ };
+
+ // check if there is already a watcher on a parent path
+ // modifies `watchPath` to the parent path when it finds a match
+ let watchedParent = false;
+ for (const watchedPath of FSEventsWatchers.keys()) {
+ if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
+ watchPath = watchedPath;
+ cont = FSEventsWatchers.get(watchPath);
+ watchedParent = true;
+ break;
+ }
+ }
+
+ if (cont || watchedParent) {
+ cont.listeners.add(filteredListener);
+ } else {
+ cont = {
+ listeners: new Set([filteredListener]),
+ rawEmitter,
+ watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+ if (!cont.listeners.size) return;
+ const info = fsevents.getInfo(fullPath, flags);
+ cont.listeners.forEach(list => {
+ list(fullPath, flags, info);
+ });
+
+ cont.rawEmitter(info.event, fullPath, info);
+ })
+ };
+ FSEventsWatchers.set(watchPath, cont);
+ }
+
+ // removes this instance's listeners and closes the underlying fsevents
+ // instance if there are no more listeners left
+ return () => {
+ const lst = cont.listeners;
+
+ lst.delete(filteredListener);
+ if (!lst.size) {
+ FSEventsWatchers.delete(watchPath);
+ if (cont.watcher) return cont.watcher.stop().then(() => {
+ cont.rawEmitter = cont.watcher = undefined;
+ Object.freeze(cont);
+ });
+ }
+ };
+}
+
+// Decide whether or not we should start a new higher-level
+// parent watcher
+const couldConsolidate = (path) => {
+ let count = 0;
+ for (const watchPath of FSEventsWatchers.keys()) {
+ if (watchPath.indexOf(path) === 0) {
+ count++;
+ if (count >= consolidateThreshhold) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+};
+
+// returns boolean indicating whether fsevents can be used
+const canUse = () => fsevents && FSEventsWatchers.size < 128;
+
+// determines subdirectory traversal levels from root to path
+const calcDepth = (path, root) => {
+ let i = 0;
+ while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
+ return i;
+};
+
+// returns boolean indicating whether the fsevents' event info has the same type
+// as the one returned by fs.stat
+const sameTypes = (info, stats) => (
+ info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+ info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+ info.type === FSEVENT_TYPE_FILE && stats.isFile()
+);
+
+/**
+ * @mixin
+ */
+class FsEventsHandler$1 {
+
+/**
+ * @param {import('../index').FSWatcher} fsw
+ */
+constructor(fsw) {
+ this.fsw = fsw;
+}
+checkIgnored(path, stats) {
+ const ipaths = this.fsw._ignoredPaths;
+ if (this.fsw._isIgnored(path, stats)) {
+ ipaths.add(path);
+ if (stats && stats.isDirectory()) {
+ ipaths.add(path + ROOT_GLOBSTAR);
+ }
+ return true;
+ }
+
+ ipaths.delete(path);
+ ipaths.delete(path + ROOT_GLOBSTAR);
+}
+
+addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+ const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
+ this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+}
+
+async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+ try {
+ const stats = await stat$1(path);
+ if (this.fsw.closed) return;
+ if (sameTypes(info, stats)) {
+ this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ } else {
+ this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ }
+ } catch (error) {
+ if (error.code === 'EACCES') {
+ this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ } else {
+ this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ }
+ }
+}
+
+handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+ if (this.fsw.closed || this.checkIgnored(path)) return;
+
+ if (event === EV_UNLINK$1) {
+ const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+ // suppress unlink events on never before seen files
+ if (isDirectory || watchedDir.has(item)) {
+ this.fsw._remove(parent, item, isDirectory);
+ }
+ } else {
+ if (event === EV_ADD$1) {
+ // track new directories
+ if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+
+ if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+ // push symlinks back to the top of the stack to get handled
+ const curDepth = opts.depth === undefined ?
+ undefined : calcDepth(fullPath, realPath) + 1;
+ return this._addToFsEvents(path, false, true, curDepth);
+ }
+
+ // track new paths
+ // (other than symlinks being followed, which will be tracked soon)
+ this.fsw._getWatchedDir(parent).add(item);
+ }
+ /**
+ * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+ */
+ const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+ this.fsw._emit(eventName, path);
+ if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
+ }
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} watchPath - file/dir path to be watched with fsevents
+ * @param {String} realPath - real path (in case of symlinks)
+ * @param {Function} transform - path transformer
+ * @param {Function} globFilter - path filter in case a glob pattern was provided
+ * @returns {Function} closer for the watcher instance
+*/
+_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+ if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+ const opts = this.fsw.options;
+ const watchCallback = async (fullPath, flags, info) => {
+ if (this.fsw.closed) return;
+ if (
+ opts.depth !== undefined &&
+ calcDepth(fullPath, realPath) > opts.depth
+ ) return;
+ const path = transform(sysPath$1.join(
+ watchPath, sysPath$1.relative(watchPath, fullPath)
+ ));
+ if (globFilter && !globFilter(path)) return;
+ // ensure directories are tracked
+ const parent = sysPath$1.dirname(path);
+ const item = sysPath$1.basename(path);
+ const watchedDir = this.fsw._getWatchedDir(
+ info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+ );
+
+ // correct for wrong events emitted
+ if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
+ if (typeof opts.ignored === FUNCTION_TYPE$1) {
+ let stats;
+ try {
+ stats = await stat$1(path);
+ } catch (error) {}
+ if (this.fsw.closed) return;
+ if (this.checkIgnored(path, stats)) return;
+ if (sameTypes(info, stats)) {
+ this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ } else {
+ this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ }
+ } else {
+ this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ }
+ } else {
+ switch (info.event) {
+ case FSEVENT_CREATED:
+ case FSEVENT_MODIFIED:
+ return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ case FSEVENT_DELETED:
+ case FSEVENT_MOVED:
+ return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+ }
+ }
+ };
+
+ const closer = setFSEventsListener(
+ watchPath,
+ realPath,
+ watchCallback,
+ this.fsw._emitRaw
+ );
+
+ this.fsw._emitReady();
+ return closer;
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} linkPath path to symlink
+ * @param {String} fullPath absolute path to the symlink
+ * @param {Function} transform pre-existing path transformer
+ * @param {Number} curDepth level of subdirectories traversed to where symlink is
+ * @returns {Promise<void>}
+ */
+async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+ // don't follow the same symlink more than once
+ if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+
+ this.fsw._symlinkPaths.set(fullPath, true);
+ this.fsw._incrReadyCount();
+
+ try {
+ const linkTarget = await realpath$1(linkPath);
+ if (this.fsw.closed) return;
+ if (this.fsw._isIgnored(linkTarget)) {
+ return this.fsw._emitReady();
+ }
+
+ this.fsw._incrReadyCount();
+
+ // add the linkTarget for watching with a wrapper for transform
+ // that causes emitted paths to incorporate the link's path
+ this._addToFsEvents(linkTarget || linkPath, (path) => {
+ let aliasedPath = linkPath;
+ if (linkTarget && linkTarget !== DOT_SLASH) {
+ aliasedPath = path.replace(linkTarget, linkPath);
+ } else if (path !== DOT_SLASH) {
+ aliasedPath = sysPath$1.join(linkPath, path);
+ }
+ return transform(aliasedPath);
+ }, false, curDepth);
+ } catch(error) {
+ if (this.fsw._handleError(error)) {
+ return this.fsw._emitReady();
+ }
+ }
+}
+
+/**
+ *
+ * @param {Path} newPath
+ * @param {fs.Stats} stats
+ */
+emitAdd(newPath, stats, processPath, opts, forceAdd) {
+ const pp = processPath(newPath);
+ const isDir = stats.isDirectory();
+ const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+ const base = sysPath$1.basename(pp);
+
+ // ensure empty dirs get tracked
+ if (isDir) this.fsw._getWatchedDir(pp);
+ if (dirObj.has(base)) return;
+ dirObj.add(base);
+
+ if (!opts.ignoreInitial || forceAdd === true) {
+ this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
+ }
+}
+
+initWatch(realPath, path, wh, processPath) {
+ if (this.fsw.closed) return;
+ const closer = this._watchWithFsEvents(
+ wh.watchPath,
+ sysPath$1.resolve(realPath || wh.watchPath),
+ processPath,
+ wh.globFilter
+ );
+ this.fsw._addPathCloser(path, closer);
+}
+
+/**
+ * Handle added path with fsevents
+ * @param {String} path file/dir path or glob pattern
+ * @param {Function|Boolean=} transform converts working path to what the user expects
+ * @param {Boolean=} forceAdd ensure add is emitted
+ * @param {Number=} priorDepth Level of subdirectories already traversed.
+ * @returns {Promise<void>}
+ */
+async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+ if (this.fsw.closed) {
+ return;
+ }
+ const opts = this.fsw.options;
+ const processPath = typeof transform === FUNCTION_TYPE$1 ? transform : IDENTITY_FN;
+
+ const wh = this.fsw._getWatchHelpers(path);
+
+ // evaluate what is at the path we're being asked to watch
+ try {
+ const stats = await statMethods[wh.statMethod](wh.watchPath);
+ if (this.fsw.closed) return;
+ if (this.fsw._isIgnored(wh.watchPath, stats)) {
+ throw null;
+ }
+ if (stats.isDirectory()) {
+ // emit addDir unless this is a glob parent
+ if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+
+ // don't recurse further if it would exceed depth setting
+ if (priorDepth && priorDepth > opts.depth) return;
+
+ // scan the contents of the dir
+ this.fsw._readdirp(wh.watchPath, {
+ fileFilter: entry => wh.filterPath(entry),
+ directoryFilter: entry => wh.filterDir(entry),
+ ...Depth(opts.depth - (priorDepth || 0))
+ }).on(STR_DATA, (entry) => {
+ // need to check filterPath on dirs b/c filterDir is less restrictive
+ if (this.fsw.closed) {
+ return;
+ }
+ if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+
+ const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
+ const {fullPath} = entry;
+
+ if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+ // preserve the current depth here since it can't be derived from
+ // real paths past the symlink
+ const curDepth = opts.depth === undefined ?
+ undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
+
+ this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+ } else {
+ this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+ }
+ }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
+ this.fsw._emitReady();
+ });
+ } else {
+ this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+ this.fsw._emitReady();
+ }
+ } catch (error) {
+ if (!error || this.fsw._handleError(error)) {
+ // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
+ this.fsw._emitReady();
+ this.fsw._emitReady();
+ }
+ }
+
+ if (opts.persistent && forceAdd !== true) {
+ if (typeof transform === FUNCTION_TYPE$1) {
+ // realpath has already been resolved
+ this.initWatch(undefined, path, wh, processPath);
+ } else {
+ let realPath;
+ try {
+ realPath = await realpath$1(wh.watchPath);
+ } catch (e) {}
+ this.initWatch(realPath, path, wh, processPath);
+ }
+ }
+}
+
+}
+
+fseventsHandler.exports = FsEventsHandler$1;
+fseventsHandler.exports.canUse = canUse;
+
+const { EventEmitter } = require$$0$5;
+const fs$6 = require$$0$3;
+const sysPath = path$b;
+const { promisify } = require$$0$4;
+const readdirp = readdirp_1;
+const anymatch = anymatch$2.exports.default;
+const globParent = globParent$1;
+const isGlob = isGlob$2;
+const braces = braces_1;
+const normalizePath = normalizePath$2;
+
+const NodeFsHandler = nodefsHandler;
+const FsEventsHandler = fseventsHandler.exports;
+const {
+ EV_ALL,
+ EV_READY,
+ EV_ADD,
+ EV_CHANGE,
+ EV_UNLINK,
+ EV_ADD_DIR,
+ EV_UNLINK_DIR,
+ EV_RAW,
+ EV_ERROR,
+
+ STR_CLOSE,
+ STR_END,
+
+ BACK_SLASH_RE,
+ DOUBLE_SLASH_RE,
+ SLASH_OR_BACK_SLASH_RE,
+ DOT_RE,
+ REPLACER_RE,
+
+ SLASH: SLASH$1,
+ SLASH_SLASH,
+ BRACE_START,
+ BANG,
+ ONE_DOT,
+ TWO_DOTS,
+ GLOBSTAR: GLOBSTAR$1,
+ SLASH_GLOBSTAR,
+ ANYMATCH_OPTS,
+ STRING_TYPE,
+ FUNCTION_TYPE,
+ EMPTY_STR,
+ EMPTY_FN,
+
+ isWindows: isWindows$2,
+ isMacos,
+ isIBMi
+} = constants$1;
+
+const stat = promisify(fs$6.stat);
+const readdir = promisify(fs$6.readdir);
+
+/**
+ * @typedef {String} Path
+ * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+ * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+ */
+
+/**
+ *
+ * @typedef {Object} WatchHelpers
+ * @property {Boolean} followSymlinks
+ * @property {'stat'|'lstat'} statMethod
+ * @property {Path} path
+ * @property {Path} watchPath
+ * @property {Function} entryPath
+ * @property {Boolean} hasGlob
+ * @property {Object} globFilter
+ * @property {Function} filterPath
+ * @property {Function} filterDir
+ */
+
+const arrify = (value = []) => Array.isArray(value) ? value : [value];
+const flatten$1 = (list, result = []) => {
+ list.forEach(item => {
+ if (Array.isArray(item)) {
+ flatten$1(item, result);
+ } else {
+ result.push(item);
+ }
+ });
+ return result;
+};
+
+const unifyPaths = (paths_) => {
+ /**
+ * @type {Array<String>}
+ */
+ const paths = flatten$1(arrify(paths_));
+ if (!paths.every(p => typeof p === STRING_TYPE)) {
+ throw new TypeError(`Non-string provided as watch path: ${paths}`);
+ }
+ return paths.map(normalizePathToUnix);
+};
+
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+// because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+ let str = string.replace(BACK_SLASH_RE, SLASH$1);
+ let prepend = false;
+ if (str.startsWith(SLASH_SLASH)) {
+ prepend = true;
+ }
+ while (str.match(DOUBLE_SLASH_RE)) {
+ str = str.replace(DOUBLE_SLASH_RE, SLASH$1);
+ }
+ if (prepend) {
+ str = SLASH$1 + str;
+ }
+ return str;
+};
+
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+
+const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+ if (typeof path !== STRING_TYPE) return path;
+ return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+};
+
+const getAbsolutePath = (path, cwd) => {
+ if (sysPath.isAbsolute(path)) {
+ return path;
+ }
+ if (path.startsWith(BANG)) {
+ return BANG + sysPath.join(cwd, path.slice(1));
+ }
+ return sysPath.join(cwd, path);
+};
+
+const undef = (opts, key) => opts[key] === undefined;
+
+/**
+ * Directory entry.
+ * @property {Path} path
+ * @property {Set<Path>} items
+ */
+class DirEntry {
+ /**
+ * @param {Path} dir
+ * @param {Function} removeWatcher
+ */
+ constructor(dir, removeWatcher) {
+ this.path = dir;
+ this._removeWatcher = removeWatcher;
+ /** @type {Set<Path>} */
+ this.items = new Set();
+ }
+
+ add(item) {
+ const {items} = this;
+ if (!items) return;
+ if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+ }
+
+ async remove(item) {
+ const {items} = this;
+ if (!items) return;
+ items.delete(item);
+ if (items.size > 0) return;
+
+ const dir = this.path;
+ try {
+ await readdir(dir);
+ } catch (err) {
+ if (this._removeWatcher) {
+ this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+ }
+ }
+ }
+
+ has(item) {
+ const {items} = this;
+ if (!items) return;
+ return items.has(item);
+ }
- if (typeof done !== 'function') {
- throw new Error('Expected function as last argument, not ' + done)
+ /**
+ * @returns {Array<String>}
+ */
+ getChildren() {
+ const {items} = this;
+ if (!items) return;
+ return [...items.values()];
+ }
+
+ dispose() {
+ this.items.clear();
+ delete this.path;
+ delete this._removeWatcher;
+ delete this.items;
+ Object.freeze(this);
+ }
+}
+
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+ constructor(path, watchPath, follow, fsw) {
+ this.fsw = fsw;
+ this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+ this.watchPath = watchPath;
+ this.fullWatchPath = sysPath.resolve(watchPath);
+ this.hasGlob = watchPath !== path;
+ /** @type {object|boolean} */
+ if (path === EMPTY_STR) this.hasGlob = false;
+ this.globSymlink = this.hasGlob && follow ? undefined : false;
+ this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
+ this.dirParts = this.getDirParts(path);
+ this.dirParts.forEach((parts) => {
+ if (parts.length > 1) parts.pop();
+ });
+ this.followSymlinks = follow;
+ this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+ }
+
+ checkGlobSymlink(entry) {
+ // only need to resolve once
+ // first entry should always have entry.parentDir === EMPTY_STR
+ if (this.globSymlink === undefined) {
+ this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
+ false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+ }
+
+ if (this.globSymlink) {
+ return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+ }
+
+ return entry.fullPath;
+ }
+
+ entryPath(entry) {
+ return sysPath.join(this.watchPath,
+ sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+ );
+ }
+
+ filterPath(entry) {
+ const {stats} = entry;
+ if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+ const resolvedPath = this.entryPath(entry);
+ const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
+ this.globFilter(resolvedPath) : true;
+ return matchesGlob &&
+ this.fsw._isntIgnored(resolvedPath, stats) &&
+ this.fsw._hasReadPermissions(stats);
+ }
+
+ getDirParts(path) {
+ if (!this.hasGlob) return [];
+ const parts = [];
+ const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+ expandedPath.forEach((path) => {
+ parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+ });
+ return parts;
+ }
+
+ filterDir(entry) {
+ if (this.hasGlob) {
+ const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+ let globstar = false;
+ this.unmatchedGlob = !this.dirParts.some((parts) => {
+ return parts.every((part, i) => {
+ if (part === GLOBSTAR$1) globstar = true;
+ return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+ });
+ });
}
+ return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+ }
+}
- next.apply(null, [null].concat(input));
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ * new FSWatcher()
+ * .add(directories)
+ * .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends EventEmitter {
+// Not indenting methods for history sake; for now.
+constructor(_opts) {
+ super();
- // Run the next `fn`, if any.
- function next(err) {
- var fn = fns[++index];
- var params = slice$3.call(arguments, 0);
- var values = params.slice(1);
- var length = input.length;
- var pos = -1;
+ const opts = {};
+ if (_opts) Object.assign(opts, _opts); // for frozen objects
+ /** @type {Map<String, DirEntry>} */
+ this._watched = new Map();
+ /** @type {Map<String, Array>} */
+ this._closers = new Map();
+ /** @type {Set<String>} */
+ this._ignoredPaths = new Set();
+
+ /** @type {Map<ThrottleType, Map>} */
+ this._throttled = new Map();
+
+ /** @type {Map<Path, String|Boolean>} */
+ this._symlinkPaths = new Map();
+
+ this._streams = new Set();
+ this.closed = false;
+
+ // Set up default options.
+ if (undef(opts, 'persistent')) opts.persistent = true;
+ if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
+ if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
+ if (undef(opts, 'interval')) opts.interval = 100;
+ if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
+ if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
+ opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+
+ // Enable fsevents on OS X when polling isn't explicitly enabled.
+ if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+
+ // If we can't use fsevents, ensure the options reflect it's disabled.
+ const canUseFsEvents = FsEventsHandler.canUse();
+ if (!canUseFsEvents) opts.useFsEvents = false;
+
+ // Use polling on Mac if not using fsevents.
+ // Other platforms use non-polling fs_watch.
+ if (undef(opts, 'usePolling') && !opts.useFsEvents) {
+ opts.usePolling = isMacos;
+ }
+
+ // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+ if(isIBMi) {
+ opts.usePolling = true;
+ }
+
+ // Global override (useful for end-developers that need to force polling for all
+ // instances of chokidar, regardless of usage/dependency depth)
+ const envPoll = process.env.CHOKIDAR_USEPOLLING;
+ if (envPoll !== undefined) {
+ const envLower = envPoll.toLowerCase();
+
+ if (envLower === 'false' || envLower === '0') {
+ opts.usePolling = false;
+ } else if (envLower === 'true' || envLower === '1') {
+ opts.usePolling = true;
+ } else {
+ opts.usePolling = !!envLower;
+ }
+ }
+ const envInterval = process.env.CHOKIDAR_INTERVAL;
+ if (envInterval) {
+ opts.interval = Number.parseInt(envInterval, 10);
+ }
+
+ // Editor atomic write normalization enabled by default with fs.watch
+ if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+ if (opts.atomic) this._pendingUnlinks = new Map();
+
+ if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+
+ if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
+ if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+ const awf = opts.awaitWriteFinish;
+ if (awf) {
+ if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
+ if (!awf.pollInterval) awf.pollInterval = 100;
+ this._pendingWrites = new Map();
+ }
+ if (opts.ignored) opts.ignored = arrify(opts.ignored);
+
+ let readyCalls = 0;
+ this._emitReady = () => {
+ readyCalls++;
+ if (readyCalls >= this._readyCount) {
+ this._emitReady = EMPTY_FN;
+ this._readyEmitted = true;
+ // use process.nextTick to allow time for listener to be bound
+ process.nextTick(() => this.emit(EV_READY));
+ }
+ };
+ this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+ this._readyEmitted = false;
+ this.options = opts;
+
+ // Initialize with proper watcher.
+ if (opts.useFsEvents) {
+ this._fsEventsHandler = new FsEventsHandler(this);
+ } else {
+ this._nodeFsHandler = new NodeFsHandler(this);
+ }
+
+ // You’re frozen when your heart’s not open.
+ Object.freeze(opts);
+}
+
+// Public methods
+
+/**
+ * Adds paths to be watched on an existing FSWatcher instance
+ * @param {Path|Array<Path>} paths_
+ * @param {String=} _origAdd private; for handling non-existent paths to be watched
+ * @param {Boolean=} _internal private; indicates a non-user add
+ * @returns {FSWatcher} for chaining
+ */
+add(paths_, _origAdd, _internal) {
+ const {cwd, disableGlobbing} = this.options;
+ this.closed = false;
+ let paths = unifyPaths(paths_);
+ if (cwd) {
+ paths = paths.map((path) => {
+ const absPath = getAbsolutePath(path, cwd);
+
+ // Check `path` instead of `absPath` because the cwd portion can't be a glob
+ if (disableGlobbing || !isGlob(path)) {
+ return absPath;
+ }
+ return normalizePath(absPath);
+ });
+ }
+
+ // set aside negated glob strings
+ paths = paths.filter((path) => {
+ if (path.startsWith(BANG)) {
+ this._ignoredPaths.add(path.slice(1));
+ return false;
+ }
+
+ // if a path is being added that was previously ignored, stop ignoring it
+ this._ignoredPaths.delete(path);
+ this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+
+ // reset the cached userIgnored anymatch fn
+ // to make ignoredPaths changes effective
+ this._userIgnored = undefined;
+
+ return true;
+ });
+
+ if (this.options.useFsEvents && this._fsEventsHandler) {
+ if (!this._readyCount) this._readyCount = paths.length;
+ if (this.options.persistent) this._readyCount *= 2;
+ paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+ } else {
+ if (!this._readyCount) this._readyCount = 0;
+ this._readyCount += paths.length;
+ Promise.all(
+ paths.map(async path => {
+ const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+ if (res) this._emitReady();
+ return res;
+ })
+ ).then(results => {
+ if (this.closed) return;
+ results.filter(item => item).forEach(item => {
+ this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+ });
+ });
+ }
+
+ return this;
+}
+
+/**
+ * Close watchers or start ignoring events from specified paths.
+ * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+ * @returns {FSWatcher} for chaining
+*/
+unwatch(paths_) {
+ if (this.closed) return this;
+ const paths = unifyPaths(paths_);
+ const {cwd} = this.options;
+
+ paths.forEach((path) => {
+ // convert to absolute path unless relative path already matches
+ if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+ if (cwd) path = sysPath.join(cwd, path);
+ path = sysPath.resolve(path);
+ }
+
+ this._closePath(path);
+
+ this._ignoredPaths.add(path);
+ if (this._watched.has(path)) {
+ this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+ }
+
+ // reset the cached userIgnored anymatch fn
+ // to make ignoredPaths changes effective
+ this._userIgnored = undefined;
+ });
+
+ return this;
+}
+
+/**
+ * Close watchers and remove all listeners from watched paths.
+ * @returns {Promise<void>}.
+*/
+close() {
+ if (this.closed) return this._closePromise;
+ this.closed = true;
+
+ // Memory management.
+ this.removeAllListeners();
+ const closers = [];
+ this._closers.forEach(closerList => closerList.forEach(closer => {
+ const promise = closer();
+ if (promise instanceof Promise) closers.push(promise);
+ }));
+ this._streams.forEach(stream => stream.destroy());
+ this._userIgnored = undefined;
+ this._readyCount = 0;
+ this._readyEmitted = false;
+ this._watched.forEach(dirent => dirent.dispose());
+ ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
+ this[`_${key}`].clear();
+ });
+
+ this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+ return this._closePromise;
+}
+
+/**
+ * Expose list of watched paths
+ * @returns {Object} for chaining
+*/
+getWatched() {
+ const watchList = {};
+ this._watched.forEach((entry, dir) => {
+ const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+ watchList[key || ONE_DOT] = entry.getChildren().sort();
+ });
+ return watchList;
+}
+
+emitWithAll(event, args) {
+ this.emit(...args);
+ if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+}
+
+// Common helpers
+// --------------
+
+/**
+ * Normalize and emit events.
+ * Calling _emit DOES NOT MEAN emit() would be called!
+ * @param {EventName} event Type of event
+ * @param {Path} path File or directory path
+ * @param {*=} val1 arguments to be passed with event
+ * @param {*=} val2
+ * @param {*=} val3
+ * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+async _emit(event, path, val1, val2, val3) {
+ if (this.closed) return;
+
+ const opts = this.options;
+ if (isWindows$2) path = sysPath.normalize(path);
+ if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+ /** @type Array<any> */
+ const args = [event, path];
+ if (val3 !== undefined) args.push(val1, val2, val3);
+ else if (val2 !== undefined) args.push(val1, val2);
+ else if (val1 !== undefined) args.push(val1);
+
+ const awf = opts.awaitWriteFinish;
+ let pw;
+ if (awf && (pw = this._pendingWrites.get(path))) {
+ pw.lastChange = new Date();
+ return this;
+ }
+
+ if (opts.atomic) {
+ if (event === EV_UNLINK) {
+ this._pendingUnlinks.set(path, args);
+ setTimeout(() => {
+ this._pendingUnlinks.forEach((entry, path) => {
+ this.emit(...entry);
+ this.emit(EV_ALL, ...entry);
+ this._pendingUnlinks.delete(path);
+ });
+ }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+ return this;
+ }
+ if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+ event = args[0] = EV_CHANGE;
+ this._pendingUnlinks.delete(path);
+ }
+ }
+
+ if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+ const awfEmit = (err, stats) => {
if (err) {
- done(err);
+ event = args[0] = EV_ERROR;
+ args[1] = err;
+ this.emitWithAll(event, args);
+ } else if (stats) {
+ // if stats doesn't exist the file must have been deleted
+ if (args.length > 2) {
+ args[2] = stats;
+ } else {
+ args.push(stats);
+ }
+ this.emitWithAll(event, args);
+ }
+ };
+
+ this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+ return this;
+ }
+
+ if (event === EV_CHANGE) {
+ const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+ if (isThrottled) return this;
+ }
+
+ if (opts.alwaysStat && val1 === undefined &&
+ (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
+ ) {
+ const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+ let stats;
+ try {
+ stats = await stat(fullPath);
+ } catch (err) {}
+ // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+ if (!stats || this.closed) return;
+ args.push(stats);
+ }
+ this.emitWithAll(event, args);
+
+ return this;
+}
+
+/**
+ * Common handler for errors
+ * @param {Error} error
+ * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+_handleError(error) {
+ const code = error && error.code;
+ if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
+ (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
+ ) {
+ this.emit(EV_ERROR, error);
+ }
+ return error || this.closed;
+}
+
+/**
+ * Helper utility for throttling
+ * @param {ThrottleType} actionType type being throttled
+ * @param {Path} path being acted upon
+ * @param {Number} timeout duration of time to suppress duplicate actions
+ * @returns {Object|false} tracking object or false if action should be suppressed
+ */
+_throttle(actionType, path, timeout) {
+ if (!this._throttled.has(actionType)) {
+ this._throttled.set(actionType, new Map());
+ }
+
+ /** @type {Map<Path, Object>} */
+ const action = this._throttled.get(actionType);
+ /** @type {Object} */
+ const actionPath = action.get(path);
+
+ if (actionPath) {
+ actionPath.count++;
+ return false;
+ }
+
+ let timeoutObject;
+ const clear = () => {
+ const item = action.get(path);
+ const count = item ? item.count : 0;
+ action.delete(path);
+ clearTimeout(timeoutObject);
+ if (item) clearTimeout(item.timeoutObject);
+ return count;
+ };
+ timeoutObject = setTimeout(clear, timeout);
+ const thr = {timeoutObject, clear, count: 0};
+ action.set(path, thr);
+ return thr;
+}
+
+_incrReadyCount() {
+ return this._readyCount++;
+}
+
+/**
+ * Awaits write operation to finish.
+ * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+ * @param {Path} path being acted upon
+ * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+ * @param {EventName} event
+ * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+ */
+_awaitWriteFinish(path, threshold, event, awfEmit) {
+ let timeoutHandler;
+
+ let fullPath = path;
+ if (this.options.cwd && !sysPath.isAbsolute(path)) {
+ fullPath = sysPath.join(this.options.cwd, path);
+ }
+
+ const now = new Date();
+
+ const awaitWriteFinish = (prevStat) => {
+ fs$6.stat(fullPath, (err, curStat) => {
+ if (err || !this._pendingWrites.has(path)) {
+ if (err && err.code !== 'ENOENT') awfEmit(err);
+ return;
+ }
+
+ const now = Number(new Date());
+
+ if (prevStat && curStat.size !== prevStat.size) {
+ this._pendingWrites.get(path).lastChange = now;
+ }
+ const pw = this._pendingWrites.get(path);
+ const df = now - pw.lastChange;
+
+ if (df >= threshold) {
+ this._pendingWrites.delete(path);
+ awfEmit(undefined, curStat);
+ } else {
+ timeoutHandler = setTimeout(
+ awaitWriteFinish,
+ this.options.awaitWriteFinish.pollInterval,
+ curStat
+ );
+ }
+ });
+ };
+
+ if (!this._pendingWrites.has(path)) {
+ this._pendingWrites.set(path, {
+ lastChange: now,
+ cancelWait: () => {
+ this._pendingWrites.delete(path);
+ clearTimeout(timeoutHandler);
+ return event;
+ }
+ });
+ timeoutHandler = setTimeout(
+ awaitWriteFinish,
+ this.options.awaitWriteFinish.pollInterval
+ );
+ }
+}
+
+_getGlobIgnored() {
+ return [...this._ignoredPaths.values()];
+}
+
+/**
+ * Determines whether user has asked to ignore this path.
+ * @param {Path} path filepath or dir
+ * @param {fs.Stats=} stats result of fs.stat
+ * @returns {Boolean}
+ */
+_isIgnored(path, stats) {
+ if (this.options.atomic && DOT_RE.test(path)) return true;
+ if (!this._userIgnored) {
+ const {cwd} = this.options;
+ const ign = this.options.ignored;
+
+ const ignored = ign && ign.map(normalizeIgnored(cwd));
+ const paths = arrify(ignored)
+ .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+ .map((path) => path + SLASH_GLOBSTAR);
+ const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+ this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+ }
+
+ return this._userIgnored([path, stats]);
+}
+
+_isntIgnored(path, stat) {
+ return !this._isIgnored(path, stat);
+}
+
+/**
+ * Provides a set of common helpers and properties relating to symlink and glob handling.
+ * @param {Path} path file, directory, or glob pattern being watched
+ * @param {Number=} depth at any depth > 0, this isn't a glob
+ * @returns {WatchHelper} object containing helpers for this path
+ */
+_getWatchHelpers(path, depth) {
+ const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+ const follow = this.options.followSymlinks;
+
+ return new WatchHelper(path, watchPath, follow, this);
+}
+
+// Directory helpers
+// -----------------
+
+/**
+ * Provides directory tracking objects
+ * @param {String} directory path of the directory
+ * @returns {DirEntry} the directory's tracking object
+ */
+_getWatchedDir(directory) {
+ if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+ const dir = sysPath.resolve(directory);
+ if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+ return this._watched.get(dir);
+}
+
+// File helpers
+// ------------
+
+/**
+ * Check for read permissions.
+ * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+ * @param {fs.Stats} stats - object, result of fs_stat
+ * @returns {Boolean} indicates whether the file can be read
+*/
+_hasReadPermissions(stats) {
+ if (this.options.ignorePermissionErrors) return true;
+
+ // stats.mode may be bigint
+ const md = stats && Number.parseInt(stats.mode, 10);
+ const st = md & 0o777;
+ const it = Number.parseInt(st.toString(8)[0], 10);
+ return Boolean(4 & it);
+}
+
+/**
+ * Handles emitting unlink events for
+ * files and directories, and via recursion, for
+ * files and directories within directories that are unlinked
+ * @param {String} directory within which the following item is located
+ * @param {String} item base path of item/directory
+ * @returns {void}
+*/
+_remove(directory, item, isDirectory) {
+ // if what is being deleted is a directory, get that directory's paths
+ // for recursive deleting and cleaning of watched object
+ // if it is not a directory, nestedDirectoryChildren will be empty array
+ const path = sysPath.join(directory, item);
+ const fullPath = sysPath.resolve(path);
+ isDirectory = isDirectory != null
+ ? isDirectory
+ : this._watched.has(path) || this._watched.has(fullPath);
+
+ // prevent duplicate handling in case of arriving here nearly simultaneously
+ // via multiple paths (such as _handleFile and _handleDir)
+ if (!this._throttle('remove', path, 100)) return;
+
+ // if the only watched file is removed, watch for its return
+ if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+ this.add(directory, item, true);
+ }
+
+ // This will create a new entry in the watched object in either case
+ // so we got to do the directory check beforehand
+ const wp = this._getWatchedDir(path);
+ const nestedDirectoryChildren = wp.getChildren();
+
+ // Recursively remove children directories / files.
+ nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+
+ // Check if item was on the watched list and remove it
+ const parent = this._getWatchedDir(directory);
+ const wasTracked = parent.has(item);
+ parent.remove(item);
+
+ // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+ // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+ // but never removed from the map in case the path was deleted.
+ // This leads to an incorrect state if the path was recreated:
+ // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+ if (this._symlinkPaths.has(fullPath)) {
+ this._symlinkPaths.delete(fullPath);
+ }
+
+ // If we wait for this file to be fully written, cancel the wait.
+ let relPath = path;
+ if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+ if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+ const event = this._pendingWrites.get(relPath).cancelWait();
+ if (event === EV_ADD) return;
+ }
+
+ // The Entry will either be a directory that just got removed
+ // or a bogus entry to a file, in either case we have to remove it
+ this._watched.delete(path);
+ this._watched.delete(fullPath);
+ const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+ if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+
+ // Avoid conflicts if we later create another file with the same name
+ if (!this.options.useFsEvents) {
+ this._closePath(path);
+ }
+}
+
+/**
+ * Closes all watchers for a path
+ * @param {Path} path
+ */
+_closePath(path) {
+ this._closeFile(path);
+ const dir = sysPath.dirname(path);
+ this._getWatchedDir(dir).remove(sysPath.basename(path));
+}
+
+/**
+ * Closes only file-specific watchers
+ * @param {Path} path
+ */
+_closeFile(path) {
+ const closers = this._closers.get(path);
+ if (!closers) return;
+ closers.forEach(closer => closer());
+ this._closers.delete(path);
+}
+
+/**
+ *
+ * @param {Path} path
+ * @param {Function} closer
+ */
+_addPathCloser(path, closer) {
+ if (!closer) return;
+ let list = this._closers.get(path);
+ if (!list) {
+ list = [];
+ this._closers.set(path, list);
+ }
+ list.push(closer);
+}
+
+_readdirp(root, opts) {
+ if (this.closed) return;
+ const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
+ let stream = readdirp(root, options);
+ this._streams.add(stream);
+ stream.once(STR_CLOSE, () => {
+ stream = undefined;
+ });
+ stream.once(STR_END, () => {
+ if (stream) {
+ this._streams.delete(stream);
+ stream = undefined;
+ }
+ });
+ return stream;
+}
+
+}
+
+// Export FSWatcher class
+chokidar.FSWatcher = FSWatcher;
+
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param {String|Array<String>} paths file/directory paths and/or globs
+ * @param {Object=} options chokidar opts
+ * @returns an instance of FSWatcher for chaining.
+ */
+const watch = (paths, options) => {
+ const watcher = new FSWatcher(options);
+ watcher.add(paths);
+ return watcher;
+};
+
+chokidar.watch = watch;
+
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ *
+ * @typedef Statistics
+ * @property {number} fatal Fatal errors (`fatal: true`)
+ * @property {number} warn warning errors (`fatal: false`)
+ * @property {number} info informational messages (`fatal: null|undefined`)
+ * @property {number} nonfatal warning + info
+ * @property {number} total nonfatal + fatal
+ */
+
+/**
+ * Get stats for a file, list of files, or list of messages.
+ *
+ * @param {Array.<VFile|VFileMessage>|VFile|VFileMessage} [value]
+ * @returns {Statistics}
+ */
+function statistics(value) {
+ var result = {true: 0, false: 0, null: 0};
+
+ if (value) {
+ if (Array.isArray(value)) {
+ list(value);
+ } else {
+ one(value);
+ }
+ }
+
+ return {
+ fatal: result.true,
+ nonfatal: result.false + result.null,
+ warn: result.false,
+ info: result.null,
+ total: result.true + result.false + result.null
+ }
+
+ /**
+ * @param {Array.<VFile|VFileMessage>} value
+ * @returns {void}
+ */
+ function list(value) {
+ var index = -1;
+
+ while (++index < value.length) {
+ one(value[index]);
+ }
+ }
+
+ /**
+ * @param {VFile|VFileMessage} value
+ * @returns {void}
+ */
+ function one(value) {
+ if ('messages' in value) return list(value.messages)
+
+ result[
+ value.fatal === undefined || value.fatal === null
+ ? null
+ : Boolean(value.fatal)
+ ]++;
+ }
+}
+
+/**
+ * @typedef {(error?: Error|null|undefined, ...output: any[]) => void} Callback
+ * @typedef {(...input: any[]) => any} Middleware
+ *
+ * @typedef {(...input: any[]) => void} Run Call all middleware.
+ * @typedef {(fn: Middleware) => Pipeline} Use Add `fn` (middleware) to the list.
+ * @typedef {{run: Run, use: Use}} Pipeline
+ */
+
+/**
+ * Create new middleware.
+ *
+ * @returns {Pipeline}
+ */
+function trough() {
+ /** @type {Middleware[]} */
+ const fns = [];
+ /** @type {Pipeline} */
+ const pipeline = {run, use};
+
+ return pipeline
+
+ /** @type {Run} */
+ function run(...values) {
+ let middlewareIndex = -1;
+ /** @type {Callback} */
+ const callback = values.pop();
+
+ if (typeof callback !== 'function') {
+ throw new TypeError('Expected function as last argument, not ' + callback)
+ }
+
+ next(null, ...values);
+
+ /**
+ * Run the next `fn`, or we’re done.
+ *
+ * @param {Error|null|undefined} error
+ * @param {any[]} output
+ */
+ function next(error, ...output) {
+ const fn = fns[++middlewareIndex];
+ let index = -1;
+
+ if (error) {
+ callback(error);
return
}
- // Copy non-nully input into values.
- while (++pos < length) {
- if (values[pos] === null || values[pos] === undefined) {
- values[pos] = input[pos];
+ // Copy non-nullish input into values.
+ while (++index < values.length) {
+ if (output[index] === null || output[index] === undefined) {
+ output[index] = values[index];
}
}
- input = values;
+ // Save the newly created `output` for the next call.
+ values = output;
// Next or done.
if (fn) {
- wrap$2(fn, next).apply(null, input);
+ wrap(fn, next)(...output);
} else {
- done.apply(null, [null].concat(input));
+ callback(null, ...output);
}
}
}
- // Add `fn` to the list.
- function use(fn) {
- if (typeof fn !== 'function') {
- throw new Error('Expected `fn` to be a function, not ' + fn)
+ /** @type {Use} */
+ function use(middelware) {
+ if (typeof middelware !== 'function') {
+ throw new TypeError(
+ 'Expected `middelware` to be a function, not ' + middelware
+ )
}
- fns.push(fn);
-
- return middleware
+ fns.push(middelware);
+ return pipeline
}
}
-var jsYaml$2 = {};
+/**
+ * Wrap `middleware`.
+ * Can be sync or async; return a promise, receive a callback, or return new
+ * values and errors.
+ *
+ * @param {Middleware} middleware
+ * @param {Callback} callback
+ */
+function wrap(middleware, callback) {
+ /** @type {boolean} */
+ let called;
+
+ return wrapped
+
+ /**
+ * Call `middleware`.
+ * @param {any[]} parameters
+ * @returns {void}
+ */
+ function wrapped(...parameters) {
+ const fnExpectsCallback = middleware.length > parameters.length;
+ /** @type {any} */
+ let result;
-var loader$2 = {};
+ if (fnExpectsCallback) {
+ parameters.push(done);
+ }
-var common$b = {};
+ try {
+ result = middleware(...parameters);
+ } catch (error) {
+ /** @type {Error} */
+ const exception = error;
-function isNothing$1(subject) {
+ // Well, this is quite the pickle.
+ // `middleware` received a callback and called it synchronously, but that
+ // threw an error.
+ // The only thing left to do is to throw the thing instead.
+ if (fnExpectsCallback && called) {
+ throw exception
+ }
+
+ return done(exception)
+ }
+
+ if (!fnExpectsCallback) {
+ if (result instanceof Promise) {
+ result.then(then, done);
+ } else if (result instanceof Error) {
+ done(result);
+ } else {
+ then(result);
+ }
+ }
+ }
+
+ /**
+ * Call `callback`, only once.
+ * @type {Callback}
+ */
+ function done(error, ...output) {
+ if (!called) {
+ called = true;
+ callback(error, ...output);
+ }
+ }
+
+ /**
+ * Call `done` with one value.
+ *
+ * @param {any} [value]
+ */
+ function then(value) {
+ done(null, value);
+ }
+}
+
+/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
+function isNothing(subject) {
return (typeof subject === 'undefined') || (subject === null);
}
-function isObject$4(subject) {
+function isObject$1(subject) {
return (typeof subject === 'object') && (subject !== null);
}
-function toArray$1(sequence) {
+function toArray(sequence) {
if (Array.isArray(sequence)) return sequence;
- else if (isNothing$1(sequence)) return [];
+ else if (isNothing(sequence)) return [];
return [ sequence ];
}
-function extend$4(target, source) {
+function extend$2(target, source) {
var index, length, key, sourceKeys;
if (source) {
@@ -294,7 +8650,7 @@ function extend$4(target, source) {
}
-function repeat$8(string, count) {
+function repeat$1(string, count) {
var result = '', cycle;
for (cycle = 0; cycle < count; cycle += 1) {
@@ -305,26 +8661,57 @@ function repeat$8(string, count) {
}
-function isNegativeZero$1(number) {
+function isNegativeZero(number) {
return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
}
-common$b.isNothing = isNothing$1;
-common$b.isObject = isObject$4;
-common$b.toArray = toArray$1;
-common$b.repeat = repeat$8;
-common$b.isNegativeZero = isNegativeZero$1;
-common$b.extend = extend$4;
+var isNothing_1 = isNothing;
+var isObject_1 = isObject$1;
+var toArray_1 = toArray;
+var repeat_1 = repeat$1;
+var isNegativeZero_1 = isNegativeZero;
+var extend_1 = extend$2;
+
+var common$4 = {
+ isNothing: isNothing_1,
+ isObject: isObject_1,
+ toArray: toArray_1,
+ repeat: repeat_1,
+ isNegativeZero: isNegativeZero_1,
+ extend: extend_1
+};
+
+// YAML error class. http://stackoverflow.com/questions/8458984
+
+
+function formatError(exception, compact) {
+ var where = '', message = exception.reason || '(unknown reason)';
+
+ if (!exception.mark) return message;
+
+ if (exception.mark.name) {
+ where += 'in "' + exception.mark.name + '" ';
+ }
+
+ where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
+
+ if (!compact && exception.mark.snippet) {
+ where += '\n\n' + exception.mark.snippet;
+ }
+
+ return message + ' ' + where;
+}
-function YAMLException$6(reason, mark) {
+
+function YAMLException$1(reason, mark) {
// Super constructor
Error.call(this);
this.name = 'YAMLException';
this.reason = reason;
this.mark = mark;
- this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
+ this.message = formatError(this, false);
// Include stack trace in error object
if (Error.captureStackTrace) {
@@ -338,119 +8725,133 @@ function YAMLException$6(reason, mark) {
// Inherit from Error
-YAMLException$6.prototype = Object.create(Error.prototype);
-YAMLException$6.prototype.constructor = YAMLException$6;
+YAMLException$1.prototype = Object.create(Error.prototype);
+YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$6.prototype.toString = function toString(compact) {
- var result = this.name + ': ';
+YAMLException$1.prototype.toString = function toString(compact) {
+ return this.name + ': ' + formatError(this, compact);
+};
- result += this.reason || '(unknown reason)';
- if (!compact && this.mark) {
- result += ' ' + this.mark.toString();
- }
+var exception = YAMLException$1;
- return result;
-};
+// get snippet for a single line, respecting maxLength
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+ var head = '';
+ var tail = '';
+ var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+ if (position - lineStart > maxHalfLength) {
+ head = ' ... ';
+ lineStart = position - maxHalfLength + head.length;
+ }
-var exception$1 = YAMLException$6;
+ if (lineEnd - position > maxHalfLength) {
+ tail = ' ...';
+ lineEnd = position + maxHalfLength - tail.length;
+ }
-var common$a = common$b;
+ return {
+ str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
+ pos: position - lineStart + head.length // relative position
+ };
+}
-function Mark$1(name, buffer, position, line, column) {
- this.name = name;
- this.buffer = buffer;
- this.position = position;
- this.line = line;
- this.column = column;
+function padStart(string, max) {
+ return common$4.repeat(' ', max - string.length) + string;
}
-Mark$1.prototype.getSnippet = function getSnippet(indent, maxLength) {
- var head, start, tail, end, snippet;
-
- if (!this.buffer) return null;
+function makeSnippet(mark, options) {
+ options = Object.create(options || null);
- indent = indent || 4;
- maxLength = maxLength || 75;
+ if (!mark.buffer) return null;
- head = '';
- start = this.position;
+ if (!options.maxLength) options.maxLength = 79;
+ if (typeof options.indent !== 'number') options.indent = 1;
+ if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
+ if (typeof options.linesAfter !== 'number') options.linesAfter = 2;
- 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;
- }
- }
+ var re = /\r?\n|\r|\0/g;
+ var lineStarts = [ 0 ];
+ var lineEnds = [];
+ var match;
+ var foundLineNo = -1;
- tail = '';
- end = this.position;
+ while ((match = re.exec(mark.buffer))) {
+ lineEnds.push(match.index);
+ lineStarts.push(match.index + match[0].length);
- 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;
+ if (mark.position <= match.index && foundLineNo < 0) {
+ foundLineNo = lineStarts.length - 2;
}
}
- snippet = this.buffer.slice(start, end);
-
- return common$a.repeat(' ', indent) + head + snippet + tail + '\n' +
- common$a.repeat(' ', indent + this.position - start + head.length) + '^';
-};
-
+ if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-Mark$1.prototype.toString = function toString(compact) {
- var snippet, where = '';
+ var result = '', i, line;
+ var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+ var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
- if (this.name) {
- where += 'in "' + this.name + '" ';
+ for (i = 1; i <= options.linesBefore; i++) {
+ if (foundLineNo - i < 0) break;
+ line = getLine(
+ mark.buffer,
+ lineStarts[foundLineNo - i],
+ lineEnds[foundLineNo - i],
+ mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
+ maxLineLength
+ );
+ result = common$4.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
+ ' | ' + line.str + '\n' + result;
}
- where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
-
- if (!compact) {
- snippet = this.getSnippet();
+ line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+ result += common$4.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
+ ' | ' + line.str + '\n';
+ result += common$4.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
- if (snippet) {
- where += ':\n' + snippet;
- }
+ for (i = 1; i <= options.linesAfter; i++) {
+ if (foundLineNo + i >= lineEnds.length) break;
+ line = getLine(
+ mark.buffer,
+ lineStarts[foundLineNo + i],
+ lineEnds[foundLineNo + i],
+ mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
+ maxLineLength
+ );
+ result += common$4.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
+ ' | ' + line.str + '\n';
}
- return where;
-};
-
+ return result.replace(/\n$/, '');
+}
-var mark$1 = Mark$1;
-var YAMLException$5 = exception$1;
+var snippet = makeSnippet;
-var TYPE_CONSTRUCTOR_OPTIONS$1 = [
+var TYPE_CONSTRUCTOR_OPTIONS = [
'kind',
+ 'multi',
'resolve',
'construct',
'instanceOf',
'predicate',
'represent',
+ 'representName',
'defaultStyle',
'styleAliases'
];
-var YAML_NODE_KINDS$1 = [
+var YAML_NODE_KINDS = [
'scalar',
'sequence',
'mapping'
];
-function compileStyleAliases$1(map) {
+function compileStyleAliases(map) {
var result = {};
if (map !== null) {
@@ -464,73 +8865,85 @@ function compileStyleAliases$1(map) {
return result;
}
-function Type$j(tag, options) {
+function Type$1(tag, options) {
options = options || {};
Object.keys(options).forEach(function (name) {
- if (TYPE_CONSTRUCTOR_OPTIONS$1.indexOf(name) === -1) {
- throw new YAMLException$5('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+ if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+ throw new exception('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$1(options['styleAliases'] || null);
+ this.options = options; // keep original options in case user wants to extend this type later
+ 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.representName = options['representName'] || null;
+ this.defaultStyle = options['defaultStyle'] || null;
+ this.multi = options['multi'] || false;
+ this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
- if (YAML_NODE_KINDS$1.indexOf(this.kind) === -1) {
- throw new YAMLException$5('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+ if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+ throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
}
}
-var type$1 = Type$j;
+var type$1 = Type$1;
/*eslint-disable max-len*/
-var common$9 = common$b;
-var YAMLException$4 = exception$1;
-var Type$i = type$1;
-function compileList$1(schema, name, result) {
- var exclude = [];
- schema.include.forEach(function (includedSchema) {
- result = compileList$1(includedSchema, name, result);
- });
+
+function compileList(schema, name) {
+ var result = [];
schema[name].forEach(function (currentType) {
+ var newIndex = result.length;
+
result.forEach(function (previousType, previousIndex) {
- if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
- exclude.push(previousIndex);
+ if (previousType.tag === currentType.tag &&
+ previousType.kind === currentType.kind &&
+ previousType.multi === currentType.multi) {
+
+ newIndex = previousIndex;
}
});
- result.push(currentType);
+ result[newIndex] = currentType;
});
- return result.filter(function (type, index) {
- return exclude.indexOf(index) === -1;
- });
+ return result;
}
-function compileMap$1(/* lists... */) {
+function compileMap(/* lists... */) {
var result = {
scalar: {},
sequence: {},
mapping: {},
- fallback: {}
+ fallback: {},
+ multi: {
+ scalar: [],
+ sequence: [],
+ mapping: [],
+ fallback: []
+ }
}, index, length;
function collectType(type) {
- result[type.kind][type.tag] = result['fallback'][type.tag] = type;
+ if (type.multi) {
+ result.multi[type.kind].push(type);
+ result.multi['fallback'].push(type);
+ } else {
+ result[type.kind][type.tag] = result['fallback'][type.tag] = type;
+ }
}
for (index = 0, length = arguments.length; index < length; index += 1) {
@@ -540,99 +8953,92 @@ function compileMap$1(/* lists... */) {
}
-function Schema$7(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$4('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
- }
- });
-
- this.compiledImplicit = compileList$1(this, 'implicit', []);
- this.compiledExplicit = compileList$1(this, 'explicit', []);
- this.compiledTypeMap = compileMap$1(this.compiledImplicit, this.compiledExplicit);
+function Schema$1(definition) {
+ return this.extend(definition);
}
-Schema$7.DEFAULT = null;
-
+Schema$1.prototype.extend = function extend(definition) {
+ var implicit = [];
+ var explicit = [];
-Schema$7.create = function createSchema() {
- var schemas, types;
+ if (definition instanceof type$1) {
+ // Schema.extend(type)
+ explicit.push(definition);
- switch (arguments.length) {
- case 1:
- schemas = Schema$7.DEFAULT;
- types = arguments[0];
- break;
+ } else if (Array.isArray(definition)) {
+ // Schema.extend([ type1, type2, ... ])
+ explicit = explicit.concat(definition);
- case 2:
- schemas = arguments[0];
- types = arguments[1];
- break;
+ } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+ // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
+ if (definition.implicit) implicit = implicit.concat(definition.implicit);
+ if (definition.explicit) explicit = explicit.concat(definition.explicit);
- default:
- throw new YAMLException$4('Wrong number of arguments for Schema.create function');
+ } else {
+ throw new exception('Schema.extend argument should be a Type, [ Type ], ' +
+ 'or a schema definition ({ implicit: [...], explicit: [...] })');
}
- schemas = common$9.toArray(schemas);
- types = common$9.toArray(types);
+ implicit.forEach(function (type$1$1) {
+ if (!(type$1$1 instanceof type$1)) {
+ throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+ }
- if (!schemas.every(function (schema) { return schema instanceof Schema$7; })) {
- throw new YAMLException$4('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
- }
+ if (type$1$1.loadKind && type$1$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.');
+ }
- if (!types.every(function (type) { return type instanceof Type$i; })) {
- throw new YAMLException$4('Specified list of YAML types (or a single Type object) contains a non-Type object.');
- }
+ if (type$1$1.multi) {
+ throw new exception('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
+ }
+ });
- return new Schema$7({
- include: schemas,
- explicit: types
+ explicit.forEach(function (type$1$1) {
+ if (!(type$1$1 instanceof type$1)) {
+ throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+ }
});
-};
+ var result = Object.create(Schema$1.prototype);
+
+ result.implicit = (this.implicit || []).concat(implicit);
+ result.explicit = (this.explicit || []).concat(explicit);
+
+ result.compiledImplicit = compileList(result, 'implicit');
+ result.compiledExplicit = compileList(result, 'explicit');
+ result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+
+ return result;
+};
-var schema$2 = Schema$7;
-var Type$h = type$1;
+var schema$1 = Schema$1;
-var str$1 = new Type$h('tag:yaml.org,2002:str', {
+var str = new type$1('tag:yaml.org,2002:str', {
kind: 'scalar',
construct: function (data) { return data !== null ? data : ''; }
});
-var Type$g = type$1;
-
-var seq$1 = new Type$g('tag:yaml.org,2002:seq', {
+var seq = new type$1('tag:yaml.org,2002:seq', {
kind: 'sequence',
construct: function (data) { return data !== null ? data : []; }
});
-var Type$f = type$1;
-
-var map$7 = new Type$f('tag:yaml.org,2002:map', {
+var map$3 = new type$1('tag:yaml.org,2002:map', {
kind: 'mapping',
construct: function (data) { return data !== null ? data : {}; }
});
-var Schema$6 = schema$2;
-
-
-var failsafe$1 = new Schema$6({
+var failsafe = new schema$1({
explicit: [
- str$1,
- seq$1,
- map$7
+ str,
+ seq,
+ map$3
]
});
-var Type$e = type$1;
-
-function resolveYamlNull$1(data) {
+function resolveYamlNull(data) {
if (data === null) return true;
var max = data.length;
@@ -641,31 +9047,30 @@ function resolveYamlNull$1(data) {
(max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
}
-function constructYamlNull$1() {
+function constructYamlNull() {
return null;
}
-function isNull$1(object) {
+function isNull(object) {
return object === null;
}
-var _null$1 = new Type$e('tag:yaml.org,2002:null', {
+var _null = new type$1('tag:yaml.org,2002:null', {
kind: 'scalar',
- resolve: resolveYamlNull$1,
- construct: constructYamlNull$1,
- predicate: isNull$1,
+ resolve: resolveYamlNull,
+ construct: constructYamlNull,
+ predicate: isNull,
represent: {
canonical: function () { return '~'; },
lowercase: function () { return 'null'; },
uppercase: function () { return 'NULL'; },
- camelcase: function () { return 'Null'; }
+ camelcase: function () { return 'Null'; },
+ empty: function () { return ''; }
},
defaultStyle: 'lowercase'
});
-var Type$d = type$1;
-
-function resolveYamlBoolean$1(data) {
+function resolveYamlBoolean(data) {
if (data === null) return false;
var max = data.length;
@@ -674,21 +9079,21 @@ function resolveYamlBoolean$1(data) {
(max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
}
-function constructYamlBoolean$1(data) {
+function constructYamlBoolean(data) {
return data === 'true' ||
data === 'True' ||
data === 'TRUE';
}
-function isBoolean$1(object) {
+function isBoolean(object) {
return Object.prototype.toString.call(object) === '[object Boolean]';
}
-var bool$1 = new Type$d('tag:yaml.org,2002:bool', {
+var bool = new type$1('tag:yaml.org,2002:bool', {
kind: 'scalar',
- resolve: resolveYamlBoolean$1,
- construct: constructYamlBoolean$1,
- predicate: isBoolean$1,
+ resolve: resolveYamlBoolean,
+ construct: constructYamlBoolean,
+ predicate: isBoolean,
represent: {
lowercase: function (object) { return object ? 'true' : 'false'; },
uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
@@ -697,24 +9102,21 @@ var bool$1 = new Type$d('tag:yaml.org,2002:bool', {
defaultStyle: 'lowercase'
});
-var common$8 = common$b;
-var Type$c = type$1;
-
-function isHexCode$1(c) {
+function isHexCode(c) {
return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
((0x61/* a */ <= c) && (c <= 0x66/* f */));
}
-function isOctCode$1(c) {
+function isOctCode(c) {
return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
}
-function isDecCode$1(c) {
+function isDecCode(c) {
return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
}
-function resolveYamlInteger$1(data) {
+function resolveYamlInteger(data) {
if (data === null) return false;
var max = data.length,
@@ -759,23 +9161,28 @@ function resolveYamlInteger$1(data) {
for (; index < max; index++) {
ch = data[index];
if (ch === '_') continue;
- if (!isHexCode$1(data.charCodeAt(index))) return false;
+ 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$1(data.charCodeAt(index))) return false;
- hasDigits = true;
+
+ if (ch === 'o') {
+ // base 8
+ index++;
+
+ for (; index < max; index++) {
+ ch = data[index];
+ if (ch === '_') continue;
+ if (!isOctCode(data.charCodeAt(index))) return false;
+ hasDigits = true;
+ }
+ return hasDigits && ch !== '_';
}
- return hasDigits && ch !== '_';
}
- // base 10 (except 0) or base 60
+ // base 10 (except 0)
// value should not start with `_`;
if (ch === '_') return false;
@@ -783,8 +9190,7 @@ function resolveYamlInteger$1(data) {
for (; index < max; index++) {
ch = data[index];
if (ch === '_') continue;
- if (ch === ':') break;
- if (!isDecCode$1(data.charCodeAt(index))) {
+ if (!isDecCode(data.charCodeAt(index))) {
return false;
}
hasDigits = true;
@@ -793,15 +9199,11 @@ function resolveYamlInteger$1(data) {
// 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));
+ return true;
}
-function constructYamlInteger$1(data) {
- var value = data, sign = 1, ch, base, digits = [];
+function constructYamlInteger(data) {
+ var value = data, sign = 1, ch;
if (value.indexOf('_') !== -1) {
value = value.replace(/_/g, '');
@@ -819,43 +9221,26 @@ function constructYamlInteger$1(data) {
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;
-
+ if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
+ if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
}
return sign * parseInt(value, 10);
}
-function isInteger$1(object) {
+function isInteger(object) {
return (Object.prototype.toString.call(object)) === '[object Number]' &&
- (object % 1 === 0 && !common$8.isNegativeZero(object));
+ (object % 1 === 0 && !common$4.isNegativeZero(object));
}
-var int$4 = new Type$c('tag:yaml.org,2002:int', {
+var int = new type$1('tag:yaml.org,2002:int', {
kind: 'scalar',
- resolve: resolveYamlInteger$1,
- construct: constructYamlInteger$1,
- predicate: isInteger$1,
+ 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); },
+ octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + 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); }
@@ -869,26 +9254,21 @@ var int$4 = new Type$c('tag:yaml.org,2002:int', {
}
});
-var common$7 = common$b;
-var Type$b = type$1;
-
-var YAML_FLOAT_PATTERN$1 = new RegExp(
+var YAML_FLOAT_PATTERN = new RegExp(
// 2.5e4, 2.5 and integers
- '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
+ '^(?:[-+]?(?:[0-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$1(data) {
+function resolveYamlFloat(data) {
if (data === null) return false;
- if (!YAML_FLOAT_PATTERN$1.test(data) ||
+ if (!YAML_FLOAT_PATTERN.test(data) ||
// Quick hack to not allow integers end with `_`
// Probably should update regexp & check speed
data[data.length - 1] === '_') {
@@ -898,12 +9278,11 @@ function resolveYamlFloat$1(data) {
return true;
}
-function constructYamlFloat$1(data) {
- var value, sign, base, digits;
+function constructYamlFloat(data) {
+ var value, sign;
value = data.replace(/_/g, '').toLowerCase();
sign = value[0] === '-' ? -1 : 1;
- digits = [];
if ('+-'.indexOf(value[0]) >= 0) {
value = value.slice(1);
@@ -914,30 +9293,14 @@ function constructYamlFloat$1(data) {
} 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$1 = /^[-+]?[0-9]+e/;
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
-function representYamlFloat$1(object, style) {
+function representYamlFloat(object, style) {
var res;
if (isNaN(object)) {
@@ -958,7 +9321,7 @@ function representYamlFloat$1(object, style) {
case 'uppercase': return '-.INF';
case 'camelcase': return '-.Inf';
}
- } else if (common$7.isNegativeZero(object)) {
+ } else if (common$4.isNegativeZero(object)) {
return '-0.0';
}
@@ -967,55 +9330,40 @@ function representYamlFloat$1(object, style) {
// 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$1.test(res) ? res.replace('e', '.e') : res;
+ return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
}
-function isFloat$1(object) {
+function isFloat(object) {
return (Object.prototype.toString.call(object) === '[object Number]') &&
- (object % 1 !== 0 || common$7.isNegativeZero(object));
+ (object % 1 !== 0 || common$4.isNegativeZero(object));
}
-var float$1 = new Type$b('tag:yaml.org,2002:float', {
+var float = new type$1('tag:yaml.org,2002:float', {
kind: 'scalar',
- resolve: resolveYamlFloat$1,
- construct: constructYamlFloat$1,
- predicate: isFloat$1,
- represent: representYamlFloat$1,
+ resolve: resolveYamlFloat,
+ construct: constructYamlFloat,
+ predicate: isFloat,
+ represent: representYamlFloat,
defaultStyle: 'lowercase'
});
-var Schema$5 = schema$2;
-
-
-var json$3 = new Schema$5({
- include: [
- failsafe$1
- ],
+var json = failsafe.extend({
implicit: [
- _null$1,
- bool$1,
- int$4,
- float$1
- ]
-});
-
-var Schema$4 = schema$2;
-
-
-var core$4 = new Schema$4({
- include: [
- json$3
+ _null,
+ bool,
+ int,
+ float
]
});
-var Type$a = type$1;
+var core = json;
-var YAML_DATE_REGEXP$1 = new RegExp(
+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$1 = new RegExp(
+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
@@ -1027,19 +9375,19 @@ var YAML_TIMESTAMP_REGEXP$1 = new RegExp(
'(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
'(?::([0-9][0-9]))?))?$'); // [11] tz_minute
-function resolveYamlTimestamp$1(data) {
+function resolveYamlTimestamp(data) {
if (data === null) return false;
- if (YAML_DATE_REGEXP$1.exec(data) !== null) return true;
- if (YAML_TIMESTAMP_REGEXP$1.exec(data) !== null) return true;
+ if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+ if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
return false;
}
-function constructYamlTimestamp$1(data) {
+function constructYamlTimestamp(data) {
var match, year, month, day, hour, minute, second, fraction = 0,
delta = null, tz_hour, tz_minute, date;
- match = YAML_DATE_REGEXP$1.exec(data);
- if (match === null) match = YAML_TIMESTAMP_REGEXP$1.exec(data);
+ match = YAML_DATE_REGEXP.exec(data);
+ if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
if (match === null) throw new Error('Date resolve error');
@@ -1083,50 +9431,41 @@ function constructYamlTimestamp$1(data) {
return date;
}
-function representYamlTimestamp$1(object /*, style*/) {
+function representYamlTimestamp(object /*, style*/) {
return object.toISOString();
}
-var timestamp$1 = new Type$a('tag:yaml.org,2002:timestamp', {
+var timestamp = new type$1('tag:yaml.org,2002:timestamp', {
kind: 'scalar',
- resolve: resolveYamlTimestamp$1,
- construct: constructYamlTimestamp$1,
+ resolve: resolveYamlTimestamp,
+ construct: constructYamlTimestamp,
instanceOf: Date,
- represent: representYamlTimestamp$1
+ represent: representYamlTimestamp
});
-var Type$9 = type$1;
-
-function resolveYamlMerge$1(data) {
+function resolveYamlMerge(data) {
return data === '<<' || data === null;
}
-var merge$2 = new Type$9('tag:yaml.org,2002:merge', {
+var merge$1 = new type$1('tag:yaml.org,2002:merge', {
kind: 'scalar',
- resolve: resolveYamlMerge$1
+ resolve: resolveYamlMerge
});
/*eslint-disable no-bitwise*/
-var NodeBuffer;
-try {
- // A trick for browserified version, to not include `Buffer` shim
- var _require$1 = commonjsRequire;
- NodeBuffer = _require$1('buffer').Buffer;
-} catch (__) {}
-var Type$8 = type$1;
// [ 64, 65, 66 ] -> [ padding, CR, LF ]
-var BASE64_MAP$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
-function resolveYamlBinary$1(data) {
+function resolveYamlBinary(data) {
if (data === null) return false;
- var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP$1;
+ var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
// Convert one by one.
for (idx = 0; idx < max; idx++) {
@@ -1145,11 +9484,11 @@ function resolveYamlBinary$1(data) {
return (bitlen % 8) === 0;
}
-function constructYamlBinary$1(data) {
+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$1,
+ map = BASE64_MAP,
bits = 0,
result = [];
@@ -1180,19 +9519,13 @@ function constructYamlBinary$1(data) {
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;
+ return new Uint8Array(result);
}
-function representYamlBinary$1(object /*, style*/) {
+function representYamlBinary(object /*, style*/) {
var result = '', bits = 0, idx, tail,
max = object.length,
- map = BASE64_MAP$1;
+ map = BASE64_MAP;
// Convert every three bytes to 4 ASCII characters.
@@ -1231,24 +9564,22 @@ function representYamlBinary$1(object /*, style*/) {
return result;
}
-function isBinary$1(object) {
- return NodeBuffer && NodeBuffer.isBuffer(object);
+function isBinary(obj) {
+ return Object.prototype.toString.call(obj) === '[object Uint8Array]';
}
-var binary$1 = new Type$8('tag:yaml.org,2002:binary', {
+var binary = new type$1('tag:yaml.org,2002:binary', {
kind: 'scalar',
- resolve: resolveYamlBinary$1,
- construct: constructYamlBinary$1,
- predicate: isBinary$1,
- represent: representYamlBinary$1
+ resolve: resolveYamlBinary,
+ construct: constructYamlBinary,
+ predicate: isBinary,
+ represent: representYamlBinary
});
-var Type$7 = type$1;
-
-var _hasOwnProperty$7 = Object.prototype.hasOwnProperty;
-var _toString$5 = Object.prototype.toString;
+var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+var _toString$2 = Object.prototype.toString;
-function resolveYamlOmap$1(data) {
+function resolveYamlOmap(data) {
if (data === null) return true;
var objectKeys = [], index, length, pair, pairKey, pairHasKey,
@@ -1258,10 +9589,10 @@ function resolveYamlOmap$1(data) {
pair = object[index];
pairHasKey = false;
- if (_toString$5.call(pair) !== '[object Object]') return false;
+ if (_toString$2.call(pair) !== '[object Object]') return false;
for (pairKey in pair) {
- if (_hasOwnProperty$7.call(pair, pairKey)) {
+ if (_hasOwnProperty$3.call(pair, pairKey)) {
if (!pairHasKey) pairHasKey = true;
else return false;
}
@@ -1276,21 +9607,19 @@ function resolveYamlOmap$1(data) {
return true;
}
-function constructYamlOmap$1(data) {
+function constructYamlOmap(data) {
return data !== null ? data : [];
}
-var omap$1 = new Type$7('tag:yaml.org,2002:omap', {
+var omap = new type$1('tag:yaml.org,2002:omap', {
kind: 'sequence',
- resolve: resolveYamlOmap$1,
- construct: constructYamlOmap$1
+ resolve: resolveYamlOmap,
+ construct: constructYamlOmap
});
-var Type$6 = type$1;
-
-var _toString$4 = Object.prototype.toString;
+var _toString$1 = Object.prototype.toString;
-function resolveYamlPairs$1(data) {
+function resolveYamlPairs(data) {
if (data === null) return true;
var index, length, pair, keys, result,
@@ -1301,7 +9630,7 @@ function resolveYamlPairs$1(data) {
for (index = 0, length = object.length; index < length; index += 1) {
pair = object[index];
- if (_toString$4.call(pair) !== '[object Object]') return false;
+ if (_toString$1.call(pair) !== '[object Object]') return false;
keys = Object.keys(pair);
@@ -1313,7 +9642,7 @@ function resolveYamlPairs$1(data) {
return true;
}
-function constructYamlPairs$1(data) {
+function constructYamlPairs(data) {
if (data === null) return [];
var index, length, pair, keys, result,
@@ -1332,23 +9661,21 @@ function constructYamlPairs$1(data) {
return result;
}
-var pairs$1 = new Type$6('tag:yaml.org,2002:pairs', {
+var pairs = new type$1('tag:yaml.org,2002:pairs', {
kind: 'sequence',
- resolve: resolveYamlPairs$1,
- construct: constructYamlPairs$1
+ resolve: resolveYamlPairs,
+ construct: constructYamlPairs
});
-var Type$5 = type$1;
-
-var _hasOwnProperty$6 = Object.prototype.hasOwnProperty;
+var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-function resolveYamlSet$1(data) {
+function resolveYamlSet(data) {
if (data === null) return true;
var key, object = data;
for (key in object) {
- if (_hasOwnProperty$6.call(object, key)) {
+ if (_hasOwnProperty$2.call(object, key)) {
if (object[key] !== null) return false;
}
}
@@ -1356,275 +9683,76 @@ function resolveYamlSet$1(data) {
return true;
}
-function constructYamlSet$1(data) {
+function constructYamlSet(data) {
return data !== null ? data : {};
}
-var set$1 = new Type$5('tag:yaml.org,2002:set', {
+var set = new type$1('tag:yaml.org,2002:set', {
kind: 'mapping',
- resolve: resolveYamlSet$1,
- construct: constructYamlSet$1
+ resolve: resolveYamlSet,
+ construct: constructYamlSet
});
-var Schema$3 = schema$2;
-
-
-var default_safe = new Schema$3({
- include: [
- core$4
- ],
+var _default$1 = core.extend({
implicit: [
- timestamp$1,
- merge$2
+ timestamp,
+ merge$1
],
explicit: [
- binary$1,
- omap$1,
- pairs$1,
- set$1
+ binary,
+ omap,
+ pairs,
+ set
]
});
-var Type$4 = type$1;
-
-function resolveJavascriptUndefined() {
- return true;
-}
-
-function constructJavascriptUndefined() {
- /*eslint-disable no-undefined*/
- return undefined;
-}
-
-function representJavascriptUndefined() {
- return '';
-}
-
-function isUndefined(object) {
- return typeof object === 'undefined';
-}
-
-var _undefined = new Type$4('tag:yaml.org,2002:js/undefined', {
- kind: 'scalar',
- resolve: resolveJavascriptUndefined,
- construct: constructJavascriptUndefined,
- predicate: isUndefined,
- represent: representJavascriptUndefined
-});
-
-var Type$3 = type$1;
-
-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]';
-}
-
-var regexp = new Type$3('tag:yaml.org,2002:js/regexp', {
- kind: 'scalar',
- resolve: resolveJavascriptRegExp,
- construct: constructJavascriptRegExp,
- predicate: isRegExp,
- represent: representJavascriptRegExp
-});
-
-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 = commonjsRequire;
- esprima = _require('esprima');
-} catch (_) {
- /* eslint-disable no-redeclare */
- /* global window */
- if (typeof window !== 'undefined') esprima = window.esprima;
-}
-
-var Type$2 = type$1;
-
-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]';
-}
-
-var _function = new Type$2('tag:yaml.org,2002:js/function', {
- kind: 'scalar',
- resolve: resolveJavascriptFunction,
- construct: constructJavascriptFunction,
- predicate: isFunction,
- represent: representJavascriptFunction
-});
+/*eslint-disable max-len,no-use-before-define*/
-var Schema$2 = schema$2;
-var default_full = Schema$2.DEFAULT = new Schema$2({
- include: [
- default_safe
- ],
- explicit: [
- _undefined,
- regexp,
- _function
- ]
-});
-/*eslint-disable max-len,no-use-before-define*/
-var common$6 = common$b;
-var YAMLException$3 = exception$1;
-var Mark = mark$1;
-var DEFAULT_SAFE_SCHEMA$1 = default_safe;
-var DEFAULT_FULL_SCHEMA$1 = default_full;
-var _hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-var CONTEXT_FLOW_IN$1 = 1;
-var CONTEXT_FLOW_OUT$1 = 2;
-var CONTEXT_BLOCK_IN$1 = 3;
-var CONTEXT_BLOCK_OUT$1 = 4;
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
-var CHOMPING_CLIP$1 = 1;
-var CHOMPING_STRIP$1 = 2;
-var CHOMPING_KEEP$1 = 3;
+var CHOMPING_CLIP = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP = 3;
-var PATTERN_NON_PRINTABLE$1 = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-var PATTERN_NON_ASCII_LINE_BREAKS$1 = /[\x85\u2028\u2029]/;
-var PATTERN_FLOW_INDICATORS$1 = /[,\[\]\{\}]/;
-var PATTERN_TAG_HANDLE$1 = /^(?:!|!!|![a-z\-]+!)$/i;
-var PATTERN_TAG_URI$1 = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
-function _class$1(obj) { return Object.prototype.toString.call(obj); }
+function _class(obj) { return Object.prototype.toString.call(obj); }
-function is_EOL$1(c) {
+function is_EOL(c) {
return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
}
-function is_WHITE_SPACE$1(c) {
+function is_WHITE_SPACE(c) {
return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
}
-function is_WS_OR_EOL$1(c) {
+function is_WS_OR_EOL(c) {
return (c === 0x09/* Tab */) ||
(c === 0x20/* Space */) ||
(c === 0x0A/* LF */) ||
(c === 0x0D/* CR */);
}
-function is_FLOW_INDICATOR$1(c) {
+function is_FLOW_INDICATOR(c) {
return c === 0x2C/* , */ ||
c === 0x5B/* [ */ ||
c === 0x5D/* ] */ ||
@@ -1632,7 +9760,7 @@ function is_FLOW_INDICATOR$1(c) {
c === 0x7D/* } */;
}
-function fromHexCode$1(c) {
+function fromHexCode(c) {
var lc;
if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
@@ -1649,14 +9777,14 @@ function fromHexCode$1(c) {
return -1;
}
-function escapedHexLen$1(c) {
+function escapedHexLen(c) {
if (c === 0x78/* x */) { return 2; }
if (c === 0x75/* u */) { return 4; }
if (c === 0x55/* U */) { return 8; }
return 0;
}
-function fromDecimalCode$1(c) {
+function fromDecimalCode(c) {
if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
return c - 0x30;
}
@@ -1664,7 +9792,7 @@ function fromDecimalCode$1(c) {
return -1;
}
-function simpleEscapeSequence$1(c) {
+function simpleEscapeSequence(c) {
/* eslint-disable indent */
return (c === 0x30/* 0 */) ? '\x00' :
(c === 0x61/* a */) ? '\x07' :
@@ -1686,7 +9814,7 @@ function simpleEscapeSequence$1(c) {
(c === 0x50/* P */) ? '\u2029' : '';
}
-function charFromCodepoint$1(c) {
+function charFromCodepoint(c) {
if (c <= 0xFFFF) {
return String.fromCharCode(c);
}
@@ -1698,21 +9826,24 @@ function charFromCodepoint$1(c) {
);
}
-var simpleEscapeCheck$1 = new Array(256); // integer, for fast access
-var simpleEscapeMap$1 = new Array(256);
-for (var i$1 = 0; i$1 < 256; i$1++) {
- simpleEscapeCheck$1[i$1] = simpleEscapeSequence$1(i$1) ? 1 : 0;
- simpleEscapeMap$1[i$1] = simpleEscapeSequence$1(i$1);
+var simpleEscapeCheck = new Array(256); // integer, for fast access
+var simpleEscapeMap = new Array(256);
+for (var i = 0; i < 256; i++) {
+ simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+ simpleEscapeMap[i] = simpleEscapeSequence(i);
}
-function State$3(input, options) {
+function State$1(input, options) {
this.input = input;
this.filename = options['filename'] || null;
- this.schema = options['schema'] || DEFAULT_FULL_SCHEMA$1;
+ this.schema = options['schema'] || _default$1;
this.onWarning = options['onWarning'] || null;
+ // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
+ // if such documents have no explicit %YAML directive
this.legacy = options['legacy'] || false;
+
this.json = options['json'] || false;
this.listener = options['listener'] || null;
@@ -1725,6 +9856,10 @@ function State$3(input, options) {
this.lineStart = 0;
this.lineIndent = 0;
+ // position of first leading tab in the current line,
+ // used to make sure there are no tabs in the indentation
+ this.firstTabInLine = -1;
+
this.documents = [];
/*
@@ -1740,55 +9875,63 @@ function State$3(input, options) {
}
-function generateError$1(state, message) {
- return new YAMLException$3(
- message,
- new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
+function generateError(state, message) {
+ var mark = {
+ name: state.filename,
+ buffer: state.input.slice(0, -1), // omit trailing \0
+ position: state.position,
+ line: state.line,
+ column: state.position - state.lineStart
+ };
+
+ mark.snippet = snippet(mark);
+
+ return new exception(message, mark);
}
-function throwError$2(state, message) {
- throw generateError$1(state, message);
+function throwError$1(state, message) {
+ throw generateError(state, message);
}
-function throwWarning$1(state, message) {
+function throwWarning(state, message) {
if (state.onWarning) {
- state.onWarning.call(null, generateError$1(state, message));
+ state.onWarning.call(null, generateError(state, message));
}
}
-var directiveHandlers$1 = {
+var directiveHandlers = {
YAML: function handleYamlDirective(state, name, args) {
var match, major, minor;
if (state.version !== null) {
- throwError$2(state, 'duplication of %YAML directive');
+ throwError$1(state, 'duplication of %YAML directive');
}
if (args.length !== 1) {
- throwError$2(state, 'YAML directive accepts exactly one argument');
+ throwError$1(state, 'YAML directive accepts exactly one argument');
}
match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
if (match === null) {
- throwError$2(state, 'ill-formed argument of the YAML directive');
+ throwError$1(state, 'ill-formed argument of the YAML directive');
}
major = parseInt(match[1], 10);
minor = parseInt(match[2], 10);
if (major !== 1) {
- throwError$2(state, 'unacceptable YAML version of the document');
+ throwError$1(state, 'unacceptable YAML version of the document');
}
state.version = args[0];
state.checkLineBreaks = (minor < 2);
if (minor !== 1 && minor !== 2) {
- throwWarning$1(state, 'unsupported YAML version of the document');
+ throwWarning(state, 'unsupported YAML version of the document');
}
},
@@ -1797,22 +9940,28 @@ var directiveHandlers$1 = {
var handle, prefix;
if (args.length !== 2) {
- throwError$2(state, 'TAG directive accepts exactly two arguments');
+ throwError$1(state, 'TAG directive accepts exactly two arguments');
}
handle = args[0];
prefix = args[1];
- if (!PATTERN_TAG_HANDLE$1.test(handle)) {
- throwError$2(state, 'ill-formed tag handle (first argument) of the TAG directive');
+ if (!PATTERN_TAG_HANDLE.test(handle)) {
+ throwError$1(state, 'ill-formed tag handle (first argument) of the TAG directive');
}
- if (_hasOwnProperty$5.call(state.tagMap, handle)) {
- throwError$2(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+ if (_hasOwnProperty$1.call(state.tagMap, handle)) {
+ throwError$1(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
}
- if (!PATTERN_TAG_URI$1.test(prefix)) {
- throwError$2(state, 'ill-formed tag prefix (second argument) of the TAG directive');
+ if (!PATTERN_TAG_URI.test(prefix)) {
+ throwError$1(state, 'ill-formed tag prefix (second argument) of the TAG directive');
+ }
+
+ try {
+ prefix = decodeURIComponent(prefix);
+ } catch (err) {
+ throwError$1(state, 'tag prefix is malformed: ' + prefix);
}
state.tagMap[handle] = prefix;
@@ -1820,7 +9969,7 @@ var directiveHandlers$1 = {
};
-function captureSegment$1(state, start, end, checkJson) {
+function captureSegment(state, start, end, checkJson) {
var _position, _length, _character, _result;
if (start < end) {
@@ -1831,22 +9980,22 @@ function captureSegment$1(state, start, end, checkJson) {
_character = _result.charCodeAt(_position);
if (!(_character === 0x09 ||
(0x20 <= _character && _character <= 0x10FFFF))) {
- throwError$2(state, 'expected valid JSON character');
+ throwError$1(state, 'expected valid JSON character');
}
}
- } else if (PATTERN_NON_PRINTABLE$1.test(_result)) {
- throwError$2(state, 'the stream contains non-printable characters');
+ } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+ throwError$1(state, 'the stream contains non-printable characters');
}
state.result += _result;
}
}
-function mergeMappings$1(state, destination, source, overridableKeys) {
+function mergeMappings(state, destination, source, overridableKeys) {
var sourceKeys, key, index, quantity;
- if (!common$6.isObject(source)) {
- throwError$2(state, 'cannot merge mappings; the provided source object is unacceptable');
+ if (!common$4.isObject(source)) {
+ throwError$1(state, 'cannot merge mappings; the provided source object is unacceptable');
}
sourceKeys = Object.keys(source);
@@ -1854,14 +10003,16 @@ function mergeMappings$1(state, destination, source, overridableKeys) {
for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
key = sourceKeys[index];
- if (!_hasOwnProperty$5.call(destination, key)) {
+ if (!_hasOwnProperty$1.call(destination, key)) {
destination[key] = source[key];
overridableKeys[key] = true;
}
}
}
-function storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
+ startLine, startLineStart, startPos) {
+
var index, quantity;
// The output is a plain object here, so keys can only be strings.
@@ -1872,10 +10023,10 @@ function storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, va
for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
if (Array.isArray(keyNode[index])) {
- throwError$2(state, 'nested arrays are not supported inside keys');
+ throwError$1(state, 'nested arrays are not supported inside keys');
}
- if (typeof keyNode === 'object' && _class$1(keyNode[index]) === '[object Object]') {
+ if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
keyNode[index] = '[object Object]';
}
}
@@ -1884,7 +10035,7 @@ function storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, va
// Avoid code execution in load() via toString property
// (still use its own toString for arrays, timestamps,
// and whatever user schema extensions happen to have @@toStringTag)
- if (typeof keyNode === 'object' && _class$1(keyNode) === '[object Object]') {
+ if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
keyNode = '[object Object]';
}
@@ -1898,27 +10049,39 @@ function storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, va
if (keyTag === 'tag:yaml.org,2002:merge') {
if (Array.isArray(valueNode)) {
for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
- mergeMappings$1(state, _result, valueNode[index], overridableKeys);
+ mergeMappings(state, _result, valueNode[index], overridableKeys);
}
} else {
- mergeMappings$1(state, _result, valueNode, overridableKeys);
+ mergeMappings(state, _result, valueNode, overridableKeys);
}
} else {
if (!state.json &&
- !_hasOwnProperty$5.call(overridableKeys, keyNode) &&
- _hasOwnProperty$5.call(_result, keyNode)) {
+ !_hasOwnProperty$1.call(overridableKeys, keyNode) &&
+ _hasOwnProperty$1.call(_result, keyNode)) {
state.line = startLine || state.line;
+ state.lineStart = startLineStart || state.lineStart;
state.position = startPos || state.position;
- throwError$2(state, 'duplicated mapping key');
+ throwError$1(state, 'duplicated mapping key');
+ }
+
+ // used for this specific key only because Object.defineProperty is slow
+ if (keyNode === '__proto__') {
+ Object.defineProperty(_result, keyNode, {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: valueNode
+ });
+ } else {
+ _result[keyNode] = valueNode;
}
- _result[keyNode] = valueNode;
delete overridableKeys[keyNode];
}
return _result;
}
-function readLineBreak$1(state) {
+function readLineBreak(state) {
var ch;
ch = state.input.charCodeAt(state.position);
@@ -1931,19 +10094,23 @@ function readLineBreak$1(state) {
state.position++;
}
} else {
- throwError$2(state, 'a line break is expected');
+ throwError$1(state, 'a line break is expected');
}
state.line += 1;
state.lineStart = state.position;
+ state.firstTabInLine = -1;
}
-function skipSeparationSpace$1(state, allowComments, checkIndent) {
+function skipSeparationSpace(state, allowComments, checkIndent) {
var lineBreaks = 0,
ch = state.input.charCodeAt(state.position);
while (ch !== 0) {
- while (is_WHITE_SPACE$1(ch)) {
+ while (is_WHITE_SPACE(ch)) {
+ if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
+ state.firstTabInLine = state.position;
+ }
ch = state.input.charCodeAt(++state.position);
}
@@ -1953,8 +10120,8 @@ function skipSeparationSpace$1(state, allowComments, checkIndent) {
} while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
}
- if (is_EOL$1(ch)) {
- readLineBreak$1(state);
+ if (is_EOL(ch)) {
+ readLineBreak(state);
ch = state.input.charCodeAt(state.position);
lineBreaks++;
@@ -1970,13 +10137,13 @@ function skipSeparationSpace$1(state, allowComments, checkIndent) {
}
if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
- throwWarning$1(state, 'deficient indentation');
+ throwWarning(state, 'deficient indentation');
}
return lineBreaks;
}
-function testDocumentSeparator$1(state) {
+function testDocumentSeparator(state) {
var _position = state.position,
ch;
@@ -1992,7 +10159,7 @@ function testDocumentSeparator$1(state) {
ch = state.input.charCodeAt(_position);
- if (ch === 0 || is_WS_OR_EOL$1(ch)) {
+ if (ch === 0 || is_WS_OR_EOL(ch)) {
return true;
}
}
@@ -2000,16 +10167,16 @@ function testDocumentSeparator$1(state) {
return false;
}
-function writeFoldedLines$1(state, count) {
+function writeFoldedLines(state, count) {
if (count === 1) {
state.result += ' ';
} else if (count > 1) {
- state.result += common$6.repeat('\n', count - 1);
+ state.result += common$4.repeat('\n', count - 1);
}
}
-function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
+function readPlainScalar(state, nodeIndent, withinFlowCollection) {
var preceding,
following,
captureStart,
@@ -2024,8 +10191,8 @@ function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
ch = state.input.charCodeAt(state.position);
- if (is_WS_OR_EOL$1(ch) ||
- is_FLOW_INDICATOR$1(ch) ||
+ if (is_WS_OR_EOL(ch) ||
+ is_FLOW_INDICATOR(ch) ||
ch === 0x23/* # */ ||
ch === 0x26/* & */ ||
ch === 0x2A/* * */ ||
@@ -2043,8 +10210,8 @@ function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
following = state.input.charCodeAt(state.position + 1);
- if (is_WS_OR_EOL$1(following) ||
- withinFlowCollection && is_FLOW_INDICATOR$1(following)) {
+ if (is_WS_OR_EOL(following) ||
+ withinFlowCollection && is_FLOW_INDICATOR(following)) {
return false;
}
}
@@ -2058,27 +10225,27 @@ function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
if (ch === 0x3A/* : */) {
following = state.input.charCodeAt(state.position + 1);
- if (is_WS_OR_EOL$1(following) ||
- withinFlowCollection && is_FLOW_INDICATOR$1(following)) {
+ if (is_WS_OR_EOL(following) ||
+ withinFlowCollection && is_FLOW_INDICATOR(following)) {
break;
}
} else if (ch === 0x23/* # */) {
preceding = state.input.charCodeAt(state.position - 1);
- if (is_WS_OR_EOL$1(preceding)) {
+ if (is_WS_OR_EOL(preceding)) {
break;
}
- } else if ((state.position === state.lineStart && testDocumentSeparator$1(state)) ||
- withinFlowCollection && is_FLOW_INDICATOR$1(ch)) {
+ } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
+ withinFlowCollection && is_FLOW_INDICATOR(ch)) {
break;
- } else if (is_EOL$1(ch)) {
+ } else if (is_EOL(ch)) {
_line = state.line;
_lineStart = state.lineStart;
_lineIndent = state.lineIndent;
- skipSeparationSpace$1(state, false, -1);
+ skipSeparationSpace(state, false, -1);
if (state.lineIndent >= nodeIndent) {
hasPendingContent = true;
@@ -2094,20 +10261,20 @@ function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
}
if (hasPendingContent) {
- captureSegment$1(state, captureStart, captureEnd, false);
- writeFoldedLines$1(state, state.line - _line);
+ captureSegment(state, captureStart, captureEnd, false);
+ writeFoldedLines(state, state.line - _line);
captureStart = captureEnd = state.position;
hasPendingContent = false;
}
- if (!is_WHITE_SPACE$1(ch)) {
+ if (!is_WHITE_SPACE(ch)) {
captureEnd = state.position + 1;
}
ch = state.input.charCodeAt(++state.position);
}
- captureSegment$1(state, captureStart, captureEnd, false);
+ captureSegment(state, captureStart, captureEnd, false);
if (state.result) {
return true;
@@ -2118,7 +10285,7 @@ function readPlainScalar$1(state, nodeIndent, withinFlowCollection) {
return false;
}
-function readSingleQuotedScalar$1(state, nodeIndent) {
+function readSingleQuotedScalar(state, nodeIndent) {
var ch,
captureStart, captureEnd;
@@ -2135,7 +10302,7 @@ function readSingleQuotedScalar$1(state, nodeIndent) {
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
if (ch === 0x27/* ' */) {
- captureSegment$1(state, captureStart, state.position, true);
+ captureSegment(state, captureStart, state.position, true);
ch = state.input.charCodeAt(++state.position);
if (ch === 0x27/* ' */) {
@@ -2146,13 +10313,13 @@ function readSingleQuotedScalar$1(state, nodeIndent) {
return true;
}
- } else if (is_EOL$1(ch)) {
- captureSegment$1(state, captureStart, captureEnd, true);
- writeFoldedLines$1(state, skipSeparationSpace$1(state, false, nodeIndent));
+ } else if (is_EOL(ch)) {
+ captureSegment(state, captureStart, captureEnd, true);
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
captureStart = captureEnd = state.position;
- } else if (state.position === state.lineStart && testDocumentSeparator$1(state)) {
- throwError$2(state, 'unexpected end of the document within a single quoted scalar');
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+ throwError$1(state, 'unexpected end of the document within a single quoted scalar');
} else {
state.position++;
@@ -2160,10 +10327,10 @@ function readSingleQuotedScalar$1(state, nodeIndent) {
}
}
- throwError$2(state, 'unexpected end of the stream within a single quoted scalar');
+ throwError$1(state, 'unexpected end of the stream within a single quoted scalar');
}
-function readDoubleQuotedScalar$1(state, nodeIndent) {
+function readDoubleQuotedScalar(state, nodeIndent) {
var captureStart,
captureEnd,
hexLength,
@@ -2184,54 +10351,54 @@ function readDoubleQuotedScalar$1(state, nodeIndent) {
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
if (ch === 0x22/* " */) {
- captureSegment$1(state, captureStart, state.position, true);
+ captureSegment(state, captureStart, state.position, true);
state.position++;
return true;
} else if (ch === 0x5C/* \ */) {
- captureSegment$1(state, captureStart, state.position, true);
+ captureSegment(state, captureStart, state.position, true);
ch = state.input.charCodeAt(++state.position);
- if (is_EOL$1(ch)) {
- skipSeparationSpace$1(state, false, nodeIndent);
+ if (is_EOL(ch)) {
+ skipSeparationSpace(state, false, nodeIndent);
// TODO: rework to inline fn with no type cast?
- } else if (ch < 256 && simpleEscapeCheck$1[ch]) {
- state.result += simpleEscapeMap$1[ch];
+ } else if (ch < 256 && simpleEscapeCheck[ch]) {
+ state.result += simpleEscapeMap[ch];
state.position++;
- } else if ((tmp = escapedHexLen$1(ch)) > 0) {
+ } else if ((tmp = escapedHexLen(ch)) > 0) {
hexLength = tmp;
hexResult = 0;
for (; hexLength > 0; hexLength--) {
ch = state.input.charCodeAt(++state.position);
- if ((tmp = fromHexCode$1(ch)) >= 0) {
+ if ((tmp = fromHexCode(ch)) >= 0) {
hexResult = (hexResult << 4) + tmp;
} else {
- throwError$2(state, 'expected hexadecimal character');
+ throwError$1(state, 'expected hexadecimal character');
}
}
- state.result += charFromCodepoint$1(hexResult);
+ state.result += charFromCodepoint(hexResult);
state.position++;
} else {
- throwError$2(state, 'unknown escape sequence');
+ throwError$1(state, 'unknown escape sequence');
}
captureStart = captureEnd = state.position;
- } else if (is_EOL$1(ch)) {
- captureSegment$1(state, captureStart, captureEnd, true);
- writeFoldedLines$1(state, skipSeparationSpace$1(state, false, nodeIndent));
+ } else if (is_EOL(ch)) {
+ captureSegment(state, captureStart, captureEnd, true);
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
captureStart = captureEnd = state.position;
- } else if (state.position === state.lineStart && testDocumentSeparator$1(state)) {
- throwError$2(state, 'unexpected end of the document within a double quoted scalar');
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+ throwError$1(state, 'unexpected end of the document within a double quoted scalar');
} else {
state.position++;
@@ -2239,12 +10406,14 @@ function readDoubleQuotedScalar$1(state, nodeIndent) {
}
}
- throwError$2(state, 'unexpected end of the stream within a double quoted scalar');
+ throwError$1(state, 'unexpected end of the stream within a double quoted scalar');
}
-function readFlowCollection$1(state, nodeIndent) {
+function readFlowCollection(state, nodeIndent) {
var readNext = true,
_line,
+ _lineStart,
+ _pos,
_tag = state.tag,
_result,
_anchor = state.anchor,
@@ -2253,7 +10422,7 @@ function readFlowCollection$1(state, nodeIndent) {
isPair,
isExplicitPair,
isMapping,
- overridableKeys = {},
+ overridableKeys = Object.create(null),
keyNode,
keyTag,
valueNode,
@@ -2280,7 +10449,7 @@ function readFlowCollection$1(state, nodeIndent) {
ch = state.input.charCodeAt(++state.position);
while (ch !== 0) {
- skipSeparationSpace$1(state, true, nodeIndent);
+ skipSeparationSpace(state, true, nodeIndent);
ch = state.input.charCodeAt(state.position);
@@ -2292,7 +10461,10 @@ function readFlowCollection$1(state, nodeIndent) {
state.result = _result;
return true;
} else if (!readNext) {
- throwError$2(state, 'missed comma between flow collection entries');
+ throwError$1(state, 'missed comma between flow collection entries');
+ } else if (ch === 0x2C/* , */) {
+ // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
+ throwError$1(state, "expected the node content, but found ','");
}
keyTag = keyNode = valueNode = null;
@@ -2301,38 +10473,40 @@ function readFlowCollection$1(state, nodeIndent) {
if (ch === 0x3F/* ? */) {
following = state.input.charCodeAt(state.position + 1);
- if (is_WS_OR_EOL$1(following)) {
+ if (is_WS_OR_EOL(following)) {
isPair = isExplicitPair = true;
state.position++;
- skipSeparationSpace$1(state, true, nodeIndent);
+ skipSeparationSpace(state, true, nodeIndent);
}
}
- _line = state.line;
- composeNode$1(state, nodeIndent, CONTEXT_FLOW_IN$1, false, true);
+ _line = state.line; // Save the current line.
+ _lineStart = state.lineStart;
+ _pos = state.position;
+ composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
keyTag = state.tag;
keyNode = state.result;
- skipSeparationSpace$1(state, true, nodeIndent);
+ skipSeparationSpace(state, true, nodeIndent);
ch = state.input.charCodeAt(state.position);
if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
isPair = true;
ch = state.input.charCodeAt(++state.position);
- skipSeparationSpace$1(state, true, nodeIndent);
- composeNode$1(state, nodeIndent, CONTEXT_FLOW_IN$1, false, true);
+ skipSeparationSpace(state, true, nodeIndent);
+ composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
valueNode = state.result;
}
if (isMapping) {
- storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, valueNode);
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
} else if (isPair) {
- _result.push(storeMappingPair$1(state, null, overridableKeys, keyTag, keyNode, valueNode));
+ _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
} else {
_result.push(keyNode);
}
- skipSeparationSpace$1(state, true, nodeIndent);
+ skipSeparationSpace(state, true, nodeIndent);
ch = state.input.charCodeAt(state.position);
@@ -2344,13 +10518,13 @@ function readFlowCollection$1(state, nodeIndent) {
}
}
- throwError$2(state, 'unexpected end of the stream within a flow collection');
+ throwError$1(state, 'unexpected end of the stream within a flow collection');
}
-function readBlockScalar$1(state, nodeIndent) {
+function readBlockScalar(state, nodeIndent) {
var captureStart,
folding,
- chomping = CHOMPING_CLIP$1,
+ chomping = CHOMPING_CLIP,
didReadContent = false,
detectedIndent = false,
textIndent = nodeIndent,
@@ -2376,20 +10550,20 @@ function readBlockScalar$1(state, nodeIndent) {
ch = state.input.charCodeAt(++state.position);
if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
- if (CHOMPING_CLIP$1 === chomping) {
- chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP$1 : CHOMPING_STRIP$1;
+ if (CHOMPING_CLIP === chomping) {
+ chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
} else {
- throwError$2(state, 'repeat of a chomping mode identifier');
+ throwError$1(state, 'repeat of a chomping mode identifier');
}
- } else if ((tmp = fromDecimalCode$1(ch)) >= 0) {
+ } else if ((tmp = fromDecimalCode(ch)) >= 0) {
if (tmp === 0) {
- throwError$2(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
+ throwError$1(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
} else if (!detectedIndent) {
textIndent = nodeIndent + tmp - 1;
detectedIndent = true;
} else {
- throwError$2(state, 'repeat of an indentation width identifier');
+ throwError$1(state, 'repeat of an indentation width identifier');
}
} else {
@@ -2397,18 +10571,18 @@ function readBlockScalar$1(state, nodeIndent) {
}
}
- if (is_WHITE_SPACE$1(ch)) {
+ if (is_WHITE_SPACE(ch)) {
do { ch = state.input.charCodeAt(++state.position); }
- while (is_WHITE_SPACE$1(ch));
+ while (is_WHITE_SPACE(ch));
if (ch === 0x23/* # */) {
do { ch = state.input.charCodeAt(++state.position); }
- while (!is_EOL$1(ch) && (ch !== 0));
+ while (!is_EOL(ch) && (ch !== 0));
}
}
while (ch !== 0) {
- readLineBreak$1(state);
+ readLineBreak(state);
state.lineIndent = 0;
ch = state.input.charCodeAt(state.position);
@@ -2423,7 +10597,7 @@ function readBlockScalar$1(state, nodeIndent) {
textIndent = state.lineIndent;
}
- if (is_EOL$1(ch)) {
+ if (is_EOL(ch)) {
emptyLines++;
continue;
}
@@ -2432,9 +10606,9 @@ function readBlockScalar$1(state, nodeIndent) {
if (state.lineIndent < textIndent) {
// Perform the chomping.
- if (chomping === CHOMPING_KEEP$1) {
- state.result += common$6.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
- } else if (chomping === CHOMPING_CLIP$1) {
+ if (chomping === CHOMPING_KEEP) {
+ state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+ } else if (chomping === CHOMPING_CLIP) {
if (didReadContent) { // i.e. only if the scalar is not empty.
state.result += '\n';
}
@@ -2448,15 +10622,15 @@ function readBlockScalar$1(state, nodeIndent) {
if (folding) {
// Lines starting with white space characters (more-indented lines) are not folded.
- if (is_WHITE_SPACE$1(ch)) {
+ if (is_WHITE_SPACE(ch)) {
atMoreIndented = true;
// except for the first content line (cf. Example 8.1)
- state.result += common$6.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+ state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
// End of more-indented block.
} else if (atMoreIndented) {
atMoreIndented = false;
- state.result += common$6.repeat('\n', emptyLines + 1);
+ state.result += common$4.repeat('\n', emptyLines + 1);
// Just one line break - perceive as the same line.
} else if (emptyLines === 0) {
@@ -2466,13 +10640,13 @@ function readBlockScalar$1(state, nodeIndent) {
// Several line breaks - perceive as different lines.
} else {
- state.result += common$6.repeat('\n', emptyLines);
+ state.result += common$4.repeat('\n', emptyLines);
}
// Literal style: just add exact number of line breaks between content lines.
} else {
// Keep all line breaks except the header line break.
- state.result += common$6.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+ state.result += common$4.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
}
didReadContent = true;
@@ -2480,17 +10654,17 @@ function readBlockScalar$1(state, nodeIndent) {
emptyLines = 0;
captureStart = state.position;
- while (!is_EOL$1(ch) && (ch !== 0)) {
+ while (!is_EOL(ch) && (ch !== 0)) {
ch = state.input.charCodeAt(++state.position);
}
- captureSegment$1(state, captureStart, state.position, false);
+ captureSegment(state, captureStart, state.position, false);
}
return true;
}
-function readBlockSequence$1(state, nodeIndent) {
+function readBlockSequence(state, nodeIndent) {
var _line,
_tag = state.tag,
_anchor = state.anchor,
@@ -2499,6 +10673,10 @@ function readBlockSequence$1(state, nodeIndent) {
detected = false,
ch;
+ // there is a leading tab before this token, so it can't be a block sequence/mapping;
+ // it can still be flow sequence/mapping or a scalar
+ if (state.firstTabInLine !== -1) return false;
+
if (state.anchor !== null) {
state.anchorMap[state.anchor] = _result;
}
@@ -2506,6 +10684,10 @@ function readBlockSequence$1(state, nodeIndent) {
ch = state.input.charCodeAt(state.position);
while (ch !== 0) {
+ if (state.firstTabInLine !== -1) {
+ state.position = state.firstTabInLine;
+ throwError$1(state, 'tab characters must not be used in indentation');
+ }
if (ch !== 0x2D/* - */) {
break;
@@ -2513,14 +10695,14 @@ function readBlockSequence$1(state, nodeIndent) {
following = state.input.charCodeAt(state.position + 1);
- if (!is_WS_OR_EOL$1(following)) {
+ if (!is_WS_OR_EOL(following)) {
break;
}
detected = true;
state.position++;
- if (skipSeparationSpace$1(state, true, -1)) {
+ if (skipSeparationSpace(state, true, -1)) {
if (state.lineIndent <= nodeIndent) {
_result.push(null);
ch = state.input.charCodeAt(state.position);
@@ -2529,14 +10711,14 @@ function readBlockSequence$1(state, nodeIndent) {
}
_line = state.line;
- composeNode$1(state, nodeIndent, CONTEXT_BLOCK_IN$1, false, true);
+ composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
_result.push(state.result);
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
ch = state.input.charCodeAt(state.position);
if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
- throwError$2(state, 'bad indentation of a sequence entry');
+ throwError$1(state, 'bad indentation of a sequence entry');
} else if (state.lineIndent < nodeIndent) {
break;
}
@@ -2552,15 +10734,17 @@ function readBlockSequence$1(state, nodeIndent) {
return false;
}
-function readBlockMapping$1(state, nodeIndent, flowIndent) {
+function readBlockMapping(state, nodeIndent, flowIndent) {
var following,
allowCompact,
_line,
- _pos,
+ _keyLine,
+ _keyLineStart,
+ _keyPos,
_tag = state.tag,
_anchor = state.anchor,
_result = {},
- overridableKeys = {},
+ overridableKeys = Object.create(null),
keyTag = null,
keyNode = null,
valueNode = null,
@@ -2568,6 +10752,10 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
detected = false,
ch;
+ // there is a leading tab before this token, so it can't be a block sequence/mapping;
+ // it can still be flow sequence/mapping or a scalar
+ if (state.firstTabInLine !== -1) return false;
+
if (state.anchor !== null) {
state.anchorMap[state.anchor] = _result;
}
@@ -2575,19 +10763,23 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
ch = state.input.charCodeAt(state.position);
while (ch !== 0) {
+ if (!atExplicitKey && state.firstTabInLine !== -1) {
+ state.position = state.firstTabInLine;
+ throwError$1(state, 'tab characters must not be used in indentation');
+ }
+
following = state.input.charCodeAt(state.position + 1);
_line = state.line; // Save the current line.
- _pos = state.position;
//
// Explicit notation case. There are two separate blocks:
// first for the key (denoted by "?") and second for the value (denoted by ":")
//
- if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL$1(following)) {
+ if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
if (ch === 0x3F/* ? */) {
if (atExplicitKey) {
- storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, null);
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
keyTag = keyNode = valueNode = null;
}
@@ -2601,7 +10793,7 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
allowCompact = true;
} else {
- throwError$2(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
+ throwError$1(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
}
state.position += 1;
@@ -2610,24 +10802,33 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
//
// Implicit notation case. Flow-style node as the key first, then ":", and the value.
//
- } else if (composeNode$1(state, flowIndent, CONTEXT_FLOW_OUT$1, false, true)) {
+ } else {
+ _keyLine = state.line;
+ _keyLineStart = state.lineStart;
+ _keyPos = state.position;
+
+ if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+ // Neither implicit nor explicit notation.
+ // Reading is done. Go to the epilogue.
+ break;
+ }
if (state.line === _line) {
ch = state.input.charCodeAt(state.position);
- while (is_WHITE_SPACE$1(ch)) {
+ while (is_WHITE_SPACE(ch)) {
ch = state.input.charCodeAt(++state.position);
}
if (ch === 0x3A/* : */) {
ch = state.input.charCodeAt(++state.position);
- if (!is_WS_OR_EOL$1(ch)) {
- throwError$2(state, 'a whitespace character is expected after the key-value separator within a block mapping');
+ if (!is_WS_OR_EOL(ch)) {
+ throwError$1(state, 'a whitespace character is expected after the key-value separator within a block mapping');
}
if (atExplicitKey) {
- storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, null);
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
keyTag = keyNode = valueNode = null;
}
@@ -2638,7 +10839,7 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
keyNode = state.result;
} else if (detected) {
- throwError$2(state, 'can not read an implicit mapping pair; a colon is missed');
+ throwError$1(state, 'can not read an implicit mapping pair; a colon is missed');
} else {
state.tag = _tag;
@@ -2647,23 +10848,26 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
}
} else if (detected) {
- throwError$2(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
+ throwError$1(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
} else {
state.tag = _tag;
state.anchor = _anchor;
return true; // Keep the result of `composeNode`.
}
-
- } else {
- break; // Reading is done. Go to the epilogue.
}
//
// Common reading code for both explicit and implicit notations.
//
if (state.line === _line || state.lineIndent > nodeIndent) {
- if (composeNode$1(state, nodeIndent, CONTEXT_BLOCK_OUT$1, true, allowCompact)) {
+ if (atExplicitKey) {
+ _keyLine = state.line;
+ _keyLineStart = state.lineStart;
+ _keyPos = state.position;
+ }
+
+ if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
if (atExplicitKey) {
keyNode = state.result;
} else {
@@ -2672,16 +10876,16 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
}
if (!atExplicitKey) {
- storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
keyTag = keyNode = valueNode = null;
}
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
ch = state.input.charCodeAt(state.position);
}
- if (state.lineIndent > nodeIndent && (ch !== 0)) {
- throwError$2(state, 'bad indentation of a mapping entry');
+ if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
+ throwError$1(state, 'bad indentation of a mapping entry');
} else if (state.lineIndent < nodeIndent) {
break;
}
@@ -2693,7 +10897,7 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
// Special case: last mapping's node contains only the key in explicit notation.
if (atExplicitKey) {
- storeMappingPair$1(state, _result, overridableKeys, keyTag, keyNode, null);
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
}
// Expose the resulting mapping.
@@ -2707,7 +10911,7 @@ function readBlockMapping$1(state, nodeIndent, flowIndent) {
return detected;
}
-function readTagProperty$1(state) {
+function readTagProperty(state) {
var _position,
isVerbatim = false,
isNamed = false,
@@ -2720,7 +10924,7 @@ function readTagProperty$1(state) {
if (ch !== 0x21/* ! */) return false;
if (state.tag !== null) {
- throwError$2(state, 'duplication of a tag property');
+ throwError$1(state, 'duplication of a tag property');
}
ch = state.input.charCodeAt(++state.position);
@@ -2748,23 +10952,23 @@ function readTagProperty$1(state) {
tagName = state.input.slice(_position, state.position);
ch = state.input.charCodeAt(++state.position);
} else {
- throwError$2(state, 'unexpected end of the stream within a verbatim tag');
+ throwError$1(state, 'unexpected end of the stream within a verbatim tag');
}
} else {
- while (ch !== 0 && !is_WS_OR_EOL$1(ch)) {
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
if (ch === 0x21/* ! */) {
if (!isNamed) {
tagHandle = state.input.slice(_position - 1, state.position + 1);
- if (!PATTERN_TAG_HANDLE$1.test(tagHandle)) {
- throwError$2(state, 'named tag handle cannot contain such characters');
+ if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+ throwError$1(state, 'named tag handle cannot contain such characters');
}
isNamed = true;
_position = state.position + 1;
} else {
- throwError$2(state, 'tag suffix cannot contain exclamation marks');
+ throwError$1(state, 'tag suffix cannot contain exclamation marks');
}
}
@@ -2773,19 +10977,25 @@ function readTagProperty$1(state) {
tagName = state.input.slice(_position, state.position);
- if (PATTERN_FLOW_INDICATORS$1.test(tagName)) {
- throwError$2(state, 'tag suffix cannot contain flow indicator characters');
+ if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+ throwError$1(state, 'tag suffix cannot contain flow indicator characters');
}
}
- if (tagName && !PATTERN_TAG_URI$1.test(tagName)) {
- throwError$2(state, 'tag name cannot contain such characters: ' + tagName);
+ if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+ throwError$1(state, 'tag name cannot contain such characters: ' + tagName);
+ }
+
+ try {
+ tagName = decodeURIComponent(tagName);
+ } catch (err) {
+ throwError$1(state, 'tag name is malformed: ' + tagName);
}
if (isVerbatim) {
state.tag = tagName;
- } else if (_hasOwnProperty$5.call(state.tagMap, tagHandle)) {
+ } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
state.tag = state.tagMap[tagHandle] + tagName;
} else if (tagHandle === '!') {
@@ -2795,13 +11005,13 @@ function readTagProperty$1(state) {
state.tag = 'tag:yaml.org,2002:' + tagName;
} else {
- throwError$2(state, 'undeclared tag handle "' + tagHandle + '"');
+ throwError$1(state, 'undeclared tag handle "' + tagHandle + '"');
}
return true;
}
-function readAnchorProperty$1(state) {
+function readAnchorProperty(state) {
var _position,
ch;
@@ -2810,25 +11020,25 @@ function readAnchorProperty$1(state) {
if (ch !== 0x26/* & */) return false;
if (state.anchor !== null) {
- throwError$2(state, 'duplication of an anchor property');
+ throwError$1(state, 'duplication of an anchor property');
}
ch = state.input.charCodeAt(++state.position);
_position = state.position;
- while (ch !== 0 && !is_WS_OR_EOL$1(ch) && !is_FLOW_INDICATOR$1(ch)) {
+ while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
ch = state.input.charCodeAt(++state.position);
}
if (state.position === _position) {
- throwError$2(state, 'name of an anchor node must contain at least one character');
+ throwError$1(state, 'name of an anchor node must contain at least one character');
}
state.anchor = state.input.slice(_position, state.position);
return true;
}
-function readAlias$1(state) {
+function readAlias(state) {
var _position, alias,
ch;
@@ -2839,26 +11049,26 @@ function readAlias$1(state) {
ch = state.input.charCodeAt(++state.position);
_position = state.position;
- while (ch !== 0 && !is_WS_OR_EOL$1(ch) && !is_FLOW_INDICATOR$1(ch)) {
+ while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
ch = state.input.charCodeAt(++state.position);
}
if (state.position === _position) {
- throwError$2(state, 'name of an alias node must contain at least one character');
+ throwError$1(state, 'name of an alias node must contain at least one character');
}
alias = state.input.slice(_position, state.position);
- if (!_hasOwnProperty$5.call(state.anchorMap, alias)) {
- throwError$2(state, 'unidentified alias "' + alias + '"');
+ if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
+ throwError$1(state, 'unidentified alias "' + alias + '"');
}
state.result = state.anchorMap[alias];
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
return true;
}
-function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
var allowBlockStyles,
allowBlockScalars,
allowBlockCollections,
@@ -2867,6 +11077,7 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
hasContent = false,
typeIndex,
typeQuantity,
+ typeList,
type,
flowIndent,
blockIndent;
@@ -2881,11 +11092,11 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
state.result = null;
allowBlockStyles = allowBlockScalars = allowBlockCollections =
- CONTEXT_BLOCK_OUT$1 === nodeContext ||
- CONTEXT_BLOCK_IN$1 === nodeContext;
+ CONTEXT_BLOCK_OUT === nodeContext ||
+ CONTEXT_BLOCK_IN === nodeContext;
if (allowToSeek) {
- if (skipSeparationSpace$1(state, true, -1)) {
+ if (skipSeparationSpace(state, true, -1)) {
atNewLine = true;
if (state.lineIndent > parentIndent) {
@@ -2899,8 +11110,8 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
}
if (indentStatus === 1) {
- while (readTagProperty$1(state) || readAnchorProperty$1(state)) {
- if (skipSeparationSpace$1(state, true, -1)) {
+ while (readTagProperty(state) || readAnchorProperty(state)) {
+ if (skipSeparationSpace(state, true, -1)) {
atNewLine = true;
allowBlockCollections = allowBlockStyles;
@@ -2921,8 +11132,8 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
allowBlockCollections = atNewLine || allowCompact;
}
- if (indentStatus === 1 || CONTEXT_BLOCK_OUT$1 === nodeContext) {
- if (CONTEXT_FLOW_IN$1 === nodeContext || CONTEXT_FLOW_OUT$1 === nodeContext) {
+ if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+ if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
flowIndent = parentIndent;
} else {
flowIndent = parentIndent + 1;
@@ -2932,24 +11143,24 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
if (indentStatus === 1) {
if (allowBlockCollections &&
- (readBlockSequence$1(state, blockIndent) ||
- readBlockMapping$1(state, blockIndent, flowIndent)) ||
- readFlowCollection$1(state, flowIndent)) {
+ (readBlockSequence(state, blockIndent) ||
+ readBlockMapping(state, blockIndent, flowIndent)) ||
+ readFlowCollection(state, flowIndent)) {
hasContent = true;
} else {
- if ((allowBlockScalars && readBlockScalar$1(state, flowIndent)) ||
- readSingleQuotedScalar$1(state, flowIndent) ||
- readDoubleQuotedScalar$1(state, flowIndent)) {
+ if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
+ readSingleQuotedScalar(state, flowIndent) ||
+ readDoubleQuotedScalar(state, flowIndent)) {
hasContent = true;
- } else if (readAlias$1(state)) {
+ } else if (readAlias(state)) {
hasContent = true;
if (state.tag !== null || state.anchor !== null) {
- throwError$2(state, 'alias node should not have any properties');
+ throwError$1(state, 'alias node should not have any properties');
}
- } else if (readPlainScalar$1(state, flowIndent, CONTEXT_FLOW_IN$1 === nodeContext)) {
+ } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
hasContent = true;
if (state.tag === null) {
@@ -2964,51 +11175,69 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
} else if (indentStatus === 0) {
// Special case: block sequences are allowed to have same indentation level as the parent.
// http://www.yaml.org/spec/1.2/spec.html#id2799784
- hasContent = allowBlockCollections && readBlockSequence$1(state, blockIndent);
+ hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
}
}
- if (state.tag !== null && state.tag !== '!') {
- if (state.tag === '?') {
- // Implicit resolving is not allowed for non-scalar types, and '?'
- // non-specific tag is only automatically assigned to plain scalars.
- //
- // We only need to check kind conformity in case user explicitly assigns '?'
- // tag, for example like this: "!<?> [0]"
- //
- if (state.result !== null && state.kind !== 'scalar') {
- throwError$2(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
- }
-
- for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
- type = state.implicitTypes[typeIndex];
+ if (state.tag === null) {
+ if (state.anchor !== null) {
+ state.anchorMap[state.anchor] = state.result;
+ }
- if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
- state.result = type.construct(state.result);
- state.tag = type.tag;
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = state.result;
- }
- break;
- }
- }
- } else if (_hasOwnProperty$5.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
- type = state.typeMap[state.kind || 'fallback'][state.tag];
+ } else if (state.tag === '?') {
+ // Implicit resolving is not allowed for non-scalar types, and '?'
+ // non-specific tag is only automatically assigned to plain scalars.
+ //
+ // We only need to check kind conformity in case user explicitly assigns '?'
+ // tag, for example like this: "!<?> [0]"
+ //
+ if (state.result !== null && state.kind !== 'scalar') {
+ throwError$1(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+ }
- if (state.result !== null && type.kind !== state.kind) {
- throwError$2(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
- }
+ for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+ type = state.implicitTypes[typeIndex];
- if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched
- throwError$2(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
- } else {
+ if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
state.result = type.construct(state.result);
+ state.tag = type.tag;
if (state.anchor !== null) {
state.anchorMap[state.anchor] = state.result;
}
+ break;
+ }
+ }
+ } else if (state.tag !== '!') {
+ if (_hasOwnProperty$1.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+ type = state.typeMap[state.kind || 'fallback'][state.tag];
+ } else {
+ // looking for multi type
+ type = null;
+ typeList = state.typeMap.multi[state.kind || 'fallback'];
+
+ for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
+ if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+ type = typeList[typeIndex];
+ break;
+ }
}
+ }
+
+ if (!type) {
+ throwError$1(state, 'unknown tag !<' + state.tag + '>');
+ }
+
+ if (state.result !== null && type.kind !== state.kind) {
+ throwError$1(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
+ }
+
+ if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
+ throwError$1(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
} else {
- throwError$2(state, 'unknown tag !<' + state.tag + '>');
+ state.result = type.construct(state.result, state.tag);
+ if (state.anchor !== null) {
+ state.anchorMap[state.anchor] = state.result;
+ }
}
}
@@ -3018,7 +11247,7 @@ function composeNode$1(state, parentIndent, nodeContext, allowToSeek, allowCompa
return state.tag !== null || state.anchor !== null || hasContent;
}
-function readDocument$1(state) {
+function readDocument(state) {
var documentStart = state.position,
_position,
directiveName,
@@ -3028,11 +11257,11 @@ function readDocument$1(state) {
state.version = null;
state.checkLineBreaks = state.legacy;
- state.tagMap = {};
- state.anchorMap = {};
+ state.tagMap = Object.create(null);
+ state.anchorMap = Object.create(null);
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
ch = state.input.charCodeAt(state.position);
@@ -3044,7 +11273,7 @@ function readDocument$1(state) {
ch = state.input.charCodeAt(++state.position);
_position = state.position;
- while (ch !== 0 && !is_WS_OR_EOL$1(ch)) {
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
ch = state.input.charCodeAt(++state.position);
}
@@ -3052,81 +11281,81 @@ function readDocument$1(state) {
directiveArgs = [];
if (directiveName.length < 1) {
- throwError$2(state, 'directive name must not be less than one character in length');
+ throwError$1(state, 'directive name must not be less than one character in length');
}
while (ch !== 0) {
- while (is_WHITE_SPACE$1(ch)) {
+ while (is_WHITE_SPACE(ch)) {
ch = state.input.charCodeAt(++state.position);
}
if (ch === 0x23/* # */) {
do { ch = state.input.charCodeAt(++state.position); }
- while (ch !== 0 && !is_EOL$1(ch));
+ while (ch !== 0 && !is_EOL(ch));
break;
}
- if (is_EOL$1(ch)) break;
+ if (is_EOL(ch)) break;
_position = state.position;
- while (ch !== 0 && !is_WS_OR_EOL$1(ch)) {
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
ch = state.input.charCodeAt(++state.position);
}
directiveArgs.push(state.input.slice(_position, state.position));
}
- if (ch !== 0) readLineBreak$1(state);
+ if (ch !== 0) readLineBreak(state);
- if (_hasOwnProperty$5.call(directiveHandlers$1, directiveName)) {
- directiveHandlers$1[directiveName](state, directiveName, directiveArgs);
+ if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
+ directiveHandlers[directiveName](state, directiveName, directiveArgs);
} else {
- throwWarning$1(state, 'unknown document directive "' + directiveName + '"');
+ throwWarning(state, 'unknown document directive "' + directiveName + '"');
}
}
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
if (state.lineIndent === 0 &&
state.input.charCodeAt(state.position) === 0x2D/* - */ &&
state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
state.position += 3;
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
} else if (hasDirectives) {
- throwError$2(state, 'directives end mark is expected');
+ throwError$1(state, 'directives end mark is expected');
}
- composeNode$1(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT$1, false, true);
- skipSeparationSpace$1(state, true, -1);
+ composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+ skipSeparationSpace(state, true, -1);
if (state.checkLineBreaks &&
- PATTERN_NON_ASCII_LINE_BREAKS$1.test(state.input.slice(documentStart, state.position))) {
- throwWarning$1(state, 'non-ASCII line breaks are interpreted as content');
+ PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
+ throwWarning(state, 'non-ASCII line breaks are interpreted as content');
}
state.documents.push(state.result);
- if (state.position === state.lineStart && testDocumentSeparator$1(state)) {
+ if (state.position === state.lineStart && testDocumentSeparator(state)) {
if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
state.position += 3;
- skipSeparationSpace$1(state, true, -1);
+ skipSeparationSpace(state, true, -1);
}
return;
}
if (state.position < (state.length - 1)) {
- throwError$2(state, 'end of the stream or a document separator is expected');
+ throwError$1(state, 'end of the stream or a document separator is expected');
} else {
return;
}
}
-function loadDocuments$1(input, options) {
+function loadDocuments(input, options) {
input = String(input);
options = options || {};
@@ -3144,13 +11373,13 @@ function loadDocuments$1(input, options) {
}
}
- var state = new State$3(input, options);
+ var state = new State$1(input, options);
var nullpos = input.indexOf('\0');
if (nullpos !== -1) {
state.position = nullpos;
- throwError$2(state, 'null byte is not allowed in input');
+ throwError$1(state, 'null byte is not allowed in input');
}
// Use 0 as string terminator. That significantly simplifies bounds check.
@@ -3162,20 +11391,20 @@ function loadDocuments$1(input, options) {
}
while (state.position < (state.length - 1)) {
- readDocument$1(state);
+ readDocument(state);
}
return state.documents;
}
-function loadAll$2(input, iterator, options) {
+function loadAll$1(input, iterator, options) {
if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
options = iterator;
iterator = null;
}
- var documents = loadDocuments$1(input, options);
+ var documents = loadDocuments(input, options);
if (typeof iterator !== 'function') {
return documents;
@@ -3187,8 +11416,8 @@ function loadAll$2(input, iterator, options) {
}
-function load$5(input, options) {
- var documents = loadDocuments$1(input, options);
+function load$1(input, options) {
+ var documents = loadDocuments(input, options);
if (documents.length === 0) {
/*eslint-disable no-undefined*/
@@ -3196,91 +11425,79 @@ function load$5(input, options) {
} else if (documents.length === 1) {
return documents[0];
}
- throw new YAMLException$3('expected a single document in the stream, but found more');
+ throw new exception('expected a single document in the stream, but found more');
}
-function safeLoadAll$1(input, iterator, options) {
- if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') {
- options = iterator;
- iterator = null;
- }
+var loadAll_1 = loadAll$1;
+var load_1 = load$1;
- return loadAll$2(input, iterator, common$6.extend({ schema: DEFAULT_SAFE_SCHEMA$1 }, options));
-}
+var loader = {
+ loadAll: loadAll_1,
+ load: load_1
+};
+/*eslint-disable no-use-before-define*/
-function safeLoad$1(input, options) {
- return load$5(input, common$6.extend({ schema: DEFAULT_SAFE_SCHEMA$1 }, options));
-}
-loader$2.loadAll = loadAll$2;
-loader$2.load = load$5;
-loader$2.safeLoadAll = safeLoadAll$1;
-loader$2.safeLoad = safeLoad$1;
-var dumper$2 = {};
-/*eslint-disable no-use-before-define*/
+var _toString = Object.prototype.toString;
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var CHAR_BOM = 0xFEFF;
+var CHAR_TAB = 0x09; /* Tab */
+var CHAR_LINE_FEED = 0x0A; /* LF */
+var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
+var CHAR_SPACE = 0x20; /* Space */
+var CHAR_EXCLAMATION = 0x21; /* ! */
+var CHAR_DOUBLE_QUOTE = 0x22; /* " */
+var CHAR_SHARP = 0x23; /* # */
+var CHAR_PERCENT = 0x25; /* % */
+var CHAR_AMPERSAND = 0x26; /* & */
+var CHAR_SINGLE_QUOTE = 0x27; /* ' */
+var CHAR_ASTERISK = 0x2A; /* * */
+var CHAR_COMMA = 0x2C; /* , */
+var CHAR_MINUS = 0x2D; /* - */
+var CHAR_COLON = 0x3A; /* : */
+var CHAR_EQUALS = 0x3D; /* = */
+var CHAR_GREATER_THAN = 0x3E; /* > */
+var CHAR_QUESTION = 0x3F; /* ? */
+var CHAR_COMMERCIAL_AT = 0x40; /* @ */
+var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
+var CHAR_GRAVE_ACCENT = 0x60; /* ` */
+var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
+var CHAR_VERTICAL_LINE = 0x7C; /* | */
+var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
+
+var ESCAPE_SEQUENCES = {};
+
+ESCAPE_SEQUENCES[0x00] = '\\0';
+ESCAPE_SEQUENCES[0x07] = '\\a';
+ESCAPE_SEQUENCES[0x08] = '\\b';
+ESCAPE_SEQUENCES[0x09] = '\\t';
+ESCAPE_SEQUENCES[0x0A] = '\\n';
+ESCAPE_SEQUENCES[0x0B] = '\\v';
+ESCAPE_SEQUENCES[0x0C] = '\\f';
+ESCAPE_SEQUENCES[0x0D] = '\\r';
+ESCAPE_SEQUENCES[0x1B] = '\\e';
+ESCAPE_SEQUENCES[0x22] = '\\"';
+ESCAPE_SEQUENCES[0x5C] = '\\\\';
+ESCAPE_SEQUENCES[0x85] = '\\N';
+ESCAPE_SEQUENCES[0xA0] = '\\_';
+ESCAPE_SEQUENCES[0x2028] = '\\L';
+ESCAPE_SEQUENCES[0x2029] = '\\P';
-var common$5 = common$b;
-var YAMLException$2 = exception$1;
-var DEFAULT_FULL_SCHEMA = default_full;
-var DEFAULT_SAFE_SCHEMA = default_safe;
-
-var _toString$3 = Object.prototype.toString;
-var _hasOwnProperty$4 = Object.prototype.hasOwnProperty;
-
-var CHAR_TAB$1 = 0x09; /* Tab */
-var CHAR_LINE_FEED$1 = 0x0A; /* LF */
-var CHAR_CARRIAGE_RETURN$1 = 0x0D; /* CR */
-var CHAR_SPACE$1 = 0x20; /* Space */
-var CHAR_EXCLAMATION$1 = 0x21; /* ! */
-var CHAR_DOUBLE_QUOTE$2 = 0x22; /* " */
-var CHAR_SHARP$1 = 0x23; /* # */
-var CHAR_PERCENT$1 = 0x25; /* % */
-var CHAR_AMPERSAND$1 = 0x26; /* & */
-var CHAR_SINGLE_QUOTE$2 = 0x27; /* ' */
-var CHAR_ASTERISK$2 = 0x2A; /* * */
-var CHAR_COMMA$3 = 0x2C; /* , */
-var CHAR_MINUS$1 = 0x2D; /* - */
-var CHAR_COLON$1 = 0x3A; /* : */
-var CHAR_EQUALS$1 = 0x3D; /* = */
-var CHAR_GREATER_THAN$1 = 0x3E; /* > */
-var CHAR_QUESTION$1 = 0x3F; /* ? */
-var CHAR_COMMERCIAL_AT$1 = 0x40; /* @ */
-var CHAR_LEFT_SQUARE_BRACKET$3 = 0x5B; /* [ */
-var CHAR_RIGHT_SQUARE_BRACKET$3 = 0x5D; /* ] */
-var CHAR_GRAVE_ACCENT$1 = 0x60; /* ` */
-var CHAR_LEFT_CURLY_BRACKET$1 = 0x7B; /* { */
-var CHAR_VERTICAL_LINE$1 = 0x7C; /* | */
-var CHAR_RIGHT_CURLY_BRACKET$1 = 0x7D; /* } */
-
-var ESCAPE_SEQUENCES$1 = {};
-
-ESCAPE_SEQUENCES$1[0x00] = '\\0';
-ESCAPE_SEQUENCES$1[0x07] = '\\a';
-ESCAPE_SEQUENCES$1[0x08] = '\\b';
-ESCAPE_SEQUENCES$1[0x09] = '\\t';
-ESCAPE_SEQUENCES$1[0x0A] = '\\n';
-ESCAPE_SEQUENCES$1[0x0B] = '\\v';
-ESCAPE_SEQUENCES$1[0x0C] = '\\f';
-ESCAPE_SEQUENCES$1[0x0D] = '\\r';
-ESCAPE_SEQUENCES$1[0x1B] = '\\e';
-ESCAPE_SEQUENCES$1[0x22] = '\\"';
-ESCAPE_SEQUENCES$1[0x5C] = '\\\\';
-ESCAPE_SEQUENCES$1[0x85] = '\\N';
-ESCAPE_SEQUENCES$1[0xA0] = '\\_';
-ESCAPE_SEQUENCES$1[0x2028] = '\\L';
-ESCAPE_SEQUENCES$1[0x2029] = '\\P';
-
-var DEPRECATED_BOOLEANS_SYNTAX$1 = [
+var DEPRECATED_BOOLEANS_SYNTAX = [
'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
];
-function compileStyleMap$1(schema, map) {
+var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+
+function compileStyleMap(schema, map) {
var result, keys, index, length, tag, style, type;
if (map === null) return {};
@@ -3297,7 +11514,7 @@ function compileStyleMap$1(schema, map) {
}
type = schema.compiledTypeMap['fallback'][tag];
- if (type && _hasOwnProperty$4.call(type.styleAliases, style)) {
+ if (type && _hasOwnProperty.call(type.styleAliases, style)) {
style = type.styleAliases[style];
}
@@ -3307,7 +11524,7 @@ function compileStyleMap$1(schema, map) {
return result;
}
-function encodeHex$1(character) {
+function encodeHex(character) {
var string, handle, length;
string = character.toString(16).toUpperCase();
@@ -3322,24 +11539,31 @@ function encodeHex$1(character) {
handle = 'U';
length = 8;
} else {
- throw new YAMLException$2('code point within a string may not be greater than 0xFFFFFFFF');
+ throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
}
- return '\\' + handle + common$5.repeat('0', length - string.length) + string;
+ return '\\' + handle + common$4.repeat('0', length - string.length) + string;
}
-function State$2(options) {
- this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
+
+var QUOTING_TYPE_SINGLE = 1,
+ QUOTING_TYPE_DOUBLE = 2;
+
+function State(options) {
+ this.schema = options['schema'] || _default$1;
this.indent = Math.max(1, (options['indent'] || 2));
this.noArrayIndent = options['noArrayIndent'] || false;
this.skipInvalid = options['skipInvalid'] || false;
- this.flowLevel = (common$5.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
- this.styleMap = compileStyleMap$1(this.schema, options['styles'] || null);
+ this.flowLevel = (common$4.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
+ this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
this.sortKeys = options['sortKeys'] || false;
this.lineWidth = options['lineWidth'] || 80;
this.noRefs = options['noRefs'] || false;
this.noCompatMode = options['noCompatMode'] || false;
this.condenseFlow = options['condenseFlow'] || false;
+ this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+ this.forceQuotes = options['forceQuotes'] || false;
+ this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null;
this.implicitTypes = this.schema.compiledImplicit;
this.explicitTypes = this.schema.compiledExplicit;
@@ -3352,8 +11576,8 @@ function State$2(options) {
}
// Indents every line in a string. Empty lines (\n only) are not indented.
-function indentString$1(string, spaces) {
- var ind = common$5.repeat(' ', spaces),
+function indentString(string, spaces) {
+ var ind = common$4.repeat(' ', spaces),
position = 0,
next = -1,
result = '',
@@ -3378,11 +11602,11 @@ function indentString$1(string, spaces) {
return result;
}
-function generateNextLine$1(state, level) {
- return '\n' + common$5.repeat(' ', state.indent * level);
+function generateNextLine(state, level) {
+ return '\n' + common$4.repeat(' ', state.indent * level);
}
-function testImplicitResolving$1(state, str) {
+function testImplicitResolving(state, str) {
var index, length, type;
for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
@@ -3397,96 +11621,128 @@ function testImplicitResolving$1(state, str) {
}
// [33] s-white ::= s-space | s-tab
-function isWhitespace$1(c) {
- return c === CHAR_SPACE$1 || c === CHAR_TAB$1;
+function isWhitespace(c) {
+ return c === CHAR_SPACE || c === CHAR_TAB;
}
// Returns true if the character can be printed without escaping.
// From YAML 1.2: "any allowed characters known to be non-printable
// should also be escaped. [However,] This isn’t mandatory"
// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
-function isPrintable$1(c) {
+function isPrintable(c) {
return (0x00020 <= c && c <= 0x00007E)
|| ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
- || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)
+ || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
|| (0x10000 <= c && c <= 0x10FFFF);
}
// [34] ns-char ::= nb-char - s-white
// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
// [26] b-char ::= b-line-feed | b-carriage-return
-// [24] b-line-feed ::= #xA /* LF */
-// [25] b-carriage-return ::= #xD /* CR */
-// [3] c-byte-order-mark ::= #xFEFF
-function isNsChar(c) {
- return isPrintable$1(c) && !isWhitespace$1(c)
- // byte-order-mark
- && c !== 0xFEFF
- // b-char
- && c !== CHAR_CARRIAGE_RETURN$1
- && c !== CHAR_LINE_FEED$1;
-}
-
-// Simplified test for values allowed after the first character in plain style.
-function isPlainSafe$1(c, prev) {
- // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
- // where nb-char ::= c-printable - b-char - c-byte-order-mark.
- return isPrintable$1(c) && c !== 0xFEFF
- // - c-flow-indicator
- && c !== CHAR_COMMA$3
- && c !== CHAR_LEFT_SQUARE_BRACKET$3
- && c !== CHAR_RIGHT_SQUARE_BRACKET$3
- && c !== CHAR_LEFT_CURLY_BRACKET$1
- && c !== CHAR_RIGHT_CURLY_BRACKET$1
- // - ":" - "#"
- // /* An ns-char preceding */ "#"
- && c !== CHAR_COLON$1
- && ((c !== CHAR_SHARP$1) || (prev && isNsChar(prev)));
+// Including s-white (for some reason, examples doesn't match specs in this aspect)
+// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
+function isNsCharOrWhitespace(c) {
+ return isPrintable(c)
+ && c !== CHAR_BOM
+ // - b-char
+ && c !== CHAR_CARRIAGE_RETURN
+ && c !== CHAR_LINE_FEED;
+}
+
+// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out
+// c = flow-in ⇒ ns-plain-safe-in
+// c = block-key ⇒ ns-plain-safe-out
+// c = flow-key ⇒ ns-plain-safe-in
+// [128] ns-plain-safe-out ::= ns-char
+// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator
+// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” )
+// | ( /* An ns-char preceding */ “#” )
+// | ( “:” /* Followed by an ns-plain-safe(c) */ )
+function isPlainSafe(c, prev, inblock) {
+ var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+ var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+ return (
+ // ns-plain-safe
+ inblock ? // c = flow-in
+ cIsNsCharOrWhitespace
+ : cIsNsCharOrWhitespace
+ // - c-flow-indicator
+ && c !== CHAR_COMMA
+ && c !== CHAR_LEFT_SQUARE_BRACKET
+ && c !== CHAR_RIGHT_SQUARE_BRACKET
+ && c !== CHAR_LEFT_CURLY_BRACKET
+ && c !== CHAR_RIGHT_CURLY_BRACKET
+ )
+ // ns-plain-char
+ && c !== CHAR_SHARP // false on '#'
+ && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
+ || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
+ || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
}
// Simplified test for values allowed as the first character in plain style.
-function isPlainSafeFirst$1(c) {
+function isPlainSafeFirst(c) {
// Uses a subset of ns-char - c-indicator
// where ns-char = nb-char - s-white.
- return isPrintable$1(c) && c !== 0xFEFF
- && !isWhitespace$1(c) // - s-white
+ // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
+ return isPrintable(c) && c !== CHAR_BOM
+ && !isWhitespace(c) // - s-white
// - (c-indicator ::=
// “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
- && c !== CHAR_MINUS$1
- && c !== CHAR_QUESTION$1
- && c !== CHAR_COLON$1
- && c !== CHAR_COMMA$3
- && c !== CHAR_LEFT_SQUARE_BRACKET$3
- && c !== CHAR_RIGHT_SQUARE_BRACKET$3
- && c !== CHAR_LEFT_CURLY_BRACKET$1
- && c !== CHAR_RIGHT_CURLY_BRACKET$1
+ && c !== CHAR_MINUS
+ && c !== CHAR_QUESTION
+ && c !== CHAR_COLON
+ && c !== CHAR_COMMA
+ && c !== CHAR_LEFT_SQUARE_BRACKET
+ && c !== CHAR_RIGHT_SQUARE_BRACKET
+ && c !== CHAR_LEFT_CURLY_BRACKET
+ && c !== CHAR_RIGHT_CURLY_BRACKET
// | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
- && c !== CHAR_SHARP$1
- && c !== CHAR_AMPERSAND$1
- && c !== CHAR_ASTERISK$2
- && c !== CHAR_EXCLAMATION$1
- && c !== CHAR_VERTICAL_LINE$1
- && c !== CHAR_EQUALS$1
- && c !== CHAR_GREATER_THAN$1
- && c !== CHAR_SINGLE_QUOTE$2
- && c !== CHAR_DOUBLE_QUOTE$2
+ && c !== CHAR_SHARP
+ && c !== CHAR_AMPERSAND
+ && c !== CHAR_ASTERISK
+ && c !== CHAR_EXCLAMATION
+ && c !== CHAR_VERTICAL_LINE
+ && c !== CHAR_EQUALS
+ && c !== CHAR_GREATER_THAN
+ && c !== CHAR_SINGLE_QUOTE
+ && c !== CHAR_DOUBLE_QUOTE
// | “%” | “@” | “`”)
- && c !== CHAR_PERCENT$1
- && c !== CHAR_COMMERCIAL_AT$1
- && c !== CHAR_GRAVE_ACCENT$1;
+ && c !== CHAR_PERCENT
+ && c !== CHAR_COMMERCIAL_AT
+ && c !== CHAR_GRAVE_ACCENT;
+}
+
+// Simplified test for values allowed as the last character in plain style.
+function isPlainSafeLast(c) {
+ // just not whitespace or colon, it will be checked to be plain character later
+ return !isWhitespace(c) && c !== CHAR_COLON;
+}
+
+// Same as 'string'.codePointAt(pos), but works in older browsers.
+function codePointAt(string, pos) {
+ var first = string.charCodeAt(pos), second;
+ if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
+ second = string.charCodeAt(pos + 1);
+ if (second >= 0xDC00 && second <= 0xDFFF) {
+ // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+ }
+ }
+ return first;
}
// Determines whether block indentation indicator is required.
-function needIndentIndicator$1(string) {
+function needIndentIndicator(string) {
var leadingSpaceRe = /^\n* /;
return leadingSpaceRe.test(string);
}
-var STYLE_PLAIN$1 = 1,
- STYLE_SINGLE$1 = 2,
- STYLE_LITERAL$1 = 3,
- STYLE_FOLDED$1 = 4,
- STYLE_DOUBLE$1 = 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.
@@ -3495,32 +11751,35 @@ var STYLE_PLAIN$1 = 1,
// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
-function chooseScalarStyle$1(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
+function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
+ testAmbiguousType, quotingType, forceQuotes, inblock) {
+
var i;
- var char, prev_char;
+ var char = 0;
+ var prevChar = null;
var hasLineBreak = false;
var hasFoldableLine = false; // only checked if shouldTrackWidth
var shouldTrackWidth = lineWidth !== -1;
var previousLineBreak = -1; // count the first line correctly
- var plain = isPlainSafeFirst$1(string.charCodeAt(0))
- && !isWhitespace$1(string.charCodeAt(string.length - 1));
+ var plain = isPlainSafeFirst(codePointAt(string, 0))
+ && isPlainSafeLast(codePointAt(string, string.length - 1));
- if (singleLineOnly) {
+ if (singleLineOnly || forceQuotes) {
// Case: no block styles.
// Check for disallowed characters to rule out plain and single.
- for (i = 0; i < string.length; i++) {
- char = string.charCodeAt(i);
- if (!isPrintable$1(char)) {
- return STYLE_DOUBLE$1;
+ for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+ char = codePointAt(string, i);
+ if (!isPrintable(char)) {
+ return STYLE_DOUBLE;
}
- prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
- plain = plain && isPlainSafe$1(char, prev_char);
+ plain = plain && isPlainSafe(char, prevChar, inblock);
+ prevChar = char;
}
} else {
// Case: block styles permitted.
- for (i = 0; i < string.length; i++) {
- char = string.charCodeAt(i);
- if (char === CHAR_LINE_FEED$1) {
+ for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+ char = codePointAt(string, i);
+ if (char === CHAR_LINE_FEED) {
hasLineBreak = true;
// Check if any line can be folded.
if (shouldTrackWidth) {
@@ -3530,11 +11789,11 @@ function chooseScalarStyle$1(string, singleLineOnly, indentPerLevel, lineWidth,
string[previousLineBreak + 1] !== ' ');
previousLineBreak = i;
}
- } else if (!isPrintable$1(char)) {
- return STYLE_DOUBLE$1;
+ } else if (!isPrintable(char)) {
+ return STYLE_DOUBLE;
}
- prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
- plain = plain && isPlainSafe$1(char, prev_char);
+ plain = plain && isPlainSafe(char, prevChar, inblock);
+ prevChar = char;
}
// in case the end is missing a \n
hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
@@ -3547,16 +11806,21 @@ function chooseScalarStyle$1(string, singleLineOnly, indentPerLevel, lineWidth,
if (!hasLineBreak && !hasFoldableLine) {
// Strings interpretable as another type have to be quoted;
// e.g. the string 'true' vs. the boolean true.
- return plain && !testAmbiguousType(string)
- ? STYLE_PLAIN$1 : STYLE_SINGLE$1;
+ if (plain && !forceQuotes && !testAmbiguousType(string)) {
+ return STYLE_PLAIN;
+ }
+ return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
}
// Edge case: block indentation indicator can only have one digit.
- if (indentPerLevel > 9 && needIndentIndicator$1(string)) {
- return STYLE_DOUBLE$1;
+ if (indentPerLevel > 9 && needIndentIndicator(string)) {
+ return STYLE_DOUBLE;
}
// At this point we know block styles are valid.
// Prefer literal style unless we want to fold.
- return hasFoldableLine ? STYLE_FOLDED$1 : STYLE_LITERAL$1;
+ if (!forceQuotes) {
+ return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+ }
+ return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
}
// Note: line breaking/folding is implemented for only the folded style.
@@ -3565,14 +11829,15 @@ function chooseScalarStyle$1(string, singleLineOnly, indentPerLevel, lineWidth,
// • No ending newline => unaffected; already using strip "-" chomping.
// • Ending newline => removed then restored.
// Importantly, this keeps the "+" chomp indicator from gaining an extra line.
-function writeScalar$1(state, string, level, iskey) {
+function writeScalar(state, string, level, iskey, inblock) {
state.dump = (function () {
if (string.length === 0) {
- return "''";
+ return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
}
- if (!state.noCompatMode &&
- DEPRECATED_BOOLEANS_SYNTAX$1.indexOf(string) !== -1) {
- return "'" + string + "'";
+ if (!state.noCompatMode) {
+ if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
+ return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
+ }
}
var indent = state.indent * Math.max(1, level); // no 0-indent scalars
@@ -3591,31 +11856,33 @@ function writeScalar$1(state, string, level, iskey) {
// No block styles in flow mode.
|| (state.flowLevel > -1 && level >= state.flowLevel);
function testAmbiguity(string) {
- return testImplicitResolving$1(state, string);
+ return testImplicitResolving(state, string);
}
- switch (chooseScalarStyle$1(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
- case STYLE_PLAIN$1:
+ switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
+ testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+
+ case STYLE_PLAIN:
return string;
- case STYLE_SINGLE$1:
+ case STYLE_SINGLE:
return "'" + string.replace(/'/g, "''") + "'";
- case STYLE_LITERAL$1:
- return '|' + blockHeader$1(string, state.indent)
- + dropEndingNewline$1(indentString$1(string, indent));
- case STYLE_FOLDED$1:
- return '>' + blockHeader$1(string, state.indent)
- + dropEndingNewline$1(indentString$1(foldString$1(string, lineWidth), indent));
- case STYLE_DOUBLE$1:
- return '"' + escapeString$1(string) + '"';
+ case STYLE_LITERAL:
+ return '|' + blockHeader(string, state.indent)
+ + dropEndingNewline(indentString(string, indent));
+ case STYLE_FOLDED:
+ return '>' + blockHeader(string, state.indent)
+ + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+ case STYLE_DOUBLE:
+ return '"' + escapeString(string) + '"';
default:
- throw new YAMLException$2('impossible error: invalid scalar style');
+ throw new exception('impossible error: invalid scalar style');
}
}());
}
// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
-function blockHeader$1(string, indentPerLevel) {
- var indentIndicator = needIndentIndicator$1(string) ? String(indentPerLevel) : '';
+function blockHeader(string, indentPerLevel) {
+ var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
// note the special case: the string '\n' counts as a "trailing" empty line.
var clip = string[string.length - 1] === '\n';
@@ -3626,13 +11893,13 @@ function blockHeader$1(string, indentPerLevel) {
}
// (See the note for writeScalar.)
-function dropEndingNewline$1(string) {
+function dropEndingNewline(string) {
return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
}
// Note: a long line without a suitable break point will exceed the width limit.
// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
-function foldString$1(string, width) {
+function foldString(string, width) {
// In folded style, $k$ consecutive newlines output as $k+1$ newlines—
// unless they're before or after a more-indented line, or at the very
// beginning or end, in which case $k$ maps to $k$.
@@ -3644,7 +11911,7 @@ function foldString$1(string, width) {
var nextLF = string.indexOf('\n');
nextLF = nextLF !== -1 ? nextLF : string.length;
lineRe.lastIndex = nextLF;
- return foldLine$1(string.slice(0, nextLF), width);
+ return foldLine(string.slice(0, nextLF), width);
}());
// If we haven't reached the first content line yet, don't add an extra \n.
var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
@@ -3658,7 +11925,7 @@ function foldString$1(string, width) {
result += prefix
+ (!prevMoreIndented && !moreIndented && line !== ''
? '\n' : '')
- + foldLine$1(line, width);
+ + foldLine(line, width);
prevMoreIndented = moreIndented;
}
@@ -3669,7 +11936,7 @@ function foldString$1(string, width) {
// Picks the longest line under the limit each time,
// otherwise settles for the shortest line over the limit.
// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
-function foldLine$1(line, width) {
+function foldLine(line, width) {
if (line === '' || line[0] === ' ') return line;
// Since a more-indented line adds a \n, breaks can't be followed by a space.
@@ -3709,42 +11976,46 @@ function foldLine$1(line, width) {
}
// Escapes a double-quoted string.
-function escapeString$1(string) {
+function escapeString(string) {
var result = '';
- var char, nextChar;
+ var char = 0;
var escapeSeq;
- for (var i = 0; i < string.length; i++) {
- char = string.charCodeAt(i);
- // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates").
- if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {
- nextChar = string.charCodeAt(i + 1);
- if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {
- // Combine the surrogate pair and store it escaped.
- result += encodeHex$1((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
- // Advance index one extra since we already used that char here.
- i++; continue;
- }
+ for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
+ char = codePointAt(string, i);
+ escapeSeq = ESCAPE_SEQUENCES[char];
+
+ if (!escapeSeq && isPrintable(char)) {
+ result += string[i];
+ if (char >= 0x10000) result += string[i + 1];
+ } else {
+ result += escapeSeq || encodeHex(char);
}
- escapeSeq = ESCAPE_SEQUENCES$1[char];
- result += !escapeSeq && isPrintable$1(char)
- ? string[i]
- : escapeSeq || encodeHex$1(char);
}
return result;
}
-function writeFlowSequence$1(state, level, object) {
+function writeFlowSequence(state, level, object) {
var _result = '',
_tag = state.tag,
index,
- length;
+ length,
+ value;
for (index = 0, length = object.length; index < length; index += 1) {
- // Write only valid elements.
- if (writeNode$1(state, level, object[index], false, false)) {
- if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
+ value = object[index];
+
+ if (state.replacer) {
+ value = state.replacer.call(object, String(index), value);
+ }
+
+ // Write only valid elements, put null instead of invalid elements.
+ if (writeNode(state, level, value, false, false) ||
+ (typeof value === 'undefined' &&
+ writeNode(state, level, null, false, false))) {
+
+ if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
_result += state.dump;
}
}
@@ -3753,20 +12024,30 @@ function writeFlowSequence$1(state, level, object) {
state.dump = '[' + _result + ']';
}
-function writeBlockSequence$1(state, level, object, compact) {
+function writeBlockSequence(state, level, object, compact) {
var _result = '',
_tag = state.tag,
index,
- length;
+ length,
+ value;
for (index = 0, length = object.length; index < length; index += 1) {
- // Write only valid elements.
- if (writeNode$1(state, level + 1, object[index], true, true)) {
- if (!compact || index !== 0) {
- _result += generateNextLine$1(state, level);
+ value = object[index];
+
+ if (state.replacer) {
+ value = state.replacer.call(object, String(index), value);
+ }
+
+ // Write only valid elements, put null instead of invalid elements.
+ if (writeNode(state, level + 1, value, true, true, false, true) ||
+ (typeof value === 'undefined' &&
+ writeNode(state, level + 1, null, true, true, false, true))) {
+
+ if (!compact || _result !== '') {
+ _result += generateNextLine(state, level);
}
- if (state.dump && CHAR_LINE_FEED$1 === state.dump.charCodeAt(0)) {
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
_result += '-';
} else {
_result += '- ';
@@ -3780,7 +12061,7 @@ function writeBlockSequence$1(state, level, object, compact) {
state.dump = _result || '[]'; // Empty sequence if no valid values.
}
-function writeFlowMapping$1(state, level, object) {
+function writeFlowMapping(state, level, object) {
var _result = '',
_tag = state.tag,
objectKeyList = Object.keys(object),
@@ -3793,14 +12074,18 @@ function writeFlowMapping$1(state, level, object) {
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
pairBuffer = '';
- if (index !== 0) pairBuffer += ', ';
+ if (_result !== '') pairBuffer += ', ';
if (state.condenseFlow) pairBuffer += '"';
objectKey = objectKeyList[index];
objectValue = object[objectKey];
- if (!writeNode$1(state, level, objectKey, false, false)) {
+ if (state.replacer) {
+ objectValue = state.replacer.call(object, objectKey, objectValue);
+ }
+
+ if (!writeNode(state, level, objectKey, false, false)) {
continue; // Skip this pair because of invalid key;
}
@@ -3808,7 +12093,7 @@ function writeFlowMapping$1(state, level, object) {
pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
- if (!writeNode$1(state, level, objectValue, false, false)) {
+ if (!writeNode(state, level, objectValue, false, false)) {
continue; // Skip this pair because of invalid value.
}
@@ -3822,7 +12107,7 @@ function writeFlowMapping$1(state, level, object) {
state.dump = '{' + _result + '}';
}
-function writeBlockMapping$1(state, level, object, compact) {
+function writeBlockMapping(state, level, object, compact) {
var _result = '',
_tag = state.tag,
objectKeyList = Object.keys(object),
@@ -3842,20 +12127,24 @@ function writeBlockMapping$1(state, level, object, compact) {
objectKeyList.sort(state.sortKeys);
} else if (state.sortKeys) {
// Something is wrong
- throw new YAMLException$2('sortKeys must be a boolean or a function');
+ throw new exception('sortKeys must be a boolean or a function');
}
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
pairBuffer = '';
- if (!compact || index !== 0) {
- pairBuffer += generateNextLine$1(state, level);
+ if (!compact || _result !== '') {
+ pairBuffer += generateNextLine(state, level);
}
objectKey = objectKeyList[index];
objectValue = object[objectKey];
- if (!writeNode$1(state, level + 1, objectKey, true, true, true)) {
+ if (state.replacer) {
+ objectValue = state.replacer.call(object, objectKey, objectValue);
+ }
+
+ if (!writeNode(state, level + 1, objectKey, true, true, true)) {
continue; // Skip this pair because of invalid key.
}
@@ -3863,7 +12152,7 @@ function writeBlockMapping$1(state, level, object, compact) {
(state.dump && state.dump.length > 1024);
if (explicitPair) {
- if (state.dump && CHAR_LINE_FEED$1 === state.dump.charCodeAt(0)) {
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
pairBuffer += '?';
} else {
pairBuffer += '? ';
@@ -3873,14 +12162,14 @@ function writeBlockMapping$1(state, level, object, compact) {
pairBuffer += state.dump;
if (explicitPair) {
- pairBuffer += generateNextLine$1(state, level);
+ pairBuffer += generateNextLine(state, level);
}
- if (!writeNode$1(state, level + 1, objectValue, true, explicitPair)) {
+ if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
continue; // Skip this pair because of invalid value.
}
- if (state.dump && CHAR_LINE_FEED$1 === state.dump.charCodeAt(0)) {
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
pairBuffer += ':';
} else {
pairBuffer += ': ';
@@ -3896,7 +12185,7 @@ function writeBlockMapping$1(state, level, object, compact) {
state.dump = _result || '{}'; // Empty mapping if no valid pairs.
}
-function detectType$1(state, object, explicit) {
+function detectType(state, object, explicit) {
var _result, typeList, index, length, type, style;
typeList = explicit ? state.explicitTypes : state.implicitTypes;
@@ -3908,17 +12197,25 @@ function detectType$1(state, object, explicit) {
(!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
(!type.predicate || type.predicate(object))) {
- state.tag = explicit ? type.tag : '?';
+ if (explicit) {
+ if (type.multi && type.representName) {
+ state.tag = type.representName(object);
+ } else {
+ state.tag = type.tag;
+ }
+ } else {
+ state.tag = '?';
+ }
if (type.represent) {
style = state.styleMap[type.tag] || type.defaultStyle;
- if (_toString$3.call(type.represent) === '[object Function]') {
+ if (_toString.call(type.represent) === '[object Function]') {
_result = type.represent(object, style);
- } else if (_hasOwnProperty$4.call(type.represent, style)) {
+ } else if (_hasOwnProperty.call(type.represent, style)) {
_result = type.represent[style](object, style);
} else {
- throw new YAMLException$2('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
+ throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
}
state.dump = _result;
@@ -3934,15 +12231,17 @@ function detectType$1(state, object, explicit) {
// Serializes `object` and writes it to global `result`.
// Returns true on success, or false on invalid object.
//
-function writeNode$1(state, level, object, block, compact, iskey) {
+function writeNode(state, level, object, block, compact, iskey, isblockseq) {
state.tag = null;
state.dump = object;
- if (!detectType$1(state, object, false)) {
- detectType$1(state, object, true);
+ if (!detectType(state, object, false)) {
+ detectType(state, object, true);
}
- var type = _toString$3.call(state.dump);
+ var type = _toString.call(state.dump);
+ var inblock = block;
+ var tagStr;
if (block) {
block = (state.flowLevel < 0 || state.flowLevel > level);
@@ -3969,53 +12268,83 @@ function writeNode$1(state, level, object, block, compact, iskey) {
}
if (type === '[object Object]') {
if (block && (Object.keys(state.dump).length !== 0)) {
- writeBlockMapping$1(state, level, state.dump, compact);
+ writeBlockMapping(state, level, state.dump, compact);
if (duplicate) {
state.dump = '&ref_' + duplicateIndex + state.dump;
}
} else {
- writeFlowMapping$1(state, level, state.dump);
+ writeFlowMapping(state, level, state.dump);
if (duplicate) {
state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
}
}
} else if (type === '[object Array]') {
- var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
if (block && (state.dump.length !== 0)) {
- writeBlockSequence$1(state, arrayLevel, state.dump, compact);
+ if (state.noArrayIndent && !isblockseq && level > 0) {
+ writeBlockSequence(state, level - 1, state.dump, compact);
+ } else {
+ writeBlockSequence(state, level, state.dump, compact);
+ }
if (duplicate) {
state.dump = '&ref_' + duplicateIndex + state.dump;
}
} else {
- writeFlowSequence$1(state, arrayLevel, state.dump);
+ writeFlowSequence(state, level, state.dump);
if (duplicate) {
state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
}
}
} else if (type === '[object String]') {
if (state.tag !== '?') {
- writeScalar$1(state, state.dump, level, iskey);
+ writeScalar(state, state.dump, level, iskey, inblock);
}
+ } else if (type === '[object Undefined]') {
+ return false;
} else {
if (state.skipInvalid) return false;
- throw new YAMLException$2('unacceptable kind of an object to dump ' + type);
+ throw new exception('unacceptable kind of an object to dump ' + type);
}
if (state.tag !== null && state.tag !== '?') {
- state.dump = '!<' + state.tag + '> ' + state.dump;
+ // Need to encode all characters except those allowed by the spec:
+ //
+ // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
+ // [36] ns-hex-digit ::= ns-dec-digit
+ // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
+ // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
+ // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
+ // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
+ // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
+ // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
+ //
+ // Also need to encode '!' because it has special meaning (end of tag prefix).
+ //
+ tagStr = encodeURI(
+ state.tag[0] === '!' ? state.tag.slice(1) : state.tag
+ ).replace(/!/g, '%21');
+
+ if (state.tag[0] === '!') {
+ tagStr = '!' + tagStr;
+ } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
+ tagStr = '!!' + tagStr.slice(18);
+ } else {
+ tagStr = '!<' + tagStr + '>';
+ }
+
+ state.dump = tagStr + ' ' + state.dump;
}
}
return true;
}
-function getDuplicateReferences$1(object, state) {
+function getDuplicateReferences(object, state) {
var objects = [],
duplicatesIndexes = [],
index,
length;
- inspectNode$1(object, objects, duplicatesIndexes);
+ inspectNode(object, objects, duplicatesIndexes);
for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
state.duplicates.push(objects[duplicatesIndexes[index]]);
@@ -4023,7 +12352,7 @@ function getDuplicateReferences$1(object, state) {
state.usedDuplicates = new Array(length);
}
-function inspectNode$1(object, objects, duplicatesIndexes) {
+function inspectNode(object, objects, duplicatesIndexes) {
var objectKeyList,
index,
length;
@@ -4039,79 +12368,100 @@ function inspectNode$1(object, objects, duplicatesIndexes) {
if (Array.isArray(object)) {
for (index = 0, length = object.length; index < length; index += 1) {
- inspectNode$1(object[index], objects, duplicatesIndexes);
+ inspectNode(object[index], objects, duplicatesIndexes);
}
} else {
objectKeyList = Object.keys(object);
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
- inspectNode$1(object[objectKeyList[index]], objects, duplicatesIndexes);
+ inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
}
}
}
}
}
-function dump$2(input, options) {
+function dump$1(input, options) {
options = options || {};
- var state = new State$2(options);
+ var state = new State(options);
- if (!state.noRefs) getDuplicateReferences$1(input, state);
+ if (!state.noRefs) getDuplicateReferences(input, state);
- if (writeNode$1(state, 0, input, true, true)) return state.dump + '\n';
+ var value = input;
- return '';
-}
+ if (state.replacer) {
+ value = state.replacer.call({ '': value }, '', value);
+ }
-function safeDump$1(input, options) {
- return dump$2(input, common$5.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
-}
+ if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
-dumper$2.dump = dump$2;
-dumper$2.safeDump = safeDump$1;
+ return '';
+}
-var loader$1 = loader$2;
-var dumper$1 = dumper$2;
+var dump_1 = dump$1;
+var dumper = {
+ dump: dump_1
+};
-function deprecated(name) {
+function renamed(from, to) {
return function () {
- throw new Error('Function ' + name + ' is deprecated and cannot be used.');
+ throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
+ 'Use yaml.' + to + ' instead, which is now safe by default.');
};
}
-jsYaml$2.Type = type$1;
-jsYaml$2.Schema = schema$2;
-jsYaml$2.FAILSAFE_SCHEMA = failsafe$1;
-jsYaml$2.JSON_SCHEMA = json$3;
-jsYaml$2.CORE_SCHEMA = core$4;
-jsYaml$2.DEFAULT_SAFE_SCHEMA = default_safe;
-jsYaml$2.DEFAULT_FULL_SCHEMA = default_full;
-jsYaml$2.load = loader$1.load;
-jsYaml$2.loadAll = loader$1.loadAll;
-jsYaml$2.safeLoad = loader$1.safeLoad;
-jsYaml$2.safeLoadAll = loader$1.safeLoadAll;
-jsYaml$2.dump = dumper$1.dump;
-jsYaml$2.safeDump = dumper$1.safeDump;
-jsYaml$2.YAMLException = exception$1;
-
-// Deprecated schema names from JS-YAML 2.0.x
-jsYaml$2.MINIMAL_SCHEMA = failsafe$1;
-jsYaml$2.SAFE_SCHEMA = default_safe;
-jsYaml$2.DEFAULT_SCHEMA = default_full;
-
-// Deprecated functions from JS-YAML 1.x.x
-jsYaml$2.scan = deprecated('scan');
-jsYaml$2.parse = deprecated('parse');
-jsYaml$2.compose = deprecated('compose');
-jsYaml$2.addConstructor = deprecated('addConstructor');
+var Type = type$1;
+var Schema = schema$1;
+var FAILSAFE_SCHEMA = failsafe;
+var JSON_SCHEMA = json;
+var CORE_SCHEMA = core;
+var DEFAULT_SCHEMA = _default$1;
+var load = loader.load;
+var loadAll = loader.loadAll;
+var dump = dumper.dump;
+var YAMLException = exception;
-var yaml$1 = jsYaml$2;
+// Re-export all types in case user wants to create custom schema
+var types$1 = {
+ binary: binary,
+ float: float,
+ map: map$3,
+ null: _null,
+ pairs: pairs,
+ set: set,
+ timestamp: timestamp,
+ bool: bool,
+ int: int,
+ merge: merge$1,
+ omap: omap,
+ seq: seq,
+ str: str
+};
+// Removed functions from JS-YAML 3.0.x
+var safeLoad = renamed('safeLoad', 'load');
+var safeLoadAll = renamed('safeLoadAll', 'loadAll');
+var safeDump = renamed('safeDump', 'dump');
-var jsYaml$1 = yaml$1;
+var jsYaml = {
+ Type: Type,
+ Schema: Schema,
+ FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
+ JSON_SCHEMA: JSON_SCHEMA,
+ CORE_SCHEMA: CORE_SCHEMA,
+ DEFAULT_SCHEMA: DEFAULT_SCHEMA,
+ load: load,
+ loadAll: loadAll,
+ dump: dump,
+ YAMLException: YAMLException,
+ types: types$1,
+ safeLoad: safeLoad,
+ safeLoadAll: safeLoadAll,
+ safeDump: safeDump
+};
var isArrayish$2 = function isArrayish(obj) {
if (!obj) {
@@ -4122,7 +12472,7 @@ var isArrayish$2 = function isArrayish(obj) {
(obj.length >= 0 && obj.splice instanceof Function);
};
-var util$4 = require$$0__default['default'];
+var util$2 = require$$0$4;
var isArrayish$1 = isArrayish$2;
var errorEx$1 = function errorEx(name, properties) {
@@ -4226,7 +12576,7 @@ var errorEx$1 = function errorEx(name, properties) {
Object.setPrototypeOf(errorExError.prototype, Error.prototype);
Object.setPrototypeOf(errorExError, Error);
} else {
- util$4.inherits(errorExError, Error);
+ util$2.inherits(errorExError, Error);
}
return errorExError;
@@ -4438,16 +12788,16 @@ var LinesAndColumns$1 = (function () {
return LinesAndColumns;
}());
-var dist$2 = /*#__PURE__*/Object.freeze({
+var dist = /*#__PURE__*/Object.freeze({
__proto__: null,
'default': LinesAndColumns$1
});
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(dist$2);
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(dist);
-var lib$9 = {};
+var lib$4 = {};
-var lib$8 = {};
+var lib$3 = {};
var jsTokens = {};
@@ -4475,7 +12825,7 @@ jsTokens.matchToToken = function(match) {
return token
};
-var lib$7 = {};
+var lib$2 = {};
var identifier = {};
@@ -4658,13 +13008,13 @@ Object.defineProperty(exports, "isKeyword", {
var _identifier = identifier;
var _keyword = keyword;
-}(lib$7));
+}(lib$2));
-var chalk$2 = {exports: {}};
+var chalk = {exports: {}};
var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
-var escapeStringRegexp$3 = function (str) {
+var escapeStringRegexp$1 = function (str) {
if (typeof str !== 'string') {
throw new TypeError('Expected a string');
}
@@ -4672,11 +13022,11 @@ var escapeStringRegexp$3 = function (str) {
return str.replace(matchOperatorsRe, '\\$&');
};
-var ansiStyles$2 = {exports: {}};
+var ansiStyles = {exports: {}};
-var conversions$5 = {exports: {}};
+var conversions$2 = {exports: {}};
-var colorName$1 = {
+var colorName = {
"aliceblue": [240, 248, 255],
"antiquewhite": [250, 235, 215],
"aqua": [0, 255, 255],
@@ -4829,20 +13179,20 @@ var colorName$1 = {
/* MIT license */
-var cssKeywords$1 = colorName$1;
+var cssKeywords = colorName;
// NOTE: conversions should only return primitive values (i.e. arrays, or
// values that give correct `typeof` results).
// do not use box values types (i.e. Number(), String(), etc.)
-var reverseKeywords$1 = {};
-for (var key$1 in cssKeywords$1) {
- if (cssKeywords$1.hasOwnProperty(key$1)) {
- reverseKeywords$1[cssKeywords$1[key$1]] = key$1;
+var reverseKeywords = {};
+for (var key$1 in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(key$1)) {
+ reverseKeywords[cssKeywords[key$1]] = key$1;
}
}
-var convert$6 = conversions$5.exports = {
+var convert$2 = conversions$2.exports = {
rgb: {channels: 3, labels: 'rgb'},
hsl: {channels: 3, labels: 'hsl'},
hsv: {channels: 3, labels: 'hsv'},
@@ -4861,30 +13211,30 @@ var convert$6 = conversions$5.exports = {
};
// hide .channels and .labels properties
-for (var model in convert$6) {
- if (convert$6.hasOwnProperty(model)) {
- if (!('channels' in convert$6[model])) {
+for (var model in convert$2) {
+ if (convert$2.hasOwnProperty(model)) {
+ if (!('channels' in convert$2[model])) {
throw new Error('missing channels property: ' + model);
}
- if (!('labels' in convert$6[model])) {
+ if (!('labels' in convert$2[model])) {
throw new Error('missing channel labels property: ' + model);
}
- if (convert$6[model].labels.length !== convert$6[model].channels) {
+ if (convert$2[model].labels.length !== convert$2[model].channels) {
throw new Error('channel and label counts mismatch: ' + model);
}
- var channels = convert$6[model].channels;
- var labels$1 = convert$6[model].labels;
- delete convert$6[model].channels;
- delete convert$6[model].labels;
- Object.defineProperty(convert$6[model], 'channels', {value: channels});
- Object.defineProperty(convert$6[model], 'labels', {value: labels$1});
+ var channels = convert$2[model].channels;
+ var labels$1 = convert$2[model].labels;
+ delete convert$2[model].channels;
+ delete convert$2[model].labels;
+ Object.defineProperty(convert$2[model], 'channels', {value: channels});
+ Object.defineProperty(convert$2[model], 'labels', {value: labels$1});
}
}
-convert$6.rgb.hsl = function (rgb) {
+convert$2.rgb.hsl = function (rgb) {
var r = rgb[0] / 255;
var g = rgb[1] / 255;
var b = rgb[2] / 255;
@@ -4924,7 +13274,7 @@ convert$6.rgb.hsl = function (rgb) {
return [h, s * 100, l * 100];
};
-convert$6.rgb.hsv = function (rgb) {
+convert$2.rgb.hsv = function (rgb) {
var rdif;
var gdif;
var bdif;
@@ -4969,11 +13319,11 @@ convert$6.rgb.hsv = function (rgb) {
];
};
-convert$6.rgb.hwb = function (rgb) {
+convert$2.rgb.hwb = function (rgb) {
var r = rgb[0];
var g = rgb[1];
var b = rgb[2];
- var h = convert$6.rgb.hsl(rgb)[0];
+ var h = convert$2.rgb.hsl(rgb)[0];
var w = 1 / 255 * Math.min(r, Math.min(g, b));
b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
@@ -4981,7 +13331,7 @@ convert$6.rgb.hwb = function (rgb) {
return [h, w * 100, b * 100];
};
-convert$6.rgb.cmyk = function (rgb) {
+convert$2.rgb.cmyk = function (rgb) {
var r = rgb[0] / 255;
var g = rgb[1] / 255;
var b = rgb[2] / 255;
@@ -5001,7 +13351,7 @@ convert$6.rgb.cmyk = function (rgb) {
/**
* See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
* */
-function comparativeDistance$1(x, y) {
+function comparativeDistance(x, y) {
return (
Math.pow(x[0] - y[0], 2) +
Math.pow(x[1] - y[1], 2) +
@@ -5009,8 +13359,8 @@ function comparativeDistance$1(x, y) {
);
}
-convert$6.rgb.keyword = function (rgb) {
- var reversed = reverseKeywords$1[rgb];
+convert$2.rgb.keyword = function (rgb) {
+ var reversed = reverseKeywords[rgb];
if (reversed) {
return reversed;
}
@@ -5018,12 +13368,12 @@ convert$6.rgb.keyword = function (rgb) {
var currentClosestDistance = Infinity;
var currentClosestKeyword;
- for (var keyword in cssKeywords$1) {
- if (cssKeywords$1.hasOwnProperty(keyword)) {
- var value = cssKeywords$1[keyword];
+ for (var keyword in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(keyword)) {
+ var value = cssKeywords[keyword];
// Compute comparative distance
- var distance = comparativeDistance$1(rgb, value);
+ var distance = comparativeDistance(rgb, value);
// Check if its less, if so set as closest
if (distance < currentClosestDistance) {
@@ -5036,11 +13386,11 @@ convert$6.rgb.keyword = function (rgb) {
return currentClosestKeyword;
};
-convert$6.keyword.rgb = function (keyword) {
- return cssKeywords$1[keyword];
+convert$2.keyword.rgb = function (keyword) {
+ return cssKeywords[keyword];
};
-convert$6.rgb.xyz = function (rgb) {
+convert$2.rgb.xyz = function (rgb) {
var r = rgb[0] / 255;
var g = rgb[1] / 255;
var b = rgb[2] / 255;
@@ -5057,8 +13407,8 @@ convert$6.rgb.xyz = function (rgb) {
return [x * 100, y * 100, z * 100];
};
-convert$6.rgb.lab = function (rgb) {
- var xyz = convert$6.rgb.xyz(rgb);
+convert$2.rgb.lab = function (rgb) {
+ var xyz = convert$2.rgb.xyz(rgb);
var x = xyz[0];
var y = xyz[1];
var z = xyz[2];
@@ -5081,7 +13431,7 @@ convert$6.rgb.lab = function (rgb) {
return [l, a, b];
};
-convert$6.hsl.rgb = function (hsl) {
+convert$2.hsl.rgb = function (hsl) {
var h = hsl[0] / 360;
var s = hsl[1] / 100;
var l = hsl[2] / 100;
@@ -5130,7 +13480,7 @@ convert$6.hsl.rgb = function (hsl) {
return rgb;
};
-convert$6.hsl.hsv = function (hsl) {
+convert$2.hsl.hsv = function (hsl) {
var h = hsl[0];
var s = hsl[1] / 100;
var l = hsl[2] / 100;
@@ -5148,7 +13498,7 @@ convert$6.hsl.hsv = function (hsl) {
return [h, sv * 100, v * 100];
};
-convert$6.hsv.rgb = function (hsv) {
+convert$2.hsv.rgb = function (hsv) {
var h = hsv[0] / 60;
var s = hsv[1] / 100;
var v = hsv[2] / 100;
@@ -5176,7 +13526,7 @@ convert$6.hsv.rgb = function (hsv) {
}
};
-convert$6.hsv.hsl = function (hsv) {
+convert$2.hsv.hsl = function (hsv) {
var h = hsv[0];
var s = hsv[1] / 100;
var v = hsv[2] / 100;
@@ -5196,7 +13546,7 @@ convert$6.hsv.hsl = function (hsv) {
};
// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
-convert$6.hwb.rgb = function (hwb) {
+convert$2.hwb.rgb = function (hwb) {
var h = hwb[0] / 360;
var wh = hwb[1] / 100;
var bl = hwb[2] / 100;
@@ -5239,7 +13589,7 @@ convert$6.hwb.rgb = function (hwb) {
return [r * 255, g * 255, b * 255];
};
-convert$6.cmyk.rgb = function (cmyk) {
+convert$2.cmyk.rgb = function (cmyk) {
var c = cmyk[0] / 100;
var m = cmyk[1] / 100;
var y = cmyk[2] / 100;
@@ -5255,7 +13605,7 @@ convert$6.cmyk.rgb = function (cmyk) {
return [r * 255, g * 255, b * 255];
};
-convert$6.xyz.rgb = function (xyz) {
+convert$2.xyz.rgb = function (xyz) {
var x = xyz[0] / 100;
var y = xyz[1] / 100;
var z = xyz[2] / 100;
@@ -5287,7 +13637,7 @@ convert$6.xyz.rgb = function (xyz) {
return [r * 255, g * 255, b * 255];
};
-convert$6.xyz.lab = function (xyz) {
+convert$2.xyz.lab = function (xyz) {
var x = xyz[0];
var y = xyz[1];
var z = xyz[2];
@@ -5310,7 +13660,7 @@ convert$6.xyz.lab = function (xyz) {
return [l, a, b];
};
-convert$6.lab.xyz = function (lab) {
+convert$2.lab.xyz = function (lab) {
var l = lab[0];
var a = lab[1];
var b = lab[2];
@@ -5336,7 +13686,7 @@ convert$6.lab.xyz = function (lab) {
return [x, y, z];
};
-convert$6.lab.lch = function (lab) {
+convert$2.lab.lch = function (lab) {
var l = lab[0];
var a = lab[1];
var b = lab[2];
@@ -5356,7 +13706,7 @@ convert$6.lab.lch = function (lab) {
return [l, c, h];
};
-convert$6.lch.lab = function (lch) {
+convert$2.lch.lab = function (lch) {
var l = lch[0];
var c = lch[1];
var h = lch[2];
@@ -5371,11 +13721,11 @@ convert$6.lch.lab = function (lch) {
return [l, a, b];
};
-convert$6.rgb.ansi16 = function (args) {
+convert$2.rgb.ansi16 = function (args) {
var r = args[0];
var g = args[1];
var b = args[2];
- var value = 1 in arguments ? arguments[1] : convert$6.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
+ var value = 1 in arguments ? arguments[1] : convert$2.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
value = Math.round(value / 50);
@@ -5395,13 +13745,13 @@ convert$6.rgb.ansi16 = function (args) {
return ansi;
};
-convert$6.hsv.ansi16 = function (args) {
+convert$2.hsv.ansi16 = function (args) {
// optimization here; we already know the value and don't need to get
// it converted for us.
- return convert$6.rgb.ansi16(convert$6.hsv.rgb(args), args[2]);
+ return convert$2.rgb.ansi16(convert$2.hsv.rgb(args), args[2]);
};
-convert$6.rgb.ansi256 = function (args) {
+convert$2.rgb.ansi256 = function (args) {
var r = args[0];
var g = args[1];
var b = args[2];
@@ -5428,7 +13778,7 @@ convert$6.rgb.ansi256 = function (args) {
return ansi;
};
-convert$6.ansi16.rgb = function (args) {
+convert$2.ansi16.rgb = function (args) {
var color = args % 10;
// handle greyscale
@@ -5450,7 +13800,7 @@ convert$6.ansi16.rgb = function (args) {
return [r, g, b];
};
-convert$6.ansi256.rgb = function (args) {
+convert$2.ansi256.rgb = function (args) {
// handle greyscale
if (args >= 232) {
var c = (args - 232) * 10 + 8;
@@ -5467,7 +13817,7 @@ convert$6.ansi256.rgb = function (args) {
return [r, g, b];
};
-convert$6.rgb.hex = function (args) {
+convert$2.rgb.hex = function (args) {
var integer = ((Math.round(args[0]) & 0xFF) << 16)
+ ((Math.round(args[1]) & 0xFF) << 8)
+ (Math.round(args[2]) & 0xFF);
@@ -5476,7 +13826,7 @@ convert$6.rgb.hex = function (args) {
return '000000'.substring(string.length) + string;
};
-convert$6.hex.rgb = function (args) {
+convert$2.hex.rgb = function (args) {
var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
if (!match) {
return [0, 0, 0];
@@ -5498,7 +13848,7 @@ convert$6.hex.rgb = function (args) {
return [r, g, b];
};
-convert$6.rgb.hcg = function (rgb) {
+convert$2.rgb.hcg = function (rgb) {
var r = rgb[0] / 255;
var g = rgb[1] / 255;
var b = rgb[2] / 255;
@@ -5532,7 +13882,7 @@ convert$6.rgb.hcg = function (rgb) {
return [hue * 360, chroma * 100, grayscale * 100];
};
-convert$6.hsl.hcg = function (hsl) {
+convert$2.hsl.hcg = function (hsl) {
var s = hsl[1] / 100;
var l = hsl[2] / 100;
var c = 1;
@@ -5551,7 +13901,7 @@ convert$6.hsl.hcg = function (hsl) {
return [hsl[0], c * 100, f * 100];
};
-convert$6.hsv.hcg = function (hsv) {
+convert$2.hsv.hcg = function (hsv) {
var s = hsv[1] / 100;
var v = hsv[2] / 100;
@@ -5565,7 +13915,7 @@ convert$6.hsv.hcg = function (hsv) {
return [hsv[0], c * 100, f * 100];
};
-convert$6.hcg.rgb = function (hcg) {
+convert$2.hcg.rgb = function (hcg) {
var h = hcg[0] / 360;
var c = hcg[1] / 100;
var g = hcg[2] / 100;
@@ -5604,7 +13954,7 @@ convert$6.hcg.rgb = function (hcg) {
];
};
-convert$6.hcg.hsv = function (hcg) {
+convert$2.hcg.hsv = function (hcg) {
var c = hcg[1] / 100;
var g = hcg[2] / 100;
@@ -5618,7 +13968,7 @@ convert$6.hcg.hsv = function (hcg) {
return [hcg[0], f * 100, v * 100];
};
-convert$6.hcg.hsl = function (hcg) {
+convert$2.hcg.hsl = function (hcg) {
var c = hcg[1] / 100;
var g = hcg[2] / 100;
@@ -5635,14 +13985,14 @@ convert$6.hcg.hsl = function (hcg) {
return [hcg[0], s * 100, l * 100];
};
-convert$6.hcg.hwb = function (hcg) {
+convert$2.hcg.hwb = function (hcg) {
var c = hcg[1] / 100;
var g = hcg[2] / 100;
var v = c + g * (1.0 - c);
return [hcg[0], (v - c) * 100, (1 - v) * 100];
};
-convert$6.hwb.hcg = function (hwb) {
+convert$2.hwb.hcg = function (hwb) {
var w = hwb[1] / 100;
var b = hwb[2] / 100;
var v = 1 - b;
@@ -5656,35 +14006,35 @@ convert$6.hwb.hcg = function (hwb) {
return [hwb[0], c * 100, g * 100];
};
-convert$6.apple.rgb = function (apple) {
+convert$2.apple.rgb = function (apple) {
return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
};
-convert$6.rgb.apple = function (rgb) {
+convert$2.rgb.apple = function (rgb) {
return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
};
-convert$6.gray.rgb = function (args) {
+convert$2.gray.rgb = function (args) {
return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
};
-convert$6.gray.hsl = convert$6.gray.hsv = function (args) {
+convert$2.gray.hsl = convert$2.gray.hsv = function (args) {
return [0, 0, args[0]];
};
-convert$6.gray.hwb = function (gray) {
+convert$2.gray.hwb = function (gray) {
return [0, 100, gray[0]];
};
-convert$6.gray.cmyk = function (gray) {
+convert$2.gray.cmyk = function (gray) {
return [0, 0, 0, gray[0]];
};
-convert$6.gray.lab = function (gray) {
+convert$2.gray.lab = function (gray) {
return [gray[0], 0, 0];
};
-convert$6.gray.hex = function (gray) {
+convert$2.gray.hex = function (gray) {
var val = Math.round(gray[0] / 100 * 255) & 0xFF;
var integer = (val << 16) + (val << 8) + val;
@@ -5692,12 +14042,12 @@ convert$6.gray.hex = function (gray) {
return '000000'.substring(string.length) + string;
};
-convert$6.rgb.gray = function (rgb) {
+convert$2.rgb.gray = function (rgb) {
var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
return [val / 255 * 100];
};
-var conversions$4 = conversions$5.exports;
+var conversions$1 = conversions$2.exports;
/*
this function routes a model to all other models.
@@ -5710,10 +14060,10 @@ var conversions$4 = conversions$5.exports;
conversions that are not possible simply are not included.
*/
-function buildGraph$1() {
+function buildGraph() {
var graph = {};
// https://jsperf.com/object-keys-vs-for-in-with-closure/3
- var models = Object.keys(conversions$4);
+ var models = Object.keys(conversions$1);
for (var len = models.length, i = 0; i < len; i++) {
graph[models[i]] = {
@@ -5728,15 +14078,15 @@ function buildGraph$1() {
}
// https://en.wikipedia.org/wiki/Breadth-first_search
-function deriveBFS$1(fromModel) {
- var graph = buildGraph$1();
+function deriveBFS(fromModel) {
+ var graph = buildGraph();
var queue = [fromModel]; // unshift -> queue -> pop
graph[fromModel].distance = 0;
while (queue.length) {
var current = queue.pop();
- var adjacents = Object.keys(conversions$4[current]);
+ var adjacents = Object.keys(conversions$1[current]);
for (var len = adjacents.length, i = 0; i < len; i++) {
var adjacent = adjacents[i];
@@ -5753,20 +14103,20 @@ function deriveBFS$1(fromModel) {
return graph;
}
-function link$2(from, to) {
+function link$1(from, to) {
return function (args) {
return to(from(args));
};
}
-function wrapConversion$1(toModel, graph) {
+function wrapConversion(toModel, graph) {
var path = [graph[toModel].parent, toModel];
- var fn = conversions$4[graph[toModel].parent][toModel];
+ var fn = conversions$1[graph[toModel].parent][toModel];
var cur = graph[toModel].parent;
while (graph[cur].parent) {
path.unshift(graph[cur].parent);
- fn = link$2(conversions$4[graph[cur].parent][cur], fn);
+ fn = link$1(conversions$1[graph[cur].parent][cur], fn);
cur = graph[cur].parent;
}
@@ -5774,8 +14124,8 @@ function wrapConversion$1(toModel, graph) {
return fn;
}
-var route$3 = function (fromModel) {
- var graph = deriveBFS$1(fromModel);
+var route$1 = function (fromModel) {
+ var graph = deriveBFS(fromModel);
var conversion = {};
var models = Object.keys(graph);
@@ -5788,20 +14138,20 @@ var route$3 = function (fromModel) {
continue;
}
- conversion[toModel] = wrapConversion$1(toModel, graph);
+ conversion[toModel] = wrapConversion(toModel, graph);
}
return conversion;
};
-var conversions$3 = conversions$5.exports;
-var route$2 = route$3;
+var conversions = conversions$2.exports;
+var route = route$1;
-var convert$5 = {};
+var convert$1 = {};
-var models$4 = Object.keys(conversions$3);
+var models = Object.keys(conversions);
-function wrapRaw$1(fn) {
+function wrapRaw(fn) {
var wrappedFn = function (args) {
if (args === undefined || args === null) {
return args;
@@ -5822,7 +14172,7 @@ function wrapRaw$1(fn) {
return wrappedFn;
}
-function wrapRounded$1(fn) {
+function wrapRounded(fn) {
var wrappedFn = function (args) {
if (args === undefined || args === null) {
return args;
@@ -5854,40 +14204,40 @@ function wrapRounded$1(fn) {
return wrappedFn;
}
-models$4.forEach(function (fromModel) {
- convert$5[fromModel] = {};
+models.forEach(function (fromModel) {
+ convert$1[fromModel] = {};
- Object.defineProperty(convert$5[fromModel], 'channels', {value: conversions$3[fromModel].channels});
- Object.defineProperty(convert$5[fromModel], 'labels', {value: conversions$3[fromModel].labels});
+ Object.defineProperty(convert$1[fromModel], 'channels', {value: conversions[fromModel].channels});
+ Object.defineProperty(convert$1[fromModel], 'labels', {value: conversions[fromModel].labels});
- var routes = route$2(fromModel);
+ var routes = route(fromModel);
var routeModels = Object.keys(routes);
routeModels.forEach(function (toModel) {
var fn = routes[toModel];
- convert$5[fromModel][toModel] = wrapRounded$1(fn);
- convert$5[fromModel][toModel].raw = wrapRaw$1(fn);
+ convert$1[fromModel][toModel] = wrapRounded(fn);
+ convert$1[fromModel][toModel].raw = wrapRaw(fn);
});
});
-var colorConvert$1 = convert$5;
+var colorConvert = convert$1;
(function (module) {
-const colorConvert = colorConvert$1;
+const colorConvert$1 = colorConvert;
const wrapAnsi16 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
+ const code = fn.apply(colorConvert$1, arguments);
return `\u001B[${code + offset}m`;
};
const wrapAnsi256 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
+ const code = fn.apply(colorConvert$1, arguments);
return `\u001B[${38 + offset};5;${code}m`;
};
const wrapAnsi16m = (fn, offset) => function () {
- const rgb = fn.apply(colorConvert, arguments);
+ const rgb = fn.apply(colorConvert$1, arguments);
return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
};
@@ -6003,12 +14353,12 @@ function assembleStyles() {
rgb: wrapAnsi16m(rgb2rgb, 10)
};
- for (let key of Object.keys(colorConvert)) {
- if (typeof colorConvert[key] !== 'object') {
+ for (let key of Object.keys(colorConvert$1)) {
+ if (typeof colorConvert$1[key] !== 'object') {
continue;
}
- const suite = colorConvert[key];
+ const suite = colorConvert$1[key];
if (key === 'ansi16') {
key = 'ansi';
@@ -6038,9 +14388,9 @@ Object.defineProperty(module, 'exports', {
enumerable: true,
get: assembleStyles
});
-}(ansiStyles$2));
+}(ansiStyles));
-var hasFlag$5 = (flag, argv) => {
+var hasFlag$2 = (flag, argv) => {
argv = argv || process.argv;
const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
const pos = argv.indexOf(prefix + flag);
@@ -6048,27 +14398,27 @@ var hasFlag$5 = (flag, argv) => {
return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
};
-const os$3 = require$$0__default$1['default'];
-const hasFlag$4 = hasFlag$5;
+const os$1 = require$$0$2;
+const hasFlag$1 = hasFlag$2;
-const env$2 = process.env;
+const env$1 = process.env;
-let forceColor$2;
-if (hasFlag$4('no-color') ||
- hasFlag$4('no-colors') ||
- hasFlag$4('color=false')) {
- forceColor$2 = false;
-} else if (hasFlag$4('color') ||
- hasFlag$4('colors') ||
- hasFlag$4('color=true') ||
- hasFlag$4('color=always')) {
- forceColor$2 = true;
+let forceColor;
+if (hasFlag$1('no-color') ||
+ hasFlag$1('no-colors') ||
+ hasFlag$1('color=false')) {
+ forceColor = false;
+} else if (hasFlag$1('color') ||
+ hasFlag$1('colors') ||
+ hasFlag$1('color=true') ||
+ hasFlag$1('color=always')) {
+ forceColor = true;
}
-if ('FORCE_COLOR' in env$2) {
- forceColor$2 = env$2.FORCE_COLOR.length === 0 || parseInt(env$2.FORCE_COLOR, 10) !== 0;
+if ('FORCE_COLOR' in env$1) {
+ forceColor = env$1.FORCE_COLOR.length === 0 || parseInt(env$1.FORCE_COLOR, 10) !== 0;
}
-function translateLevel$2(level) {
+function translateLevel$1(level) {
if (level === 0) {
return false;
}
@@ -6081,26 +14431,26 @@ function translateLevel$2(level) {
};
}
-function supportsColor$2(stream) {
- if (forceColor$2 === false) {
+function supportsColor$1(stream) {
+ if (forceColor === false) {
return 0;
}
- if (hasFlag$4('color=16m') ||
- hasFlag$4('color=full') ||
- hasFlag$4('color=truecolor')) {
+ if (hasFlag$1('color=16m') ||
+ hasFlag$1('color=full') ||
+ hasFlag$1('color=truecolor')) {
return 3;
}
- if (hasFlag$4('color=256')) {
+ if (hasFlag$1('color=256')) {
return 2;
}
- if (stream && !stream.isTTY && forceColor$2 !== true) {
+ if (stream && !stream.isTTY && forceColor !== true) {
return 0;
}
- const min = forceColor$2 ? 1 : 0;
+ const min = forceColor ? 1 : 0;
if (process.platform === 'win32') {
// Node.js 7.5.0 is the first version of Node.js to include a patch to
@@ -6109,7 +14459,7 @@ function supportsColor$2(stream) {
// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
// release that supports 256 colors. Windows 10 build 14931 is the first release
// that supports 16m/TrueColor.
- const osRelease = os$3.release().split('.');
+ const osRelease = os$1.release().split('.');
if (
Number(process.versions.node.split('.')[0]) >= 8 &&
Number(osRelease[0]) >= 10 &&
@@ -6121,26 +14471,26 @@ function supportsColor$2(stream) {
return 1;
}
- if ('CI' in env$2) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$2) || env$2.CI_NAME === 'codeship') {
+ if ('CI' in env$1) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
return 1;
}
return min;
}
- if ('TEAMCITY_VERSION' in env$2) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$2.TEAMCITY_VERSION) ? 1 : 0;
+ if ('TEAMCITY_VERSION' in env$1) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
}
- if (env$2.COLORTERM === 'truecolor') {
+ if (env$1.COLORTERM === 'truecolor') {
return 3;
}
- if ('TERM_PROGRAM' in env$2) {
- const version = parseInt((env$2.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+ if ('TERM_PROGRAM' in env$1) {
+ const version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
- switch (env$2.TERM_PROGRAM) {
+ switch (env$1.TERM_PROGRAM) {
case 'iTerm.app':
return version >= 3 ? 3 : 2;
case 'Apple_Terminal':
@@ -6149,42 +14499,42 @@ function supportsColor$2(stream) {
}
}
- if (/-256(color)?$/i.test(env$2.TERM)) {
+ if (/-256(color)?$/i.test(env$1.TERM)) {
return 2;
}
- if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$2.TERM)) {
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
return 1;
}
- if ('COLORTERM' in env$2) {
+ if ('COLORTERM' in env$1) {
return 1;
}
- if (env$2.TERM === 'dumb') {
+ if (env$1.TERM === 'dumb') {
return min;
}
return min;
}
-function getSupportLevel$2(stream) {
- const level = supportsColor$2(stream);
- return translateLevel$2(level);
+function getSupportLevel(stream) {
+ const level = supportsColor$1(stream);
+ return translateLevel$1(level);
}
-var supportsColor_1$2 = {
- supportsColor: getSupportLevel$2,
- stdout: getSupportLevel$2(process.stdout),
- stderr: getSupportLevel$2(process.stderr)
+var supportsColor_1 = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
};
-const TEMPLATE_REGEX$1 = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX$1 = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
-const ESCAPES$1 = new Map([
+const ESCAPES = new Map([
['n', '\n'],
['r', '\r'],
['t', '\t'],
@@ -6197,15 +14547,15 @@ const ESCAPES$1 = new Map([
['a', '\u0007']
]);
-function unescape$1(c) {
+function unescape(c) {
if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
return String.fromCharCode(parseInt(c.slice(1), 16));
}
- return ESCAPES$1.get(c) || c;
+ return ESCAPES.get(c) || c;
}
-function parseArguments$1(name, args) {
+function parseArguments(name, args) {
const results = [];
const chunks = args.trim().split(/\s*,\s*/g);
let matches;
@@ -6213,8 +14563,8 @@ function parseArguments$1(name, args) {
for (const chunk of chunks) {
if (!isNaN(chunk)) {
results.push(Number(chunk));
- } else if ((matches = chunk.match(STRING_REGEX$1))) {
- results.push(matches[2].replace(ESCAPE_REGEX$1, (m, escape, chr) => escape ? unescape$1(escape) : chr));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
} else {
throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
}
@@ -6223,17 +14573,17 @@ function parseArguments$1(name, args) {
return results;
}
-function parseStyle$1(style) {
- STYLE_REGEX$1.lastIndex = 0;
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
const results = [];
let matches;
- while ((matches = STYLE_REGEX$1.exec(style)) !== null) {
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
const name = matches[1];
if (matches[2]) {
- const args = parseArguments$1(name, matches[2]);
+ const args = parseArguments(name, matches[2]);
results.push([name].concat(args));
} else {
results.push([name]);
@@ -6243,7 +14593,7 @@ function parseStyle$1(style) {
return results;
}
-function buildStyle$1(chalk, styles) {
+function buildStyle(chalk, styles) {
const enabled = {};
for (const layer of styles) {
@@ -6270,26 +14620,26 @@ function buildStyle$1(chalk, styles) {
return current;
}
-var templates$1 = (chalk, tmp) => {
+var templates = (chalk, tmp) => {
const styles = [];
const chunks = [];
let chunk = [];
// eslint-disable-next-line max-params
- tmp.replace(TEMPLATE_REGEX$1, (m, escapeChar, inverse, style, close, chr) => {
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
if (escapeChar) {
- chunk.push(unescape$1(escapeChar));
+ chunk.push(unescape(escapeChar));
} else if (style) {
const str = chunk.join('');
chunk = [];
- chunks.push(styles.length === 0 ? str : buildStyle$1(chalk, styles)(str));
- styles.push({inverse, styles: parseStyle$1(style)});
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
} else if (close) {
if (styles.length === 0) {
throw new Error('Found extraneous } in Chalk template literal');
}
- chunks.push(buildStyle$1(chalk, styles)(chunk.join('')));
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
chunk = [];
styles.pop();
} else {
@@ -6308,11 +14658,11 @@ var templates$1 = (chalk, tmp) => {
};
(function (module) {
-const escapeStringRegexp = escapeStringRegexp$3;
-const ansiStyles = ansiStyles$2.exports;
-const stdoutColor = supportsColor_1$2.stdout;
+const escapeStringRegexp = escapeStringRegexp$1;
+const ansiStyles$1 = ansiStyles.exports;
+const stdoutColor = supportsColor_1.stdout;
-const template = templates$1;
+const template = templates;
const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
@@ -6358,15 +14708,15 @@ function Chalk(options) {
// Use bright blue on Windows as the normal blue color is illegible
if (isSimpleWindowsTerm) {
- ansiStyles.blue.open = '\u001B[94m';
+ ansiStyles$1.blue.open = '\u001B[94m';
}
-for (const key of Object.keys(ansiStyles)) {
- ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+for (const key of Object.keys(ansiStyles$1)) {
+ ansiStyles$1[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles$1[key].close), 'g');
styles[key] = {
get() {
- const codes = ansiStyles[key];
+ const codes = ansiStyles$1[key];
return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
}
};
@@ -6378,8 +14728,8 @@ styles.visible = {
}
};
-ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
-for (const model of Object.keys(ansiStyles.color.ansi)) {
+ansiStyles$1.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles$1.color.close), 'g');
+for (const model of Object.keys(ansiStyles$1.color.ansi)) {
if (skipModels.has(model)) {
continue;
}
@@ -6388,11 +14738,11 @@ for (const model of Object.keys(ansiStyles.color.ansi)) {
get() {
const level = this.level;
return function () {
- const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const open = ansiStyles$1.color[levelMapping[level]][model].apply(null, arguments);
const codes = {
open,
- close: ansiStyles.color.close,
- closeRe: ansiStyles.color.closeRe
+ close: ansiStyles$1.color.close,
+ closeRe: ansiStyles$1.color.closeRe
};
return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
};
@@ -6400,8 +14750,8 @@ for (const model of Object.keys(ansiStyles.color.ansi)) {
};
}
-ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
-for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ansiStyles$1.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles$1.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles$1.bgColor.ansi)) {
if (skipModels.has(model)) {
continue;
}
@@ -6411,11 +14761,11 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
get() {
const level = this.level;
return function () {
- const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const open = ansiStyles$1.bgColor[levelMapping[level]][model].apply(null, arguments);
const codes = {
open,
- close: ansiStyles.bgColor.close,
- closeRe: ansiStyles.bgColor.closeRe
+ close: ansiStyles$1.bgColor.close,
+ closeRe: ansiStyles$1.bgColor.closeRe
};
return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
};
@@ -6489,9 +14839,9 @@ function applyStyle() {
// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
// see https://github.com/chalk/chalk/issues/58
// If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
- const originalDim = ansiStyles.dim.open;
+ const originalDim = ansiStyles$1.dim.open;
if (isSimpleWindowsTerm && this.hasGrey) {
- ansiStyles.dim.open = '';
+ ansiStyles$1.dim.open = '';
}
for (const code of this._styles.slice().reverse()) {
@@ -6507,7 +14857,7 @@ function applyStyle() {
}
// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
- ansiStyles.dim.open = originalDim;
+ ansiStyles$1.dim.open = originalDim;
return str;
}
@@ -6535,20 +14885,20 @@ Object.defineProperties(Chalk.prototype, styles);
module.exports = Chalk(); // eslint-disable-line new-cap
module.exports.supportsColor = stdoutColor;
module.exports.default = module.exports; // For TypeScript
-}(chalk$2));
+}(chalk));
-Object.defineProperty(lib$8, "__esModule", {
+Object.defineProperty(lib$3, "__esModule", {
value: true
});
-lib$8.shouldHighlight = shouldHighlight;
-lib$8.getChalk = getChalk;
-lib$8.default = highlight;
+lib$3.shouldHighlight = shouldHighlight;
+lib$3.getChalk = getChalk;
+lib$3.default = highlight;
var _jsTokens = jsTokens;
-var _helperValidatorIdentifier = lib$7;
+var _helperValidatorIdentifier = lib$2;
-var _chalk = chalk$2.exports;
+var _chalk = chalk.exports;
const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
@@ -6568,7 +14918,7 @@ function getDefs$1(chalk) {
const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
const BRACKET = /^[()[\]{}]$/;
-let tokenize$3;
+let tokenize;
{
const JSX_TAG = /^[a-z][\w-]*$/i;
@@ -6598,7 +14948,7 @@ let tokenize$3;
return token.type;
};
- tokenize$3 = function* (text) {
+ tokenize = function* (text) {
let match;
while (match = _jsTokens.default.exec(text)) {
@@ -6618,7 +14968,7 @@ function highlightTokens(defs, text) {
for (const {
type,
value
- } of tokenize$3(text)) {
+ } of tokenize(text)) {
const colorize = defs[type];
if (colorize) {
@@ -6652,13 +15002,13 @@ function highlight(code, options = {}) {
}
}
-Object.defineProperty(lib$9, "__esModule", {
+Object.defineProperty(lib$4, "__esModule", {
value: true
});
-lib$9.codeFrameColumns = codeFrameColumns$1;
-lib$9.default = _default$1;
+lib$4.codeFrameColumns = codeFrameColumns$1;
+lib$4.default = _default;
-var _highlight = lib$8;
+var _highlight = lib$3;
let deprecationWarningShown = false;
@@ -6790,7 +15140,7 @@ function codeFrameColumns$1(rawLines, loc, opts = {}) {
}
}
-function _default$1(rawLines, lineNumber, colNumber, opts = {}) {
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
if (!deprecationWarningShown) {
deprecationWarningShown = true;
const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
@@ -6817,7 +15167,7 @@ function _default$1(rawLines, lineNumber, colNumber, opts = {}) {
const errorEx = errorEx_1;
const fallback = jsonParseEvenBetterErrors;
const {default: LinesAndColumns} = require$$2;
-const {codeFrameColumns} = lib$9;
+const {codeFrameColumns} = lib$4;
const JSONError = errorEx('JSONError', {
fileName: errorEx.append('in %s'),
@@ -6901,7 +15251,7 @@ var ms = function(val, options) {
options = options || {};
var type = typeof val;
if (type === 'string' && val.length > 0) {
- return parse$c(val);
+ return parse$a(val);
} else if (type === 'number' && isFinite(val)) {
return options.long ? fmtLong(val) : fmtShort(val);
}
@@ -6919,7 +15269,7 @@ var ms = function(val, options) {
* @api private
*/
-function parse$c(str) {
+function parse$a(str) {
str = String(str);
if (str.length > 100) {
return;
@@ -7307,7 +15657,7 @@ function setup(env) {
return createDebug;
}
-var common$4 = setup;
+var common$3 = setup;
/* eslint-env browser */
@@ -7564,7 +15914,7 @@ function localstorage() {
}
}
-module.exports = common$4(exports);
+module.exports = common$3(exports);
const {formatters} = module.exports;
@@ -7583,155 +15933,13 @@ formatters.j = function (v) {
var node = {exports: {}};
-var hasFlag$3 = (flag, argv = process.argv) => {
- const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
- const position = argv.indexOf(prefix + flag);
- const terminatorPosition = argv.indexOf('--');
- return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-};
-
-const os$2 = require$$0__default$1['default'];
-const tty = require$$1__default['default'];
-const hasFlag$2 = hasFlag$3;
-
-const {env: env$1} = process;
-
-let forceColor$1;
-if (hasFlag$2('no-color') ||
- hasFlag$2('no-colors') ||
- hasFlag$2('color=false') ||
- hasFlag$2('color=never')) {
- forceColor$1 = 0;
-} else if (hasFlag$2('color') ||
- hasFlag$2('colors') ||
- hasFlag$2('color=true') ||
- hasFlag$2('color=always')) {
- forceColor$1 = 1;
-}
-
-if ('FORCE_COLOR' in env$1) {
- if (env$1.FORCE_COLOR === 'true') {
- forceColor$1 = 1;
- } else if (env$1.FORCE_COLOR === 'false') {
- forceColor$1 = 0;
- } else {
- forceColor$1 = env$1.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env$1.FORCE_COLOR, 10), 3);
- }
-}
-
-function translateLevel$1(level) {
- if (level === 0) {
- return false;
- }
-
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
-}
-
-function supportsColor$1(haveStream, streamIsTTY) {
- if (forceColor$1 === 0) {
- return 0;
- }
-
- if (hasFlag$2('color=16m') ||
- hasFlag$2('color=full') ||
- hasFlag$2('color=truecolor')) {
- return 3;
- }
-
- if (hasFlag$2('color=256')) {
- return 2;
- }
-
- if (haveStream && !streamIsTTY && forceColor$1 === undefined) {
- return 0;
- }
-
- const min = forceColor$1 || 0;
-
- if (env$1.TERM === 'dumb') {
- return min;
- }
-
- if (process.platform === 'win32') {
- // Windows 10 build 10586 is the first Windows release that supports 256 colors.
- // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
- const osRelease = os$2.release().split('.');
- if (
- Number(osRelease[0]) >= 10 &&
- Number(osRelease[2]) >= 10586
- ) {
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
- }
-
- return 1;
- }
-
- if ('CI' in env$1) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env$1) || env$1.CI_NAME === 'codeship') {
- return 1;
- }
-
- return min;
- }
-
- if ('TEAMCITY_VERSION' in env$1) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env$1.TEAMCITY_VERSION) ? 1 : 0;
- }
-
- if (env$1.COLORTERM === 'truecolor') {
- return 3;
- }
-
- if ('TERM_PROGRAM' in env$1) {
- const version = parseInt((env$1.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-
- switch (env$1.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Apple_Terminal':
- return 2;
- // No default
- }
- }
-
- if (/-256(color)?$/i.test(env$1.TERM)) {
- return 2;
- }
-
- if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env$1.TERM)) {
- return 1;
- }
-
- if ('COLORTERM' in env$1) {
- return 1;
- }
-
- return min;
-}
-
-function getSupportLevel$1(stream) {
- const level = supportsColor$1(stream, stream && stream.isTTY);
- return translateLevel$1(level);
-}
-
-var supportsColor_1$1 = {
- supportsColor: getSupportLevel$1,
- stdout: translateLevel$1(supportsColor$1(true, tty.isatty(1))),
- stderr: translateLevel$1(supportsColor$1(true, tty.isatty(2)))
-};
-
/**
* Module dependencies.
*/
(function (module, exports) {
-const tty = require$$1__default['default'];
-const util = require$$0__default['default'];
+const tty = tty$1;
+const util = require$$0$4;
/**
* This is the Node.js implementation of `debug()`.
@@ -7965,7 +16173,7 @@ function init(debug) {
}
}
-module.exports = common$4(exports);
+module.exports = common$3(exports);
const {formatters} = module.exports;
@@ -8002,54 +16210,4296 @@ if (typeof process === 'undefined' || process.type === 'renderer' || process.bro
src.exports = node.exports;
}
-var resolveFrom$1 = {exports: {}};
+var createDebug = src.exports;
-const path$l = require$$0__default$2['default'];
-const Module = require$$1__default$1['default'];
-const fs$j = require$$0__default$3['default'];
+var re$6 = {exports: {}};
-const resolveFrom = (fromDirectory, moduleId, silent) => {
- if (typeof fromDirectory !== 'string') {
- throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDirectory}\``);
- }
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0';
- if (typeof moduleId !== 'string') {
- throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
- }
+const MAX_LENGTH$2 = 256;
+const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
+ /* istanbul ignore next */ 9007199254740991;
- try {
- fromDirectory = fs$j.realpathSync(fromDirectory);
- } catch (error) {
- if (error.code === 'ENOENT') {
- fromDirectory = path$l.resolve(fromDirectory);
- } else if (silent) {
- return;
- } else {
- throw error;
- }
- }
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16;
- const fromFile = path$l.join(fromDirectory, 'noop.js');
+var constants = {
+ SEMVER_SPEC_VERSION,
+ MAX_LENGTH: MAX_LENGTH$2,
+ MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
+ MAX_SAFE_COMPONENT_LENGTH
+};
- const resolveFileName = () => Module._resolveFilename(moduleId, {
- id: fromFile,
- filename: fromFile,
- paths: Module._nodeModulePaths(fromDirectory)
- });
+const debug$f = (
+ typeof process === 'object' &&
+ process.env &&
+ process.env.NODE_DEBUG &&
+ /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+ : () => {};
- if (silent) {
- try {
- return resolveFileName();
- } catch (error) {
- return;
- }
- }
+var debug_1 = debug$f;
+
+(function (module, exports) {
+const { MAX_SAFE_COMPONENT_LENGTH } = constants;
+const debug = debug_1;
+exports = module.exports = {};
+
+// The actual regexps go on exports.re
+const re = exports.re = [];
+const src = exports.src = [];
+const t = exports.t = {};
+let R = 0;
+
+const createToken = (name, value, isGlobal) => {
+ const index = R++;
+ debug(index, value);
+ t[name] = index;
+ src[index] = value;
+ re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+};
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+ `(${src[t.NUMERICIDENTIFIER]})\\.` +
+ `(${src[t.NUMERICIDENTIFIER]})`);
+
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+ `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+ `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+}|${src[t.NONNUMERICIDENTIFIER]})`);
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+ src[t.BUILD]}?`);
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`);
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+ src[t.BUILD]}?`);
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
+
+createToken('GTLT', '((?:<|>)?=?)');
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+ `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+ `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+ `(?:${src[t.PRERELEASE]})?${
+ src[t.BUILD]}?` +
+ `)?)?`);
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+ `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+ `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+ `(?:${src[t.PRERELEASELOOSE]})?${
+ src[t.BUILD]}?` +
+ `)?)?`);
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCE', `${'(^|[^\\d])' +
+ '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+ `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+ `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+ `(?:$|[^\\d])`);
+createToken('COERCERTL', src[t.COERCE], true);
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)');
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+exports.tildeTrimReplace = '$1~';
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)');
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
+exports.caretTrimReplace = '$1^';
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+exports.comparatorTrimReplace = '$1$2$3';
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+ `\\s+-\\s+` +
+ `(${src[t.XRANGEPLAIN]})` +
+ `\\s*$`);
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+ `\\s+-\\s+` +
+ `(${src[t.XRANGEPLAINLOOSE]})` +
+ `\\s*$`);
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*');
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
+createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
+}(re$6, re$6.exports));
+
+// parse out just the options we care about so we always get a consistent
+// obj with keys in a consistent order.
+const opts = ['includePrerelease', 'loose', 'rtl'];
+const parseOptions$4 = options =>
+ !options ? {}
+ : typeof options !== 'object' ? { loose: true }
+ : opts.filter(k => options[k]).reduce((options, k) => {
+ options[k] = true;
+ return options
+ }, {});
+var parseOptions_1 = parseOptions$4;
+
+const numeric$1 = /^[0-9]+$/;
+const compareIdentifiers$1 = (a, b) => {
+ const anum = numeric$1.test(a);
+ const bnum = numeric$1.test(b);
+
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+
+ return a === b ? 0
+ : (anum && !bnum) ? -1
+ : (bnum && !anum) ? 1
+ : a < b ? -1
+ : 1
+};
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
+
+var identifiers = {
+ compareIdentifiers: compareIdentifiers$1,
+ rcompareIdentifiers
+};
+
+const debug$e = debug_1;
+const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants;
+const { re: re$5, t: t$4 } = re$6.exports;
+
+const parseOptions$3 = parseOptions_1;
+const { compareIdentifiers } = identifiers;
+class SemVer$e {
+ constructor (version, options) {
+ options = parseOptions$3(options);
+
+ if (version instanceof SemVer$e) {
+ if (version.loose === !!options.loose &&
+ version.includePrerelease === !!options.includePrerelease) {
+ return version
+ } else {
+ version = version.version;
+ }
+ } else if (typeof version !== 'string') {
+ throw new TypeError(`Invalid Version: ${version}`)
+ }
+
+ if (version.length > MAX_LENGTH$1) {
+ throw new TypeError(
+ `version is longer than ${MAX_LENGTH$1} characters`
+ )
+ }
+
+ debug$e('SemVer', version, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ // this isn't actually relevant for versions, but keep it so that we
+ // don't run into trouble passing this.options around.
+ this.includePrerelease = !!options.includePrerelease;
+
+ const m = version.trim().match(options.loose ? re$5[t$4.LOOSE] : re$5[t$4.FULL]);
+
+ if (!m) {
+ throw new TypeError(`Invalid Version: ${version}`)
+ }
+
+ this.raw = version;
+
+ // these are actually numbers
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError('Invalid major version')
+ }
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError('Invalid minor version')
+ }
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError('Invalid patch version')
+ }
+
+ // numberify any prerelease numeric ids
+ if (!m[4]) {
+ this.prerelease = [];
+ } else {
+ this.prerelease = m[4].split('.').map((id) => {
+ if (/^[0-9]+$/.test(id)) {
+ const num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num
+ }
+ }
+ return id
+ });
+ }
+
+ this.build = m[5] ? m[5].split('.') : [];
+ this.format();
+ }
+
+ format () {
+ this.version = `${this.major}.${this.minor}.${this.patch}`;
+ if (this.prerelease.length) {
+ this.version += `-${this.prerelease.join('.')}`;
+ }
+ return this.version
+ }
+
+ toString () {
+ return this.version
+ }
+
+ compare (other) {
+ debug$e('SemVer.compare', this.version, this.options, other);
+ if (!(other instanceof SemVer$e)) {
+ if (typeof other === 'string' && other === this.version) {
+ return 0
+ }
+ other = new SemVer$e(other, this.options);
+ }
+
+ if (other.version === this.version) {
+ return 0
+ }
+
+ return this.compareMain(other) || this.comparePre(other)
+ }
+
+ compareMain (other) {
+ if (!(other instanceof SemVer$e)) {
+ other = new SemVer$e(other, this.options);
+ }
+
+ return (
+ compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch)
+ )
+ }
+
+ comparePre (other) {
+ if (!(other instanceof SemVer$e)) {
+ other = new SemVer$e(other, this.options);
+ }
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0
+ }
+
+ let i = 0;
+ do {
+ const a = this.prerelease[i];
+ const b = other.prerelease[i];
+ debug$e('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined) {
+ return 0
+ } else if (b === undefined) {
+ return 1
+ } else if (a === undefined) {
+ return -1
+ } else if (a === b) {
+ continue
+ } else {
+ return compareIdentifiers(a, b)
+ }
+ } while (++i)
+ }
+
+ compareBuild (other) {
+ if (!(other instanceof SemVer$e)) {
+ other = new SemVer$e(other, this.options);
+ }
+
+ let i = 0;
+ do {
+ const a = this.build[i];
+ const b = other.build[i];
+ debug$e('prerelease compare', i, a, b);
+ if (a === undefined && b === undefined) {
+ return 0
+ } else if (b === undefined) {
+ return 1
+ } else if (a === undefined) {
+ return -1
+ } else if (a === b) {
+ continue
+ } else {
+ return compareIdentifiers(a, b)
+ }
+ } while (++i)
+ }
+
+ // preminor will bump the version up to the next minor release, and immediately
+ // down to pre-release. premajor and prepatch work the same way.
+ inc (release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc('pre', identifier);
+ break
+ case 'preminor':
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc('pre', identifier);
+ break
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0;
+ this.inc('patch', identifier);
+ this.inc('pre', identifier);
+ break
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0) {
+ this.inc('patch', identifier);
+ }
+ this.inc('pre', identifier);
+ break
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (
+ this.minor !== 0 ||
+ this.patch !== 0 ||
+ this.prerelease.length === 0
+ ) {
+ this.major++;
+ }
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++;
+ }
+ this.patch = 0;
+ this.prerelease = [];
+ break
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0) {
+ this.patch++;
+ }
+ this.prerelease = [];
+ break
+ // This probably shouldn't be used publicly.
+ // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0];
+ } else {
+ let i = this.prerelease.length;
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++;
+ i = -2;
+ }
+ }
+ if (i === -1) {
+ // didn't increment anything
+ this.prerelease.push(0);
+ }
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0];
+ }
+ } else {
+ this.prerelease = [identifier, 0];
+ }
+ }
+ break
+
+ default:
+ throw new Error(`invalid increment argument: ${release}`)
+ }
+ this.format();
+ this.raw = this.version;
+ return this
+ }
+}
+
+var semver$2 = SemVer$e;
+
+const {MAX_LENGTH} = constants;
+const { re: re$4, t: t$3 } = re$6.exports;
+const SemVer$d = semver$2;
+
+const parseOptions$2 = parseOptions_1;
+const parse$9 = (version, options) => {
+ options = parseOptions$2(options);
+
+ if (version instanceof SemVer$d) {
+ return version
+ }
+
+ if (typeof version !== 'string') {
+ return null
+ }
+
+ if (version.length > MAX_LENGTH) {
+ return null
+ }
+
+ const r = options.loose ? re$4[t$3.LOOSE] : re$4[t$3.FULL];
+ if (!r.test(version)) {
+ return null
+ }
+
+ try {
+ return new SemVer$d(version, options)
+ } catch (er) {
+ return null
+ }
+};
+
+var parse_1 = parse$9;
+
+const parse$8 = parse_1;
+const valid$1 = (version, options) => {
+ const v = parse$8(version, options);
+ return v ? v.version : null
+};
+var valid_1 = valid$1;
+
+const parse$7 = parse_1;
+const clean = (version, options) => {
+ const s = parse$7(version.trim().replace(/^[=v]+/, ''), options);
+ return s ? s.version : null
+};
+var clean_1 = clean;
+
+const SemVer$c = semver$2;
+
+const inc = (version, release, options, identifier) => {
+ if (typeof (options) === 'string') {
+ identifier = options;
+ options = undefined;
+ }
+
+ try {
+ return new SemVer$c(version, options).inc(release, identifier).version
+ } catch (er) {
+ return null
+ }
+};
+var inc_1 = inc;
+
+const SemVer$b = semver$2;
+const compare$b = (a, b, loose) =>
+ new SemVer$b(a, loose).compare(new SemVer$b(b, loose));
+
+var compare_1 = compare$b;
+
+const compare$a = compare_1;
+const eq$2 = (a, b, loose) => compare$a(a, b, loose) === 0;
+var eq_1 = eq$2;
+
+const parse$6 = parse_1;
+const eq$1 = eq_1;
+
+const diff = (version1, version2) => {
+ if (eq$1(version1, version2)) {
+ return null
+ } else {
+ const v1 = parse$6(version1);
+ const v2 = parse$6(version2);
+ const hasPre = v1.prerelease.length || v2.prerelease.length;
+ const prefix = hasPre ? 'pre' : '';
+ const defaultResult = hasPre ? 'prerelease' : '';
+ for (const key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return prefix + key
+ }
+ }
+ }
+ return defaultResult // may be undefined
+ }
+};
+var diff_1 = diff;
+
+const SemVer$a = semver$2;
+const major = (a, loose) => new SemVer$a(a, loose).major;
+var major_1 = major;
+
+const SemVer$9 = semver$2;
+const minor = (a, loose) => new SemVer$9(a, loose).minor;
+var minor_1 = minor;
+
+const SemVer$8 = semver$2;
+const patch = (a, loose) => new SemVer$8(a, loose).patch;
+var patch_1 = patch;
+
+const parse$5 = parse_1;
+const prerelease = (version, options) => {
+ const parsed = parse$5(version, options);
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+};
+var prerelease_1 = prerelease;
+
+const compare$9 = compare_1;
+const rcompare = (a, b, loose) => compare$9(b, a, loose);
+var rcompare_1 = rcompare;
+
+const compare$8 = compare_1;
+const compareLoose = (a, b) => compare$8(a, b, true);
+var compareLoose_1 = compareLoose;
+
+const SemVer$7 = semver$2;
+const compareBuild$2 = (a, b, loose) => {
+ const versionA = new SemVer$7(a, loose);
+ const versionB = new SemVer$7(b, loose);
+ return versionA.compare(versionB) || versionA.compareBuild(versionB)
+};
+var compareBuild_1 = compareBuild$2;
+
+const compareBuild$1 = compareBuild_1;
+const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(a, b, loose));
+var sort_1 = sort$1;
+
+const compareBuild = compareBuild_1;
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+var rsort_1 = rsort;
+
+const compare$7 = compare_1;
+const gt$3 = (a, b, loose) => compare$7(a, b, loose) > 0;
+var gt_1 = gt$3;
+
+const compare$6 = compare_1;
+const lt$2 = (a, b, loose) => compare$6(a, b, loose) < 0;
+var lt_1 = lt$2;
+
+const compare$5 = compare_1;
+const neq$1 = (a, b, loose) => compare$5(a, b, loose) !== 0;
+var neq_1 = neq$1;
+
+const compare$4 = compare_1;
+const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
+var gte_1 = gte$3;
+
+const compare$3 = compare_1;
+const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
+var lte_1 = lte$3;
+
+const eq = eq_1;
+const neq = neq_1;
+const gt$2 = gt_1;
+const gte$2 = gte_1;
+const lt$1 = lt_1;
+const lte$2 = lte_1;
+
+const cmp$1 = (a, op, b, loose) => {
+ switch (op) {
+ case '===':
+ if (typeof a === 'object')
+ a = a.version;
+ if (typeof b === 'object')
+ b = b.version;
+ return a === b
+
+ case '!==':
+ if (typeof a === 'object')
+ a = a.version;
+ if (typeof b === 'object')
+ b = b.version;
+ return a !== b
+
+ case '':
+ case '=':
+ case '==':
+ return eq(a, b, loose)
+
+ case '!=':
+ return neq(a, b, loose)
+
+ case '>':
+ return gt$2(a, b, loose)
+
+ case '>=':
+ return gte$2(a, b, loose)
+
+ case '<':
+ return lt$1(a, b, loose)
+
+ case '<=':
+ return lte$2(a, b, loose)
+
+ default:
+ throw new TypeError(`Invalid operator: ${op}`)
+ }
+};
+var cmp_1 = cmp$1;
+
+const SemVer$6 = semver$2;
+const parse$4 = parse_1;
+const {re: re$3, t: t$2} = re$6.exports;
+
+const coerce$I = (version, options) => {
+ if (version instanceof SemVer$6) {
+ return version
+ }
+
+ if (typeof version === 'number') {
+ version = String(version);
+ }
+
+ if (typeof version !== 'string') {
+ return null
+ }
+
+ options = options || {};
+
+ let match = null;
+ if (!options.rtl) {
+ match = version.match(re$3[t$2.COERCE]);
+ } else {
+ // Find the right-most coercible string that does not share
+ // a terminus with a more left-ward coercible string.
+ // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+ //
+ // Walk through the string checking with a /g regexp
+ // Manually set the index so as to pick up overlapping matches.
+ // Stop when we get a match that ends at the string end, since no
+ // coercible string can be more right-ward without the same terminus.
+ let next;
+ while ((next = re$3[t$2.COERCERTL].exec(version)) &&
+ (!match || match.index + match[0].length !== version.length)
+ ) {
+ if (!match ||
+ next.index + next[0].length !== match.index + match[0].length) {
+ match = next;
+ }
+ re$3[t$2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+ }
+ // leave it in a clean state
+ re$3[t$2.COERCERTL].lastIndex = -1;
+ }
+
+ if (match === null)
+ return null
+
+ return parse$4(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+};
+var coerce_1 = coerce$I;
+
+var iterator = function (Yallist) {
+ Yallist.prototype[Symbol.iterator] = function* () {
+ for (let walker = this.head; walker; walker = walker.next) {
+ yield walker.value;
+ }
+ };
+};
+
+var yallist = Yallist$1;
+
+Yallist$1.Node = Node;
+Yallist$1.create = Yallist$1;
+
+function Yallist$1 (list) {
+ var self = this;
+ if (!(self instanceof Yallist$1)) {
+ self = new Yallist$1();
+ }
+
+ self.tail = null;
+ self.head = null;
+ self.length = 0;
+
+ if (list && typeof list.forEach === 'function') {
+ list.forEach(function (item) {
+ self.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self.push(arguments[i]);
+ }
+ }
+
+ return self
+}
+
+Yallist$1.prototype.removeNode = function (node) {
+ if (node.list !== this) {
+ throw new Error('removing node which does not belong to this list')
+ }
+
+ var next = node.next;
+ var prev = node.prev;
+
+ if (next) {
+ next.prev = prev;
+ }
+
+ if (prev) {
+ prev.next = next;
+ }
+
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+
+ return next
+};
+
+Yallist$1.prototype.unshiftNode = function (node) {
+ if (node === this.head) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+};
+
+Yallist$1.prototype.pushNode = function (node) {
+ if (node === this.tail) {
+ return
+ }
+
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+};
+
+Yallist$1.prototype.push = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push$2(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist$1.prototype.unshift = function () {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length
+};
+
+Yallist$1.prototype.pop = function () {
+ if (!this.tail) {
+ return undefined
+ }
+
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist$1.prototype.shift = function () {
+ if (!this.head) {
+ return undefined
+ }
+
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res
+};
+
+Yallist$1.prototype.forEach = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+};
+
+Yallist$1.prototype.forEachReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+};
+
+Yallist$1.prototype.get = function (n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist$1.prototype.getReverse = function (n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ // abort out of the list early if we hit a cycle
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value
+ }
+};
+
+Yallist$1.prototype.map = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist$1();
+ for (var walker = this.head; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res
+};
+
+Yallist$1.prototype.mapReverse = function (fn, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist$1();
+ for (var walker = this.tail; walker !== null;) {
+ res.push(fn.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res
+};
+
+Yallist$1.prototype.reduce = function (fn, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = 0; walker !== null; i++) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.next;
+ }
+
+ return acc
+};
+
+Yallist$1.prototype.reduceReverse = function (fn, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError('Reduce of empty list with no initial value')
+ }
+
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn(acc, walker.value, i);
+ walker = walker.prev;
+ }
+
+ return acc
+};
+
+Yallist$1.prototype.toArray = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr
+};
+
+Yallist$1.prototype.toArrayReverse = function () {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr
+};
+
+Yallist$1.prototype.slice = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist$1();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist$1.prototype.sliceReverse = function (from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist$1();
+ if (to < from || to < 0) {
+ return ret
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret
+};
+
+Yallist$1.prototype.splice = function (start, deleteCount, ...nodes) {
+ if (start > this.length) {
+ start = this.length - 1;
+ }
+ if (start < 0) {
+ start = this.length + start;
+ }
+
+ for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+ walker = walker.next;
+ }
+
+ var ret = [];
+ for (var i = 0; walker && i < deleteCount; i++) {
+ ret.push(walker.value);
+ walker = this.removeNode(walker);
+ }
+ if (walker === null) {
+ walker = this.tail;
+ }
+
+ if (walker !== this.head && walker !== this.tail) {
+ walker = walker.prev;
+ }
+
+ for (var i = 0; i < nodes.length; i++) {
+ walker = insert(this, walker, nodes[i]);
+ }
+ return ret;
+};
+
+Yallist$1.prototype.reverse = function () {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this
+};
+
+function insert (self, node, value) {
+ var inserted = node === self.head ?
+ new Node(value, null, node, self) :
+ new Node(value, node, node.next, self);
+
+ if (inserted.next === null) {
+ self.tail = inserted;
+ }
+ if (inserted.prev === null) {
+ self.head = inserted;
+ }
+
+ self.length++;
+
+ return inserted
+}
+
+function push$2 (self, item) {
+ self.tail = new Node(item, self.tail, null, self);
+ if (!self.head) {
+ self.head = self.tail;
+ }
+ self.length++;
+}
+
+function unshift (self, item) {
+ self.head = new Node(item, null, self.head, self);
+ if (!self.tail) {
+ self.tail = self.head;
+ }
+ self.length++;
+}
+
+function Node (value, prev, next, list) {
+ if (!(this instanceof Node)) {
+ return new Node(value, prev, next, list)
+ }
+
+ this.list = list;
+ this.value = value;
+
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+}
+
+try {
+ // add if support for Symbol.iterator is present
+ iterator(Yallist$1);
+} catch (er) {}
+
+// A linked list to keep track of recently-used-ness
+const Yallist = yallist;
+
+const MAX = Symbol('max');
+const LENGTH = Symbol('length');
+const LENGTH_CALCULATOR = Symbol('lengthCalculator');
+const ALLOW_STALE = Symbol('allowStale');
+const MAX_AGE = Symbol('maxAge');
+const DISPOSE = Symbol('dispose');
+const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
+const LRU_LIST = Symbol('lruList');
+const CACHE = Symbol('cache');
+const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
+
+const naiveLength = () => 1;
+
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest. the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node. This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
+class LRUCache {
+ constructor (options) {
+ if (typeof options === 'number')
+ options = { max: options };
+
+ if (!options)
+ options = {};
+
+ if (options.max && (typeof options.max !== 'number' || options.max < 0))
+ throw new TypeError('max must be a non-negative number')
+ // Kind of weird to have a default max of Infinity, but oh well.
+ this[MAX] = options.max || Infinity;
+
+ const lc = options.length || naiveLength;
+ this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
+ this[ALLOW_STALE] = options.stale || false;
+ if (options.maxAge && typeof options.maxAge !== 'number')
+ throw new TypeError('maxAge must be a number')
+ this[MAX_AGE] = options.maxAge || 0;
+ this[DISPOSE] = options.dispose;
+ this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+ this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+ this.reset();
+ }
+
+ // resize the cache when the max changes.
+ set max (mL) {
+ if (typeof mL !== 'number' || mL < 0)
+ throw new TypeError('max must be a non-negative number')
+
+ this[MAX] = mL || Infinity;
+ trim(this);
+ }
+ get max () {
+ return this[MAX]
+ }
+
+ set allowStale (allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ }
+ get allowStale () {
+ return this[ALLOW_STALE]
+ }
+
+ set maxAge (mA) {
+ if (typeof mA !== 'number')
+ throw new TypeError('maxAge must be a non-negative number')
+
+ this[MAX_AGE] = mA;
+ trim(this);
+ }
+ get maxAge () {
+ return this[MAX_AGE]
+ }
+
+ // resize the cache when the lengthCalculator changes.
+ set lengthCalculator (lC) {
+ if (typeof lC !== 'function')
+ lC = naiveLength;
+
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach(hit => {
+ hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+ this[LENGTH] += hit.length;
+ });
+ }
+ trim(this);
+ }
+ get lengthCalculator () { return this[LENGTH_CALCULATOR] }
+
+ get length () { return this[LENGTH] }
+ get itemCount () { return this[LRU_LIST].length }
+
+ rforEach (fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].tail; walker !== null;) {
+ const prev = walker.prev;
+ forEachStep(this, fn, walker, thisp);
+ walker = prev;
+ }
+ }
+
+ forEach (fn, thisp) {
+ thisp = thisp || this;
+ for (let walker = this[LRU_LIST].head; walker !== null;) {
+ const next = walker.next;
+ forEachStep(this, fn, walker, thisp);
+ walker = next;
+ }
+ }
+
+ keys () {
+ return this[LRU_LIST].toArray().map(k => k.key)
+ }
+
+ values () {
+ return this[LRU_LIST].toArray().map(k => k.value)
+ }
+
+ reset () {
+ if (this[DISPOSE] &&
+ this[LRU_LIST] &&
+ this[LRU_LIST].length) {
+ this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
+ }
+
+ this[CACHE] = new Map(); // hash of items by key
+ this[LRU_LIST] = new Yallist(); // list of items in order of use recency
+ this[LENGTH] = 0; // length of items in the list
+ }
+
+ dump () {
+ return this[LRU_LIST].map(hit =>
+ isStale(this, hit) ? false : {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ }).toArray().filter(h => h)
+ }
+
+ dumpLru () {
+ return this[LRU_LIST]
+ }
+
+ set (key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+
+ if (maxAge && typeof maxAge !== 'number')
+ throw new TypeError('maxAge must be a number')
+
+ const now = maxAge ? Date.now() : 0;
+ const len = this[LENGTH_CALCULATOR](value, key);
+
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ del(this, this[CACHE].get(key));
+ return false
+ }
+
+ const node = this[CACHE].get(key);
+ const item = node.value;
+
+ // dispose of the old one before overwriting
+ // split out into 2 ifs for better coverage tracking
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET])
+ this[DISPOSE](key, item.value);
+ }
+
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true
+ }
+
+ const hit = new Entry(key, value, len, now, maxAge);
+
+ // oversized objects fall out of cache automatically.
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE])
+ this[DISPOSE](key, value);
+
+ return false
+ }
+
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true
+ }
+
+ has (key) {
+ if (!this[CACHE].has(key)) return false
+ const hit = this[CACHE].get(key).value;
+ return !isStale(this, hit)
+ }
+
+ get (key) {
+ return get(this, key, true)
+ }
+
+ peek (key) {
+ return get(this, key, false)
+ }
+
+ pop () {
+ const node = this[LRU_LIST].tail;
+ if (!node)
+ return null
+
+ del(this, node);
+ return node.value
+ }
+
+ del (key) {
+ del(this, this[CACHE].get(key));
+ }
+
+ load (arr) {
+ // reset the cache
+ this.reset();
+
+ const now = Date.now();
+ // A previous serialized cache has the most recent items first
+ for (let l = arr.length - 1; l >= 0; l--) {
+ const hit = arr[l];
+ const expiresAt = hit.e || 0;
+ if (expiresAt === 0)
+ // the item was created without expiration in a non aged cache
+ this.set(hit.k, hit.v);
+ else {
+ const maxAge = expiresAt - now;
+ // dont add already expired items
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+ }
+
+ prune () {
+ this[CACHE].forEach((value, key) => get(this, key, false));
+ }
+}
+
+const get = (self, key, doUse) => {
+ const node = self[CACHE].get(key);
+ if (node) {
+ const hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ return undefined
+ } else {
+ if (doUse) {
+ if (self[UPDATE_AGE_ON_GET])
+ node.value.now = Date.now();
+ self[LRU_LIST].unshiftNode(node);
+ }
+ }
+ return hit.value
+ }
+};
+
+const isStale = (self, hit) => {
+ if (!hit || (!hit.maxAge && !self[MAX_AGE]))
+ return false
+
+ const diff = Date.now() - hit.now;
+ return hit.maxAge ? diff > hit.maxAge
+ : self[MAX_AGE] && (diff > self[MAX_AGE])
+};
+
+const trim = self => {
+ if (self[LENGTH] > self[MAX]) {
+ for (let walker = self[LRU_LIST].tail;
+ self[LENGTH] > self[MAX] && walker !== null;) {
+ // We know that we're about to delete this one, and also
+ // what the next least recently used key will be, so just
+ // go ahead and set it now.
+ const prev = walker.prev;
+ del(self, walker);
+ walker = prev;
+ }
+ }
+};
+
+const del = (self, node) => {
+ if (node) {
+ const hit = node.value;
+ if (self[DISPOSE])
+ self[DISPOSE](hit.key, hit.value);
+
+ self[LENGTH] -= hit.length;
+ self[CACHE].delete(hit.key);
+ self[LRU_LIST].removeNode(node);
+ }
+};
+
+class Entry {
+ constructor (key, value, length, now, maxAge) {
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+ }
+}
+
+const forEachStep = (self, fn, node, thisp) => {
+ let hit = node.value;
+ if (isStale(self, hit)) {
+ del(self, node);
+ if (!self[ALLOW_STALE])
+ hit = undefined;
+ }
+ if (hit)
+ fn.call(thisp, hit.value, hit.key, self);
+};
+
+var lruCache = LRUCache;
+
+// hoisted class for cyclic dependency
+class Range$a {
+ constructor (range, options) {
+ options = parseOptions$1(options);
+
+ if (range instanceof Range$a) {
+ if (
+ range.loose === !!options.loose &&
+ range.includePrerelease === !!options.includePrerelease
+ ) {
+ return range
+ } else {
+ return new Range$a(range.raw, options)
+ }
+ }
+
+ if (range instanceof Comparator$2) {
+ // just put it in the set and return
+ this.raw = range.value;
+ this.set = [[range]];
+ this.format();
+ return this
+ }
+
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+
+ // First, split based on boolean or ||
+ this.raw = range;
+ this.set = range
+ .split(/\s*\|\|\s*/)
+ // map the range to a 2d array of comparators
+ .map(range => this.parseRange(range.trim()))
+ // throw out any comparator lists that are empty
+ // this generally means that it was not a valid range, which is allowed
+ // in loose mode, but will still throw if the WHOLE range is invalid.
+ .filter(c => c.length);
+
+ if (!this.set.length) {
+ throw new TypeError(`Invalid SemVer Range: ${range}`)
+ }
+
+ // if we have any that are not the null set, throw out null sets.
+ if (this.set.length > 1) {
+ // keep the first one, in case they're all null sets
+ const first = this.set[0];
+ this.set = this.set.filter(c => !isNullSet(c[0]));
+ if (this.set.length === 0)
+ this.set = [first];
+ else if (this.set.length > 1) {
+ // if we have any that are *, then the range is just *
+ for (const c of this.set) {
+ if (c.length === 1 && isAny(c[0])) {
+ this.set = [c];
+ break
+ }
+ }
+ }
+ }
+
+ this.format();
+ }
+
+ format () {
+ this.range = this.set
+ .map((comps) => {
+ return comps.join(' ').trim()
+ })
+ .join('||')
+ .trim();
+ return this.range
+ }
+
+ toString () {
+ return this.range
+ }
+
+ parseRange (range) {
+ range = range.trim();
+
+ // memoize range parsing for performance.
+ // this is a very hot path, and fully deterministic.
+ const memoOpts = Object.keys(this.options).join(',');
+ const memoKey = `parseRange:${memoOpts}:${range}`;
+ const cached = cache$1.get(memoKey);
+ if (cached)
+ return cached
+
+ const loose = this.options.loose;
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ const hr = loose ? re$2[t$1.HYPHENRANGELOOSE] : re$2[t$1.HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+ debug$d('hyphen replace', range);
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re$2[t$1.COMPARATORTRIM], comparatorTrimReplace);
+ debug$d('comparator trim', range, re$2[t$1.COMPARATORTRIM]);
+
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re$2[t$1.TILDETRIM], tildeTrimReplace);
+
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re$2[t$1.CARETTRIM], caretTrimReplace);
+
+ // normalize spaces
+ range = range.split(/\s+/).join(' ');
+
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
+
+ const compRe = loose ? re$2[t$1.COMPARATORLOOSE] : re$2[t$1.COMPARATOR];
+ const rangeList = range
+ .split(' ')
+ .map(comp => parseComparator(comp, this.options))
+ .join(' ')
+ .split(/\s+/)
+ // >=0.0.0 is equivalent to *
+ .map(comp => replaceGTE0(comp, this.options))
+ // in loose mode, throw out any that are not valid comparators
+ .filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
+ .map(comp => new Comparator$2(comp, this.options));
+
+ // if any comparators are the null set, then replace with JUST null set
+ // if more than one comparator, remove any * comparators
+ // also, don't include the same comparator more than once
+ rangeList.length;
+ const rangeMap = new Map();
+ for (const comp of rangeList) {
+ if (isNullSet(comp))
+ return [comp]
+ rangeMap.set(comp.value, comp);
+ }
+ if (rangeMap.size > 1 && rangeMap.has(''))
+ rangeMap.delete('');
+
+ const result = [...rangeMap.values()];
+ cache$1.set(memoKey, result);
+ return result
+ }
+
+ intersects (range, options) {
+ if (!(range instanceof Range$a)) {
+ throw new TypeError('a Range is required')
+ }
+
+ return this.set.some((thisComparators) => {
+ return (
+ isSatisfiable(thisComparators, options) &&
+ range.set.some((rangeComparators) => {
+ return (
+ isSatisfiable(rangeComparators, options) &&
+ thisComparators.every((thisComparator) => {
+ return rangeComparators.every((rangeComparator) => {
+ return thisComparator.intersects(rangeComparator, options)
+ })
+ })
+ )
+ })
+ )
+ })
+ }
+
+ // if ANY of the sets match ALL of its comparators, then pass
+ test (version) {
+ if (!version) {
+ return false
+ }
+
+ if (typeof version === 'string') {
+ try {
+ version = new SemVer$5(version, this.options);
+ } catch (er) {
+ return false
+ }
+ }
+
+ for (let i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version, this.options)) {
+ return true
+ }
+ }
+ return false
+ }
+}
+var range$1 = Range$a;
+
+const LRU = lruCache;
+const cache$1 = new LRU({ max: 1000 });
+
+const parseOptions$1 = parseOptions_1;
+const Comparator$2 = comparator$1;
+const debug$d = debug_1;
+const SemVer$5 = semver$2;
+const {
+ re: re$2,
+ t: t$1,
+ comparatorTrimReplace,
+ tildeTrimReplace,
+ caretTrimReplace
+} = re$6.exports;
+
+const isNullSet = c => c.value === '<0.0.0-0';
+const isAny = c => c.value === '';
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+ let result = true;
+ const remainingComparators = comparators.slice();
+ let testComparator = remainingComparators.pop();
+
+ while (result && remainingComparators.length) {
+ result = remainingComparators.every((otherComparator) => {
+ return testComparator.intersects(otherComparator, options)
+ });
+
+ testComparator = remainingComparators.pop();
+ }
+
+ return result
+};
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+ debug$d('comp', comp, options);
+ comp = replaceCarets(comp, options);
+ debug$d('caret', comp);
+ comp = replaceTildes(comp, options);
+ debug$d('tildes', comp);
+ comp = replaceXRanges(comp, options);
+ debug$d('xrange', comp);
+ comp = replaceStars(comp, options);
+ debug$d('stars', comp);
+ return comp
+};
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+const replaceTildes = (comp, options) =>
+ comp.trim().split(/\s+/).map((comp) => {
+ return replaceTilde(comp, options)
+ }).join(' ');
+
+const replaceTilde = (comp, options) => {
+ const r = options.loose ? re$2[t$1.TILDELOOSE] : re$2[t$1.TILDE];
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug$d('tilde', comp, _, M, m, p, pr);
+ let ret;
+
+ if (isX(M)) {
+ ret = '';
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ // ~1.2 == >=1.2.0 <1.3.0-0
+ ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+ } else if (pr) {
+ debug$d('replaceTilde pr', pr);
+ ret = `>=${M}.${m}.${p}-${pr
+ } <${M}.${+m + 1}.0-0`;
+ } else {
+ // ~1.2.3 == >=1.2.3 <1.3.0-0
+ ret = `>=${M}.${m}.${p
+ } <${M}.${+m + 1}.0-0`;
+ }
+
+ debug$d('tilde return', ret);
+ return ret
+ })
+};
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+const replaceCarets = (comp, options) =>
+ comp.trim().split(/\s+/).map((comp) => {
+ return replaceCaret(comp, options)
+ }).join(' ');
+
+const replaceCaret = (comp, options) => {
+ debug$d('caret', comp, options);
+ const r = options.loose ? re$2[t$1.CARETLOOSE] : re$2[t$1.CARET];
+ const z = options.includePrerelease ? '-0' : '';
+ return comp.replace(r, (_, M, m, p, pr) => {
+ debug$d('caret', comp, _, M, m, p, pr);
+ let ret;
+
+ if (isX(M)) {
+ ret = '';
+ } else if (isX(m)) {
+ ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+ } else if (isX(p)) {
+ if (M === '0') {
+ ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+ } else {
+ ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+ }
+ } else if (pr) {
+ debug$d('replaceCaret pr', pr);
+ if (M === '0') {
+ if (m === '0') {
+ ret = `>=${M}.${m}.${p}-${pr
+ } <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr
+ } <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p}-${pr
+ } <${+M + 1}.0.0-0`;
+ }
+ } else {
+ debug$d('no pr');
+ if (M === '0') {
+ if (m === '0') {
+ ret = `>=${M}.${m}.${p
+ }${z} <${M}.${m}.${+p + 1}-0`;
+ } else {
+ ret = `>=${M}.${m}.${p
+ }${z} <${M}.${+m + 1}.0-0`;
+ }
+ } else {
+ ret = `>=${M}.${m}.${p
+ } <${+M + 1}.0.0-0`;
+ }
+ }
+
+ debug$d('caret return', ret);
+ return ret
+ })
+};
+
+const replaceXRanges = (comp, options) => {
+ debug$d('replaceXRanges', comp, options);
+ return comp.split(/\s+/).map((comp) => {
+ return replaceXRange(comp, options)
+ }).join(' ')
+};
+
+const replaceXRange = (comp, options) => {
+ comp = comp.trim();
+ const r = options.loose ? re$2[t$1.XRANGELOOSE] : re$2[t$1.XRANGE];
+ return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+ debug$d('xRange', comp, ret, gtlt, M, m, p, pr);
+ const xM = isX(M);
+ const xm = xM || isX(m);
+ const xp = xm || isX(p);
+ const anyX = xp;
+
+ if (gtlt === '=' && anyX) {
+ gtlt = '';
+ }
+
+ // if we're including prereleases in the match, then we need
+ // to fix this to -0, the lowest possible prerelease value
+ pr = options.includePrerelease ? '-0' : '';
+
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0-0';
+ } else {
+ // nothing is forbidden
+ ret = '*';
+ }
+ } else if (gtlt && anyX) {
+ // we know patch is an x, because we have any x at all.
+ // replace X with 0
+ if (xm) {
+ m = 0;
+ }
+ p = 0;
+
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ gtlt = '>=';
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<';
+ if (xm) {
+ M = +M + 1;
+ } else {
+ m = +m + 1;
+ }
+ }
+
+ if (gtlt === '<')
+ pr = '-0';
+
+ ret = `${gtlt + M}.${m}.${p}${pr}`;
+ } else if (xm) {
+ ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+ } else if (xp) {
+ ret = `>=${M}.${m}.0${pr
+ } <${M}.${+m + 1}.0-0`;
+ }
+
+ debug$d('xRange return', ret);
+
+ return ret
+ })
+};
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+ debug$d('replaceStars', comp, options);
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re$2[t$1.STAR], '')
+};
+
+const replaceGTE0 = (comp, options) => {
+ debug$d('replaceGTE0', comp, options);
+ return comp.trim()
+ .replace(re$2[options.includePrerelease ? t$1.GTE0PRE : t$1.GTE0], '')
+};
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+const hyphenReplace = incPr => ($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) => {
+ if (isX(fM)) {
+ from = '';
+ } else if (isX(fm)) {
+ from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
+ } else if (isX(fp)) {
+ from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
+ } else if (fpr) {
+ from = `>=${from}`;
+ } else {
+ from = `>=${from}${incPr ? '-0' : ''}`;
+ }
+
+ if (isX(tM)) {
+ to = '';
+ } else if (isX(tm)) {
+ to = `<${+tM + 1}.0.0-0`;
+ } else if (isX(tp)) {
+ to = `<${tM}.${+tm + 1}.0-0`;
+ } else if (tpr) {
+ to = `<=${tM}.${tm}.${tp}-${tpr}`;
+ } else if (incPr) {
+ to = `<${tM}.${tm}.${+tp + 1}-0`;
+ } else {
+ to = `<=${to}`;
+ }
+
+ return (`${from} ${to}`).trim()
+};
+
+const testSet = (set, version, options) => {
+ for (let i = 0; i < set.length; i++) {
+ if (!set[i].test(version)) {
+ return false
+ }
+ }
+
+ if (version.prerelease.length && !options.includePrerelease) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (let i = 0; i < set.length; i++) {
+ debug$d(set[i].semver);
+ if (set[i].semver === Comparator$2.ANY) {
+ continue
+ }
+
+ if (set[i].semver.prerelease.length > 0) {
+ const allowed = set[i].semver;
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch) {
+ return true
+ }
+ }
+ }
+
+ // Version has a -pre, but it's not one of the ones we like.
+ return false
+ }
+
+ return true
+};
+
+const ANY$2 = Symbol('SemVer ANY');
+// hoisted class for cyclic dependency
+class Comparator$1 {
+ static get ANY () {
+ return ANY$2
+ }
+ constructor (comp, options) {
+ options = parseOptions(options);
+
+ if (comp instanceof Comparator$1) {
+ if (comp.loose === !!options.loose) {
+ return comp
+ } else {
+ comp = comp.value;
+ }
+ }
+
+ debug$c('comparator', comp, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.parse(comp);
+
+ if (this.semver === ANY$2) {
+ this.value = '';
+ } else {
+ this.value = this.operator + this.semver.version;
+ }
+
+ debug$c('comp', this);
+ }
+
+ parse (comp) {
+ const r = this.options.loose ? re$1[t.COMPARATORLOOSE] : re$1[t.COMPARATOR];
+ const m = comp.match(r);
+
+ if (!m) {
+ throw new TypeError(`Invalid comparator: ${comp}`)
+ }
+
+ this.operator = m[1] !== undefined ? m[1] : '';
+ if (this.operator === '=') {
+ this.operator = '';
+ }
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2]) {
+ this.semver = ANY$2;
+ } else {
+ this.semver = new SemVer$4(m[2], this.options.loose);
+ }
+ }
+
+ toString () {
+ return this.value
+ }
+
+ test (version) {
+ debug$c('Comparator.test', version, this.options.loose);
+
+ if (this.semver === ANY$2 || version === ANY$2) {
+ return true
+ }
+
+ if (typeof version === 'string') {
+ try {
+ version = new SemVer$4(version, this.options);
+ } catch (er) {
+ return false
+ }
+ }
+
+ return cmp(version, this.operator, this.semver, this.options)
+ }
+
+ intersects (comp, options) {
+ if (!(comp instanceof Comparator$1)) {
+ throw new TypeError('a Comparator is required')
+ }
+
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ };
+ }
+
+ if (this.operator === '') {
+ if (this.value === '') {
+ return true
+ }
+ return new Range$9(comp.value, options).test(this.value)
+ } else if (comp.operator === '') {
+ if (comp.value === '') {
+ return true
+ }
+ return new Range$9(this.value, options).test(comp.semver)
+ }
+
+ const sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>');
+ const sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<');
+ const sameSemVer = this.semver.version === comp.semver.version;
+ const differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=');
+ const oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, options) &&
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<');
+ const oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, options) &&
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>');
+
+ return (
+ sameDirectionIncreasing ||
+ sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan ||
+ oppositeDirectionsGreaterThan
+ )
+ }
+}
+
+var comparator$1 = Comparator$1;
+
+const parseOptions = parseOptions_1;
+const {re: re$1, t} = re$6.exports;
+const cmp = cmp_1;
+const debug$c = debug_1;
+const SemVer$4 = semver$2;
+const Range$9 = range$1;
+
+const Range$8 = range$1;
+const satisfies$3 = (version, range, options) => {
+ try {
+ range = new Range$8(range, options);
+ } catch (er) {
+ return false
+ }
+ return range.test(version)
+};
+var satisfies_1 = satisfies$3;
+
+const Range$7 = range$1;
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+ new Range$7(range, options).set
+ .map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
+
+var toComparators_1 = toComparators;
+
+const SemVer$3 = semver$2;
+const Range$6 = range$1;
+
+const maxSatisfying = (versions, range, options) => {
+ let max = null;
+ let maxSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range$6(range, options);
+ } catch (er) {
+ return null
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!max || maxSV.compare(v) === -1) {
+ // compare(max, v, true)
+ max = v;
+ maxSV = new SemVer$3(max, options);
+ }
+ }
+ });
+ return max
+};
+var maxSatisfying_1 = maxSatisfying;
- return resolveFileName();
+const SemVer$2 = semver$2;
+const Range$5 = range$1;
+const minSatisfying = (versions, range, options) => {
+ let min = null;
+ let minSV = null;
+ let rangeObj = null;
+ try {
+ rangeObj = new Range$5(range, options);
+ } catch (er) {
+ return null
+ }
+ versions.forEach((v) => {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!min || minSV.compare(v) === 1) {
+ // compare(min, v, true)
+ min = v;
+ minSV = new SemVer$2(min, options);
+ }
+ }
+ });
+ return min
};
+var minSatisfying_1 = minSatisfying;
+
+const SemVer$1 = semver$2;
+const Range$4 = range$1;
+const gt$1 = gt_1;
+
+const minVersion = (range, loose) => {
+ range = new Range$4(range, loose);
+
+ let minver = new SemVer$1('0.0.0');
+ if (range.test(minver)) {
+ return minver
+ }
+
+ minver = new SemVer$1('0.0.0-0');
+ if (range.test(minver)) {
+ return minver
+ }
+
+ minver = null;
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+
+ let setMin = null;
+ comparators.forEach((comparator) => {
+ // Clone to avoid manipulating the comparator's semver object.
+ const compver = new SemVer$1(comparator.semver.version);
+ switch (comparator.operator) {
+ case '>':
+ if (compver.prerelease.length === 0) {
+ compver.patch++;
+ } else {
+ compver.prerelease.push(0);
+ }
+ compver.raw = compver.format();
+ /* fallthrough */
+ case '':
+ case '>=':
+ if (!setMin || gt$1(compver, setMin)) {
+ setMin = compver;
+ }
+ break
+ case '<':
+ case '<=':
+ /* Ignore maximum versions */
+ break
+ /* istanbul ignore next */
+ default:
+ throw new Error(`Unexpected operation: ${comparator.operator}`)
+ }
+ });
+ if (setMin && (!minver || gt$1(minver, setMin)))
+ minver = setMin;
+ }
+
+ if (minver && range.test(minver)) {
+ return minver
+ }
+
+ return null
+};
+var minVersion_1 = minVersion;
+
+const Range$3 = range$1;
+const validRange = (range, options) => {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range$3(range, options).range || '*'
+ } catch (er) {
+ return null
+ }
+};
+var valid = validRange;
+
+const SemVer = semver$2;
+const Comparator = comparator$1;
+const {ANY: ANY$1} = Comparator;
+const Range$2 = range$1;
+const satisfies$2 = satisfies_1;
+const gt = gt_1;
+const lt = lt_1;
+const lte$1 = lte_1;
+const gte$1 = gte_1;
+
+const outside$2 = (version, range, hilo, options) => {
+ version = new SemVer(version, options);
+ range = new Range$2(range, options);
+
+ let gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case '>':
+ gtfn = gt;
+ ltefn = lte$1;
+ ltfn = lt;
+ comp = '>';
+ ecomp = '>=';
+ break
+ case '<':
+ gtfn = lt;
+ ltefn = gte$1;
+ ltfn = gt;
+ comp = '<';
+ ecomp = '<=';
+ break
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"')
+ }
+
+ // If it satisfies the range it is not outside
+ if (satisfies$2(version, range, options)) {
+ return false
+ }
+
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
+
+ for (let i = 0; i < range.set.length; ++i) {
+ const comparators = range.set[i];
+
+ let high = null;
+ let low = null;
+
+ comparators.forEach((comparator) => {
+ if (comparator.semver === ANY$1) {
+ comparator = new Comparator('>=0.0.0');
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, options)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, options)) {
+ low = comparator;
+ }
+ });
+
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false
+ }
+ }
+ return true
+};
+
+var outside_1 = outside$2;
+
+// Determine if version is greater than all the versions possible in the range.
+const outside$1 = outside_1;
+const gtr = (version, range, options) => outside$1(version, range, '>', options);
+var gtr_1 = gtr;
+
+const outside = outside_1;
+// Determine if version is less than all the versions possible in the range
+const ltr = (version, range, options) => outside(version, range, '<', options);
+var ltr_1 = ltr;
+
+const Range$1 = range$1;
+const intersects = (r1, r2, options) => {
+ r1 = new Range$1(r1, options);
+ r2 = new Range$1(r2, options);
+ return r1.intersects(r2)
+};
+var intersects_1 = intersects;
+
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies$1 = satisfies_1;
+const compare$2 = compare_1;
+var simplify = (versions, range, options) => {
+ const set = [];
+ let min = null;
+ let prev = null;
+ const v = versions.sort((a, b) => compare$2(a, b, options));
+ for (const version of v) {
+ const included = satisfies$1(version, range, options);
+ if (included) {
+ prev = version;
+ if (!min)
+ min = version;
+ } else {
+ if (prev) {
+ set.push([min, prev]);
+ }
+ prev = null;
+ min = null;
+ }
+ }
+ if (min)
+ set.push([min, null]);
+
+ const ranges = [];
+ for (const [min, max] of set) {
+ if (min === max)
+ ranges.push(min);
+ else if (!max && min === v[0])
+ ranges.push('*');
+ else if (!max)
+ ranges.push(`>=${min}`);
+ else if (min === v[0])
+ ranges.push(`<=${max}`);
+ else
+ ranges.push(`${min} - ${max}`);
+ }
+ const simplified = ranges.join(' || ');
+ const original = typeof range.raw === 'string' ? range.raw : String(range);
+ return simplified.length < original.length ? simplified : range
+};
+
+const Range = range$1;
+const { ANY } = comparator$1;
+const satisfies = satisfies_1;
+const compare$1 = compare_1;
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a subset of some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+// - If C is only the ANY comparator, return true
+// - Else return false
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If EQ
+// - If GT, and EQ does not satisfy GT, return true (null set)
+// - If LT, and EQ does not satisfy LT, return true (null set)
+// - If EQ satisfies every C, return true
+// - Else return false
+// - If GT
+// - If GT.semver is lower than any > or >= comp in C, return false
+// - If GT is >=, and GT.semver does not satisfy every C, return false
+// - If LT
+// - If LT.semver is greater than any < or <= comp in C, return false
+// - If LT is <=, and LT.semver does not satisfy every C, return false
+// - If any C is a = range, and GT or LT are set, return false
+// - Else return true
+
+const subset = (sub, dom, options) => {
+ if (sub === dom)
+ return true
+
+ sub = new Range(sub, options);
+ dom = new Range(dom, options);
+ let sawNonNull = false;
+
+ OUTER: for (const simpleSub of sub.set) {
+ for (const simpleDom of dom.set) {
+ const isSub = simpleSubset(simpleSub, simpleDom, options);
+ sawNonNull = sawNonNull || isSub !== null;
+ if (isSub)
+ continue OUTER
+ }
+ // the null set is a subset of everything, but null simple ranges in
+ // a complex range should be ignored. so if we saw a non-null range,
+ // then we know this isn't a subset, but if EVERY simple range was null,
+ // then it is a subset.
+ if (sawNonNull)
+ return false
+ }
+ return true
+};
+
+const simpleSubset = (sub, dom, options) => {
+ if (sub === dom)
+ return true
+
+ if (sub.length === 1 && sub[0].semver === ANY)
+ return dom.length === 1 && dom[0].semver === ANY
+
+ const eqSet = new Set();
+ let gt, lt;
+ for (const c of sub) {
+ if (c.operator === '>' || c.operator === '>=')
+ gt = higherGT(gt, c, options);
+ else if (c.operator === '<' || c.operator === '<=')
+ lt = lowerLT(lt, c, options);
+ else
+ eqSet.add(c.semver);
+ }
+
+ if (eqSet.size > 1)
+ return null
+
+ let gtltComp;
+ if (gt && lt) {
+ gtltComp = compare$1(gt.semver, lt.semver, options);
+ if (gtltComp > 0)
+ return null
+ else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<='))
+ return null
+ }
+
+ // will iterate one or zero times
+ for (const eq of eqSet) {
+ if (gt && !satisfies(eq, String(gt), options))
+ return null
+
+ if (lt && !satisfies(eq, String(lt), options))
+ return null
+
+ for (const c of dom) {
+ if (!satisfies(eq, String(c), options))
+ return false
+ }
+
+ return true
+ }
+
+ let higher, lower;
+ let hasDomLT, hasDomGT;
+ for (const c of dom) {
+ hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
+ hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
+ if (gt) {
+ if (c.operator === '>' || c.operator === '>=') {
+ higher = higherGT(gt, c, options);
+ if (higher === c && higher !== gt)
+ return false
+ } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options))
+ return false
+ }
+ if (lt) {
+ if (c.operator === '<' || c.operator === '<=') {
+ lower = lowerLT(lt, c, options);
+ if (lower === c && lower !== lt)
+ return false
+ } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options))
+ return false
+ }
+ if (!c.operator && (lt || gt) && gtltComp !== 0)
+ return false
+ }
+
+ // if there was a < or >, and nothing in the dom, then must be false
+ // UNLESS it was limited by another range in the other direction.
+ // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+ if (gt && hasDomLT && !lt && gtltComp !== 0)
+ return false
+
+ if (lt && hasDomGT && !gt && gtltComp !== 0)
+ return false
+
+ return true
+};
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+ if (!a)
+ return b
+ const comp = compare$1(a.semver, b.semver, options);
+ return comp > 0 ? a
+ : comp < 0 ? b
+ : b.operator === '>' && a.operator === '>=' ? b
+ : a
+};
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+ if (!a)
+ return b
+ const comp = compare$1(a.semver, b.semver, options);
+ return comp < 0 ? a
+ : comp > 0 ? b
+ : b.operator === '<' && a.operator === '<=' ? b
+ : a
+};
+
+var subset_1 = subset;
+
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = re$6.exports;
+var semver$1 = {
+ re: internalRe.re,
+ src: internalRe.src,
+ tokens: internalRe.t,
+ SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+ SemVer: semver$2,
+ compareIdentifiers: identifiers.compareIdentifiers,
+ rcompareIdentifiers: identifiers.rcompareIdentifiers,
+ parse: parse_1,
+ valid: valid_1,
+ clean: clean_1,
+ inc: inc_1,
+ diff: diff_1,
+ major: major_1,
+ minor: minor_1,
+ patch: patch_1,
+ prerelease: prerelease_1,
+ compare: compare_1,
+ rcompare: rcompare_1,
+ compareLoose: compareLoose_1,
+ compareBuild: compareBuild_1,
+ sort: sort_1,
+ rsort: rsort_1,
+ gt: gt_1,
+ lt: lt_1,
+ eq: eq_1,
+ neq: neq_1,
+ gte: gte_1,
+ lte: lte_1,
+ cmp: cmp_1,
+ coerce: coerce_1,
+ Comparator: comparator$1,
+ Range: range$1,
+ satisfies: satisfies_1,
+ toComparators: toComparators_1,
+ maxSatisfying: maxSatisfying_1,
+ minSatisfying: minSatisfying_1,
+ minVersion: minVersion_1,
+ validRange: valid,
+ outside: outside_1,
+ gtr: gtr_1,
+ ltr: ltr_1,
+ intersects: intersects_1,
+ simplifyRange: simplify,
+ subset: subset_1,
+};
+
+var semver = semver$1;
+
+var builtins = function ({
+ version = process.version,
+ experimental = false
+} = {}) {
+ var coreModules = [
+ 'assert',
+ 'buffer',
+ 'child_process',
+ 'cluster',
+ 'console',
+ 'constants',
+ 'crypto',
+ 'dgram',
+ 'dns',
+ 'domain',
+ 'events',
+ 'fs',
+ 'http',
+ 'https',
+ 'module',
+ 'net',
+ 'os',
+ 'path',
+ 'punycode',
+ 'querystring',
+ 'readline',
+ 'repl',
+ 'stream',
+ 'string_decoder',
+ 'sys',
+ 'timers',
+ 'tls',
+ 'tty',
+ 'url',
+ 'util',
+ 'vm',
+ 'zlib'
+ ];
+
+ if (semver.lt(version, '6.0.0')) coreModules.push('freelist');
+ if (semver.gte(version, '1.0.0')) coreModules.push('v8');
+ if (semver.gte(version, '1.1.0')) coreModules.push('process');
+ if (semver.gte(version, '8.0.0')) coreModules.push('inspector');
+ if (semver.gte(version, '8.1.0')) coreModules.push('async_hooks');
+ if (semver.gte(version, '8.4.0')) coreModules.push('http2');
+ if (semver.gte(version, '8.5.0')) coreModules.push('perf_hooks');
+ if (semver.gte(version, '10.0.0')) coreModules.push('trace_events');
+
+ if (
+ semver.gte(version, '10.5.0') &&
+ (experimental || semver.gte(version, '12.0.0'))
+ ) {
+ coreModules.push('worker_threads');
+ }
+ if (semver.gte(version, '12.16.0') && experimental) {
+ coreModules.push('wasi');
+ }
+
+ return coreModules
+};
+
+// Manually “tree shaken” from:
+
+const reader = {read: read$3};
+var packageJsonReader = reader;
+
+/**
+ * @param {string} jsonPath
+ * @returns {{string: string}}
+ */
+function read$3(jsonPath) {
+ return find$1(path$b.dirname(jsonPath))
+}
+
+/**
+ * @param {string} dir
+ * @returns {{string: string}}
+ */
+function find$1(dir) {
+ try {
+ const string = require$$0$3.readFileSync(
+ path$b.toNamespacedPath(path$b.join(dir, 'package.json')),
+ 'utf8'
+ );
+ return {string}
+ } catch (error) {
+ if (error.code === 'ENOENT') {
+ const parent = path$b.dirname(dir);
+ if (dir !== parent) return find$1(parent)
+ return {string: undefined}
+ // Throw all other errors.
+ /* c8 ignore next 4 */
+ }
+
+ throw error
+ }
+}
+
+// Manually “tree shaken” from:
+
+const isWindows$1 = process.platform === 'win32';
+
+const own$e = {}.hasOwnProperty;
+
+const codes = {};
+
+/**
+ * @typedef {(...args: unknown[]) => string} MessageFunction
+ */
+
+/** @type {Map<string, MessageFunction|string>} */
+const messages = new Map();
+const nodeInternalPrefix = '__node_internal_';
+/** @type {number} */
+let userStackTraceLimit;
+
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+ 'ERR_INVALID_MODULE_SPECIFIER',
+ /**
+ * @param {string} request
+ * @param {string} reason
+ * @param {string} [base]
+ */
+ (request, reason, base = undefined) => {
+ return `Invalid module "${request}" ${reason}${
+ base ? ` imported from ${base}` : ''
+ }`
+ },
+ TypeError
+);
+
+codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+ 'ERR_INVALID_PACKAGE_CONFIG',
+ /**
+ * @param {string} path
+ * @param {string} [base]
+ * @param {string} [message]
+ */
+ (path, base, message) => {
+ return `Invalid package config ${path}${
+ base ? ` while importing ${base}` : ''
+ }${message ? `. ${message}` : ''}`
+ },
+ Error
+);
+
+codes.ERR_INVALID_PACKAGE_TARGET = createError(
+ 'ERR_INVALID_PACKAGE_TARGET',
+ /**
+ * @param {string} pkgPath
+ * @param {string} key
+ * @param {unknown} target
+ * @param {boolean} [isImport=false]
+ * @param {string} [base]
+ */
+ (pkgPath, key, target, isImport = false, base = undefined) => {
+ const relError =
+ typeof target === 'string' &&
+ !isImport &&
+ target.length > 0 &&
+ !target.startsWith('./');
+ if (key === '.') {
+ assert$2(isImport === false);
+ return (
+ `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
+ `in the package config ${pkgPath}package.json${
+ base ? ` imported from ${base}` : ''
+ }${relError ? '; targets must start with "./"' : ''}`
+ )
+ }
+
+ return `Invalid "${
+ isImport ? 'imports' : 'exports'
+ }" target ${JSON.stringify(
+ target
+ )} defined for '${key}' in the package config ${pkgPath}package.json${
+ base ? ` imported from ${base}` : ''
+ }${relError ? '; targets must start with "./"' : ''}`
+ },
+ Error
+);
+
+codes.ERR_MODULE_NOT_FOUND = createError(
+ 'ERR_MODULE_NOT_FOUND',
+ /**
+ * @param {string} path
+ * @param {string} base
+ * @param {string} [type]
+ */
+ (path, base, type = 'package') => {
+ return `Cannot find ${type} '${path}' imported from ${base}`
+ },
+ Error
+);
+
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+ 'ERR_PACKAGE_IMPORT_NOT_DEFINED',
+ /**
+ * @param {string} specifier
+ * @param {string} packagePath
+ * @param {string} base
+ */
+ (specifier, packagePath, base) => {
+ return `Package import specifier "${specifier}" is not defined${
+ packagePath ? ` in package ${packagePath}package.json` : ''
+ } imported from ${base}`
+ },
+ TypeError
+);
+
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+ 'ERR_PACKAGE_PATH_NOT_EXPORTED',
+ /**
+ * @param {string} pkgPath
+ * @param {string} subpath
+ * @param {string} [base]
+ */
+ (pkgPath, subpath, base = undefined) => {
+ if (subpath === '.')
+ return `No "exports" main defined in ${pkgPath}package.json${
+ base ? ` imported from ${base}` : ''
+ }`
+ return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${
+ base ? ` imported from ${base}` : ''
+ }`
+ },
+ Error
+);
+
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
+ 'ERR_UNSUPPORTED_DIR_IMPORT',
+ "Directory import '%s' is not supported " +
+ 'resolving ES modules imported from %s',
+ Error
+);
+
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+ 'ERR_UNKNOWN_FILE_EXTENSION',
+ 'Unknown file extension "%s" for %s',
+ TypeError
+);
+
+codes.ERR_INVALID_ARG_VALUE = createError(
+ 'ERR_INVALID_ARG_VALUE',
+ /**
+ * @param {string} name
+ * @param {unknown} value
+ * @param {string} [reason='is invalid']
+ */
+ (name, value, reason = 'is invalid') => {
+ let inspected = inspect$1(value);
+
+ if (inspected.length > 128) {
+ inspected = `${inspected.slice(0, 128)}...`;
+ }
+
+ const type = name.includes('.') ? 'property' : 'argument';
+
+ return `The ${type} '${name}' ${reason}. Received ${inspected}`
+ },
+ TypeError
+ // Note: extra classes have been shaken out.
+ // , RangeError
+);
+
+codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError(
+ 'ERR_UNSUPPORTED_ESM_URL_SCHEME',
+ /**
+ * @param {URL} url
+ */
+ (url) => {
+ let message =
+ 'Only file and data URLs are supported by the default ESM loader';
+
+ if (isWindows$1 && url.protocol.length === 2) {
+ message += '. On Windows, absolute paths must be valid file:// URLs';
+ }
+
+ message += `. Received protocol '${url.protocol}'`;
+ return message
+ },
+ Error
+);
+
+/**
+ * Utility function for registering the error codes. Only used here. Exported
+ * *only* to allow for testing.
+ * @param {string} sym
+ * @param {MessageFunction|string} value
+ * @param {ErrorConstructor} def
+ * @returns {new (...args: unknown[]) => Error}
+ */
+function createError(sym, value, def) {
+ // Special case for SystemError that formats the error message differently
+ // The SystemErrors only have SystemError as their base classes.
+ messages.set(sym, value);
+
+ return makeNodeErrorWithCode(def, sym)
+}
+
+/**
+ * @param {ErrorConstructor} Base
+ * @param {string} key
+ * @returns {ErrorConstructor}
+ */
+function makeNodeErrorWithCode(Base, key) {
+ // @ts-expect-error It’s a Node error.
+ return NodeError
+ /**
+ * @param {unknown[]} args
+ */
+ function NodeError(...args) {
+ const limit = Error.stackTraceLimit;
+ if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+ const error = new Base();
+ // Reset the limit and setting the name property.
+ if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+ const message = getMessage(key, args, error);
+ Object.defineProperty(error, 'message', {
+ value: message,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ });
+ Object.defineProperty(error, 'toString', {
+ /** @this {Error} */
+ value() {
+ return `${this.name} [${key}]: ${this.message}`
+ },
+ enumerable: false,
+ writable: true,
+ configurable: true
+ });
+ addCodeToName(error, Base.name, key);
+ // @ts-expect-error It’s a Node error.
+ error.code = key;
+ return error
+ }
+}
+
+const addCodeToName = hideStackFrames(
+ /**
+ * @param {Error} error
+ * @param {string} name
+ * @param {string} code
+ * @returns {void}
+ */
+ function (error, name, code) {
+ // Set the stack
+ error = captureLargerStackTrace(error);
+ // Add the error code to the name to include it in the stack trace.
+ error.name = `${name} [${code}]`;
+ // Access the stack to generate the error message including the error code
+ // from the name.
+ error.stack; // eslint-disable-line no-unused-expressions
+ // Reset the name to the actual name.
+ if (name === 'SystemError') {
+ Object.defineProperty(error, 'name', {
+ value: name,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ });
+ } else {
+ delete error.name;
+ }
+ }
+);
+
+/**
+ * @returns {boolean}
+ */
+function isErrorStackTraceLimitWritable() {
+ const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
+ if (desc === undefined) {
+ return Object.isExtensible(Error)
+ }
+
+ return own$e.call(desc, 'writable') ? desc.writable : desc.set !== undefined
+}
+
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ * @template {(...args: unknown[]) => unknown} T
+ * @type {(fn: T) => T}
+ */
+function hideStackFrames(fn) {
+ // We rename the functions that will be hidden to cut off the stacktrace
+ // at the outermost one
+ const hidden = nodeInternalPrefix + fn.name;
+ Object.defineProperty(fn, 'name', {value: hidden});
+ return fn
+}
+
+const captureLargerStackTrace = hideStackFrames(
+ /**
+ * @param {Error} error
+ * @returns {Error}
+ */
+ function (error) {
+ const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+ if (stackTraceLimitIsWritable) {
+ userStackTraceLimit = Error.stackTraceLimit;
+ Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+ }
+
+ Error.captureStackTrace(error);
+
+ // Reset the limit
+ if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+
+ return error
+ }
+);
+
+/**
+ * @param {string} key
+ * @param {unknown[]} args
+ * @param {Error} self
+ * @returns {string}
+ */
+function getMessage(key, args, self) {
+ const message = messages.get(key);
+
+ if (typeof message === 'function') {
+ assert$2(
+ message.length <= args.length, // Default options do not count.
+ `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+ `match the required ones (${message.length}).`
+ );
+ return Reflect.apply(message, self, args)
+ }
+
+ const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
+ assert$2(
+ expectedLength === args.length,
+ `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+ `match the required ones (${expectedLength}).`
+ );
+ if (args.length === 0) return message
+
+ args.unshift(message);
+ return Reflect.apply(format$2, null, args)
+}
+
+// Manually “tree shaken” from:
+
+const {ERR_UNKNOWN_FILE_EXTENSION} = codes;
+
+const extensionFormatMap = {
+ __proto__: null,
+ '.cjs': 'commonjs',
+ '.js': 'module',
+ '.mjs': 'module'
+};
+
+/**
+ * @param {string} url
+ * @returns {{format: string|null}}
+ */
+function defaultGetFormat(url) {
+ if (url.startsWith('node:')) {
+ return {format: 'builtin'}
+ }
+
+ const parsed = new URL$1(url);
+
+ if (parsed.protocol === 'data:') {
+ const {1: mime} = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+ parsed.pathname
+ ) || [null, null];
+ const format = mime === 'text/javascript' ? 'module' : null;
+ return {format}
+ }
+
+ if (parsed.protocol === 'file:') {
+ const ext = path$b.extname(parsed.pathname);
+ /** @type {string} */
+ let format;
+ if (ext === '.js') {
+ format = getPackageType(parsed.href) === 'module' ? 'module' : 'commonjs';
+ } else {
+ format = extensionFormatMap[ext];
+ }
+
+ if (!format) {
+ throw new ERR_UNKNOWN_FILE_EXTENSION(ext, fileURLToPath(url))
+ }
+
+ return {format: format || null}
+ }
+
+ return {format: null}
+}
+
+// Manually “tree shaken” from:
+
+const listOfBuiltins = builtins();
+
+const {
+ ERR_INVALID_MODULE_SPECIFIER,
+ ERR_INVALID_PACKAGE_CONFIG,
+ ERR_INVALID_PACKAGE_TARGET,
+ ERR_MODULE_NOT_FOUND,
+ ERR_PACKAGE_IMPORT_NOT_DEFINED,
+ ERR_PACKAGE_PATH_NOT_EXPORTED,
+ ERR_UNSUPPORTED_DIR_IMPORT,
+ ERR_UNSUPPORTED_ESM_URL_SCHEME,
+ ERR_INVALID_ARG_VALUE
+} = codes;
+
+const own$d = {}.hasOwnProperty;
+
+const DEFAULT_CONDITIONS = Object.freeze(['node', 'import']);
+const DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+
+const invalidSegmentRegEx = /(^|\\|\/)(\.\.?|node_modules)(\\|\/|$)/;
+const patternRegEx = /\*/g;
+const encodedSepRegEx = /%2f|%2c/i;
+/** @type {Set<string>} */
+const emittedPackageWarnings = new Set();
+/** @type {Map<string, PackageConfig>} */
+const packageJsonCache = new Map();
+
+/**
+ * @param {string} match
+ * @param {URL} pjsonUrl
+ * @param {boolean} isExports
+ * @param {URL} base
+ * @returns {void}
+ */
+function emitFolderMapDeprecation(match, pjsonUrl, isExports, base) {
+ const pjsonPath = fileURLToPath(pjsonUrl);
+
+ if (emittedPackageWarnings.has(pjsonPath + '|' + match)) return
+ emittedPackageWarnings.add(pjsonPath + '|' + match);
+ process.emitWarning(
+ `Use of deprecated folder mapping "${match}" in the ${
+ isExports ? '"exports"' : '"imports"'
+ } field module resolution of the package at ${pjsonPath}${
+ base ? ` imported from ${fileURLToPath(base)}` : ''
+ }.\n` +
+ `Update this package.json to use a subpath pattern like "${match}*".`,
+ 'DeprecationWarning',
+ 'DEP0148'
+ );
+}
+
+/**
+ * @param {URL} url
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {unknown} [main]
+ * @returns {void}
+ */
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+ const {format} = defaultGetFormat(url.href);
+ if (format !== 'module') return
+ const path = fileURLToPath(url.href);
+ const pkgPath = fileURLToPath(new URL$1('.', packageJsonUrl));
+ const basePath = fileURLToPath(base);
+ if (main)
+ process.emitWarning(
+ `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, ` +
+ `excluding the full filename and extension to the resolved file at "${path.slice(
+ pkgPath.length
+ )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is` +
+ 'deprecated for ES modules.',
+ 'DeprecationWarning',
+ 'DEP0151'
+ );
+ else
+ process.emitWarning(
+ `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path.slice(
+ pkgPath.length
+ )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
+ 'DeprecationWarning',
+ 'DEP0151'
+ );
+}
+
+/**
+ * @param {string[]} [conditions]
+ * @returns {Set<string>}
+ */
+function getConditionsSet(conditions) {
+ if (conditions !== undefined && conditions !== DEFAULT_CONDITIONS) {
+ if (!Array.isArray(conditions)) {
+ throw new ERR_INVALID_ARG_VALUE(
+ 'conditions',
+ conditions,
+ 'expected an array'
+ )
+ }
+
+ return new Set(conditions)
+ }
+
+ return DEFAULT_CONDITIONS_SET
+}
+
+/**
+ * @param {string} path
+ * @returns {Stats}
+ */
+function tryStatSync(path) {
+ // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
+ try {
+ return statSync(path)
+ } catch {
+ return new Stats()
+ }
+}
+
+/**
+ * @param {string} path
+ * @param {string|URL} specifier Note: `specifier` is actually optional, not base.
+ * @param {URL} [base]
+ * @returns {PackageConfig}
+ */
+function getPackageConfig(path, specifier, base) {
+ const existing = packageJsonCache.get(path);
+ if (existing !== undefined) {
+ return existing
+ }
+
+ const source = packageJsonReader.read(path).string;
+
+ if (source === undefined) {
+ /** @type {PackageConfig} */
+ const packageConfig = {
+ pjsonPath: path,
+ exists: false,
+ main: undefined,
+ name: undefined,
+ type: 'none',
+ exports: undefined,
+ imports: undefined
+ };
+ packageJsonCache.set(path, packageConfig);
+ return packageConfig
+ }
+
+ /** @type {Object.<string, unknown>} */
+ let packageJson;
+ try {
+ packageJson = JSON.parse(source);
+ } catch (error) {
+ throw new ERR_INVALID_PACKAGE_CONFIG(
+ path,
+ (base ? `"${specifier}" from ` : '') + fileURLToPath(base || specifier),
+ error.message
+ )
+ }
+
+ const {exports, imports, main, name, type} = packageJson;
+
+ /** @type {PackageConfig} */
+ const packageConfig = {
+ pjsonPath: path,
+ exists: true,
+ main: typeof main === 'string' ? main : undefined,
+ name: typeof name === 'string' ? name : undefined,
+ type: type === 'module' || type === 'commonjs' ? type : 'none',
+ // @ts-expect-error Assume `Object.<string, unknown>`.
+ exports,
+ // @ts-expect-error Assume `Object.<string, unknown>`.
+ imports: imports && typeof imports === 'object' ? imports : undefined
+ };
+ packageJsonCache.set(path, packageConfig);
+ return packageConfig
+}
+
+/**
+ * @param {URL|string} resolved
+ * @returns {PackageConfig}
+ */
+function getPackageScopeConfig(resolved) {
+ let packageJsonUrl = new URL$1('./package.json', resolved);
+
+ while (true) {
+ const packageJsonPath = packageJsonUrl.pathname;
+
+ if (packageJsonPath.endsWith('node_modules/package.json')) break
+
+ const packageConfig = getPackageConfig(
+ fileURLToPath(packageJsonUrl),
+ resolved
+ );
+ if (packageConfig.exists) return packageConfig
+
+ const lastPackageJsonUrl = packageJsonUrl;
+ packageJsonUrl = new URL$1('../package.json', packageJsonUrl);
+
+ // Terminates at root where ../package.json equals ../../package.json
+ // (can't just check "/package.json" for Windows support).
+ if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname) break
+ }
+
+ const packageJsonPath = fileURLToPath(packageJsonUrl);
+ /** @type {PackageConfig} */
+ const packageConfig = {
+ pjsonPath: packageJsonPath,
+ exists: false,
+ main: undefined,
+ name: undefined,
+ type: 'none',
+ exports: undefined,
+ imports: undefined
+ };
+ packageJsonCache.set(packageJsonPath, packageConfig);
+ return packageConfig
+}
+
+/**
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ *
+ * @param {URL} url
+ * @returns {boolean}
+ */
+function fileExists(url) {
+ return tryStatSync(fileURLToPath(url)).isFile()
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {PackageConfig} packageConfig
+ * @param {URL} base
+ * @returns {URL}
+ */
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+ /** @type {URL} */
+ let guess;
+ if (packageConfig.main !== undefined) {
+ guess = new URL$1(`./${packageConfig.main}`, packageJsonUrl);
+ // Note: fs check redundances will be handled by Descriptor cache here.
+ if (fileExists(guess)) return guess
+
+ const tries = [
+ `./${packageConfig.main}.js`,
+ `./${packageConfig.main}.json`,
+ `./${packageConfig.main}.node`,
+ `./${packageConfig.main}/index.js`,
+ `./${packageConfig.main}/index.json`,
+ `./${packageConfig.main}/index.node`
+ ];
+ let i = -1;
+
+ while (++i < tries.length) {
+ guess = new URL$1(tries[i], packageJsonUrl);
+ if (fileExists(guess)) break
+ guess = undefined;
+ }
+
+ if (guess) {
+ emitLegacyIndexDeprecation(
+ guess,
+ packageJsonUrl,
+ base,
+ packageConfig.main
+ );
+ return guess
+ }
+ // Fallthrough.
+ }
+
+ const tries = ['./index.js', './index.json', './index.node'];
+ let i = -1;
+
+ while (++i < tries.length) {
+ guess = new URL$1(tries[i], packageJsonUrl);
+ if (fileExists(guess)) break
+ guess = undefined;
+ }
+
+ if (guess) {
+ emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+ return guess
+ }
+
+ // Not found.
+ throw new ERR_MODULE_NOT_FOUND(
+ fileURLToPath(new URL$1('.', packageJsonUrl)),
+ fileURLToPath(base)
+ )
+}
+
+/**
+ * @param {URL} resolved
+ * @param {URL} base
+ * @returns {URL}
+ */
+function finalizeResolution(resolved, base) {
+ if (encodedSepRegEx.test(resolved.pathname))
+ throw new ERR_INVALID_MODULE_SPECIFIER(
+ resolved.pathname,
+ 'must not include encoded "/" or "\\" characters',
+ fileURLToPath(base)
+ )
+
+ const path = fileURLToPath(resolved);
+
+ const stats = tryStatSync(path.endsWith('/') ? path.slice(-1) : path);
+
+ if (stats.isDirectory()) {
+ const error = new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath(base));
+ // @ts-expect-error Add this for `import.meta.resolve`.
+ error.url = String(resolved);
+ throw error
+ }
+
+ if (!stats.isFile()) {
+ throw new ERR_MODULE_NOT_FOUND(
+ path || resolved.pathname,
+ base && fileURLToPath(base),
+ 'module'
+ )
+ }
+
+ return resolved
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL?} packageJsonUrl
+ * @param {URL} base
+ * @returns {never}
+ */
+function throwImportNotDefined(specifier, packageJsonUrl, base) {
+ throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+ specifier,
+ packageJsonUrl && fileURLToPath(new URL$1('.', packageJsonUrl)),
+ fileURLToPath(base)
+ )
+}
+
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {never}
+ */
+function throwExportsNotFound(subpath, packageJsonUrl, base) {
+ throw new ERR_PACKAGE_PATH_NOT_EXPORTED(
+ fileURLToPath(new URL$1('.', packageJsonUrl)),
+ subpath,
+ base && fileURLToPath(base)
+ )
+}
+
+/**
+ * @param {string} subpath
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidSubpath(subpath, packageJsonUrl, internal, base) {
+ const reason = `request is not a valid subpath for the "${
+ internal ? 'imports' : 'exports'
+ }" resolution of ${fileURLToPath(packageJsonUrl)}`;
+
+ throw new ERR_INVALID_MODULE_SPECIFIER(
+ subpath,
+ reason,
+ base && fileURLToPath(base)
+ )
+}
+
+/**
+ * @param {string} subpath
+ * @param {unknown} target
+ * @param {URL} packageJsonUrl
+ * @param {boolean} internal
+ * @param {URL} [base]
+ * @returns {never}
+ */
+function throwInvalidPackageTarget(
+ subpath,
+ target,
+ packageJsonUrl,
+ internal,
+ base
+) {
+ target =
+ typeof target === 'object' && target !== null
+ ? JSON.stringify(target, null, '')
+ : `${target}`;
+
+ throw new ERR_INVALID_PACKAGE_TARGET(
+ fileURLToPath(new URL$1('.', packageJsonUrl)),
+ subpath,
+ target,
+ internal,
+ base && fileURLToPath(base)
+ )
+}
+
+/**
+ * @param {string} target
+ * @param {string} subpath
+ * @param {string} match
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function resolvePackageTargetString(
+ target,
+ subpath,
+ match,
+ packageJsonUrl,
+ base,
+ pattern,
+ internal,
+ conditions
+) {
+ if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
+ throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
+
+ if (!target.startsWith('./')) {
+ if (internal && !target.startsWith('../') && !target.startsWith('/')) {
+ let isURL = false;
+
+ try {
+ new URL$1(target);
+ isURL = true;
+ } catch {}
+
+ if (!isURL) {
+ const exportTarget = pattern
+ ? target.replace(patternRegEx, subpath)
+ : target + subpath;
+
+ return packageResolve(exportTarget, packageJsonUrl, conditions)
+ }
+ }
+
+ throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
+ }
+
+ if (invalidSegmentRegEx.test(target.slice(2)))
+ throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
+
+ const resolved = new URL$1(target, packageJsonUrl);
+ const resolvedPath = resolved.pathname;
+ const packagePath = new URL$1('.', packageJsonUrl).pathname;
+
+ if (!resolvedPath.startsWith(packagePath))
+ throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base);
+
+ if (subpath === '') return resolved
+
+ if (invalidSegmentRegEx.test(subpath))
+ throwInvalidSubpath(match + subpath, packageJsonUrl, internal, base);
+
+ if (pattern) return new URL$1(resolved.href.replace(patternRegEx, subpath))
+ return new URL$1(subpath, resolved)
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isArrayIndex(key) {
+ const keyNumber = Number(key);
+ if (`${keyNumber}` !== key) return false
+ return keyNumber >= 0 && keyNumber < 0xffff_ffff
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {unknown} target
+ * @param {string} subpath
+ * @param {string} packageSubpath
+ * @param {URL} base
+ * @param {boolean} pattern
+ * @param {boolean} internal
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function resolvePackageTarget(
+ packageJsonUrl,
+ target,
+ subpath,
+ packageSubpath,
+ base,
+ pattern,
+ internal,
+ conditions
+) {
+ if (typeof target === 'string') {
+ return resolvePackageTargetString(
+ target,
+ subpath,
+ packageSubpath,
+ packageJsonUrl,
+ base,
+ pattern,
+ internal,
+ conditions
+ )
+ }
+
+ if (Array.isArray(target)) {
+ /** @type {unknown[]} */
+ const targetList = target;
+ if (targetList.length === 0) return null
+
+ /** @type {Error} */
+ let lastException;
+ let i = -1;
+
+ while (++i < targetList.length) {
+ const targetItem = targetList[i];
+ /** @type {URL} */
+ let resolved;
+ try {
+ resolved = resolvePackageTarget(
+ packageJsonUrl,
+ targetItem,
+ subpath,
+ packageSubpath,
+ base,
+ pattern,
+ internal,
+ conditions
+ );
+ } catch (error) {
+ lastException = error;
+ if (error.code === 'ERR_INVALID_PACKAGE_TARGET') continue
+ throw error
+ }
+
+ if (resolved === undefined) continue
+
+ if (resolved === null) {
+ lastException = null;
+ continue
+ }
+
+ return resolved
+ }
+
+ if (lastException === undefined || lastException === null) {
+ // @ts-expect-error The diff between `undefined` and `null` seems to be
+ // intentional
+ return lastException
+ }
+
+ throw lastException
+ }
+
+ if (typeof target === 'object' && target !== null) {
+ const keys = Object.getOwnPropertyNames(target);
+ let i = -1;
+
+ while (++i < keys.length) {
+ const key = keys[i];
+ if (isArrayIndex(key)) {
+ throw new ERR_INVALID_PACKAGE_CONFIG(
+ fileURLToPath(packageJsonUrl),
+ base,
+ '"exports" cannot contain numeric property keys.'
+ )
+ }
+ }
+
+ i = -1;
+
+ while (++i < keys.length) {
+ const key = keys[i];
+ if (key === 'default' || (conditions && conditions.has(key))) {
+ /** @type {unknown} */
+ const conditionalTarget = target[key];
+ const resolved = resolvePackageTarget(
+ packageJsonUrl,
+ conditionalTarget,
+ subpath,
+ packageSubpath,
+ base,
+ pattern,
+ internal,
+ conditions
+ );
+ if (resolved === undefined) continue
+ return resolved
+ }
+ }
+
+ return undefined
+ }
+
+ if (target === null) {
+ return null
+ }
+
+ throwInvalidPackageTarget(
+ packageSubpath,
+ target,
+ packageJsonUrl,
+ internal,
+ base
+ );
+}
+
+/**
+ * @param {unknown} exports
+ * @param {URL} packageJsonUrl
+ * @param {URL} base
+ * @returns {boolean}
+ */
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+ if (typeof exports === 'string' || Array.isArray(exports)) return true
+ if (typeof exports !== 'object' || exports === null) return false
+
+ const keys = Object.getOwnPropertyNames(exports);
+ let isConditionalSugar = false;
+ let i = 0;
+ let j = -1;
+ while (++j < keys.length) {
+ const key = keys[j];
+ const curIsConditionalSugar = key === '' || key[0] !== '.';
+ if (i++ === 0) {
+ isConditionalSugar = curIsConditionalSugar;
+ } else if (isConditionalSugar !== curIsConditionalSugar) {
+ throw new ERR_INVALID_PACKAGE_CONFIG(
+ fileURLToPath(packageJsonUrl),
+ base,
+ '"exports" cannot contain some keys starting with \'.\' and some not.' +
+ ' The exports object must either be an object of package subpath keys' +
+ ' or an object of main entry condition name keys only.'
+ )
+ }
+ }
+
+ return isConditionalSugar
+}
+
+/**
+ * @param {URL} packageJsonUrl
+ * @param {string} packageSubpath
+ * @param {Object.<string, unknown>} packageConfig
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {ResolveObject}
+ */
+function packageExportsResolve(
+ packageJsonUrl,
+ packageSubpath,
+ packageConfig,
+ base,
+ conditions
+) {
+ let exports = packageConfig.exports;
+ if (isConditionalExportsMainSugar(exports, packageJsonUrl, base))
+ exports = {'.': exports};
+
+ if (own$d.call(exports, packageSubpath)) {
+ const target = exports[packageSubpath];
+ const resolved = resolvePackageTarget(
+ packageJsonUrl,
+ target,
+ '',
+ packageSubpath,
+ base,
+ false,
+ false,
+ conditions
+ );
+ if (resolved === null || resolved === undefined)
+ throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+ return {resolved, exact: true}
+ }
+
+ let bestMatch = '';
+ const keys = Object.getOwnPropertyNames(exports);
+ let i = -1;
+
+ while (++i < keys.length) {
+ const key = keys[i];
+ if (
+ key[key.length - 1] === '*' &&
+ packageSubpath.startsWith(key.slice(0, -1)) &&
+ packageSubpath.length >= key.length &&
+ key.length > bestMatch.length
+ ) {
+ bestMatch = key;
+ } else if (
+ key[key.length - 1] === '/' &&
+ packageSubpath.startsWith(key) &&
+ key.length > bestMatch.length
+ ) {
+ bestMatch = key;
+ }
+ }
+
+ if (bestMatch) {
+ const target = exports[bestMatch];
+ const pattern = bestMatch[bestMatch.length - 1] === '*';
+ const subpath = packageSubpath.slice(bestMatch.length - (pattern ? 1 : 0));
+ const resolved = resolvePackageTarget(
+ packageJsonUrl,
+ target,
+ subpath,
+ bestMatch,
+ base,
+ pattern,
+ false,
+ conditions
+ );
+ if (resolved === null || resolved === undefined)
+ throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+ if (!pattern)
+ emitFolderMapDeprecation(bestMatch, packageJsonUrl, true, base);
+ return {resolved, exact: pattern}
+ }
+
+ throwExportsNotFound(packageSubpath, packageJsonUrl, base);
+}
-resolveFrom$1.exports = (fromDirectory, moduleId) => resolveFrom(fromDirectory, moduleId);
-resolveFrom$1.exports.silent = (fromDirectory, moduleId) => resolveFrom(fromDirectory, moduleId, true);
+/**
+ * @param {string} name
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {ResolveObject}
+ */
+function packageImportsResolve(name, base, conditions) {
+ if (name === '#' || name.startsWith('#/')) {
+ const reason = 'is not a valid internal imports specifier name';
+ throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base))
+ }
+
+ /** @type {URL} */
+ let packageJsonUrl;
+
+ const packageConfig = getPackageScopeConfig(base);
+
+ if (packageConfig.exists) {
+ packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+ const imports = packageConfig.imports;
+ if (imports) {
+ if (own$d.call(imports, name)) {
+ const resolved = resolvePackageTarget(
+ packageJsonUrl,
+ imports[name],
+ '',
+ name,
+ base,
+ false,
+ true,
+ conditions
+ );
+ if (resolved !== null) return {resolved, exact: true}
+ } else {
+ let bestMatch = '';
+ const keys = Object.getOwnPropertyNames(imports);
+ let i = -1;
+
+ while (++i < keys.length) {
+ const key = keys[i];
+
+ if (
+ key[key.length - 1] === '*' &&
+ name.startsWith(key.slice(0, -1)) &&
+ name.length >= key.length &&
+ key.length > bestMatch.length
+ ) {
+ bestMatch = key;
+ } else if (
+ key[key.length - 1] === '/' &&
+ name.startsWith(key) &&
+ key.length > bestMatch.length
+ ) {
+ bestMatch = key;
+ }
+ }
+
+ if (bestMatch) {
+ const target = imports[bestMatch];
+ const pattern = bestMatch[bestMatch.length - 1] === '*';
+ const subpath = name.slice(bestMatch.length - (pattern ? 1 : 0));
+ const resolved = resolvePackageTarget(
+ packageJsonUrl,
+ target,
+ subpath,
+ bestMatch,
+ base,
+ pattern,
+ true,
+ conditions
+ );
+ if (resolved !== null) {
+ if (!pattern)
+ emitFolderMapDeprecation(bestMatch, packageJsonUrl, false, base);
+ return {resolved, exact: pattern}
+ }
+ }
+ }
+ }
+ }
+
+ throwImportNotDefined(name, packageJsonUrl, base);
+}
+
+/**
+ * @param {string} url
+ * @returns {PackageType}
+ */
+function getPackageType(url) {
+ const packageConfig = getPackageScopeConfig(url);
+ return packageConfig.type
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ */
+function parsePackageName(specifier, base) {
+ let separatorIndex = specifier.indexOf('/');
+ let validPackageName = true;
+ let isScoped = false;
+ if (specifier[0] === '@') {
+ isScoped = true;
+ if (separatorIndex === -1 || specifier.length === 0) {
+ validPackageName = false;
+ } else {
+ separatorIndex = specifier.indexOf('/', separatorIndex + 1);
+ }
+ }
+
+ const packageName =
+ separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+
+ // Package name cannot have leading . and cannot have percent-encoding or
+ // separators.
+ let i = -1;
+ while (++i < packageName.length) {
+ if (packageName[i] === '%' || packageName[i] === '\\') {
+ validPackageName = false;
+ break
+ }
+ }
+
+ if (!validPackageName) {
+ throw new ERR_INVALID_MODULE_SPECIFIER(
+ specifier,
+ 'is not a valid package name',
+ fileURLToPath(base)
+ )
+ }
+
+ const packageSubpath =
+ '.' + (separatorIndex === -1 ? '' : specifier.slice(separatorIndex));
+
+ return {packageName, packageSubpath, isScoped}
+}
+
+/**
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} conditions
+ * @returns {URL}
+ */
+function packageResolve(specifier, base, conditions) {
+ const {packageName, packageSubpath, isScoped} = parsePackageName(
+ specifier,
+ base
+ );
+
+ // ResolveSelf
+ const packageConfig = getPackageScopeConfig(base);
+
+ // Can’t test.
+ /* c8 ignore next 16 */
+ if (packageConfig.exists) {
+ const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+ if (
+ packageConfig.name === packageName &&
+ packageConfig.exports !== undefined &&
+ packageConfig.exports !== null
+ ) {
+ return packageExportsResolve(
+ packageJsonUrl,
+ packageSubpath,
+ packageConfig,
+ base,
+ conditions
+ ).resolved
+ }
+ }
+
+ let packageJsonUrl = new URL$1(
+ './node_modules/' + packageName + '/package.json',
+ base
+ );
+ let packageJsonPath = fileURLToPath(packageJsonUrl);
+ /** @type {string} */
+ let lastPath;
+ do {
+ const stat = tryStatSync(packageJsonPath.slice(0, -13));
+ if (!stat.isDirectory()) {
+ lastPath = packageJsonPath;
+ packageJsonUrl = new URL$1(
+ (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
+ packageName +
+ '/package.json',
+ packageJsonUrl
+ );
+ packageJsonPath = fileURLToPath(packageJsonUrl);
+ continue
+ }
+
+ // Package match.
+ const packageConfig = getPackageConfig(packageJsonPath, specifier, base);
+ if (packageConfig.exports !== undefined && packageConfig.exports !== null)
+ return packageExportsResolve(
+ packageJsonUrl,
+ packageSubpath,
+ packageConfig,
+ base,
+ conditions
+ ).resolved
+ if (packageSubpath === '.')
+ return legacyMainResolve(packageJsonUrl, packageConfig, base)
+ return new URL$1(packageSubpath, packageJsonUrl)
+ // Cross-platform root check.
+ } while (packageJsonPath.length !== lastPath.length)
+
+ throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base))
+}
+
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function isRelativeSpecifier(specifier) {
+ if (specifier[0] === '.') {
+ if (specifier.length === 1 || specifier[1] === '/') return true
+ if (
+ specifier[1] === '.' &&
+ (specifier.length === 2 || specifier[2] === '/')
+ ) {
+ return true
+ }
+ }
+
+ return false
+}
+
+/**
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+ if (specifier === '') return false
+ if (specifier[0] === '/') return true
+ return isRelativeSpecifier(specifier)
+}
+
+/**
+ * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
+ * sync and slightly lower-level than `resolve`).
+ *
+ *
+ *
+ * @param {string} specifier
+ * @param {URL} base
+ * @param {Set<string>} [conditions]
+ * @returns {URL}
+ */
+function moduleResolve(specifier, base, conditions) {
+ // Order swapped from spec for minor perf gain.
+ // Ok since relative URLs cannot parse as URLs.
+ /** @type {URL} */
+ let resolved;
+
+ if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+ resolved = new URL$1(specifier, base);
+ } else if (specifier[0] === '#') {
+({resolved} = packageImportsResolve(specifier, base, conditions));
+ } else {
+ try {
+ resolved = new URL$1(specifier);
+ } catch {
+ resolved = packageResolve(specifier, base, conditions);
+ }
+ }
+
+ return finalizeResolution(resolved, base)
+}
+
+/**
+ * @param {string} specifier
+ * @param {{parentURL?: string, conditions?: string[]}} context
+ * @returns {{url: string}}
+ */
+function defaultResolve(specifier, context = {}) {
+ const {parentURL} = context;
+ /** @type {URL} */
+ let parsed;
+
+ try {
+ parsed = new URL$1(specifier);
+ if (parsed.protocol === 'data:') {
+ return {url: specifier}
+ }
+ } catch {}
+
+ if (parsed && parsed.protocol === 'node:') return {url: specifier}
+ if (parsed && parsed.protocol !== 'file:' && parsed.protocol !== 'data:')
+ throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed)
+
+ if (listOfBuiltins.includes(specifier)) {
+ return {url: 'node:' + specifier}
+ }
+
+ if (parentURL.startsWith('data:')) {
+ // This is gonna blow up, we want the error
+ new URL$1(specifier, parentURL);
+ }
+
+ const conditions = getConditionsSet(context.conditions);
+ let url = moduleResolve(specifier, new URL$1(parentURL), conditions);
+
+ const urlPath = fileURLToPath(url);
+ const real = realpathSync$1(urlPath);
+ const old = url;
+ url = pathToFileURL(real + (urlPath.endsWith(path$b.sep) ? '/' : ''));
+ url.search = old.search;
+ url.hash = old.hash;
+
+ return {url: `${url}`}
+}
+
+/**
+ * Provides a module-relative resolution function scoped to each module,
+ * returning the URL string.
+ * `import.meta.resolve` also accepts a second argument which is the parent
+ * module from which to resolve from.
+ *
+ * This function is asynchronous because the ES module resolver in Node.js is
+ * allowed to be asynchronous.
+ *
+ * @param {string} specifier The module specifier to resolve relative to parent.
+ * @param {string} parent The absolute parent module URL to resolve from.
+ * You should pass `import.meta.url` or something else
+ * @returns {Promise<string>}
+ */
+async function resolve(specifier, parent) {
+ if (!parent) {
+ throw new Error(
+ 'Please pass `parent`: `import-meta-resolve` cannot ponyfill that'
+ )
+ }
+
+ try {
+ return defaultResolve(specifier, {parentURL: parent}).url
+ } catch (error) {
+ return error.code === 'ERR_UNSUPPORTED_DIR_IMPORT'
+ ? error.url
+ : Promise.reject(error)
+ }
+}
var libnpmconfig = {};
@@ -8134,7 +20584,7 @@ class FiggyPudding {
}
}
try {
- const util = require$$0__default['default'];
+ const util = require$$0$4;
FiggyPudding.prototype[util.inspect.custom] = function (depth, opts) {
return (
this[Symbol.toStringTag] + ' '
@@ -8249,23 +20699,23 @@ function entries (obj) {
return Object.keys(obj).map(k => [k, obj[k]])
}
-var findUp$2 = {exports: {}};
+var findUp$1 = {exports: {}};
var locatePath$1 = {exports: {}};
var pathExists$1 = {exports: {}};
-const fs$i = require$$0__default$3['default'];
+const fs$5 = require$$0$3;
pathExists$1.exports = fp => new Promise(resolve => {
- fs$i.access(fp, err => {
+ fs$5.access(fp, err => {
resolve(!err);
});
});
pathExists$1.exports.sync = fp => {
try {
- fs$i.accessSync(fp);
+ fs$5.accessSync(fp);
return true;
} catch (err) {
return false;
@@ -8375,7 +20825,7 @@ var pLocate$1 = (iterable, tester, opts) => {
.catch(err => err instanceof EndError ? err.value : Promise.reject(err));
};
-const path$k = require$$0__default$2['default'];
+const path$7 = path$b;
const pathExists = pathExists$1.exports;
const pLocate = pLocate$1;
@@ -8384,7 +20834,7 @@ locatePath$1.exports = (iterable, options) => {
cwd: process.cwd()
}, options);
- return pLocate(iterable, el => pathExists(path$k.resolve(options.cwd, el)), options);
+ return pLocate(iterable, el => pathExists(path$7.resolve(options.cwd, el)), options);
};
locatePath$1.exports.sync = (iterable, options) => {
@@ -8393,18 +20843,18 @@ locatePath$1.exports.sync = (iterable, options) => {
}, options);
for (const el of iterable) {
- if (pathExists.sync(path$k.resolve(options.cwd, el))) {
+ if (pathExists.sync(path$7.resolve(options.cwd, el))) {
return el;
}
}
};
-const path$j = require$$0__default$2['default'];
+const path$6 = path$b;
const locatePath = locatePath$1.exports;
-findUp$2.exports = (filename, opts = {}) => {
- const startDir = path$j.resolve(opts.cwd || '');
- const {root} = path$j.parse(startDir);
+findUp$1.exports = (filename, opts = {}) => {
+ const startDir = path$6.resolve(opts.cwd || '');
+ const {root} = path$6.parse(startDir);
const filenames = [].concat(filename);
@@ -8412,20 +20862,20 @@ findUp$2.exports = (filename, opts = {}) => {
(function find(dir) {
locatePath(filenames, {cwd: dir}).then(file => {
if (file) {
- resolve(path$j.join(dir, file));
+ resolve(path$6.join(dir, file));
} else if (dir === root) {
resolve(null);
} else {
- find(path$j.dirname(dir));
+ find(path$6.dirname(dir));
}
});
})(startDir);
});
};
-findUp$2.exports.sync = (filename, opts = {}) => {
- let dir = path$j.resolve(opts.cwd || '');
- const {root} = path$j.parse(dir);
+findUp$1.exports.sync = (filename, opts = {}) => {
+ let dir = path$6.resolve(opts.cwd || '');
+ const {root} = path$6.parse(dir);
const filenames = [].concat(filename);
@@ -8434,27 +20884,27 @@ findUp$2.exports.sync = (filename, opts = {}) => {
const file = locatePath.sync(filenames, {cwd: dir});
if (file) {
- return path$j.join(dir, file);
+ return path$6.join(dir, file);
}
if (dir === root) {
return null;
}
- dir = path$j.dirname(dir);
+ dir = path$6.dirname(dir);
}
};
var ini$1 = {};
-ini$1.parse = ini$1.decode = decode$2;
+ini$1.parse = ini$1.decode = decode;
ini$1.stringify = ini$1.encode = encode$1;
-ini$1.safe = safe$8;
+ini$1.safe = safe$1;
ini$1.unsafe = unsafe$1;
-var eol$2 = typeof process !== 'undefined' &&
+var eol$1 = typeof process !== 'undefined' &&
process.platform === 'win32' ? '\r\n' : '\n';
function encode$1 (obj, opt) {
@@ -8477,16 +20927,16 @@ function encode$1 (obj, opt) {
var val = obj[k];
if (val && Array.isArray(val)) {
val.forEach(function (item) {
- out += safe$8(k + '[]') + separator + safe$8(item) + '\n';
+ out += safe$1(k + '[]') + separator + safe$1(item) + '\n';
});
} else if (val && typeof val === 'object')
children.push(k);
else
- out += safe$8(k) + separator + safe$8(val) + eol$2;
+ out += safe$1(k) + separator + safe$1(val) + eol$1;
});
if (opt.section && out.length)
- out = '[' + safe$8(opt.section) + ']' + eol$2 + out;
+ out = '[' + safe$1(opt.section) + ']' + eol$1 + out;
children.forEach(function (k, _, __) {
var nk = dotSplit(k).join('\\.');
@@ -8496,7 +20946,7 @@ function encode$1 (obj, opt) {
whitespace: opt.whitespace,
});
if (out.length && child.length)
- out += eol$2;
+ out += eol$1;
out += child;
});
@@ -8513,7 +20963,7 @@ function dotSplit (str) {
})
}
-function decode$2 (str) {
+function decode (str) {
var out = {};
var p = out;
var section = null;
@@ -8605,7 +21055,7 @@ function isQuoted (val) {
(val.charAt(0) === "'" && val.slice(-1) === "'")
}
-function safe$8 (val) {
+function safe$1 (val) {
return (typeof val !== 'string' ||
val.match(/[=\r\n]/) ||
val.match(/^\[/) ||
@@ -8654,12 +21104,12 @@ function unsafe$1 (val, doUnesc) {
return val
}
-const fs$h = require$$0__default$3['default'];
+const fs$4 = require$$0$3;
const figgyPudding = figgyPudding_1;
-const findUp$1 = findUp$2.exports;
+const findUp = findUp$1.exports;
const ini = ini$1;
-const os$1 = require$$0__default$1['default'];
-const path$i = require$$0__default$2['default'];
+const os = require$$0$2;
+const path$5 = path$b;
const NpmConfig = figgyPudding({}, {
// Open up the pudding object.
@@ -8667,14 +21117,14 @@ const NpmConfig = figgyPudding({}, {
});
const ConfigOpts = figgyPudding({
- cache: { default: path$i.join(os$1.homedir(), '.npm') },
+ cache: { default: path$5.join(os.homedir(), '.npm') },
configNames: { default: ['npmrc', '.npmrc'] },
envPrefix: { default: /^npm_config_/i },
cwd: { default: () => process.cwd() },
globalconfig: {
- default: () => path$i.join(getGlobalPrefix(), 'etc', 'npmrc')
+ default: () => path$5.join(getGlobalPrefix(), 'etc', 'npmrc')
},
- userconfig: { default: path$i.join(os$1.homedir(), '.npmrc') }
+ userconfig: { default: path$5.join(os.homedir(), '.npmrc') }
});
libnpmconfig.read = getNpmConfig;
@@ -8701,7 +21151,7 @@ function getNpmConfig (_opts, _builtin) {
env.globalconfig
);
const global = globalConfPath && maybeReadIni(globalConfPath);
- const projConfPath = findUp$1.sync(builtin.configNames, { cwd: builtin.cwd });
+ const projConfPath = findUp.sync(builtin.configNames, { cwd: builtin.cwd });
let proj = {};
if (projConfPath && projConfPath !== userConfPath) {
proj = maybeReadIni(projConfPath);
@@ -8709,17 +21159,17 @@ function getNpmConfig (_opts, _builtin) {
const newOpts = NpmConfig(builtin, global, user, proj, env, cli);
if (newOpts.cache) {
return newOpts.concat({
- cache: path$i.resolve(
+ cache: path$5.resolve(
(
(cli.cache || env.cache)
? builtin.cwd
: proj.cache
- ? path$i.dirname(projConfPath)
+ ? path$5.dirname(projConfPath)
: user.cache
- ? path$i.dirname(userConfPath)
+ ? path$5.dirname(userConfPath)
: global.cache
- ? path$i.dirname(globalConfPath)
- : path$i.dirname(userConfPath)
+ ? path$5.dirname(globalConfPath)
+ : path$5.dirname(userConfPath)
),
newOpts.cache
)
@@ -8732,7 +21182,7 @@ function getNpmConfig (_opts, _builtin) {
function maybeReadIni (f) {
let txt;
try {
- txt = fs$h.readFileSync(f, 'utf8');
+ txt = fs$4.readFileSync(f, 'utf8');
} catch (err) {
if (err.code === 'ENOENT') {
return ''
@@ -8748,59 +21198,64 @@ function getGlobalPrefix () {
return process.env.PREFIX
} else if (process.platform === 'win32') {
// c:\node\node.exe --> prefix=c:\node\
- return path$i.dirname(process.execPath)
+ return path$5.dirname(process.execPath)
} else {
// /usr/local/bin/node --> prefix=/usr/local
- let pref = path$i.dirname(path$i.dirname(process.execPath));
+ let pref = path$5.dirname(path$5.dirname(process.execPath));
// destdir only is respected on Unix
if (process.env.DESTDIR) {
- pref = path$i.join(process.env.DESTDIR, pref);
+ pref = path$5.join(process.env.DESTDIR, pref);
}
return pref
}
}
-var fs$g = require$$0__default$3['default'];
-var path$h = require$$0__default$2['default'];
-var resolve = resolveFrom$1.exports.silent;
-var readNpmConfig = libnpmconfig.read;
-
-var loadPlugin_1 = loadPlugin$1;
-loadPlugin$1.resolve = resolvePlugin;
+/**
+ * @typedef ResolveOptions
+ * @property {string} [prefix]
+ * @property {string|string[]} [cwd]
+ * @property {boolean} [global]
+ */
-var electron = process.versions.electron !== undefined;
-var windows = process.platform === 'win32';
+const electron = process.versions.electron !== undefined;
+const windows = process.platform === 'win32';
-var argv = process.argv[1] || /* istanbul ignore next */ '';
-var nvm = process.env.NVM_BIN;
-var appData = process.env.APPDATA;
+const argv = process.argv[1] || /* c8 ignore next */ '';
+const nvm = process.env.NVM_BIN;
+const appData = process.env.APPDATA;
-/* istanbul ignore next */
-var globalsLibrary = windows ? '' : 'lib';
+/* c8 ignore next */
+const globalsLibrary = windows ? '' : 'lib';
-var builtinNpmConfig;
+/** @type {{prefix?: string}} */
+let builtinNpmConfig;
// The prefix config defaults to the location where node is installed.
// On Windows, this is in a place called `%AppData%`, which we have to
// pass to `libnpmconfig` explicitly:
-/* istanbul ignore next */
+/* c8 ignore next 4 */
if (windows && appData) {
- builtinNpmConfig = {prefix: path$h.join(appData, 'npm')};
+ builtinNpmConfig = {prefix: path$b.join(appData, 'npm')};
}
-var npmPrefix = readNpmConfig(null, builtinNpmConfig).prefix;
+/**
+ * Note: `libnpmconfig` uses `figgy-pudding` which is slated for archival.
+ * Either `libnpmconfig` will switch to an alternative or we’ll have to.
+ * @type {string}
+ */
+let npmPrefix = libnpmconfig.read(null, builtinNpmConfig).prefix;
// If there is no prefix defined, use the defaults
// See: <https://github.com/eush77/npm-prefix/blob/master/index.js>
-/* istanbul ignore next */
+/* c8 ignore next 5 */
if (!npmPrefix) {
npmPrefix = windows
- ? path$h.dirname(process.execPath)
- : path$h.resolve(process.execPath, '../..');
+ ? path$b.dirname(process.execPath)
+ : path$b.resolve(process.execPath, '../..');
}
-var globally = electron || argv.indexOf(npmPrefix) === 0;
-var globals = path$h.resolve(npmPrefix, globalsLibrary, 'node_modules');
+const globalsDefault = electron || argv.indexOf(npmPrefix) === 0;
+let globalDir = path$b.resolve(npmPrefix, globalsLibrary, 'node_modules');
// If we’re in Electron, we’re running in a modified Node that cannot really
// install global node modules.
@@ -8810,63 +21265,74 @@ var globals = path$h.resolve(npmPrefix, globalsLibrary, 'node_modules');
// versions of Node.
// Luckily NVM leaks some environment variables that we can pick up on to try
// and detect the actual modules.
-/* istanbul ignore next */
-if (electron && nvm && !fs$g.existsSync(globals)) {
- globals = path$h.resolve(nvm, '..', globalsLibrary, 'node_modules');
+/* c8 ignore next 3 */
+if (electron && nvm && !require$$0$3.existsSync(globalDir)) {
+ globalDir = path$b.resolve(nvm, '..', globalsLibrary, 'node_modules');
}
-// Load the plugin found using `resolvePlugin`.
-function loadPlugin$1(name, options) {
- return commonjsRequire(resolvePlugin(name, options) || name)
+/**
+ * Load the plugin found using `resolvePlugin`.
+ *
+ * @param {string} name The name to import.
+ * @param {LoadOptions} [options]
+ * @returns {Promise<unknown>}
+ */
+async function loadPlugin(name, options = {}) {
+ const {key = 'default', ...rest} = options;
+ const fp = await resolvePlugin(name, rest);
+ /** @type {Object.<string, unknown>} */
+ // Bug with coverage on Node@12.
+ /* c8 ignore next 3 */
+ const mod = await import(pathToFileURL(fp).href);
+ return key === false ? mod : mod[key]
}
-// 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 global = settings.global;
- var filePath;
- var sources;
- var length;
- var index;
- var plugin;
- var slash;
- var scope = '';
-
- if (global === null || global === undefined) {
- global = globally;
- }
-
- if (cwd && typeof cwd === 'object') {
- sources = cwd.concat();
- } else {
- sources = [cwd || process.cwd()];
- }
+/**
+ * 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).
+ *
+ * @param {string} name
+ * @param {ResolveOptions} [options]
+ * @returns {Promise.<string>}
+ */
+async function resolvePlugin(name, options = {}) {
+ const prefix = options.prefix
+ ? options.prefix +
+ (options.prefix.charAt(options.prefix.length - 1) === '-' ? '' : '-')
+ : undefined;
+ const cwd = options.cwd;
+ const globals =
+ options.global === undefined || options.global === null
+ ? globalsDefault
+ : options.global;
+ const sources = Array.isArray(cwd) ? cwd.concat() : [cwd || process.cwd()];
+ /** @type {string} */
+ let plugin;
+ /** @type {Error} */
+ let lastError;
// Non-path.
if (name.charAt(0) !== '.') {
- if (global) {
- sources.push(globals);
+ if (globals) {
+ sources.push(globalDir);
}
+ let scope = '';
+
// Unprefix module.
if (prefix) {
- prefix = prefix.charAt(prefix.length - 1) === '-' ? prefix : prefix + '-';
-
// Scope?
if (name.charAt(0) === '@') {
- slash = name.indexOf('/');
+ const slash = name.indexOf('/');
// Let’s keep the algorithm simple.
// No need to care if this is a “valid” scope (I think?).
@@ -8885,29 +21351,51 @@ function resolvePlugin(name, options) {
}
}
- length = sources.length;
- index = -1;
+ let index = -1;
+ /** @type {string} */
+ let fp;
- while (++index < length) {
- cwd = sources[index];
- filePath = (plugin && resolve(cwd, plugin)) || resolve(cwd, name);
+ while (++index < sources.length) {
+ fp = plugin && (await attempt(sources[index], plugin));
+ if (fp) return fp
- if (filePath) {
- return filePath
- }
+ fp = await attempt(sources[index], name);
+ if (fp) return fp
}
- return null
+ // There’s always an error.
+ // Bug with coverage on Node@12.
+ /* c8 ignore next 8 */
+ throw lastError
+
+ /**
+ * @param {string} base
+ * @param {string} name
+ * @returns {Promise<string>}
+ */
+ async function attempt(base, name) {
+ try {
+ // `import-meta-resolve` resolves from files, whereas `load-plugin` works
+ // on folders, which is why we add a `/` at the end.
+ return fileURLToPath(
+ await resolve(name, pathToFileURL(base).href + '/')
+ )
+ // Bug with coverage on Node@12.
+ /* c8 ignore next 1 */
+ } catch (error) {
+ lastError = error;
+ }
+ }
}
-var isPlainObj = value => {
+function isPlainObject$1(value) {
if (Object.prototype.toString.call(value) !== '[object Object]') {
return false;
}
const prototype = Object.getPrototypeOf(value);
return prototype === null || prototype === Object.prototype;
-};
+}
var format$1 = {exports: {}};
@@ -9027,242 +21515,323 @@ var format$1 = {exports: {}};
var formatter = format$1.exports;
-var fault$3 = create$2(Error);
-
-var fault_1 = fault$3;
-
-fault$3.eval = create$2(EvalError);
-fault$3.range = create$2(RangeError);
-fault$3.reference = create$2(ReferenceError);
-fault$3.syntax = create$2(SyntaxError);
-fault$3.type = create$2(TypeError);
-fault$3.uri = create$2(URIError);
+// @ts-ignore
-fault$3.create = create$2;
+var fault = Object.assign(create$1(Error), {
+ eval: create$1(EvalError),
+ range: create$1(RangeError),
+ reference: create$1(ReferenceError),
+ syntax: create$1(SyntaxError),
+ type: create$1(TypeError),
+ uri: create$1(URIError)
+});
-// Create a new `EConstructor`, with the formatted `format` as a first argument.
-function create$2(EConstructor) {
- FormattedError.displayName = EConstructor.displayName || EConstructor.name;
+/**
+ * Create a new `EConstructor`, with the formatted `format` as a first argument.
+ *
+ * @template {Error} Fault
+ * @template {new (reason: string) => Fault} Class
+ * @param {Class} Constructor
+ */
+function create$1(Constructor) {
+ /** @type {string} */
+ // @ts-ignore
+ FormattedError.displayName = Constructor.displayName || Constructor.name;
return FormattedError
- function FormattedError(format) {
- if (format) {
- format = formatter.apply(null, arguments);
- }
-
- return new EConstructor(format)
+ /**
+ * @param {string} [format]
+ * @param {...unknown} values
+ * @returns {Fault}
+ */
+ function FormattedError(format, ...values) {
+ /** @type {string} */
+ var reason = format ? formatter(format, ...values) : format;
+ return new Constructor(reason)
}
}
-var fs$f = require$$0__default$3['default'];
-var path$g = require$$0__default$2['default'];
-var fault$2 = fault_1;
-var debug$d = src.exports('unified-engine:find-up');
-var wrap$1 = wrap_1;
-
-var findUp = FindUp$2;
+const debug$b = createDebug('unified-engine:find-up');
-FindUp$2.prototype.load = load$4;
-
-function FindUp$2(options) {
- var self = this;
-
- self.cache = {};
- self.cwd = options.cwd;
- self.detect = options.detect;
- self.names = options.names;
- self.create = options.create;
-
- if (options.filePath) {
- self.givenFilePath = path$g.resolve(options.cwd, options.filePath);
- }
-}
-
-function load$4(filePath, callback) {
- var self = this;
- var givenFile = self.givenFile;
- var parent;
+/**
+ * @template Value
+ */
+class FindUp {
+ /**
+ * @callback Create
+ * @param {Buffer} buf
+ * @param {string} filePath
+ * @returns {Promise<Value|undefined>|Value|undefined}
+ */
- if (self.givenFilePath) {
- if (givenFile) {
- apply(callback, givenFile);
- } else {
- givenFile = [callback];
- self.givenFile = givenFile;
- debug$d('Checking given file `%s`', self.givenFilePath);
- fs$f.readFile(self.givenFilePath, loadGiven);
- }
+ /**
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {Value} [result]
+ * @returns {void}
+ */
- return
- }
+ /**
+ * @typedef Options
+ * @property {string} cwd
+ * @property {string|undefined} filePath
+ * @property {boolean|undefined} [detect]
+ * @property {string[]} names
+ * @property {Create} create
+ */
- if (!self.detect) {
- return callback()
- }
+ /**
+ * @param {Options} options
+ */
+ constructor(options) {
+ /** @type {Record<string, Callback[]|undefined|Error|Value>} */
+ this.cache = {};
+ /** @type {string} */
+ this.cwd = options.cwd;
+ /** @type {boolean|undefined} */
+ this.detect = options.detect;
+ /** @type {string[]} */
+ this.names = options.names;
+ /** @type {Create} */
+ this.create = options.create;
- filePath = path$g.resolve(self.cwd, filePath);
- parent = path$g.dirname(filePath);
+ /** @type {string|undefined} */
+ this.givenFilePath = options.filePath
+ ? path$c.resolve(options.cwd, options.filePath)
+ : undefined;
- if (parent in self.cache) {
- apply(callback, self.cache[parent]);
- } else {
- self.cache[parent] = [callback];
- find(parent);
+ /* eslint-disable no-unused-expressions */
+ /** @type {Error|Value|Callback[]|undefined} */
+ this.givenFile;
+ /* eslint-enable no-unused-expressions */
}
- function loadGiven(error, buf) {
- var cbs = self.givenFile;
- var result;
-
- if (error) {
- result = fault$2(
- 'Cannot read given file `%s`\n%s',
- path$g.relative(self.cwd, self.givenFilePath),
- error.stack
- );
- result.code = 'ENOENT';
- result.path = error.path;
- result.syscall = error.syscall;
- loaded(result);
- } else {
- wrap$1(self.create, onparse)(buf, self.givenFilePath);
- }
-
- function onparse(error, result) {
- if (error) {
- debug$d(error.message);
- loaded(
- fault$2(
- 'Cannot parse given file `%s`\n%s',
- path$g.relative(self.cwd, self.givenFilePath),
- error.stack
- )
- );
+ /**
+ * @param {string} filePath
+ * @param {Callback} callback
+ */
+ load(filePath, callback) {
+ const self = this;
+ const givenFile = this.givenFile;
+ const {givenFilePath} = this;
+
+ if (givenFilePath) {
+ if (givenFile) {
+ apply(callback, givenFile);
} else {
- debug$d('Read given file `%s`', self.givenFilePath);
- loaded(result);
+ const cbs = [callback];
+ this.givenFile = cbs;
+ debug$b('Checking given file `%s`', givenFilePath);
+ fs$a.readFile(givenFilePath, (error, buf) => {
+ if (error) {
+ /** @type {NodeJS.ErrnoException} */
+ const result = fault(
+ 'Cannot read given file `%s`\n%s',
+ path$c.relative(this.cwd, givenFilePath),
+ error.stack
+ );
+ result.code = 'ENOENT';
+ result.path = error.path;
+ result.syscall = error.syscall;
+ loaded(result);
+ } else {
+ wrap(this.create, (error, /** @type {Value} */ result) => {
+ if (error) {
+ debug$b(error.message);
+ loaded(
+ fault(
+ 'Cannot parse given file `%s`\n%s',
+ path$c.relative(this.cwd, givenFilePath),
+ error.stack
+ )
+ );
+ } else {
+ debug$b('Read given file `%s`', givenFilePath);
+ loaded(result);
+ }
+ })(buf, givenFilePath);
+ }
+
+ /** @param {Error|Value} result */
+ function loaded(result) {
+ self.givenFile = result;
+ applyAll(cbs, result);
+ }
+ });
}
+
+ return
}
- function loaded(result) {
- givenFile = result;
- self.givenFile = result;
- applyAll(cbs, result);
+ if (!this.detect) {
+ return callback(null)
}
- }
- function find(directory) {
- var index = -1;
+ filePath = path$c.resolve(this.cwd, filePath);
+ const parent = path$c.dirname(filePath);
- next();
+ if (parent in this.cache) {
+ apply(callback, this.cache[parent]);
+ } else {
+ this.cache[parent] = [callback];
+ find(parent);
+ }
- function next() {
- var parent;
+ /**
+ * @param {string} directory
+ */
+ function find(directory) {
+ let index = -1;
- // Try to read the next file.
- // We do not use `readdir` because on huge directories, that could be
- // *very* slow.
- if (++index < self.names.length) {
- fs$f.readFile(path$g.join(directory, self.names[index]), done);
- } else {
- parent = path$g.dirname(directory);
+ next();
- if (directory === parent) {
- debug$d('No files found for `%s`', filePath);
- found();
- } else if (parent in self.cache) {
- apply(found, self.cache[parent]);
+ function next() {
+ // Try to read the next file.
+ // We do not use `readdir` because on huge directories, that could be
+ // *very* slow.
+ if (++index < self.names.length) {
+ fs$a.readFile(path$c.join(directory, self.names[index]), done);
} else {
- self.cache[parent] = [found];
- find(parent);
- }
- }
- }
-
- function done(error, buf) {
- var fp = path$g.join(directory, self.names[index]);
+ const parent = path$c.dirname(directory);
- /* istanbul ignore if - Hard to test. */
- if (error) {
- if (error.code === 'ENOENT') {
- return next()
+ if (directory === parent) {
+ debug$b('No files found for `%s`', filePath);
+ found(null);
+ } else if (parent in self.cache) {
+ apply(found, self.cache[parent]);
+ } else {
+ self.cache[parent] = [found];
+ find(parent);
+ }
}
-
- debug$d(error.message);
- return found(
- fault$2(
- 'Cannot read file `%s`\n%s',
- path$g.relative(self.cwd, fp),
- error.message
- )
- )
}
- wrap$1(self.create, onparse)(buf, fp);
+ /**
+ * @param {NodeJS.ErrnoException|null} error
+ * @param {Buffer} [buf]
+ * @returns {void}
+ */
+ function done(error, buf) {
+ const fp = path$c.join(directory, self.names[index]);
- function onparse(error, result) {
if (error) {
- found(
- fault$2(
- 'Cannot parse file `%s`\n%s',
- path$g.relative(self.cwd, fp),
+ // Hard to test.
+ /* c8 ignore next 13 */
+ if (error.code === 'ENOENT') {
+ return next()
+ }
+
+ debug$b(error.message);
+ return found(
+ fault(
+ 'Cannot read file `%s`\n%s',
+ path$c.relative(self.cwd, fp),
error.message
)
- );
- } else if (result) {
- debug$d('Read file `%s`', fp);
- found(null, result);
- } else {
- next();
+ )
}
+
+ wrap(self.create, (error, /** @type {Value} */ result) => {
+ if (error) {
+ found(
+ fault(
+ 'Cannot parse file `%s`\n%s',
+ path$c.relative(self.cwd, fp),
+ error.message
+ )
+ );
+ } else if (result) {
+ debug$b('Read file `%s`', fp);
+ found(null, result);
+ } else {
+ next();
+ }
+ })(buf, fp);
}
- }
- function found(error, result) {
- var cbs = self.cache[directory];
- self.cache[directory] = error || result;
- applyAll(cbs, error || result);
+ /**
+ * @param {Error|null} error
+ * @param {Value} [result]
+ * @returns {void}
+ */
+ function found(error, result) {
+ /** @type {Callback[]} */
+ // @ts-expect-error: always a list if found.
+ const cbs = self.cache[directory];
+ self.cache[directory] = error || result;
+ applyAll(cbs, error || result);
+ }
}
- }
- function applyAll(cbs, result) {
- var index = cbs.length;
+ /**
+ * @param {Callback[]} cbs
+ * @param {Value|Error|undefined} result
+ */
+ function applyAll(cbs, result) {
+ let index = cbs.length;
- while (index--) {
- apply(cbs[index], result);
+ while (index--) {
+ apply(cbs[index], result);
+ }
}
- }
- function apply(cb, result) {
- if (
- result !== null &&
- typeof result === 'object' &&
- typeof result[0] === 'function'
- ) {
- result.push(cb);
- } else if (result instanceof Error) {
- cb(result);
- } else {
- cb(null, result);
+ /**
+ * @param {Callback} cb
+ * @param {Value|Error|Callback[]|undefined} result
+ */
+ function apply(cb, result) {
+ if (Array.isArray(result)) {
+ result.push(cb);
+ } else if (result instanceof Error) {
+ cb(result);
+ } else {
+ cb(null, result);
+ }
}
}
}
-var path$f = require$$0__default$2['default'];
-var yaml = jsYaml$1;
-var json$2 = parseJson_1;
-var debug$c = src.exports('unified-engine:configuration');
-var loadPlugin = loadPlugin_1;
-var plain$1 = isPlainObj;
-var fault$1 = fault_1;
-var FindUp$1 = findUp;
+/**
+ * @typedef {import('unified').Plugin<unknown[]>} Plugin
+ * @typedef {import('unified').PluginTuple<unknown[]>} PluginTuple
+ * @typedef {import('unified').PluggableList} PluggableList
+ *
+ * @typedef {Record<string, unknown>} Settings
+ *
+ * @typedef {Record<string, Settings|null|undefined>} PluginIdObject
+ * @typedef {Array<string|[string, ...unknown[]]>} PluginIdList
+ *
+ * @typedef Preset
+ * @property {Settings} [settings]
+ * @property {PluggableList|PluginIdObject|PluginIdList|undefined} [plugins]
+ *
+ * @typedef Config
+ * @property {Settings} [settings]
+ * @property {Array<PluginTuple>} [plugins]
+ *
+ * @callback ConfigTransform
+ * @param {any} config
+ * @param {string} filePath
+ * @returns {Preset}
+ *
+ * @callback Loader
+ * @param {Buffer} buf
+ * @param {string} filePath
+ * @returns {Promise<Preset|undefined>}
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {Config} [result]
+ * @returns {void}
+ */
-var configuration = Config;
+const debug$a = createDebug('unified-engine:configuration');
-var own$f = {}.hasOwnProperty;
+const own$c = {}.hasOwnProperty;
-var loaders = {
+/** @type {Record<string, Loader>} */
+const loaders = {
'.json': loadJson,
'.cjs': loadScriptOrModule,
'.mjs': loadScriptOrModule,
@@ -9271,142 +21840,211 @@ var loaders = {
'.yml': loadYaml
};
-var defaultLoader = loadJson;
+const defaultLoader = loadJson;
-Config.prototype.load = load$3;
+/**
+ * @typedef Options
+ * @property {string} cwd
+ * @property {string} [packageField]
+ * @property {string} [pluginPrefix]
+ * @property {string} [rcName]
+ * @property {string} [rcPath]
+ * @property {boolean} [detectConfig]
+ * @property {ConfigTransform} [configTransform]
+ * @property {Preset} [defaultConfig]
+ * @property {Preset['settings']} [settings]
+ * @property {Preset['plugins']} [plugins]
+ */
+
+class Configuration {
+ /**
+ * @param {Options} options
+ */
+ constructor(options) {
+ /** @type {string[]} */
+ const names = [];
-function Config(options) {
- var names = [];
+ /** @type {string} */
+ this.cwd = options.cwd;
+ /** @type {string|undefined} */
+ this.packageField = options.packageField;
+ /** @type {string|undefined} */
+ this.pluginPrefix = options.pluginPrefix;
+ /** @type {ConfigTransform|undefined} */
+ this.configTransform = options.configTransform;
+ /** @type {Preset|undefined} */
+ this.defaultConfig = options.defaultConfig;
+
+ if (options.rcName) {
+ names.push(
+ options.rcName,
+ options.rcName + '.js',
+ options.rcName + '.yml',
+ options.rcName + '.yaml'
+ );
+ debug$a('Looking for `%s` configuration files', names);
+ }
- this.cwd = options.cwd;
- this.packageField = options.packageField;
- this.pluginPrefix = options.pluginPrefix;
- this.configTransform = options.configTransform;
- this.defaultConfig = options.defaultConfig;
+ if (options.packageField) {
+ names.push('package.json');
+ debug$a(
+ 'Looking for `%s` fields in `package.json` files',
+ options.packageField
+ );
+ }
- if (options.rcName) {
- names.push(
- options.rcName,
- options.rcName + '.js',
- options.rcName + '.yml',
- options.rcName + '.yaml'
- );
- debug$c('Looking for `%s` configuration files', names);
- }
+ /** @type {Preset} */
+ this.given = {settings: options.settings, plugins: options.plugins};
+ this.create = this.create.bind(this);
- if (options.packageField) {
- names.push('package.json');
- debug$c(
- 'Looking for `%s` fields in `package.json` files',
- options.packageField
- );
+ /** @type {FindUp<Config>} */
+ this.findUp = new FindUp({
+ cwd: options.cwd,
+ filePath: options.rcPath,
+ detect: options.detectConfig,
+ names,
+ create: this.create
+ });
}
- this.given = {settings: options.settings, plugins: options.plugins};
- this.create = create$1.bind(this);
-
- this.findUp = new FindUp$1({
- filePath: options.rcPath,
- cwd: options.cwd,
- detect: options.detectConfig,
- names: names,
- create: this.create
- });
-}
-
-function load$3(filePath, callback) {
- var self = this;
-
- self.findUp.load(filePath || path$f.resolve(this.cwd, 'stdin.js'), done);
-
- function done(error, file) {
- if (error || file) {
- return callback(error, file)
- }
+ /**
+ * @param {string} filePath
+ * @param {Callback} callback
+ * @returns {void}
+ */
+ load(filePath, callback) {
+ this.findUp.load(
+ filePath || path$c.resolve(this.cwd, 'stdin.js'),
+ (error, file) => {
+ if (error || file) {
+ return callback(error, file)
+ }
- self.create().then(function (result) {
- callback(null, result);
- }, callback);
+ this.create(undefined, undefined).then((result) => {
+ callback(null, result);
+ }, callback);
+ }
+ );
}
-}
-async function create$1(buf, filePath) {
- var self = this;
- var fn = (filePath && loaders[path$f.extname(filePath)]) || defaultLoader;
- var options = {prefix: self.pluginPrefix, cwd: self.cwd};
- var result = {settings: {}, plugins: []};
- var contents;
+ /**
+ * @param {Buffer|undefined} buf
+ * @param {string|undefined} filePath
+ * @returns {Promise<Config|undefined>}
+ */
+ async create(buf, filePath) {
+ const options = {prefix: this.pluginPrefix, cwd: this.cwd};
+ const result = {settings: {}, plugins: []};
+ const extname = filePath ? path$c.extname(filePath) : undefined;
+ const loader =
+ extname && extname in loaders ? loaders[extname] : defaultLoader;
+ /** @type {Preset|undefined} */
+ let value;
- if (filePath) {
- contents = await fn.apply(self, arguments);
- }
+ if (filePath && buf) {
+ value = await loader.call(this, buf, filePath);
- if (self.configTransform && contents !== undefined) {
- contents = self.configTransform(contents, filePath);
- }
+ if (this.configTransform && value !== undefined) {
+ value = this.configTransform(value, filePath);
+ }
+ }
- // Exit if we did find a `package.json`, but it does not have configuration.
- if (
- buf &&
- contents === undefined &&
- path$f.basename(filePath) === 'package.json'
- ) {
- return
- }
+ // Exit if we did find a `package.json`, but it does not have configuration.
+ if (
+ filePath &&
+ value === undefined &&
+ path$c.basename(filePath) === 'package.json'
+ ) {
+ return
+ }
- if (contents === undefined) {
- if (self.defaultConfig) {
- await merge$1(
+ if (value === undefined) {
+ if (this.defaultConfig) {
+ await merge(
+ result,
+ this.defaultConfig,
+ Object.assign({}, options, {root: this.cwd})
+ );
+ }
+ } else {
+ await merge(
result,
- self.defaultConfig,
- Object.assign({}, options, {root: self.cwd})
+ value,
+ // @ts-expect-error: `value` can only exist if w/ `filePath`.
+ Object.assign({}, options, {root: path$c.dirname(filePath)})
);
}
- } else {
- await merge$1(
+
+ await merge(
result,
- contents,
- Object.assign({}, options, {root: path$f.dirname(filePath)})
+ this.given,
+ Object.assign({}, options, {root: this.cwd})
);
- }
-
- await merge$1(result, self.given, Object.assign({}, options, {root: self.cwd}));
- return result
+ // C8 bug on Node@12
+ /* c8 ignore next 2 */
+ return result
+ }
}
-function loadScriptOrModule(_, filePath) {
+/** @type {Loader} */
+async function loadScriptOrModule(_, filePath) {
+ // C8 bug on Node@12
+ /* c8 ignore next 4 */
+ // @ts-expect-error: Assume it matches config.
+ // type-coverage:ignore-next-line
return loadFromAbsolutePath(filePath, this.cwd)
}
-function loadYaml(buf, filePath) {
- return yaml.safeLoad(buf, {filename: path$f.basename(filePath)})
+/** @type {Loader} */
+async function loadYaml(buf, filePath) {
+ // C8 bug on Node@12
+ /* c8 ignore next 4 */
+ // @ts-expect-error: Assume it matches config.
+ return jsYaml.load(String(buf), {filename: path$c.basename(filePath)})
}
-function loadJson(buf, filePath) {
- var result = json$2(buf, filePath);
-
- if (path$f.basename(filePath) === 'package.json') {
- result = result[this.packageField];
- }
+/** @type {Loader} */
+async function loadJson(buf, filePath) {
+ /** @type {Record<string, unknown>} */
+ const result = parseJson_1(String(buf), filePath);
- return result
+ // C8 bug on Node@12
+ /* c8 ignore next 8 */
+ // @ts-expect-error: Assume it matches config.
+ return path$c.basename(filePath) === 'package.json'
+ ? // @ts-expect-error: `this` is the configuration context, TS doesn’t like
+ // `this` on callbacks.
+ // type-coverage:ignore-next-line
+ result[this.packageField]
+ : result
}
-async function merge$1(target, raw, options) {
+/**
+ * @param {Required<Config>} target
+ * @param {Preset} raw
+ * @param {{root: string, prefix: string|undefined}} options
+ * @returns {Promise<Config>}
+ */
+async function merge(target, raw, options) {
if (typeof raw === 'object' && raw !== null) {
await addPreset(raw);
} else {
throw new Error('Expected preset, not `' + raw + '`')
}
+ // C8 bug on Node@12
+ /* c8 ignore next 6 */
return target
+ /**
+ * @param {Preset} result
+ */
async function addPreset(result) {
- var plugins = result.plugins;
+ const plugins = result.plugins;
if (plugins === null || plugins === undefined) ; else if (typeof plugins === 'object' && plugins !== null) {
- await ('length' in plugins ? addEach(plugins) : addIn(plugins));
+ await (Array.isArray(plugins) ? addEach(plugins) : addIn(plugins));
} else {
throw new Error(
'Expected a list or object of plugins, not `' + plugins + '`'
@@ -9414,152 +22052,190 @@ async function merge$1(target, raw, options) {
}
target.settings = Object.assign({}, target.settings, result.settings);
+ // C8 bug on Node@12
+ /* c8 ignore next 6 */
}
+ /**
+ * @param {PluginIdList|PluggableList} result
+ */
async function addEach(result) {
- var index = -1;
- var value;
+ let index = -1;
while (++index < result.length) {
- value = result[index];
+ const value = result[index];
// Keep order sequential instead of parallel.
- // eslint-disable-next-line no-await-in-loop
- await (value !== null && typeof value === 'object' && 'length' in value
- ? use.apply(null, value)
- : use(value));
+ /* eslint-disable no-await-in-loop */
+ // @ts-expect-error: Spreading is fine.
+ // type-coverage:ignore-next-line
+ await (Array.isArray(value) ? use(...value) : use(value, undefined));
+ /* eslint-enable no-await-in-loop */
}
+ // C8 bug on Node@12
+ /* c8 ignore next 6 */
}
+ /**
+ * @param {PluginIdObject} result
+ */
async function addIn(result) {
- var key;
+ /** @type {string} */
+ let key;
for (key in result) {
- // Keep order sequential instead of parallel.
- // eslint-disable-next-line no-await-in-loop
- await use(key, result[key]);
+ if (own$c.call(result, key)) {
+ // Keep order sequential instead of parallel.
+ // eslint-disable-next-line no-await-in-loop
+ await use(key, result[key]);
+ }
}
+ // C8 bug on Node@12
+ /* c8 ignore next 7 */
}
+ /**
+ * @param {string|Plugin|Preset} usable
+ * @param {Settings|null|undefined} value
+ */
async function use(usable, value) {
if (typeof usable === 'string') {
await addModule(usable, value);
} else if (typeof usable === 'function') {
addPlugin(usable, value);
} else {
- await merge$1(target, usable, options);
+ await merge(target, usable, options);
}
+ // C8 bug on Node@12
+ /* c8 ignore next 7 */
}
+ /**
+ * @param {string} id
+ * @param {Settings|null|undefined} value
+ */
async function addModule(id, value) {
- var fp = loadPlugin.resolve(id, {cwd: options.root, prefix: options.prefix});
- var result;
+ /** @type {string} */
+ let fp;
- if (fp) {
- result = await loadFromAbsolutePath(fp, options.root);
+ try {
+ fp = await resolvePlugin(id, {
+ cwd: options.root,
+ prefix: options.prefix
+ });
+ } catch (error) {
+ addPlugin(() => {
+ throw fault('Could not find module `%s`\n%s', id, error.stack)
+ }, value);
+ return
+ }
- try {
- if (typeof result === 'function') {
- addPlugin(result, value);
- } else {
- await merge$1(
- target,
- result,
- Object.assign({}, options, {root: path$f.dirname(fp)})
- );
- }
- } catch (_) {
- throw fault$1(
- 'Error: Expected preset or plugin, not %s, at `%s`',
+ const result = await loadFromAbsolutePath(fp, options.root);
+
+ try {
+ if (typeof result === 'function') {
+ addPlugin(result, value);
+ } else {
+ await merge(
+ target,
result,
- path$f.relative(options.root, fp)
- )
+ Object.assign({}, options, {root: path$c.dirname(fp)})
+ );
}
- } else {
- fp = path$f.relative(options.cwd, path$f.resolve(options.root, id));
- addPlugin(
- failingModule(fp, new Error('Could not find module `' + id + '`')),
- value
- );
+ } catch {
+ throw fault(
+ 'Error: Expected preset or plugin, not %s, at `%s`',
+ result,
+ path$c.relative(options.root, fp)
+ )
}
+ // C8 bug on Node@12
+ /* c8 ignore next 8 */
}
- function addPlugin(result, value) {
- var entry = find$2(target.plugins, result);
+ /**
+ * @param {Plugin} plugin
+ * @param {Settings|null|undefined} value
+ * @returns {void}
+ */
+ function addPlugin(plugin, value) {
+ const entry = find(target.plugins, plugin);
+
+ if (value === null) {
+ value = undefined;
+ }
if (entry) {
reconfigure(entry, value);
} else {
- target.plugins.push([result, value]);
+ target.plugins.push([plugin, value]);
}
}
}
+/**
+ * @param {PluginTuple} entry
+ * @param {Settings|undefined} value
+ * @returns {void}
+ */
function reconfigure(entry, value) {
- if (plain$1(entry[1]) && plain$1(value)) {
+ if (isPlainObject$1(entry[1]) && isPlainObject$1(value)) {
value = Object.assign({}, entry[1], value);
}
entry[1] = value;
}
-function find$2(entries, plugin) {
- var index = -1;
+/**
+ * @param {Array<PluginTuple>} entries
+ * @param {Plugin} plugin
+ * @returns {PluginTuple|undefined}
+ */
+function find(entries, plugin) {
+ let index = -1;
while (++index < entries.length) {
- if (entries[index][0] === plugin) {
- return entries[index]
+ const entry = entries[index];
+ if (entry[0] === plugin) {
+ return entry
}
}
}
-function failingModule(id, error) {
- var cache = failingModule.cache || (failingModule.cache = {});
- var submodule = own$f.call(cache, id) ? cache[id] : (cache[id] = fail);
- return submodule
- function fail() {
- throw error
- }
-}
-
+/**
+ * @param {string} fp
+ * @param {string} base
+ * @returns {Promise<Plugin|Preset>}
+ */
async function loadFromAbsolutePath(fp, base) {
- var ext = path$f.extname(fp);
- var result;
-
- /* istanbul ignore next - To do next major: Tests don’t run on Node 10 */
- if (ext !== '.mjs') {
- try {
- result = commonjsRequire(fp);
- } catch (error) {
- if (ext !== '.cjs' && error.code === 'ERR_REQUIRE_ESM') {
- ext = '.mjs';
- } else {
- throw fault$1(
- 'Cannot parse script `%s`\n%s',
- path$f.relative(base, fp),
- error.stack
- )
- }
- }
+ try {
+ /** @type {{default?: unknown}} */
+ const result = await import(pathToFileURL$1(fp).href);
- if (result && typeof result === 'object' && result.__esModule) {
- result = result.default;
+ if (!('default' in result)) {
+ throw new Error(
+ 'Expected a plugin or preset exported as the default export'
+ )
}
- }
- /* istanbul ignore next - To do next major: Tests don’t run on Node 10 */
- if (ext === '.mjs') {
- result = (await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(fp)); })).default;
+ // @ts-expect-error: assume plugin/preset.
+ return result.default
+ // C8 bug on Node@12
+ /* c8 ignore next 4 */
+ } catch (error) {
+ throw fault('Cannot import `%s`\n%s', path$c.relative(base, fp), error.stack)
}
-
- return result
}
-var Configuration = configuration;
-
-var configure_1$2 = configure$6;
+/**
+ * @typedef {import('./index.js').Settings} Settings
+ */
-function configure$6(context, settings) {
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ */
+function configure$3(context, settings) {
context.configuration = new Configuration(settings);
}
@@ -9584,7 +22260,7 @@ const REGEX_SPLITALL_CRLF = /\r?\n/g;
// ..
const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
-const SLASH$1 = '/';
+const SLASH = '/';
const KEY_IGNORE = typeof Symbol !== 'undefined'
? Symbol.for('node-ignore')
/* istanbul ignore next */
@@ -9927,7 +22603,7 @@ const createRule = (pattern, ignorecase) => {
)
};
-const throwError$1 = (message, Ctor) => {
+const throwError = (message, Ctor) => {
throw new Ctor(message)
};
@@ -9961,7 +22637,7 @@ const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path);
checkPath.isNotRelative = isNotRelative;
checkPath.convert = p => p;
-class Ignore$2 {
+class Ignore$1 {
constructor ({
ignorecase = true
} = {}) {
@@ -10064,7 +22740,7 @@ class Ignore$2 {
// Supports nullable path
&& checkPath.convert(originalPath);
- checkPath(path, originalPath, throwError$1);
+ checkPath(path, originalPath, throwError);
return this._t(path, cache, checkUnignored, slices)
}
@@ -10077,7 +22753,7 @@ class Ignore$2 {
if (!slices) {
// path/to/a.js
// ['path', 'to', 'a.js']
- slices = path.split(SLASH$1);
+ slices = path.split(SLASH);
}
slices.pop();
@@ -10088,7 +22764,7 @@ class Ignore$2 {
}
const parent = this._t(
- slices.join(SLASH$1) + SLASH$1,
+ slices.join(SLASH) + SLASH,
cache,
checkUnignored,
slices
@@ -10120,19 +22796,19 @@ class Ignore$2 {
}
}
-const factory$5 = options => new Ignore$2(options);
+const factory$1 = options => new Ignore$1(options);
const returnFalse = () => false;
const isPathValid = path =>
checkPath(path && checkPath.convert(path), path, returnFalse);
-factory$5.isPathValid = isPathValid;
+factory$1.isPathValid = isPathValid;
// Fixes typescript
-factory$5.default = factory$5;
+factory$1.default = factory$1;
-var ignore$2 = factory$5;
+var ignore = factory$1;
// Windows
// --------------------------------------------------------------
@@ -10161,66 +22837,87 @@ if (
|| isNotRelative(path);
}
-var path$e = require$$0__default$2['default'];
-var gitignore$1 = ignore$2;
-var FindUp = findUp;
-
-var ignore$1 = Ignore$1;
-
-Ignore$1.prototype.check = check$5;
-
-function Ignore$1(options) {
- this.cwd = options.cwd;
- this.ignorePathResolveFrom = options.ignorePathResolveFrom;
-
- this.findUp = new FindUp({
- filePath: options.ignorePath,
- cwd: options.cwd,
- detect: options.detectIgnore,
- names: options.ignoreName ? [options.ignoreName] : [],
- create: create
- });
-}
-
-function check$5(filePath, callback) {
- var self = this;
-
- self.findUp.load(filePath, done);
+/**
+ * @typedef {import('ignore').Ignore & {filePath: string}} IgnoreConfig
+ *
+ * @typedef {'cwd'|'dir'} ResolveFrom
+ *
+ * @typedef Options
+ * @property {string} cwd
+ * @property {boolean|undefined} detectIgnore
+ * @property {string|undefined} ignoreName
+ * @property {string|undefined} ignorePath
+ * @property {ResolveFrom|undefined} ignorePathResolveFrom
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {boolean|undefined} [result]
+ */
- function done(error, ignore) {
- var normal;
+class Ignore {
+ /**
+ * @param {Options} options
+ */
+ constructor(options) {
+ /** @type {string} */
+ this.cwd = options.cwd;
+ /** @type {ResolveFrom|undefined} */
+ this.ignorePathResolveFrom = options.ignorePathResolveFrom;
+
+ /** @type {FindUp<IgnoreConfig>} */
+ this.findUp = new FindUp({
+ cwd: options.cwd,
+ filePath: options.ignorePath,
+ detect: options.detectIgnore,
+ names: options.ignoreName ? [options.ignoreName] : [],
+ create
+ });
+ }
- if (error) {
- callback(error);
- } else if (ignore) {
- normal = path$e.relative(
- path$e.resolve(
- self.cwd,
- self.ignorePathResolveFrom === 'cwd' ? '.' : ignore.filePath
- ),
- path$e.resolve(self.cwd, filePath)
- );
+ /**
+ * @param {string} filePath
+ * @param {Callback} callback
+ */
+ check(filePath, callback) {
+ this.findUp.load(filePath, (error, ignoreSet) => {
+ if (error) {
+ callback(error);
+ } else if (ignoreSet) {
+ const normal = path$c.relative(
+ path$c.resolve(
+ this.cwd,
+ this.ignorePathResolveFrom === 'cwd' ? '.' : ignoreSet.filePath
+ ),
+ path$c.resolve(this.cwd, filePath)
+ );
- if (
- normal === '' ||
- normal === '..' ||
- normal.charAt(0) === path$e.sep ||
- normal.slice(0, 3) === '..' + path$e.sep
- ) {
- callback(null, false);
+ if (
+ normal === '' ||
+ normal === '..' ||
+ normal.charAt(0) === path$c.sep ||
+ normal.slice(0, 3) === '..' + path$c.sep
+ ) {
+ callback(null, false);
+ } else {
+ callback(null, ignoreSet.ignores(normal));
+ }
} else {
- callback(null, ignore.ignores(normal));
+ callback(null, false);
}
- } else {
- callback(null, false);
- }
+ });
}
}
+/**
+ * @param {Buffer} buf
+ * @param {string} filePath
+ * @returns {IgnoreConfig}
+ */
function create(buf, filePath) {
- var ignore = gitignore$1().add(String(buf));
- ignore.filePath = path$e.dirname(filePath);
- return ignore
+ /** @type {IgnoreConfig} */
+ return Object.assign(ignore().add(String(buf)), {
+ filePath: path$c.dirname(filePath)
+ })
}
var old$1 = {};
@@ -10246,9 +22943,9 @@ var old$1 = {};
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-var pathModule = require$$0__default$2['default'];
-var isWindows$2 = process.platform === 'win32';
-var fs$e = require$$0__default$3['default'];
+var pathModule = path$b;
+var isWindows = process.platform === 'win32';
+var fs$3 = require$$0$3;
// JavaScript implementation of realpath, ported from node pre-v6
@@ -10297,14 +22994,14 @@ pathModule.normalize;
// Regexp that finds the next partion of a (partial) path
// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
-if (isWindows$2) {
+if (isWindows) {
var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
} else {
var nextPartRe = /(.*?)(?:[\/]+|$)/g;
}
// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
-if (isWindows$2) {
+if (isWindows) {
var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
} else {
var splitRootRe = /^[\/]*/;
@@ -10342,8 +23039,8 @@ old$1.realpathSync = function realpathSync(p, cache) {
previous = '';
// On windows, check that the root exists. On unix there is no need.
- if (isWindows$2 && !knownHard[base]) {
- fs$e.lstatSync(base);
+ if (isWindows && !knownHard[base]) {
+ fs$3.lstatSync(base);
knownHard[base] = true;
}
}
@@ -10370,7 +23067,7 @@ old$1.realpathSync = function realpathSync(p, cache) {
// some known symbolic link. no need to stat again.
resolvedLink = cache[base];
} else {
- var stat = fs$e.lstatSync(base);
+ var stat = fs$3.lstatSync(base);
if (!stat.isSymbolicLink()) {
knownHard[base] = true;
if (cache) cache[base] = base;
@@ -10380,20 +23077,20 @@ old$1.realpathSync = function realpathSync(p, cache) {
// read the link if it wasn't read before
// dev/ino always return 0 on windows, so skip the check.
var linkTarget = null;
- if (!isWindows$2) {
+ if (!isWindows) {
var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
if (seenLinks.hasOwnProperty(id)) {
linkTarget = seenLinks[id];
}
}
if (linkTarget === null) {
- fs$e.statSync(base);
- linkTarget = fs$e.readlinkSync(base);
+ fs$3.statSync(base);
+ linkTarget = fs$3.readlinkSync(base);
}
resolvedLink = pathModule.resolve(previous, linkTarget);
// track this, if given a cache.
if (cache) cache[base] = resolvedLink;
- if (!isWindows$2) seenLinks[id] = linkTarget;
+ if (!isWindows) seenLinks[id] = linkTarget;
}
// resolve the link, then start over
@@ -10444,8 +23141,8 @@ old$1.realpath = function realpath(p, cache, cb) {
previous = '';
// On windows, check that the root exists. On unix there is no need.
- if (isWindows$2 && !knownHard[base]) {
- fs$e.lstat(base, function(err) {
+ if (isWindows && !knownHard[base]) {
+ fs$3.lstat(base, function(err) {
if (err) return cb(err);
knownHard[base] = true;
LOOP();
@@ -10482,7 +23179,7 @@ old$1.realpath = function realpath(p, cache, cb) {
return gotResolvedLink(cache[base]);
}
- return fs$e.lstat(base, gotStat);
+ return fs$3.lstat(base, gotStat);
}
function gotStat(err, stat) {
@@ -10498,17 +23195,17 @@ old$1.realpath = function realpath(p, cache, cb) {
// stat & read the link if not read before
// call gotTarget as soon as the link target is known
// dev/ino always return 0 on windows, so skip the check.
- if (!isWindows$2) {
+ if (!isWindows) {
var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
if (seenLinks.hasOwnProperty(id)) {
return gotTarget(null, seenLinks[id], base);
}
}
- fs$e.stat(base, function(err) {
+ fs$3.stat(base, function(err) {
if (err) return cb(err);
- fs$e.readlink(base, function(err, target) {
- if (!isWindows$2) seenLinks[id] = target;
+ fs$3.readlink(base, function(err, target) {
+ if (!isWindows) seenLinks[id] = target;
gotTarget(err, target);
});
});
@@ -10529,19 +23226,19 @@ old$1.realpath = function realpath(p, cache, cb) {
}
};
-var fs_realpath = realpath$2;
-realpath$2.realpath = realpath$2;
-realpath$2.sync = realpathSync;
-realpath$2.realpathSync = realpathSync;
-realpath$2.monkeypatch = monkeypatch;
-realpath$2.unmonkeypatch = unmonkeypatch;
+var fs_realpath = realpath;
+realpath.realpath = realpath;
+realpath.sync = realpathSync;
+realpath.realpathSync = realpathSync;
+realpath.monkeypatch = monkeypatch;
+realpath.unmonkeypatch = unmonkeypatch;
-var fs$d = require$$0__default$3['default'];
-var origRealpath = fs$d.realpath;
-var origRealpathSync = fs$d.realpathSync;
+var fs$2 = require$$0$3;
+var origRealpath = fs$2.realpath;
+var origRealpathSync = fs$2.realpathSync;
var version$2 = process.version;
-var ok$2 = /^v[0-5]\./.test(version$2);
+var ok$1 = /^v[0-5]\./.test(version$2);
var old = old$1;
function newError (er) {
@@ -10552,8 +23249,8 @@ function newError (er) {
)
}
-function realpath$2 (p, cache, cb) {
- if (ok$2) {
+function realpath (p, cache, cb) {
+ if (ok$1) {
return origRealpath(p, cache, cb)
}
@@ -10571,7 +23268,7 @@ function realpath$2 (p, cache, cb) {
}
function realpathSync (p, cache) {
- if (ok$2) {
+ if (ok$1) {
return origRealpathSync(p, cache)
}
@@ -10587,13 +23284,13 @@ function realpathSync (p, cache) {
}
function monkeypatch () {
- fs$d.realpath = realpath$2;
- fs$d.realpathSync = realpathSync;
+ fs$2.realpath = realpath;
+ fs$2.realpathSync = realpathSync;
}
function unmonkeypatch () {
- fs$d.realpath = origRealpath;
- fs$d.realpathSync = origRealpathSync;
+ fs$2.realpath = origRealpath;
+ fs$2.realpathSync = origRealpathSync;
}
var concatMap$1 = function (xs, fn) {
@@ -10615,7 +23312,7 @@ function balanced$1(a, b, str) {
if (a instanceof RegExp) a = maybeMatch(a, str);
if (b instanceof RegExp) b = maybeMatch(b, str);
- var r = range$3(a, b, str);
+ var r = range(a, b, str);
return r && {
start: r[0],
@@ -10631,17 +23328,14 @@ function maybeMatch(reg, str) {
return m ? m[0] : null;
}
-balanced$1.range = range$3;
-function range$3(a, b, str) {
+balanced$1.range = range;
+function range(a, b, str) {
var begs, beg, left, right, result;
var ai = str.indexOf(a);
var bi = str.indexOf(b, ai + 1);
var i = ai;
if (ai >= 0 && bi > 0) {
- if(a===b) {
- return [ai, bi];
- }
begs = [];
left = str.length;
@@ -10683,7 +23377,7 @@ var escClose = '\0CLOSE'+Math.random()+'\0';
var escComma = '\0COMMA'+Math.random()+'\0';
var escPeriod = '\0PERIOD'+Math.random()+'\0';
-function numeric$1(str) {
+function numeric(str) {
return parseInt(str, 10) == str
? parseInt(str, 10)
: str.charCodeAt(0);
@@ -10750,7 +23444,7 @@ function expandTop(str) {
str = '\\{\\}' + str.substr(2);
}
- return expand$4(escapeBraces(str), true).map(unescapeBraces);
+ return expand$2(escapeBraces(str), true).map(unescapeBraces);
}
function embrace(str) {
@@ -10767,7 +23461,7 @@ function gte(i, y) {
return i >= y;
}
-function expand$4(str, isTop) {
+function expand$2(str, isTop) {
var expansions = [];
var m = balanced('{', '}', str);
@@ -10781,7 +23475,7 @@ function expand$4(str, isTop) {
// {a},b}
if (m.post.match(/,.*\}/)) {
str = m.pre + '{' + m.body + escClose + m.post;
- return expand$4(str);
+ return expand$2(str);
}
return [str];
}
@@ -10793,10 +23487,10 @@ function expand$4(str, isTop) {
n = parseCommaParts(m.body);
if (n.length === 1) {
// x{{a,b}}y ==> x{a}y x{b}y
- n = expand$4(n[0], false).map(embrace);
+ n = expand$2(n[0], false).map(embrace);
if (n.length === 1) {
var post = m.post.length
- ? expand$4(m.post, false)
+ ? expand$2(m.post, false)
: [''];
return post.map(function(p) {
return m.pre + n[0] + p;
@@ -10811,17 +23505,17 @@ function expand$4(str, isTop) {
// no need to expand pre, since it is guaranteed to be free of brace-sets
var pre = m.pre;
var post = m.post.length
- ? expand$4(m.post, false)
+ ? expand$2(m.post, false)
: [''];
var N;
if (isSequence) {
- var x = numeric$1(n[0]);
- var y = numeric$1(n[1]);
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
var width = Math.max(n[0].length, n[1].length);
var incr = n.length == 3
- ? Math.abs(numeric$1(n[2]))
+ ? Math.abs(numeric(n[2]))
: 1;
var test = lte;
var reverse = y < x;
@@ -10855,7 +23549,7 @@ function expand$4(str, isTop) {
N.push(c);
}
} else {
- N = concatMap(n, function(el) { return expand$4(el, false) });
+ N = concatMap(n, function(el) { return expand$2(el, false) });
}
for (var j = 0; j < N.length; j++) {
@@ -10872,13 +23566,13 @@ function expand$4(str, isTop) {
var minimatch_1 = minimatch$3;
minimatch$3.Minimatch = Minimatch$1;
-var path$d = { sep: '/' };
+var path$4 = { sep: '/' };
try {
- path$d = require$$0__default$2['default'];
+ path$4 = path$b;
} catch (er) {}
-var GLOBSTAR$1 = minimatch$3.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
-var expand$3 = braceExpansion;
+var GLOBSTAR = minimatch$3.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
+var expand$1 = braceExpansion;
var plTypes = {
'!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
@@ -10893,7 +23587,7 @@ var plTypes = {
var qmark = '[^/]';
// * => any number of characters
-var star$3 = qmark + '*?';
+var star = qmark + '*?';
// ** when dots are allowed. Anything goes, except .. and .
// not (^ or / followed by one or two dots followed by $ or /),
@@ -10991,8 +23685,8 @@ function Minimatch$1 (pattern, options) {
pattern = pattern.trim();
// windows support: need to use /, not \
- if (path$d.sep !== '/') {
- pattern = pattern.split(path$d.sep).join('/');
+ if (path$4.sep !== '/') {
+ pattern = pattern.split(path$4.sep).join('/');
}
this.options = options;
@@ -11123,7 +23817,7 @@ function braceExpand (pattern, options) {
return [pattern]
}
- return expand$3(pattern)
+ return expand$1(pattern)
}
// parse a component of the expanded set.
@@ -11137,9 +23831,9 @@ function braceExpand (pattern, options) {
// 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$1.prototype.parse = parse$b;
+Minimatch$1.prototype.parse = parse$3;
var SUBPARSE = {};
-function parse$b (pattern, isSub) {
+function parse$3 (pattern, isSub) {
if (pattern.length > 1024 * 64) {
throw new TypeError('pattern is too long')
}
@@ -11147,7 +23841,7 @@ function parse$b (pattern, isSub) {
var options = this.options;
// shortcuts
- if (!options.noglobstar && pattern === '**') return GLOBSTAR$1
+ if (!options.noglobstar && pattern === '**') return GLOBSTAR
if (pattern === '') return ''
var re = '';
@@ -11174,7 +23868,7 @@ function parse$b (pattern, isSub) {
// that wasn't consumed by this pass.
switch (stateChar) {
case '*':
- re += star$3;
+ re += star;
hasMagic = true;
break
case '?':
@@ -11408,7 +24102,7 @@ function parse$b (pattern, isSub) {
});
this.debug('tail=%j\n %s', tail, tail, pl, re);
- var t = pl.type === '*' ? star$3
+ var t = pl.type === '*' ? star
: pl.type === '?' ? qmark
: '\\' + pl.type;
@@ -11527,14 +24221,14 @@ function makeRe () {
}
var options = this.options;
- var twoStar = options.noglobstar ? star$3
+ 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$1) ? twoStar
+ return (p === GLOBSTAR) ? twoStar
: (typeof p === 'string') ? regExpEscape(p)
: p._src
}).join('\\\/')
@@ -11580,8 +24274,8 @@ function match (f, partial) {
var options = this.options;
// windows: need to use /, not \
- if (path$d.sep !== '/') {
- f = f.split(path$d.sep).join('/');
+ if (path$4.sep !== '/') {
+ f = f.split(path$4.sep).join('/');
}
// treat the test path as a set of pathparts.
@@ -11652,7 +24346,7 @@ Minimatch$1.prototype.matchOne = function (file, pattern, partial) {
// some invalid regexp stuff in the set.
if (p === false) return false
- if (p === GLOBSTAR$1) {
+ if (p === GLOBSTAR) {
this.debug('GLOBSTAR', [pattern, p, f]);
// "**"
@@ -11793,7 +24487,7 @@ function regExpEscape (s) {
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
}
-var inherits$3 = {exports: {}};
+var inherits$2 = {exports: {}};
var inherits_browser = {exports: {}};
@@ -11826,13 +24520,13 @@ if (typeof Object.create === 'function') {
}
try {
- var util$3 = require$$0__default['default'];
+ var util$1 = require$$0$4;
/* istanbul ignore next */
- if (typeof util$3.inherits !== 'function') throw '';
- inherits$3.exports = util$3.inherits;
+ if (typeof util$1.inherits !== 'function') throw '';
+ inherits$2.exports = util$1.inherits;
} catch (e) {
/* istanbul ignore next */
- inherits$3.exports = inherits_browser.exports;
+ inherits$2.exports = inherits_browser.exports;
}
var pathIsAbsolute = {exports: {}};
@@ -11856,27 +24550,33 @@ pathIsAbsolute.exports = process.platform === 'win32' ? win32 : posix;
pathIsAbsolute.exports.posix = posix;
pathIsAbsolute.exports.win32 = win32;
-var common$3 = {};
+var common$2 = {};
-common$3.setopts = setopts$2;
-common$3.ownProp = ownProp$2;
-common$3.makeAbs = makeAbs;
-common$3.finish = finish;
-common$3.mark = mark;
-common$3.isIgnored = isIgnored$2;
-common$3.childrenIgnored = childrenIgnored$2;
+common$2.alphasort = alphasort;
+common$2.alphasorti = alphasorti;
+common$2.setopts = setopts$2;
+common$2.ownProp = ownProp$2;
+common$2.makeAbs = makeAbs;
+common$2.finish = finish;
+common$2.mark = mark;
+common$2.isIgnored = isIgnored$2;
+common$2.childrenIgnored = childrenIgnored$2;
function ownProp$2 (obj, field) {
return Object.prototype.hasOwnProperty.call(obj, field)
}
-var path$c = require$$0__default$2['default'];
+var path$3 = path$b;
var minimatch$2 = minimatch_1;
var isAbsolute$2 = pathIsAbsolute.exports;
var Minimatch = minimatch$2.Minimatch;
+function alphasorti (a, b) {
+ return a.toLowerCase().localeCompare(b.toLowerCase())
+}
+
function alphasort (a, b) {
- return a.localeCompare(b, 'en')
+ return a.localeCompare(b)
}
function setupIgnores (self, options) {
@@ -11948,12 +24648,12 @@ function setopts$2 (self, pattern, options) {
if (!ownProp$2(options, "cwd"))
self.cwd = cwd;
else {
- self.cwd = path$c.resolve(options.cwd);
+ self.cwd = path$3.resolve(options.cwd);
self.changedCwd = self.cwd !== cwd;
}
- self.root = options.root || path$c.resolve(self.cwd, "/");
- self.root = path$c.resolve(self.root);
+ self.root = options.root || path$3.resolve(self.cwd, "/");
+ self.root = path$3.resolve(self.root);
if (process.platform === "win32")
self.root = self.root.replace(/\\/g, "/");
@@ -12004,7 +24704,7 @@ function finish (self) {
all = Object.keys(all);
if (!self.nosort)
- all = all.sort(alphasort);
+ all = all.sort(self.nocase ? alphasorti : alphasort);
// at *some* point we statted all of these
if (self.mark) {
@@ -12057,13 +24757,13 @@ function mark (self, p) {
function makeAbs (self, f) {
var abs = f;
if (f.charAt(0) === '/') {
- abs = path$c.join(self.root, f);
+ abs = path$3.join(self.root, f);
} else if (isAbsolute$2(f) || f === '') {
abs = f;
} else if (self.changedCwd) {
- abs = path$c.resolve(self.cwd, f);
+ abs = path$3.resolve(self.cwd, f);
} else {
- abs = path$c.resolve(f);
+ abs = path$3.resolve(f);
}
if (process.platform === 'win32')
@@ -12093,20 +24793,22 @@ function childrenIgnored$2 (self, path) {
})
}
-var sync$3 = globSync$1;
+var sync$1 = globSync$1;
globSync$1.GlobSync = GlobSync$1;
-var fs$c = require$$0__default$3['default'];
+var fs$1 = require$$0$3;
var rp$1 = fs_realpath;
var minimatch$1 = minimatch_1;
-var path$b = require$$0__default$2['default'];
-var assert$1 = require$$5__default['default'];
+var path$2 = path$b;
+var assert$1 = assert$2;
var isAbsolute$1 = pathIsAbsolute.exports;
-var common$2 = common$3;
-var setopts$1 = common$2.setopts;
-var ownProp$1 = common$2.ownProp;
-var childrenIgnored$1 = common$2.childrenIgnored;
-var isIgnored$1 = common$2.isIgnored;
+var common$1 = common$2;
+common$1.alphasort;
+common$1.alphasorti;
+var setopts$1 = common$1.setopts;
+var ownProp$1 = common$1.ownProp;
+var childrenIgnored$1 = common$1.childrenIgnored;
+var isIgnored$1 = common$1.isIgnored;
function globSync$1 (pattern, options) {
if (typeof options === 'function' || arguments.length === 3)
@@ -12160,7 +24862,7 @@ GlobSync$1.prototype._finish = function () {
}
});
}
- common$2.finish(this);
+ common$1.finish(this);
};
@@ -12276,7 +24978,7 @@ GlobSync$1.prototype._processReaddir = function (prefix, read, abs, remain, inde
}
if (e.charAt(0) === '/' && !this.nomount) {
- e = path$b.join(this.root, e);
+ e = path$2.join(this.root, e);
}
this._emitMatch(index, e);
}
@@ -12337,7 +25039,7 @@ GlobSync$1.prototype._readdirInGlobStar = function (abs) {
var entries;
var lstat;
try {
- lstat = fs$c.lstatSync(abs);
+ lstat = fs$1.lstatSync(abs);
} catch (er) {
if (er.code === 'ENOENT') {
// lstat failed, doesn't exist
@@ -12373,7 +25075,7 @@ GlobSync$1.prototype._readdir = function (abs, inGlobStar) {
}
try {
- return this._readdirEntries(abs, fs$c.readdirSync(abs))
+ return this._readdirEntries(abs, fs$1.readdirSync(abs))
} catch (er) {
this._readdirError(abs, er);
return null
@@ -12487,9 +25189,9 @@ GlobSync$1.prototype._processSimple = function (prefix, index) {
if (prefix && isAbsolute$1(prefix) && !this.nomount) {
var trail = /[\/\\]$/.test(prefix);
if (prefix.charAt(0) === '/') {
- prefix = path$b.join(this.root, prefix);
+ prefix = path$2.join(this.root, prefix);
} else {
- prefix = path$b.resolve(this.root, prefix);
+ prefix = path$2.resolve(this.root, prefix);
if (trail)
prefix += '/';
}
@@ -12530,7 +25232,7 @@ GlobSync$1.prototype._stat = function (f) {
if (!stat) {
var lstat;
try {
- lstat = fs$c.lstatSync(abs);
+ lstat = fs$1.lstatSync(abs);
} catch (er) {
if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
this.statCache[abs] = false;
@@ -12540,7 +25242,7 @@ GlobSync$1.prototype._stat = function (f) {
if (lstat && lstat.isSymbolicLink()) {
try {
- stat = fs$c.statSync(abs);
+ stat = fs$1.statSync(abs);
} catch (er) {
stat = lstat;
}
@@ -12564,11 +25266,11 @@ GlobSync$1.prototype._stat = function (f) {
};
GlobSync$1.prototype._mark = function (p) {
- return common$2.mark(this, p)
+ return common$1.mark(this, p)
};
GlobSync$1.prototype._makeAbs = function (f) {
- return common$2.makeAbs(this, f)
+ return common$1.makeAbs(this, f)
};
// Returns a wrapper function that returns a wrapped callback
@@ -12670,7 +25372,7 @@ function makeres (key) {
return once$1(function RES () {
var cbs = reqs[key];
var len = cbs.length;
- var args = slice$2(arguments);
+ var args = slice$1(arguments);
// XXX It's somewhat ambiguous whether a new callback added in this
// pass should be queued for later execution if something in the
@@ -12697,7 +25399,7 @@ function makeres (key) {
})
}
-function slice$2 (args) {
+function slice$1 (args) {
var length = args.length;
var array = [];
@@ -12745,27 +25447,29 @@ function slice$2 (args) {
// `true` for files, and [children,...] for directories, or `false` for
// things that don't exist.
-var glob_1 = glob$1;
+var glob_1 = glob;
-var fs$b = require$$0__default$3['default'];
+var fs = require$$0$3;
var rp = fs_realpath;
var minimatch = minimatch_1;
-var inherits$2 = inherits$3.exports;
-var EE = require$$0__default$4['default'].EventEmitter;
-var path$a = require$$0__default$2['default'];
-var assert = require$$5__default['default'];
+var inherits$1 = inherits$2.exports;
+var EE = require$$0$5.EventEmitter;
+var path$1 = path$b;
+var assert = assert$2;
var isAbsolute = pathIsAbsolute.exports;
-var globSync = sync$3;
-var common$1 = common$3;
-var setopts = common$1.setopts;
-var ownProp = common$1.ownProp;
+var globSync = sync$1;
+var common = common$2;
+common.alphasort;
+common.alphasorti;
+var setopts = common.setopts;
+var ownProp = common.ownProp;
var inflight = inflight_1;
-var childrenIgnored = common$1.childrenIgnored;
-var isIgnored = common$1.isIgnored;
+var childrenIgnored = common.childrenIgnored;
+var isIgnored = common.isIgnored;
var once = once$3.exports;
-function glob$1 (pattern, options, cb) {
+function glob (pattern, options, cb) {
if (typeof options === 'function') cb = options, options = {};
if (!options) options = {};
@@ -12778,13 +25482,13 @@ function glob$1 (pattern, options, cb) {
return new Glob(pattern, options, cb)
}
-glob$1.sync = globSync;
-var GlobSync = glob$1.GlobSync = globSync.GlobSync;
+glob.sync = globSync;
+var GlobSync = glob.GlobSync = globSync.GlobSync;
// old api surface
-glob$1.glob = glob$1;
+glob.glob = glob;
-function extend$3 (origin, add) {
+function extend$1 (origin, add) {
if (add === null || typeof add !== 'object') {
return origin
}
@@ -12797,8 +25501,8 @@ function extend$3 (origin, add) {
return origin
}
-glob$1.hasMagic = function (pattern, options_) {
- var options = extend$3({}, options_);
+glob.hasMagic = function (pattern, options_) {
+ var options = extend$1({}, options_);
options.noprocess = true;
var g = new Glob(pattern, options);
@@ -12818,8 +25522,8 @@ glob$1.hasMagic = function (pattern, options_) {
return false
};
-glob$1.Glob = Glob;
-inherits$2(Glob, EE);
+glob.Glob = Glob;
+inherits$1(Glob, EE);
function Glob (pattern, options, cb) {
if (typeof options === 'function') {
cb = options;
@@ -12896,7 +25600,7 @@ Glob.prototype._finish = function () {
if (this.realpath && !this._didRealpath)
return this._realpath()
- common$1.finish(this);
+ common.finish(this);
this.emit('end', this.found);
};
@@ -12955,11 +25659,11 @@ Glob.prototype._realpathSet = function (index, cb) {
};
Glob.prototype._mark = function (p) {
- return common$1.mark(this, p)
+ return common.mark(this, p)
};
Glob.prototype._makeAbs = function (f) {
- return common$1.makeAbs(this, f)
+ return common.makeAbs(this, f)
};
Glob.prototype.abort = function () {
@@ -13129,7 +25833,7 @@ Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, in
}
if (e.charAt(0) === '/' && !this.nomount) {
- e = path$a.join(this.root, e);
+ e = path$1.join(this.root, e);
}
this._emitMatch(index, e);
}
@@ -13205,7 +25909,7 @@ Glob.prototype._readdirInGlobStar = function (abs, cb) {
var lstatcb = inflight(lstatkey, lstatcb_);
if (lstatcb)
- fs$b.lstat(abs, lstatcb);
+ fs.lstat(abs, lstatcb);
function lstatcb_ (er, lstat) {
if (er && er.code === 'ENOENT')
@@ -13244,7 +25948,7 @@ Glob.prototype._readdir = function (abs, inGlobStar, cb) {
if (Array.isArray(c))
return cb(null, c)
}
- fs$b.readdir(abs, readdirCb(this, abs, cb));
+ fs.readdir(abs, readdirCb(this, abs, cb));
};
function readdirCb (self, abs, cb) {
@@ -13390,9 +26094,9 @@ Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
if (prefix && isAbsolute(prefix) && !this.nomount) {
var trail = /[\/\\]$/.test(prefix);
if (prefix.charAt(0) === '/') {
- prefix = path$a.join(this.root, prefix);
+ prefix = path$1.join(this.root, prefix);
} else {
- prefix = path$a.resolve(this.root, prefix);
+ prefix = path$1.resolve(this.root, prefix);
if (trail)
prefix += '/';
}
@@ -13446,13 +26150,13 @@ Glob.prototype._stat = function (f, cb) {
var self = this;
var statcb = inflight('stat\0' + abs, lstatcb_);
if (statcb)
- fs$b.lstat(abs, 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$b.stat(abs, function (er, stat) {
+ return fs.stat(abs, function (er, stat) {
if (er)
self._stat2(f, abs, null, lstat, cb);
else
@@ -13499,597 +26203,915 @@ var isBuffer = function isBuffer (obj) {
typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
};
-var own$e = {}.hasOwnProperty;
+const proc$1 = process;
-var unistUtilStringifyPosition = stringify$e;
+var own$b = {}.hasOwnProperty;
-function stringify$e(value) {
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ */
+
+/**
+ * Stringify one point, a position (start and end points), or a node’s
+ * positional information.
+ *
+ * @param {Node|Position|Point} [value]
+ * @returns {string}
+ */
+function stringifyPosition$1(value) {
// Nothing.
if (!value || typeof value !== 'object') {
return ''
}
// Node.
- if (own$e.call(value, 'position') || own$e.call(value, 'type')) {
- return position$4(value.position)
+ if (own$b.call(value, 'position') || own$b.call(value, 'type')) {
+ // @ts-ignore looks like a node.
+ return position(value.position)
}
// Position.
- if (own$e.call(value, 'start') || own$e.call(value, 'end')) {
- return position$4(value)
+ if (own$b.call(value, 'start') || own$b.call(value, 'end')) {
+ // @ts-ignore looks like a position.
+ return position(value)
}
// Point.
- if (own$e.call(value, 'line') || own$e.call(value, 'column')) {
- return point$3(value)
+ if (own$b.call(value, 'line') || own$b.call(value, 'column')) {
+ // @ts-ignore looks like a point.
+ return point$1(value)
}
// ?
return ''
}
-function point$3(point) {
- if (!point || typeof point !== 'object') {
- point = {};
- }
-
- return index$2(point.line) + ':' + index$2(point.column)
+/**
+ * @param {Point} point
+ * @returns {string}
+ */
+function point$1(point) {
+ return index$1(point && point.line) + ':' + index$1(point && point.column)
}
-function position$4(pos) {
- if (!pos || typeof pos !== 'object') {
- pos = {};
- }
-
- return point$3(pos.start) + '-' + point$3(pos.end)
+/**
+ * @param {Position} pos
+ * @returns {string}
+ */
+function position(pos) {
+ return point$1(pos && pos.start) + '-' + point$1(pos && pos.end)
}
-function index$2(value) {
+/**
+ * @param {number} value
+ * @returns {number}
+ */
+function index$1(value) {
return value && typeof value === 'number' ? value : 1
}
-var stringify$d = unistUtilStringifyPosition;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ */
-var vfileMessage$1 = VMessage$3;
+class VFileMessage extends Error {
+ /**
+ * Constructor of a message for `reason` at `place` from `origin`.
+ * When an error is passed in as `reason`, copies the `stack`.
+ *
+ * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+ * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+ * @param {string} [origin] Place in code the message originates from (`string`, optional).
+ */
+ constructor(reason, place, origin) {
+ /** @type {[string?, string?]} */
+ var parts = [null, null];
+ /** @type {Position} */
+ var position = {
+ start: {line: null, column: null},
+ end: {line: null, column: null}
+ };
+ /** @type {number} */
+ var index;
-// Inherit from `Error#`.
-function VMessagePrototype$1() {}
-VMessagePrototype$1.prototype = Error.prototype;
-VMessage$3.prototype = new VMessagePrototype$1();
+ super();
-// Message properties.
-var proto$2 = VMessage$3.prototype;
+ if (typeof place === 'string') {
+ origin = place;
+ place = null;
+ }
-proto$2.file = '';
-proto$2.name = '';
-proto$2.reason = '';
-proto$2.message = '';
-proto$2.stack = '';
-proto$2.fatal = null;
-proto$2.column = null;
-proto$2.line = null;
+ if (typeof origin === 'string') {
+ index = origin.indexOf(':');
-// 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$3(reason, position, origin) {
- var parts;
- var range;
- var location;
+ if (index === -1) {
+ parts[1] = origin;
+ } else {
+ parts[0] = origin.slice(0, index);
+ parts[1] = origin.slice(index + 1);
+ }
+ }
- if (typeof position === 'string') {
- origin = position;
- position = null;
- }
+ if (place) {
+ // Node.
+ if ('type' in place || 'position' in place) {
+ if (place.position) {
+ position = place.position;
+ }
+ }
+ // Position.
+ else if ('start' in place || 'end' in place) {
+ // @ts-ignore Looks like a position.
+ position = place;
+ }
+ // Point.
+ else if ('line' in place || 'column' in place) {
+ // @ts-ignore Looks like a point.
+ position.start = place;
+ }
+ }
- parts = parseOrigin$1(origin);
- range = stringify$d(position) || '1:1';
+ // Fields from `Error`
+ this.name = stringifyPosition$1(place) || '1:1';
+ this.message = typeof reason === 'object' ? reason.message : reason;
+ this.stack = typeof reason === 'object' ? reason.stack : '';
- location = {
- start: {line: null, column: null},
- end: {line: null, column: null}
- };
+ /**
+ * Reason for message.
+ * @type {string}
+ */
+ this.reason = this.message;
+ /**
+ * Starting line of error.
+ * @type {number?}
+ */
+ this.line = position.start.line;
+ /**
+ * Starting column of error.
+ * @type {number?}
+ */
+ this.column = position.start.column;
+ /**
+ * Namespace of warning.
+ * @type {string?}
+ */
+ this.source = parts[0];
+ /**
+ * Category of message.
+ * @type {string?}
+ */
+ this.ruleId = parts[1];
+ /**
+ * Full range information, when available.
+ * Has start and end properties, both set to an object with line and column, set to number?.
+ * @type {Position?}
+ */
+ this.position = position;
- // Node.
- if (position && position.position) {
- position = position.position;
- }
+ // The following fields are “well known”.
+ // Not standard.
+ // Feel free to add other non-standard fields to your messages.
- if (position) {
- // Position.
- if (position.start) {
- location = position;
- position = position.start;
- } else {
- // Point.
- location.start = position;
- }
+ /* eslint-disable no-unused-expressions */
+ /**
+ * You may add a file property with a path of a file (used throughout the VFile ecosystem).
+ * @type {string?}
+ */
+ this.file;
+ /**
+ * If true, marks associated file as no longer processable.
+ * @type {boolean?}
+ */
+ this.fatal;
+ /**
+ * You may add a url property with a link to documentation for the message.
+ * @type {string?}
+ */
+ this.url;
+ /**
+ * You may add a note property with a long form description of the message (supported by vfile-reporter).
+ * @type {string?}
+ */
+ this.note;
+ /* eslint-enable no-unused-expressions */
}
+}
- if (reason.stack) {
- this.stack = reason.stack;
- reason = reason.message;
- }
+VFileMessage.prototype.file = '';
+VFileMessage.prototype.name = '';
+VFileMessage.prototype.reason = '';
+VFileMessage.prototype.message = '';
+VFileMessage.prototype.stack = '';
+VFileMessage.prototype.fatal = null;
+VFileMessage.prototype.column = null;
+VFileMessage.prototype.line = null;
+VFileMessage.prototype.source = null;
+VFileMessage.prototype.ruleId = null;
+VFileMessage.prototype.position = null;
- 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];
-}
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Position} Position
+ * @typedef {import('unist').Point} Point
+ *
+ * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'latin1'|'binary'|'hex'} BufferEncoding
+ * Encodings supported by the buffer class.
+ * This is a copy of the typing from Node, copied to prevent Node globals from
+ * being needed.
+ * Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/a2bc1d8/types/node/globals.d.ts#L174>
+ *
+ * @typedef {string|Uint8Array} VFileValue Contents of the file.
+ * Can either be text, or a Buffer like structure.
+ * This does not directly use type `Buffer`, because it can also be used in a
+ * browser context.
+ * Instead this leverages `Uint8Array` which is the base type for `Buffer`,
+ * and a native JavaScript construct.
+ *
+ * @typedef {VFileValue|VFileOptions|VFile} VFileCompatible Things that can be
+ * passed to the constructor.
+ *
+ * @typedef VFileCoreOptions
+ * @property {VFileValue} [value]
+ * @property {string} [cwd]
+ * @property {Array.<string>} [history]
+ * @property {string} [path]
+ * @property {string} [basename]
+ * @property {string} [stem]
+ * @property {string} [extname]
+ * @property {string} [dirname]
+ * @property {Object.<string, unknown>} [data]
+ *
+ * @typedef {{[key: string]: unknown} & VFileCoreOptions} VFileOptions
+ * Configuration: a bunch of keys that will be shallow copied over to the new
+ * file.
+ *
+ * @typedef {Object.<string, unknown>} VFileReporterSettings
+ * @typedef {<T = VFileReporterSettings>(files: VFile[], options: T) => string} VFileReporter
+ */
-function parseOrigin$1(origin) {
- var result = [null, null];
- var index;
+// 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'];
- if (typeof origin === 'string') {
- index = origin.indexOf(':');
+class VFile {
+ /**
+ * Create a new virtual file.
+ *
+ * If `options` is `string` or `Buffer`, treats it as `{value: options}`.
+ * If `options` is a `VFile`, shallow copies its data over to the new file.
+ * All other given fields are set on the newly created `VFile`.
+ *
+ * Path related properties are set in the following order (least specific to
+ * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+ * `dirname`.
+ *
+ * It’s not possible to set either `dirname` or `extname` without setting
+ * either `history`, `path`, `basename`, or `stem` as well.
+ *
+ * @param {VFileCompatible} [value]
+ */
+ constructor(value) {
+ var index = -1;
+ /** @type {VFileOptions} */
+ var options;
+ /** @type {string} */
+ var prop;
- if (index === -1) {
- result[1] = origin;
+ if (!value) {
+ options = {};
+ } else if (typeof value === 'string' || isBuffer(value)) {
+ // @ts-ignore Looks like a buffer.
+ options = {value};
} else {
- result[0] = origin.slice(0, index);
- result[1] = origin.slice(index + 1);
+ // @ts-ignore Looks like file or options.
+ options = value;
}
- }
-
- return result
-}
-var minpath$1 = require$$0__default$2['default'];
+ /**
+ * Place to store custom information.
+ * It’s OK to store custom data directly on the file, moving it to `data`
+ * gives a little more privacy.
+ * @type {Object.<string, unknown>}
+ */
+ this.data = {};
-var minproc$1 = process;
+ /**
+ * List of messages associated with the file.
+ * @type {Array.<VFileMessage>}
+ */
+ this.messages = [];
-var p$1 = minpath$1;
-var proc$2 = minproc$1;
-var buffer$5 = isBuffer;
+ /**
+ * List of file paths the file moved between.
+ * @type {Array.<string>}
+ */
+ this.history = [];
-var core$3 = VFile$3;
+ /**
+ * Base of `path`.
+ * Defaults to `process.cwd()` (`/` in browsers).
+ * @type {string}
+ */
+ this.cwd = proc$1.cwd();
-var own$d = {}.hasOwnProperty;
+ /* eslint-disable no-unused-expressions */
+ /**
+ * Raw value.
+ * @type {VFileValue}
+ */
+ this.value;
-// 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$4 = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
+ // The below are non-standard, they are “well-known”.
+ // As in, used in several tools.
-VFile$3.prototype.toString = toString$9;
+ /**
+ * Whether a file was saved to disk.
+ * This is used by vfile reporters.
+ * @type {boolean}
+ */
+ this.stored;
-// Access full path (`~/index.min.js`).
-Object.defineProperty(VFile$3.prototype, 'path', {get: getPath$1, set: setPath$1});
+ /**
+ * Sometimes files have a non-string representation.
+ * This can be stored in the `result` field.
+ * One example is when turning markdown into React nodes.
+ * This is used by unified to store non-string results.
+ * @type {unknown}
+ */
+ this.result;
+ /* eslint-enable no-unused-expressions */
-// Access parent path (`~`).
-Object.defineProperty(VFile$3.prototype, 'dirname', {
- get: getDirname$1,
- set: setDirname$1
-});
+ // Set path related properties in the correct order.
+ while (++index < order.length) {
+ prop = order[index];
-// Access basename (`index.min.js`).
-Object.defineProperty(VFile$3.prototype, 'basename', {
- get: getBasename$1,
- set: setBasename$1
-});
+ // Note: we specifically use `in` instead of `hasOwnProperty` to accept
+ // `vfile`s too.
+ if (prop in options && options[prop] !== undefined) {
+ this[prop] = prop === 'history' ? options[prop].concat() : options[prop];
+ }
+ }
-// Access extname (`.js`).
-Object.defineProperty(VFile$3.prototype, 'extname', {
- get: getExtname$1,
- set: setExtname$1
-});
+ // Set non-path related properties.
+ for (prop in options) {
+ if (!order.includes(prop)) {
+ this[prop] = options[prop];
+ }
+ }
+ }
-// Access stem (`index.min`).
-Object.defineProperty(VFile$3.prototype, 'stem', {get: getStem$1, set: setStem$1});
+ /**
+ * Access full path (`~/index.min.js`).
+ */
+ get path() {
+ return this.history[this.history.length - 1]
+ }
-// Construct a new file.
-function VFile$3(options) {
- var prop;
- var index;
+ /**
+ * Set full path (`~/index.min.js`).
+ * Cannot be nullified.
+ */
+ set path(path) {
+ assertNonEmpty(path, 'path');
- if (!options) {
- options = {};
- } else if (typeof options === 'string' || buffer$5(options)) {
- options = {contents: options};
- } else if ('message' in options && 'messages' in options) {
- return options
+ if (this.path !== path) {
+ this.history.push(path);
+ }
}
- if (!(this instanceof VFile$3)) {
- return new VFile$3(options)
+ /**
+ * Access parent path (`~`).
+ */
+ get dirname() {
+ return typeof this.path === 'string' ? path$b.dirname(this.path) : undefined
}
- this.data = {};
- this.messages = [];
- this.history = [];
- this.cwd = proc$2.cwd();
+ /**
+ * Set parent path (`~`).
+ * Cannot be set if there's no `path` yet.
+ */
+ set dirname(dirname) {
+ assertPath(this.path, 'dirname');
+ this.path = path$b.join(dirname || '', this.basename);
+ }
- // Set path related properties in the correct order.
- index = -1;
+ /**
+ * Access basename (including extname) (`index.min.js`).
+ */
+ get basename() {
+ return typeof this.path === 'string' ? path$b.basename(this.path) : undefined
+ }
- while (++index < order$4.length) {
- prop = order$4[index];
+ /**
+ * Set basename (`index.min.js`).
+ * Cannot contain path separators.
+ * Cannot be nullified either (use `file.path = file.dirname` instead).
+ */
+ set basename(basename) {
+ assertNonEmpty(basename, 'basename');
+ assertPart(basename, 'basename');
+ this.path = path$b.join(this.dirname || '', basename);
+ }
- if (own$d.call(options, prop)) {
- this[prop] = options[prop];
- }
+ /**
+ * Access extname (including dot) (`.js`).
+ */
+ get extname() {
+ return typeof this.path === 'string' ? path$b.extname(this.path) : undefined
}
- // Set non-path related properties.
- for (prop in options) {
- if (order$4.indexOf(prop) < 0) {
- this[prop] = options[prop];
+ /**
+ * Set extname (including dot) (`.js`).
+ * Cannot be set if there's no `path` yet and cannot contain path separators.
+ */
+ set extname(extname) {
+ assertPart(extname, 'extname');
+ assertPath(this.path, 'extname');
+
+ if (extname) {
+ if (extname.charCodeAt(0) !== 46 /* `.` */) {
+ throw new Error('`extname` must start with `.`')
+ }
+
+ if (extname.includes('.', 1)) {
+ throw new Error('`extname` cannot contain multiple dots')
+ }
}
+
+ this.path = path$b.join(this.dirname, this.stem + (extname || ''));
}
-}
-function getPath$1() {
- return this.history[this.history.length - 1]
-}
+ /**
+ * Access stem (w/o extname) (`index.min`).
+ */
+ get stem() {
+ return typeof this.path === 'string'
+ ? path$b.basename(this.path, this.extname)
+ : undefined
+ }
-function setPath$1(path) {
- assertNonEmpty$1(path, 'path');
+ /**
+ * Set stem (w/o extname) (`index.min`).
+ * Cannot be nullified, and cannot contain path separators.
+ */
+ set stem(stem) {
+ assertNonEmpty(stem, 'stem');
+ assertPart(stem, 'stem');
+ this.path = path$b.join(this.dirname || '', stem + (this.extname || ''));
+ }
- if (this.path !== path) {
- this.history.push(path);
+ /**
+ * Serialize the file.
+ *
+ * @param {BufferEncoding} [encoding='utf8'] If `file.value` is a buffer, `encoding` is used to serialize buffers.
+ * @returns {string}
+ */
+ toString(encoding) {
+ // @ts-ignore string’s don’t accept the parameter, but buffers do.
+ return (this.value || '').toString(encoding)
}
-}
-function getDirname$1() {
- return typeof this.path === 'string' ? p$1.dirname(this.path) : undefined
-}
+ /**
+ * Create a message and associates it w/ the file.
+ *
+ * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+ * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+ * @param {string} [origin] Place in code the message originates from (`string`, optional).
+ * @returns {VFileMessage}
+ */
+ message(reason, place, origin) {
+ var message = new VFileMessage(reason, place, origin);
-function setDirname$1(dirname) {
- assertPath$1(this.path, 'dirname');
- this.path = p$1.join(dirname || '', this.basename);
-}
+ if (this.path) {
+ message.name = this.path + ':' + message.name;
+ message.file = this.path;
+ }
-function getBasename$1() {
- return typeof this.path === 'string' ? p$1.basename(this.path) : undefined
-}
+ message.fatal = false;
-function setBasename$1(basename) {
- assertNonEmpty$1(basename, 'basename');
- assertPart$1(basename, 'basename');
- this.path = p$1.join(this.dirname || '', basename);
-}
+ this.messages.push(message);
-function getExtname$1() {
- return typeof this.path === 'string' ? p$1.extname(this.path) : undefined
-}
+ return message
+ }
-function setExtname$1(extname) {
- assertPart$1(extname, 'extname');
- assertPath$1(this.path, 'extname');
+ /**
+ * Info: create a message, associate it with the file, and mark the fatality
+ * as `null`.
+ * Calls `message()` internally.
+ *
+ * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+ * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+ * @param {string} [origin] Place in code the message originates from (`string`, optional).
+ * @returns {VFileMessage}
+ */
+ info(reason, place, origin) {
+ var message = this.message(reason, place, origin);
- if (extname) {
- if (extname.charCodeAt(0) !== 46 /* `.` */) {
- throw new Error('`extname` must start with `.`')
- }
+ message.fatal = null;
- if (extname.indexOf('.', 1) > -1) {
- throw new Error('`extname` cannot contain multiple dots')
- }
+ return message
}
- this.path = p$1.join(this.dirname, this.stem + (extname || ''));
-}
-
-function getStem$1() {
- return typeof this.path === 'string'
- ? p$1.basename(this.path, this.extname)
- : undefined
-}
+ /**
+ * Fail: create a message, associate it with the file, mark the fatality as
+ * `true`.
+ * Note: fatal errors mean a file is no longer processable.
+ * Calls `message()` internally.
+ *
+ * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
+ * @param {Node|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
+ * @param {string} [origin] Place in code the message originates from (`string`, optional).
+ * @returns {never}
+ */
+ fail(reason, place, origin) {
+ var message = this.message(reason, place, origin);
-function setStem$1(stem) {
- assertNonEmpty$1(stem, 'stem');
- assertPart$1(stem, 'stem');
- this.path = p$1.join(this.dirname || '', stem + (this.extname || ''));
-}
+ message.fatal = true;
-// Get the value of the file.
-function toString$9(encoding) {
- return (this.contents || '').toString(encoding)
+ throw message
+ }
}
-// Assert that `part` is not a path (i.e., does not contain `p.sep`).
-function assertPart$1(part, name) {
- if (part && part.indexOf(p$1.sep) > -1) {
+/**
+ * Assert that `part` is not a path (as in, does not contain `path.sep`).
+ *
+ * @param {string} part
+ * @param {string} name
+ * @returns {void}
+ */
+function assertPart(part, name) {
+ if (part && part.includes(path$b.sep)) {
throw new Error(
- '`' + name + '` cannot be a path: did not expect `' + p$1.sep + '`'
+ '`' + name + '` cannot be a path: did not expect `' + path$b.sep + '`'
)
}
}
-// Assert that `part` is not empty.
-function assertNonEmpty$1(part, name) {
+/**
+ * Assert that `part` is not empty.
+ *
+ * @param {string} part
+ * @param {string} name
+ * @returns {void}
+ */
+function assertNonEmpty(part, name) {
if (!part) {
throw new Error('`' + name + '` cannot be empty')
}
}
-// Assert `path` exists.
-function assertPath$1(path, name) {
+/**
+ * Assert `path` exists.
+ *
+ * @param {string} path
+ * @param {string} name
+ * @returns {void}
+ */
+function assertPath(path, name) {
if (!path) {
throw new Error('Setting `' + name + '` requires `path` to be set too')
}
}
-var VMessage$2 = vfileMessage$1;
-var VFile$2 = core$3;
-
-var lib$6 = VFile$2;
-
-VFile$2.prototype.message = message$1;
-VFile$2.prototype.info = info$1;
-VFile$2.prototype.fail = fail$2;
-
-// 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 message = new VMessage$2(reason, position, origin);
-
- if (this.path) {
- message.name = this.path + ':' + message.name;
- message.file = this.path;
- }
-
- message.fatal = false;
-
- this.messages.push(message);
-
- return message
-}
-
-// Fail: creates a vmessage, associates it with the file, and throws it.
-function fail$2() {
- var message = this.message.apply(this, arguments);
-
- message.fatal = true;
-
- throw message
-}
-
-// Info: creates a vmessage, associates it with the file, and marks the fatality
-// as null.
-function info$1() {
- var message = this.message.apply(this, arguments);
-
- message.fatal = null;
-
- return message
-}
-
-var vfile$9 = lib$6;
-
-var buffer$4 = isBuffer;
-var vfile$8 = vfile$9;
-
-var core$2 = toVFile;
+/**
+ * @typedef {import('vfile').VFileValue} Value
+ * @typedef {import('vfile').VFileOptions} Options
+ * @typedef {import('vfile').BufferEncoding} BufferEncoding
+ *
+ * @typedef {number|string} Mode
+ * @typedef {BufferEncoding|{encoding?: null|BufferEncoding, flag?: string}} ReadOptions
+ * @typedef {BufferEncoding|{encoding?: null|BufferEncoding, mode: Mode?, flag?: string}} WriteOptions
+ *
+ * @typedef {string|Uint8Array} Path Path of the file.
+ * @typedef {Path|URL|Options|VFile} Compatible Things that can be
+ * passed to the function.
+ */
-// 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()`.
+/**
+ * Create a virtual file from a description.
+ * If `options` is a string or a buffer, it’s used as the path.
+ * If it’s a VFile itself, it’s returned instead.
+ * In all other cases, the options are passed through to `vfile()`.
+ *
+ * @param {Compatible} [options]
+ * @returns {VFile}
+ */
function toVFile(options) {
- if (typeof options === 'string' || buffer$4(options)) {
+ if (typeof options === 'string' || isBuffer(options)) {
options = {path: String(options)};
+ } else if (options instanceof URL$1) {
+ options = {path: fileURLToPath(options)};
}
- return vfile$8(options)
+ return looksLikeAVFile$1(options) ? options : new VFile(options)
}
-var sync$2 = {};
-
-var fs$a = require$$0__default$3['default'];
-var path$9 = require$$0__default$2['default'];
-var vfile$7 = core$2;
-
-sync$2.read = readSync;
-sync$2.write = writeSync;
-
-// Create a virtual file and read it in, synchronously.
+/**
+ * Create a virtual file and read it in, synchronously.
+ *
+ * @param {Compatible} description
+ * @param {ReadOptions} [options]
+ * @returns {VFile}
+ */
function readSync(description, options) {
- var file = vfile$7(description);
- file.contents = fs$a.readFileSync(path$9.resolve(file.cwd, file.path), options);
+ var file = toVFile(description);
+ file.value = require$$0$3.readFileSync(path$b.resolve(file.cwd, file.path), options);
return file
}
-// Create a virtual file and write it out, synchronously.
+/**
+ * Create a virtual file and write it in, synchronously.
+ *
+ * @param {Compatible} description
+ * @param {WriteOptions} [options]
+ * @returns {VFile}
+ */
function writeSync(description, options) {
- var file = vfile$7(description);
- fs$a.writeFileSync(
- path$9.resolve(file.cwd, file.path),
- file.contents || '',
- options
- );
+ var file = toVFile(description);
+ require$$0$3.writeFileSync(path$b.resolve(file.cwd, file.path), file.value || '', options);
return file
}
-var async$1 = {};
-
-var fs$9 = require$$0__default$3['default'];
-var path$8 = require$$0__default$2['default'];
-var vfile$6 = core$2;
-
-async$1.read = read$3;
-async$1.write = write;
-
-// Create a virtual file and read it in, asynchronously.
-function read$3(description, options, callback) {
- var file = vfile$6(description);
+const read$2 =
+ /**
+ * @type {{
+ * (description: Compatible, options: ReadOptions, callback: Callback): void
+ * (description: Compatible, callback: Callback): void
+ * (description: Compatible, options?: ReadOptions): Promise<VFile>
+ * }}
+ */
+ (
+ /**
+ * Create a virtual file and read it in, asynchronously.
+ *
+ * @param {Compatible} description
+ * @param {ReadOptions} [options]
+ * @param {Callback} [callback]
+ */
+ function (description, options, callback) {
+ var file = toVFile(description);
- if (!callback && typeof options === 'function') {
- callback = options;
- options = null;
- }
+ if (!callback && typeof options === 'function') {
+ callback = options;
+ options = null;
+ }
- if (!callback) {
- return new Promise(executor)
- }
+ if (!callback) {
+ return new Promise(executor)
+ }
- executor(resolve, callback);
+ executor(resolve, callback);
- function resolve(result) {
- callback(null, result);
- }
+ /**
+ * @param {VFile} result
+ */
+ function resolve(result) {
+ callback(null, result);
+ }
- function executor(resolve, reject) {
- var fp;
+ /**
+ * @param {(x: VFile) => void} resolve
+ * @param {(x: Error, y?: VFile) => void} reject
+ */
+ function executor(resolve, reject) {
+ /** @type {string} */
+ var fp;
- try {
- fp = path$8.resolve(file.cwd, file.path);
- } catch (error) {
- return reject(error)
- }
+ try {
+ fp = path$b.resolve(file.cwd, file.path);
+ } catch (error) {
+ return reject(error)
+ }
- fs$9.readFile(fp, options, done);
+ require$$0$3.readFile(fp, options, done);
- function done(error, res) {
- if (error) {
- reject(error);
- } else {
- file.contents = res;
- resolve(file);
+ /**
+ * @param {Error} error
+ * @param {Value} result
+ */
+ function done(error, result) {
+ if (error) {
+ reject(error);
+ } else {
+ file.value = result;
+ resolve(file);
+ }
+ }
}
}
- }
-}
+ );
-// Create a virtual file and write it out, asynchronously.
-function write(description, options, callback) {
- var file = vfile$6(description);
+const write =
+ /**
+ * @type {{
+ * (description: Compatible, options: WriteOptions, callback: Callback): void
+ * (description: Compatible, callback: Callback): void
+ * (description: Compatible, options?: WriteOptions): Promise<VFile>
+ * }}
+ */
+ (
+ /**
+ * Create a virtual file and write it in, asynchronously.
+ *
+ * @param {Compatible} description
+ * @param {WriteOptions} [options]
+ * @param {Callback} [callback]
+ */
+ function (description, options, callback) {
+ var file = toVFile(description);
- // Weird, right? Otherwise `fs` doesn’t accept it.
- if (!callback && typeof options === 'function') {
- callback = options;
- options = undefined;
- }
+ // Weird, right? Otherwise `fs` doesn’t accept it.
+ if (!callback && typeof options === 'function') {
+ callback = options;
+ options = undefined;
+ }
- if (!callback) {
- return new Promise(executor)
- }
+ if (!callback) {
+ return new Promise(executor)
+ }
- executor(resolve, callback);
+ executor(resolve, callback);
- function resolve(result) {
- callback(null, result);
- }
+ /**
+ * @param {VFile} result
+ */
+ function resolve(result) {
+ callback(null, result);
+ }
- function executor(resolve, reject) {
- var fp;
+ /**
+ * @param {(x: VFile) => void} resolve
+ * @param {(x: Error, y?: VFile) => void} reject
+ */
+ function executor(resolve, reject) {
+ /** @type {string} */
+ var fp;
- try {
- fp = path$8.resolve(file.cwd, file.path);
- } catch (error) {
- return reject(error)
- }
+ try {
+ fp = path$b.resolve(file.cwd, file.path);
+ } catch (error) {
+ return reject(error)
+ }
- fs$9.writeFile(fp, file.contents || '', options, done);
+ require$$0$3.writeFile(fp, file.value || '', options, done);
- function done(error) {
- if (error) {
- reject(error);
- } else {
- resolve(file);
+ /**
+ * @param {Error} error
+ */
+ function done(error) {
+ if (error) {
+ reject(error);
+ } else {
+ resolve(file);
+ }
+ }
}
}
- }
-}
-
-var vfile$5 = core$2;
-var sync$1 = sync$2;
-var async = async$1;
-
-var fs$8 = vfile$5;
-
-vfile$5.read = async.read;
-vfile$5.readSync = sync$1.read;
-vfile$5.write = async.write;
-vfile$5.writeSync = sync$1.write;
-
-var toVfile = fs$8;
+ );
-var path$7 = require$$0__default$2['default'];
-var fs$7 = require$$0__default$3['default'];
-var gitignore = ignore$2;
-var glob = glob_1;
-var vfile$4 = toVfile;
+/**
+ * @param {Compatible} value
+ * @returns {value is VFile}
+ */
+function looksLikeAVFile$1(value) {
+ return (
+ value &&
+ typeof value === 'object' &&
+ 'message' in value &&
+ 'messages' in value
+ )
+}
-var finder = find$1;
+toVFile.readSync = readSync;
+toVFile.writeSync = writeSync;
+toVFile.read = read$2;
+toVFile.write = write;
-// Search `patterns`, a mix of globs, paths, and files.
-function find$1(input, options, callback) {
- expand$2(input, options, done);
+/**
+ * @typedef {import('fs').Stats} Stats
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./ignore.js').Ignore} Ignore
+ * @typedef {import('ignore').Ignore} GitIgnore
+ *
+ * @typedef Options
+ * @property {string} cwd
+ * @property {Array.<string>} extensions
+ * @property {boolean|undefined} silentlyIgnore
+ * @property {Array.<string>} ignorePatterns
+ * @property {Ignore} ignore
+ *
+ * @typedef SearchResults
+ * @property {fs.Stats|undefined} stats
+ * @property {boolean|undefined} ignored
+ *
+ * @typedef Result
+ * @property {Array.<string|VFile>} input
+ * @property {VFile[]} output
+ *
+ * @typedef CleanResult
+ * @property {boolean} oneFileMode
+ * @property {VFile[]} files
+ *
+ * @callback Callback
+ * @param {Error|null} error
+ * @param {CleanResult} [result]
+ */
- function done(error, result) {
- /* istanbul ignore if - glob errors are unusual.
- * other errors are on the vfile results. */
- if (error) {
+/**
+ * Search `patterns`, a mix of globs, paths, and files.
+ *
+ * @param {Array.<string|VFile>} input
+ * @param {Options} options
+ * @param {Callback} callback
+ */
+function finder(input, options, callback) {
+ expand(input, options, (error, result) => {
+ // Glob errors are unusual.
+ // other errors are on the vfile results.
+ /* c8 ignore next 2 */
+ if (error || !result) {
callback(error);
} else {
callback(null, {oneFileMode: oneFileMode(result), files: result.output});
}
- }
+ });
}
-// Expand the given glob patterns, search given and found directories, and map
-// to vfiles.
-function expand$2(input, options, next) {
- var paths = [];
- var actual = 0;
- var expected = 0;
- var failed;
-
- input.forEach(each);
-
- if (!expected) {
- search$1(paths, options, done);
- }
+/**
+ * Expand the given glob patterns, search given and found directories, and map
+ * to vfiles.
+ *
+ * @param {Array.<string|VFile>} input
+ * @param {Options} options
+ * @param {(error: Error|null, result?: Result) => void} next
+ */
+function expand(input, options, next) {
+ /** @type {Array.<string|VFile>} */
+ let paths = [];
+ let actual = 0;
+ let expected = 0;
+ let index = -1;
+ /** @type {boolean|undefined} */
+ let failed;
- function each(file) {
+ while (++index < input.length) {
+ let file = input[index];
if (typeof file === 'string') {
- if (glob.hasMagic(file)) {
+ if (glob_1.hasMagic(file)) {
expected++;
- glob(file, {cwd: options.cwd}, one);
+ glob_1(file, {cwd: options.cwd}, (error, files) => {
+ // Glob errors are unusual.
+ /* c8 ignore next 3 */
+ if (failed) {
+ return
+ }
+
+ // Glob errors are unusual.
+ /* c8 ignore next 4 */
+ if (error) {
+ failed = true;
+ done1(error);
+ } else {
+ actual++;
+ paths = paths.concat(files);
+
+ if (actual === expected) {
+ search$1(paths, options, done1);
+ }
+ }
+ });
} else {
// `relative` to make the paths canonical.
file =
- path$7.relative(options.cwd, path$7.resolve(options.cwd, file)) || '.';
+ path$c.relative(options.cwd, path$c.resolve(options.cwd, file)) || '.';
paths.push(file);
}
} else {
+ const fp = file.path ? path$c.relative(options.cwd, file.path) : options.cwd;
file.cwd = options.cwd;
- file.path = path$7.relative(options.cwd, file.path);
- file.history = [file.path];
+ file.path = fp;
+ file.history = [fp];
paths.push(file);
}
}
- function one(error, files) {
- /* istanbul ignore if - Glob errors are unusual. */
- if (failed) {
- return
- }
-
- /* istanbul ignore if - Glob errors are unusual. */
- if (error) {
- failed = true;
- done(error);
- } else {
- actual++;
- paths = paths.concat(files);
-
- if (actual === expected) {
- search$1(paths, options, done);
- }
- }
+ if (!expected) {
+ search$1(paths, options, done1);
}
- function done(error, files) {
- /* istanbul ignore if - `search` currently does not give errors. */
- if (error) {
+ /**
+ * @param {Error|null} error
+ * @param {Array<VFile>} [files]
+ */
+ function done1(error, files) {
+ // `search` currently does not give errors.
+ /* c8 ignore next 2 */
+ if (error || !files) {
next(error);
} else {
next(null, {input: paths, output: files});
@@ -14097,31 +27119,41 @@ function expand$2(input, options, next) {
}
}
-// Search `paths`.
+/**
+ * Search `paths`.
+ *
+ * @param {Array.<string|VFile>} input
+ * @param {Options & {nested?: boolean}} options
+ * @param {(error: Error|null, files: Array.<VFile>) => void} next
+ */
function search$1(input, options, next) {
- var extraIgnore = gitignore().add(options.ignorePatterns);
- var files = [];
- var expected = 0;
- var actual = 0;
+ const extraIgnore = ignore().add(options.ignorePatterns);
+ let expected = 0;
+ let actual = 0;
+ let index = -1;
+ /** @type {Array.<VFile>} */
+ let files = [];
- input.forEach(each);
+ while (++index < input.length) {
+ each(input[index]);
+ }
if (!expected) {
next(null, files);
}
- return each
-
+ /**
+ * @param {string|VFile} file
+ */
function each(file) {
- var ext = typeof file === 'string' ? path$7.extname(file) : file.extname;
- var part;
+ const ext = typeof file === 'string' ? path$c.extname(file) : file.extname;
// Normalise globs.
if (typeof file === 'string') {
- file = file.split('/').join(path$7.sep);
+ file = file.split('/').join(path$c.sep);
}
- part = base(file);
+ const part = base$1(file);
if (options.nested && (part.charAt(0) === '.' || part === 'node_modules')) {
return
@@ -14131,75 +27163,82 @@ function search$1(input, options, next) {
statAndIgnore(
file,
- Object.assign({}, options, {extraIgnore: extraIgnore}),
- handle
- );
-
- function handle(error, result) {
- var ignored = result && result.ignored;
- var dir = result && result.stats && result.stats.isDirectory();
-
- if (ignored && (options.nested || options.silentlyIgnore)) {
- return one(null, [])
- }
-
- if (!ignored && dir) {
- return fs$7.readdir(path$7.resolve(options.cwd, filePath(file)), directory)
- }
-
- if (
- !dir &&
- options.nested &&
- options.extensions.length > 0 &&
- options.extensions.indexOf(ext) === -1
- ) {
- return one(null, [])
- }
-
- file = vfile$4(file);
- file.cwd = options.cwd;
-
- if (ignored) {
- try {
- file.fail('Cannot process specified file: it’s ignored');
- } catch (_) {}
- }
-
- if (error && error.code === 'ENOENT') {
- try {
- file.fail(
- error.syscall === 'stat' ? 'No such file or directory' : error
- );
- } catch (_) {}
- }
-
- one(null, [file]);
- }
+ Object.assign({}, options, {extraIgnore}),
+ (error, result) => {
+ const ignored = result && result.ignored;
+ const dir = result && result.stats && result.stats.isDirectory();
+
+ if (ignored && (options.nested || options.silentlyIgnore)) {
+ return one(null, [])
+ }
+
+ if (!ignored && dir) {
+ return fs$a.readdir(
+ path$c.resolve(options.cwd, filePath(file)),
+ (error, basenames) => {
+ // Should not happen often: the directory is `stat`ed first, which was ok,
+ // but reading it is not.
+ /* c8 ignore next 9 */
+ if (error) {
+ const otherFile = toVFile(filePath(file));
+ otherFile.cwd = options.cwd;
+
+ try {
+ otherFile.fail('Cannot read directory');
+ } catch {}
+
+ one(null, [otherFile]);
+ } else {
+ search$1(
+ basenames.map((name) => path$c.join(filePath(file), name)),
+ Object.assign({}, options, {nested: true}),
+ one
+ );
+ }
+ }
+ )
+ }
- function directory(error, basenames) {
- var file;
+ if (
+ !dir &&
+ options.nested &&
+ options.extensions.length > 0 &&
+ !options.extensions.includes(ext)
+ ) {
+ return one(null, [])
+ }
- /* istanbul ignore if - Should not happen often: the directory is `stat`ed
- * first, which was ok, but reading it is not. */
- if (error) {
- file = vfile$4(filePath(file));
+ file = toVFile(file);
file.cwd = options.cwd;
- try {
- file.fail('Cannot read directory');
- } catch (_) {}
+ if (ignored) {
+ try {
+ file.fail('Cannot process specified file: it’s ignored');
+ // C8 bug on Node@12
+ /* c8 ignore next 1 */
+ } catch {}
+ }
+
+ if (error && error.code === 'ENOENT') {
+ try {
+ file.fail(
+ error.syscall === 'stat' ? 'No such file or directory' : error
+ );
+ // C8 bug on Node@12
+ /* c8 ignore next 1 */
+ } catch {}
+ }
one(null, [file]);
- } else {
- search$1(
- basenames.map(concat),
- Object.assign({}, options, {nested: true}),
- one
- );
}
- }
+ );
- // Error is never given. Always given `results`.
+ /**
+ * Error is never given. Always given `results`.
+ *
+ * @param {Error|null} _
+ * @param {Array.<VFile>} results
+ */
function one(_, results) {
/* istanbul ignore else - Always given. */
if (results) {
@@ -14212,39 +27251,41 @@ function search$1(input, options, next) {
next(null, files);
}
}
-
- function concat(value) {
- return path$7.join(filePath(file), value)
- }
}
}
+/**
+ * @param {VFile|string} file
+ * @param {Options & {extraIgnore: GitIgnore}} options
+ * @param {(error: NodeJS.ErrnoException|null, result?: SearchResults) => void} callback
+ */
function statAndIgnore(file, options, callback) {
- var fp = path$7.resolve(options.cwd, filePath(file));
- var normal = path$7.relative(options.cwd, fp);
- var expected = 1;
- var actual = 0;
- var stats;
- var ignored;
+ const fp = path$c.resolve(options.cwd, filePath(file));
+ const normal = path$c.relative(options.cwd, fp);
+ let expected = 1;
+ let actual = 0;
+ /** @type {Stats|undefined} */
+ let stats;
+ /** @type {boolean|undefined} */
+ let ignored;
- if (!file.contents) {
+ if (typeof file === 'string' || !file.value) {
expected++;
- fs$7.stat(fp, handleStat);
- }
-
- options.ignore.check(fp, handleIgnore);
-
- function handleStat(error, value) {
- stats = value;
- one(error);
+ fs$a.stat(fp, (error, value) => {
+ stats = value;
+ onStartOrCheck(error);
+ });
}
- function handleIgnore(error, value) {
+ options.ignore.check(fp, (error, value) => {
ignored = value;
- one(error);
- }
+ onStartOrCheck(error);
+ });
- function one(error) {
+ /**
+ * @param {Error|null} error
+ */
+ function onStartOrCheck(error) {
actual++;
if (error) {
@@ -14252,13 +27293,13 @@ function statAndIgnore(file, options, callback) {
actual = -1;
} else if (actual === expected) {
callback(null, {
- stats: stats,
+ stats,
ignored:
ignored ||
(normal === '' ||
normal === '..' ||
- normal.charAt(0) === path$7.sep ||
- normal.slice(0, 3) === '..' + path$7.sep
+ normal.charAt(0) === path$c.sep ||
+ normal.slice(0, 3) === '..' + path$c.sep
? false
: options.extraIgnore.ignores(normal))
});
@@ -14266,14 +27307,26 @@ function statAndIgnore(file, options, callback) {
}
}
-function base(file) {
- return typeof file === 'string' ? path$7.basename(file) : file.basename
+/**
+ * @param {string|VFile} file
+ * @returns {string}
+ */
+function base$1(file) {
+ return typeof file === 'string' ? path$c.basename(file) : file.basename
}
+/**
+ * @param {string|VFile} file
+ * @returns {string}
+ */
function filePath(file) {
return typeof file === 'string' ? file : file.path
}
+/**
+ * @param {Result} result
+ * @returns {boolean}
+ */
function oneFileMode(result) {
return (
result.output.length === 1 &&
@@ -14282,17 +27335,23 @@ function oneFileMode(result) {
)
}
-var Ignore = ignore$1;
-var find = finder;
-
-var fileSystem_1$1 = fileSystem$3;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
-// Find files from the file-system.
-function fileSystem$3(context, settings, next) {
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function fileSystem$1(context, settings, next) {
if (context.files.length === 0) {
next();
} else {
- find(
+ finder(
context.files,
{
cwd: settings.cwd,
@@ -14307,37 +27366,46 @@ function fileSystem$3(context, settings, next) {
ignorePathResolveFrom: settings.ignorePathResolveFrom
})
},
- onfound
- );
- }
-
- function onfound(error, result) {
- var output = result.files;
+ (error, result) => {
+ // Glob errors typically don’t occur.
+ /* c8 ignore next 4 */
+ if (!result) {
+ next(error);
+ return
+ }
- // Sort alphabetically.
- // Everything is unique so we do not care about cases where left and right
- // are equal.
- output.sort(sortAlphabetically);
+ const output = result.files;
- // Mark as given.
- // This allows outputting files, which can be pretty dangerous, so it’s
- // “hidden”.
- output.forEach(markAsGiven);
+ // Sort alphabetically.
+ // Everything is unique so we do not care about cases where left and right
+ // are equal.
+ output.sort(sortAlphabetically);
- context.files = output;
+ // Mark as given.
+ // This allows outputting files, which can be pretty dangerous, so it’s
+ // “hidden”.
+ let index = -1;
+ while (++index < output.length) {
+ output[index].data.unifiedEngineGiven = true;
+ }
- // If `out` was not set, detect it based on whether one file was given.
- if (settings.out === null || settings.out === undefined) {
- settings.out = result.oneFileMode;
- }
+ context.files = output;
- next(error);
- }
+ // If `out` was not set, detect it based on whether one file was given.
+ if (settings.out === null || settings.out === undefined) {
+ settings.out = result.oneFileMode;
+ }
- function markAsGiven(file) {
- file.data.unifiedEngineGiven = true;
+ next(error);
+ }
+ );
}
+ /**
+ * @param {VFile} left
+ * @param {VFile} right
+ * @returns {number}
+ */
function sortAlphabetically(left, right) {
return left.path < right.path ? -1 : 1
}
@@ -14345,7 +27413,7 @@ function fileSystem$3(context, settings, next) {
/* eslint-disable node/no-deprecated-api */
-var toString$8 = Object.prototype.toString;
+var toString$2 = Object.prototype.toString;
var isModern = (
typeof Buffer !== 'undefined' &&
@@ -14355,7 +27423,7 @@ var isModern = (
);
function isArrayBuffer (input) {
- return toString$8.call(input).slice(8, -1) === 'ArrayBuffer'
+ return toString$2.call(input).slice(8, -1) === 'ArrayBuffer'
}
function fromArrayBuffer (obj, byteOffset, length) {
@@ -15050,8 +28118,8 @@ function packF32(v) { return packIEEE754(v, 8, 23); }
}());
}(typedarray));
-var Writable = require$$0__default$5['default'].Writable;
-var inherits$1 = inherits$3.exports;
+var Writable = require$$1.Writable;
+var inherits = inherits$2.exports;
var bufferFrom = bufferFrom_1;
if (typeof Uint8Array === 'undefined') {
@@ -15091,7 +28159,7 @@ function ConcatStream(opts, cb) {
}
var concatStream = ConcatStream;
-inherits$1(ConcatStream, Writable);
+inherits(ConcatStream, Writable);
ConcatStream.prototype._write = function(chunk, enc, next) {
this.body.push(chunk);
@@ -15190,17 +28258,25 @@ function u8Concat (parts) {
return u8
}
-var debug$b = src.exports('unified-engine:file-set-pipeline:stdin');
-var vfile$3 = toVfile;
-var concat = concatStream;
-
-var stdin_1 = stdin$1;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ */
-function stdin$1(context, settings, next) {
- var error;
+const debug$9 = createDebug('unified-engine:file-set-pipeline:stdin');
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function stdin(context, settings, next) {
if (settings.files && settings.files.length > 0) {
- debug$b('Ignoring `streamIn`');
+ debug$9('Ignoring `streamIn`');
+
+ /** @type {Error|undefined} */
+ let error;
if (settings.filePath) {
error = new Error(
@@ -15213,176 +28289,183 @@ function stdin$1(context, settings, next) {
return
}
+ // @ts-expect-error: does exist on `stdin`.
if (settings.streamIn.isTTY) {
- debug$b('Cannot read from `tty` stream');
+ debug$9('Cannot read from `tty` stream');
next(new Error('No input'));
return
}
- debug$b('Reading from `streamIn`');
-
- settings.streamIn.pipe(concat({encoding: 'string'}, read));
-
- function read(value) {
- var file = vfile$3(settings.filePath || undefined);
-
- debug$b('Read from `streamIn`');
-
- file.cwd = settings.cwd;
- file.contents = value;
- file.data.unifiedEngineGiven = true;
- file.data.unifiedEngineStreamIn = true;
-
- context.files = [file];
-
- // If `out` was not set, set `out`.
- settings.out =
- settings.out === null || settings.out === undefined ? true : settings.out;
-
- next();
- }
-}
-
-var events = require$$0__default$4['default'];
-var inherits = require$$0__default['default'].inherits;
-var trough$3 = trough_1;
-var vfile$2 = toVfile;
+ debug$9('Reading from `streamIn`');
-var fileSet = FileSet$1;
-
-// FileSet constructor.
-function FileSet$1() {
- var self = this;
+ settings.streamIn.pipe(
+ concatStream({encoding: 'string'}, (value) => {
+ const file = toVFile(settings.filePath);
- self.files = [];
- self.origins = [];
+ debug$9('Read from `streamIn`');
- self.expected = 0;
- self.actual = 0;
+ file.cwd = settings.cwd;
+ file.value = value;
+ file.data.unifiedEngineGiven = true;
+ file.data.unifiedEngineStreamIn = true;
- self.pipeline = trough$3();
- self.plugins = [];
+ context.files = [file];
- events.init.call(self);
+ // If `out` was not set, set `out`.
+ settings.out =
+ settings.out === null || settings.out === undefined
+ ? true
+ : settings.out;
- self.on('one', one$1.bind(self));
+ next();
+ })
+ );
}
-// Events.
-inherits(FileSet$1, events.EventEmitter);
-
-// Expose methods.
-FileSet$1.prototype.valueOf = valueOf;
-FileSet$1.prototype.use = use;
-FileSet$1.prototype.add = add;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Pipeline} Pipeline
+ */
-// Create an array representation of `fileSet`.
-function valueOf() {
- return this.files
-}
+class FileSet extends EventEmitter$1 {
+ /**
+ * FileSet constructor.
+ * A FileSet is created to process multiple files through unified processors.
+ * This set, containing all files, is exposed to plugins as an argument to the
+ * attacher.
+ */
+ constructor() {
+ super();
-// Attach middleware to the pipeline on `fileSet`.
-function use(plugin) {
- var self = this;
- var pipeline = self.pipeline;
- var duplicate = false;
+ /** @type {Array.<VFile>} */
+ this.files = [];
+ /** @type {string[]} */
+ this.origins = [];
+ /** @type {Completer[]} */
+ this.plugins = [];
+ /** @type {number} */
+ this.expected = 0;
+ /** @type {number} */
+ this.actual = 0;
+ /** @type {Pipeline} */
+ this.pipeline = trough();
- if (plugin && plugin.pluginId) {
- duplicate = self.plugins.some(matches);
- }
+ // Called when a single file has completed it’s pipeline, triggering `done`
+ // when all files are complete.
+ this.on('one', () => {
+ this.actual++;
- if (!duplicate && self.plugins.indexOf(plugin) !== -1) {
- duplicate = true;
+ if (this.actual >= this.expected) {
+ this.emit('done');
+ }
+ });
}
- if (!duplicate) {
- self.plugins.push(plugin);
- pipeline.use(plugin);
+ /**
+ * Access the files in a set.
+ */
+ valueOf() {
+ return this.files
}
- return self
+ /**
+ * Attach middleware to the pipeline on `fileSet`.
+ *
+ * @param {Completer} plugin
+ */
+ use(plugin) {
+ const pipeline = this.pipeline;
+ let duplicate = false;
- function matches(fn) {
- return fn.pluginId === plugin.pluginId
- }
-}
+ if (plugin && plugin.pluginId) {
+ duplicate = this.plugins.some((fn) => fn.pluginId === plugin.pluginId);
+ }
-// Add a file to be processed.
-// Ignores duplicate files (based on the `filePath` at time of addition).
-// Only runs `file-pipeline` on files which have not `failed` before addition.
-function add(file) {
- var self = this;
+ if (!duplicate && this.plugins.includes(plugin)) {
+ duplicate = true;
+ }
- if (typeof file === 'string') {
- file = vfile$2(file);
- }
+ if (!duplicate) {
+ this.plugins.push(plugin);
+ pipeline.use(plugin);
+ }
- // Prevent files from being added multiple times.
- if (self.origins.indexOf(file.history[0]) !== -1) {
- return self
+ return this
}
- self.origins.push(file.history[0]);
-
- // Add.
- self.valueOf().push(file);
- self.expected++;
-
- // Force an asynchronous operation.
- // This ensures that files which fall through the file pipeline immediately
- // (such as, when already fatally failed) still queue up correctly.
- setImmediate(add);
+ /**
+ * Add a file to be processed.
+ * The given file is processed like other files with a few differences:
+ *
+ * * Ignored when their file path is already added
+ * * Never written to the file system or streamOut
+ * * Not reported for
+ *
+ * @param {string|VFile} file
+ */
+ add(file) {
+ if (typeof file === 'string') {
+ file = toVFile(file);
+ }
- return self
+ // Prevent files from being added multiple times.
+ if (this.origins.includes(file.history[0])) {
+ return this
+ }
- function add() {
- self.emit('add', file);
- }
-}
+ this.origins.push(file.history[0]);
-// Utility invoked when a single file has completed it's pipeline, triggering
-// `done` when all files are complete.
-function one$1() {
- var self = this;
+ // Add.
+ this.valueOf().push(file);
+ this.expected++;
- self.actual++;
+ // Force an asynchronous operation.
+ // This ensures that files which fall through the file pipeline immediately
+ // (such as, when already fatally failed) still queue up correctly.
+ setImmediate(() => {
+ this.emit('add', file);
+ });
- if (self.actual >= self.expected) {
- self.emit('done');
+ return this
}
}
-var fs$6 = require$$0__default$3['default'];
-var path$6 = require$$0__default$2['default'];
-var debug$a = src.exports('unified-engine:file-pipeline:read');
-var stats$7 = vfileStatistics;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var read_1 = read$2;
+const debug$8 = createDebug('unified-engine:file-pipeline:read');
-// Fill a file with its contents when not already filled.
-function read$2(context, file, fileSet, next) {
- var filePath = file.path;
+/**
+ * Fill a file with its value when not already filled.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function read$1(context, file, next) {
+ let filePath = file.path;
- if (file.contents || file.data.unifiedEngineStreamIn) {
- debug$a('Not reading file `%s` with contents', filePath);
+ if (file.value || file.data.unifiedEngineStreamIn) {
+ debug$8('Not reading file `%s` with `value`', filePath);
next();
- } else if (stats$7(file).fatal) {
- debug$a('Not reading failed file `%s`', filePath);
+ } else if (statistics(file).fatal) {
+ debug$8('Not reading failed file `%s`', filePath);
next();
} else {
- filePath = path$6.resolve(context.cwd, filePath);
+ filePath = path$c.resolve(context.settings.cwd, filePath);
- debug$a('Reading `%s` in `%s`', filePath, 'utf8');
- fs$6.readFile(filePath, 'utf8', onread);
- }
-
- function onread(error, contents) {
- debug$a('Read `%s` (error: %s)', filePath, error);
+ debug$8('Reading `%s` in `%s`', filePath, 'utf8');
+ fs$a.readFile(filePath, 'utf8', (error, value) => {
+ debug$8('Read `%s` (error: %s)', filePath, error);
- file.contents = contents || '';
+ file.value = value || '';
- next(error);
+ next(error);
+ });
}
}
@@ -15400,7 +28483,7 @@ var has = Object.prototype.hasOwnProperty;
* @type {Function}
*/
-var toString$7 = Object.prototype.toString;
+var toString$1 = Object.prototype.toString;
/**
* Test whether a value is "empty".
@@ -15409,7 +28492,7 @@ var toString$7 = Object.prototype.toString;
* @return {Boolean}
*/
-function isEmpty$1(val) {
+function isEmpty(val) {
// Null and Undefined...
if (val == null) return true
@@ -15432,7 +28515,7 @@ function isEmpty$1(val) {
if (val instanceof Error) return val.message === ''
// Objects...
- if (val.toString == toString$7) {
+ if (val.toString == toString$1) {
switch (val.toString()) {
// Maps, Sets, Files and Errors...
@@ -15463,89 +28546,107 @@ function isEmpty$1(val) {
* @type {Function}
*/
-var lib$5 = isEmpty$1;
+var lib$1 = isEmpty;
-var debug$9 = src.exports('unified-engine:file-pipeline:configure');
-var stats$6 = vfileStatistics;
-var empty$3 = lib$5;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var configure_1$1 = configure$5;
+const debug$7 = createDebug('unified-engine:file-pipeline:configure');
-// Collect configuration for a file based on the context.
-function configure$5(context, file, fileSet, next) {
- if (stats$6(file).fatal) {
+/**
+ * Collect configuration for a file based on the context.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function configure$2(context, file, next) {
+ if (statistics(file).fatal) {
return next()
}
- context.configuration.load(file.path, handleConfiguration);
-
- function handleConfiguration(error, configuration) {
- var index = -1;
- var plugin;
- var options;
+ context.configuration.load(file.path, (error, configuration) => {
+ let index = -1;
- if (error) {
+ if (!configuration) {
return next(error)
}
+ // Could be missing if a `configTransform` returns weird things.
+ /* c8 ignore next 1 */
+ const plugins = configuration.plugins || [];
+
// Store configuration on the context object.
- debug$9('Using settings `%j`', configuration.settings);
+ debug$7('Using settings `%j`', configuration.settings);
context.processor.data('settings', configuration.settings);
- debug$9('Using `%d` plugins', configuration.plugins.length);
+ debug$7('Using `%d` plugins', plugins.length);
- while (++index < configuration.plugins.length) {
- plugin = configuration.plugins[index][0];
- options = configuration.plugins[index][1];
+ while (++index < plugins.length) {
+ const plugin = plugins[index][0];
+ let options = plugins[index][1];
if (options === false) {
continue
}
// Allow for default arguments in es2020.
- if (options === null || (typeof options === 'object' && empty$3(options))) {
+ /* c8 ignore next 6 */
+ if (
+ options === null ||
+ (typeof options === 'object' && lib$1(options))
+ ) {
options = undefined;
}
- debug$9(
+ debug$7(
'Using plugin `%s`, with options `%j`',
+ // @ts-expect-error: `displayName` sure can exist on functions.
plugin.displayName || plugin.name || 'function',
options
);
try {
- context.processor.use(plugin, options, fileSet);
+ context.processor.use(plugin, options, context.fileSet);
+ /* Should not happen anymore! */
+ /* c8 ignore next 3 */
} catch (error_) {
- /* istanbul ignore next - Should not happen anymore! */
return next(error_)
}
}
next();
- }
+ });
}
-var debug$8 = src.exports('unified-engine:file-pipeline:parse');
-var stats$5 = vfileStatistics;
-var json$1 = parseJson_1;
-
-var parse_1$4 = parse$a;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./index.js').Context} Context
+ */
-// Fill a file with a tree.
-function parse$a(context, file) {
- var message;
+const debug$6 = createDebug('unified-engine:file-pipeline:parse');
- if (stats$5(file).fatal) {
+/**
+ * Fill a file with a tree.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ */
+function parse$2(context, file) {
+ if (statistics(file).fatal) {
return
}
- if (context.treeIn) {
- debug$8('Not parsing already parsed document');
+ if (context.settings.treeIn) {
+ debug$6('Not parsing already parsed document');
try {
- context.tree = json$1(file.toString());
+ context.tree = parseJson_1(file.toString());
} catch (error) {
- message = file.message(
+ const message = file.message(
new Error('Cannot read file as JSON\n' + error.message)
);
message.fatal = true;
@@ -15555,334 +28656,457 @@ function parse$a(context, file) {
// correctly recognised.
// Only add it if there is a path — not if the file is for example stdin.
if (file.path) {
- file.extname = context.extensions[0];
+ file.extname = context.settings.extensions[0];
}
- file.contents = '';
+ file.value = '';
return
}
- debug$8('Parsing `%s`', file.path);
+ debug$6('Parsing `%s`', file.path);
context.tree = context.processor.parse(file);
- debug$8('Parsed document');
+ debug$6('Parsed document');
}
-var debug$7 = src.exports('unified-engine:file-pipeline:transform');
-var stats$4 = vfileStatistics;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var transform_1$1 = transform$5;
+const debug$5 = createDebug('unified-engine:file-pipeline:transform');
-// Transform the tree associated with a file with configured plugins.
-function transform$5(context, file, fileSet, next) {
- if (stats$4(file).fatal) {
+/**
+ * Transform the tree associated with a file with configured plugins.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function transform$2(context, file, next) {
+ if (statistics(file).fatal) {
next();
} else {
- debug$7('Transforming document `%s`', file.path);
- context.processor.run(context.tree, file, onrun);
- }
-
- function onrun(error, node) {
- debug$7('Transformed document (error: %s)', error);
- context.tree = node;
- next(error);
+ debug$5('Transforming document `%s`', file.path);
+ // @ts-expect-error: `tree` is defined at this point.
+ context.processor.run(context.tree, file, (error, node) => {
+ debug$5('Transformed document (error: %s)', error);
+ context.tree = node;
+ next(error);
+ });
}
}
-var debug$6 = src.exports('unified-engine:file-pipeline:queue');
-var stats$3 = vfileStatistics;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var queue_1 = queue$1;
+const debug$4 = createDebug('unified-engine:file-pipeline:queue');
-// Queue all files which came this far.
-// When the last file gets here, run the file-set pipeline and flush the queue.
-function queue$1(context, file, fileSet, next) {
- var origin = file.history[0];
- var map = fileSet.complete;
- var complete = true;
+const own$a = {}.hasOwnProperty;
+
+/**
+ * Queue all files which came this far.
+ * When the last file gets here, run the file-set pipeline and flush the queue.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function queue(context, file, next) {
+ let origin = file.history[0];
+ // @ts-expect-error: store a completion map on the `fileSet`.
+ let map = context.fileSet.complete;
+ let complete = true;
if (!map) {
map = {};
- fileSet.complete = map;
+ // @ts-expect-error: store a completion map on the `fileSet`.
+ context.fileSet.complete = map;
}
- debug$6('Queueing `%s`', origin);
+ debug$4('Queueing `%s`', origin);
map[origin] = next;
- fileSet.valueOf().forEach(each);
+ const files = context.fileSet.valueOf();
+ let index = -1;
+ while (++index < files.length) {
+ each(files[index]);
+ }
if (!complete) {
- debug$6('Not flushing: some files cannot be flushed');
+ debug$4('Not flushing: some files cannot be flushed');
return
}
- fileSet.complete = {};
-
- fileSet.pipeline.run(fileSet, done);
+ // @ts-expect-error: Reset map.
+ context.fileSet.complete = {};
+ context.fileSet.pipeline.run(context.fileSet, done);
+ /**
+ * @param {VFile} file
+ */
function each(file) {
- var key = file.history[0];
+ const key = file.history[0];
- if (stats$3(file).fatal) {
+ if (statistics(file).fatal) {
return
}
if (typeof map[key] === 'function') {
- debug$6('`%s` can be flushed', key);
+ debug$4('`%s` can be flushed', key);
} else {
- debug$6('Interupting flush: `%s` is not finished', key);
+ debug$4('Interupting flush: `%s` is not finished', key);
complete = false;
}
}
+ /**
+ * @param {Error|Null} error
+ */
function done(error) {
- debug$6('Flushing: all files can be flushed');
+ debug$4('Flushing: all files can be flushed');
// Flush.
for (origin in map) {
- map[origin](error);
+ if (own$a.call(map, origin)) {
+ map[origin](error);
+ }
}
}
}
-var isEmpty = lib$5;
-
-// Detect color support.
-var color$4 = true;
-
-try {
- color$4 = 'inspect' in require$$0__default['default'];
-} catch (_) {
- /* istanbul ignore next - browser */
- color$4 = false;
-}
-
-var unistUtilInspect = color$4 ? inspect$2 : /* istanbul ignore next */ noColor;
-
-inspect$2.color = inspect$2;
-noColor.color = inspect$2;
-inspect$2.noColor = noColor;
-noColor.noColor = noColor;
+var own$9 = {}.hasOwnProperty;
+var bold = ansiColor(1, 22);
var dim = ansiColor(2, 22);
var yellow = ansiColor(33, 39);
var green = ansiColor(32, 39);
-// Define ANSII color removal functionality.
-var colorExpression = new RegExp(
- '(?:' +
- '(?:\\u001b\\[)|' +
- '\\u009b' +
- ')' +
- '(?:' +
- '(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m]' +
- ')|' +
- '\\u001b[A-M]',
- 'g'
-);
+// ANSI color regex.
+/* eslint-disable-next-line no-control-regex */
+var colorExpression = /(?:(?:\u001B\[)|\u009B)(?:\d{1,3})?(?:(?:;\d{0,3})*)?[A-M|f-m]|\u001B[A-M]/g;
-// Standard keys defined by unist: https://github.com/syntax-tree/unist.
-// We don’t ignore `data` though.
-var ignore = ['type', 'value', 'children', 'position'];
-
-// Inspects a node, without using color.
-function noColor(node, pad) {
- return stripColor(inspect$2(node, pad))
+/**
+ * Inspects a node, without using color.
+ *
+ * @param {unknown} node
+ * @param {InspectOptions} [options]
+ * @returns {string}
+ */
+function inspectNoColor(node, options) {
+ return inspectColor(node, options).replace(colorExpression, '')
}
-// Inspects a node.
-function inspect$2(node, pad) {
- var result;
- var children;
- var index;
- var length;
+/**
+ * Inspects a node, using color.
+ *
+ * @param {unknown} tree
+ * @param {InspectOptions} [options]
+ * @returns {string}
+ */
+function inspectColor(tree, options) {
+ var positions =
+ !options ||
+ options.showPositions === null ||
+ options.showPositions === undefined
+ ? true
+ : options.showPositions;
- if (node && Boolean(node.length) && typeof node !== 'string') {
- length = node.length;
- index = -1;
- result = [];
+ return inspectValue(tree)
- while (++index < length) {
- result[index] = inspect$2(node[index]);
+ /**
+ * @param {unknown} node
+ * @returns {string}
+ */
+ function inspectValue(node) {
+ if (node && typeof node === 'object' && 'length' in node) {
+ // @ts-ignore looks like a list of nodes.
+ return inspectNodes(node)
}
- return result.join('\n')
- }
-
- if (!node || !node.type) {
- return String(node)
- }
-
- result = [formatNode(node)];
- children = node.children;
- length = children && children.length;
- index = -1;
+ // @ts-ignore looks like a single node.
+ if (node && node.type) {
+ // @ts-ignore looks like a single node.
+ return inspectTree(node)
+ }
- if (!length) {
- return result[0]
+ return inspectNonTree(node)
}
- if (!pad || typeof pad === 'number') {
- pad = '';
+ /**
+ * @param {unknown} value
+ * @returns {string}
+ */
+ function inspectNonTree(value) {
+ return JSON.stringify(value)
}
- while (++index < length) {
- node = children[index];
+ /**
+ * @param {Node[]} nodes
+ * @returns {string}
+ */
+ function inspectNodes(nodes) {
+ /** @type {Array.<string>} */
+ var result = [];
+ var index = -1;
- if (index === length - 1) {
- result.push(formatNesting(pad + '└─ ') + inspect$2(node, pad + ' '));
- } else {
- result.push(formatNesting(pad + '├─ ') + inspect$2(node, pad + '│ '));
+ while (++index < nodes.length) {
+ result.push(
+ dim((index < nodes.length - 1 ? '├' : '└') + '─' + index) +
+ ' ' +
+ indent(
+ inspectValue(nodes[index]),
+ (index < nodes.length - 1 ? dim('│') : ' ') + ' ',
+ true
+ )
+ );
}
- }
- return result.join('\n')
-}
-
-// Colored nesting formatter.
-function formatNesting(value) {
- return dim(value)
-}
-
-// Compile a single position.
-function compile$2(pos) {
- var values = [];
-
- if (!pos) {
- return null
+ return result.join('\n')
}
- values = [[pos.line || 1, pos.column || 1].join(':')];
+ /**
+ * @param {Object.<string, unknown>} object
+ * @returns {string}
+ */
+ function inspectFields(object) {
+ /** @type {Array.<string>} */
+ var result = [];
+ /** @type {string} */
+ var key;
+ /** @type {unknown} */
+ var value;
+ /** @type {string} */
+ var formatted;
- if ('offset' in pos) {
- values.push(String(pos.offset || 0));
- }
+ for (key in object) {
+ /* c8 ignore next 1 */
+ if (!own$9.call(object, key)) continue
- return values
-}
+ value = object[key];
-// Compile a location.
-function stringify$c(start, end) {
- var values = [];
- var positions = [];
- var offsets = [];
+ if (
+ value === undefined ||
+ // Standard keys defined by unist that we format differently.
+ // <https://github.com/syntax-tree/unist>
+ key === 'type' ||
+ key === 'value' ||
+ key === 'children' ||
+ key === 'position' ||
+ // Ignore `name` (from xast) and `tagName` (from `hast`) when string.
+ (typeof value === 'string' && (key === 'name' || key === 'tagName'))
+ ) {
+ continue
+ }
- add(start);
- add(end);
+ // A single node.
+ if (
+ value &&
+ typeof value === 'object' &&
+ // @ts-ignore looks like a node.
+ value.type &&
+ key !== 'data' &&
+ key !== 'attributes' &&
+ key !== 'properties'
+ ) {
+ // @ts-ignore looks like a node.
+ formatted = inspectTree(value);
+ }
+ // A list of nodes.
+ else if (
+ value &&
+ typeof value === 'object' &&
+ 'length' in value &&
+ value[0] &&
+ value[0].type
+ ) {
+ // @ts-ignore looks like a list of nodes.
+ formatted = '\n' + inspectNodes(value);
+ } else {
+ formatted = inspectNonTree(value);
+ }
- if (positions.length !== 0) {
- values.push(positions.join('-'));
+ result.push(
+ key + dim(':') + (/\s/.test(formatted.charAt(0)) ? '' : ' ') + formatted
+ );
+ }
+
+ return indent(
+ result.join('\n'),
+ // @ts-ignore looks like a parent node.
+ (object.children && object.children.length > 0 ? dim('│') : ' ') + ' '
+ )
}
- if (offsets.length !== 0) {
- values.push(offsets.join('-'));
+ /**
+ * @param {Node} node
+ * @returns {string}
+ */
+ function inspectTree(node) {
+ var result = [formatNode(node)];
+ var fields = inspectFields(node);
+ // @ts-ignore looks like a parent.
+ var content = inspectNodes(node.children || []);
+ if (fields) result.push(fields);
+ if (content) result.push(content);
+ return result.join('\n')
}
- return values.join(', ')
+ /**
+ * Colored node formatter.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+ function formatNode(node) {
+ var result = [bold(node.type)];
+ var kind = node.tagName || node.name;
+ var position = positions ? stringifyPosition(node.position) : '';
- // Add a position.
- function add(position) {
- var tuple = compile$2(position);
+ if (typeof kind === 'string') {
+ result.push('<', kind, '>');
+ }
- if (tuple) {
- positions.push(tuple[0]);
+ if (node.children) {
+ // @ts-ignore looks like a parent.
+ result.push(dim('['), yellow(node.children.length), dim(']'));
+ } else if (typeof node.value === 'string') {
+ result.push(' ', green(inspectNonTree(node.value)));
+ }
- if (tuple[1]) {
- offsets.push(tuple[1]);
- }
+ if (position) {
+ result.push(' ', dim('('), position, dim(')'));
}
+
+ return result.join('')
}
}
-// Colored node formatter.
-function formatNode(node) {
- var log = node.type;
- var location = node.position || {};
- var position = stringify$c(location.start, location.end);
- var key;
- var values = [];
- var value;
+/**
+ * @param {string} value
+ * @param {string} indentation
+ * @param {boolean} [ignoreFirst=false]
+ * @returns {string}
+ */
+function indent(value, indentation, ignoreFirst) {
+ var lines = value.split('\n');
+ var index = ignoreFirst ? 0 : -1;
- if (node.children) {
- log += dim('[') + yellow(node.children.length) + dim(']');
- } else if (typeof node.value === 'string') {
- log += dim(': ') + green(JSON.stringify(node.value));
- }
+ if (!value) return value
- if (position) {
- log += ' (' + position + ')';
+ while (++index < lines.length) {
+ lines[index] = indentation + lines[index];
}
- for (key in node) {
- value = node[key];
+ return lines.join('\n')
+}
- if (
- ignore.indexOf(key) !== -1 ||
- value === null ||
- value === undefined ||
- (typeof value === 'object' && isEmpty(value))
- ) {
- continue
- }
+/**
+ * @param {Position} value
+ * @returns {string}
+ */
+function stringifyPosition(value) {
+ /** @type {Position} */
+ // @ts-ignore
+ var position = value || {};
+ /** @type {Array.<string>} */
+ var result = [];
+ /** @type {Array.<string>} */
+ var positions = [];
+ /** @type {Array.<string>} */
+ var offsets = [];
- values.push('[' + key + '=' + JSON.stringify(value) + ']');
- }
+ point(position.start);
+ point(position.end);
- if (values.length !== 0) {
- log += ' ' + values.join('');
- }
+ if (positions.length > 0) result.push(positions.join('-'));
+ if (offsets.length > 0) result.push(offsets.join('-'));
- return log
-}
+ return result.join(', ')
-// Remove ANSI colour from `value`.
-function stripColor(value) {
- return value.replace(colorExpression, '')
+ /**
+ * @param {Point} value
+ */
+ function point(value) {
+ if (value) {
+ positions.push((value.line || 1) + ':' + (value.column || 1));
+
+ if ('offset' in value) {
+ offsets.push(String(value.offset || 0));
+ }
+ }
+ }
}
-// Factory to wrap values in ANSI colours.
+/**
+ * Factory to wrap values in ANSI colours.
+ *
+ * @param {number} open
+ * @param {number} close
+ * @returns {function(string): string}
+ */
function ansiColor(open, close) {
return color
+ /**
+ * @param {string} value
+ * @returns {string}
+ */
function color(value) {
return '\u001B[' + open + 'm' + value + '\u001B[' + close + 'm'
}
}
-var debug$5 = src.exports('unified-engine:file-pipeline:stringify');
-var buffer$3 = isBuffer;
-var stats$2 = vfileStatistics;
-var inspect$1 = unistUtilInspect;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('./index.js').Context} Context
+ */
-var stringify_1 = stringify$b;
+const debug$3 = createDebug('unified-engine:file-pipeline:stringify');
-// Stringify a tree.
-function stringify$b(context, file) {
- var value;
+/**
+ * Stringify a tree.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ */
+function stringify$1(context, file) {
+ /** @type {unknown} */
+ let value;
- if (stats$2(file).fatal) {
- debug$5('Not compiling failed document');
+ if (statistics(file).fatal) {
+ debug$3('Not compiling failed document');
return
}
- if (!context.output && !context.out && !context.alwaysStringify) {
- debug$5('Not compiling document without output settings');
+ if (
+ !context.settings.output &&
+ !context.settings.out &&
+ !context.settings.alwaysStringify
+ ) {
+ debug$3('Not compiling document without output settings');
return
}
- debug$5('Compiling `%s`', file.path);
+ debug$3('Compiling `%s`', file.path);
- if (context.inspect) {
+ if (context.settings.inspect) {
// Add a `txt` extension if there is a path.
if (file.path) {
file.extname = '.txt';
}
- value = inspect$1[context.color ? 'color' : 'noColor'](context.tree) + '\n';
- } else if (context.treeOut) {
+ value =
+ (context.settings.color ? inspectColor : inspectNoColor)(context.tree) +
+ '\n';
+ } else if (context.settings.treeOut) {
// Add a `json` extension to ensure the file is correctly seen as JSON.
// Only add it if there is a path — not if the file is for example stdin.
if (file.path) {
@@ -15892,282 +29116,317 @@ function stringify$b(context, file) {
// Add the line feed to create a valid UNIX file.
value = JSON.stringify(context.tree, null, 2) + '\n';
} else {
+ // @ts-expect-error: `tree` is defined if we came this far.
value = context.processor.stringify(context.tree, file);
}
- if (value === undefined || value === null) ; else if (typeof value === 'string' || buffer$3(value)) {
- file.contents = value;
+ if (value === undefined || value === null) ; else if (typeof value === 'string' || isBuffer(value)) {
+ // @ts-expect-error: `isBuffer` checks buffer.
+ file.value = value;
} else {
file.result = value;
}
- debug$5('Serialized document');
+ debug$3('Serialized document');
}
-var fs$5 = require$$0__default$3['default'];
-var path$5 = require$$0__default$2['default'];
-var debug$4 = src.exports('unified-engine:file-pipeline:copy');
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var copy_1 = copy$4;
+const debug$2 = createDebug('unified-engine:file-pipeline:copy');
-// Move a file.
-function copy$4(context, file, fileSet, next) {
- var output = context.output;
- var outpath = output;
- var currentPath = file.path;
+/**
+ * Move a file.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function copy(context, file, next) {
+ const output = context.settings.output;
+ const currentPath = file.path;
- if (typeof outpath !== 'string') {
- debug$4('Not copying');
- return next()
+ if (typeof output !== 'string') {
+ debug$2('Not copying');
+ next();
+ return
}
- outpath = path$5.resolve(context.cwd, outpath);
+ const outpath = path$c.resolve(context.settings.cwd, output);
- debug$4('Copying `%s`', currentPath);
+ debug$2('Copying `%s`', currentPath);
- fs$5.stat(outpath, onstatfile);
-
- function onstatfile(error, stats) {
+ fs$a.stat(outpath, (error, stats) => {
if (error) {
if (
error.code !== 'ENOENT' ||
- output.charAt(output.length - 1) === path$5.sep
+ output.charAt(output.length - 1) === path$c.sep
) {
return next(
new Error('Cannot read output directory. Error:\n' + error.message)
)
}
- fs$5.stat(path$5.dirname(outpath), onstatparent);
+ // This is either given an error, or the parent exists which is a directory,
+ // but we should keep the basename of the given file.
+ fs$a.stat(path$c.dirname(outpath), (error) => {
+ if (error) {
+ next(
+ new Error('Cannot read parent directory. Error:\n' + error.message)
+ );
+ } else {
+ done(false);
+ }
+ });
} else {
done(stats.isDirectory());
}
- }
-
- // This is either given an error, or the parent exists which is a directory,
- // but we should keep the basename of the given file.
- function onstatparent(error) {
- if (error) {
- next(new Error('Cannot read parent directory. Error:\n' + error.message));
- } else {
- done(false);
- }
- }
+ });
+ /**
+ * @param {boolean} directory
+ */
function done(directory) {
- if (!directory && fileSet.expected > 1) {
+ if (!directory && context.fileSet.expected > 1) {
return next(
new Error('Cannot write multiple files to single output: ' + outpath)
)
}
- file[directory ? 'dirname' : 'path'] = path$5.relative(file.cwd, outpath);
+ file[directory ? 'dirname' : 'path'] = path$c.relative(file.cwd, outpath);
- debug$4('Copying document from %s to %s', currentPath, file.path);
+ debug$2('Copying document from %s to %s', currentPath, file.path);
next();
}
}
-var debug$3 = src.exports('unified-engine:file-pipeline:stdout');
-var stats$1 = vfileStatistics;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-var stdout_1 = stdout$1;
+const debug$1 = createDebug('unified-engine:file-pipeline:stdout');
-// Write a virtual file to `streamOut`.
-// Ignored when `output` is given, more than one file was processed, or `out`
-// is false.
-function stdout$1(context, file, fileSet, next) {
+/**
+ * Write a virtual file to `streamOut`.
+ * Ignored when `output` is given, more than one file was processed, or `out`
+ * is false.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function stdout(context, file, next) {
if (!file.data.unifiedEngineGiven) {
- debug$3('Ignoring programmatically added file');
+ debug$1('Ignoring programmatically added file');
next();
- } else if (stats$1(file).fatal || context.output || !context.out) {
- debug$3('Ignoring writing to `streamOut`');
+ } else if (
+ statistics(file).fatal ||
+ context.settings.output ||
+ !context.settings.out
+ ) {
+ debug$1('Ignoring writing to `streamOut`');
next();
} else {
- debug$3('Writing document to `streamOut`');
- context.streamOut.write(file.toString(), next);
+ debug$1('Writing document to `streamOut`');
+ context.settings.streamOut.write(file.toString(), next);
}
}
-var fs$4 = require$$0__default$3['default'];
-var path$4 = require$$0__default$2['default'];
-var debug$2 = src.exports('unified-engine:file-pipeline:file-system');
-var stats = vfileStatistics;
-
-var fileSystem_1 = fileSystem$2;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Context} Context
+ */
-// Write a virtual file to the file-system.
-// Ignored when `output` is not given.
-function fileSystem$2(context, file, fileSet, next) {
- var destinationPath;
+const debug = createDebug('unified-engine:file-pipeline:file-system');
- if (!context.output) {
- debug$2('Ignoring writing to file-system');
+/**
+ * Write a virtual file to the file-system.
+ * Ignored when `output` is not given.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {Callback} next
+ */
+function fileSystem(context, file, next) {
+ if (!context.settings.output) {
+ debug('Ignoring writing to file-system');
return next()
}
if (!file.data.unifiedEngineGiven) {
- debug$2('Ignoring programmatically added file');
+ debug('Ignoring programmatically added file');
return next()
}
- destinationPath = file.path;
+ let destinationPath = file.path;
if (!destinationPath) {
- debug$2('Cannot write file without a `destinationPath`');
+ debug('Cannot write file without a `destinationPath`');
return next(new Error('Cannot write file without an output path'))
}
- if (stats(file).fatal) {
- debug$2('Cannot write file with a fatal error');
+ if (statistics(file).fatal) {
+ debug('Cannot write file with a fatal error');
return next()
}
- destinationPath = path$4.resolve(context.cwd, destinationPath);
- debug$2('Writing document to `%s`', destinationPath);
+ destinationPath = path$c.resolve(context.settings.cwd, destinationPath);
+ debug('Writing document to `%s`', destinationPath);
file.stored = true;
-
- fs$4.writeFile(destinationPath, file.toString(), next);
+ fs$a.writeFile(destinationPath, file.toString(), next);
}
-var trough$2 = trough_1;
-var read$1 = read_1;
-var configure$4 = configure_1$1;
-var parse$9 = parse_1$4;
-var transform$4 = transform_1$1;
-var queue = queue_1;
-var stringify$a = stringify_1;
-var copy$3 = copy_1;
-var stdout = stdout_1;
-var fileSystem$1 = fileSystem_1;
+/**
+ * @typedef {import('trough').Pipeline} Pipeline
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unified').Processor} Processor
+ * @typedef {import('../file-set.js').FileSet} FileSet
+ * @typedef {import('../configuration.js').Configuration} Configuration
+ * @typedef {import('../index.js').Settings} Settings
+ */
// This pipeline ensures each of the pipes always runs: even if the read pipe
// fails, queue and write run.
-var filePipeline$1 = trough$2()
- .use(chunk(trough$2().use(read$1).use(configure$4).use(parse$9).use(transform$4)))
- .use(chunk(trough$2().use(queue)))
- .use(chunk(trough$2().use(stringify$a).use(copy$3).use(stdout).use(fileSystem$1)));
-
-// Factory to run a pipe.
-// Wraps a pipe to trigger an error on the `file` in `context`, but still call
-// `next`.
+const filePipeline = trough()
+ .use(chunk(trough().use(read$1).use(configure$2).use(parse$2).use(transform$2)))
+ .use(chunk(trough().use(queue)))
+ .use(chunk(trough().use(stringify$1).use(copy).use(stdout).use(fileSystem)));
+
+/**
+ * Factory to run a pipe.
+ * Wraps a pipe to trigger an error on the `file` in `context`, but still call
+ * `next`.
+ *
+ * @param {Pipeline} pipe
+ */
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(error) {
- var messages = file.messages;
- var index;
+ /**
+ * Run the bound pipe and handle any errors.
+ *
+ * @param {Context} context
+ * @param {VFile} file
+ * @param {() => void} next
+ */
+ function run(context, file, next) {
+ pipe.run(context, file, (/** @type {VFileMessage|null} */ error) => {
+ const messages = file.messages;
if (error) {
- index = messages.indexOf(error);
+ const index = messages.indexOf(error);
if (index === -1) {
- error = file.message(error);
- index = messages.length - 1;
+ Object.assign(file.message(error), {fatal: true});
+ } else {
+ messages[index].fatal = true;
}
-
- messages[index].fatal = true;
}
next();
- }
+ });
}
}
-var FileSet = fileSet;
-var filePipeline = filePipeline$1;
-
-var transform_1 = transform$3;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('trough').Callback} Callback
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
-// Transform all files.
-function transform$3(context, settings, next) {
- var fileSet = new FileSet();
+/**
+ * Transform all files.
+ *
+ * @param {Context} context
+ * @param {Settings} settings
+ * @param {Callback} next
+ */
+function transform$1(context, settings, next) {
+ const fileSet = new FileSet();
context.fileSet = fileSet;
- fileSet.on('add', add).on('done', next);
-
- if (context.files.length === 0) {
- next();
- } else {
- context.files.forEach(fileSet.add, fileSet);
- }
-
- function add(file) {
+ fileSet.on('add', (/** @type {VFile} */ file) => {
filePipeline.run(
{
configuration: context.configuration,
+ // Needed `any`s
+ // type-coverage:ignore-next-line
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
+ fileSet,
+ settings
},
file,
- fileSet,
- done
- );
+ (/** @type {Error|null} */ error) => {
+ // Does not 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.
+ /* c8 ignore next 4 */
+ if (error) {
+ Object.assign(file.message(error), {fatal: true});
+ }
- function done(error) {
- /* istanbul ignore next - Does not 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 (error) {
- error = file.message(error);
- error.fatal = true;
+ fileSet.emit('one', file);
}
+ );
+ });
+
+ fileSet.on('done', next);
- fileSet.emit('one', file);
+ if (context.files.length === 0) {
+ next();
+ } else {
+ let index = -1;
+ while (++index < context.files.length) {
+ fileSet.add(context.files[index]);
}
}
}
-var hasFlag$1 = (flag, argv) => {
- argv = argv || process.argv;
+function hasFlag(flag, argv = process$1.argv) {
const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
- const pos = argv.indexOf(prefix + flag);
- const terminatorPos = argv.indexOf('--');
- return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
-};
-
-const os = require$$0__default$1['default'];
-const hasFlag = hasFlag$1;
+ const position = argv.indexOf(prefix + flag);
+ const terminatorPosition = argv.indexOf('--');
+ return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
-const {env} = process;
+const {env} = process$1;
-let forceColor;
+let flagForceColor;
if (hasFlag('no-color') ||
hasFlag('no-colors') ||
hasFlag('color=false') ||
hasFlag('color=never')) {
- forceColor = 0;
+ flagForceColor = 0;
} else if (hasFlag('color') ||
hasFlag('colors') ||
hasFlag('color=true') ||
hasFlag('color=always')) {
- forceColor = 1;
+ flagForceColor = 1;
}
-if ('FORCE_COLOR' in env) {
- if (env.FORCE_COLOR === true || env.FORCE_COLOR === 'true') {
- forceColor = 1;
- } else if (env.FORCE_COLOR === false || env.FORCE_COLOR === 'false') {
- forceColor = 0;
- } else {
- forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+
+function envForceColor() {
+ if ('FORCE_COLOR' in env) {
+ if (env.FORCE_COLOR === 'true') {
+ return 1;
+ }
+
+ if (env.FORCE_COLOR === 'false') {
+ return 0;
+ }
+
+ return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
}
}
@@ -16184,22 +29443,31 @@ function translateLevel(level) {
};
}
-function supportsColor(stream) {
+function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {
+ const noFlagForceColor = envForceColor();
+ if (noFlagForceColor !== undefined) {
+ flagForceColor = noFlagForceColor;
+ }
+
+ const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+
if (forceColor === 0) {
return 0;
}
- if (hasFlag('color=16m') ||
- hasFlag('color=full') ||
- hasFlag('color=truecolor')) {
- return 3;
- }
+ if (sniffFlags) {
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
- if (hasFlag('color=256')) {
- return 2;
+ if (hasFlag('color=256')) {
+ return 2;
+ }
}
- if (stream && !stream.isTTY && forceColor === undefined) {
+ if (haveStream && !streamIsTTY && forceColor === undefined) {
return 0;
}
@@ -16209,16 +29477,11 @@ function supportsColor(stream) {
return min;
}
- 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. Windows 10 build 14931 is the first release
- // that supports 16m/TrueColor.
- const osRelease = os.release().split('.');
+ if (process$1.platform === 'win32') {
+ // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+ // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+ const osRelease = require$$0$2.release().split('.');
if (
- Number(process.versions.node.split('.')[0]) >= 8 &&
Number(osRelease[0]) >= 10 &&
Number(osRelease[2]) >= 10586
) {
@@ -16229,7 +29492,7 @@ function supportsColor(stream) {
}
if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
return 1;
}
@@ -16245,7 +29508,7 @@ function supportsColor(stream) {
}
if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+ const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
switch (env.TERM_PROGRAM) {
case 'iTerm.app':
@@ -16271,94 +29534,84 @@ function supportsColor(stream) {
return min;
}
-function getSupportLevel(stream) {
- const level = supportsColor(stream);
+function createSupportsColor(stream, options = {}) {
+ const level = _supportsColor(stream, {
+ streamIsTTY: stream && stream.isTTY,
+ ...options
+ });
+
return translateLevel(level);
}
-var supportsColor_1 = {
- supportsColor: getSupportLevel,
- stdout: getSupportLevel(process.stdout),
- stderr: getSupportLevel(process.stderr)
+const supportsColor = {
+ stdout: createSupportsColor({isTTY: tty$1.isatty(1)}),
+ stderr: createSupportsColor({isTTY: tty$1.isatty(2)})
};
-var stringWidth$1 = {exports: {}};
-
-var ansiRegex$1 = ({onlyFirst = false} = {}) => {
+function ansiRegex({onlyFirst = false} = {}) {
const pattern = [
'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
].join('|');
return new RegExp(pattern, onlyFirst ? undefined : 'g');
-};
-
-const ansiRegex = ansiRegex$1;
+}
-var stripAnsi$1 = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string;
+function stripAnsi(string) {
+ if (typeof string !== 'string') {
+ throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+ }
-var isFullwidthCodePoint$2 = {exports: {}};
+ return string.replace(ansiRegex(), '');
+}
/* eslint-disable yoda */
-const isFullwidthCodePoint$1 = codePoint => {
- if (Number.isNaN(codePoint)) {
+function isFullwidthCodePoint(codePoint) {
+ if (!Number.isInteger(codePoint)) {
return false;
}
// Code points are derived from:
- // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
- if (
- codePoint >= 0x1100 && (
- codePoint <= 0x115F || // Hangul Jamo
- codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
- codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
- // CJK Radicals Supplement .. Enclosed CJK Letters and Months
- (0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
- // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
- (0x3250 <= codePoint && codePoint <= 0x4DBF) ||
- // CJK Unified Ideographs .. Yi Radicals
- (0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
- // Hangul Jamo Extended-A
- (0xA960 <= codePoint && codePoint <= 0xA97C) ||
- // Hangul Syllables
- (0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
- // CJK Compatibility Ideographs
- (0xF900 <= codePoint && codePoint <= 0xFAFF) ||
- // Vertical Forms
- (0xFE10 <= codePoint && codePoint <= 0xFE19) ||
- // CJK Compatibility Forms .. Small Form Variants
- (0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
- // Halfwidth and Fullwidth Forms
- (0xFF01 <= codePoint && codePoint <= 0xFF60) ||
- (0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
- // Kana Supplement
- (0x1B000 <= codePoint && codePoint <= 0x1B001) ||
- // Enclosed Ideographic Supplement
- (0x1F200 <= codePoint && codePoint <= 0x1F251) ||
- // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
- (0x20000 <= codePoint && codePoint <= 0x3FFFD)
- )
- ) {
- return true;
- }
-
- return false;
-};
-
-isFullwidthCodePoint$2.exports = isFullwidthCodePoint$1;
-isFullwidthCodePoint$2.exports.default = isFullwidthCodePoint$1;
+ // https://unicode.org/Public/UNIDATA/EastAsianWidth.txt
+ return codePoint >= 0x1100 && (
+ codePoint <= 0x115F || // Hangul Jamo
+ codePoint === 0x2329 || // LEFT-POINTING ANGLE BRACKET
+ codePoint === 0x232A || // RIGHT-POINTING ANGLE BRACKET
+ // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+ (0x2E80 <= codePoint && codePoint <= 0x3247 && codePoint !== 0x303F) ||
+ // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+ (0x3250 <= codePoint && codePoint <= 0x4DBF) ||
+ // CJK Unified Ideographs .. Yi Radicals
+ (0x4E00 <= codePoint && codePoint <= 0xA4C6) ||
+ // Hangul Jamo Extended-A
+ (0xA960 <= codePoint && codePoint <= 0xA97C) ||
+ // Hangul Syllables
+ (0xAC00 <= codePoint && codePoint <= 0xD7A3) ||
+ // CJK Compatibility Ideographs
+ (0xF900 <= codePoint && codePoint <= 0xFAFF) ||
+ // Vertical Forms
+ (0xFE10 <= codePoint && codePoint <= 0xFE19) ||
+ // CJK Compatibility Forms .. Small Form Variants
+ (0xFE30 <= codePoint && codePoint <= 0xFE6B) ||
+ // Halfwidth and Fullwidth Forms
+ (0xFF01 <= codePoint && codePoint <= 0xFF60) ||
+ (0xFFE0 <= codePoint && codePoint <= 0xFFE6) ||
+ // Kana Supplement
+ (0x1B000 <= codePoint && codePoint <= 0x1B001) ||
+ // Enclosed Ideographic Supplement
+ (0x1F200 <= codePoint && codePoint <= 0x1F251) ||
+ // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+ (0x20000 <= codePoint && codePoint <= 0x3FFFD)
+ );
+}
-var emojiRegex$1 = function () {
+var emojiRegex = function () {
// https://mths.be/emoji
- return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+ return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
};
-const stripAnsi = stripAnsi$1;
-const isFullwidthCodePoint = isFullwidthCodePoint$2.exports;
-const emojiRegex = emojiRegex$1;
-
-const stringWidth = string => {
+function stringWidth(string) {
if (typeof string !== 'string' || string.length === 0) {
return 0;
}
@@ -16373,33 +29626,29 @@ const stringWidth = string => {
let width = 0;
- for (let i = 0; i < string.length; i++) {
- const code = string.codePointAt(i);
+ for (let index = 0; index < string.length; index++) {
+ const codePoint = string.codePointAt(index);
// Ignore control characters
- if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
+ if (codePoint <= 0x1F || (codePoint >= 0x7F && codePoint <= 0x9F)) {
continue;
}
// Ignore combining characters
- if (code >= 0x300 && code <= 0x36F) {
+ if (codePoint >= 0x300 && codePoint <= 0x36F) {
continue;
}
// Surrogates
- if (code > 0xFFFF) {
- i++;
+ if (codePoint > 0xFFFF) {
+ index++;
}
- width += isFullwidthCodePoint(code) ? 2 : 1;
+ width += isFullwidthCodePoint(codePoint) ? 2 : 1;
}
return width;
-};
-
-stringWidth$1.exports = stringWidth;
-// TODO: remove this in the next major version
-stringWidth$1.exports.default = stringWidth;
+}
/*!
* repeat-string <https://github.com/jonschlinkert/repeat-string>
@@ -16419,7 +29668,7 @@ var cache;
* Expose `repeat`
*/
-var repeatString = repeat$7;
+var repeatString = repeat;
/**
* Repeat the given `string` the specified `number`
@@ -16439,7 +29688,7 @@ var repeatString = repeat$7;
* @api public
*/
-function repeat$7(str, num) {
+function repeat(str, num) {
if (typeof str !== 'string') {
throw new TypeError('expected a string');
}
@@ -16470,68 +29719,115 @@ function repeat$7(str, num) {
return res;
}
-var vfileSort = sort$1;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ */
-var severities = {
- true: 2,
- false: 1,
- null: 0,
- undefined: 0
-};
+var severities = {true: 2, false: 1, null: 0, undefined: 0};
-function sort$1(file) {
+/**
+ * @template {VFile} F
+ * @param {F} file
+ * @returns {F}
+ */
+function sort(file) {
file.messages.sort(comparator);
return file
}
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @returns {number}
+ */
function comparator(a, b) {
return (
- check$4(a, b, 'line') ||
- check$4(a, b, 'column') ||
+ check$1(a, b, 'line') ||
+ check$1(a, b, 'column') ||
severities[b.fatal] - severities[a.fatal] ||
- compare$3(a, b, 'source') ||
- compare$3(a, b, 'ruleId') ||
- compare$3(a, b, 'reason') ||
+ compare(a, b, 'source') ||
+ compare(a, b, 'ruleId') ||
+ compare(a, b, 'reason') ||
0
)
}
-function check$4(a, b, property) {
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @param {string} property
+ * @returns {number}
+ */
+function check$1(a, b, property) {
return (a[property] || 0) - (b[property] || 0)
}
-function compare$3(a, b, property) {
- return (a[property] || '').localeCompare(b[property] || '')
+/**
+ * @param {VFileMessage} a
+ * @param {VFileMessage} b
+ * @param {string} property
+ * @returns {number}
+ */
+function compare(a, b, property) {
+ return String(a[property] || '').localeCompare(b[property] || '')
}
-var supported = supportsColor_1.stderr.hasBasic;
-var width = stringWidth$1.exports;
-var stringify$9 = unistUtilStringifyPosition;
-var repeat$6 = repeatString;
-var statistics$1 = vfileStatistics;
-var sort = vfileSort;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('vfile-message').VFileMessage} VFileMessage
+ * @typedef {import('vfile-statistics').Statistics} Statistics
+ *
+ * @typedef Options
+ * @property {boolean} [color]
+ * @property {boolean} [silent=false]
+ * @property {boolean} [quiet=false]
+ * @property {boolean} [verbose=false]
+ * @property {string} [defaultName='<stdin>']
+ *
+ * @typedef _Row
+ * @property {string} place
+ * @property {string} label
+ * @property {string} reason
+ * @property {string} ruleId
+ * @property {string} source
+ *
+ * @typedef _FileRow
+ * @property {'file'} type
+ * @property {VFile} file
+ * @property {Statistics} stats
+ *
+ * @typedef {{[x: string]: number}} _Sizes
+ *
+ * @typedef _Info
+ * @property {Array.<_FileRow|_Row>} rows
+ * @property {Statistics} stats
+ * @property {_Sizes} sizes
+ */
-var vfileReporter = reporter$1;
+var own$8 = {}.hasOwnProperty;
-var push$1 = [].push;
+// @ts-ignore Types are incorrect.
+var supported = supportsColor.stderr.hasBasic;
-// `log-symbols` without chalk:
-/* istanbul ignore next - Windows. */
-var chars$1 =
+// `log-symbols` without chalk, ignored for Windows:
+/* c8 ignore next 4 */
+var chars =
process.platform === 'win32'
? {error: '×', warning: '‼'}
: {error: '✖', warning: '⚠'};
-var labels = {
- true: 'error',
- false: 'warning',
- null: 'info',
- undefined: 'info'
-};
+var labels = {true: 'error', false: 'warning', null: 'info', undefined: 'info'};
-// Report a file’s messages.
-function reporter$1(files, options) {
- var settings = options || {};
+/**
+ * Report a file’s messages.
+ *
+ * @param {Error|VFile|Array.<VFile>} [files]
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function reporter$1(files, options = {}) {
+ /** @type {boolean} */
var one;
if (!files) {
@@ -16544,28 +29840,43 @@ function reporter$1(files, options) {
}
// One file.
- if (!('length' in files)) {
+ if (!Array.isArray(files)) {
one = true;
files = [files];
}
- return format(transform$2(files, settings), one, settings)
+ return format(transform(files, options), one, options)
}
-function transform$2(files, options) {
+/**
+ * @param {Array.<VFile>} files
+ * @param {Options} options
+ * @returns {_Info}
+ */
+function transform(files, options) {
var index = -1;
+ /** @type {Array.<_FileRow|_Row>} */
var rows = [];
+ /** @type {Array.<VFileMessage>} */
var all = [];
+ /** @type {number} */
+ var offset;
+ /** @type {_Sizes} */
var sizes = {};
+ /** @type {Array.<VFileMessage>} */
var messages;
- var offset;
+ /** @type {VFileMessage} */
var message;
- var messageRows;
+ /** @type {_Row} */
var row;
+ /** @type {Array.<_Row>} */
+ var messageRows;
+ /** @type {string} */
var key;
while (++index < files.length) {
- messages = sort({messages: files[index].messages.concat()}).messages;
+ // @ts-ignore it works fine.
+ messages = sort({messages: [...files[index].messages]}).messages;
messageRows = [];
offset = -1;
@@ -16576,10 +29887,10 @@ function transform$2(files, options) {
all.push(message);
row = {
- location: stringify$9(
- message.location.end.line && message.location.end.column
- ? message.location
- : message.location.start
+ place: stringifyPosition$1(
+ message.position.end.line && message.position.end.column
+ ? message.position
+ : message.position.start
),
label: labels[message.fatal],
reason:
@@ -16590,37 +29901,57 @@ function transform$2(files, options) {
};
for (key in row) {
- sizes[key] = Math.max(size$1(row[key]), sizes[key] || 0);
+ if (own$8.call(row, key)) {
+ sizes[key] = Math.max(size$1(row[key]), sizes[key] || 0);
+ }
}
messageRows.push(row);
}
}
- if ((!options.quiet && !options.silent) || messageRows.length) {
- rows.push({type: 'file', file: files[index], stats: statistics$1(messages)});
- push$1.apply(rows, messageRows);
+ if ((!options.quiet && !options.silent) || messageRows.length > 0) {
+ rows.push(
+ {type: 'file', file: files[index], stats: statistics(messages)},
+ ...messageRows
+ );
}
}
- return {rows: rows, stats: statistics$1(all), sizes: sizes}
+ return {rows, stats: statistics(all), sizes}
}
+/**
+ * @param {_Info} map
+ * @param {boolean} one
+ * @param {Options} options
+ */
function format(map, one, options) {
- var enabled = options.color == null ? supported : options.color;
+ /** @type {boolean} */
+ var enabled =
+ options.color === undefined || options.color === null
+ ? supported
+ : options.color;
+ /** @type {Array.<string>} */
var lines = [];
var index = -1;
+ /** @type {Statistics} */
var stats;
+ /** @type {_FileRow|_Row} */
var row;
+ /** @type {string} */
var line;
+ /** @type {string} */
var reason;
+ /** @type {string} */
var rest;
+ /** @type {RegExpMatchArray} */
var match;
while (++index < map.rows.length) {
row = map.rows[index];
- if (row.type === 'file') {
+ if ('type' in row) {
stats = row.stats;
line = row.file.history[0] || options.defaultName || '<stdin>';
@@ -16628,14 +29959,14 @@ function format(map, one, options) {
one && !options.defaultName && !row.file.history[0]
? ''
: (enabled
- ? '\x1b[4m' /* Underline. */ +
+ ? '\u001B[4m' /* Underline. */ +
(stats.fatal
- ? '\x1b[31m' /* Red. */
+ ? '\u001B[31m' /* Red. */
: stats.total
- ? '\x1b[33m' /* Yellow. */
- : '\x1b[32m') /* Green. */ +
+ ? '\u001B[33m' /* Yellow. */
+ : '\u001B[32m') /* Green. */ +
line +
- '\x1b[39m\x1b[24m'
+ '\u001B[39m\u001B[24m'
: line) +
(row.file.stored && row.file.path !== row.file.history[0]
? ' > ' + row.file.path
@@ -16646,13 +29977,13 @@ function format(map, one, options) {
(line ? line + ': ' : '') +
(row.file.stored
? enabled
- ? '\x1b[33mwritten\x1b[39m' /* Yellow. */
+ ? '\u001B[33mwritten\u001B[39m' /* Yellow. */
: 'written'
: 'no issues found');
}
if (line) {
- if (index && map.rows[index - 1].type !== 'file') {
+ if (index && !('type' in map.rows[index - 1])) {
lines.push('');
}
@@ -16672,23 +30003,23 @@ function format(map, one, options) {
lines.push(
(
' ' +
- repeat$6(' ', map.sizes.location - size$1(row.location)) +
- row.location +
+ repeatString(' ', map.sizes.place - size$1(row.place)) +
+ row.place +
' ' +
(enabled
? (row.label === 'error'
- ? '\x1b[31m' /* Red. */
- : '\x1b[33m') /* Yellow. */ +
+ ? '\u001B[31m' /* Red. */
+ : '\u001B[33m') /* Yellow. */ +
row.label +
- '\x1b[39m'
+ '\u001B[39m'
: row.label) +
- repeat$6(' ', map.sizes.label - size$1(row.label)) +
+ repeatString(' ', map.sizes.label - size$1(row.label)) +
' ' +
reason +
- repeat$6(' ', map.sizes.reason - size$1(reason)) +
+ repeatString(' ', map.sizes.reason - size$1(reason)) +
' ' +
row.ruleId +
- repeat$6(' ', map.sizes.ruleId - size$1(row.ruleId)) +
+ repeatString(' ', map.sizes.ruleId - size$1(row.ruleId)) +
' ' +
(row.source || '')
).replace(/ +$/, '') + rest
@@ -16704,8 +30035,8 @@ function format(map, one, options) {
if (stats.fatal) {
line =
(enabled
- ? '\x1b[31m' /* Red. */ + chars$1.error + '\x1b[39m'
- : chars$1.error) +
+ ? '\u001B[31m' /* Red. */ + chars.error + '\u001B[39m'
+ : chars.error) +
' ' +
stats.fatal +
' ' +
@@ -16716,8 +30047,8 @@ function format(map, one, options) {
line =
(line ? line + ', ' : '') +
(enabled
- ? '\x1b[33m' /* Yellow. */ + chars$1.warning + '\x1b[39m'
- : chars$1.warning) +
+ ? '\u001B[33m' /* Yellow. */ + chars.warning + '\u001B[39m'
+ : chars.warning) +
' ' +
stats.warn +
' ' +
@@ -16734,32 +30065,54 @@ function format(map, one, options) {
return lines.join('\n')
}
-// Get the length of `value`, ignoring ANSI sequences.
+/**
+ * Get the length of `value`, ignoring ANSI sequences.
+ *
+ * @param {string} value
+ * @returns {number}
+ */
function size$1(value) {
var match = /\r?\n|\r/.exec(value);
- return width(match ? value.slice(0, match.index) : value)
+ return stringWidth(match ? value.slice(0, match.index) : value)
}
-var load$2 = loadPlugin_1;
-var report = vfileReporter;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('../index.js').VFileReporter} VFileReporter
+ * @typedef {import('./index.js').Settings} Settings
+ * @typedef {import('./index.js').Configuration} Configuration
+ */
-var log_1 = log$1;
+/**
+ * @typedef Context
+ * @property {Array.<VFile>} files
+ * @property {Configuration} [configuration]
+ */
-function log$1(context, settings, next) {
- var reporter = settings.reporter || report;
- var diagnostics;
+/**
+ * @param {Context} context
+ * @param {Settings} settings
+ */
+async function log(context, settings) {
+ /** @type {VFileReporter} */
+ let func = reporter$1;
- if (typeof reporter === 'string') {
+ if (typeof settings.reporter === 'string') {
try {
- reporter = load$2(reporter, {cwd: settings.cwd, prefix: 'vfile-reporter'});
- } catch (_) {
- next(new Error('Could not find reporter `' + reporter + '`'));
- return
+ // @ts-expect-error: Assume loaded value is a vfile reporter.
+ func = await loadPlugin(settings.reporter, {
+ cwd: settings.cwd,
+ prefix: 'vfile-reporter'
+ });
+ } catch {
+ throw new Error('Could not find reporter `' + settings.reporter + '`')
}
+ } else if (settings.reporter) {
+ func = settings.reporter;
}
- diagnostics = reporter(
- context.files.filter(given),
+ let diagnostics = func(
+ context.files.filter((file) => file.data.unifiedEngineGiven),
Object.assign({}, settings.reporterOptions, {
quiet: settings.quiet,
silent: settings.silent,
@@ -16772,80 +30125,247 @@ function log$1(context, settings, next) {
diagnostics += '\n';
}
- settings.streamError.write(diagnostics, next);
- } else {
- next();
+ return new Promise((resolve) => {
+ settings.streamError.write(diagnostics, resolve);
+ })
}
}
-function given(file) {
- return file.data.unifiedEngineGiven
-}
-
-var trough$1 = trough_1;
-var configure$3 = configure_1$2;
-var fileSystem = fileSystem_1$1;
-var stdin = stdin_1;
-var transform$1 = transform_1;
-var log = log_1;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('../configuration.js').Configuration} Configuration
+ * @typedef {import('../index.js').Settings} Settings
+ */
-var fileSetPipeline$1 = trough$1()
+const fileSetPipeline = trough()
.use(configure$3)
- .use(fileSystem)
+ .use(fileSystem$1)
.use(stdin)
.use(transform$1)
.use(log);
-var PassThrough = require$$0__default$5['default'].PassThrough;
-var statistics = vfileStatistics;
-var fileSetPipeline = fileSetPipeline$1;
-
-var lib$4 = run;
+/**
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('unified').Processor<any, any, any, any>} Processor
+ * @typedef {import('./file-set.js').FileSet} FileSet
+ * @typedef {import('./file-set.js').Completer} Completer
+ * @typedef {import('./ignore.js').ResolveFrom} ResolveFrom
+ * @typedef {import('./configuration.js').ConfigTransform} ConfigTransform
+ * @typedef {import('./configuration.js').Preset} Preset
+ *
+ * @typedef VFileReporterFields
+ * @property {boolean} [color]
+ * @property {boolean} [quiet]
+ * @property {boolean} [silent]
+ *
+ * @typedef {{[key: string]: unknown} & VFileReporterFields} VFileReporterOptions
+ *
+ * @callback VFileReporter
+ * @param {VFile[]} files
+ * @param {VFileReporterOptions} options
+ * @returns {string}
+ *
+ * @typedef Settings
+ * @property {Options['processor']} processor
+ * @property {Exclude<Options['cwd'], undefined>} cwd
+ * @property {Exclude<Options['files'], undefined>} files
+ * @property {Exclude<Options['extensions'], undefined>} extensions
+ * @property {Exclude<Options['streamIn'], undefined>} streamIn
+ * @property {Options['filePath']} filePath
+ * @property {Exclude<Options['streamOut'], undefined>} streamOut
+ * @property {Exclude<Options['streamError'], undefined>} streamError
+ * @property {Options['out']} out
+ * @property {Options['output']} output
+ * @property {Options['alwaysStringify']} alwaysStringify
+ * @property {Options['tree']} tree
+ * @property {Options['treeIn']} treeIn
+ * @property {Options['treeOut']} treeOut
+ * @property {Options['inspect']} inspect
+ * @property {Options['rcName']} rcName
+ * @property {Options['packageField']} packageField
+ * @property {Options['detectConfig']} detectConfig
+ * @property {Options['rcPath']} rcPath
+ * @property {Exclude<Options['settings'], undefined>} settings
+ * @property {Options['ignoreName']} ignoreName
+ * @property {Options['detectIgnore']} detectIgnore
+ * @property {Options['ignorePath']} ignorePath
+ * @property {Options['ignorePathResolveFrom']} ignorePathResolveFrom
+ * @property {Exclude<Options['ignorePatterns'], undefined>} ignorePatterns
+ * @property {Options['silentlyIgnore']} silentlyIgnore
+ * @property {Options['plugins']} plugins
+ * @property {Options['pluginPrefix']} pluginPrefix
+ * @property {Options['configTransform']} configTransform
+ * @property {Options['defaultConfig']} defaultConfig
+ * @property {Options['reporter']} reporter
+ * @property {Options['reporterOptions']} reporterOptions
+ * @property {Options['color']} color
+ * @property {Options['silent']} silent
+ * @property {Options['quiet']} quiet
+ * @property {Options['frail']} frail
+ *
+ * @typedef Options
+ * Options for unified engine
+ * @property {() => Processor} processor
+ * Unified processor to transform files
+ * @property {string} [cwd]
+ * Directory to search files in, load plugins from, and more.
+ * Defaults to `process.cwd()`.
+ * @property {Array<string|VFile>} [files]
+ * Paths or globs to files and directories, or virtual files, to process.
+ * @property {string[]} [extensions]
+ * If `files` matches directories, include `files` with `extensions`
+ * @property {NodeJS.ReadableStream} [streamIn]
+ * Stream to read from if no files are found or given.
+ * Defaults to `process.stdin`.
+ * @property {string} [filePath]
+ * File path to process the given file on `streamIn` as.
+ * @property {NodeJS.WritableStream} [streamOut]
+ * Stream to write processed files to.
+ * Defaults to `process.stdout`.
+ * @property {NodeJS.WritableStream} [streamError]
+ * Stream to write the report (if any) to.
+ * Defaults to `process.stderr`.
+ * @property {boolean} [out=false]
+ * Whether to write the processed file to `streamOut`
+ * @property {boolean|string} [output=false]
+ * Whether to write successfully processed files, and where to.
+ *
+ * * When `true`, overwrites the given files
+ * * When `false`, does not write to the file system
+ * * When pointing to an existing directory, files are written to that
+ * directory and keep their original basenames
+ * * When the parent directory of the given path exists and one file is
+ * processed, the file is written to the given path
+ * @property {boolean} [alwaysStringify=false]
+ * Whether to always serialize successfully processed files.
+ * @property {boolean} [tree=false]
+ * Whether to treat both input and output as a syntax tree.
+ * @property {boolean} [treeIn]
+ * Whether to treat input as a syntax tree.
+ * Defaults to `options.tree`.
+ * @property {boolean} [treeOut]
+ * Whether to treat output as a syntax tree.
+ * Defaults to `options.tree`.
+ * @property {boolean} [inspect=false]
+ * Whether to output a formatted syntax tree.
+ * @property {string} [rcName]
+ * Name of configuration files to load.
+ * @property {string} [packageField]
+ * Property at which configuration can be found in `package.json` files
+ * @property {boolean} [detectConfig]
+ * Whether to search for configuration files.
+ * Defaults to `true` if `rcName` or `packageField` are given
+ * @property {string} [rcPath]
+ * Filepath to a configuration file to load.
+ * @property {Preset['settings']} [settings]
+ * Configuration for the parser and compiler of the processor.
+ * @property {string} [ignoreName]
+ * Name of ignore files to load.
+ * @property {boolean} [detectIgnore]
+ * Whether to search for ignore files.
+ * Defaults to `true` if `ignoreName` is given.
+ * @property {string} [ignorePath]
+ * Filepath to an ignore file to load.
+ * @property {ResolveFrom} [ignorePathResolveFrom]
+ * Resolve patterns in `ignorePath` from the current working
+ * directory (`'cwd'`) or the ignore file’s directory (`'dir'`, default).
+ * @property {string[]} [ignorePatterns]
+ * Patterns to ignore in addition to ignore files
+ * @property {boolean} [silentlyIgnore=false]
+ * Skip given files if they are ignored.
+ * @property {Preset['plugins']} [plugins]
+ * Plugins to use.
+ * @property {string} [pluginPrefix]
+ * Prefix to use when searching for plugins
+ * @property {ConfigTransform} [configTransform]
+ * Transform config files from a different schema.
+ * @property {Preset} [defaultConfig]
+ * Default configuration to use if no config file is given or found.
+ * @property {VFileReporter|string} [reporter]
+ * Reporter to use
+ * Defaults to `vfile-reporter`
+ * @property {VFileReporterOptions} [reporterOptions]
+ * Config to pass to the used reporter.
+ * @property {VFileReporterOptions['color']} [color=false]
+ * Whether to report with ANSI color sequences.
+ * @property {VFileReporterOptions['silent']} [silent=false]
+ * Report only fatal errors
+ * @property {VFileReporterOptions['quiet']} [quiet=false]
+ * Do not report successful files
+ * @property {boolean} [frail=false]
+ * Call back with an unsuccessful (`1`) code on warnings as well as errors
+ *
+ * @typedef Context
+ * Processing context.
+ * @property {VFile[]} [files]
+ * Processed files.
+ * @property {FileSet} [fileSet]
+ * Internally used information
+ *
+ * @callback Callback
+ * Callback called when processing according to options is complete.
+ * Invoked with either a fatal error if processing went horribly wrong
+ * (probably due to incorrect configuration), or a status code and the
+ * processing context.
+ * @param {Error|null} error
+ * @param {0|1} [status]
+ * @param {Context} [context]
+ * @returns {void}
+ */
-// 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;
+/**
+ * Run the file set pipeline once.
+ * `callback` is called with a fatal error, or with a status code (`0` on
+ * success, `1` on failure).
+ *
+ * @param {Options} options
+ * @param {Callback} callback
+ */
+function engine(options, callback) {
+ /** @type {Settings} */
+ const settings = {};
+ /** @type {NodeJS.ReadStream} */
+ // @ts-expect-error: `PassThrough` sure is readable.
+ let stdin = new PassThrough();
try {
- stdin = process.stdin;
- } catch (_) {
+ stdin = process$2.stdin;
// Obscure bug in Node (seen on Windows).
// See: <https://github.com/nodejs/node/blob/f856234/lib/internal/process/stdio.js#L82>,
// <https://github.com/AtomLinter/linter-markdown/pull/85>.
- }
+ /* c8 ignore next 1 */
+ } catch {}
if (!callback) {
throw new Error('Missing `callback`')
}
+ // Needed `any`s
+ // type-coverage:ignore-next-line
if (!options || !options.processor) {
return next(new Error('Missing `processor`'))
}
// Processor.
+ // Needed `any`s
+ // type-coverage:ignore-next-line
settings.processor = options.processor;
// Path to run as.
- settings.cwd = options.cwd || process.cwd();
+ settings.cwd = options.cwd || process$2.cwd();
// Input.
settings.files = options.files || [];
- settings.extensions = (options.extensions || []).map(extension$2);
+ settings.extensions = (options.extensions || []).map((ext) =>
+ ext.charAt(0) === '.' ? ext : '.' + ext
+ );
- settings.filePath = options.filePath || null;
+ settings.filePath = options.filePath;
settings.streamIn = options.streamIn || stdin;
// Output.
- settings.streamOut = options.streamOut || process.stdout;
- settings.streamError = options.streamError || process.stderr;
+ settings.streamOut = options.streamOut || process$2.stdout;
+ settings.streamError = options.streamError || process$2.stderr;
settings.alwaysStringify = options.alwaysStringify;
settings.output = options.output;
settings.out = options.out;
@@ -16860,7 +30380,7 @@ function run(options, callback) {
}
// Process phase management.
- tree = options.tree || false;
+ const tree = options.tree || false;
settings.treeIn = options.treeIn;
settings.treeOut = options.treeOut;
@@ -16875,8 +30395,8 @@ function run(options, callback) {
}
// Configuration.
- detectConfig = options.detectConfig;
- hasConfig = Boolean(options.rcName || options.packageField);
+ const detectConfig = options.detectConfig;
+ const hasConfig = Boolean(options.rcName || options.packageField);
if (detectConfig && !hasConfig) {
return next(
@@ -16888,23 +30408,23 @@ function run(options, callback) {
detectConfig === null || detectConfig === undefined
? hasConfig
: detectConfig;
- settings.rcName = options.rcName || null;
- settings.rcPath = options.rcPath || null;
- settings.packageField = options.packageField || null;
+ settings.rcName = options.rcName;
+ settings.rcPath = options.rcPath;
+ settings.packageField = options.packageField;
settings.settings = options.settings || {};
settings.configTransform = options.configTransform;
settings.defaultConfig = options.defaultConfig;
// Ignore.
- detectIgnore = options.detectIgnore;
- hasIgnore = Boolean(options.ignoreName);
+ const detectIgnore = options.detectIgnore;
+ const hasIgnore = Boolean(options.ignoreName);
settings.detectIgnore =
detectIgnore === null || detectIgnore === undefined
? hasIgnore
: detectIgnore;
- settings.ignoreName = options.ignoreName || null;
- settings.ignorePath = options.ignorePath || null;
+ settings.ignoreName = options.ignoreName;
+ settings.ignorePath = options.ignorePath;
settings.ignorePathResolveFrom = options.ignorePathResolveFrom || 'dir';
settings.ignorePatterns = options.ignorePatterns || [];
settings.silentlyIgnore = Boolean(options.silentlyIgnore);
@@ -16914,23 +30434,27 @@ function run(options, callback) {
}
// Plugins.
- settings.pluginPrefix = options.pluginPrefix || null;
- settings.plugins = options.plugins || {};
+ settings.pluginPrefix = options.pluginPrefix;
+ settings.plugins = options.plugins || [];
// Reporting.
- settings.reporter = options.reporter || null;
- settings.reporterOptions = options.reporterOptions || null;
+ settings.reporter = options.reporter;
+ settings.reporterOptions = options.reporterOptions;
settings.color = options.color || false;
- settings.silent = options.silent || false;
- settings.quiet = options.quiet || false;
- settings.frail = options.frail || false;
+ settings.silent = options.silent;
+ settings.quiet = options.quiet;
+ settings.frail = options.frail;
// Process.
fileSetPipeline.run({files: options.files || []}, settings, next);
+ /**
+ * @param {Error|null} error
+ * @param {Context} [context]
+ */
function next(error, context) {
- var stats = statistics((context || {}).files);
- var failed = Boolean(
+ const stats = statistics((context || {}).files);
+ const failed = Boolean(
settings.frail ? stats.fatal || stats.warn : stats.fatal
);
@@ -16942,8246 +30466,6 @@ function run(options, callback) {
}
}
-function extension$2(ext) {
- return ext.charAt(0) === '.' ? ext : '.' + ext
-}
-
-var ansiStyles$1 = {exports: {}};
-
-var colorName = {
- "aliceblue": [240, 248, 255],
- "antiquewhite": [250, 235, 215],
- "aqua": [0, 255, 255],
- "aquamarine": [127, 255, 212],
- "azure": [240, 255, 255],
- "beige": [245, 245, 220],
- "bisque": [255, 228, 196],
- "black": [0, 0, 0],
- "blanchedalmond": [255, 235, 205],
- "blue": [0, 0, 255],
- "blueviolet": [138, 43, 226],
- "brown": [165, 42, 42],
- "burlywood": [222, 184, 135],
- "cadetblue": [95, 158, 160],
- "chartreuse": [127, 255, 0],
- "chocolate": [210, 105, 30],
- "coral": [255, 127, 80],
- "cornflowerblue": [100, 149, 237],
- "cornsilk": [255, 248, 220],
- "crimson": [220, 20, 60],
- "cyan": [0, 255, 255],
- "darkblue": [0, 0, 139],
- "darkcyan": [0, 139, 139],
- "darkgoldenrod": [184, 134, 11],
- "darkgray": [169, 169, 169],
- "darkgreen": [0, 100, 0],
- "darkgrey": [169, 169, 169],
- "darkkhaki": [189, 183, 107],
- "darkmagenta": [139, 0, 139],
- "darkolivegreen": [85, 107, 47],
- "darkorange": [255, 140, 0],
- "darkorchid": [153, 50, 204],
- "darkred": [139, 0, 0],
- "darksalmon": [233, 150, 122],
- "darkseagreen": [143, 188, 143],
- "darkslateblue": [72, 61, 139],
- "darkslategray": [47, 79, 79],
- "darkslategrey": [47, 79, 79],
- "darkturquoise": [0, 206, 209],
- "darkviolet": [148, 0, 211],
- "deeppink": [255, 20, 147],
- "deepskyblue": [0, 191, 255],
- "dimgray": [105, 105, 105],
- "dimgrey": [105, 105, 105],
- "dodgerblue": [30, 144, 255],
- "firebrick": [178, 34, 34],
- "floralwhite": [255, 250, 240],
- "forestgreen": [34, 139, 34],
- "fuchsia": [255, 0, 255],
- "gainsboro": [220, 220, 220],
- "ghostwhite": [248, 248, 255],
- "gold": [255, 215, 0],
- "goldenrod": [218, 165, 32],
- "gray": [128, 128, 128],
- "green": [0, 128, 0],
- "greenyellow": [173, 255, 47],
- "grey": [128, 128, 128],
- "honeydew": [240, 255, 240],
- "hotpink": [255, 105, 180],
- "indianred": [205, 92, 92],
- "indigo": [75, 0, 130],
- "ivory": [255, 255, 240],
- "khaki": [240, 230, 140],
- "lavender": [230, 230, 250],
- "lavenderblush": [255, 240, 245],
- "lawngreen": [124, 252, 0],
- "lemonchiffon": [255, 250, 205],
- "lightblue": [173, 216, 230],
- "lightcoral": [240, 128, 128],
- "lightcyan": [224, 255, 255],
- "lightgoldenrodyellow": [250, 250, 210],
- "lightgray": [211, 211, 211],
- "lightgreen": [144, 238, 144],
- "lightgrey": [211, 211, 211],
- "lightpink": [255, 182, 193],
- "lightsalmon": [255, 160, 122],
- "lightseagreen": [32, 178, 170],
- "lightskyblue": [135, 206, 250],
- "lightslategray": [119, 136, 153],
- "lightslategrey": [119, 136, 153],
- "lightsteelblue": [176, 196, 222],
- "lightyellow": [255, 255, 224],
- "lime": [0, 255, 0],
- "limegreen": [50, 205, 50],
- "linen": [250, 240, 230],
- "magenta": [255, 0, 255],
- "maroon": [128, 0, 0],
- "mediumaquamarine": [102, 205, 170],
- "mediumblue": [0, 0, 205],
- "mediumorchid": [186, 85, 211],
- "mediumpurple": [147, 112, 219],
- "mediumseagreen": [60, 179, 113],
- "mediumslateblue": [123, 104, 238],
- "mediumspringgreen": [0, 250, 154],
- "mediumturquoise": [72, 209, 204],
- "mediumvioletred": [199, 21, 133],
- "midnightblue": [25, 25, 112],
- "mintcream": [245, 255, 250],
- "mistyrose": [255, 228, 225],
- "moccasin": [255, 228, 181],
- "navajowhite": [255, 222, 173],
- "navy": [0, 0, 128],
- "oldlace": [253, 245, 230],
- "olive": [128, 128, 0],
- "olivedrab": [107, 142, 35],
- "orange": [255, 165, 0],
- "orangered": [255, 69, 0],
- "orchid": [218, 112, 214],
- "palegoldenrod": [238, 232, 170],
- "palegreen": [152, 251, 152],
- "paleturquoise": [175, 238, 238],
- "palevioletred": [219, 112, 147],
- "papayawhip": [255, 239, 213],
- "peachpuff": [255, 218, 185],
- "peru": [205, 133, 63],
- "pink": [255, 192, 203],
- "plum": [221, 160, 221],
- "powderblue": [176, 224, 230],
- "purple": [128, 0, 128],
- "rebeccapurple": [102, 51, 153],
- "red": [255, 0, 0],
- "rosybrown": [188, 143, 143],
- "royalblue": [65, 105, 225],
- "saddlebrown": [139, 69, 19],
- "salmon": [250, 128, 114],
- "sandybrown": [244, 164, 96],
- "seagreen": [46, 139, 87],
- "seashell": [255, 245, 238],
- "sienna": [160, 82, 45],
- "silver": [192, 192, 192],
- "skyblue": [135, 206, 235],
- "slateblue": [106, 90, 205],
- "slategray": [112, 128, 144],
- "slategrey": [112, 128, 144],
- "snow": [255, 250, 250],
- "springgreen": [0, 255, 127],
- "steelblue": [70, 130, 180],
- "tan": [210, 180, 140],
- "teal": [0, 128, 128],
- "thistle": [216, 191, 216],
- "tomato": [255, 99, 71],
- "turquoise": [64, 224, 208],
- "violet": [238, 130, 238],
- "wheat": [245, 222, 179],
- "white": [255, 255, 255],
- "whitesmoke": [245, 245, 245],
- "yellow": [255, 255, 0],
- "yellowgreen": [154, 205, 50]
-};
-
-/* MIT license */
-
-/* eslint-disable no-mixed-operators */
-const cssKeywords = colorName;
-
-// NOTE: conversions should only return primitive values (i.e. arrays, or
-// values that give correct `typeof` results).
-// do not use box values types (i.e. Number(), String(), etc.)
-
-const reverseKeywords = {};
-for (const key of Object.keys(cssKeywords)) {
- reverseKeywords[cssKeywords[key]] = key;
-}
-
-const convert$4 = {
- rgb: {channels: 3, labels: 'rgb'},
- hsl: {channels: 3, labels: 'hsl'},
- hsv: {channels: 3, labels: 'hsv'},
- hwb: {channels: 3, labels: 'hwb'},
- cmyk: {channels: 4, labels: 'cmyk'},
- xyz: {channels: 3, labels: 'xyz'},
- lab: {channels: 3, labels: 'lab'},
- lch: {channels: 3, labels: 'lch'},
- hex: {channels: 1, labels: ['hex']},
- keyword: {channels: 1, labels: ['keyword']},
- ansi16: {channels: 1, labels: ['ansi16']},
- ansi256: {channels: 1, labels: ['ansi256']},
- hcg: {channels: 3, labels: ['h', 'c', 'g']},
- apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
- gray: {channels: 1, labels: ['gray']}
-};
-
-var conversions$2 = convert$4;
-
-// Hide .channels and .labels properties
-for (const model of Object.keys(convert$4)) {
- if (!('channels' in convert$4[model])) {
- throw new Error('missing channels property: ' + model);
- }
-
- if (!('labels' in convert$4[model])) {
- throw new Error('missing channel labels property: ' + model);
- }
-
- if (convert$4[model].labels.length !== convert$4[model].channels) {
- throw new Error('channel and label counts mismatch: ' + model);
- }
-
- const {channels, labels} = convert$4[model];
- delete convert$4[model].channels;
- delete convert$4[model].labels;
- Object.defineProperty(convert$4[model], 'channels', {value: channels});
- Object.defineProperty(convert$4[model], 'labels', {value: labels});
-}
-
-convert$4.rgb.hsl = function (rgb) {
- const r = rgb[0] / 255;
- const g = rgb[1] / 255;
- const b = rgb[2] / 255;
- const min = Math.min(r, g, b);
- const max = Math.max(r, g, b);
- const delta = max - min;
- let h;
- let s;
-
- if (max === min) {
- h = 0;
- } else if (r === max) {
- h = (g - b) / delta;
- } else if (g === max) {
- h = 2 + (b - r) / delta;
- } else if (b === max) {
- h = 4 + (r - g) / delta;
- }
-
- h = Math.min(h * 60, 360);
-
- if (h < 0) {
- h += 360;
- }
-
- const l = (min + max) / 2;
-
- if (max === min) {
- s = 0;
- } else if (l <= 0.5) {
- s = delta / (max + min);
- } else {
- s = delta / (2 - max - min);
- }
-
- return [h, s * 100, l * 100];
-};
-
-convert$4.rgb.hsv = function (rgb) {
- let rdif;
- let gdif;
- let bdif;
- let h;
- let s;
-
- const r = rgb[0] / 255;
- const g = rgb[1] / 255;
- const b = rgb[2] / 255;
- const v = Math.max(r, g, b);
- const diff = v - Math.min(r, g, b);
- const diffc = function (c) {
- return (v - c) / 6 / diff + 1 / 2;
- };
-
- if (diff === 0) {
- h = 0;
- s = 0;
- } else {
- s = diff / v;
- rdif = diffc(r);
- gdif = diffc(g);
- bdif = diffc(b);
-
- if (r === v) {
- h = bdif - gdif;
- } else if (g === v) {
- h = (1 / 3) + rdif - bdif;
- } else if (b === v) {
- h = (2 / 3) + gdif - rdif;
- }
-
- if (h < 0) {
- h += 1;
- } else if (h > 1) {
- h -= 1;
- }
- }
-
- return [
- h * 360,
- s * 100,
- v * 100
- ];
-};
-
-convert$4.rgb.hwb = function (rgb) {
- const r = rgb[0];
- const g = rgb[1];
- let b = rgb[2];
- const h = convert$4.rgb.hsl(rgb)[0];
- const w = 1 / 255 * Math.min(r, Math.min(g, b));
-
- b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
-
- return [h, w * 100, b * 100];
-};
-
-convert$4.rgb.cmyk = function (rgb) {
- const r = rgb[0] / 255;
- const g = rgb[1] / 255;
- const b = rgb[2] / 255;
-
- const k = Math.min(1 - r, 1 - g, 1 - b);
- const c = (1 - r - k) / (1 - k) || 0;
- const m = (1 - g - k) / (1 - k) || 0;
- const y = (1 - b - k) / (1 - k) || 0;
-
- return [c * 100, m * 100, y * 100, k * 100];
-};
-
-function comparativeDistance(x, y) {
- /*
- See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
- */
- return (
- ((x[0] - y[0]) ** 2) +
- ((x[1] - y[1]) ** 2) +
- ((x[2] - y[2]) ** 2)
- );
-}
-
-convert$4.rgb.keyword = function (rgb) {
- const reversed = reverseKeywords[rgb];
- if (reversed) {
- return reversed;
- }
-
- let currentClosestDistance = Infinity;
- let currentClosestKeyword;
-
- for (const keyword of Object.keys(cssKeywords)) {
- const value = cssKeywords[keyword];
-
- // Compute comparative distance
- const distance = comparativeDistance(rgb, value);
-
- // Check if its less, if so set as closest
- if (distance < currentClosestDistance) {
- currentClosestDistance = distance;
- currentClosestKeyword = keyword;
- }
- }
-
- return currentClosestKeyword;
-};
-
-convert$4.keyword.rgb = function (keyword) {
- return cssKeywords[keyword];
-};
-
-convert$4.rgb.xyz = function (rgb) {
- let r = rgb[0] / 255;
- let g = rgb[1] / 255;
- let b = rgb[2] / 255;
-
- // Assume sRGB
- r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
- g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
- b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
-
- const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
- const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
- const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
-
- return [x * 100, y * 100, z * 100];
-};
-
-convert$4.rgb.lab = function (rgb) {
- const xyz = convert$4.rgb.xyz(rgb);
- let x = xyz[0];
- let y = xyz[1];
- let z = xyz[2];
-
- x /= 95.047;
- y /= 100;
- z /= 108.883;
-
- x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
- y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
- z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
-
- const l = (116 * y) - 16;
- const a = 500 * (x - y);
- const b = 200 * (y - z);
-
- return [l, a, b];
-};
-
-convert$4.hsl.rgb = function (hsl) {
- const h = hsl[0] / 360;
- const s = hsl[1] / 100;
- const l = hsl[2] / 100;
- let t2;
- let t3;
- let val;
-
- if (s === 0) {
- val = l * 255;
- return [val, val, val];
- }
-
- if (l < 0.5) {
- t2 = l * (1 + s);
- } else {
- t2 = l + s - l * s;
- }
-
- const t1 = 2 * l - t2;
-
- const rgb = [0, 0, 0];
- for (let i = 0; i < 3; i++) {
- t3 = h + 1 / 3 * -(i - 1);
- if (t3 < 0) {
- t3++;
- }
-
- if (t3 > 1) {
- t3--;
- }
-
- if (6 * t3 < 1) {
- val = t1 + (t2 - t1) * 6 * t3;
- } else if (2 * t3 < 1) {
- val = t2;
- } else if (3 * t3 < 2) {
- val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
- } else {
- val = t1;
- }
-
- rgb[i] = val * 255;
- }
-
- return rgb;
-};
-
-convert$4.hsl.hsv = function (hsl) {
- const h = hsl[0];
- let s = hsl[1] / 100;
- let l = hsl[2] / 100;
- let smin = s;
- const lmin = Math.max(l, 0.01);
-
- l *= 2;
- s *= (l <= 1) ? l : 2 - l;
- smin *= lmin <= 1 ? lmin : 2 - lmin;
- const v = (l + s) / 2;
- const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
-
- return [h, sv * 100, v * 100];
-};
-
-convert$4.hsv.rgb = function (hsv) {
- const h = hsv[0] / 60;
- const s = hsv[1] / 100;
- let v = hsv[2] / 100;
- const hi = Math.floor(h) % 6;
-
- const f = h - Math.floor(h);
- const p = 255 * v * (1 - s);
- const q = 255 * v * (1 - (s * f));
- const t = 255 * v * (1 - (s * (1 - f)));
- v *= 255;
-
- switch (hi) {
- case 0:
- return [v, t, p];
- case 1:
- return [q, v, p];
- case 2:
- return [p, v, t];
- case 3:
- return [p, q, v];
- case 4:
- return [t, p, v];
- case 5:
- return [v, p, q];
- }
-};
-
-convert$4.hsv.hsl = function (hsv) {
- const h = hsv[0];
- const s = hsv[1] / 100;
- const v = hsv[2] / 100;
- const vmin = Math.max(v, 0.01);
- let sl;
- let l;
-
- l = (2 - s) * v;
- const lmin = (2 - s) * vmin;
- sl = s * vmin;
- sl /= (lmin <= 1) ? lmin : 2 - lmin;
- sl = sl || 0;
- l /= 2;
-
- return [h, sl * 100, l * 100];
-};
-
-// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
-convert$4.hwb.rgb = function (hwb) {
- const h = hwb[0] / 360;
- let wh = hwb[1] / 100;
- let bl = hwb[2] / 100;
- const ratio = wh + bl;
- let f;
-
- // Wh + bl cant be > 1
- if (ratio > 1) {
- wh /= ratio;
- bl /= ratio;
- }
-
- const i = Math.floor(6 * h);
- const v = 1 - bl;
- f = 6 * h - i;
-
- if ((i & 0x01) !== 0) {
- f = 1 - f;
- }
-
- const n = wh + f * (v - wh); // Linear interpolation
-
- let r;
- let g;
- let b;
- /* eslint-disable max-statements-per-line,no-multi-spaces */
- switch (i) {
- default:
- case 6:
- case 0: r = v; g = n; b = wh; break;
- case 1: r = n; g = v; b = wh; break;
- case 2: r = wh; g = v; b = n; break;
- case 3: r = wh; g = n; b = v; break;
- case 4: r = n; g = wh; b = v; break;
- case 5: r = v; g = wh; b = n; break;
- }
- /* eslint-enable max-statements-per-line,no-multi-spaces */
-
- return [r * 255, g * 255, b * 255];
-};
-
-convert$4.cmyk.rgb = function (cmyk) {
- const c = cmyk[0] / 100;
- const m = cmyk[1] / 100;
- const y = cmyk[2] / 100;
- const k = cmyk[3] / 100;
-
- const r = 1 - Math.min(1, c * (1 - k) + k);
- const g = 1 - Math.min(1, m * (1 - k) + k);
- const b = 1 - Math.min(1, y * (1 - k) + k);
-
- return [r * 255, g * 255, b * 255];
-};
-
-convert$4.xyz.rgb = function (xyz) {
- const x = xyz[0] / 100;
- const y = xyz[1] / 100;
- const z = xyz[2] / 100;
- let r;
- let g;
- let b;
-
- r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
- g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
- b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
-
- // Assume sRGB
- r = r > 0.0031308
- ? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
- : r * 12.92;
-
- g = g > 0.0031308
- ? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
- : g * 12.92;
-
- b = b > 0.0031308
- ? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
- : b * 12.92;
-
- r = Math.min(Math.max(0, r), 1);
- g = Math.min(Math.max(0, g), 1);
- b = Math.min(Math.max(0, b), 1);
-
- return [r * 255, g * 255, b * 255];
-};
-
-convert$4.xyz.lab = function (xyz) {
- let x = xyz[0];
- let y = xyz[1];
- let z = xyz[2];
-
- x /= 95.047;
- y /= 100;
- z /= 108.883;
-
- x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
- y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
- z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
-
- const l = (116 * y) - 16;
- const a = 500 * (x - y);
- const b = 200 * (y - z);
-
- return [l, a, b];
-};
-
-convert$4.lab.xyz = function (lab) {
- const l = lab[0];
- const a = lab[1];
- const b = lab[2];
- let x;
- let y;
- let z;
-
- y = (l + 16) / 116;
- x = a / 500 + y;
- z = y - b / 200;
-
- const y2 = y ** 3;
- const x2 = x ** 3;
- const z2 = z ** 3;
- y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
- x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
- z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
-
- x *= 95.047;
- y *= 100;
- z *= 108.883;
-
- return [x, y, z];
-};
-
-convert$4.lab.lch = function (lab) {
- const l = lab[0];
- const a = lab[1];
- const b = lab[2];
- let h;
-
- const hr = Math.atan2(b, a);
- h = hr * 360 / 2 / Math.PI;
-
- if (h < 0) {
- h += 360;
- }
-
- const c = Math.sqrt(a * a + b * b);
-
- return [l, c, h];
-};
-
-convert$4.lch.lab = function (lch) {
- const l = lch[0];
- const c = lch[1];
- const h = lch[2];
-
- const hr = h / 360 * 2 * Math.PI;
- const a = c * Math.cos(hr);
- const b = c * Math.sin(hr);
-
- return [l, a, b];
-};
-
-convert$4.rgb.ansi16 = function (args, saturation = null) {
- const [r, g, b] = args;
- let value = saturation === null ? convert$4.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
-
- value = Math.round(value / 50);
-
- if (value === 0) {
- return 30;
- }
-
- let ansi = 30
- + ((Math.round(b / 255) << 2)
- | (Math.round(g / 255) << 1)
- | Math.round(r / 255));
-
- if (value === 2) {
- ansi += 60;
- }
-
- return ansi;
-};
-
-convert$4.hsv.ansi16 = function (args) {
- // Optimization here; we already know the value and don't need to get
- // it converted for us.
- return convert$4.rgb.ansi16(convert$4.hsv.rgb(args), args[2]);
-};
-
-convert$4.rgb.ansi256 = function (args) {
- const r = args[0];
- const g = args[1];
- const b = args[2];
-
- // We use the extended greyscale palette here, with the exception of
- // black and white. normal palette only has 4 greyscale shades.
- if (r === g && g === b) {
- if (r < 8) {
- return 16;
- }
-
- if (r > 248) {
- return 231;
- }
-
- return Math.round(((r - 8) / 247) * 24) + 232;
- }
-
- const ansi = 16
- + (36 * Math.round(r / 255 * 5))
- + (6 * Math.round(g / 255 * 5))
- + Math.round(b / 255 * 5);
-
- return ansi;
-};
-
-convert$4.ansi16.rgb = function (args) {
- let color = args % 10;
-
- // Handle greyscale
- if (color === 0 || color === 7) {
- if (args > 50) {
- color += 3.5;
- }
-
- color = color / 10.5 * 255;
-
- return [color, color, color];
- }
-
- const mult = (~~(args > 50) + 1) * 0.5;
- const r = ((color & 1) * mult) * 255;
- const g = (((color >> 1) & 1) * mult) * 255;
- const b = (((color >> 2) & 1) * mult) * 255;
-
- return [r, g, b];
-};
-
-convert$4.ansi256.rgb = function (args) {
- // Handle greyscale
- if (args >= 232) {
- const c = (args - 232) * 10 + 8;
- return [c, c, c];
- }
-
- args -= 16;
-
- let rem;
- const r = Math.floor(args / 36) / 5 * 255;
- const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
- const b = (rem % 6) / 5 * 255;
-
- return [r, g, b];
-};
-
-convert$4.rgb.hex = function (args) {
- const integer = ((Math.round(args[0]) & 0xFF) << 16)
- + ((Math.round(args[1]) & 0xFF) << 8)
- + (Math.round(args[2]) & 0xFF);
-
- const string = integer.toString(16).toUpperCase();
- return '000000'.substring(string.length) + string;
-};
-
-convert$4.hex.rgb = function (args) {
- const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
- if (!match) {
- return [0, 0, 0];
- }
-
- let colorString = match[0];
-
- if (match[0].length === 3) {
- colorString = colorString.split('').map(char => {
- return char + char;
- }).join('');
- }
-
- const integer = parseInt(colorString, 16);
- const r = (integer >> 16) & 0xFF;
- const g = (integer >> 8) & 0xFF;
- const b = integer & 0xFF;
-
- return [r, g, b];
-};
-
-convert$4.rgb.hcg = function (rgb) {
- const r = rgb[0] / 255;
- const g = rgb[1] / 255;
- const b = rgb[2] / 255;
- const max = Math.max(Math.max(r, g), b);
- const min = Math.min(Math.min(r, g), b);
- const chroma = (max - min);
- let grayscale;
- let hue;
-
- if (chroma < 1) {
- grayscale = min / (1 - chroma);
- } else {
- grayscale = 0;
- }
-
- if (chroma <= 0) {
- hue = 0;
- } else
- if (max === r) {
- hue = ((g - b) / chroma) % 6;
- } else
- if (max === g) {
- hue = 2 + (b - r) / chroma;
- } else {
- hue = 4 + (r - g) / chroma;
- }
-
- hue /= 6;
- hue %= 1;
-
- return [hue * 360, chroma * 100, grayscale * 100];
-};
-
-convert$4.hsl.hcg = function (hsl) {
- const s = hsl[1] / 100;
- const l = hsl[2] / 100;
-
- const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
-
- let f = 0;
- if (c < 1.0) {
- f = (l - 0.5 * c) / (1.0 - c);
- }
-
- return [hsl[0], c * 100, f * 100];
-};
-
-convert$4.hsv.hcg = function (hsv) {
- const s = hsv[1] / 100;
- const v = hsv[2] / 100;
-
- const c = s * v;
- let f = 0;
-
- if (c < 1.0) {
- f = (v - c) / (1 - c);
- }
-
- return [hsv[0], c * 100, f * 100];
-};
-
-convert$4.hcg.rgb = function (hcg) {
- const h = hcg[0] / 360;
- const c = hcg[1] / 100;
- const g = hcg[2] / 100;
-
- if (c === 0.0) {
- return [g * 255, g * 255, g * 255];
- }
-
- const pure = [0, 0, 0];
- const hi = (h % 1) * 6;
- const v = hi % 1;
- const w = 1 - v;
- let mg = 0;
-
- /* eslint-disable max-statements-per-line */
- switch (Math.floor(hi)) {
- case 0:
- pure[0] = 1; pure[1] = v; pure[2] = 0; break;
- case 1:
- pure[0] = w; pure[1] = 1; pure[2] = 0; break;
- case 2:
- pure[0] = 0; pure[1] = 1; pure[2] = v; break;
- case 3:
- pure[0] = 0; pure[1] = w; pure[2] = 1; break;
- case 4:
- pure[0] = v; pure[1] = 0; pure[2] = 1; break;
- default:
- pure[0] = 1; pure[1] = 0; pure[2] = w;
- }
- /* eslint-enable max-statements-per-line */
-
- mg = (1.0 - c) * g;
-
- return [
- (c * pure[0] + mg) * 255,
- (c * pure[1] + mg) * 255,
- (c * pure[2] + mg) * 255
- ];
-};
-
-convert$4.hcg.hsv = function (hcg) {
- const c = hcg[1] / 100;
- const g = hcg[2] / 100;
-
- const v = c + g * (1.0 - c);
- let f = 0;
-
- if (v > 0.0) {
- f = c / v;
- }
-
- return [hcg[0], f * 100, v * 100];
-};
-
-convert$4.hcg.hsl = function (hcg) {
- const c = hcg[1] / 100;
- const g = hcg[2] / 100;
-
- const l = g * (1.0 - c) + 0.5 * c;
- let s = 0;
-
- if (l > 0.0 && l < 0.5) {
- s = c / (2 * l);
- } else
- if (l >= 0.5 && l < 1.0) {
- s = c / (2 * (1 - l));
- }
-
- return [hcg[0], s * 100, l * 100];
-};
-
-convert$4.hcg.hwb = function (hcg) {
- const c = hcg[1] / 100;
- const g = hcg[2] / 100;
- const v = c + g * (1.0 - c);
- return [hcg[0], (v - c) * 100, (1 - v) * 100];
-};
-
-convert$4.hwb.hcg = function (hwb) {
- const w = hwb[1] / 100;
- const b = hwb[2] / 100;
- const v = 1 - b;
- const c = v - w;
- let g = 0;
-
- if (c < 1) {
- g = (v - c) / (1 - c);
- }
-
- return [hwb[0], c * 100, g * 100];
-};
-
-convert$4.apple.rgb = function (apple) {
- return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
-};
-
-convert$4.rgb.apple = function (rgb) {
- return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
-};
-
-convert$4.gray.rgb = function (args) {
- return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
-};
-
-convert$4.gray.hsl = function (args) {
- return [0, 0, args[0]];
-};
-
-convert$4.gray.hsv = convert$4.gray.hsl;
-
-convert$4.gray.hwb = function (gray) {
- return [0, 100, gray[0]];
-};
-
-convert$4.gray.cmyk = function (gray) {
- return [0, 0, 0, gray[0]];
-};
-
-convert$4.gray.lab = function (gray) {
- return [gray[0], 0, 0];
-};
-
-convert$4.gray.hex = function (gray) {
- const val = Math.round(gray[0] / 100 * 255) & 0xFF;
- const integer = (val << 16) + (val << 8) + val;
-
- const string = integer.toString(16).toUpperCase();
- return '000000'.substring(string.length) + string;
-};
-
-convert$4.rgb.gray = function (rgb) {
- const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
- return [val / 255 * 100];
-};
-
-const conversions$1 = conversions$2;
-
-/*
- This function routes a model to all other models.
-
- all functions that are routed have a property `.conversion` attached
- to the returned synthetic function. This property is an array
- of strings, each with the steps in between the 'from' and 'to'
- color models (inclusive).
-
- conversions that are not possible simply are not included.
-*/
-
-function buildGraph() {
- const graph = {};
- // https://jsperf.com/object-keys-vs-for-in-with-closure/3
- const models = Object.keys(conversions$1);
-
- for (let len = models.length, i = 0; i < len; i++) {
- graph[models[i]] = {
- // http://jsperf.com/1-vs-infinity
- // micro-opt, but this is simple.
- distance: -1,
- parent: null
- };
- }
-
- return graph;
-}
-
-// https://en.wikipedia.org/wiki/Breadth-first_search
-function deriveBFS(fromModel) {
- const graph = buildGraph();
- const queue = [fromModel]; // Unshift -> queue -> pop
-
- graph[fromModel].distance = 0;
-
- while (queue.length) {
- const current = queue.pop();
- const adjacents = Object.keys(conversions$1[current]);
-
- for (let len = adjacents.length, i = 0; i < len; i++) {
- const adjacent = adjacents[i];
- const node = graph[adjacent];
-
- if (node.distance === -1) {
- node.distance = graph[current].distance + 1;
- node.parent = current;
- queue.unshift(adjacent);
- }
- }
- }
-
- return graph;
-}
-
-function link$1(from, to) {
- return function (args) {
- return to(from(args));
- };
-}
-
-function wrapConversion(toModel, graph) {
- const path = [graph[toModel].parent, toModel];
- let fn = conversions$1[graph[toModel].parent][toModel];
-
- let cur = graph[toModel].parent;
- while (graph[cur].parent) {
- path.unshift(graph[cur].parent);
- fn = link$1(conversions$1[graph[cur].parent][cur], fn);
- cur = graph[cur].parent;
- }
-
- fn.conversion = path;
- return fn;
-}
-
-var route$1 = function (fromModel) {
- const graph = deriveBFS(fromModel);
- const conversion = {};
-
- const models = Object.keys(graph);
- for (let len = models.length, i = 0; i < len; i++) {
- const toModel = models[i];
- const node = graph[toModel];
-
- if (node.parent === null) {
- // No possible conversion, or this node is the source model.
- continue;
- }
-
- conversion[toModel] = wrapConversion(toModel, graph);
- }
-
- return conversion;
-};
-
-const conversions = conversions$2;
-const route = route$1;
-
-const convert$3 = {};
-
-const models$3 = Object.keys(conversions);
-
-function wrapRaw(fn) {
- const wrappedFn = function (...args) {
- const arg0 = args[0];
- if (arg0 === undefined || arg0 === null) {
- return arg0;
- }
-
- if (arg0.length > 1) {
- args = arg0;
- }
-
- return fn(args);
- };
-
- // Preserve .conversion property if there is one
- if ('conversion' in fn) {
- wrappedFn.conversion = fn.conversion;
- }
-
- return wrappedFn;
-}
-
-function wrapRounded(fn) {
- const wrappedFn = function (...args) {
- const arg0 = args[0];
-
- if (arg0 === undefined || arg0 === null) {
- return arg0;
- }
-
- if (arg0.length > 1) {
- args = arg0;
- }
-
- const result = fn(args);
-
- // We're assuming the result is an array here.
- // see notice in conversions.js; don't use box types
- // in conversion functions.
- if (typeof result === 'object') {
- for (let len = result.length, i = 0; i < len; i++) {
- result[i] = Math.round(result[i]);
- }
- }
-
- return result;
- };
-
- // Preserve .conversion property if there is one
- if ('conversion' in fn) {
- wrappedFn.conversion = fn.conversion;
- }
-
- return wrappedFn;
-}
-
-models$3.forEach(fromModel => {
- convert$3[fromModel] = {};
-
- Object.defineProperty(convert$3[fromModel], 'channels', {value: conversions[fromModel].channels});
- Object.defineProperty(convert$3[fromModel], 'labels', {value: conversions[fromModel].labels});
-
- const routes = route(fromModel);
- const routeModels = Object.keys(routes);
-
- routeModels.forEach(toModel => {
- const fn = routes[toModel];
-
- convert$3[fromModel][toModel] = wrapRounded(fn);
- convert$3[fromModel][toModel].raw = wrapRaw(fn);
- });
-});
-
-var colorConvert = convert$3;
-
-(function (module) {
-
-const wrapAnsi16 = (fn, offset) => (...args) => {
- const code = fn(...args);
- return `\u001B[${code + offset}m`;
-};
-
-const wrapAnsi256 = (fn, offset) => (...args) => {
- const code = fn(...args);
- return `\u001B[${38 + offset};5;${code}m`;
-};
-
-const wrapAnsi16m = (fn, offset) => (...args) => {
- const rgb = fn(...args);
- return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
-};
-
-const ansi2ansi = n => n;
-const rgb2rgb = (r, g, b) => [r, g, b];
-
-const setLazyProperty = (object, property, get) => {
- Object.defineProperty(object, property, {
- get: () => {
- const value = get();
-
- Object.defineProperty(object, property, {
- value,
- enumerable: true,
- configurable: true
- });
-
- return value;
- },
- enumerable: true,
- configurable: true
- });
-};
-
-/** @type {typeof import('color-convert')} */
-let colorConvert$1;
-const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
- if (colorConvert$1 === undefined) {
- colorConvert$1 = colorConvert;
- }
-
- const offset = isBackground ? 10 : 0;
- const styles = {};
-
- for (const [sourceSpace, suite] of Object.entries(colorConvert$1)) {
- const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
- if (sourceSpace === targetSpace) {
- styles[name] = wrap(identity, offset);
- } else if (typeof suite === 'object') {
- styles[name] = wrap(suite[targetSpace], offset);
- }
- }
-
- return styles;
-};
-
-function assembleStyles() {
- const codes = new Map();
- const styles = {
- modifier: {
- reset: [0, 0],
- // 21 isn't widely supported and 22 does the same thing
- bold: [1, 22],
- dim: [2, 22],
- italic: [3, 23],
- underline: [4, 24],
- inverse: [7, 27],
- hidden: [8, 28],
- strikethrough: [9, 29]
- },
- color: {
- black: [30, 39],
- red: [31, 39],
- green: [32, 39],
- yellow: [33, 39],
- blue: [34, 39],
- magenta: [35, 39],
- cyan: [36, 39],
- white: [37, 39],
-
- // Bright color
- blackBright: [90, 39],
- redBright: [91, 39],
- greenBright: [92, 39],
- yellowBright: [93, 39],
- blueBright: [94, 39],
- magentaBright: [95, 39],
- cyanBright: [96, 39],
- whiteBright: [97, 39]
- },
- bgColor: {
- bgBlack: [40, 49],
- bgRed: [41, 49],
- bgGreen: [42, 49],
- bgYellow: [43, 49],
- bgBlue: [44, 49],
- bgMagenta: [45, 49],
- bgCyan: [46, 49],
- bgWhite: [47, 49],
-
- // Bright color
- bgBlackBright: [100, 49],
- bgRedBright: [101, 49],
- bgGreenBright: [102, 49],
- bgYellowBright: [103, 49],
- bgBlueBright: [104, 49],
- bgMagentaBright: [105, 49],
- bgCyanBright: [106, 49],
- bgWhiteBright: [107, 49]
- }
- };
-
- // Alias bright black as gray (and grey)
- styles.color.gray = styles.color.blackBright;
- styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
- styles.color.grey = styles.color.blackBright;
- styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
-
- for (const [groupName, group] of Object.entries(styles)) {
- for (const [styleName, style] of Object.entries(group)) {
- styles[styleName] = {
- open: `\u001B[${style[0]}m`,
- close: `\u001B[${style[1]}m`
- };
-
- group[styleName] = styles[styleName];
-
- codes.set(style[0], style[1]);
- }
-
- Object.defineProperty(styles, groupName, {
- value: group,
- enumerable: false
- });
- }
-
- Object.defineProperty(styles, 'codes', {
- value: codes,
- enumerable: false
- });
-
- styles.color.close = '\u001B[39m';
- styles.bgColor.close = '\u001B[49m';
-
- setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
- setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
- setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
- setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
- setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
- setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
-
- return styles;
-}
-
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
- enumerable: true,
- get: assembleStyles
-});
-}(ansiStyles$1));
-
-const stringReplaceAll$1 = (string, substring, replacer) => {
- let index = string.indexOf(substring);
- if (index === -1) {
- return string;
- }
-
- const substringLength = substring.length;
- let endIndex = 0;
- let returnValue = '';
- do {
- returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
- endIndex = index + substringLength;
- index = string.indexOf(substring, endIndex);
- } while (index !== -1);
-
- returnValue += string.substr(endIndex);
- return returnValue;
-};
-
-const stringEncaseCRLFWithFirstIndex$1 = (string, prefix, postfix, index) => {
- let endIndex = 0;
- let returnValue = '';
- do {
- const gotCR = string[index - 1] === '\r';
- returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
- endIndex = index + 1;
- index = string.indexOf('\n', endIndex);
- } while (index !== -1);
-
- returnValue += string.substr(endIndex);
- return returnValue;
-};
-
-var util$2 = {
- stringReplaceAll: stringReplaceAll$1,
- stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex$1
-};
-
-const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi;
-
-const ESCAPES = new Map([
- ['n', '\n'],
- ['r', '\r'],
- ['t', '\t'],
- ['b', '\b'],
- ['f', '\f'],
- ['v', '\v'],
- ['0', '\0'],
- ['\\', '\\'],
- ['e', '\u001B'],
- ['a', '\u0007']
-]);
-
-function unescape(c) {
- const u = c[0] === 'u';
- const bracket = c[1] === '{';
-
- if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
- return String.fromCharCode(parseInt(c.slice(1), 16));
- }
-
- if (u && bracket) {
- return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
- }
-
- return ESCAPES.get(c) || c;
-}
-
-function parseArguments(name, arguments_) {
- const results = [];
- const chunks = arguments_.trim().split(/\s*,\s*/g);
- let matches;
-
- for (const chunk of chunks) {
- const number = Number(chunk);
- if (!Number.isNaN(number)) {
- results.push(number);
- } else if ((matches = chunk.match(STRING_REGEX))) {
- results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
- } else {
- throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
- }
- }
-
- return results;
-}
-
-function parseStyle(style) {
- STYLE_REGEX.lastIndex = 0;
-
- const results = [];
- let matches;
-
- while ((matches = STYLE_REGEX.exec(style)) !== null) {
- const name = matches[1];
-
- if (matches[2]) {
- const args = parseArguments(name, matches[2]);
- results.push([name].concat(args));
- } else {
- results.push([name]);
- }
- }
-
- return results;
-}
-
-function buildStyle(chalk, styles) {
- const enabled = {};
-
- for (const layer of styles) {
- for (const style of layer.styles) {
- enabled[style[0]] = layer.inverse ? null : style.slice(1);
- }
- }
-
- let current = chalk;
- for (const [styleName, styles] of Object.entries(enabled)) {
- if (!Array.isArray(styles)) {
- continue;
- }
-
- if (!(styleName in current)) {
- throw new Error(`Unknown Chalk style: ${styleName}`);
- }
-
- current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
- }
-
- return current;
-}
-
-var templates = (chalk, temporary) => {
- const styles = [];
- const chunks = [];
- let chunk = [];
-
- // eslint-disable-next-line max-params
- temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
- if (escapeCharacter) {
- chunk.push(unescape(escapeCharacter));
- } else if (style) {
- const string = chunk.join('');
- chunk = [];
- chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
- styles.push({inverse, styles: parseStyle(style)});
- } else if (close) {
- if (styles.length === 0) {
- throw new Error('Found extraneous } in Chalk template literal');
- }
-
- chunks.push(buildStyle(chalk, styles)(chunk.join('')));
- chunk = [];
- styles.pop();
- } else {
- chunk.push(character);
- }
- });
-
- chunks.push(chunk.join(''));
-
- if (styles.length > 0) {
- const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
- throw new Error(errMsg);
- }
-
- return chunks.join('');
-};
-
-const ansiStyles = ansiStyles$1.exports;
-const {stdout: stdoutColor, stderr: stderrColor} = supportsColor_1$1;
-const {
- stringReplaceAll,
- stringEncaseCRLFWithFirstIndex
-} = util$2;
-
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = [
- 'ansi',
- 'ansi',
- 'ansi256',
- 'ansi16m'
-];
-
-const styles = Object.create(null);
-
-const applyOptions = (object, options = {}) => {
- if (options.level > 3 || options.level < 0) {
- throw new Error('The `level` option should be an integer from 0 to 3');
- }
-
- // Detect level if not set manually
- const colorLevel = stdoutColor ? stdoutColor.level : 0;
- object.level = options.level === undefined ? colorLevel : options.level;
-};
-
-class ChalkClass {
- constructor(options) {
- return chalkFactory(options);
- }
-}
-
-const chalkFactory = options => {
- const chalk = {};
- applyOptions(chalk, options);
-
- chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
-
- Object.setPrototypeOf(chalk, Chalk.prototype);
- Object.setPrototypeOf(chalk.template, chalk);
-
- chalk.template.constructor = () => {
- throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
- };
-
- chalk.template.Instance = ChalkClass;
-
- return chalk.template;
-};
-
-function Chalk(options) {
- return chalkFactory(options);
-}
-
-for (const [styleName, style] of Object.entries(ansiStyles)) {
- styles[styleName] = {
- get() {
- const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
- Object.defineProperty(this, styleName, {value: builder});
- return builder;
- }
- };
-}
-
-styles.visible = {
- get() {
- const builder = createBuilder(this, this._styler, true);
- Object.defineProperty(this, 'visible', {value: builder});
- return builder;
- }
-};
-
-const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
-
-for (const model of usedModels) {
- styles[model] = {
- get() {
- const {level} = this;
- return function (...arguments_) {
- const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
- return createBuilder(this, styler, this._isEmpty);
- };
- }
- };
-}
-
-for (const model of usedModels) {
- const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
- styles[bgModel] = {
- get() {
- const {level} = this;
- return function (...arguments_) {
- const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
- return createBuilder(this, styler, this._isEmpty);
- };
- }
- };
-}
-
-const proto$1 = Object.defineProperties(() => {}, {
- ...styles,
- level: {
- enumerable: true,
- get() {
- return this._generator.level;
- },
- set(level) {
- this._generator.level = level;
- }
- }
-});
-
-const createStyler = (open, close, parent) => {
- let openAll;
- let closeAll;
- if (parent === undefined) {
- openAll = open;
- closeAll = close;
- } else {
- openAll = parent.openAll + open;
- closeAll = close + parent.closeAll;
- }
-
- return {
- open,
- close,
- openAll,
- closeAll,
- parent
- };
-};
-
-const createBuilder = (self, _styler, _isEmpty) => {
- const builder = (...arguments_) => {
- // Single argument is hot path, implicit coercion is faster than anything
- // eslint-disable-next-line no-implicit-coercion
- return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
- };
-
- // `__proto__` is used because we must return a function, but there is
- // no way to create a function with a different prototype
- builder.__proto__ = proto$1; // eslint-disable-line no-proto
-
- builder._generator = self;
- builder._styler = _styler;
- builder._isEmpty = _isEmpty;
-
- return builder;
-};
-
-const applyStyle = (self, string) => {
- if (self.level <= 0 || !string) {
- return self._isEmpty ? '' : string;
- }
-
- let styler = self._styler;
-
- if (styler === undefined) {
- return string;
- }
-
- const {openAll, closeAll} = styler;
- if (string.indexOf('\u001B') !== -1) {
- while (styler !== undefined) {
- // Replace any instances already present with a re-opening code
- // otherwise only the part of the string until said closing code
- // will be colored, and the rest will simply be 'plain'.
- string = stringReplaceAll(string, styler.close, styler.open);
-
- styler = styler.parent;
- }
- }
-
- // We can move both next actions out of loop, because remaining actions in loop won't have
- // any/visible effect on parts we add here. Close the styling before a linebreak and reopen
- // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
- const lfIndex = string.indexOf('\n');
- if (lfIndex !== -1) {
- string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
- }
-
- return openAll + string + closeAll;
-};
-
-let template;
-const chalkTag = (chalk, ...strings) => {
- const [firstString] = strings;
-
- if (!Array.isArray(firstString)) {
- // If chalk() was called by itself or with a string,
- // return the string itself as a string.
- return strings.join(' ');
- }
-
- const arguments_ = strings.slice(1);
- const parts = [firstString.raw[0]];
-
- for (let i = 1; i < firstString.length; i++) {
- parts.push(
- String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
- String(firstString.raw[i])
- );
- }
-
- if (template === undefined) {
- template = templates;
- }
-
- return template(chalk, parts.join(''));
-};
-
-Object.defineProperties(Chalk.prototype, styles);
-
-const chalk$1 = Chalk(); // eslint-disable-line new-cap
-chalk$1.supportsColor = stdoutColor;
-chalk$1.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
-chalk$1.stderr.supportsColor = stderrColor;
-
-// For TypeScript
-chalk$1.Level = {
- None: 0,
- Basic: 1,
- Ansi256: 2,
- TrueColor: 3,
- 0: 'None',
- 1: 'Basic',
- 2: 'Ansi256',
- 3: 'TrueColor'
-};
-
-var source$1 = chalk$1;
-
-var chokidar$1 = {};
-
-var utils$7 = {};
-
-const path$3 = require$$0__default$2['default'];
-const WIN_SLASH = '\\\\/';
-const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-
-/**
- * Posix glob regex
- */
-
-const DOT_LITERAL = '\\.';
-const PLUS_LITERAL = '\\+';
-const QMARK_LITERAL = '\\?';
-const SLASH_LITERAL = '\\/';
-const ONE_CHAR = '(?=.)';
-const QMARK = '[^/]';
-const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-const NO_DOT = `(?!${DOT_LITERAL})`;
-const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR$1 = `${QMARK}*?`;
-
-const POSIX_CHARS = {
- DOT_LITERAL,
- PLUS_LITERAL,
- QMARK_LITERAL,
- SLASH_LITERAL,
- ONE_CHAR,
- QMARK,
- END_ANCHOR,
- DOTS_SLASH,
- NO_DOT,
- NO_DOTS,
- NO_DOT_SLASH,
- NO_DOTS_SLASH,
- QMARK_NO_DOT,
- STAR: STAR$1,
- START_ANCHOR
-};
-
-/**
- * Windows glob regex
- */
-
-const WINDOWS_CHARS = {
- ...POSIX_CHARS,
-
- SLASH_LITERAL: `[${WIN_SLASH}]`,
- QMARK: WIN_NO_SLASH,
- STAR: `${WIN_NO_SLASH}*?`,
- DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
- NO_DOT: `(?!${DOT_LITERAL})`,
- NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
- NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
- NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
- QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
- START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
- END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
-};
-
-/**
- * POSIX Bracket Regex
- */
-
-const POSIX_REGEX_SOURCE$1 = {
- alnum: 'a-zA-Z0-9',
- alpha: 'a-zA-Z',
- ascii: '\\x00-\\x7F',
- blank: ' \\t',
- cntrl: '\\x00-\\x1F\\x7F',
- digit: '0-9',
- graph: '\\x21-\\x7E',
- lower: 'a-z',
- print: '\\x20-\\x7E ',
- punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
- space: ' \\t\\r\\n\\v\\f',
- upper: 'A-Z',
- word: 'A-Za-z0-9_',
- xdigit: 'A-Fa-f0-9'
-};
-
-var constants$5 = {
- MAX_LENGTH: 1024 * 64,
- POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-
- // regular expressions
- REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
- REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
- REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
- REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
- REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
- REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-
- // Replace globs with equivalent patterns to reduce parsing time.
- REPLACEMENTS: {
- '***': '*',
- '**/**': '**',
- '**/**/**': '**'
- },
-
- // Digits
- CHAR_0: 48, /* 0 */
- CHAR_9: 57, /* 9 */
-
- // Alphabet chars.
- CHAR_UPPERCASE_A: 65, /* A */
- CHAR_LOWERCASE_A: 97, /* a */
- CHAR_UPPERCASE_Z: 90, /* Z */
- CHAR_LOWERCASE_Z: 122, /* z */
-
- CHAR_LEFT_PARENTHESES: 40, /* ( */
- CHAR_RIGHT_PARENTHESES: 41, /* ) */
-
- CHAR_ASTERISK: 42, /* * */
-
- // Non-alphabetic chars.
- CHAR_AMPERSAND: 38, /* & */
- CHAR_AT: 64, /* @ */
- CHAR_BACKWARD_SLASH: 92, /* \ */
- CHAR_CARRIAGE_RETURN: 13, /* \r */
- CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
- CHAR_COLON: 58, /* : */
- CHAR_COMMA: 44, /* , */
- CHAR_DOT: 46, /* . */
- CHAR_DOUBLE_QUOTE: 34, /* " */
- CHAR_EQUAL: 61, /* = */
- CHAR_EXCLAMATION_MARK: 33, /* ! */
- CHAR_FORM_FEED: 12, /* \f */
- CHAR_FORWARD_SLASH: 47, /* / */
- CHAR_GRAVE_ACCENT: 96, /* ` */
- CHAR_HASH: 35, /* # */
- CHAR_HYPHEN_MINUS: 45, /* - */
- CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
- CHAR_LEFT_CURLY_BRACE: 123, /* { */
- CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
- CHAR_LINE_FEED: 10, /* \n */
- CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
- CHAR_PERCENT: 37, /* % */
- CHAR_PLUS: 43, /* + */
- CHAR_QUESTION_MARK: 63, /* ? */
- CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
- CHAR_RIGHT_CURLY_BRACE: 125, /* } */
- CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
- CHAR_SEMICOLON: 59, /* ; */
- CHAR_SINGLE_QUOTE: 39, /* ' */
- CHAR_SPACE: 32, /* */
- CHAR_TAB: 9, /* \t */
- CHAR_UNDERSCORE: 95, /* _ */
- CHAR_VERTICAL_LINE: 124, /* | */
- CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-
- SEP: path$3.sep,
-
- /**
- * Create EXTGLOB_CHARS
- */
-
- extglobChars(chars) {
- return {
- '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
- '?': { type: 'qmark', open: '(?:', close: ')?' },
- '+': { type: 'plus', open: '(?:', close: ')+' },
- '*': { type: 'star', open: '(?:', close: ')*' },
- '@': { type: 'at', open: '(?:', close: ')' }
- };
- },
-
- /**
- * Create GLOB_CHARS
- */
-
- globChars(win32) {
- return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
- }
-};
-
-(function (exports) {
-
-const path = require$$0__default$2['default'];
-const win32 = process.platform === 'win32';
-const {
- REGEX_BACKSLASH,
- REGEX_REMOVE_BACKSLASH,
- REGEX_SPECIAL_CHARS,
- REGEX_SPECIAL_CHARS_GLOBAL
-} = constants$5;
-
-exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
-exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
-exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
-exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
-
-exports.removeBackslashes = str => {
- return str.replace(REGEX_REMOVE_BACKSLASH, match => {
- return match === '\\' ? '' : match;
- });
-};
-
-exports.supportsLookbehinds = () => {
- const segs = process.version.slice(1).split('.').map(Number);
- if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
- return true;
- }
- return false;
-};
-
-exports.isWindows = options => {
- if (options && typeof options.windows === 'boolean') {
- return options.windows;
- }
- return win32 === true || path.sep === '\\';
-};
-
-exports.escapeLast = (input, char, lastIdx) => {
- const idx = input.lastIndexOf(char, lastIdx);
- if (idx === -1) return input;
- if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
- return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-};
-
-exports.removePrefix = (input, state = {}) => {
- let output = input;
- if (output.startsWith('./')) {
- output = output.slice(2);
- state.prefix = './';
- }
- return output;
-};
-
-exports.wrapOutput = (input, state = {}, options = {}) => {
- const prepend = options.contains ? '' : '^';
- const append = options.contains ? '' : '$';
-
- let output = `${prepend}(?:${input})${append}`;
- if (state.negated === true) {
- output = `(?:^(?!${output}).*$)`;
- }
- return output;
-};
-}(utils$7));
-
-const utils$6 = utils$7;
-const {
- CHAR_ASTERISK: CHAR_ASTERISK$1, /* * */
- CHAR_AT, /* @ */
- CHAR_BACKWARD_SLASH, /* \ */
- CHAR_COMMA: CHAR_COMMA$2, /* , */
- CHAR_DOT: CHAR_DOT$1, /* . */
- CHAR_EXCLAMATION_MARK, /* ! */
- CHAR_FORWARD_SLASH, /* / */
- CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
- CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
- CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$2, /* [ */
- CHAR_PLUS, /* + */
- CHAR_QUESTION_MARK, /* ? */
- CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
- CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
- CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$2 /* ] */
-} = constants$5;
-
-const isPathSeparator = code => {
- return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
-
-const depth = token => {
- if (token.isPrefix !== true) {
- token.depth = token.isGlobstar ? Infinity : 1;
- }
-};
-
-/**
- * Quickly scans a glob pattern and returns an object with a handful of
- * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
- * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
- *
- * ```js
- * const pm = require('picomatch');
- * console.log(pm.scan('foo/bar/*.js'));
- * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {Object} Returns an object with tokens and regex source string.
- * @api public
- */
-
-const scan$1 = (input, options) => {
- const opts = options || {};
-
- const length = input.length - 1;
- const scanToEnd = opts.parts === true || opts.scanToEnd === true;
- const slashes = [];
- const tokens = [];
- const parts = [];
-
- let str = input;
- let index = -1;
- let start = 0;
- let lastIndex = 0;
- let isBrace = false;
- let isBracket = false;
- let isGlob = false;
- let isExtglob = false;
- let isGlobstar = false;
- let braceEscaped = false;
- let backslashes = false;
- let negated = false;
- let negatedExtglob = false;
- let finished = false;
- let braces = 0;
- let prev;
- let code;
- let token = { value: '', depth: 0, isGlob: false };
-
- const eos = () => index >= length;
- const peek = () => str.charCodeAt(index + 1);
- const advance = () => {
- prev = code;
- return str.charCodeAt(++index);
- };
-
- while (index < length) {
- code = advance();
- let next;
-
- if (code === CHAR_BACKWARD_SLASH) {
- backslashes = token.backslashes = true;
- code = advance();
-
- if (code === CHAR_LEFT_CURLY_BRACE$1) {
- braceEscaped = true;
- }
- continue;
- }
-
- if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {
- braces++;
-
- while (eos() !== true && (code = advance())) {
- if (code === CHAR_BACKWARD_SLASH) {
- backslashes = token.backslashes = true;
- advance();
- continue;
- }
-
- if (code === CHAR_LEFT_CURLY_BRACE$1) {
- braces++;
- continue;
- }
-
- if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {
- isBrace = token.isBrace = true;
- isGlob = token.isGlob = true;
- finished = true;
-
- if (scanToEnd === true) {
- continue;
- }
-
- break;
- }
-
- if (braceEscaped !== true && code === CHAR_COMMA$2) {
- isBrace = token.isBrace = true;
- isGlob = token.isGlob = true;
- finished = true;
-
- if (scanToEnd === true) {
- continue;
- }
-
- break;
- }
-
- if (code === CHAR_RIGHT_CURLY_BRACE$1) {
- braces--;
-
- if (braces === 0) {
- braceEscaped = false;
- isBrace = token.isBrace = true;
- finished = true;
- break;
- }
- }
- }
-
- if (scanToEnd === true) {
- continue;
- }
-
- break;
- }
-
- if (code === CHAR_FORWARD_SLASH) {
- slashes.push(index);
- tokens.push(token);
- token = { value: '', depth: 0, isGlob: false };
-
- if (finished === true) continue;
- if (prev === CHAR_DOT$1 && index === (start + 1)) {
- start += 2;
- continue;
- }
-
- lastIndex = index + 1;
- continue;
- }
-
- if (opts.noext !== true) {
- const isExtglobChar = code === CHAR_PLUS
- || code === CHAR_AT
- || code === CHAR_ASTERISK$1
- || code === CHAR_QUESTION_MARK
- || code === CHAR_EXCLAMATION_MARK;
-
- if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {
- isGlob = token.isGlob = true;
- isExtglob = token.isExtglob = true;
- finished = true;
- if (code === CHAR_EXCLAMATION_MARK && index === start) {
- negatedExtglob = true;
- }
-
- if (scanToEnd === true) {
- while (eos() !== true && (code = advance())) {
- if (code === CHAR_BACKWARD_SLASH) {
- backslashes = token.backslashes = true;
- code = advance();
- continue;
- }
-
- if (code === CHAR_RIGHT_PARENTHESES$1) {
- isGlob = token.isGlob = true;
- finished = true;
- break;
- }
- }
- continue;
- }
- break;
- }
- }
-
- if (code === CHAR_ASTERISK$1) {
- if (prev === CHAR_ASTERISK$1) isGlobstar = token.isGlobstar = true;
- isGlob = token.isGlob = true;
- finished = true;
-
- if (scanToEnd === true) {
- continue;
- }
- break;
- }
-
- if (code === CHAR_QUESTION_MARK) {
- isGlob = token.isGlob = true;
- finished = true;
-
- if (scanToEnd === true) {
- continue;
- }
- break;
- }
-
- if (code === CHAR_LEFT_SQUARE_BRACKET$2) {
- while (eos() !== true && (next = advance())) {
- if (next === CHAR_BACKWARD_SLASH) {
- backslashes = token.backslashes = true;
- advance();
- continue;
- }
-
- if (next === CHAR_RIGHT_SQUARE_BRACKET$2) {
- isBracket = token.isBracket = true;
- isGlob = token.isGlob = true;
- finished = true;
- break;
- }
- }
-
- if (scanToEnd === true) {
- continue;
- }
-
- break;
- }
-
- if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
- negated = token.negated = true;
- start++;
- continue;
- }
-
- if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {
- isGlob = token.isGlob = true;
-
- if (scanToEnd === true) {
- while (eos() !== true && (code = advance())) {
- if (code === CHAR_LEFT_PARENTHESES$1) {
- backslashes = token.backslashes = true;
- code = advance();
- continue;
- }
-
- if (code === CHAR_RIGHT_PARENTHESES$1) {
- finished = true;
- break;
- }
- }
- continue;
- }
- break;
- }
-
- if (isGlob === true) {
- finished = true;
-
- if (scanToEnd === true) {
- continue;
- }
-
- break;
- }
- }
-
- if (opts.noext === true) {
- isExtglob = false;
- isGlob = false;
- }
-
- let base = str;
- let prefix = '';
- let glob = '';
-
- if (start > 0) {
- prefix = str.slice(0, start);
- str = str.slice(start);
- lastIndex -= start;
- }
-
- if (base && isGlob === true && lastIndex > 0) {
- base = str.slice(0, lastIndex);
- glob = str.slice(lastIndex);
- } else if (isGlob === true) {
- base = '';
- glob = str;
- } else {
- base = str;
- }
-
- if (base && base !== '' && base !== '/' && base !== str) {
- if (isPathSeparator(base.charCodeAt(base.length - 1))) {
- base = base.slice(0, -1);
- }
- }
-
- if (opts.unescape === true) {
- if (glob) glob = utils$6.removeBackslashes(glob);
-
- if (base && backslashes === true) {
- base = utils$6.removeBackslashes(base);
- }
- }
-
- const state = {
- prefix,
- input,
- start,
- base,
- glob,
- isBrace,
- isBracket,
- isGlob,
- isExtglob,
- isGlobstar,
- negated,
- negatedExtglob
- };
-
- if (opts.tokens === true) {
- state.maxDepth = 0;
- if (!isPathSeparator(code)) {
- tokens.push(token);
- }
- state.tokens = tokens;
- }
-
- if (opts.parts === true || opts.tokens === true) {
- let prevIndex;
-
- for (let idx = 0; idx < slashes.length; idx++) {
- const n = prevIndex ? prevIndex + 1 : start;
- const i = slashes[idx];
- const value = input.slice(n, i);
- if (opts.tokens) {
- if (idx === 0 && start !== 0) {
- tokens[idx].isPrefix = true;
- tokens[idx].value = prefix;
- } else {
- tokens[idx].value = value;
- }
- depth(tokens[idx]);
- state.maxDepth += tokens[idx].depth;
- }
- if (idx !== 0 || value !== '') {
- parts.push(value);
- }
- prevIndex = i;
- }
-
- if (prevIndex && prevIndex + 1 < input.length) {
- const value = input.slice(prevIndex + 1);
- parts.push(value);
-
- if (opts.tokens) {
- tokens[tokens.length - 1].value = value;
- depth(tokens[tokens.length - 1]);
- state.maxDepth += tokens[tokens.length - 1].depth;
- }
- }
-
- state.slashes = slashes;
- state.parts = parts;
- }
-
- return state;
-};
-
-var scan_1 = scan$1;
-
-const constants$4 = constants$5;
-const utils$5 = utils$7;
-
-/**
- * Constants
- */
-
-const {
- MAX_LENGTH: MAX_LENGTH$4,
- POSIX_REGEX_SOURCE,
- REGEX_NON_SPECIAL_CHARS,
- REGEX_SPECIAL_CHARS_BACKREF,
- REPLACEMENTS
-} = constants$4;
-
-/**
- * Helpers
- */
-
-const expandRange = (args, options) => {
- if (typeof options.expandRange === 'function') {
- return options.expandRange(...args, options);
- }
-
- args.sort();
- const value = `[${args.join('-')}]`;
-
- try {
- /* eslint-disable-next-line no-new */
- new RegExp(value);
- } catch (ex) {
- return args.map(v => utils$5.escapeRegex(v)).join('..');
- }
-
- return value;
-};
-
-/**
- * Create the message for a syntax error
- */
-
-const syntaxError$1 = (type, char) => {
- return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
-
-/**
- * Parse the given input string.
- * @param {String} input
- * @param {Object} options
- * @return {Object}
- */
-
-const parse$8 = (input, options) => {
- if (typeof input !== 'string') {
- throw new TypeError('Expected a string');
- }
-
- input = REPLACEMENTS[input] || input;
-
- const opts = { ...options };
- const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
-
- let len = input.length;
- if (len > max) {
- throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
- }
-
- const bos = { type: 'bos', value: '', output: opts.prepend || '' };
- const tokens = [bos];
-
- const capture = opts.capture ? '' : '?:';
- const win32 = utils$5.isWindows(options);
-
- // create constants based on platform, for windows or posix
- const PLATFORM_CHARS = constants$4.globChars(win32);
- const EXTGLOB_CHARS = constants$4.extglobChars(PLATFORM_CHARS);
-
- const {
- DOT_LITERAL,
- PLUS_LITERAL,
- SLASH_LITERAL,
- ONE_CHAR,
- DOTS_SLASH,
- NO_DOT,
- NO_DOT_SLASH,
- NO_DOTS_SLASH,
- QMARK,
- QMARK_NO_DOT,
- STAR,
- START_ANCHOR
- } = PLATFORM_CHARS;
-
- const globstar = opts => {
- return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
- };
-
- const nodot = opts.dot ? '' : NO_DOT;
- const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
- let star = opts.bash === true ? globstar(opts) : STAR;
-
- if (opts.capture) {
- star = `(${star})`;
- }
-
- // minimatch options support
- if (typeof opts.noext === 'boolean') {
- opts.noextglob = opts.noext;
- }
-
- const state = {
- input,
- index: -1,
- start: 0,
- dot: opts.dot === true,
- consumed: '',
- output: '',
- prefix: '',
- backtrack: false,
- negated: false,
- brackets: 0,
- braces: 0,
- parens: 0,
- quotes: 0,
- globstar: false,
- tokens
- };
-
- input = utils$5.removePrefix(input, state);
- len = input.length;
-
- const extglobs = [];
- const braces = [];
- const stack = [];
- let prev = bos;
- let value;
-
- /**
- * Tokenizing helpers
- */
-
- const eos = () => state.index === len - 1;
- const peek = state.peek = (n = 1) => input[state.index + n];
- const advance = state.advance = () => input[++state.index] || '';
- const remaining = () => input.slice(state.index + 1);
- const consume = (value = '', num = 0) => {
- state.consumed += value;
- state.index += num;
- };
-
- const append = token => {
- state.output += token.output != null ? token.output : token.value;
- consume(token.value);
- };
-
- const negate = () => {
- let count = 1;
-
- while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
- advance();
- state.start++;
- count++;
- }
-
- if (count % 2 === 0) {
- return false;
- }
-
- state.negated = true;
- state.start++;
- return true;
- };
-
- const increment = type => {
- state[type]++;
- stack.push(type);
- };
-
- const decrement = type => {
- state[type]--;
- stack.pop();
- };
-
- /**
- * Push tokens onto the tokens array. This helper speeds up
- * tokenizing by 1) helping us avoid backtracking as much as possible,
- * and 2) helping us avoid creating extra tokens when consecutive
- * characters are plain text. This improves performance and simplifies
- * lookbehinds.
- */
-
- const push = tok => {
- if (prev.type === 'globstar') {
- const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
- const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
-
- if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
- state.output = state.output.slice(0, -prev.output.length);
- prev.type = 'star';
- prev.value = '*';
- prev.output = star;
- state.output += prev.output;
- }
- }
-
- if (extglobs.length && tok.type !== 'paren') {
- extglobs[extglobs.length - 1].inner += tok.value;
- }
-
- if (tok.value || tok.output) append(tok);
- if (prev && prev.type === 'text' && tok.type === 'text') {
- prev.value += tok.value;
- prev.output = (prev.output || '') + tok.value;
- return;
- }
-
- tok.prev = prev;
- tokens.push(tok);
- prev = tok;
- };
-
- const extglobOpen = (type, value) => {
- const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
-
- token.prev = prev;
- token.parens = state.parens;
- token.output = state.output;
- const output = (opts.capture ? '(' : '') + token.open;
-
- increment('parens');
- push({ type, value, output: state.output ? '' : ONE_CHAR });
- push({ type: 'paren', extglob: true, value: advance(), output });
- extglobs.push(token);
- };
-
- const extglobClose = token => {
- let output = token.close + (opts.capture ? ')' : '');
- let rest;
-
- if (token.type === 'negate') {
- let extglobStar = star;
-
- if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
- extglobStar = globstar(opts);
- }
-
- if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
- output = token.close = `)$))${extglobStar}`;
- }
-
- if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
- output = token.close = `)${rest})${extglobStar})`;
- }
-
- if (token.prev.type === 'bos') {
- state.negatedExtglob = true;
- }
- }
-
- push({ type: 'paren', extglob: true, value, output });
- decrement('parens');
- };
-
- /**
- * Fast paths
- */
-
- if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
- let backslashes = false;
-
- let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
- if (first === '\\') {
- backslashes = true;
- return m;
- }
-
- if (first === '?') {
- if (esc) {
- return esc + first + (rest ? QMARK.repeat(rest.length) : '');
- }
- if (index === 0) {
- return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
- }
- return QMARK.repeat(chars.length);
- }
-
- if (first === '.') {
- return DOT_LITERAL.repeat(chars.length);
- }
-
- if (first === '*') {
- if (esc) {
- return esc + first + (rest ? star : '');
- }
- return star;
- }
- return esc ? m : `\\${m}`;
- });
-
- if (backslashes === true) {
- if (opts.unescape === true) {
- output = output.replace(/\\/g, '');
- } else {
- output = output.replace(/\\+/g, m => {
- return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
- });
- }
- }
-
- if (output === input && opts.contains === true) {
- state.output = input;
- return state;
- }
-
- state.output = utils$5.wrapOutput(output, state, options);
- return state;
- }
-
- /**
- * Tokenize input until we reach end-of-string
- */
-
- while (!eos()) {
- value = advance();
-
- if (value === '\u0000') {
- continue;
- }
-
- /**
- * Escaped characters
- */
-
- if (value === '\\') {
- const next = peek();
-
- if (next === '/' && opts.bash !== true) {
- continue;
- }
-
- if (next === '.' || next === ';') {
- continue;
- }
-
- if (!next) {
- value += '\\';
- push({ type: 'text', value });
- continue;
- }
-
- // collapse slashes to reduce potential for exploits
- const match = /^\\+/.exec(remaining());
- let slashes = 0;
-
- if (match && match[0].length > 2) {
- slashes = match[0].length;
- state.index += slashes;
- if (slashes % 2 !== 0) {
- value += '\\';
- }
- }
-
- if (opts.unescape === true) {
- value = advance();
- } else {
- value += advance();
- }
-
- if (state.brackets === 0) {
- push({ type: 'text', value });
- continue;
- }
- }
-
- /**
- * If we're inside a regex character class, continue
- * until we reach the closing bracket.
- */
-
- if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
- if (opts.posix !== false && value === ':') {
- const inner = prev.value.slice(1);
- if (inner.includes('[')) {
- prev.posix = true;
-
- if (inner.includes(':')) {
- const idx = prev.value.lastIndexOf('[');
- const pre = prev.value.slice(0, idx);
- const rest = prev.value.slice(idx + 2);
- const posix = POSIX_REGEX_SOURCE[rest];
- if (posix) {
- prev.value = pre + posix;
- state.backtrack = true;
- advance();
-
- if (!bos.output && tokens.indexOf(prev) === 1) {
- bos.output = ONE_CHAR;
- }
- continue;
- }
- }
- }
- }
-
- if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
- value = `\\${value}`;
- }
-
- if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
- value = `\\${value}`;
- }
-
- if (opts.posix === true && value === '!' && prev.value === '[') {
- value = '^';
- }
-
- prev.value += value;
- append({ value });
- continue;
- }
-
- /**
- * If we're inside a quoted string, continue
- * until we reach the closing double quote.
- */
-
- if (state.quotes === 1 && value !== '"') {
- value = utils$5.escapeRegex(value);
- prev.value += value;
- append({ value });
- continue;
- }
-
- /**
- * Double quotes
- */
-
- if (value === '"') {
- state.quotes = state.quotes === 1 ? 0 : 1;
- if (opts.keepQuotes === true) {
- push({ type: 'text', value });
- }
- continue;
- }
-
- /**
- * Parentheses
- */
-
- if (value === '(') {
- increment('parens');
- push({ type: 'paren', value });
- continue;
- }
-
- if (value === ')') {
- if (state.parens === 0 && opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError$1('opening', '('));
- }
-
- const extglob = extglobs[extglobs.length - 1];
- if (extglob && state.parens === extglob.parens + 1) {
- extglobClose(extglobs.pop());
- continue;
- }
-
- push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
- decrement('parens');
- continue;
- }
-
- /**
- * Square brackets
- */
-
- if (value === '[') {
- if (opts.nobracket === true || !remaining().includes(']')) {
- if (opts.nobracket !== true && opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError$1('closing', ']'));
- }
-
- value = `\\${value}`;
- } else {
- increment('brackets');
- }
-
- push({ type: 'bracket', value });
- continue;
- }
-
- if (value === ']') {
- if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
- push({ type: 'text', value, output: `\\${value}` });
- continue;
- }
-
- if (state.brackets === 0) {
- if (opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError$1('opening', '['));
- }
-
- push({ type: 'text', value, output: `\\${value}` });
- continue;
- }
-
- decrement('brackets');
-
- const prevValue = prev.value.slice(1);
- if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
- value = `/${value}`;
- }
-
- prev.value += value;
- append({ value });
-
- // when literal brackets are explicitly disabled
- // assume we should match with a regex character class
- if (opts.literalBrackets === false || utils$5.hasRegexChars(prevValue)) {
- continue;
- }
-
- const escaped = utils$5.escapeRegex(prev.value);
- state.output = state.output.slice(0, -prev.value.length);
-
- // when literal brackets are explicitly enabled
- // assume we should escape the brackets to match literal characters
- if (opts.literalBrackets === true) {
- state.output += escaped;
- prev.value = escaped;
- continue;
- }
-
- // when the user specifies nothing, try to match both
- prev.value = `(${capture}${escaped}|${prev.value})`;
- state.output += prev.value;
- continue;
- }
-
- /**
- * Braces
- */
-
- if (value === '{' && opts.nobrace !== true) {
- increment('braces');
-
- const open = {
- type: 'brace',
- value,
- output: '(',
- outputIndex: state.output.length,
- tokensIndex: state.tokens.length
- };
-
- braces.push(open);
- push(open);
- continue;
- }
-
- if (value === '}') {
- const brace = braces[braces.length - 1];
-
- if (opts.nobrace === true || !brace) {
- push({ type: 'text', value, output: value });
- continue;
- }
-
- let output = ')';
-
- if (brace.dots === true) {
- const arr = tokens.slice();
- const range = [];
-
- for (let i = arr.length - 1; i >= 0; i--) {
- tokens.pop();
- if (arr[i].type === 'brace') {
- break;
- }
- if (arr[i].type !== 'dots') {
- range.unshift(arr[i].value);
- }
- }
-
- output = expandRange(range, opts);
- state.backtrack = true;
- }
-
- if (brace.comma !== true && brace.dots !== true) {
- const out = state.output.slice(0, brace.outputIndex);
- const toks = state.tokens.slice(brace.tokensIndex);
- brace.value = brace.output = '\\{';
- value = output = '\\}';
- state.output = out;
- for (const t of toks) {
- state.output += (t.output || t.value);
- }
- }
-
- push({ type: 'brace', value, output });
- decrement('braces');
- braces.pop();
- continue;
- }
-
- /**
- * Pipes
- */
-
- if (value === '|') {
- if (extglobs.length > 0) {
- extglobs[extglobs.length - 1].conditions++;
- }
- push({ type: 'text', value });
- continue;
- }
-
- /**
- * Commas
- */
-
- if (value === ',') {
- let output = value;
-
- const brace = braces[braces.length - 1];
- if (brace && stack[stack.length - 1] === 'braces') {
- brace.comma = true;
- output = '|';
- }
-
- push({ type: 'comma', value, output });
- continue;
- }
-
- /**
- * Slashes
- */
-
- if (value === '/') {
- // if the beginning of the glob is "./", advance the start
- // to the current index, and don't add the "./" characters
- // to the state. This greatly simplifies lookbehinds when
- // checking for BOS characters like "!" and "." (not "./")
- if (prev.type === 'dot' && state.index === state.start + 1) {
- state.start = state.index + 1;
- state.consumed = '';
- state.output = '';
- tokens.pop();
- prev = bos; // reset "prev" to the first token
- continue;
- }
-
- push({ type: 'slash', value, output: SLASH_LITERAL });
- continue;
- }
-
- /**
- * Dots
- */
-
- if (value === '.') {
- if (state.braces > 0 && prev.type === 'dot') {
- if (prev.value === '.') prev.output = DOT_LITERAL;
- const brace = braces[braces.length - 1];
- prev.type = 'dots';
- prev.output += value;
- prev.value += value;
- brace.dots = true;
- continue;
- }
-
- if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
- push({ type: 'text', value, output: DOT_LITERAL });
- continue;
- }
-
- push({ type: 'dot', value, output: DOT_LITERAL });
- continue;
- }
-
- /**
- * Question marks
- */
-
- if (value === '?') {
- const isGroup = prev && prev.value === '(';
- if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- extglobOpen('qmark', value);
- continue;
- }
-
- if (prev && prev.type === 'paren') {
- const next = peek();
- let output = value;
-
- if (next === '<' && !utils$5.supportsLookbehinds()) {
- throw new Error('Node.js v10 or higher is required for regex lookbehinds');
- }
-
- if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
- output = `\\${value}`;
- }
-
- push({ type: 'text', value, output });
- continue;
- }
-
- if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
- push({ type: 'qmark', value, output: QMARK_NO_DOT });
- continue;
- }
-
- push({ type: 'qmark', value, output: QMARK });
- continue;
- }
-
- /**
- * Exclamation
- */
-
- if (value === '!') {
- if (opts.noextglob !== true && peek() === '(') {
- if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
- extglobOpen('negate', value);
- continue;
- }
- }
-
- if (opts.nonegate !== true && state.index === 0) {
- negate();
- continue;
- }
- }
-
- /**
- * Plus
- */
-
- if (value === '+') {
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- extglobOpen('plus', value);
- continue;
- }
-
- if ((prev && prev.value === '(') || opts.regex === false) {
- push({ type: 'plus', value, output: PLUS_LITERAL });
- continue;
- }
-
- if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
- push({ type: 'plus', value });
- continue;
- }
-
- push({ type: 'plus', value: PLUS_LITERAL });
- continue;
- }
-
- /**
- * Plain text
- */
-
- if (value === '@') {
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- push({ type: 'at', extglob: true, value, output: '' });
- continue;
- }
-
- push({ type: 'text', value });
- continue;
- }
-
- /**
- * Plain text
- */
-
- if (value !== '*') {
- if (value === '$' || value === '^') {
- value = `\\${value}`;
- }
-
- const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
- if (match) {
- value += match[0];
- state.index += match[0].length;
- }
-
- push({ type: 'text', value });
- continue;
- }
-
- /**
- * Stars
- */
-
- if (prev && (prev.type === 'globstar' || prev.star === true)) {
- prev.type = 'star';
- prev.star = true;
- prev.value += value;
- prev.output = star;
- state.backtrack = true;
- state.globstar = true;
- consume(value);
- continue;
- }
-
- let rest = remaining();
- if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
- extglobOpen('star', value);
- continue;
- }
-
- if (prev.type === 'star') {
- if (opts.noglobstar === true) {
- consume(value);
- continue;
- }
-
- const prior = prev.prev;
- const before = prior.prev;
- const isStart = prior.type === 'slash' || prior.type === 'bos';
- const afterStar = before && (before.type === 'star' || before.type === 'globstar');
-
- if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
- push({ type: 'star', value, output: '' });
- continue;
- }
-
- const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
- const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
- if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
- push({ type: 'star', value, output: '' });
- continue;
- }
-
- // strip consecutive `/**/`
- while (rest.slice(0, 3) === '/**') {
- const after = input[state.index + 4];
- if (after && after !== '/') {
- break;
- }
- rest = rest.slice(3);
- consume('/**', 3);
- }
-
- if (prior.type === 'bos' && eos()) {
- prev.type = 'globstar';
- prev.value += value;
- prev.output = globstar(opts);
- state.output = prev.output;
- state.globstar = true;
- consume(value);
- continue;
- }
-
- if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
- state.output = state.output.slice(0, -(prior.output + prev.output).length);
- prior.output = `(?:${prior.output}`;
-
- prev.type = 'globstar';
- prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
- prev.value += value;
- state.globstar = true;
- state.output += prior.output + prev.output;
- consume(value);
- continue;
- }
-
- if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
- const end = rest[1] !== void 0 ? '|$' : '';
-
- state.output = state.output.slice(0, -(prior.output + prev.output).length);
- prior.output = `(?:${prior.output}`;
-
- prev.type = 'globstar';
- prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
- prev.value += value;
-
- state.output += prior.output + prev.output;
- state.globstar = true;
-
- consume(value + advance());
-
- push({ type: 'slash', value: '/', output: '' });
- continue;
- }
-
- if (prior.type === 'bos' && rest[0] === '/') {
- prev.type = 'globstar';
- prev.value += value;
- prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
- state.output = prev.output;
- state.globstar = true;
- consume(value + advance());
- push({ type: 'slash', value: '/', output: '' });
- continue;
- }
-
- // remove single star from output
- state.output = state.output.slice(0, -prev.output.length);
-
- // reset previous token to globstar
- prev.type = 'globstar';
- prev.output = globstar(opts);
- prev.value += value;
-
- // reset output with globstar
- state.output += prev.output;
- state.globstar = true;
- consume(value);
- continue;
- }
-
- const token = { type: 'star', value, output: star };
-
- if (opts.bash === true) {
- token.output = '.*?';
- if (prev.type === 'bos' || prev.type === 'slash') {
- token.output = nodot + token.output;
- }
- push(token);
- continue;
- }
-
- if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
- token.output = value;
- push(token);
- continue;
- }
-
- if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
- if (prev.type === 'dot') {
- state.output += NO_DOT_SLASH;
- prev.output += NO_DOT_SLASH;
-
- } else if (opts.dot === true) {
- state.output += NO_DOTS_SLASH;
- prev.output += NO_DOTS_SLASH;
-
- } else {
- state.output += nodot;
- prev.output += nodot;
- }
-
- if (peek() !== '*') {
- state.output += ONE_CHAR;
- prev.output += ONE_CHAR;
- }
- }
-
- push(token);
- }
-
- while (state.brackets > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ']'));
- state.output = utils$5.escapeLast(state.output, '[');
- decrement('brackets');
- }
-
- while (state.parens > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', ')'));
- state.output = utils$5.escapeLast(state.output, '(');
- decrement('parens');
- }
-
- while (state.braces > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError$1('closing', '}'));
- state.output = utils$5.escapeLast(state.output, '{');
- decrement('braces');
- }
-
- if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
- push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
- }
-
- // rebuild the output if we had to backtrack at any point
- if (state.backtrack === true) {
- state.output = '';
-
- for (const token of state.tokens) {
- state.output += token.output != null ? token.output : token.value;
-
- if (token.suffix) {
- state.output += token.suffix;
- }
- }
- }
-
- return state;
-};
-
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
-
-parse$8.fastpaths = (input, options) => {
- const opts = { ...options };
- const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$4, opts.maxLength) : MAX_LENGTH$4;
- const len = input.length;
- if (len > max) {
- throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
- }
-
- input = REPLACEMENTS[input] || input;
- const win32 = utils$5.isWindows(options);
-
- // create constants based on platform, for windows or posix
- const {
- DOT_LITERAL,
- SLASH_LITERAL,
- ONE_CHAR,
- DOTS_SLASH,
- NO_DOT,
- NO_DOTS,
- NO_DOTS_SLASH,
- STAR,
- START_ANCHOR
- } = constants$4.globChars(win32);
-
- const nodot = opts.dot ? NO_DOTS : NO_DOT;
- const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
- const capture = opts.capture ? '' : '?:';
- const state = { negated: false, prefix: '' };
- let star = opts.bash === true ? '.*?' : STAR;
-
- if (opts.capture) {
- star = `(${star})`;
- }
-
- const globstar = opts => {
- if (opts.noglobstar === true) return star;
- return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
- };
-
- const create = str => {
- switch (str) {
- case '*':
- return `${nodot}${ONE_CHAR}${star}`;
-
- case '.*':
- return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-
- case '*.*':
- return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
- case '*/*':
- return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-
- case '**':
- return nodot + globstar(opts);
-
- case '**/*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-
- case '**/*.*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-
- case '**/.*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-
- default: {
- const match = /^(.*?)\.(\w+)$/.exec(str);
- if (!match) return;
-
- const source = create(match[1]);
- if (!source) return;
-
- return source + DOT_LITERAL + match[2];
- }
- }
- };
-
- const output = utils$5.removePrefix(input, state);
- let source = create(output);
-
- if (source && opts.strictSlashes !== true) {
- source += `${SLASH_LITERAL}?`;
- }
-
- return source;
-};
-
-var parse_1$3 = parse$8;
-
-const path$2 = require$$0__default$2['default'];
-const scan = scan_1;
-const parse$7 = parse_1$3;
-const utils$4 = utils$7;
-const constants$3 = constants$5;
-const isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);
-
-/**
- * Creates a matcher function from one or more glob patterns. The
- * returned function takes a string to match as its first argument,
- * and returns true if the string is a match. The returned matcher
- * function also takes a boolean as the second argument that, when true,
- * returns an object with additional information.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch(glob[, options]);
- *
- * const isMatch = picomatch('*.!(*a)');
- * console.log(isMatch('a.a')); //=> false
- * console.log(isMatch('a.b')); //=> true
- * ```
- * @name picomatch
- * @param {String|Array} `globs` One or more glob patterns.
- * @param {Object=} `options`
- * @return {Function=} Returns a matcher function.
- * @api public
- */
-
-const picomatch$3 = (glob, options, returnState = false) => {
- if (Array.isArray(glob)) {
- const fns = glob.map(input => picomatch$3(input, options, returnState));
- const arrayMatcher = str => {
- for (const isMatch of fns) {
- const state = isMatch(str);
- if (state) return state;
- }
- return false;
- };
- return arrayMatcher;
- }
-
- const isState = isObject$3(glob) && glob.tokens && glob.input;
-
- if (glob === '' || (typeof glob !== 'string' && !isState)) {
- throw new TypeError('Expected pattern to be a non-empty string');
- }
-
- const opts = options || {};
- const posix = utils$4.isWindows(options);
- const regex = isState
- ? picomatch$3.compileRe(glob, options)
- : picomatch$3.makeRe(glob, options, false, true);
-
- const state = regex.state;
- delete regex.state;
-
- let isIgnored = () => false;
- if (opts.ignore) {
- const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
- isIgnored = picomatch$3(opts.ignore, ignoreOpts, returnState);
- }
-
- const matcher = (input, returnObject = false) => {
- const { isMatch, match, output } = picomatch$3.test(input, regex, options, { glob, posix });
- const result = { glob, state, regex, posix, input, output, match, isMatch };
-
- if (typeof opts.onResult === 'function') {
- opts.onResult(result);
- }
-
- if (isMatch === false) {
- result.isMatch = false;
- return returnObject ? result : false;
- }
-
- if (isIgnored(input)) {
- if (typeof opts.onIgnore === 'function') {
- opts.onIgnore(result);
- }
- result.isMatch = false;
- return returnObject ? result : false;
- }
-
- if (typeof opts.onMatch === 'function') {
- opts.onMatch(result);
- }
- return returnObject ? result : true;
- };
-
- if (returnState) {
- matcher.state = state;
- }
-
- return matcher;
-};
-
-/**
- * Test `input` with the given `regex`. This is used by the main
- * `picomatch()` function to test the input string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.test(input, regex[, options]);
- *
- * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
- * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp} `regex`
- * @return {Object} Returns an object with matching info.
- * @api public
- */
-
-picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
- if (typeof input !== 'string') {
- throw new TypeError('Expected input to be a string');
- }
-
- if (input === '') {
- return { isMatch: false, output: '' };
- }
-
- const opts = options || {};
- const format = opts.format || (posix ? utils$4.toPosixSlashes : null);
- let match = input === glob;
- let output = (match && format) ? format(input) : input;
-
- if (match === false) {
- output = format ? format(input) : input;
- match = output === glob;
- }
-
- if (match === false || opts.capture === true) {
- if (opts.matchBase === true || opts.basename === true) {
- match = picomatch$3.matchBase(input, regex, options, posix);
- } else {
- match = regex.exec(output);
- }
- }
-
- return { isMatch: Boolean(match), match, output };
-};
-
-/**
- * Match the basename of a filepath.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.matchBase(input, glob[, options]);
- * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
- * ```
- * @param {String} `input` String to test.
- * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
- * @return {Boolean}
- * @api public
- */
-
-picomatch$3.matchBase = (input, glob, options, posix = utils$4.isWindows(options)) => {
- const regex = glob instanceof RegExp ? glob : picomatch$3.makeRe(glob, options);
- return regex.test(path$2.basename(input));
-};
-
-/**
- * Returns true if **any** of the given glob `patterns` match the specified `string`.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.isMatch(string, patterns[, options]);
- *
- * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
- * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
- * ```
- * @param {String|Array} str The string to test.
- * @param {String|Array} patterns One or more glob patterns to use for matching.
- * @param {Object} [options] See available [options](#options).
- * @return {Boolean} Returns true if any patterns match `str`
- * @api public
- */
-
-picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)(str);
-
-/**
- * Parse a glob pattern to create the source string for a regular
- * expression.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const result = picomatch.parse(pattern[, options]);
- * ```
- * @param {String} `pattern`
- * @param {Object} `options`
- * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
- * @api public
- */
-
-picomatch$3.parse = (pattern, options) => {
- if (Array.isArray(pattern)) return pattern.map(p => picomatch$3.parse(p, options));
- return parse$7(pattern, { ...options, fastpaths: false });
-};
-
-/**
- * Scan a glob pattern to separate the pattern into segments.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.scan(input[, options]);
- *
- * const result = picomatch.scan('!./foo/*.js');
- * console.log(result);
- * { prefix: '!./',
- * input: '!./foo/*.js',
- * start: 3,
- * base: 'foo',
- * glob: '*.js',
- * isBrace: false,
- * isBracket: false,
- * isGlob: true,
- * isExtglob: false,
- * isGlobstar: false,
- * negated: true }
- * ```
- * @param {String} `input` Glob pattern to scan.
- * @param {Object} `options`
- * @return {Object} Returns an object with
- * @api public
- */
-
-picomatch$3.scan = (input, options) => scan(input, options);
-
-/**
- * Compile a regular expression from the `state` object returned by the
- * [parse()](#parse) method.
- *
- * @param {Object} `state`
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
- * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
- * @return {RegExp}
- * @api public
- */
-
-picomatch$3.compileRe = (state, options, returnOutput = false, returnState = false) => {
- if (returnOutput === true) {
- return state.output;
- }
-
- const opts = options || {};
- const prepend = opts.contains ? '' : '^';
- const append = opts.contains ? '' : '$';
-
- let source = `${prepend}(?:${state.output})${append}`;
- if (state && state.negated === true) {
- source = `^(?!${source}).*$`;
- }
-
- const regex = picomatch$3.toRegex(source, options);
- if (returnState === true) {
- regex.state = state;
- }
-
- return regex;
-};
-
-/**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
- *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
- * @param {Object} `options`
- * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
- * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
- * @return {RegExp} Returns a regex created from the given pattern.
- * @api public
- */
-
-picomatch$3.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
- if (!input || typeof input !== 'string') {
- throw new TypeError('Expected a non-empty string');
- }
-
- let parsed = { negated: false, fastpaths: true };
-
- if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
- parsed.output = parse$7.fastpaths(input, options);
- }
-
- if (!parsed.output) {
- parsed = parse$7(input, options);
- }
-
- return picomatch$3.compileRe(parsed, options, returnOutput, returnState);
-};
-
-/**
- * Create a regular expression from the given regex source string.
- *
- * ```js
- * const picomatch = require('picomatch');
- * // picomatch.toRegex(source[, options]);
- *
- * const { output } = picomatch.parse('*.js');
- * console.log(picomatch.toRegex(output));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `source` Regular expression source string.
- * @param {Object} `options`
- * @return {RegExp}
- * @api public
- */
-
-picomatch$3.toRegex = (source, options) => {
- try {
- const opts = options || {};
- return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
- } catch (err) {
- if (options && options.debug === true) throw err;
- return /$^/;
- }
-};
-
-/**
- * Picomatch constants.
- * @return {Object}
- */
-
-picomatch$3.constants = constants$3;
-
-/**
- * Expose "picomatch"
- */
-
-var picomatch_1 = picomatch$3;
-
-var picomatch$2 = picomatch_1;
-
-const fs$3 = require$$0__default$3['default'];
-const { Readable } = require$$0__default$5['default'];
-const sysPath$3 = require$$0__default$2['default'];
-const { promisify: promisify$3 } = require$$0__default['default'];
-const picomatch$1 = picomatch$2;
-
-const readdir$1 = promisify$3(fs$3.readdir);
-const stat$3 = promisify$3(fs$3.stat);
-const lstat$2 = promisify$3(fs$3.lstat);
-const realpath$1 = promisify$3(fs$3.realpath);
-
-/**
- * @typedef {Object} EntryInfo
- * @property {String} path
- * @property {String} fullPath
- * @property {fs.Stats=} stats
- * @property {fs.Dirent=} dirent
- * @property {String} basename
- */
-
-const BANG$2 = '!';
-const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
-const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
-const FILE_TYPE = 'files';
-const DIR_TYPE = 'directories';
-const FILE_DIR_TYPE = 'files_directories';
-const EVERYTHING_TYPE = 'all';
-const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
-
-const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
-const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
-const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
-
-const normalizeFilter = filter => {
- if (filter === undefined) return;
- if (typeof filter === 'function') return filter;
-
- if (typeof filter === 'string') {
- const glob = picomatch$1(filter.trim());
- return entry => glob(entry.basename);
- }
-
- if (Array.isArray(filter)) {
- const positive = [];
- const negative = [];
- for (const item of filter) {
- const trimmed = item.trim();
- if (trimmed.charAt(0) === BANG$2) {
- negative.push(picomatch$1(trimmed.slice(1)));
- } else {
- positive.push(picomatch$1(trimmed));
- }
- }
-
- if (negative.length > 0) {
- if (positive.length > 0) {
- return entry =>
- positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
- }
- return entry => !negative.some(f => f(entry.basename));
- }
- return entry => positive.some(f => f(entry.basename));
- }
-};
-
-class ReaddirpStream extends Readable {
- static get defaultOptions() {
- return {
- root: '.',
- /* eslint-disable no-unused-vars */
- fileFilter: (path) => true,
- directoryFilter: (path) => true,
- /* eslint-enable no-unused-vars */
- type: FILE_TYPE,
- lstat: false,
- depth: 2147483648,
- alwaysStat: false
- };
- }
-
- constructor(options = {}) {
- super({
- objectMode: true,
- autoDestroy: true,
- highWaterMark: options.highWaterMark || 4096
- });
- const opts = { ...ReaddirpStream.defaultOptions, ...options };
- const { root, type } = opts;
-
- this._fileFilter = normalizeFilter(opts.fileFilter);
- this._directoryFilter = normalizeFilter(opts.directoryFilter);
-
- const statMethod = opts.lstat ? lstat$2 : stat$3;
- // Use bigint stats if it's windows and stat() supports options (node 10+).
- if (wantBigintFsStats) {
- this._stat = path => statMethod(path, { bigint: true });
- } else {
- this._stat = statMethod;
- }
-
- this._maxDepth = opts.depth;
- this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
- this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
- this._wantsEverything = type === EVERYTHING_TYPE;
- this._root = sysPath$3.resolve(root);
- this._isDirent = ('Dirent' in fs$3) && !opts.alwaysStat;
- this._statsProp = this._isDirent ? 'dirent' : 'stats';
- this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
-
- // Launch stream with one parent, the root dir.
- this.parents = [this._exploreDir(root, 1)];
- this.reading = false;
- this.parent = undefined;
- }
-
- async _read(batch) {
- if (this.reading) return;
- this.reading = true;
-
- try {
- while (!this.destroyed && batch > 0) {
- const { path, depth, files = [] } = this.parent || {};
-
- if (files.length > 0) {
- const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
- for (const entry of await Promise.all(slice)) {
- if (this.destroyed) return;
-
- const entryType = await this._getEntryType(entry);
- if (entryType === 'directory' && this._directoryFilter(entry)) {
- if (depth <= this._maxDepth) {
- this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
- }
-
- if (this._wantsDir) {
- this.push(entry);
- batch--;
- }
- } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
- if (this._wantsFile) {
- this.push(entry);
- batch--;
- }
- }
- }
- } else {
- const parent = this.parents.pop();
- if (!parent) {
- this.push(null);
- break;
- }
- this.parent = await parent;
- if (this.destroyed) return;
- }
- }
- } catch (error) {
- this.destroy(error);
- } finally {
- this.reading = false;
- }
- }
-
- async _exploreDir(path, depth) {
- let files;
- try {
- files = await readdir$1(path, this._rdOptions);
- } catch (error) {
- this._onError(error);
- }
- return { files, depth, path };
- }
-
- async _formatEntry(dirent, path) {
- let entry;
- try {
- const basename = this._isDirent ? dirent.name : dirent;
- const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
- entry = { path: sysPath$3.relative(this._root, fullPath), fullPath, basename };
- entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
- } catch (err) {
- this._onError(err);
- }
- return entry;
- }
-
- _onError(err) {
- if (isNormalFlowError(err) && !this.destroyed) {
- this.emit('warn', err);
- } else {
- this.destroy(err);
- }
- }
-
- async _getEntryType(entry) {
- // entry may be undefined, because a warning or an error were emitted
- // and the statsProp is undefined
- const stats = entry && entry[this._statsProp];
- if (!stats) {
- return;
- }
- if (stats.isFile()) {
- return 'file';
- }
- if (stats.isDirectory()) {
- return 'directory';
- }
- if (stats && stats.isSymbolicLink()) {
- const full = entry.fullPath;
- try {
- const entryRealPath = await realpath$1(full);
- const entryRealPathStats = await lstat$2(entryRealPath);
- if (entryRealPathStats.isFile()) {
- return 'file';
- }
- if (entryRealPathStats.isDirectory()) {
- const len = entryRealPath.length;
- if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
- const recursiveError = new Error(
- `Circular symlink detected: "${full}" points to "${entryRealPath}"`
- );
- recursiveError.code = RECURSIVE_ERROR_CODE;
- return this._onError(recursiveError);
- }
- return 'directory';
- }
- } catch (error) {
- this._onError(error);
- }
- }
- }
-
- _includeAsFile(entry) {
- const stats = entry && entry[this._statsProp];
-
- return stats && this._wantsEverything && !stats.isDirectory();
- }
-}
-
-/**
- * @typedef {Object} ReaddirpArguments
- * @property {Function=} fileFilter
- * @property {Function=} directoryFilter
- * @property {String=} type
- * @property {Number=} depth
- * @property {String=} root
- * @property {Boolean=} lstat
- * @property {Boolean=} bigint
- */
-
-/**
- * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
- * @param {String} root Root directory
- * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
- */
-const readdirp$1 = (root, options = {}) => {
- let type = options.entryType || options.type;
- if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
- if (type) options.type = type;
- if (!root) {
- throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
- } else if (typeof root !== 'string') {
- throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
- } else if (type && !ALL_TYPES.includes(type)) {
- throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
- }
-
- options.root = root;
- return new ReaddirpStream(options);
-};
-
-const readdirpPromise = (root, options = {}) => {
- return new Promise((resolve, reject) => {
- const files = [];
- readdirp$1(root, options)
- .on('data', entry => files.push(entry))
- .on('end', () => resolve(files))
- .on('error', error => reject(error));
- });
-};
-
-readdirp$1.promise = readdirpPromise;
-readdirp$1.ReaddirpStream = ReaddirpStream;
-readdirp$1.default = readdirp$1;
-
-var readdirp_1 = readdirp$1;
-
-var anymatch$2 = {exports: {}};
-
-/*!
- * normalize-path <https://github.com/jonschlinkert/normalize-path>
- *
- * Copyright (c) 2014-2018, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-var normalizePath$2 = function(path, stripTrailing) {
- if (typeof path !== 'string') {
- throw new TypeError('expected path to be a string');
- }
-
- if (path === '\\' || path === '/') return '/';
-
- var len = path.length;
- if (len <= 1) return path;
-
- // ensure that win32 namespaces has two leading slashes, so that the path is
- // handled properly by the win32 version of path.parse() after being normalized
- // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
- var prefix = '';
- if (len > 4 && path[3] === '\\') {
- var ch = path[2];
- if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
- path = path.slice(2);
- prefix = '//';
- }
- }
-
- var segs = path.split(/[/\\]+/);
- if (stripTrailing !== false && segs[segs.length - 1] === '') {
- segs.pop();
- }
- return prefix + segs.join('/');
-};
-
-Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
-
-const picomatch = picomatch$2;
-const normalizePath$1 = normalizePath$2;
-
-/**
- * @typedef {(testString: string) => boolean} AnymatchFn
- * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
- * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
- */
-const BANG$1 = '!';
-const DEFAULT_OPTIONS = {returnIndex: false};
-const arrify$1 = (item) => Array.isArray(item) ? item : [item];
-
-/**
- * @param {AnymatchPattern} matcher
- * @param {object} options
- * @returns {AnymatchFn}
- */
-const createPattern = (matcher, options) => {
- if (typeof matcher === 'function') {
- return matcher;
- }
- if (typeof matcher === 'string') {
- const glob = picomatch(matcher, options);
- return (string) => matcher === string || glob(string);
- }
- if (matcher instanceof RegExp) {
- return (string) => matcher.test(string);
- }
- return (string) => false;
-};
-
-/**
- * @param {Array<Function>} patterns
- * @param {Array<Function>} negPatterns
- * @param {String|Array} args
- * @param {Boolean} returnIndex
- * @returns {boolean|number}
- */
-const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
- const isList = Array.isArray(args);
- const _path = isList ? args[0] : args;
- if (!isList && typeof _path !== 'string') {
- throw new TypeError('anymatch: second argument must be a string: got ' +
- Object.prototype.toString.call(_path))
- }
- const path = normalizePath$1(_path);
-
- for (let index = 0; index < negPatterns.length; index++) {
- const nglob = negPatterns[index];
- if (nglob(path)) {
- return returnIndex ? -1 : false;
- }
- }
-
- const applied = isList && [path].concat(args.slice(1));
- for (let index = 0; index < patterns.length; index++) {
- const pattern = patterns[index];
- if (isList ? pattern(...applied) : pattern(path)) {
- return returnIndex ? index : true;
- }
- }
-
- return returnIndex ? -1 : false;
-};
-
-/**
- * @param {AnymatchMatcher} matchers
- * @param {Array|string} testString
- * @param {object} options
- * @returns {boolean|number|Function}
- */
-const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
- if (matchers == null) {
- throw new TypeError('anymatch: specify first argument');
- }
- const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
- const returnIndex = opts.returnIndex || false;
-
- // Early cache for matchers.
- const mtchers = arrify$1(matchers);
- const negatedGlobs = mtchers
- .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
- .map(item => item.slice(1))
- .map(item => picomatch(item, opts));
- const patterns = mtchers
- .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG$1))
- .map(matcher => createPattern(matcher, opts));
-
- if (testString == null) {
- return (testString, ri = false) => {
- const returnIndex = typeof ri === 'boolean' ? ri : false;
- return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
- }
- }
-
- return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
-};
-
-anymatch$1.default = anymatch$1;
-anymatch$2.exports = anymatch$1;
-
-/*!
- * is-extglob <https://github.com/jonschlinkert/is-extglob>
- *
- * Copyright (c) 2014-2016, Jon Schlinkert.
- * Licensed under the MIT License.
- */
-
-var isExtglob$1 = function isExtglob(str) {
- if (typeof str !== 'string' || str === '') {
- return false;
- }
-
- var match;
- while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
- if (match[2]) return true;
- str = str.slice(match.index + match[0].length);
- }
-
- return false;
-};
-
-/*!
- * is-glob <https://github.com/jonschlinkert/is-glob>
- *
- * Copyright (c) 2014-2017, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-var isExtglob = isExtglob$1;
-var chars = { '{': '}', '(': ')', '[': ']'};
-var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
-var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
-
-var isGlob$2 = function isGlob(str, options) {
- if (typeof str !== 'string' || str === '') {
- return false;
- }
-
- if (isExtglob(str)) {
- return true;
- }
-
- var regex = strictRegex;
- var match;
-
- // optionally relax regex
- if (options && options.strict === false) {
- regex = relaxedRegex;
- }
-
- while ((match = regex.exec(str))) {
- if (match[2]) return true;
- var idx = match.index + match[0].length;
-
- // if an open bracket/brace/paren is escaped,
- // set the index to the next closing character
- var open = match[1];
- var close = open ? chars[open] : null;
- if (open && close) {
- var n = str.indexOf(close, idx);
- if (n !== -1) {
- idx = n + 1;
- }
- }
-
- str = str.slice(idx);
- }
- return false;
-};
-
-var isGlob$1 = isGlob$2;
-var pathPosixDirname = require$$0__default$2['default'].posix.dirname;
-var isWin32 = require$$0__default$1['default'].platform() === 'win32';
-
-var slash = '/';
-var backslash = /\\/g;
-var enclosure = /[\{\[].*[\}\]]$/;
-var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
-var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
-
-/**
- * @param {string} str
- * @param {Object} opts
- * @param {boolean} [opts.flipBackslashes=true]
- * @returns {string}
- */
-var globParent$1 = function globParent(str, opts) {
- var options = Object.assign({ flipBackslashes: true }, opts);
-
- // flip windows path separators
- if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
- str = str.replace(backslash, slash);
- }
-
- // special case for strings ending in enclosure containing path separator
- if (enclosure.test(str)) {
- str += slash;
- }
-
- // preserves full path in case of trailing path separator
- str += 'a';
-
- // remove path parts that are globby
- do {
- str = pathPosixDirname(str);
- } while (isGlob$1(str) || globby.test(str));
-
- // remove escape chars and return result
- return str.replace(escaped, '$1');
-};
-
-var utils$3 = {};
-
-(function (exports) {
-
-exports.isInteger = num => {
- if (typeof num === 'number') {
- return Number.isInteger(num);
- }
- if (typeof num === 'string' && num.trim() !== '') {
- return Number.isInteger(Number(num));
- }
- return false;
-};
-
-/**
- * Find a node of the given type
- */
-
-exports.find = (node, type) => node.nodes.find(node => node.type === type);
-
-/**
- * Find a node of the given type
- */
-
-exports.exceedsLimit = (min, max, step = 1, limit) => {
- if (limit === false) return false;
- if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
- return ((Number(max) - Number(min)) / Number(step)) >= limit;
-};
-
-/**
- * Escape the given node with '\\' before node.value
- */
-
-exports.escapeNode = (block, n = 0, type) => {
- let node = block.nodes[n];
- if (!node) return;
-
- if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
- if (node.escaped !== true) {
- node.value = '\\' + node.value;
- node.escaped = true;
- }
- }
-};
-
-/**
- * Returns true if the given brace node should be enclosed in literal braces
- */
-
-exports.encloseBrace = node => {
- if (node.type !== 'brace') return false;
- if ((node.commas >> 0 + node.ranges >> 0) === 0) {
- node.invalid = true;
- return true;
- }
- return false;
-};
-
-/**
- * Returns true if a brace node is invalid.
- */
-
-exports.isInvalidBrace = block => {
- if (block.type !== 'brace') return false;
- if (block.invalid === true || block.dollar) return true;
- if ((block.commas >> 0 + block.ranges >> 0) === 0) {
- block.invalid = true;
- return true;
- }
- if (block.open !== true || block.close !== true) {
- block.invalid = true;
- return true;
- }
- return false;
-};
-
-/**
- * Returns true if a node is an open or close node
- */
-
-exports.isOpenOrClose = node => {
- if (node.type === 'open' || node.type === 'close') {
- return true;
- }
- return node.open === true || node.close === true;
-};
-
-/**
- * Reduce an array of text nodes.
- */
-
-exports.reduce = nodes => nodes.reduce((acc, node) => {
- if (node.type === 'text') acc.push(node.value);
- if (node.type === 'range') node.type = 'text';
- return acc;
-}, []);
-
-/**
- * Flatten an array
- */
-
-exports.flatten = (...args) => {
- const result = [];
- const flat = arr => {
- for (let i = 0; i < arr.length; i++) {
- let ele = arr[i];
- Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
- }
- return result;
- };
- flat(args);
- return result;
-};
-}(utils$3));
-
-const utils$2 = utils$3;
-
-var stringify$8 = (ast, options = {}) => {
- let stringify = (node, parent = {}) => {
- let invalidBlock = options.escapeInvalid && utils$2.isInvalidBrace(parent);
- let invalidNode = node.invalid === true && options.escapeInvalid === true;
- let output = '';
-
- if (node.value) {
- if ((invalidBlock || invalidNode) && utils$2.isOpenOrClose(node)) {
- return '\\' + node.value;
- }
- return node.value;
- }
-
- if (node.value) {
- return node.value;
- }
-
- if (node.nodes) {
- for (let child of node.nodes) {
- output += stringify(child);
- }
- }
- return output;
- };
-
- return stringify(ast);
-};
-
-/*!
- * is-number <https://github.com/jonschlinkert/is-number>
- *
- * Copyright (c) 2014-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-var isNumber$3 = function(num) {
- if (typeof num === 'number') {
- return num - num === 0;
- }
- if (typeof num === 'string' && num.trim() !== '') {
- return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
- }
- return false;
-};
-
-/*!
- * to-regex-range <https://github.com/micromatch/to-regex-range>
- *
- * Copyright (c) 2015-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-const isNumber$2 = isNumber$3;
-
-const toRegexRange$1 = (min, max, options) => {
- if (isNumber$2(min) === false) {
- throw new TypeError('toRegexRange: expected the first argument to be a number');
- }
-
- if (max === void 0 || min === max) {
- return String(min);
- }
-
- if (isNumber$2(max) === false) {
- throw new TypeError('toRegexRange: expected the second argument to be a number.');
- }
-
- let opts = { relaxZeros: true, ...options };
- if (typeof opts.strictZeros === 'boolean') {
- opts.relaxZeros = opts.strictZeros === false;
- }
-
- let relax = String(opts.relaxZeros);
- let shorthand = String(opts.shorthand);
- let capture = String(opts.capture);
- let wrap = String(opts.wrap);
- let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
-
- if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) {
- return toRegexRange$1.cache[cacheKey].result;
- }
-
- let a = Math.min(min, max);
- let b = Math.max(min, max);
-
- if (Math.abs(a - b) === 1) {
- let result = min + '|' + max;
- if (opts.capture) {
- return `(${result})`;
- }
- if (opts.wrap === false) {
- return result;
- }
- return `(?:${result})`;
- }
-
- let isPadded = hasPadding(min) || hasPadding(max);
- let state = { min, max, a, b };
- let positives = [];
- let negatives = [];
-
- if (isPadded) {
- state.isPadded = isPadded;
- state.maxLen = String(state.max).length;
- }
-
- if (a < 0) {
- let newMin = b < 0 ? Math.abs(b) : 1;
- negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
- a = state.a = 0;
- }
-
- if (b >= 0) {
- positives = splitToPatterns(a, b, state, opts);
- }
-
- state.negatives = negatives;
- state.positives = positives;
- state.result = collatePatterns(negatives, positives);
-
- if (opts.capture === true) {
- state.result = `(${state.result})`;
- } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
- state.result = `(?:${state.result})`;
- }
-
- toRegexRange$1.cache[cacheKey] = state;
- return state.result;
-};
-
-function collatePatterns(neg, pos, options) {
- let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
- let onlyPositive = filterPatterns(pos, neg, '', false) || [];
- let intersected = filterPatterns(neg, pos, '-?', true) || [];
- let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
- return subpatterns.join('|');
-}
-
-function splitToRanges(min, max) {
- let nines = 1;
- let zeros = 1;
-
- let stop = countNines(min, nines);
- let stops = new Set([max]);
-
- while (min <= stop && stop <= max) {
- stops.add(stop);
- nines += 1;
- stop = countNines(min, nines);
- }
-
- stop = countZeros(max + 1, zeros) - 1;
-
- while (min < stop && stop <= max) {
- stops.add(stop);
- zeros += 1;
- stop = countZeros(max + 1, zeros) - 1;
- }
-
- stops = [...stops];
- stops.sort(compare$2);
- return stops;
-}
-
-/**
- * Convert a range to a regex pattern
- * @param {Number} `start`
- * @param {Number} `stop`
- * @return {String}
- */
-
-function rangeToPattern(start, stop, options) {
- if (start === stop) {
- return { pattern: start, count: [], digits: 0 };
- }
-
- let zipped = zip(start, stop);
- let digits = zipped.length;
- let pattern = '';
- let count = 0;
-
- for (let i = 0; i < digits; i++) {
- let [startDigit, stopDigit] = zipped[i];
-
- if (startDigit === stopDigit) {
- pattern += startDigit;
-
- } else if (startDigit !== '0' || stopDigit !== '9') {
- pattern += toCharacterClass(startDigit, stopDigit);
-
- } else {
- count++;
- }
- }
-
- if (count) {
- pattern += options.shorthand === true ? '\\d' : '[0-9]';
- }
-
- return { pattern, count: [count], digits };
-}
-
-function splitToPatterns(min, max, tok, options) {
- let ranges = splitToRanges(min, max);
- let tokens = [];
- let start = min;
- let prev;
-
- for (let i = 0; i < ranges.length; i++) {
- let max = ranges[i];
- let obj = rangeToPattern(String(start), String(max), options);
- let zeros = '';
-
- if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
- if (prev.count.length > 1) {
- prev.count.pop();
- }
-
- prev.count.push(obj.count[0]);
- prev.string = prev.pattern + toQuantifier(prev.count);
- start = max + 1;
- continue;
- }
-
- if (tok.isPadded) {
- zeros = padZeros(max, tok, options);
- }
-
- obj.string = zeros + obj.pattern + toQuantifier(obj.count);
- tokens.push(obj);
- start = max + 1;
- prev = obj;
- }
-
- return tokens;
-}
-
-function filterPatterns(arr, comparison, prefix, intersection, options) {
- let result = [];
-
- for (let ele of arr) {
- let { string } = ele;
-
- // only push if _both_ are negative...
- if (!intersection && !contains(comparison, 'string', string)) {
- result.push(prefix + string);
- }
-
- // or _both_ are positive
- if (intersection && contains(comparison, 'string', string)) {
- result.push(prefix + string);
- }
- }
- return result;
-}
-
-/**
- * Zip strings
- */
-
-function zip(a, b) {
- let arr = [];
- for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
- return arr;
-}
-
-function compare$2(a, b) {
- return a > b ? 1 : b > a ? -1 : 0;
-}
-
-function contains(arr, key, val) {
- return arr.some(ele => ele[key] === val);
-}
-
-function countNines(min, len) {
- return Number(String(min).slice(0, -len) + '9'.repeat(len));
-}
-
-function countZeros(integer, zeros) {
- return integer - (integer % Math.pow(10, zeros));
-}
-
-function toQuantifier(digits) {
- let [start = 0, stop = ''] = digits;
- if (stop || start > 1) {
- return `{${start + (stop ? ',' + stop : '')}}`;
- }
- return '';
-}
-
-function toCharacterClass(a, b, options) {
- return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
-}
-
-function hasPadding(str) {
- return /^-?(0+)\d/.test(str);
-}
-
-function padZeros(value, tok, options) {
- if (!tok.isPadded) {
- return value;
- }
-
- let diff = Math.abs(tok.maxLen - String(value).length);
- let relax = options.relaxZeros !== false;
-
- switch (diff) {
- case 0:
- return '';
- case 1:
- return relax ? '0?' : '0';
- case 2:
- return relax ? '0{0,2}' : '00';
- default: {
- return relax ? `0{0,${diff}}` : `0{${diff}}`;
- }
- }
-}
-
-/**
- * Cache
- */
-
-toRegexRange$1.cache = {};
-toRegexRange$1.clearCache = () => (toRegexRange$1.cache = {});
-
-/**
- * Expose `toRegexRange`
- */
-
-var toRegexRange_1 = toRegexRange$1;
-
-/*!
- * fill-range <https://github.com/jonschlinkert/fill-range>
- *
- * Copyright (c) 2014-present, Jon Schlinkert.
- * Licensed under the MIT License.
- */
-
-const util$1 = require$$0__default['default'];
-const toRegexRange = toRegexRange_1;
-
-const isObject$2 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
-
-const transform = toNumber => {
- return value => toNumber === true ? Number(value) : String(value);
-};
-
-const isValidValue = value => {
- return typeof value === 'number' || (typeof value === 'string' && value !== '');
-};
-
-const isNumber$1 = num => Number.isInteger(+num);
-
-const zeros = input => {
- let value = `${input}`;
- let index = -1;
- if (value[0] === '-') value = value.slice(1);
- if (value === '0') return false;
- while (value[++index] === '0');
- return index > 0;
-};
-
-const stringify$7 = (start, end, options) => {
- if (typeof start === 'string' || typeof end === 'string') {
- return true;
- }
- return options.stringify === true;
-};
-
-const pad = (input, maxLength, toNumber) => {
- if (maxLength > 0) {
- let dash = input[0] === '-' ? '-' : '';
- if (dash) input = input.slice(1);
- input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
- }
- if (toNumber === false) {
- return String(input);
- }
- return input;
-};
-
-const toMaxLen = (input, maxLength) => {
- let negative = input[0] === '-' ? '-' : '';
- if (negative) {
- input = input.slice(1);
- maxLength--;
- }
- while (input.length < maxLength) input = '0' + input;
- return negative ? ('-' + input) : input;
-};
-
-const toSequence = (parts, options) => {
- parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
- parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-
- let prefix = options.capture ? '' : '?:';
- let positives = '';
- let negatives = '';
- let result;
-
- if (parts.positives.length) {
- positives = parts.positives.join('|');
- }
-
- if (parts.negatives.length) {
- negatives = `-(${prefix}${parts.negatives.join('|')})`;
- }
-
- if (positives && negatives) {
- result = `${positives}|${negatives}`;
- } else {
- result = positives || negatives;
- }
-
- if (options.wrap) {
- return `(${prefix}${result})`;
- }
-
- return result;
-};
-
-const toRange = (a, b, isNumbers, options) => {
- if (isNumbers) {
- return toRegexRange(a, b, { wrap: false, ...options });
- }
-
- let start = String.fromCharCode(a);
- if (a === b) return start;
-
- let stop = String.fromCharCode(b);
- return `[${start}-${stop}]`;
-};
-
-const toRegex = (start, end, options) => {
- if (Array.isArray(start)) {
- let wrap = options.wrap === true;
- let prefix = options.capture ? '' : '?:';
- return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
- }
- return toRegexRange(start, end, options);
-};
-
-const rangeError = (...args) => {
- return new RangeError('Invalid range arguments: ' + util$1.inspect(...args));
-};
-
-const invalidRange = (start, end, options) => {
- if (options.strictRanges === true) throw rangeError([start, end]);
- return [];
-};
-
-const invalidStep = (step, options) => {
- if (options.strictRanges === true) {
- throw new TypeError(`Expected step "${step}" to be a number`);
- }
- return [];
-};
-
-const fillNumbers = (start, end, step = 1, options = {}) => {
- let a = Number(start);
- let b = Number(end);
-
- if (!Number.isInteger(a) || !Number.isInteger(b)) {
- if (options.strictRanges === true) throw rangeError([start, end]);
- return [];
- }
-
- // fix negative zero
- if (a === 0) a = 0;
- if (b === 0) b = 0;
-
- let descending = a > b;
- let startString = String(start);
- let endString = String(end);
- let stepString = String(step);
- step = Math.max(Math.abs(step), 1);
-
- let padded = zeros(startString) || zeros(endString) || zeros(stepString);
- let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
- let toNumber = padded === false && stringify$7(start, end, options) === false;
- let format = options.transform || transform(toNumber);
-
- if (options.toRegex && step === 1) {
- return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
- }
-
- let parts = { negatives: [], positives: [] };
- let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
- let range = [];
- let index = 0;
-
- while (descending ? a >= b : a <= b) {
- if (options.toRegex === true && step > 1) {
- push(a);
- } else {
- range.push(pad(format(a, index), maxLen, toNumber));
- }
- a = descending ? a - step : a + step;
- index++;
- }
-
- if (options.toRegex === true) {
- return step > 1
- ? toSequence(parts, options)
- : toRegex(range, null, { wrap: false, ...options });
- }
-
- return range;
-};
-
-const fillLetters = (start, end, step = 1, options = {}) => {
- if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
- return invalidRange(start, end, options);
- }
-
-
- let format = options.transform || (val => String.fromCharCode(val));
- let a = `${start}`.charCodeAt(0);
- let b = `${end}`.charCodeAt(0);
-
- let descending = a > b;
- let min = Math.min(a, b);
- let max = Math.max(a, b);
-
- if (options.toRegex && step === 1) {
- return toRange(min, max, false, options);
- }
-
- let range = [];
- let index = 0;
-
- while (descending ? a >= b : a <= b) {
- range.push(format(a, index));
- a = descending ? a - step : a + step;
- index++;
- }
-
- if (options.toRegex === true) {
- return toRegex(range, null, { wrap: false, options });
- }
-
- return range;
-};
-
-const fill$2 = (start, end, step, options = {}) => {
- if (end == null && isValidValue(start)) {
- return [start];
- }
-
- if (!isValidValue(start) || !isValidValue(end)) {
- return invalidRange(start, end, options);
- }
-
- if (typeof step === 'function') {
- return fill$2(start, end, 1, { transform: step });
- }
-
- if (isObject$2(step)) {
- return fill$2(start, end, 0, step);
- }
-
- let opts = { ...options };
- if (opts.capture === true) opts.wrap = true;
- step = step || opts.step || 1;
-
- if (!isNumber$1(step)) {
- if (step != null && !isObject$2(step)) return invalidStep(step, opts);
- return fill$2(start, end, 1, step);
- }
-
- if (isNumber$1(start) && isNumber$1(end)) {
- return fillNumbers(start, end, step, opts);
- }
-
- return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
-};
-
-var fillRange = fill$2;
-
-const fill$1 = fillRange;
-const utils$1 = utils$3;
-
-const compile$1 = (ast, options = {}) => {
- let walk = (node, parent = {}) => {
- let invalidBlock = utils$1.isInvalidBrace(parent);
- let invalidNode = node.invalid === true && options.escapeInvalid === true;
- let invalid = invalidBlock === true || invalidNode === true;
- let prefix = options.escapeInvalid === true ? '\\' : '';
- let output = '';
-
- if (node.isOpen === true) {
- return prefix + node.value;
- }
- if (node.isClose === true) {
- return prefix + node.value;
- }
-
- if (node.type === 'open') {
- return invalid ? (prefix + node.value) : '(';
- }
-
- if (node.type === 'close') {
- return invalid ? (prefix + node.value) : ')';
- }
-
- if (node.type === 'comma') {
- return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
- }
-
- if (node.value) {
- return node.value;
- }
-
- if (node.nodes && node.ranges > 0) {
- let args = utils$1.reduce(node.nodes);
- let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
-
- if (range.length !== 0) {
- return args.length > 1 && range.length > 1 ? `(${range})` : range;
- }
- }
-
- if (node.nodes) {
- for (let child of node.nodes) {
- output += walk(child, node);
- }
- }
- return output;
- };
-
- return walk(ast);
-};
-
-var compile_1 = compile$1;
-
-const fill = fillRange;
-const stringify$6 = stringify$8;
-const utils = utils$3;
-
-const append = (queue = '', stash = '', enclose = false) => {
- let result = [];
-
- queue = [].concat(queue);
- stash = [].concat(stash);
-
- if (!stash.length) return queue;
- if (!queue.length) {
- return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
- }
-
- for (let item of queue) {
- if (Array.isArray(item)) {
- for (let value of item) {
- result.push(append(value, stash, enclose));
- }
- } else {
- for (let ele of stash) {
- if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
- result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
- }
- }
- }
- return utils.flatten(result);
-};
-
-const expand$1 = (ast, options = {}) => {
- let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
-
- let walk = (node, parent = {}) => {
- node.queue = [];
-
- let p = parent;
- let q = parent.queue;
-
- while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
- p = p.parent;
- q = p.queue;
- }
-
- if (node.invalid || node.dollar) {
- q.push(append(q.pop(), stringify$6(node, options)));
- return;
- }
-
- if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
- q.push(append(q.pop(), ['{}']));
- return;
- }
-
- if (node.nodes && node.ranges > 0) {
- let args = utils.reduce(node.nodes);
-
- if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
- throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
- }
-
- let range = fill(...args, options);
- if (range.length === 0) {
- range = stringify$6(node, options);
- }
-
- q.push(append(q.pop(), range));
- node.nodes = [];
- return;
- }
-
- let enclose = utils.encloseBrace(node);
- let queue = node.queue;
- let block = node;
-
- while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
- block = block.parent;
- queue = block.queue;
- }
-
- for (let i = 0; i < node.nodes.length; i++) {
- let child = node.nodes[i];
-
- if (child.type === 'comma' && node.type === 'brace') {
- if (i === 1) queue.push('');
- queue.push('');
- continue;
- }
-
- if (child.type === 'close') {
- q.push(append(q.pop(), queue, enclose));
- continue;
- }
-
- if (child.value && child.type !== 'open') {
- queue.push(append(queue.pop(), child.value));
- continue;
- }
-
- if (child.nodes) {
- walk(child, node);
- }
- }
-
- return queue;
- };
-
- return utils.flatten(walk(ast));
-};
-
-var expand_1 = expand$1;
-
-var constants$2 = {
- MAX_LENGTH: 1024 * 64,
-
- // Digits
- CHAR_0: '0', /* 0 */
- CHAR_9: '9', /* 9 */
-
- // Alphabet chars.
- CHAR_UPPERCASE_A: 'A', /* A */
- CHAR_LOWERCASE_A: 'a', /* a */
- CHAR_UPPERCASE_Z: 'Z', /* Z */
- CHAR_LOWERCASE_Z: 'z', /* z */
-
- CHAR_LEFT_PARENTHESES: '(', /* ( */
- CHAR_RIGHT_PARENTHESES: ')', /* ) */
-
- CHAR_ASTERISK: '*', /* * */
-
- // Non-alphabetic chars.
- CHAR_AMPERSAND: '&', /* & */
- CHAR_AT: '@', /* @ */
- CHAR_BACKSLASH: '\\', /* \ */
- CHAR_BACKTICK: '`', /* ` */
- CHAR_CARRIAGE_RETURN: '\r', /* \r */
- CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
- CHAR_COLON: ':', /* : */
- CHAR_COMMA: ',', /* , */
- CHAR_DOLLAR: '$', /* . */
- CHAR_DOT: '.', /* . */
- CHAR_DOUBLE_QUOTE: '"', /* " */
- CHAR_EQUAL: '=', /* = */
- CHAR_EXCLAMATION_MARK: '!', /* ! */
- CHAR_FORM_FEED: '\f', /* \f */
- CHAR_FORWARD_SLASH: '/', /* / */
- CHAR_HASH: '#', /* # */
- CHAR_HYPHEN_MINUS: '-', /* - */
- CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
- CHAR_LEFT_CURLY_BRACE: '{', /* { */
- CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
- CHAR_LINE_FEED: '\n', /* \n */
- CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
- CHAR_PERCENT: '%', /* % */
- CHAR_PLUS: '+', /* + */
- CHAR_QUESTION_MARK: '?', /* ? */
- CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
- CHAR_RIGHT_CURLY_BRACE: '}', /* } */
- CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
- CHAR_SEMICOLON: ';', /* ; */
- CHAR_SINGLE_QUOTE: '\'', /* ' */
- CHAR_SPACE: ' ', /* */
- CHAR_TAB: '\t', /* \t */
- CHAR_UNDERSCORE: '_', /* _ */
- CHAR_VERTICAL_LINE: '|', /* | */
- CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
-};
-
-const stringify$5 = stringify$8;
-
-/**
- * Constants
- */
-
-const {
- MAX_LENGTH: MAX_LENGTH$3,
- CHAR_BACKSLASH, /* \ */
- CHAR_BACKTICK, /* ` */
- CHAR_COMMA: CHAR_COMMA$1, /* , */
- CHAR_DOT, /* . */
- CHAR_LEFT_PARENTHESES, /* ( */
- CHAR_RIGHT_PARENTHESES, /* ) */
- CHAR_LEFT_CURLY_BRACE, /* { */
- CHAR_RIGHT_CURLY_BRACE, /* } */
- CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
- CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
- CHAR_DOUBLE_QUOTE: CHAR_DOUBLE_QUOTE$1, /* " */
- CHAR_SINGLE_QUOTE: CHAR_SINGLE_QUOTE$1, /* ' */
- CHAR_NO_BREAK_SPACE,
- CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants$2;
-
-/**
- * parse
- */
-
-const parse$6 = (input, options = {}) => {
- if (typeof input !== 'string') {
- throw new TypeError('Expected a string');
- }
-
- let opts = options || {};
- let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3;
- if (input.length > max) {
- throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
- }
-
- let ast = { type: 'root', input, nodes: [] };
- let stack = [ast];
- let block = ast;
- let prev = ast;
- let brackets = 0;
- let length = input.length;
- let index = 0;
- let depth = 0;
- let value;
-
- /**
- * Helpers
- */
-
- const advance = () => input[index++];
- const push = node => {
- if (node.type === 'text' && prev.type === 'dot') {
- prev.type = 'text';
- }
-
- if (prev && prev.type === 'text' && node.type === 'text') {
- prev.value += node.value;
- return;
- }
-
- block.nodes.push(node);
- node.parent = block;
- node.prev = prev;
- prev = node;
- return node;
- };
-
- push({ type: 'bos' });
-
- while (index < length) {
- block = stack[stack.length - 1];
- value = advance();
-
- /**
- * Invalid chars
- */
-
- if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
- continue;
- }
-
- /**
- * Escaped chars
- */
-
- if (value === CHAR_BACKSLASH) {
- push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
- continue;
- }
-
- /**
- * Right square bracket (literal): ']'
- */
-
- if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
- push({ type: 'text', value: '\\' + value });
- continue;
- }
-
- /**
- * Left square bracket: '['
- */
-
- if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
- brackets++;
- let next;
-
- while (index < length && (next = advance())) {
- value += next;
-
- if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
- brackets++;
- continue;
- }
-
- if (next === CHAR_BACKSLASH) {
- value += advance();
- continue;
- }
-
- if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
- brackets--;
-
- if (brackets === 0) {
- break;
- }
- }
- }
-
- push({ type: 'text', value });
- continue;
- }
-
- /**
- * Parentheses
- */
-
- if (value === CHAR_LEFT_PARENTHESES) {
- block = push({ type: 'paren', nodes: [] });
- stack.push(block);
- push({ type: 'text', value });
- continue;
- }
-
- if (value === CHAR_RIGHT_PARENTHESES) {
- if (block.type !== 'paren') {
- push({ type: 'text', value });
- continue;
- }
- block = stack.pop();
- push({ type: 'text', value });
- block = stack[stack.length - 1];
- continue;
- }
-
- /**
- * Quotes: '|"|`
- */
-
- if (value === CHAR_DOUBLE_QUOTE$1 || value === CHAR_SINGLE_QUOTE$1 || value === CHAR_BACKTICK) {
- let open = value;
- let next;
-
- if (options.keepQuotes !== true) {
- value = '';
- }
-
- while (index < length && (next = advance())) {
- if (next === CHAR_BACKSLASH) {
- value += next + advance();
- continue;
- }
-
- if (next === open) {
- if (options.keepQuotes === true) value += next;
- break;
- }
-
- value += next;
- }
-
- push({ type: 'text', value });
- continue;
- }
-
- /**
- * Left curly brace: '{'
- */
-
- if (value === CHAR_LEFT_CURLY_BRACE) {
- depth++;
-
- let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
- let brace = {
- type: 'brace',
- open: true,
- close: false,
- dollar,
- depth,
- commas: 0,
- ranges: 0,
- nodes: []
- };
-
- block = push(brace);
- stack.push(block);
- push({ type: 'open', value });
- continue;
- }
-
- /**
- * Right curly brace: '}'
- */
-
- if (value === CHAR_RIGHT_CURLY_BRACE) {
- if (block.type !== 'brace') {
- push({ type: 'text', value });
- continue;
- }
-
- let type = 'close';
- block = stack.pop();
- block.close = true;
-
- push({ type, value });
- depth--;
-
- block = stack[stack.length - 1];
- continue;
- }
-
- /**
- * Comma: ','
- */
-
- if (value === CHAR_COMMA$1 && depth > 0) {
- if (block.ranges > 0) {
- block.ranges = 0;
- let open = block.nodes.shift();
- block.nodes = [open, { type: 'text', value: stringify$5(block) }];
- }
-
- push({ type: 'comma', value });
- block.commas++;
- continue;
- }
-
- /**
- * Dot: '.'
- */
-
- if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
- let siblings = block.nodes;
-
- if (depth === 0 || siblings.length === 0) {
- push({ type: 'text', value });
- continue;
- }
-
- if (prev.type === 'dot') {
- block.range = [];
- prev.value += value;
- prev.type = 'range';
-
- if (block.nodes.length !== 3 && block.nodes.length !== 5) {
- block.invalid = true;
- block.ranges = 0;
- prev.type = 'text';
- continue;
- }
-
- block.ranges++;
- block.args = [];
- continue;
- }
-
- if (prev.type === 'range') {
- siblings.pop();
-
- let before = siblings[siblings.length - 1];
- before.value += prev.value + value;
- prev = before;
- block.ranges--;
- continue;
- }
-
- push({ type: 'dot', value });
- continue;
- }
-
- /**
- * Text
- */
-
- push({ type: 'text', value });
- }
-
- // Mark imbalanced braces and brackets as invalid
- do {
- block = stack.pop();
-
- if (block.type !== 'root') {
- block.nodes.forEach(node => {
- if (!node.nodes) {
- if (node.type === 'open') node.isOpen = true;
- if (node.type === 'close') node.isClose = true;
- if (!node.nodes) node.type = 'text';
- node.invalid = true;
- }
- });
-
- // get the location of the block on parent.nodes (block's siblings)
- let parent = stack[stack.length - 1];
- let index = parent.nodes.indexOf(block);
- // replace the (invalid) block with it's nodes
- parent.nodes.splice(index, 1, ...block.nodes);
- }
- } while (stack.length > 0);
-
- push({ type: 'eos' });
- return ast;
-};
-
-var parse_1$2 = parse$6;
-
-const stringify$4 = stringify$8;
-const compile = compile_1;
-const expand = expand_1;
-const parse$5 = parse_1$2;
-
-/**
- * Expand the given pattern or create a regex-compatible string.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
- * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {String}
- * @api public
- */
-
-const braces$1 = (input, options = {}) => {
- let output = [];
-
- if (Array.isArray(input)) {
- for (let pattern of input) {
- let result = braces$1.create(pattern, options);
- if (Array.isArray(result)) {
- output.push(...result);
- } else {
- output.push(result);
- }
- }
- } else {
- output = [].concat(braces$1.create(input, options));
- }
-
- if (options && options.expand === true && options.nodupes === true) {
- output = [...new Set(output)];
- }
- return output;
-};
-
-/**
- * Parse the given `str` with the given `options`.
- *
- * ```js
- * // braces.parse(pattern, [, options]);
- * const ast = braces.parse('a/{b,c}/d');
- * console.log(ast);
- * ```
- * @param {String} pattern Brace pattern to parse
- * @param {Object} options
- * @return {Object} Returns an AST
- * @api public
- */
-
-braces$1.parse = (input, options = {}) => parse$5(input, options);
-
-/**
- * Creates a braces string from an AST, or an AST node.
- *
- * ```js
- * const braces = require('braces');
- * let ast = braces.parse('foo/{a,b}/bar');
- * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
-braces$1.stringify = (input, options = {}) => {
- if (typeof input === 'string') {
- return stringify$4(braces$1.parse(input, options), options);
- }
- return stringify$4(input, options);
-};
-
-/**
- * Compiles a brace pattern into a regex-compatible, optimized string.
- * This method is called by the main [braces](#braces) function by default.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.compile('a/{b,c}/d'));
- * //=> ['a/(b|c)/d']
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
-braces$1.compile = (input, options = {}) => {
- if (typeof input === 'string') {
- input = braces$1.parse(input, options);
- }
- return compile(input, options);
-};
-
-/**
- * Expands a brace pattern into an array. This method is called by the
- * main [braces](#braces) function when `options.expand` is true. Before
- * using this method it's recommended that you read the [performance notes](#performance))
- * and advantages of using [.compile](#compile) instead.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.expand('a/{b,c}/d'));
- * //=> ['a/b/d', 'a/c/d'];
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
-braces$1.expand = (input, options = {}) => {
- if (typeof input === 'string') {
- input = braces$1.parse(input, options);
- }
-
- let result = expand(input, options);
-
- // filter out empty strings if specified
- if (options.noempty === true) {
- result = result.filter(Boolean);
- }
-
- // filter out duplicates if specified
- if (options.nodupes === true) {
- result = [...new Set(result)];
- }
-
- return result;
-};
-
-/**
- * Processes a brace pattern and returns either an expanded array
- * (if `options.expand` is true), a highly optimized regex-compatible string.
- * This method is called by the main [braces](#braces) function.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
- * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
-braces$1.create = (input, options = {}) => {
- if (input === '' || input.length < 3) {
- return [input];
- }
-
- return options.expand !== true
- ? braces$1.compile(input, options)
- : braces$1.expand(input, options);
-};
-
-/**
- * Expose "braces"
- */
-
-var braces_1 = braces$1;
-
-var require$$0$4 = [
- "3dm",
- "3ds",
- "3g2",
- "3gp",
- "7z",
- "a",
- "aac",
- "adp",
- "ai",
- "aif",
- "aiff",
- "alz",
- "ape",
- "apk",
- "appimage",
- "ar",
- "arj",
- "asf",
- "au",
- "avi",
- "bak",
- "baml",
- "bh",
- "bin",
- "bk",
- "bmp",
- "btif",
- "bz2",
- "bzip2",
- "cab",
- "caf",
- "cgm",
- "class",
- "cmx",
- "cpio",
- "cr2",
- "cur",
- "dat",
- "dcm",
- "deb",
- "dex",
- "djvu",
- "dll",
- "dmg",
- "dng",
- "doc",
- "docm",
- "docx",
- "dot",
- "dotm",
- "dra",
- "DS_Store",
- "dsk",
- "dts",
- "dtshd",
- "dvb",
- "dwg",
- "dxf",
- "ecelp4800",
- "ecelp7470",
- "ecelp9600",
- "egg",
- "eol",
- "eot",
- "epub",
- "exe",
- "f4v",
- "fbs",
- "fh",
- "fla",
- "flac",
- "flatpak",
- "fli",
- "flv",
- "fpx",
- "fst",
- "fvt",
- "g3",
- "gh",
- "gif",
- "graffle",
- "gz",
- "gzip",
- "h261",
- "h263",
- "h264",
- "icns",
- "ico",
- "ief",
- "img",
- "ipa",
- "iso",
- "jar",
- "jpeg",
- "jpg",
- "jpgv",
- "jpm",
- "jxr",
- "key",
- "ktx",
- "lha",
- "lib",
- "lvp",
- "lz",
- "lzh",
- "lzma",
- "lzo",
- "m3u",
- "m4a",
- "m4v",
- "mar",
- "mdi",
- "mht",
- "mid",
- "midi",
- "mj2",
- "mka",
- "mkv",
- "mmr",
- "mng",
- "mobi",
- "mov",
- "movie",
- "mp3",
- "mp4",
- "mp4a",
- "mpeg",
- "mpg",
- "mpga",
- "mxu",
- "nef",
- "npx",
- "numbers",
- "nupkg",
- "o",
- "odp",
- "ods",
- "odt",
- "oga",
- "ogg",
- "ogv",
- "otf",
- "ott",
- "pages",
- "pbm",
- "pcx",
- "pdb",
- "pdf",
- "pea",
- "pgm",
- "pic",
- "png",
- "pnm",
- "pot",
- "potm",
- "potx",
- "ppa",
- "ppam",
- "ppm",
- "pps",
- "ppsm",
- "ppsx",
- "ppt",
- "pptm",
- "pptx",
- "psd",
- "pya",
- "pyc",
- "pyo",
- "pyv",
- "qt",
- "rar",
- "ras",
- "raw",
- "resources",
- "rgb",
- "rip",
- "rlc",
- "rmf",
- "rmvb",
- "rpm",
- "rtf",
- "rz",
- "s3m",
- "s7z",
- "scpt",
- "sgi",
- "shar",
- "snap",
- "sil",
- "sketch",
- "slk",
- "smv",
- "snk",
- "so",
- "stl",
- "suo",
- "sub",
- "swf",
- "tar",
- "tbz",
- "tbz2",
- "tga",
- "tgz",
- "thmx",
- "tif",
- "tiff",
- "tlz",
- "ttc",
- "ttf",
- "txz",
- "udf",
- "uvh",
- "uvi",
- "uvm",
- "uvp",
- "uvs",
- "uvu",
- "viv",
- "vob",
- "war",
- "wav",
- "wax",
- "wbmp",
- "wdp",
- "weba",
- "webm",
- "webp",
- "whl",
- "wim",
- "wm",
- "wma",
- "wmv",
- "wmx",
- "woff",
- "woff2",
- "wrm",
- "wvx",
- "xbm",
- "xif",
- "xla",
- "xlam",
- "xls",
- "xlsb",
- "xlsm",
- "xlsx",
- "xlt",
- "xltm",
- "xltx",
- "xm",
- "xmind",
- "xpi",
- "xpm",
- "xwd",
- "xz",
- "z",
- "zip",
- "zipx"
-];
-
-var binaryExtensions$1 = require$$0$4;
-
-const path$1 = require$$0__default$2['default'];
-const binaryExtensions = binaryExtensions$1;
-
-const extensions$1 = new Set(binaryExtensions);
-
-var isBinaryPath$1 = filePath => extensions$1.has(path$1.extname(filePath).slice(1).toLowerCase());
-
-var constants$1 = {};
-
-(function (exports) {
-
-const {sep} = require$$0__default$2['default'];
-const {platform} = process;
-const os = require$$0__default$1['default'];
-
-exports.EV_ALL = 'all';
-exports.EV_READY = 'ready';
-exports.EV_ADD = 'add';
-exports.EV_CHANGE = 'change';
-exports.EV_ADD_DIR = 'addDir';
-exports.EV_UNLINK = 'unlink';
-exports.EV_UNLINK_DIR = 'unlinkDir';
-exports.EV_RAW = 'raw';
-exports.EV_ERROR = 'error';
-
-exports.STR_DATA = 'data';
-exports.STR_END = 'end';
-exports.STR_CLOSE = 'close';
-
-exports.FSEVENT_CREATED = 'created';
-exports.FSEVENT_MODIFIED = 'modified';
-exports.FSEVENT_DELETED = 'deleted';
-exports.FSEVENT_MOVED = 'moved';
-exports.FSEVENT_CLONED = 'cloned';
-exports.FSEVENT_UNKNOWN = 'unknown';
-exports.FSEVENT_TYPE_FILE = 'file';
-exports.FSEVENT_TYPE_DIRECTORY = 'directory';
-exports.FSEVENT_TYPE_SYMLINK = 'symlink';
-
-exports.KEY_LISTENERS = 'listeners';
-exports.KEY_ERR = 'errHandlers';
-exports.KEY_RAW = 'rawEmitters';
-exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
-
-exports.DOT_SLASH = `.${sep}`;
-
-exports.BACK_SLASH_RE = /\\/g;
-exports.DOUBLE_SLASH_RE = /\/\//;
-exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
-exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-exports.REPLACER_RE = /^\.[/\\]/;
-
-exports.SLASH = '/';
-exports.SLASH_SLASH = '//';
-exports.BRACE_START = '{';
-exports.BANG = '!';
-exports.ONE_DOT = '.';
-exports.TWO_DOTS = '..';
-exports.STAR = '*';
-exports.GLOBSTAR = '**';
-exports.ROOT_GLOBSTAR = '/**/*';
-exports.SLASH_GLOBSTAR = '/**';
-exports.DIR_SUFFIX = 'Dir';
-exports.ANYMATCH_OPTS = {dot: true};
-exports.STRING_TYPE = 'string';
-exports.FUNCTION_TYPE = 'function';
-exports.EMPTY_STR = '';
-exports.EMPTY_FN = () => {};
-exports.IDENTITY_FN = val => val;
-
-exports.isWindows = platform === 'win32';
-exports.isMacos = platform === 'darwin';
-exports.isLinux = platform === 'linux';
-exports.isIBMi = os.type() === 'OS400';
-}(constants$1));
-
-const fs$2 = require$$0__default$3['default'];
-const sysPath$2 = require$$0__default$2['default'];
-const { promisify: promisify$2 } = require$$0__default['default'];
-const isBinaryPath = isBinaryPath$1;
-const {
- isWindows: isWindows$1,
- isLinux,
- EMPTY_FN: EMPTY_FN$2,
- EMPTY_STR: EMPTY_STR$1,
- KEY_LISTENERS,
- KEY_ERR,
- KEY_RAW,
- HANDLER_KEYS,
- EV_CHANGE: EV_CHANGE$2,
- EV_ADD: EV_ADD$2,
- EV_ADD_DIR: EV_ADD_DIR$2,
- EV_ERROR: EV_ERROR$2,
- STR_DATA: STR_DATA$1,
- STR_END: STR_END$2,
- BRACE_START: BRACE_START$1,
- STAR
-} = constants$1;
-
-const THROTTLE_MODE_WATCH = 'watch';
-
-const open = promisify$2(fs$2.open);
-const stat$2 = promisify$2(fs$2.stat);
-const lstat$1 = promisify$2(fs$2.lstat);
-const close = promisify$2(fs$2.close);
-const fsrealpath = promisify$2(fs$2.realpath);
-
-const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
-
-// TODO: emit errors properly. Example: EMFILE on Macos.
-const foreach = (val, fn) => {
- if (val instanceof Set) {
- val.forEach(fn);
- } else {
- fn(val);
- }
-};
-
-const addAndConvert = (main, prop, item) => {
- let container = main[prop];
- if (!(container instanceof Set)) {
- main[prop] = container = new Set([container]);
- }
- container.add(item);
-};
-
-const clearItem = cont => key => {
- const set = cont[key];
- if (set instanceof Set) {
- set.clear();
- } else {
- delete cont[key];
- }
-};
-
-const delFromSet = (main, prop, item) => {
- const container = main[prop];
- if (container instanceof Set) {
- container.delete(item);
- } else if (container === item) {
- delete main[prop];
- }
-};
-
-const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-
-/**
- * @typedef {String} Path
- */
-
-// fs_watch helpers
-
-// object to hold per-process fs_watch instances
-// (may be shared across chokidar FSWatcher instances)
-
-/**
- * @typedef {Object} FsWatchContainer
- * @property {Set} listeners
- * @property {Set} errHandlers
- * @property {Set} rawEmitters
- * @property {fs.FSWatcher=} watcher
- * @property {Boolean=} watcherUnusable
- */
-
-/**
- * @type {Map<String,FsWatchContainer>}
- */
-const FsWatchInstances = new Map();
-
-/**
- * Instantiates the fs_watch interface
- * @param {String} path to be watched
- * @param {Object} options to be passed to fs_watch
- * @param {Function} listener main event handler
- * @param {Function} errHandler emits info about errors
- * @param {Function} emitRaw emits raw event data
- * @returns {fs.FSWatcher} new fsevents instance
- */
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
- const handleEvent = (rawEvent, evPath) => {
- listener(path);
- emitRaw(rawEvent, evPath, {watchedPath: path});
-
- // emit based on events occurring for files from a directory's watcher in
- // case the file's watcher misses it (and rely on throttling to de-dupe)
- if (evPath && path !== evPath) {
- fsWatchBroadcast(
- sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
- );
- }
- };
- try {
- return fs$2.watch(path, options, handleEvent);
- } catch (error) {
- errHandler(error);
- }
-}
-
-/**
- * Helper for passing fs_watch event data to a collection of listeners
- * @param {Path} fullPath absolute path bound to fs_watch instance
- * @param {String} type listener type
- * @param {*=} val1 arguments to be passed to listeners
- * @param {*=} val2
- * @param {*=} val3
- */
-const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
- const cont = FsWatchInstances.get(fullPath);
- if (!cont) return;
- foreach(cont[type], (listener) => {
- listener(val1, val2, val3);
- });
-};
-
-/**
- * Instantiates the fs_watch interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path
- * @param {String} fullPath absolute path
- * @param {Object} options to be passed to fs_watch
- * @param {Object} handlers container for event listener functions
- */
-const setFsWatchListener = (path, fullPath, options, handlers) => {
- const {listener, errHandler, rawEmitter} = handlers;
- let cont = FsWatchInstances.get(fullPath);
-
- /** @type {fs.FSWatcher=} */
- let watcher;
- if (!options.persistent) {
- watcher = createFsWatchInstance(
- path, options, listener, errHandler, rawEmitter
- );
- return watcher.close.bind(watcher);
- }
- if (cont) {
- addAndConvert(cont, KEY_LISTENERS, listener);
- addAndConvert(cont, KEY_ERR, errHandler);
- addAndConvert(cont, KEY_RAW, rawEmitter);
- } else {
- watcher = createFsWatchInstance(
- path,
- options,
- fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
- errHandler, // no need to use broadcast here
- fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
- );
- if (!watcher) return;
- watcher.on(EV_ERROR$2, async (error) => {
- const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
- cont.watcherUnusable = true; // documented since Node 10.4.1
- // Workaround for https://github.com/joyent/node/issues/4337
- if (isWindows$1 && error.code === 'EPERM') {
- try {
- const fd = await open(path, 'r');
- await close(fd);
- broadcastErr(error);
- } catch (err) {}
- } else {
- broadcastErr(error);
- }
- });
- cont = {
- listeners: listener,
- errHandlers: errHandler,
- rawEmitters: rawEmitter,
- watcher
- };
- FsWatchInstances.set(fullPath, cont);
- }
- // const index = cont.listeners.indexOf(listener);
-
- // removes this instance's listeners and closes the underlying fs_watch
- // instance if there are no more listeners left
- return () => {
- delFromSet(cont, KEY_LISTENERS, listener);
- delFromSet(cont, KEY_ERR, errHandler);
- delFromSet(cont, KEY_RAW, rawEmitter);
- if (isEmptySet(cont.listeners)) {
- // Check to protect against issue gh-730.
- // if (cont.watcherUnusable) {
- cont.watcher.close();
- // }
- FsWatchInstances.delete(fullPath);
- HANDLER_KEYS.forEach(clearItem(cont));
- cont.watcher = undefined;
- Object.freeze(cont);
- }
- };
-};
-
-// fs_watchFile helpers
-
-// object to hold per-process fs_watchFile instances
-// (may be shared across chokidar FSWatcher instances)
-const FsWatchFileInstances = new Map();
-
-/**
- * Instantiates the fs_watchFile interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path to be watched
- * @param {String} fullPath absolute path
- * @param {Object} options options to be passed to fs_watchFile
- * @param {Object} handlers container for event listener functions
- * @returns {Function} closer
- */
-const setFsWatchFileListener = (path, fullPath, options, handlers) => {
- const {listener, rawEmitter} = handlers;
- let cont = FsWatchFileInstances.get(fullPath);
-
- const copts = cont && cont.options;
- if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
- fs$2.unwatchFile(fullPath);
- cont = undefined;
- }
-
- /* eslint-enable no-unused-vars, prefer-destructuring */
-
- if (cont) {
- addAndConvert(cont, KEY_LISTENERS, listener);
- addAndConvert(cont, KEY_RAW, rawEmitter);
- } else {
- // TODO
- // listeners.add(listener);
- // rawEmitters.add(rawEmitter);
- cont = {
- listeners: listener,
- rawEmitters: rawEmitter,
- options,
- watcher: fs$2.watchFile(fullPath, options, (curr, prev) => {
- foreach(cont.rawEmitters, (rawEmitter) => {
- rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
- });
- const currmtime = curr.mtimeMs;
- if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
- foreach(cont.listeners, (listener) => listener(path, curr));
- }
- })
- };
- FsWatchFileInstances.set(fullPath, cont);
- }
- // const index = cont.listeners.indexOf(listener);
-
- // Removes this instance's listeners and closes the underlying fs_watchFile
- // instance if there are no more listeners left.
- return () => {
- delFromSet(cont, KEY_LISTENERS, listener);
- delFromSet(cont, KEY_RAW, rawEmitter);
- if (isEmptySet(cont.listeners)) {
- FsWatchFileInstances.delete(fullPath);
- fs$2.unwatchFile(fullPath);
- cont.options = cont.watcher = undefined;
- Object.freeze(cont);
- }
- };
-};
-
-/**
- * @mixin
- */
-class NodeFsHandler$1 {
-
-/**
- * @param {import("../index").FSWatcher} fsW
- */
-constructor(fsW) {
- this.fsw = fsW;
- this._boundHandleError = (error) => fsW._handleError(error);
-}
-
-/**
- * Watch file for changes with fs_watchFile or fs_watch.
- * @param {String} path to file or dir
- * @param {Function} listener on fs change
- * @returns {Function} closer for the watcher instance
- */
-_watchWithNodeFs(path, listener) {
- const opts = this.fsw.options;
- const directory = sysPath$2.dirname(path);
- const basename = sysPath$2.basename(path);
- const parent = this.fsw._getWatchedDir(directory);
- parent.add(basename);
- const absolutePath = sysPath$2.resolve(path);
- const options = {persistent: opts.persistent};
- if (!listener) listener = EMPTY_FN$2;
-
- let closer;
- if (opts.usePolling) {
- options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
- opts.binaryInterval : opts.interval;
- closer = setFsWatchFileListener(path, absolutePath, options, {
- listener,
- rawEmitter: this.fsw._emitRaw
- });
- } else {
- closer = setFsWatchListener(path, absolutePath, options, {
- listener,
- errHandler: this._boundHandleError,
- rawEmitter: this.fsw._emitRaw
- });
- }
- return closer;
-}
-
-/**
- * Watch a file and emit add event if warranted.
- * @param {Path} file Path
- * @param {fs.Stats} stats result of fs_stat
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @returns {Function} closer for the watcher instance
- */
-_handleFile(file, stats, initialAdd) {
- if (this.fsw.closed) {
- return;
- }
- const dirname = sysPath$2.dirname(file);
- const basename = sysPath$2.basename(file);
- const parent = this.fsw._getWatchedDir(dirname);
- // stats is always present
- let prevStats = stats;
-
- // if the file is already being watched, do nothing
- if (parent.has(basename)) return;
-
- const listener = async (path, newStats) => {
- if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
- if (!newStats || newStats.mtimeMs === 0) {
- try {
- const newStats = await stat$2(file);
- if (this.fsw.closed) return;
- // Check that change event was not fired because of changed only accessTime.
- const at = newStats.atimeMs;
- const mt = newStats.mtimeMs;
- if (!at || at <= mt || mt !== prevStats.mtimeMs) {
- this.fsw._emit(EV_CHANGE$2, file, newStats);
- }
- if (isLinux && prevStats.ino !== newStats.ino) {
- this.fsw._closeFile(path);
- prevStats = newStats;
- this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
- } else {
- prevStats = newStats;
- }
- } catch (error) {
- // Fix issues where mtime is null but file is still present
- this.fsw._remove(dirname, basename);
- }
- // add is about to be emitted if file not already tracked in parent
- } else if (parent.has(basename)) {
- // Check that change event was not fired because of changed only accessTime.
- const at = newStats.atimeMs;
- const mt = newStats.mtimeMs;
- if (!at || at <= mt || mt !== prevStats.mtimeMs) {
- this.fsw._emit(EV_CHANGE$2, file, newStats);
- }
- prevStats = newStats;
- }
- };
- // kick off the watcher
- const closer = this._watchWithNodeFs(file, listener);
-
- // emit an add event if we're supposed to
- if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
- if (!this.fsw._throttle(EV_ADD$2, file, 0)) return;
- this.fsw._emit(EV_ADD$2, file, stats);
- }
-
- return closer;
-}
-
-/**
- * Handle symlinks encountered while reading a dir.
- * @param {Object} entry returned by readdirp
- * @param {String} directory path of dir being read
- * @param {String} path of this item
- * @param {String} item basename of this item
- * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
- */
-async _handleSymlink(entry, directory, path, item) {
- if (this.fsw.closed) {
- return;
- }
- const full = entry.fullPath;
- const dir = this.fsw._getWatchedDir(directory);
-
- if (!this.fsw.options.followSymlinks) {
- // watch symlink directly (don't follow) and detect changes
- this.fsw._incrReadyCount();
- const linkPath = await fsrealpath(path);
- if (this.fsw.closed) return;
- if (dir.has(item)) {
- if (this.fsw._symlinkPaths.get(full) !== linkPath) {
- this.fsw._symlinkPaths.set(full, linkPath);
- this.fsw._emit(EV_CHANGE$2, path, entry.stats);
- }
- } else {
- dir.add(item);
- this.fsw._symlinkPaths.set(full, linkPath);
- this.fsw._emit(EV_ADD$2, path, entry.stats);
- }
- this.fsw._emitReady();
- return true;
- }
-
- // don't follow the same symlink more than once
- if (this.fsw._symlinkPaths.has(full)) {
- return true;
- }
-
- this.fsw._symlinkPaths.set(full, true);
-}
-
-_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
- // Normalize the directory name on Windows
- directory = sysPath$2.join(directory, EMPTY_STR$1);
-
- if (!wh.hasGlob) {
- throttler = this.fsw._throttle('readdir', directory, 1000);
- if (!throttler) return;
- }
-
- const previous = this.fsw._getWatchedDir(wh.path);
- const current = new Set();
-
- let stream = this.fsw._readdirp(directory, {
- fileFilter: entry => wh.filterPath(entry),
- directoryFilter: entry => wh.filterDir(entry),
- depth: 0
- }).on(STR_DATA$1, async (entry) => {
- if (this.fsw.closed) {
- stream = undefined;
- return;
- }
- const item = entry.path;
- let path = sysPath$2.join(directory, item);
- current.add(item);
-
- if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
- return;
- }
-
- if (this.fsw.closed) {
- stream = undefined;
- return;
- }
- // Files that present in current directory snapshot
- // but absent in previous are added to watch list and
- // emit `add` event.
- if (item === target || !target && !previous.has(item)) {
- this.fsw._incrReadyCount();
-
- // ensure relativeness of path is preserved in case of watcher reuse
- path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
-
- this._addToNodeFs(path, initialAdd, wh, depth + 1);
- }
- }).on(EV_ERROR$2, this._boundHandleError);
-
- return new Promise(resolve =>
- stream.once(STR_END$2, () => {
- if (this.fsw.closed) {
- stream = undefined;
- return;
- }
- const wasThrottled = throttler ? throttler.clear() : false;
-
- resolve();
-
- // Files that absent in current directory snapshot
- // but present in previous emit `remove` event
- // and are removed from @watched[directory].
- previous.getChildren().filter((item) => {
- return item !== directory &&
- !current.has(item) &&
- // in case of intersecting globs;
- // a path may have been filtered out of this readdir, but
- // shouldn't be removed because it matches a different glob
- (!wh.hasGlob || wh.filterPath({
- fullPath: sysPath$2.resolve(directory, item)
- }));
- }).forEach((item) => {
- this.fsw._remove(directory, item);
- });
-
- stream = undefined;
-
- // one more time for any missed in case changes came in extremely quickly
- if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
- })
- );
-}
-
-/**
- * Read directory to add / remove files from `@watched` list and re-read it on change.
- * @param {String} dir fs path
- * @param {fs.Stats} stats
- * @param {Boolean} initialAdd
- * @param {Number} depth relative to user-supplied path
- * @param {String} target child path targeted for watch
- * @param {Object} wh Common watch helpers for this path
- * @param {String} realpath
- * @returns {Promise<Function>} closer for the watcher instance.
- */
-async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
- const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
- const tracked = parentDir.has(sysPath$2.basename(dir));
- if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
- if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
- }
-
- // ensure dir is tracked (harmless if redundant)
- parentDir.add(sysPath$2.basename(dir));
- this.fsw._getWatchedDir(dir);
- let throttler;
- let closer;
-
- const oDepth = this.fsw.options.depth;
- if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
- if (!target) {
- await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
- if (this.fsw.closed) return;
- }
-
- closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
- // if current directory is removed, do nothing
- if (stats && stats.mtimeMs === 0) return;
-
- this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
- });
- }
- return closer;
-}
-
-/**
- * Handle added file, directory, or glob pattern.
- * Delegates call to _handleFile / _handleDir after checks.
- * @param {String} path to file or ir
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @param {Object} priorWh depth relative to user-supplied path
- * @param {Number} depth Child path actually targeted for watch
- * @param {String=} target Child path actually targeted for watch
- * @returns {Promise}
- */
-async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
- const ready = this.fsw._emitReady;
- if (this.fsw._isIgnored(path) || this.fsw.closed) {
- ready();
- return false;
- }
-
- const wh = this.fsw._getWatchHelpers(path, depth);
- if (!wh.hasGlob && priorWh) {
- wh.hasGlob = priorWh.hasGlob;
- wh.globFilter = priorWh.globFilter;
- wh.filterPath = entry => priorWh.filterPath(entry);
- wh.filterDir = entry => priorWh.filterDir(entry);
- }
-
- // evaluate what is at the path we're being asked to watch
- try {
- const stats = await statMethods$1[wh.statMethod](wh.watchPath);
- if (this.fsw.closed) return;
- if (this.fsw._isIgnored(wh.watchPath, stats)) {
- ready();
- return false;
- }
-
- const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
- let closer;
- if (stats.isDirectory()) {
- const absPath = sysPath$2.resolve(path);
- const targetPath = follow ? await fsrealpath(path) : path;
- if (this.fsw.closed) return;
- closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
- if (this.fsw.closed) return;
- // preserve this symlink's target path
- if (absPath !== targetPath && targetPath !== undefined) {
- this.fsw._symlinkPaths.set(absPath, targetPath);
- }
- } else if (stats.isSymbolicLink()) {
- const targetPath = follow ? await fsrealpath(path) : path;
- if (this.fsw.closed) return;
- const parent = sysPath$2.dirname(wh.watchPath);
- this.fsw._getWatchedDir(parent).add(wh.watchPath);
- this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
- closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
- if (this.fsw.closed) return;
-
- // preserve this symlink's target path
- if (targetPath !== undefined) {
- this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
- }
- } else {
- closer = this._handleFile(wh.watchPath, stats, initialAdd);
- }
- ready();
-
- this.fsw._addPathCloser(path, closer);
- return false;
-
- } catch (error) {
- if (this.fsw._handleError(error)) {
- ready();
- return path;
- }
- }
-}
-
-}
-
-var nodefsHandler = NodeFsHandler$1;
-
-var fseventsHandler = {exports: {}};
-
-const fs$1 = require$$0__default$3['default'];
-const sysPath$1 = require$$0__default$2['default'];
-const { promisify: promisify$1 } = require$$0__default['default'];
-
-let fsevents;
-try {
- fsevents = undefined;
-} catch (error) {
- if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
-}
-
-if (fsevents) {
- // TODO: real check
- const mtch = process.version.match(/v(\d+)\.(\d+)/);
- if (mtch && mtch[1] && mtch[2]) {
- const maj = Number.parseInt(mtch[1], 10);
- const min = Number.parseInt(mtch[2], 10);
- if (maj === 8 && min < 16) {
- fsevents = undefined;
- }
- }
-}
-
-const {
- EV_ADD: EV_ADD$1,
- EV_CHANGE: EV_CHANGE$1,
- EV_ADD_DIR: EV_ADD_DIR$1,
- EV_UNLINK: EV_UNLINK$1,
- EV_ERROR: EV_ERROR$1,
- STR_DATA,
- STR_END: STR_END$1,
- FSEVENT_CREATED,
- FSEVENT_MODIFIED,
- FSEVENT_DELETED,
- FSEVENT_MOVED,
- // FSEVENT_CLONED,
- FSEVENT_UNKNOWN,
- FSEVENT_TYPE_FILE,
- FSEVENT_TYPE_DIRECTORY,
- FSEVENT_TYPE_SYMLINK,
-
- ROOT_GLOBSTAR,
- DIR_SUFFIX,
- DOT_SLASH,
- FUNCTION_TYPE: FUNCTION_TYPE$1,
- EMPTY_FN: EMPTY_FN$1,
- IDENTITY_FN
-} = constants$1;
-
-const Depth = (value) => isNaN(value) ? {} : {depth: value};
-
-const stat$1 = promisify$1(fs$1.stat);
-const lstat = promisify$1(fs$1.lstat);
-const realpath = promisify$1(fs$1.realpath);
-
-const statMethods = { stat: stat$1, lstat };
-
-/**
- * @typedef {String} Path
- */
-
-/**
- * @typedef {Object} FsEventsWatchContainer
- * @property {Set<Function>} listeners
- * @property {Function} rawEmitter
- * @property {{stop: Function}} watcher
- */
-
-// fsevents instance helper functions
-/**
- * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
- * @type {Map<Path,FsEventsWatchContainer>}
- */
-const FSEventsWatchers = new Map();
-
-// Threshold of duplicate path prefixes at which to start
-// consolidating going forward
-const consolidateThreshhold = 10;
-
-const wrongEventFlags = new Set([
- 69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
-]);
-
-/**
- * Instantiates the fsevents interface
- * @param {Path} path path to be watched
- * @param {Function} callback called when fsevents is bound and ready
- * @returns {{stop: Function}} new fsevents instance
- */
-const createFSEventsInstance = (path, callback) => {
- const stop = fsevents.watch(path, callback);
- return {stop};
-};
-
-/**
- * Instantiates the fsevents interface or binds listeners to an existing one covering
- * the same file tree.
- * @param {Path} path - to be watched
- * @param {Path} realPath - real path for symlinks
- * @param {Function} listener - called when fsevents emits events
- * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
- * @returns {Function} closer
- */
-function setFSEventsListener(path, realPath, listener, rawEmitter) {
- let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
-
- const parentPath = sysPath$1.dirname(watchPath);
- let cont = FSEventsWatchers.get(watchPath);
-
- // If we've accumulated a substantial number of paths that
- // could have been consolidated by watching one directory
- // above the current one, create a watcher on the parent
- // path instead, so that we do consolidate going forward.
- if (couldConsolidate(parentPath)) {
- watchPath = parentPath;
- }
-
- const resolvedPath = sysPath$1.resolve(path);
- const hasSymlink = resolvedPath !== realPath;
-
- const filteredListener = (fullPath, flags, info) => {
- if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
- if (
- fullPath === resolvedPath ||
- !fullPath.indexOf(resolvedPath + sysPath$1.sep)
- ) listener(fullPath, flags, info);
- };
-
- // check if there is already a watcher on a parent path
- // modifies `watchPath` to the parent path when it finds a match
- let watchedParent = false;
- for (const watchedPath of FSEventsWatchers.keys()) {
- if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
- watchPath = watchedPath;
- cont = FSEventsWatchers.get(watchPath);
- watchedParent = true;
- break;
- }
- }
-
- if (cont || watchedParent) {
- cont.listeners.add(filteredListener);
- } else {
- cont = {
- listeners: new Set([filteredListener]),
- rawEmitter,
- watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
- if (!cont.listeners.size) return;
- const info = fsevents.getInfo(fullPath, flags);
- cont.listeners.forEach(list => {
- list(fullPath, flags, info);
- });
-
- cont.rawEmitter(info.event, fullPath, info);
- })
- };
- FSEventsWatchers.set(watchPath, cont);
- }
-
- // removes this instance's listeners and closes the underlying fsevents
- // instance if there are no more listeners left
- return () => {
- const lst = cont.listeners;
-
- lst.delete(filteredListener);
- if (!lst.size) {
- FSEventsWatchers.delete(watchPath);
- if (cont.watcher) return cont.watcher.stop().then(() => {
- cont.rawEmitter = cont.watcher = undefined;
- Object.freeze(cont);
- });
- }
- };
-}
-
-// Decide whether or not we should start a new higher-level
-// parent watcher
-const couldConsolidate = (path) => {
- let count = 0;
- for (const watchPath of FSEventsWatchers.keys()) {
- if (watchPath.indexOf(path) === 0) {
- count++;
- if (count >= consolidateThreshhold) {
- return true;
- }
- }
- }
-
- return false;
-};
-
-// returns boolean indicating whether fsevents can be used
-const canUse = () => fsevents && FSEventsWatchers.size < 128;
-
-// determines subdirectory traversal levels from root to path
-const calcDepth = (path, root) => {
- let i = 0;
- while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
- return i;
-};
-
-// returns boolean indicating whether the fsevents' event info has the same type
-// as the one returned by fs.stat
-const sameTypes = (info, stats) => (
- info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
- info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
- info.type === FSEVENT_TYPE_FILE && stats.isFile()
-);
-
-/**
- * @mixin
- */
-class FsEventsHandler$1 {
-
-/**
- * @param {import('../index').FSWatcher} fsw
- */
-constructor(fsw) {
- this.fsw = fsw;
-}
-checkIgnored(path, stats) {
- const ipaths = this.fsw._ignoredPaths;
- if (this.fsw._isIgnored(path, stats)) {
- ipaths.add(path);
- if (stats && stats.isDirectory()) {
- ipaths.add(path + ROOT_GLOBSTAR);
- }
- return true;
- }
-
- ipaths.delete(path);
- ipaths.delete(path + ROOT_GLOBSTAR);
-}
-
-addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
- const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
- this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
-}
-
-async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
- try {
- const stats = await stat$1(path);
- if (this.fsw.closed) return;
- if (sameTypes(info, stats)) {
- this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- } else {
- this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
- }
- } catch (error) {
- if (error.code === 'EACCES') {
- this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- } else {
- this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
- }
- }
-}
-
-handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
- if (this.fsw.closed || this.checkIgnored(path)) return;
-
- if (event === EV_UNLINK$1) {
- const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
- // suppress unlink events on never before seen files
- if (isDirectory || watchedDir.has(item)) {
- this.fsw._remove(parent, item, isDirectory);
- }
- } else {
- if (event === EV_ADD$1) {
- // track new directories
- if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
-
- if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
- // push symlinks back to the top of the stack to get handled
- const curDepth = opts.depth === undefined ?
- undefined : calcDepth(fullPath, realPath) + 1;
- return this._addToFsEvents(path, false, true, curDepth);
- }
-
- // track new paths
- // (other than symlinks being followed, which will be tracked soon)
- this.fsw._getWatchedDir(parent).add(item);
- }
- /**
- * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
- */
- const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
- this.fsw._emit(eventName, path);
- if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
- }
-}
-
-/**
- * Handle symlinks encountered during directory scan
- * @param {String} watchPath - file/dir path to be watched with fsevents
- * @param {String} realPath - real path (in case of symlinks)
- * @param {Function} transform - path transformer
- * @param {Function} globFilter - path filter in case a glob pattern was provided
- * @returns {Function} closer for the watcher instance
-*/
-_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
- if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
- const opts = this.fsw.options;
- const watchCallback = async (fullPath, flags, info) => {
- if (this.fsw.closed) return;
- if (
- opts.depth !== undefined &&
- calcDepth(fullPath, realPath) > opts.depth
- ) return;
- const path = transform(sysPath$1.join(
- watchPath, sysPath$1.relative(watchPath, fullPath)
- ));
- if (globFilter && !globFilter(path)) return;
- // ensure directories are tracked
- const parent = sysPath$1.dirname(path);
- const item = sysPath$1.basename(path);
- const watchedDir = this.fsw._getWatchedDir(
- info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
- );
-
- // correct for wrong events emitted
- if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
- if (typeof opts.ignored === FUNCTION_TYPE$1) {
- let stats;
- try {
- stats = await stat$1(path);
- } catch (error) {}
- if (this.fsw.closed) return;
- if (this.checkIgnored(path, stats)) return;
- if (sameTypes(info, stats)) {
- this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- } else {
- this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
- }
- } else {
- this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- }
- } else {
- switch (info.event) {
- case FSEVENT_CREATED:
- case FSEVENT_MODIFIED:
- return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- case FSEVENT_DELETED:
- case FSEVENT_MOVED:
- return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
- }
- }
- };
-
- const closer = setFSEventsListener(
- watchPath,
- realPath,
- watchCallback,
- this.fsw._emitRaw
- );
-
- this.fsw._emitReady();
- return closer;
-}
-
-/**
- * Handle symlinks encountered during directory scan
- * @param {String} linkPath path to symlink
- * @param {String} fullPath absolute path to the symlink
- * @param {Function} transform pre-existing path transformer
- * @param {Number} curDepth level of subdirectories traversed to where symlink is
- * @returns {Promise<void>}
- */
-async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
- // don't follow the same symlink more than once
- if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
-
- this.fsw._symlinkPaths.set(fullPath, true);
- this.fsw._incrReadyCount();
-
- try {
- const linkTarget = await realpath(linkPath);
- if (this.fsw.closed) return;
- if (this.fsw._isIgnored(linkTarget)) {
- return this.fsw._emitReady();
- }
-
- this.fsw._incrReadyCount();
-
- // add the linkTarget for watching with a wrapper for transform
- // that causes emitted paths to incorporate the link's path
- this._addToFsEvents(linkTarget || linkPath, (path) => {
- let aliasedPath = linkPath;
- if (linkTarget && linkTarget !== DOT_SLASH) {
- aliasedPath = path.replace(linkTarget, linkPath);
- } else if (path !== DOT_SLASH) {
- aliasedPath = sysPath$1.join(linkPath, path);
- }
- return transform(aliasedPath);
- }, false, curDepth);
- } catch(error) {
- if (this.fsw._handleError(error)) {
- return this.fsw._emitReady();
- }
- }
-}
-
-/**
- *
- * @param {Path} newPath
- * @param {fs.Stats} stats
- */
-emitAdd(newPath, stats, processPath, opts, forceAdd) {
- const pp = processPath(newPath);
- const isDir = stats.isDirectory();
- const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
- const base = sysPath$1.basename(pp);
-
- // ensure empty dirs get tracked
- if (isDir) this.fsw._getWatchedDir(pp);
- if (dirObj.has(base)) return;
- dirObj.add(base);
-
- if (!opts.ignoreInitial || forceAdd === true) {
- this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
- }
-}
-
-initWatch(realPath, path, wh, processPath) {
- if (this.fsw.closed) return;
- const closer = this._watchWithFsEvents(
- wh.watchPath,
- sysPath$1.resolve(realPath || wh.watchPath),
- processPath,
- wh.globFilter
- );
- this.fsw._addPathCloser(path, closer);
-}
-
-/**
- * Handle added path with fsevents
- * @param {String} path file/dir path or glob pattern
- * @param {Function|Boolean=} transform converts working path to what the user expects
- * @param {Boolean=} forceAdd ensure add is emitted
- * @param {Number=} priorDepth Level of subdirectories already traversed.
- * @returns {Promise<void>}
- */
-async _addToFsEvents(path, transform, forceAdd, priorDepth) {
- if (this.fsw.closed) {
- return;
- }
- const opts = this.fsw.options;
- const processPath = typeof transform === FUNCTION_TYPE$1 ? transform : IDENTITY_FN;
-
- const wh = this.fsw._getWatchHelpers(path);
-
- // evaluate what is at the path we're being asked to watch
- try {
- const stats = await statMethods[wh.statMethod](wh.watchPath);
- if (this.fsw.closed) return;
- if (this.fsw._isIgnored(wh.watchPath, stats)) {
- throw null;
- }
- if (stats.isDirectory()) {
- // emit addDir unless this is a glob parent
- if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
-
- // don't recurse further if it would exceed depth setting
- if (priorDepth && priorDepth > opts.depth) return;
-
- // scan the contents of the dir
- this.fsw._readdirp(wh.watchPath, {
- fileFilter: entry => wh.filterPath(entry),
- directoryFilter: entry => wh.filterDir(entry),
- ...Depth(opts.depth - (priorDepth || 0))
- }).on(STR_DATA, (entry) => {
- // need to check filterPath on dirs b/c filterDir is less restrictive
- if (this.fsw.closed) {
- return;
- }
- if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
-
- const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
- const {fullPath} = entry;
-
- if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
- // preserve the current depth here since it can't be derived from
- // real paths past the symlink
- const curDepth = opts.depth === undefined ?
- undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
-
- this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
- } else {
- this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
- }
- }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
- this.fsw._emitReady();
- });
- } else {
- this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
- this.fsw._emitReady();
- }
- } catch (error) {
- if (!error || this.fsw._handleError(error)) {
- // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
- this.fsw._emitReady();
- this.fsw._emitReady();
- }
- }
-
- if (opts.persistent && forceAdd !== true) {
- if (typeof transform === FUNCTION_TYPE$1) {
- // realpath has already been resolved
- this.initWatch(undefined, path, wh, processPath);
- } else {
- let realPath;
- try {
- realPath = await realpath(wh.watchPath);
- } catch (e) {}
- this.initWatch(realPath, path, wh, processPath);
- }
- }
-}
-
-}
-
-fseventsHandler.exports = FsEventsHandler$1;
-fseventsHandler.exports.canUse = canUse;
-
-const { EventEmitter } = require$$0__default$4['default'];
-const fs = require$$0__default$3['default'];
-const sysPath = require$$0__default$2['default'];
-const { promisify } = require$$0__default['default'];
-const readdirp = readdirp_1;
-const anymatch = anymatch$2.exports.default;
-const globParent = globParent$1;
-const isGlob = isGlob$2;
-const braces = braces_1;
-const normalizePath = normalizePath$2;
-
-const NodeFsHandler = nodefsHandler;
-const FsEventsHandler = fseventsHandler.exports;
-const {
- EV_ALL,
- EV_READY,
- EV_ADD,
- EV_CHANGE,
- EV_UNLINK,
- EV_ADD_DIR,
- EV_UNLINK_DIR,
- EV_RAW,
- EV_ERROR,
-
- STR_CLOSE,
- STR_END,
-
- BACK_SLASH_RE,
- DOUBLE_SLASH_RE,
- SLASH_OR_BACK_SLASH_RE,
- DOT_RE,
- REPLACER_RE,
-
- SLASH,
- SLASH_SLASH,
- BRACE_START,
- BANG,
- ONE_DOT,
- TWO_DOTS,
- GLOBSTAR,
- SLASH_GLOBSTAR,
- ANYMATCH_OPTS,
- STRING_TYPE,
- FUNCTION_TYPE,
- EMPTY_STR,
- EMPTY_FN,
-
- isWindows,
- isMacos,
- isIBMi
-} = constants$1;
-
-const stat = promisify(fs.stat);
-const readdir = promisify(fs.readdir);
-
-/**
- * @typedef {String} Path
- * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
- * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
- */
-
-/**
- *
- * @typedef {Object} WatchHelpers
- * @property {Boolean} followSymlinks
- * @property {'stat'|'lstat'} statMethod
- * @property {Path} path
- * @property {Path} watchPath
- * @property {Function} entryPath
- * @property {Boolean} hasGlob
- * @property {Object} globFilter
- * @property {Function} filterPath
- * @property {Function} filterDir
- */
-
-const arrify = (value = []) => Array.isArray(value) ? value : [value];
-const flatten$1 = (list, result = []) => {
- list.forEach(item => {
- if (Array.isArray(item)) {
- flatten$1(item, result);
- } else {
- result.push(item);
- }
- });
- return result;
-};
-
-const unifyPaths = (paths_) => {
- /**
- * @type {Array<String>}
- */
- const paths = flatten$1(arrify(paths_));
- if (!paths.every(p => typeof p === STRING_TYPE)) {
- throw new TypeError(`Non-string provided as watch path: ${paths}`);
- }
- return paths.map(normalizePathToUnix);
-};
-
-// If SLASH_SLASH occurs at the beginning of path, it is not replaced
-// because "//StoragePC/DrivePool/Movies" is a valid network path
-const toUnix = (string) => {
- let str = string.replace(BACK_SLASH_RE, SLASH);
- let prepend = false;
- if (str.startsWith(SLASH_SLASH)) {
- prepend = true;
- }
- while (str.match(DOUBLE_SLASH_RE)) {
- str = str.replace(DOUBLE_SLASH_RE, SLASH);
- }
- if (prepend) {
- str = SLASH + str;
- }
- return str;
-};
-
-// Our version of upath.normalize
-// TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
-
-const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
- if (typeof path !== STRING_TYPE) return path;
- return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
-};
-
-const getAbsolutePath = (path, cwd) => {
- if (sysPath.isAbsolute(path)) {
- return path;
- }
- if (path.startsWith(BANG)) {
- return BANG + sysPath.join(cwd, path.slice(1));
- }
- return sysPath.join(cwd, path);
-};
-
-const undef = (opts, key) => opts[key] === undefined;
-
-/**
- * Directory entry.
- * @property {Path} path
- * @property {Set<Path>} items
- */
-class DirEntry {
- /**
- * @param {Path} dir
- * @param {Function} removeWatcher
- */
- constructor(dir, removeWatcher) {
- this.path = dir;
- this._removeWatcher = removeWatcher;
- /** @type {Set<Path>} */
- this.items = new Set();
- }
-
- add(item) {
- const {items} = this;
- if (!items) return;
- if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
- }
-
- async remove(item) {
- const {items} = this;
- if (!items) return;
- items.delete(item);
- if (items.size > 0) return;
-
- const dir = this.path;
- try {
- await readdir(dir);
- } catch (err) {
- if (this._removeWatcher) {
- this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
- }
- }
- }
-
- has(item) {
- const {items} = this;
- if (!items) return;
- return items.has(item);
- }
-
- /**
- * @returns {Array<String>}
- */
- getChildren() {
- const {items} = this;
- if (!items) return;
- return [...items.values()];
- }
-
- dispose() {
- this.items.clear();
- delete this.path;
- delete this._removeWatcher;
- delete this.items;
- Object.freeze(this);
- }
-}
-
-const STAT_METHOD_F = 'stat';
-const STAT_METHOD_L = 'lstat';
-class WatchHelper {
- constructor(path, watchPath, follow, fsw) {
- this.fsw = fsw;
- this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
- this.watchPath = watchPath;
- this.fullWatchPath = sysPath.resolve(watchPath);
- this.hasGlob = watchPath !== path;
- /** @type {object|boolean} */
- if (path === EMPTY_STR) this.hasGlob = false;
- this.globSymlink = this.hasGlob && follow ? undefined : false;
- this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
- this.dirParts = this.getDirParts(path);
- this.dirParts.forEach((parts) => {
- if (parts.length > 1) parts.pop();
- });
- this.followSymlinks = follow;
- this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
- }
-
- checkGlobSymlink(entry) {
- // only need to resolve once
- // first entry should always have entry.parentDir === EMPTY_STR
- if (this.globSymlink === undefined) {
- this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
- false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
- }
-
- if (this.globSymlink) {
- return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
- }
-
- return entry.fullPath;
- }
-
- entryPath(entry) {
- return sysPath.join(this.watchPath,
- sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
- );
- }
-
- filterPath(entry) {
- const {stats} = entry;
- if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
- const resolvedPath = this.entryPath(entry);
- const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
- this.globFilter(resolvedPath) : true;
- return matchesGlob &&
- this.fsw._isntIgnored(resolvedPath, stats) &&
- this.fsw._hasReadPermissions(stats);
- }
-
- getDirParts(path) {
- if (!this.hasGlob) return [];
- const parts = [];
- const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
- expandedPath.forEach((path) => {
- parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
- });
- return parts;
- }
-
- filterDir(entry) {
- if (this.hasGlob) {
- const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
- let globstar = false;
- this.unmatchedGlob = !this.dirParts.some((parts) => {
- return parts.every((part, i) => {
- if (part === GLOBSTAR) globstar = true;
- return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
- });
- });
- }
- return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
- }
-}
-
-/**
- * Watches files & directories for changes. Emitted events:
- * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
- *
- * new FSWatcher()
- * .add(directories)
- * .on('add', path => log('File', path, 'was added'))
- */
-class FSWatcher extends EventEmitter {
-// Not indenting methods for history sake; for now.
-constructor(_opts) {
- super();
-
- const opts = {};
- if (_opts) Object.assign(opts, _opts); // for frozen objects
-
- /** @type {Map<String, DirEntry>} */
- this._watched = new Map();
- /** @type {Map<String, Array>} */
- this._closers = new Map();
- /** @type {Set<String>} */
- this._ignoredPaths = new Set();
-
- /** @type {Map<ThrottleType, Map>} */
- this._throttled = new Map();
-
- /** @type {Map<Path, String|Boolean>} */
- this._symlinkPaths = new Map();
-
- this._streams = new Set();
- this.closed = false;
-
- // Set up default options.
- if (undef(opts, 'persistent')) opts.persistent = true;
- if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
- if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
- if (undef(opts, 'interval')) opts.interval = 100;
- if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
- if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
- opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
-
- // Enable fsevents on OS X when polling isn't explicitly enabled.
- if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
-
- // If we can't use fsevents, ensure the options reflect it's disabled.
- const canUseFsEvents = FsEventsHandler.canUse();
- if (!canUseFsEvents) opts.useFsEvents = false;
-
- // Use polling on Mac if not using fsevents.
- // Other platforms use non-polling fs_watch.
- if (undef(opts, 'usePolling') && !opts.useFsEvents) {
- opts.usePolling = isMacos;
- }
-
- // Always default to polling on IBM i because fs.watch() is not available on IBM i.
- if(isIBMi) {
- opts.usePolling = true;
- }
-
- // Global override (useful for end-developers that need to force polling for all
- // instances of chokidar, regardless of usage/dependency depth)
- const envPoll = process.env.CHOKIDAR_USEPOLLING;
- if (envPoll !== undefined) {
- const envLower = envPoll.toLowerCase();
-
- if (envLower === 'false' || envLower === '0') {
- opts.usePolling = false;
- } else if (envLower === 'true' || envLower === '1') {
- opts.usePolling = true;
- } else {
- opts.usePolling = !!envLower;
- }
- }
- const envInterval = process.env.CHOKIDAR_INTERVAL;
- if (envInterval) {
- opts.interval = Number.parseInt(envInterval, 10);
- }
-
- // Editor atomic write normalization enabled by default with fs.watch
- if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
- if (opts.atomic) this._pendingUnlinks = new Map();
-
- if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
-
- if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
- if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
- const awf = opts.awaitWriteFinish;
- if (awf) {
- if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
- if (!awf.pollInterval) awf.pollInterval = 100;
- this._pendingWrites = new Map();
- }
- if (opts.ignored) opts.ignored = arrify(opts.ignored);
-
- let readyCalls = 0;
- this._emitReady = () => {
- readyCalls++;
- if (readyCalls >= this._readyCount) {
- this._emitReady = EMPTY_FN;
- this._readyEmitted = true;
- // use process.nextTick to allow time for listener to be bound
- process.nextTick(() => this.emit(EV_READY));
- }
- };
- this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
- this._readyEmitted = false;
- this.options = opts;
-
- // Initialize with proper watcher.
- if (opts.useFsEvents) {
- this._fsEventsHandler = new FsEventsHandler(this);
- } else {
- this._nodeFsHandler = new NodeFsHandler(this);
- }
-
- // You’re frozen when your heart’s not open.
- Object.freeze(opts);
-}
-
-// Public methods
-
-/**
- * Adds paths to be watched on an existing FSWatcher instance
- * @param {Path|Array<Path>} paths_
- * @param {String=} _origAdd private; for handling non-existent paths to be watched
- * @param {Boolean=} _internal private; indicates a non-user add
- * @returns {FSWatcher} for chaining
- */
-add(paths_, _origAdd, _internal) {
- const {cwd, disableGlobbing} = this.options;
- this.closed = false;
- let paths = unifyPaths(paths_);
- if (cwd) {
- paths = paths.map((path) => {
- const absPath = getAbsolutePath(path, cwd);
-
- // Check `path` instead of `absPath` because the cwd portion can't be a glob
- if (disableGlobbing || !isGlob(path)) {
- return absPath;
- }
- return normalizePath(absPath);
- });
- }
-
- // set aside negated glob strings
- paths = paths.filter((path) => {
- if (path.startsWith(BANG)) {
- this._ignoredPaths.add(path.slice(1));
- return false;
- }
-
- // if a path is being added that was previously ignored, stop ignoring it
- this._ignoredPaths.delete(path);
- this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
-
- // reset the cached userIgnored anymatch fn
- // to make ignoredPaths changes effective
- this._userIgnored = undefined;
-
- return true;
- });
-
- if (this.options.useFsEvents && this._fsEventsHandler) {
- if (!this._readyCount) this._readyCount = paths.length;
- if (this.options.persistent) this._readyCount *= 2;
- paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
- } else {
- if (!this._readyCount) this._readyCount = 0;
- this._readyCount += paths.length;
- Promise.all(
- paths.map(async path => {
- const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
- if (res) this._emitReady();
- return res;
- })
- ).then(results => {
- if (this.closed) return;
- results.filter(item => item).forEach(item => {
- this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
- });
- });
- }
-
- return this;
-}
-
-/**
- * Close watchers or start ignoring events from specified paths.
- * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
- * @returns {FSWatcher} for chaining
-*/
-unwatch(paths_) {
- if (this.closed) return this;
- const paths = unifyPaths(paths_);
- const {cwd} = this.options;
-
- paths.forEach((path) => {
- // convert to absolute path unless relative path already matches
- if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
- if (cwd) path = sysPath.join(cwd, path);
- path = sysPath.resolve(path);
- }
-
- this._closePath(path);
-
- this._ignoredPaths.add(path);
- if (this._watched.has(path)) {
- this._ignoredPaths.add(path + SLASH_GLOBSTAR);
- }
-
- // reset the cached userIgnored anymatch fn
- // to make ignoredPaths changes effective
- this._userIgnored = undefined;
- });
-
- return this;
-}
-
-/**
- * Close watchers and remove all listeners from watched paths.
- * @returns {Promise<void>}.
-*/
-close() {
- if (this.closed) return this._closePromise;
- this.closed = true;
-
- // Memory management.
- this.removeAllListeners();
- const closers = [];
- this._closers.forEach(closerList => closerList.forEach(closer => {
- const promise = closer();
- if (promise instanceof Promise) closers.push(promise);
- }));
- this._streams.forEach(stream => stream.destroy());
- this._userIgnored = undefined;
- this._readyCount = 0;
- this._readyEmitted = false;
- this._watched.forEach(dirent => dirent.dispose());
- ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
- this[`_${key}`].clear();
- });
-
- this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
- return this._closePromise;
-}
-
-/**
- * Expose list of watched paths
- * @returns {Object} for chaining
-*/
-getWatched() {
- const watchList = {};
- this._watched.forEach((entry, dir) => {
- const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
- watchList[key || ONE_DOT] = entry.getChildren().sort();
- });
- return watchList;
-}
-
-emitWithAll(event, args) {
- this.emit(...args);
- if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
-}
-
-// Common helpers
-// --------------
-
-/**
- * Normalize and emit events.
- * Calling _emit DOES NOT MEAN emit() would be called!
- * @param {EventName} event Type of event
- * @param {Path} path File or directory path
- * @param {*=} val1 arguments to be passed with event
- * @param {*=} val2
- * @param {*=} val3
- * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
- */
-async _emit(event, path, val1, val2, val3) {
- if (this.closed) return;
-
- const opts = this.options;
- if (isWindows) path = sysPath.normalize(path);
- if (opts.cwd) path = sysPath.relative(opts.cwd, path);
- /** @type Array<any> */
- const args = [event, path];
- if (val3 !== undefined) args.push(val1, val2, val3);
- else if (val2 !== undefined) args.push(val1, val2);
- else if (val1 !== undefined) args.push(val1);
-
- const awf = opts.awaitWriteFinish;
- let pw;
- if (awf && (pw = this._pendingWrites.get(path))) {
- pw.lastChange = new Date();
- return this;
- }
-
- if (opts.atomic) {
- if (event === EV_UNLINK) {
- this._pendingUnlinks.set(path, args);
- setTimeout(() => {
- this._pendingUnlinks.forEach((entry, path) => {
- this.emit(...entry);
- this.emit(EV_ALL, ...entry);
- this._pendingUnlinks.delete(path);
- });
- }, typeof opts.atomic === 'number' ? opts.atomic : 100);
- return this;
- }
- if (event === EV_ADD && this._pendingUnlinks.has(path)) {
- event = args[0] = EV_CHANGE;
- this._pendingUnlinks.delete(path);
- }
- }
-
- if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
- const awfEmit = (err, stats) => {
- if (err) {
- event = args[0] = EV_ERROR;
- args[1] = err;
- this.emitWithAll(event, args);
- } else if (stats) {
- // if stats doesn't exist the file must have been deleted
- if (args.length > 2) {
- args[2] = stats;
- } else {
- args.push(stats);
- }
- this.emitWithAll(event, args);
- }
- };
-
- this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
- return this;
- }
-
- if (event === EV_CHANGE) {
- const isThrottled = !this._throttle(EV_CHANGE, path, 50);
- if (isThrottled) return this;
- }
-
- if (opts.alwaysStat && val1 === undefined &&
- (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
- ) {
- const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
- let stats;
- try {
- stats = await stat(fullPath);
- } catch (err) {}
- // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
- if (!stats || this.closed) return;
- args.push(stats);
- }
- this.emitWithAll(event, args);
-
- return this;
-}
-
-/**
- * Common handler for errors
- * @param {Error} error
- * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
- */
-_handleError(error) {
- const code = error && error.code;
- if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
- (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
- ) {
- this.emit(EV_ERROR, error);
- }
- return error || this.closed;
-}
-
-/**
- * Helper utility for throttling
- * @param {ThrottleType} actionType type being throttled
- * @param {Path} path being acted upon
- * @param {Number} timeout duration of time to suppress duplicate actions
- * @returns {Object|false} tracking object or false if action should be suppressed
- */
-_throttle(actionType, path, timeout) {
- if (!this._throttled.has(actionType)) {
- this._throttled.set(actionType, new Map());
- }
-
- /** @type {Map<Path, Object>} */
- const action = this._throttled.get(actionType);
- /** @type {Object} */
- const actionPath = action.get(path);
-
- if (actionPath) {
- actionPath.count++;
- return false;
- }
-
- let timeoutObject;
- const clear = () => {
- const item = action.get(path);
- const count = item ? item.count : 0;
- action.delete(path);
- clearTimeout(timeoutObject);
- if (item) clearTimeout(item.timeoutObject);
- return count;
- };
- timeoutObject = setTimeout(clear, timeout);
- const thr = {timeoutObject, clear, count: 0};
- action.set(path, thr);
- return thr;
-}
-
-_incrReadyCount() {
- return this._readyCount++;
-}
-
-/**
- * Awaits write operation to finish.
- * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
- * @param {Path} path being acted upon
- * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
- * @param {EventName} event
- * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
- */
-_awaitWriteFinish(path, threshold, event, awfEmit) {
- let timeoutHandler;
-
- let fullPath = path;
- if (this.options.cwd && !sysPath.isAbsolute(path)) {
- fullPath = sysPath.join(this.options.cwd, path);
- }
-
- const now = new Date();
-
- const awaitWriteFinish = (prevStat) => {
- fs.stat(fullPath, (err, curStat) => {
- if (err || !this._pendingWrites.has(path)) {
- if (err && err.code !== 'ENOENT') awfEmit(err);
- return;
- }
-
- const now = Number(new Date());
-
- if (prevStat && curStat.size !== prevStat.size) {
- this._pendingWrites.get(path).lastChange = now;
- }
- const pw = this._pendingWrites.get(path);
- const df = now - pw.lastChange;
-
- if (df >= threshold) {
- this._pendingWrites.delete(path);
- awfEmit(undefined, curStat);
- } else {
- timeoutHandler = setTimeout(
- awaitWriteFinish,
- this.options.awaitWriteFinish.pollInterval,
- curStat
- );
- }
- });
- };
-
- if (!this._pendingWrites.has(path)) {
- this._pendingWrites.set(path, {
- lastChange: now,
- cancelWait: () => {
- this._pendingWrites.delete(path);
- clearTimeout(timeoutHandler);
- return event;
- }
- });
- timeoutHandler = setTimeout(
- awaitWriteFinish,
- this.options.awaitWriteFinish.pollInterval
- );
- }
-}
-
-_getGlobIgnored() {
- return [...this._ignoredPaths.values()];
-}
-
-/**
- * Determines whether user has asked to ignore this path.
- * @param {Path} path filepath or dir
- * @param {fs.Stats=} stats result of fs.stat
- * @returns {Boolean}
- */
-_isIgnored(path, stats) {
- if (this.options.atomic && DOT_RE.test(path)) return true;
- if (!this._userIgnored) {
- const {cwd} = this.options;
- const ign = this.options.ignored;
-
- const ignored = ign && ign.map(normalizeIgnored(cwd));
- const paths = arrify(ignored)
- .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
- .map((path) => path + SLASH_GLOBSTAR);
- const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
- this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
- }
-
- return this._userIgnored([path, stats]);
-}
-
-_isntIgnored(path, stat) {
- return !this._isIgnored(path, stat);
-}
-
-/**
- * Provides a set of common helpers and properties relating to symlink and glob handling.
- * @param {Path} path file, directory, or glob pattern being watched
- * @param {Number=} depth at any depth > 0, this isn't a glob
- * @returns {WatchHelper} object containing helpers for this path
- */
-_getWatchHelpers(path, depth) {
- const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
- const follow = this.options.followSymlinks;
-
- return new WatchHelper(path, watchPath, follow, this);
-}
-
-// Directory helpers
-// -----------------
-
-/**
- * Provides directory tracking objects
- * @param {String} directory path of the directory
- * @returns {DirEntry} the directory's tracking object
- */
-_getWatchedDir(directory) {
- if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
- const dir = sysPath.resolve(directory);
- if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
- return this._watched.get(dir);
-}
-
-// File helpers
-// ------------
-
-/**
- * Check for read permissions.
- * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
- * @param {fs.Stats} stats - object, result of fs_stat
- * @returns {Boolean} indicates whether the file can be read
-*/
-_hasReadPermissions(stats) {
- if (this.options.ignorePermissionErrors) return true;
-
- // stats.mode may be bigint
- const md = stats && Number.parseInt(stats.mode, 10);
- const st = md & 0o777;
- const it = Number.parseInt(st.toString(8)[0], 10);
- return Boolean(4 & it);
-}
-
-/**
- * Handles emitting unlink events for
- * files and directories, and via recursion, for
- * files and directories within directories that are unlinked
- * @param {String} directory within which the following item is located
- * @param {String} item base path of item/directory
- * @returns {void}
-*/
-_remove(directory, item, isDirectory) {
- // if what is being deleted is a directory, get that directory's paths
- // for recursive deleting and cleaning of watched object
- // if it is not a directory, nestedDirectoryChildren will be empty array
- const path = sysPath.join(directory, item);
- const fullPath = sysPath.resolve(path);
- isDirectory = isDirectory != null
- ? isDirectory
- : this._watched.has(path) || this._watched.has(fullPath);
-
- // prevent duplicate handling in case of arriving here nearly simultaneously
- // via multiple paths (such as _handleFile and _handleDir)
- if (!this._throttle('remove', path, 100)) return;
-
- // if the only watched file is removed, watch for its return
- if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
- this.add(directory, item, true);
- }
-
- // This will create a new entry in the watched object in either case
- // so we got to do the directory check beforehand
- const wp = this._getWatchedDir(path);
- const nestedDirectoryChildren = wp.getChildren();
-
- // Recursively remove children directories / files.
- nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
-
- // Check if item was on the watched list and remove it
- const parent = this._getWatchedDir(directory);
- const wasTracked = parent.has(item);
- parent.remove(item);
-
- // Fixes issue #1042 -> Relative paths were detected and added as symlinks
- // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
- // but never removed from the map in case the path was deleted.
- // This leads to an incorrect state if the path was recreated:
- // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
- if (this._symlinkPaths.has(fullPath)) {
- this._symlinkPaths.delete(fullPath);
- }
-
- // If we wait for this file to be fully written, cancel the wait.
- let relPath = path;
- if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
- if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
- const event = this._pendingWrites.get(relPath).cancelWait();
- if (event === EV_ADD) return;
- }
-
- // The Entry will either be a directory that just got removed
- // or a bogus entry to a file, in either case we have to remove it
- this._watched.delete(path);
- this._watched.delete(fullPath);
- const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
- if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
-
- // Avoid conflicts if we later create another file with the same name
- if (!this.options.useFsEvents) {
- this._closePath(path);
- }
-}
-
-/**
- * Closes all watchers for a path
- * @param {Path} path
- */
-_closePath(path) {
- this._closeFile(path);
- const dir = sysPath.dirname(path);
- this._getWatchedDir(dir).remove(sysPath.basename(path));
-}
-
-/**
- * Closes only file-specific watchers
- * @param {Path} path
- */
-_closeFile(path) {
- const closers = this._closers.get(path);
- if (!closers) return;
- closers.forEach(closer => closer());
- this._closers.delete(path);
-}
-
-/**
- *
- * @param {Path} path
- * @param {Function} closer
- */
-_addPathCloser(path, closer) {
- if (!closer) return;
- let list = this._closers.get(path);
- if (!list) {
- list = [];
- this._closers.set(path, list);
- }
- list.push(closer);
-}
-
-_readdirp(root, opts) {
- if (this.closed) return;
- const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
- let stream = readdirp(root, options);
- this._streams.add(stream);
- stream.once(STR_CLOSE, () => {
- stream = undefined;
- });
- stream.once(STR_END, () => {
- if (stream) {
- this._streams.delete(stream);
- stream = undefined;
- }
- });
- return stream;
-}
-
-}
-
-// Export FSWatcher class
-chokidar$1.FSWatcher = FSWatcher;
-
-/**
- * Instantiates watcher with paths to be tracked.
- * @param {String|Array<String>} paths file/directory paths and/or globs
- * @param {Object=} options chokidar opts
- * @returns an instance of FSWatcher for chaining.
- */
-const watch = (paths, options) => {
- const watcher = new FSWatcher(options);
- watcher.add(paths);
- return watcher;
-};
-
-chokidar$1.watch = watch;
-
var textTable = function (rows_, opts) {
if (!opts) opts = {};
var hsep = opts.hsep === undefined ? ' ' : opts.hsep;
@@ -25198,8 +30482,8 @@ var textTable = function (rows_, opts) {
return acc;
}, []);
- var rows = map$6(rows_, function (row) {
- return map$6(row, function (c_, ix) {
+ 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);
@@ -25220,8 +30504,8 @@ var textTable = function (rows_, opts) {
return acc;
}, []);
- return map$6(rows, function (row) {
- return map$6(row, function (c, ix) {
+ 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] === '.') {
@@ -25260,7 +30544,7 @@ function forEach (xs, f) {
}
}
-function map$6 (xs, f) {
+function map$2 (xs, f) {
if (xs.map) return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
@@ -25271,7 +30555,7 @@ function map$6 (xs, f) {
var camelcase$1 = {exports: {}};
-const preserveCamelCase = string => {
+const preserveCamelCase = (string, locale) => {
let isLastCharLower = false;
let isLastCharUpper = false;
let isLastLastCharUpper = false;
@@ -25279,37 +30563,46 @@ const preserveCamelCase = string => {
for (let i = 0; i < string.length; i++) {
const character = string[i];
- if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
+ if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
string = string.slice(0, i) + '-' + string.slice(i);
isLastCharLower = false;
isLastLastCharUpper = isLastCharUpper;
isLastCharUpper = true;
i++;
- } else if (isLastCharUpper && isLastLastCharUpper && /[a-zA-Z]/.test(character) && character.toLowerCase() === character) {
+ } else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
isLastLastCharUpper = isLastCharUpper;
isLastCharUpper = false;
isLastCharLower = true;
} else {
- isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
+ isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
isLastLastCharUpper = isLastCharUpper;
- isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
+ isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
}
}
return string;
};
+const preserveConsecutiveUppercase = input => {
+ return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, m1 => m1.toLowerCase());
+};
+
+const postProcess = (input, options) => {
+ return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toLocaleUpperCase(options.locale))
+ .replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toLocaleUpperCase(options.locale));
+};
+
const camelCase = (input, options) => {
if (!(typeof input === 'string' || Array.isArray(input))) {
throw new TypeError('Expected the input to be `string | string[]`');
}
- options = Object.assign({
- pascalCase: false
- }, options);
-
- const postProcess = x => options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x;
+ options = {
+ pascalCase: false,
+ preserveConsecutiveUppercase: false,
+ ...options
+ };
if (Array.isArray(input)) {
input = input.map(x => x.trim())
@@ -25324,29 +30617,37 @@ const camelCase = (input, options) => {
}
if (input.length === 1) {
- return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
+ return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
}
- const hasUpperCase = input !== input.toLowerCase();
+ const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
if (hasUpperCase) {
- input = preserveCamelCase(input);
+ input = preserveCamelCase(input, options.locale);
}
- input = input
- .replace(/^[_.\- ]+/, '')
- .toLowerCase()
- .replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
- .replace(/\d+(\w|$)/g, m => m.toUpperCase());
+ input = input.replace(/^[_.\- ]+/, '');
+
+ if (options.preserveConsecutiveUppercase) {
+ input = preserveConsecutiveUppercase(input);
+ } else {
+ input = input.toLocaleLowerCase();
+ }
+
+ if (options.pascalCase) {
+ input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
+ }
- return postProcess(input);
+ return postProcess(input, options);
};
camelcase$1.exports = camelCase;
// TODO: Remove this for the next major release
camelcase$1.exports.default = camelCase;
-var minimist$1 = function (args, opts) {
+var camelcase = camelcase$1.exports;
+
+var minimist = function (args, opts) {
if (!opts) opts = {};
var flags = { bools : {}, strings : {}, unknownFn: null };
@@ -25646,7 +30947,7 @@ let token;
let key;
let root$1;
-var parse$4 = function parse (text, reviver) {
+var parse$1 = function parse (text, reviver) {
source = String(text);
parseState = 'start';
stack = [];
@@ -25692,14 +30993,14 @@ function internalize (holder, name, reviver) {
}
let lexState;
-let buffer$2;
+let buffer;
let doubleQuote;
let sign;
let c;
function lex () {
lexState = 'default';
- buffer$2 = '';
+ buffer = '';
doubleQuote = false;
sign = 1;
@@ -25880,12 +31181,12 @@ const lexStates = {
return
case '.':
- buffer$2 = read();
+ buffer = read();
lexState = 'decimalPointLeading';
return
case '0':
- buffer$2 = read();
+ buffer = read();
lexState = 'zero';
return
@@ -25898,7 +31199,7 @@ const lexStates = {
case '7':
case '8':
case '9':
- buffer$2 = read();
+ buffer = read();
lexState = 'decimalInteger';
return
@@ -25915,7 +31216,7 @@ const lexStates = {
case '"':
case "'":
doubleQuote = (read() === '"');
- buffer$2 = '';
+ buffer = '';
lexState = 'string';
return
}
@@ -25943,7 +31244,7 @@ const lexStates = {
break
}
- buffer$2 += u;
+ buffer += u;
lexState = 'identifierName';
},
@@ -25953,7 +31254,7 @@ const lexStates = {
case '_':
case '\u200C':
case '\u200D':
- buffer$2 += read();
+ buffer += read();
return
case '\\':
@@ -25963,11 +31264,11 @@ const lexStates = {
}
if (util.isIdContinueChar(c)) {
- buffer$2 += read();
+ buffer += read();
return
}
- return newToken('identifier', buffer$2)
+ return newToken('identifier', buffer)
},
identifierNameEscape () {
@@ -25992,19 +31293,19 @@ const lexStates = {
break
}
- buffer$2 += u;
+ buffer += u;
lexState = 'identifierName';
},
sign () {
switch (c) {
case '.':
- buffer$2 = read();
+ buffer = read();
lexState = 'decimalPointLeading';
return
case '0':
- buffer$2 = read();
+ buffer = read();
lexState = 'zero';
return
@@ -26017,7 +31318,7 @@ const lexStates = {
case '7':
case '8':
case '9':
- buffer$2 = read();
+ buffer = read();
lexState = 'decimalInteger';
return
@@ -26038,19 +31339,19 @@ const lexStates = {
zero () {
switch (c) {
case '.':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalPoint';
return
case 'e':
case 'E':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponent';
return
case 'x':
case 'X':
- buffer$2 += read();
+ buffer += read();
lexState = 'hexadecimal';
return
}
@@ -26061,28 +31362,28 @@ const lexStates = {
decimalInteger () {
switch (c) {
case '.':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalPoint';
return
case 'e':
case 'E':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponent';
return
}
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
return
}
- return newToken('numeric', sign * Number(buffer$2))
+ return newToken('numeric', sign * Number(buffer))
},
decimalPointLeading () {
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalFraction';
return
}
@@ -26094,48 +31395,48 @@ const lexStates = {
switch (c) {
case 'e':
case 'E':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponent';
return
}
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalFraction';
return
}
- return newToken('numeric', sign * Number(buffer$2))
+ return newToken('numeric', sign * Number(buffer))
},
decimalFraction () {
switch (c) {
case 'e':
case 'E':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponent';
return
}
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
return
}
- return newToken('numeric', sign * Number(buffer$2))
+ return newToken('numeric', sign * Number(buffer))
},
decimalExponent () {
switch (c) {
case '+':
case '-':
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponentSign';
return
}
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponentInteger';
return
}
@@ -26145,7 +31446,7 @@ const lexStates = {
decimalExponentSign () {
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'decimalExponentInteger';
return
}
@@ -26155,16 +31456,16 @@ const lexStates = {
decimalExponentInteger () {
if (util.isDigit(c)) {
- buffer$2 += read();
+ buffer += read();
return
}
- return newToken('numeric', sign * Number(buffer$2))
+ return newToken('numeric', sign * Number(buffer))
},
hexadecimal () {
if (util.isHexDigit(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'hexadecimalInteger';
return
}
@@ -26174,36 +31475,36 @@ const lexStates = {
hexadecimalInteger () {
if (util.isHexDigit(c)) {
- buffer$2 += read();
+ buffer += read();
return
}
- return newToken('numeric', sign * Number(buffer$2))
+ return newToken('numeric', sign * Number(buffer))
},
string () {
switch (c) {
case '\\':
read();
- buffer$2 += escape();
+ buffer += escape();
return
case '"':
if (doubleQuote) {
read();
- return newToken('string', buffer$2)
+ return newToken('string', buffer)
}
- buffer$2 += read();
+ buffer += read();
return
case "'":
if (!doubleQuote) {
read();
- return newToken('string', buffer$2)
+ return newToken('string', buffer)
}
- buffer$2 += read();
+ buffer += read();
return
case '\n':
@@ -26219,7 +31520,7 @@ const lexStates = {
throw invalidChar(read())
}
- buffer$2 += read();
+ buffer += read();
},
start () {
@@ -26240,7 +31541,7 @@ const lexStates = {
switch (c) {
case '$':
case '_':
- buffer$2 = read();
+ buffer = read();
lexState = 'identifierName';
return
@@ -26260,7 +31561,7 @@ const lexStates = {
}
if (util.isIdStartChar(c)) {
- buffer$2 += read();
+ buffer += read();
lexState = 'identifierName';
return
}
@@ -26457,7 +31758,7 @@ const parseStates = {
throw invalidEOF()
}
- push();
+ push$1();
},
beforePropertyName () {
@@ -26503,7 +31804,7 @@ const parseStates = {
throw invalidEOF()
}
- push();
+ push$1();
},
beforeArrayValue () {
@@ -26516,7 +31817,7 @@ const parseStates = {
return
}
- push();
+ push$1();
},
afterPropertyValue () {
@@ -26573,7 +31874,7 @@ const parseStates = {
},
};
-function push () {
+function push$1 () {
let value;
switch (token.type) {
@@ -26722,7 +32023,7 @@ function syntaxError (message) {
return err
}
-var stringify$3 = function stringify (value, replacer, space) {
+var stringify = function stringify (value, replacer, space) {
const stack = [];
let indent = '';
let propertyList;
@@ -26983,221 +32284,258 @@ var stringify$3 = function stringify (value, replacer, space) {
};
const JSON5 = {
- parse: parse$4,
- stringify: stringify$3,
+ parse: parse$1,
+ stringify,
};
-var lib$3 = JSON5;
+var lib = JSON5;
-var dist$1 = /*#__PURE__*/Object.freeze({
- __proto__: null,
- 'default': lib$3
-});
+/**
+ * @typedef Option
+ * @property {'boolean'|'string'} [type='string']
+ * @property {string} long
+ * @property {string} description
+ * @property {string} [value]
+ * @property {string} [short]
+ * @property {boolean|string} [default='']
+ * @property {boolean} [truelike=false]
+ */
-var require$$3$1 = /*@__PURE__*/getAugmentedNamespace(dist$1);
-
-var require$$5$1 = [
- {
- 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: "ignore-path-resolve-from",
- description: "resolve patterns in `ignore-path` from its directory or cwd",
- type: "string",
- value: "dir|cwd",
- "default": "dir"
- },
- {
- long: "ignore-pattern",
- description: "specify ignore patterns",
- type: "string",
- value: "<globs>"
- },
- {
- long: "silently-ignore",
- description: "do not fail when given ignored files",
- type: "boolean"
- },
- {
- 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
- }
+/** @type {Option[]} */
+const schema = [
+ {
+ 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: 'ignore-path-resolve-from',
+ description: 'resolve patterns in `ignore-path` from its directory or cwd',
+ type: 'string',
+ value: 'dir|cwd',
+ default: 'dir'
+ },
+ {
+ long: 'ignore-pattern',
+ description: 'specify ignore patterns',
+ type: 'string',
+ value: '<globs>'
+ },
+ {
+ long: 'silently-ignore',
+ description: 'do not fail when given ignored files',
+ type: 'boolean'
+ },
+ {
+ 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 table = textTable;
-var camelcase = camelcase$1.exports;
-var minimist = minimist$1;
-var json5 = require$$3$1;
-var fault = fault_1;
-var schema$1 = require$$5$1;
+/**
+ * @typedef {import('unified-engine').Options} EngineOptions
+ * @typedef {import('./schema.js').Option} Option
+ *
+ * @typedef {Required<
+ * Pick<
+ * EngineOptions,
+ * | 'extensions'
+ * | 'ignoreName'
+ * | 'packageField'
+ * | 'pluginPrefix'
+ * | 'processor'
+ * | 'rcName'
+ * >
+ * >} RequiredEngineOptions
+ *
+ * @typedef ArgsOptionsFields
+ * @property {string} name
+ * Name of executable
+ * @property {string} description
+ * Description of executable
+ * @property {string} version
+ * Version (semver) of executable
+ *
+ * @typedef {RequiredEngineOptions & Pick<EngineOptions, 'cwd'> & ArgsOptionsFields} Options
+ */
-var options_1 = options$1;
+const own$7 = {}.hasOwnProperty;
-// Schema for `minimist`.
-var minischema = {
+/**
+ * Schema for `minimist`.
+ */
+const minischema = {
unknown: handleUnknownArgument,
+ /** @type {Record<string, string|boolean|null>} */
default: {},
+ /** @type {Record<string, string>} */
alias: {},
+ /** @type {string[]} */
string: [],
+ /** @type {string[]} */
boolean: []
};
-schema$1.forEach(addEach);
+let index = -1;
+while (++index < schema.length) {
+ addEach(schema[index]);
+}
-// Parse CLI options.
-function options$1(flags, configuration) {
- var extension = configuration.extensions[0];
- var name = configuration.name;
- var config = toCamelCase(minimist(flags, minischema));
- var help;
- var ext;
- var report;
+/**
+ * Parse CLI options.
+ *
+ * @param {string[]} flags
+ * @param {Options} configuration
+ */
+function options(flags, configuration) {
+ const extension = configuration.extensions[0];
+ const name = configuration.name;
+ const config = toCamelCase(minimist(flags, minischema));
+ let index = -1;
- schema$1.forEach(function (option) {
+ while (++index < schema.length) {
+ const option = schema[index];
if (option.type === 'string' && config[option.long] === '') {
throw fault('Missing value:%s', inspect(option).join(' '))
}
- });
-
- ext = commaSeparated(config.ext);
- report = reporter(config.report);
+ }
- help = [
- inspectAll(schema$1),
+ const ext = commaSeparated(/** @type {string} */ (config.ext));
+ const report = reporter(/** @type {string} */ (config.report));
+ const help = [
+ inspectAll(schema),
'',
'Examples:',
'',
@@ -27213,7 +32551,6 @@ function options$1(flags, configuration) {
return {
helpMessage: help,
- // “hidden” feature, makes testing easier.
cwd: configuration.cwd,
processor: configuration.processor,
help: config.help,
@@ -27232,15 +32569,19 @@ function options$1(flags, configuration) {
packageField: configuration.packageField,
rcPath: config.rcPath,
detectConfig: config.config,
- settings: settings(config.setting),
+ settings: /** @type {Record<string, unknown>} */ (
+ settings(/** @type {string} */ (config.setting))
+ ),
ignoreName: configuration.ignoreName,
ignorePath: config.ignorePath,
ignorePathResolveFrom: config.ignorePathResolveFrom,
- ignorePatterns: commaSeparated(config.ignorePattern),
+ ignorePatterns: commaSeparated(
+ /** @type {string} */ (config.ignorePattern)
+ ),
silentlyIgnore: config.silentlyIgnore,
detectIgnore: config.ignore,
pluginPrefix: configuration.pluginPrefix,
- plugins: plugins(config.use),
+ plugins: plugins$2(/** @type {string} */ (config.use)),
reporter: report[0],
reporterOptions: report[1],
color: config.color,
@@ -27250,12 +32591,15 @@ function options$1(flags, configuration) {
}
}
+/**
+ * @param {Option} option
+ */
function addEach(option) {
- var value = option.default;
+ const value = option.default;
minischema.default[option.long] = value === undefined ? null : value;
- if (option.type in minischema) {
+ if (option.type && option.type in minischema) {
minischema[option.type].push(option.long);
}
@@ -27264,116 +32608,165 @@ function addEach(option) {
}
}
-// Parse `extensions`.
+/**
+ * Parse `extensions`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {string[]}
+ */
function commaSeparated(value) {
- return flatten(normalize(value).map(splitList))
+ return flatten(normalize(value).map((d) => splitList(d)))
}
-// Parse `plugins`.
-function plugins(value) {
- var result = {};
+/**
+ * Parse `plugins`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {Record<string, Record<string, unknown>|undefined>}
+ */
+function plugins$2(value) {
+ const normalized = normalize(value).map((d) => splitOptions(d));
+ let index = -1;
+ /** @type {Record<string, Record<string, unknown>|undefined>} */
+ const result = {};
- normalize(value)
- .map(splitOptions)
- .forEach(function (value) {
- result[value[0]] = value[1] ? parseConfig(value[1], {}) : null;
- });
+ while (++index < normalized.length) {
+ const value = normalized[index];
+ result[value[0]] = value[1] ? parseConfig(value[1], {}) : undefined;
+ }
return result
}
-// Parse `reporter`: only one is accepted.
+/**
+ * Parse `reporter`: only one is accepted.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {[string|undefined, Record<string, unknown>|undefined]}
+ */
function reporter(value) {
- var all = normalize(value)
- .map(splitOptions)
- .map(function (value) {
- return [value[0], value[1] ? parseConfig(value[1], {}) : null]
- });
+ const all = normalize(value)
+ .map((d) => splitOptions(d))
+ .map(
+ /**
+ * @returns {[string, Record<string, unknown>|undefined]}
+ */
+ (value) => [value[0], value[1] ? parseConfig(value[1], {}) : undefined]
+ );
return all[all.length - 1] || []
}
-// Parse `settings`.
+/**
+ * Parse `settings`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {Record<string, unknown>}
+ */
function settings(value) {
- var cache = {};
+ const normalized = normalize(value);
+ let index = -1;
+ /** @type {Record<string, unknown>} */
+ const cache = {};
- normalize(value).forEach(function (value) {
- parseConfig(value, cache);
- });
+ while (++index < normalized.length) {
+ parseConfig(normalized[index], cache);
+ }
return cache
}
-// Parse configuration.
-function parseConfig(flags, cache) {
- var flag;
- var message;
+/**
+ * Parse configuration.
+ *
+ * @param {string} value
+ * @param {Record<string, unknown>} cache
+ * @returns {Record<string, unknown>}
+ */
+function parseConfig(value, cache) {
+ /** @type {Record<string, unknown>} */
+ let flags;
+ /** @type {string} */
+ let flag;
try {
- flags = toCamelCase(parseJSON(flags));
+ flags = toCamelCase(parseJSON(value));
} catch (error) {
- // Fix position
- message = error.message.replace(/at(?= position)/, 'around');
-
- throw fault('Cannot parse `%s` as JSON: %s', flags, message)
+ throw fault(
+ 'Cannot parse `%s` as JSON: %s',
+ value,
+ // Fix position
+ error.message.replace(/at(?= position)/, 'around')
+ )
}
for (flag in flags) {
- cache[flag] = flags[flag];
+ if (own$7.call(flags, flag)) {
+ cache[flag] = flags[flag];
+ }
}
return cache
}
-// Handle an unknown flag.
+/**
+ * Handle an unknown flag.
+ *
+ * @param {string} flag
+ * @returns {boolean}
+ */
function handleUnknownArgument(flag) {
- // Glob.
- if (flag.charAt(0) !== '-') {
- return
- }
-
- // Long options, always unknown.
- if (flag.charAt(1) === '-') {
- throw fault('Unknown option `%s`, expected:\n%s', flag, inspectAll(schema$1))
- }
-
- // Short options, can be grouped.
- flag.slice(1).split('').forEach(each);
-
- function each(key) {
- var length = schema$1.length;
- var index = -1;
- var option;
+ // Not a glob.
+ if (flag.charAt(0) === '-') {
+ // Long options, always unknown.
+ if (flag.charAt(1) === '-') {
+ throw fault(
+ 'Unknown option `%s`, expected:\n%s',
+ flag,
+ inspectAll(schema)
+ )
+ }
- while (++index < length) {
- option = schema$1[index];
+ // Short options, can be grouped.
+ const found = flag.slice(1).split('');
+ const known = schema.filter((d) => d.short);
+ const knownKeys = new Set(known.map((d) => d.short));
+ let index = -1;
- if (option.short === key) {
- return
+ while (++index < found.length) {
+ const key = found[index];
+ if (!knownKeys.has(key)) {
+ throw fault(
+ 'Unknown short option `-%s`, expected:\n%s',
+ key,
+ inspectAll(known)
+ )
}
}
-
- throw fault(
- 'Unknown short option `-%s`, expected:\n%s',
- key,
- inspectAll(schema$1.filter(short))
- )
}
- function short(option) {
- return option.short
- }
+ return true
}
-// Inspect all `options`.
+/**
+ * Inspect all `options`.
+ *
+ * @param {Option[]} options
+ * @returns {string}
+ */
function inspectAll(options) {
- return table(options.map(inspect))
+ return textTable(options.map((d) => inspect(d)))
}
-// Inspect one `option`.
+/**
+ * Inspect one `option`.
+ *
+ * @param {Option} option
+ * @returns {string[]}
+ */
function inspect(option) {
- var description = option.description;
- var long = option.long;
+ let description = option.description;
+ let long = option.long;
if (option.default === true || option.truelike) {
description += ' (on by default)';
@@ -27388,7 +32781,12 @@ function inspect(option) {
]
}
-// Normalize `value`.
+/**
+ * Normalize `value`.
+ *
+ * @param {string[]|string|null|undefined} value
+ * @returns {string[]}
+ */
function normalize(value) {
if (!value) {
return []
@@ -27398,82 +32796,114 @@ function normalize(value) {
return [value]
}
- return flatten(value.map(normalize))
+ return flatten(value.map((d) => normalize(d)))
}
-// Flatten `values`.
+/**
+ * Flatten `values`.
+ *
+ * @param {string|string[]|string[][]} values
+ * @returns {string[]}
+ */
function flatten(values) {
- return [].concat.apply([], values)
+ // @ts-expect-error: TS is wrong.
+ return values.flat()
}
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
function splitOptions(value) {
return value.split('=')
}
+/**
+ * @param {string} value
+ * @returns {string[]}
+ */
function splitList(value) {
return value.split(',')
}
-// Transform the keys on an object to camel-case, recursivly.
+/**
+ * Transform the keys on an object to camel-case, recursivly.
+ *
+ * @param {Record<string, unknown>} object
+ * @returns {Record<string, unknown>}
+ */
function toCamelCase(object) {
- var result = {};
- var value;
- var key;
+ /** @type {Record<string, unknown>} */
+ const result = {};
+ /** @type {string} */
+ let key;
for (key in object) {
- value = object[key];
+ if (own$7.call(object, key)) {
+ let value = object[key];
- if (value && typeof value === 'object' && !('length' in value)) {
- value = toCamelCase(value);
- }
+ if (value && typeof value === 'object' && !Array.isArray(value)) {
+ // @ts-expect-error: looks like an object.
+ value = toCamelCase(value);
+ }
- result[camelcase(key)] = value;
+ result[camelcase(key)] = value;
+ }
}
return result
}
-// Parse a (lazy?) JSON config.
+/**
+ * Parse a (lazy?) JSON config.
+ *
+ * @param {string} value
+ * @returns {Record<string, unknown>}
+ */
function parseJSON(value) {
- return json5.parse('{' + value + '}')
+ return lib.parse('{' + value + '}')
}
-var stream = require$$0__default$5['default'];
-var engine = lib$4;
-var chalk = source$1;
-var chokidar = chokidar$1;
-var options = options_1;
-
-var lib$2 = start$3;
-
-var noop$2 = Function.prototype;
+/**
+ * @typedef {import('unified-engine').Options} EngineOptions
+ * @typedef {import('unified-engine').Context} EngineContext
+ * @typedef {import('unified-engine').Callback} EngineCallback
+ * @typedef {import('./options.js').Options} Options
+ */
// Fake TTY stream.
-var ttyStream = new stream.Readable();
-ttyStream.isTTY = true;
+const ttyStream = Object.assign(new stream.Readable(), {isTTY: true});
// Exit, lazily, with the correct exit status code.
-var exitStatus = 0;
+let exitStatus = 0;
-process.on('exit', onexit);
+process$2.on('exit', onexit);
// Handle uncaught errors, such as from unexpected async behaviour.
-process.on('uncaughtException', fail$1);
+process$2.on('uncaughtException', fail);
-// Start the CLI.
-function start$3(cliConfig) {
- var config;
- var output;
- var watcher;
+/**
+ * Start the CLI.
+ *
+ * @param {Options} cliConfig
+ */
+function args(cliConfig) {
+ /** @type {EngineOptions & {help: boolean, helpMessage: string, watch: boolean, version: boolean}} */
+ let config;
+ /** @type {chokidar.FSWatcher|undefined} */
+ let watcher;
+ /** @type {boolean|string|undefined} */
+ let output;
try {
- config = options(process.argv.slice(2), cliConfig);
+ // @ts-expect-error: Close enough.
+ config = options(process$2.argv.slice(2), cliConfig);
} catch (error) {
- return fail$1(error, true)
+ return fail(error, true)
}
if (config.help) {
- process.stdout.write(
+ process$2.stdout.write(
[
'Usage: ' + cliConfig.name + ' [options] [path | glob ...]',
'',
@@ -27484,14 +32914,14 @@ function start$3(cliConfig) {
config.helpMessage,
''
].join('\n'),
- noop$2
+ noop$1
);
return
}
if (config.version) {
- process.stdout.write(cliConfig.version + '\n', noop$2);
+ process$2.stdout.write(cliConfig.version + '\n', noop$1);
return
}
@@ -27506,18 +32936,18 @@ function start$3(cliConfig) {
// Do not write to stdout(4).
config.out = false;
- process.stderr.write(
- chalk.bold('Watching...') + ' (press CTRL+C to exit)\n',
- noop$2
+ process$2.stderr.write(
+ source$1.bold('Watching...') + ' (press CTRL+C to exit)\n',
+ noop$1
);
// Prevent infinite loop if set to regeneration.
if (output === true) {
config.output = false;
- process.stderr.write(
- chalk.yellow('Note') + ': Ignoring `--output` until exit.\n',
- noop$2
+ process$2.stderr.write(
+ source$1.yellow('Note') + ': Ignoring `--output` until exit.\n',
+ noop$1
);
}
}
@@ -27525,15 +32955,19 @@ function start$3(cliConfig) {
// Initial run.
engine(config, done);
- // Handle complete run.
- function done(err, code, context) {
- if (err) {
+ /**
+ * Handle complete run.
+ *
+ * @type {EngineCallback}
+ */
+ function done(error, code, context) {
+ if (error) {
clean();
- fail$1(err);
+ fail(error);
} else {
- exitStatus = code;
+ exitStatus = code || 0;
- if (config.watch && !watcher) {
+ if (config.watch && !watcher && context) {
subscribe(context);
}
}
@@ -27543,28 +32977,33 @@ function start$3(cliConfig) {
function clean() {
if (watcher) {
watcher.close();
- watcher = null;
+ watcher = undefined;
}
}
- // Subscribe a chokidar watcher to all processed files.
+ /**
+ * Subscribe a chokidar watcher to all processed files.
+ *
+ * @param {EngineContext} context
+ */
function subscribe(context) {
watcher = chokidar
+ // @ts-expect-error: `fileSet` is available.
.watch(context.fileSet.origins, {cwd: config.cwd, ignoreInitial: true})
.on('error', done)
- .on('change', onchange);
-
- process.on('SIGINT', onsigint);
-
- function onchange(filePath) {
- config.files = [filePath];
+ .on('change', (filePath) => {
+ config.files = [filePath];
+ engine(config, done);
+ });
- engine(config, done);
- }
+ process$2.on('SIGINT', onsigint);
+ /**
+ * Handle a SIGINT.
+ */
function onsigint() {
// Hide the `^C` in terminal.
- process.stderr.write('\n', noop$2);
+ process$2.stderr.write('\n', noop$1);
clean();
@@ -27578,26 +33017,31 @@ function start$3(cliConfig) {
}
}
-// Print an error, optionally with stack.
-function fail$1(err, pretty) {
- var message =
- (pretty ? String(err).trim() : err.stack) ||
- /* istanbul ignore next - Old versions of Node */ err;
+/**
+ * Print an error, optionally with stack.
+ *
+ * @param {Error} error
+ * @param {boolean} [pretty=false]
+ */
+function fail(error, pretty) {
+ // Old versions of Node
+ /* c8 ignore next 1 */
+ const message = String((pretty ? error : error.stack) || error);
exitStatus = 1;
- process.stderr.write(message.trim() + '\n', noop$2);
+ process$2.stderr.write(message.trim() + '\n', noop$1);
}
function onexit() {
/* eslint-disable unicorn/no-process-exit */
- process.exit(exitStatus);
+ process$2.exit(exitStatus);
/* eslint-enable unicorn/no-process-exit */
}
-var unifiedArgs = lib$2;
+function noop$1() {}
-var require$$0$3 = [
+var require$$0 = [
"md",
"markdown",
"mdown",
@@ -27608,13 +33052,16 @@ var require$$0$3 = [
"ron"
];
-var markdownExtensions = require$$0$3;
-
-var bail_1 = bail$1;
+var markdownExtensions = require$$0;
-function bail$1(err) {
- if (err) {
- throw err
+/**
+ * Throw a given error.
+ *
+ * @param {Error | null | undefined} [error]
+ */
+function bail(error) {
+ if (error) {
+ throw error
}
}
@@ -27680,7 +33127,7 @@ var getProperty = function getProperty(obj, name) {
return obj[name];
};
-var extend$2 = function extend() {
+var extend = function extend() {
var options, name, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
@@ -27734,396 +33181,66 @@ var extend$2 = function extend() {
return target;
};
-var stringify$2 = unistUtilStringifyPosition;
-
-var vfileMessage = VMessage$1;
-
-// Inherit from `Error#`.
-function VMessagePrototype() {}
-VMessagePrototype.prototype = Error.prototype;
-VMessage$1.prototype = new VMessagePrototype();
-
-// Message properties.
-var proto = VMessage$1.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$1(reason, position, origin) {
- var parts;
- var range;
- var location;
-
- if (typeof position === 'string') {
- origin = position;
- position = null;
- }
-
- parts = parseOrigin(origin);
- range = stringify$2(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
-}
-
-var minpath = require$$0__default$2['default'];
-
-var minproc = process;
-
-var p = minpath;
-var proc$1 = minproc;
-var buffer$1 = isBuffer;
-
-var core$1 = VFile$1;
-
-var own$c = {}.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$3 = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
-
-VFile$1.prototype.toString = toString$6;
-
-// Access full path (`~/index.min.js`).
-Object.defineProperty(VFile$1.prototype, 'path', {get: getPath, set: setPath});
-
-// Access parent path (`~`).
-Object.defineProperty(VFile$1.prototype, 'dirname', {
- get: getDirname,
- set: setDirname
-});
-
-// Access basename (`index.min.js`).
-Object.defineProperty(VFile$1.prototype, 'basename', {
- get: getBasename,
- set: setBasename
-});
-
-// Access extname (`.js`).
-Object.defineProperty(VFile$1.prototype, 'extname', {
- get: getExtname,
- set: setExtname
-});
-
-// Access stem (`index.min`).
-Object.defineProperty(VFile$1.prototype, 'stem', {get: getStem, set: setStem});
-
-// Construct a new file.
-function VFile$1(options) {
- var prop;
- var index;
-
- if (!options) {
- options = {};
- } else if (typeof options === 'string' || buffer$1(options)) {
- options = {contents: options};
- } else if ('message' in options && 'messages' in options) {
- return options
- }
-
- if (!(this instanceof VFile$1)) {
- return new VFile$1(options)
- }
-
- this.data = {};
- this.messages = [];
- this.history = [];
- this.cwd = proc$1.cwd();
-
- // Set path related properties in the correct order.
- index = -1;
-
- while (++index < order$3.length) {
- prop = order$3[index];
-
- if (own$c.call(options, prop)) {
- this[prop] = options[prop];
- }
- }
-
- // Set non-path related properties.
- for (prop in options) {
- if (order$3.indexOf(prop) < 0) {
- this[prop] = options[prop];
- }
- }
-}
-
-function getPath() {
- return this.history[this.history.length - 1]
-}
-
-function setPath(path) {
- assertNonEmpty(path, 'path');
-
- if (this.path !== path) {
- this.history.push(path);
- }
-}
-
-function getDirname() {
- return typeof this.path === 'string' ? p.dirname(this.path) : undefined
-}
-
-function setDirname(dirname) {
- assertPath(this.path, 'dirname');
- this.path = p.join(dirname || '', this.basename);
-}
-
-function getBasename() {
- return typeof this.path === 'string' ? p.basename(this.path) : undefined
-}
-
-function setBasename(basename) {
- assertNonEmpty(basename, 'basename');
- assertPart(basename, 'basename');
- this.path = p.join(this.dirname || '', basename);
-}
-
-function getExtname() {
- return typeof this.path === 'string' ? p.extname(this.path) : undefined
-}
-
-function setExtname(extname) {
- assertPart(extname, 'extname');
- assertPath(this.path, 'extname');
-
- if (extname) {
- if (extname.charCodeAt(0) !== 46 /* `.` */) {
- throw new Error('`extname` must start with `.`')
- }
-
- if (extname.indexOf('.', 1) > -1) {
- throw new Error('`extname` cannot contain multiple dots')
- }
- }
-
- this.path = p.join(this.dirname, this.stem + (extname || ''));
-}
-
-function getStem() {
- return typeof this.path === 'string'
- ? p.basename(this.path, this.extname)
- : undefined
-}
-
-function setStem(stem) {
- assertNonEmpty(stem, 'stem');
- assertPart(stem, 'stem');
- this.path = p.join(this.dirname || '', stem + (this.extname || ''));
-}
-
-// Get the value of the file.
-function toString$6(encoding) {
- return (this.contents || '').toString(encoding)
-}
-
-// Assert that `part` is not a path (i.e., does not contain `p.sep`).
-function assertPart(part, name) {
- if (part && part.indexOf(p.sep) > -1) {
- throw new Error(
- '`' + name + '` cannot be a path: did not expect `' + p.sep + '`'
- )
- }
-}
-
-// Assert that `part` is not empty.
-function assertNonEmpty(part, name) {
- if (!part) {
- throw new Error('`' + name + '` cannot be empty')
- }
-}
-
-// Assert `path` exists.
-function assertPath(path, name) {
- if (!path) {
- throw new Error('Setting `' + name + '` requires `path` to be set too')
- }
-}
-
-var VMessage = vfileMessage;
-var VFile = core$1;
-
-var lib$1 = VFile;
-
-VFile.prototype.message = message;
-VFile.prototype.info = info;
-VFile.prototype.fail = fail;
-
-// Create a message with `reason` at `position`.
-// When an error is passed in as `reason`, copies the stack.
-function message(reason, position, origin) {
- var message = new VMessage(reason, position, origin);
-
- if (this.path) {
- message.name = this.path + ':' + message.name;
- message.file = this.path;
- }
-
- message.fatal = false;
-
- this.messages.push(message);
-
- return message
-}
-
-// Fail: creates a vmessage, associates it with the file, and throws it.
-function fail() {
- var message = this.message.apply(this, arguments);
-
- message.fatal = true;
-
- throw message
-}
-
-// Info: creates a vmessage, associates it with the file, and marks the fatality
-// as null.
-function info() {
- var message = this.message.apply(this, arguments);
-
- message.fatal = null;
-
- return message
-}
-
-var vfile$1 = lib$1;
-
-var bail = bail_1;
-var buffer = isBuffer;
-var extend$1 = extend$2;
-var plain = isPlainObj;
-var trough = trough_1;
-var vfile = vfile$1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFileCompatible} VFileCompatible
+ * @typedef {import('vfile').VFileValue} VFileValue
+ * @typedef {import('..').Processor} Processor
+ * @typedef {import('..').Plugin} Plugin
+ * @typedef {import('..').Preset} Preset
+ * @typedef {import('..').Pluggable} Pluggable
+ * @typedef {import('..').PluggableList} PluggableList
+ * @typedef {import('..').Transformer} Transformer
+ * @typedef {import('..').Parser} Parser
+ * @typedef {import('..').Compiler} Compiler
+ * @typedef {import('..').RunCallback} RunCallback
+ * @typedef {import('..').ProcessCallback} ProcessCallback
+ *
+ * @typedef Context
+ * @property {Node} tree
+ * @property {VFile} file
+ */
// Expose a frozen processor.
-var unified_1 = unified$1().freeze();
-
-var slice$1 = [].slice;
-var own$b = {}.hasOwnProperty;
-
-// Process pipeline.
-var pipeline = trough()
- .use(pipelineParse)
- .use(pipelineRun)
- .use(pipelineStringify);
+const unified = base().freeze();
-function pipelineParse(p, ctx) {
- ctx.tree = p.parse(ctx.file);
-}
-
-function pipelineRun(p, ctx, next) {
- p.run(ctx.tree, ctx.file, done);
-
- function done(error, tree, file) {
- if (error) {
- next(error);
- } else {
- ctx.tree = tree;
- ctx.file = file;
- next();
- }
- }
-}
-
-function pipelineStringify(p, ctx) {
- var result = p.stringify(ctx.tree, ctx.file);
-
- if (result === undefined || result === null) ; else if (typeof result === 'string' || buffer(result)) {
- if ('value' in ctx.file) {
- ctx.file.value = result;
- }
-
- ctx.file.contents = result;
- } else {
- ctx.file.result = result;
- }
-}
+const own$6 = {}.hasOwnProperty;
// Function to create the first processor.
-function unified$1() {
- var attachers = [];
- var transformers = trough();
- var namespace = {};
- var freezeIndex = -1;
- var frozen;
+/**
+ * @returns {Processor}
+ */
+function base() {
+ const transformers = trough();
+ /** @type {Processor['attachers']} */
+ const attachers = [];
+ /** @type {Record<string, unknown>} */
+ let namespace = {};
+ /** @type {boolean|undefined} */
+ let frozen;
+ let freezeIndex = -1;
// Data management.
+ // @ts-expect-error: overloads are handled.
processor.data = data;
+ processor.Parser = undefined;
+ processor.Compiler = undefined;
// Lock.
processor.freeze = freeze;
// Plugins.
processor.attachers = attachers;
+ // @ts-expect-error: overloads are handled.
processor.use = use;
// API.
processor.parse = parse;
processor.stringify = stringify;
+ // @ts-expect-error: overloads are handled.
processor.run = run;
processor.runSync = runSync;
+ // @ts-expect-error: overloads are handled.
processor.process = process;
processor.processSync = processSync;
@@ -28131,60 +33248,25 @@ function unified$1() {
return processor
// Create a new processor based on the processor in the current scope.
+ /** @type {Processor} */
function processor() {
- var destination = unified$1();
- var index = -1;
+ const destination = base();
+ let index = -1;
while (++index < attachers.length) {
- destination.use.apply(null, attachers[index]);
+ destination.use(...attachers[index]);
}
- destination.data(extend$1(true, {}, namespace));
+ destination.data(extend(true, {}, namespace));
return destination
}
- // Freeze: used to signal a processor that has finished configuration.
- //
- // For example, take unified itself: it’s frozen.
- // Plugins should not be added to it.
- // Rather, it should be extended, by invoking it, before modifying it.
- //
- // In essence, always invoke this when exporting a processor.
- function freeze() {
- var values;
- var transformer;
-
- if (frozen) {
- return processor
- }
-
- while (++freezeIndex < attachers.length) {
- values = attachers[freezeIndex];
-
- if (values[1] === false) {
- continue
- }
-
- if (values[1] === true) {
- values[1] = undefined;
- }
-
- transformer = values[0].apply(processor, values.slice(1));
-
- if (typeof transformer === 'function') {
- transformers.use(transformer);
- }
- }
-
- frozen = true;
- freezeIndex = Infinity;
-
- return processor
- }
-
- // Data management.
- // Getter / setter for processor-specific informtion.
+ /**
+ * @param {string|Record<string, unknown>} [key]
+ * @param {unknown} [value]
+ * @returns {unknown}
+ */
function data(key, value) {
if (typeof key === 'string') {
// Set `key`.
@@ -28195,7 +33277,7 @@ function unified$1() {
}
// Get `key`.
- return (own$b.call(namespace, key) && namespace[key]) || null
+ return (own$6.call(namespace, key) && namespace[key]) || null
}
// Set space.
@@ -28209,132 +33291,213 @@ function unified$1() {
return namespace
}
- // Plugin management.
- //
- // Pass it:
- // * an attacher and options,
- // * a preset,
- // * a list of presets, attachers, and arguments (list of attachers and
- // options).
- function use(value) {
- var settings;
+ /** @type {Processor['freeze']} */
+ function freeze() {
+ if (frozen) {
+ return processor
+ }
+
+ while (++freezeIndex < attachers.length) {
+ const [attacher, ...options] = attachers[freezeIndex];
+
+ if (options[0] === false) {
+ continue
+ }
+
+ if (options[0] === true) {
+ options[1] = undefined;
+ }
+
+ /** @type {Transformer|void} */
+ const transformer = attacher.call(processor, ...options);
+
+ if (typeof transformer === 'function') {
+ transformers.use(transformer);
+ }
+ }
+
+ frozen = true;
+ freezeIndex = Number.POSITIVE_INFINITY;
+
+ return processor
+ }
+
+ /**
+ * @param {Pluggable|null|undefined} [value]
+ * @param {...unknown} options
+ * @returns {Processor}
+ */
+ function use(value, ...options) {
+ /** @type {Record<string, unknown>|undefined} */
+ let settings;
assertUnfrozen('use', frozen);
if (value === null || value === undefined) ; else if (typeof value === 'function') {
- addPlugin.apply(null, arguments);
+ addPlugin(value, ...options);
} else if (typeof value === 'object') {
- if ('length' in value) {
+ if (Array.isArray(value)) {
addList(value);
} else {
addPreset(value);
}
} else {
- throw new Error('Expected usable value, not `' + value + '`')
+ throw new TypeError('Expected usable value, not `' + value + '`')
}
if (settings) {
- namespace.settings = extend$1(namespace.settings || {}, settings);
+ namespace.settings = Object.assign(namespace.settings || {}, settings);
}
return processor
- function addPreset(result) {
- addList(result.plugins);
-
- if (result.settings) {
- settings = extend$1(settings || {}, result.settings);
- }
- }
-
+ /**
+ * @param {import('..').Pluggable<unknown[]>} value
+ * @returns {void}
+ */
function add(value) {
if (typeof value === 'function') {
addPlugin(value);
} else if (typeof value === 'object') {
- if ('length' in value) {
- addPlugin.apply(null, value);
+ if (Array.isArray(value)) {
+ const [plugin, ...options] = value;
+ addPlugin(plugin, ...options);
} else {
addPreset(value);
}
} else {
- throw new Error('Expected usable value, not `' + value + '`')
+ throw new TypeError('Expected usable value, not `' + value + '`')
}
}
+ /**
+ * @param {Preset} result
+ * @returns {void}
+ */
+ function addPreset(result) {
+ addList(result.plugins);
+
+ if (result.settings) {
+ settings = Object.assign(settings || {}, result.settings);
+ }
+ }
+
+ /**
+ * @param {PluggableList|null|undefined} [plugins]
+ * @returns {void}
+ */
function addList(plugins) {
- var index = -1;
+ let index = -1;
- if (plugins === null || plugins === undefined) ; else if (typeof plugins === 'object' && 'length' in plugins) {
+ if (plugins === null || plugins === undefined) ; else if (Array.isArray(plugins)) {
while (++index < plugins.length) {
- add(plugins[index]);
+ const thing = plugins[index];
+ add(thing);
}
} else {
- throw new Error('Expected a list of plugins, not `' + plugins + '`')
+ throw new TypeError('Expected a list of plugins, not `' + plugins + '`')
}
}
+ /**
+ * @param {Plugin} plugin
+ * @param {...unknown} [value]
+ * @returns {void}
+ */
function addPlugin(plugin, value) {
- var entry = find(plugin);
+ let index = -1;
+ /** @type {Processor['attachers'][number]|undefined} */
+ let entry;
+
+ while (++index < attachers.length) {
+ if (attachers[index][0] === plugin) {
+ entry = attachers[index];
+ break
+ }
+ }
if (entry) {
- if (plain(entry[1]) && plain(value)) {
- value = extend$1(true, entry[1], value);
+ if (isPlainObject$1(entry[1]) && isPlainObject$1(value)) {
+ value = extend(true, entry[1], value);
}
entry[1] = value;
} else {
- attachers.push(slice$1.call(arguments));
- }
- }
- }
-
- function find(plugin) {
- var index = -1;
-
- while (++index < attachers.length) {
- if (attachers[index][0] === plugin) {
- return attachers[index]
+ // @ts-expect-error: fine.
+ attachers.push([...arguments]);
}
}
}
- // Parse a file (in string or vfile representation) into a unist node using
- // the `Parser` on the processor.
+ /** @type {Processor['parse']} */
function parse(doc) {
- var file = vfile(doc);
- var Parser;
-
- freeze();
- Parser = processor.Parser;
+ processor.freeze();
+ const file = vfile(doc);
+ const Parser = processor.Parser;
assertParser('parse', Parser);
if (newable(Parser, 'parse')) {
+ // @ts-expect-error: `newable` checks this.
return new Parser(String(file), file).parse()
}
+ // @ts-expect-error: `newable` checks this.
return Parser(String(file), file) // eslint-disable-line new-cap
}
- // Run transforms on a unist node representation of a file (in string or
- // vfile representation), async.
- function run(node, file, cb) {
+ /** @type {Processor['stringify']} */
+ function stringify(node, doc) {
+ processor.freeze();
+ const file = vfile(doc);
+ const Compiler = processor.Compiler;
+ assertCompiler('stringify', Compiler);
+ assertNode(node);
+
+ if (newable(Compiler, 'compile')) {
+ // @ts-expect-error: `newable` checks this.
+ return new Compiler(node, file).compile()
+ }
+
+ // @ts-expect-error: `newable` checks this.
+ return Compiler(node, file) // eslint-disable-line new-cap
+ }
+
+ /**
+ * @param {Node} node
+ * @param {VFileCompatible|RunCallback} [doc]
+ * @param {RunCallback} [callback]
+ * @returns {Promise<Node>|void}
+ */
+ function run(node, doc, callback) {
assertNode(node);
- freeze();
+ processor.freeze();
- if (!cb && typeof file === 'function') {
- cb = file;
- file = null;
+ if (!callback && typeof doc === 'function') {
+ callback = doc;
+ doc = undefined;
}
- if (!cb) {
+ if (!callback) {
return new Promise(executor)
}
- executor(null, cb);
+ executor(null, callback);
+ /**
+ * @param {null|((node: Node) => void)} resolve
+ * @param {(error: Error) => void} reject
+ * @returns {void}
+ */
function executor(resolve, reject) {
- transformers.run(node, vfile(file), done);
+ // @ts-expect-error: `doc` can’t be a callback anymore, we checked.
+ transformers.run(node, vfile(doc), done);
+ /**
+ * @param {Error|null} error
+ * @param {Node} tree
+ * @param {VFile} file
+ * @returns {void}
+ */
function done(error, tree, file) {
tree = tree || node;
if (error) {
@@ -28342,97 +33505,119 @@ function unified$1() {
} else if (resolve) {
resolve(tree);
} else {
- cb(null, tree, file);
+ // @ts-expect-error: `callback` is defined if `resolve` is not.
+ callback(null, tree, file);
}
}
}
}
- // Run transforms on a unist node representation of a file (in string or
- // vfile representation), sync.
+ /** @type {Processor['runSync']} */
function runSync(node, file) {
- var result;
- var complete;
+ /** @type {Node|undefined} */
+ let result;
+ /** @type {boolean|undefined} */
+ let complete;
- run(node, file, done);
+ processor.run(node, file, done);
assertDone('runSync', 'run', complete);
+ // @ts-expect-error: we either bailed on an error or have a tree.
return result
+ /**
+ * @param {Error|null} [error]
+ * @param {Node} [tree]
+ * @returns {void}
+ */
function done(error, tree) {
- complete = true;
- result = tree;
bail(error);
+ result = tree;
+ complete = true;
}
}
- // Stringify a unist node representation of a file (in string or vfile
- // representation) into a string using the `Compiler` on the processor.
- function stringify(node, doc) {
- var file = vfile(doc);
- var Compiler;
-
- freeze();
- Compiler = processor.Compiler;
- assertCompiler('stringify', Compiler);
- assertNode(node);
-
- if (newable(Compiler, 'compile')) {
- return new Compiler(node, file).compile()
- }
-
- return Compiler(node, file) // eslint-disable-line new-cap
- }
-
- // Parse a file (in string or vfile representation) into a unist node using
- // the `Parser` on the processor, then run transforms on that node, and
- // compile the resulting node using the `Compiler` on the processor, and
- // store that result on the vfile.
- function process(doc, cb) {
- freeze();
+ /**
+ * @param {VFileCompatible} doc
+ * @param {ProcessCallback} [callback]
+ * @returns {Promise<VFile>|undefined}
+ */
+ function process(doc, callback) {
+ processor.freeze();
assertParser('process', processor.Parser);
assertCompiler('process', processor.Compiler);
- if (!cb) {
+ if (!callback) {
return new Promise(executor)
}
- executor(null, cb);
+ executor(null, callback);
+ /**
+ * @param {null|((file: VFile) => void)} resolve
+ * @param {(error?: Error|null|undefined) => void} reject
+ * @returns {void}
+ */
function executor(resolve, reject) {
- var file = vfile(doc);
+ const file = vfile(doc);
- pipeline.run(processor, {file: file}, done);
+ processor.run(processor.parse(file), file, (error, tree, file) => {
+ if (error || !tree || !file) {
+ done(error);
+ } else {
+ /** @type {unknown} */
+ const result = processor.stringify(tree, file);
- function done(error) {
- if (error) {
+ if (result === undefined || result === null) ; else if (looksLikeAVFileValue(result)) {
+ file.value = result;
+ } else {
+ file.result = result;
+ }
+
+ done(error, file);
+ }
+ });
+
+ /**
+ * @param {Error|null|undefined} [error]
+ * @param {VFile|undefined} [file]
+ * @returns {void}
+ */
+ function done(error, file) {
+ if (error || !file) {
reject(error);
} else if (resolve) {
resolve(file);
} else {
- cb(null, file);
+ // @ts-expect-error: `callback` is defined if `resolve` is not.
+ callback(null, file);
}
}
}
}
- // Process the given document (in string or vfile representation), sync.
+ /** @type {Processor['processSync']} */
function processSync(doc) {
- var file;
- var complete;
+ /** @type {boolean|undefined} */
+ let complete;
- freeze();
+ processor.freeze();
assertParser('processSync', processor.Parser);
assertCompiler('processSync', processor.Compiler);
- file = vfile(doc);
- process(file, done);
+ const file = vfile(doc);
+
+ processor.process(file, done);
assertDone('processSync', 'process', complete);
return file
+ /**
+ * @param {Error|null|undefined} [error]
+ * @returns {void}
+ */
function done(error) {
complete = true;
bail(error);
@@ -28440,61 +33625,112 @@ function unified$1() {
}
}
-// Check if `value` is a constructor.
+/**
+ * Check if `value` is a constructor.
+ *
+ * @param {unknown} value
+ * @param {string} name
+ * @returns {boolean}
+ */
function newable(value, name) {
return (
typeof value === 'function' &&
+ // Prototypes do exist.
+ // type-coverage:ignore-next-line
value.prototype &&
// A function with keys in its prototype is probably a constructor.
// Classes’ prototype methods are not enumerable, so we check if some value
// exists in the prototype.
+ // type-coverage:ignore-next-line
(keys(value.prototype) || name in value.prototype)
)
}
-// Check if `value` is an object with keys.
+/**
+ * Check if `value` is an object with keys.
+ *
+ * @param {Record<string, unknown>} value
+ * @returns {boolean}
+ */
function keys(value) {
- var key;
+ /** @type {string} */
+ let key;
+
for (key in value) {
- return true
+ if (own$6.call(value, key)) {
+ return true
+ }
}
return false
}
-// Assert a parser is available.
-function assertParser(name, Parser) {
- if (typeof Parser !== 'function') {
- throw new Error('Cannot `' + name + '` without `Parser`')
+/**
+ * Assert a parser is available.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {asserts value is Parser}
+ */
+function assertParser(name, value) {
+ if (typeof value !== 'function') {
+ throw new TypeError('Cannot `' + name + '` without `Parser`')
}
}
-// Assert a compiler is available.
-function assertCompiler(name, Compiler) {
- if (typeof Compiler !== 'function') {
- throw new Error('Cannot `' + name + '` without `Compiler`')
+/**
+ * Assert a compiler is available.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {asserts value is Compiler}
+ */
+function assertCompiler(name, value) {
+ if (typeof value !== 'function') {
+ throw new TypeError('Cannot `' + name + '` without `Compiler`')
}
}
-// Assert the processor is not frozen.
+/**
+ * Assert the processor is not frozen.
+ *
+ * @param {string} name
+ * @param {unknown} frozen
+ * @returns {asserts frozen is false}
+ */
function assertUnfrozen(name, frozen) {
if (frozen) {
throw new Error(
- 'Cannot invoke `' +
+ 'Cannot call `' +
name +
- '` on a frozen processor.\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'
+ '` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'
)
}
}
-// Assert `node` is a unist node.
+/**
+ * Assert `node` is a unist node.
+ *
+ * @param {unknown} node
+ * @returns {asserts node is Node}
+ */
function assertNode(node) {
- if (!node || typeof node.type !== 'string') {
- throw new Error('Expected node, got `' + node + '`')
+ // `isPlainObj` unfortunately uses `any` instead of `unknown`.
+ // type-coverage:ignore-next-line
+ if (!isPlainObject$1(node) || typeof node.type !== 'string') {
+ throw new TypeError('Expected node, got `' + node + '`')
+ // Fine.
}
}
-// Assert that `complete` is `true`.
+/**
+ * Assert that `complete` is `true`.
+ *
+ * @param {string} name
+ * @param {string} asyncName
+ * @param {unknown} complete
+ * @returns {asserts complete is true}
+ */
function assertDone(name, asyncName, complete) {
if (!complete) {
throw new Error(
@@ -28503,120 +33739,516 @@ function assertDone(name, asyncName, complete) {
}
}
-var mdastUtilToString$1 = toString$5;
+/**
+ * @param {VFileCompatible} [value]
+ * @returns {VFile}
+ */
+function vfile(value) {
+ return looksLikeAVFile(value) ? value : new VFile(value)
+}
+
+/**
+ * @param {VFileCompatible} [value]
+ * @returns {value is VFile}
+ */
+function looksLikeAVFile(value) {
+ return Boolean(
+ value &&
+ typeof value === 'object' &&
+ 'message' in value &&
+ 'messages' in value
+ )
+}
+
+/**
+ * @param {unknown} [value]
+ * @returns {value is VFileValue}
+ */
+function looksLikeAVFileValue(value) {
+ return typeof value === 'string' || isBuffer(value)
+}
+
+/**
+ * @typedef Options
+ * @property {boolean} [includeImageAlt=true]
+ */
-// Get the text content of a node.
-// Prefer the node’s plain-text fields, otherwise serialize its children,
-// and if the given value is an array, serialize the nodes in it.
-function toString$5(node) {
+/**
+ * Get the text content of a node.
+ * Prefer the node’s plain-text fields, otherwise serialize its children,
+ * and if the given value is an array, serialize the nodes in it.
+ *
+ * @param {unknown} node
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function toString(node, options) {
+ var {includeImageAlt = true} = options || {};
+ return one(node, includeImageAlt)
+}
+
+/**
+ * @param {unknown} node
+ * @param {boolean} includeImageAlt
+ * @returns {string}
+ */
+function one(node, includeImageAlt) {
return (
(node &&
+ typeof node === 'object' &&
+ // @ts-ignore looks like a literal.
(node.value ||
- node.alt ||
- node.title ||
- ('children' in node && all$2(node.children)) ||
- ('length' in node && all$2(node)))) ||
+ // @ts-ignore looks like an image.
+ (includeImageAlt ? node.alt : '') ||
+ // @ts-ignore looks like a parent.
+ ('children' in node && all(node.children, includeImageAlt)) ||
+ (Array.isArray(node) && all(node, includeImageAlt)))) ||
''
)
}
-function all$2(values) {
+/**
+ * @param {Array.<unknown>} values
+ * @param {boolean} includeImageAlt
+ * @returns {string}
+ */
+function all(values, includeImageAlt) {
+ /** @type {Array.<string>} */
var result = [];
var index = -1;
while (++index < values.length) {
- result[index] = toString$5(values[index]);
+ result[index] = one(values[index], includeImageAlt);
}
return result.join('')
}
-var assign$5 = Object.assign;
+/**
+ * Like `Array#splice`, but smarter for giant arrays.
+ *
+ * `Array#splice` takes all items to be inserted as individual argument which
+ * causes a stack overflow in V8 when trying to insert 100k items for instance.
+ *
+ * Otherwise, this does not return the removed items, and takes `items` as an
+ * array instead of rest parameters.
+ *
+ * @template {unknown} T
+ * @param {T[]} list
+ * @param {number} start
+ * @param {number} remove
+ * @param {T[]} items
+ * @returns {void}
+ */
+function splice(list, start, remove, items) {
+ const end = list.length;
+ let chunkStart = 0;
+ /** @type {unknown[]} */
-var assign_1 = assign$5;
+ let parameters; // Make start between zero and `end` (included).
-var own$a = {}.hasOwnProperty;
+ if (start < 0) {
+ start = -start > end ? 0 : end + start;
+ } else {
+ start = start > end ? end : start;
+ }
-var hasOwnProperty$2 = own$a;
+ remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.
-function normalizeIdentifier$4(value) {
- return (
- value // Collapse Markdown whitespace.
- .replace(/[\t\n\r ]+/g, ' ') // Trim.
- .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase
- // counterpart is uppercased will result in a different uppercase
- // character.
- // Hence, to get that form, we perform both lower- and uppercase.
- // Upper case makes sure keys will not interact with default prototypal
- // methods: no object method is uppercase.
- .toLowerCase()
- .toUpperCase()
- )
+ if (items.length < 10000) {
+ parameters = Array.from(items);
+ parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.
+ ;[].splice.apply(list, parameters);
+ } else {
+ // Delete `remove` items starting from `start`
+ if (remove) [].splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.
+
+ while (chunkStart < items.length) {
+ parameters = items.slice(chunkStart, chunkStart + 10000);
+ parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.
+ ;[].splice.apply(list, parameters);
+ chunkStart += 10000;
+ start += 10000;
+ }
+ }
}
+/**
+ * Append `items` (an array) at the end of `list` (another array).
+ * When `list` was empty, returns `items` instead.
+ *
+ * This prevents a potentially expensive operation when `list` is empty,
+ * and adds items in batches to prevent V8 from hanging.
+ *
+ * @template {unknown} T
+ * @param {T[]} list
+ * @param {T[]} items
+ * @returns {T[]}
+ */
-var normalizeIdentifier_1 = normalizeIdentifier$4;
+function push(list, items) {
+ if (list.length > 0) {
+ splice(list, list.length, 0, items);
+ return list
+ }
-var fromCharCode$4 = String.fromCharCode;
+ return items
+}
-var fromCharCode_1 = fromCharCode$4;
+/**
+ * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension
+ * @typedef {import('micromark-util-types').Extension} Extension
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
-var fromCharCode$3 = fromCharCode_1;
+const hasOwnProperty = {}.hasOwnProperty;
-function safeFromInt$1(value, base) {
- var code = parseInt(value, base);
+/**
+ * Combine several syntax extensions into one.
+ *
+ * @param {Extension[]} extensions List of syntax extensions.
+ * @returns {NormalizedExtension} A single combined extension.
+ */
+function combineExtensions(extensions) {
+ /** @type {NormalizedExtension} */
+ const all = {};
+ let index = -1;
- if (
- // C0 except for HT, LF, FF, CR, space
- code < 9 ||
- code === 11 ||
- (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.
- (code > 126 && code < 160) || // Lone high surrogates and low surrogates.
- (code > 55295 && code < 57344) || // Noncharacters.
- (code > 64975 && code < 65008) ||
- (code & 65535) === 65535 ||
- (code & 65535) === 65534 || // Out of range
- code > 1114111
- ) {
- return '\uFFFD'
+ while (++index < extensions.length) {
+ syntaxExtension(all, extensions[index]);
}
- return fromCharCode$3(code)
+ return all
}
-var safeFromInt_1 = safeFromInt$1;
+/**
+ * Merge `extension` into `all`.
+ *
+ * @param {NormalizedExtension} all Extension to merge into.
+ * @param {Extension} extension Extension to merge.
+ * @returns {void}
+ */
+function syntaxExtension(all, extension) {
+ /** @type {string} */
+ let hook;
-var content$3 = {};
+ for (hook in extension) {
+ const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
+ const left = maybe || (all[hook] = {});
+ const right = extension[hook];
+ /** @type {string} */
+ let code;
-function markdownLineEnding$k(code) {
- return code < -2
+ for (code in right) {
+ if (!hasOwnProperty.call(left, code)) left[code] = [];
+ const value = right[code];
+ constructs(
+ // @ts-expect-error Looks like a list.
+ left[code],
+ Array.isArray(value) ? value : value ? [value] : []
+ );
+ }
+ }
}
-var markdownLineEnding_1 = markdownLineEnding$k;
+/**
+ * Merge `list` into `existing` (both lists of constructs).
+ * Mutates `existing`.
+ *
+ * @param {unknown[]} existing
+ * @param {unknown[]} list
+ * @returns {void}
+ */
+function constructs(existing, list) {
+ let index = -1;
+ /** @type {unknown[]} */
+ const before = [];
+
+ while (++index < list.length) {
+(list[index].add === 'after' ? existing : before).push(list[index]);
+ }
+
+ splice(existing, 0, 0, before);
+}
+
+/**
+ * Combine several HTML extensions into one.
+ *
+ * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.
+ * @returns {HtmlExtension} A single combined extension.
+ */
+function combineHtmlExtensions(htmlExtensions) {
+ /** @type {HtmlExtension} */
+ const handlers = {};
+ let index = -1;
-function markdownSpace$a(code) {
+ while (++index < htmlExtensions.length) {
+ htmlExtension(handlers, htmlExtensions[index]);
+ }
+
+ return handlers
+}
+
+/**
+ * Merge `extension` into `all`.
+ *
+ * @param {HtmlExtension} all Extension to merge into.
+ * @param {HtmlExtension} extension Extension to merge.
+ * @returns {void}
+ */
+function htmlExtension(all, extension) {
+ /** @type {string} */
+ let hook;
+
+ for (hook in extension) {
+ const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
+ const left = maybe || (all[hook] = {});
+ const right = extension[hook];
+ /** @type {string} */
+ let type;
+
+ if (right) {
+ for (type in right) {
+ left[type] = right[type];
+ }
+ }
+ }
+}
+
+// This module is generated by `script/`.
+//
+// CommonMark handles attention (emphasis, strong) markers based on what comes
+// before or after them.
+// One such difference is if those characters are Unicode punctuation.
+// This script is generated from the Unicode data.
+const unicodePunctuationRegex =
+ /[!-/:-@[-`{-~\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;
+
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/**
+ * Check whether the character code represents an ASCII alpha (`a` through `z`,
+ * case insensitive).
+ *
+ * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
+ *
+ * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
+ * to U+005A (`Z`).
+ *
+ * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
+ * to U+007A (`z`).
+ */
+
+const asciiAlpha = regexCheck(/[A-Za-z]/);
+/**
+ * Check whether the character code represents an ASCII digit (`0` through `9`).
+ *
+ * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
+ * U+0039 (`9`).
+ */
+
+const asciiDigit = regexCheck(/\d/);
+/**
+ * Check whether the character code represents an ASCII hex digit (`a` through
+ * `f`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
+ * digit, or an ASCII lower hex digit.
+ *
+ * An **ASCII upper hex digit** is a character in the inclusive range U+0041
+ * (`A`) to U+0046 (`F`).
+ *
+ * An **ASCII lower hex digit** is a character in the inclusive range U+0061
+ * (`a`) to U+0066 (`f`).
+ */
+
+const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+/**
+ * Check whether the character code represents an ASCII alphanumeric (`a`
+ * through `z`, case insensitive, or `0` through `9`).
+ *
+ * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
+ * (see `asciiAlpha`).
+ */
+
+const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+/**
+ * Check whether the character code represents ASCII punctuation.
+ *
+ * An **ASCII punctuation** is a character in the inclusive ranges U+0021
+ * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
+ * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
+ * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
+ */
+
+const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+/**
+ * Check whether the character code represents an ASCII atext.
+ *
+ * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
+ * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
+ * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
+ * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
+ * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
+ * (`{`) to U+007E TILDE (`~`).
+ *
+ * See:
+ * **\[RFC5322]**:
+ * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
+ * P. Resnick.
+ * IETF.
+ */
+
+const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+/**
+ * Check whether a character code is an ASCII control character.
+ *
+ * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
+ * to U+001F (US), or U+007F (DEL).
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
+
+function asciiControl(code) {
+ return (
+ // Special whitespace codes (which have negative values), C0 and Control
+ // character DEL
+ code !== null && (code < 32 || code === 127)
+ )
+}
+/**
+ * Check whether a character code is a markdown line ending (see
+ * `markdownLineEnding`) or markdown space (see `markdownSpace`).
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
+
+function markdownLineEndingOrSpace(code) {
+ return code !== null && (code < 0 || code === 32)
+}
+/**
+ * Check whether a character code is a markdown line ending.
+ *
+ * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+ * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+ *
+ * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+ * RETURN (CR) are replaced by these virtual characters depending on whether
+ * they occurred together.
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
+
+function markdownLineEnding(code) {
+ return code !== null && code < -2
+}
+/**
+ * Check whether a character code is a markdown space.
+ *
+ * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+ * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+ *
+ * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+ * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+ * SPACE (VS) characters, depending on the column at which the tab occurred.
+ *
+ * @param {Code} code
+ * @returns {code is number}
+ */
+
+function markdownSpace(code) {
return code === -2 || code === -1 || code === 32
}
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ */
-var markdownSpace_1 = markdownSpace$a;
+const unicodeWhitespace = regexCheck(/\s/);
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ */
+// Size note: removing ASCII from the regex and using `asciiPunctuation` here
+// In fact adds to the bundle size.
-var markdownSpace$9 = markdownSpace_1;
+const unicodePunctuation = regexCheck(unicodePunctuationRegex);
+/**
+ * Create a code check from a regex.
+ *
+ * @param {RegExp} regex
+ * @returns {(code: Code) => code is number}
+ */
+
+function regexCheck(regex) {
+ return check
+ /**
+ * Check whether a code matches the bound regex.
+ *
+ * @param {Code} code Character code
+ * @returns {code is number} Whether the character code matches the bound regex
+ */
-function spaceFactory(effects, ok, type, max) {
- var limit = max ? max - 1 : Infinity;
- var size = 0;
+ function check(code) {
+ return code !== null && regex.test(String.fromCharCode(code))
+ }
+}
+
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ */
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {string} type
+ * @param {number} [max=Infinity]
+ * @returns {State}
+ */
+
+function factorySpace(effects, ok, type, max) {
+ const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+ let size = 0;
return start
+ /** @type {State} */
function start(code) {
- if (markdownSpace$9(code)) {
+ if (markdownSpace(code)) {
effects.enter(type);
return prefix(code)
}
return ok(code)
}
+ /** @type {State} */
function prefix(code) {
- if (markdownSpace$9(code) && size++ < limit) {
+ if (markdownSpace(code) && size++ < limit) {
effects.consume(code);
return prefix
}
@@ -28626,23 +34258,30 @@ function spaceFactory(effects, ok, type, max) {
}
}
-var factorySpace$i = spaceFactory;
-
-Object.defineProperty(content$3, '__esModule', {value: true});
-
-var markdownLineEnding$j = markdownLineEnding_1;
-var factorySpace$h = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
-var tokenize$2 = initializeContent;
+/** @type {InitialConstruct} */
+const content$1 = {
+ tokenize: initializeContent
+};
+/** @type {Initializer} */
function initializeContent(effects) {
- var contentStart = effects.attempt(
+ const contentStart = effects.attempt(
this.parser.constructs.contentInitial,
afterContentStartConstruct,
paragraphInitial
);
- var previous;
+ /** @type {Token} */
+
+ let previous;
return contentStart
+ /** @type {State} */
function afterContentStartConstruct(code) {
if (code === null) {
@@ -28653,18 +34292,20 @@ function initializeContent(effects) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return factorySpace$h(effects, contentStart, 'linePrefix')
+ return factorySpace(effects, contentStart, 'linePrefix')
}
+ /** @type {State} */
function paragraphInitial(code) {
effects.enter('paragraph');
return lineStart(code)
}
+ /** @type {State} */
function lineStart(code) {
- var token = effects.enter('chunkText', {
+ const token = effects.enter('chunkText', {
contentType: 'text',
- previous: previous
+ previous
});
if (previous) {
@@ -28674,6 +34315,7 @@ function initializeContent(effects) {
previous = token;
return data(code)
}
+ /** @type {State} */
function data(code) {
if (code === null) {
@@ -28683,7 +34325,7 @@ function initializeContent(effects) {
return
}
- if (markdownLineEnding$j(code)) {
+ if (markdownLineEnding(code)) {
effects.consume(code);
effects.exit('chunkText');
return lineStart
@@ -28694,84 +34336,128 @@ function initializeContent(effects) {
}
}
-content$3.tokenize = tokenize$2;
-
-var document$3 = {};
-
-var markdownLineEnding$i = markdownLineEnding_1;
-var factorySpace$g = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Point} Point
+ */
+/** @type {InitialConstruct} */
-var partialBlankLine$4 = {
- tokenize: tokenizePartialBlankLine,
- partial: true
+const document$2 = {
+ tokenize: initializeDocument
};
+/** @type {Construct} */
-function tokenizePartialBlankLine(effects, ok, nok) {
- return factorySpace$g(effects, afterWhitespace, 'linePrefix')
-
- function afterWhitespace(code) {
- return code === null || markdownLineEnding$i(code) ? ok(code) : nok(code)
- }
-}
+const containerConstruct = {
+ tokenize: tokenizeContainer
+};
+/** @type {Initializer} */
-var partialBlankLine_1 = partialBlankLine$4;
+function initializeDocument(effects) {
+ const self = this;
+ /** @type {StackItem[]} */
-Object.defineProperty(document$3, '__esModule', {value: true});
+ const stack = [];
+ let continued = 0;
+ /** @type {TokenizeContext|undefined} */
-var markdownLineEnding$h = markdownLineEnding_1;
-var factorySpace$f = factorySpace$i;
-var partialBlankLine$3 = partialBlankLine_1;
+ let childFlow;
+ /** @type {Token|undefined} */
-var tokenize$1 = initializeDocument;
-var containerConstruct = {
- tokenize: tokenizeContainer
-};
-var lazyFlowConstruct = {
- tokenize: tokenizeLazyFlow
-};
+ let childToken;
+ /** @type {number} */
-function initializeDocument(effects) {
- var self = this;
- var stack = [];
- var continued = 0;
- var inspectConstruct = {
- tokenize: tokenizeInspect,
- partial: true
- };
- var inspectResult;
- var childFlow;
- var childToken;
+ let lineStartOffset;
return start
+ /** @type {State} */
function start(code) {
+ // First we iterate through the open blocks, starting with the root
+ // document, and descending through last children down to the last open
+ // block.
+ // Each block imposes a condition that the line must satisfy if the block is
+ // to remain open.
+ // For example, a block quote requires a `>` character.
+ // A paragraph requires a non-blank line.
+ // In this phase we may match all or just some of the open blocks.
+ // But we cannot close unmatched blocks yet, because we may have a lazy
+ // continuation line.
if (continued < stack.length) {
- self.containerState = stack[continued][1];
+ const item = stack[continued];
+ self.containerState = item[1];
return effects.attempt(
- stack[continued][0].continuation,
+ item[0].continuation,
documentContinue,
- documentContinued
+ checkNewContainers
)(code)
- }
+ } // Done.
- return documentContinued(code)
+ return checkNewContainers(code)
}
+ /** @type {State} */
function documentContinue(code) {
+ if (self.containerState._closeFlow) closeFlow();
continued++;
return start(code)
}
+ /** @type {State} */
- function documentContinued(code) {
- // If we’re in a concrete construct (such as when expecting another line of
- // HTML, or we resulted in lazy content), we can immediately start flow.
- if (inspectResult && inspectResult.flowContinue) {
- return flowStart(code)
- }
+ function checkNewContainers(code) {
+ // Next, after consuming the continuation markers for existing blocks, we
+ // look for new block starts (e.g. `>` for a block quote).
+ // If we encounter a new block start, we close any blocks unmatched in
+ // step 1 before creating the new block as a child of the last matched
+ // block.
+ if (continued === stack.length) {
+ // No need to `check` whether there’s a container, of `exitContainers`
+ // would be moot.
+ // We can instead immediately `attempt` to parse one.
+ if (!childFlow) {
+ return documentContinued(code)
+ } // If we have concrete content, such as block HTML or fenced code,
+ // we can’t have containers “pierce” into them, so we can immediately
+ // start.
+
+ if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
+ return flowStart(code)
+ } // If we do have flow, it could still be a blank line,
+ // but we’d be interrupting it w/ a new container if there’s a current
+ // construct.
+
+ self.interrupt = Boolean(childFlow.currentConstruct);
+ } // Check if there is a new container.
+
+ self.containerState = {};
+ return effects.check(
+ containerConstruct,
+ thereIsANewContainer,
+ thereIsNoNewContainer
+ )(code)
+ }
+ /** @type {State} */
- self.interrupt =
- childFlow &&
- childFlow.currentConstruct &&
- childFlow.currentConstruct.interruptible;
+ function thereIsANewContainer(code) {
+ if (childFlow) closeFlow();
+ exitContainers(continued);
+ return documentContinued(code)
+ }
+ /** @type {State} */
+
+ function thereIsNoNewContainer(code) {
+ self.parser.lazy[self.now().line] = continued !== stack.length;
+ lineStartOffset = self.now().offset;
+ return flowStart(code)
+ }
+ /** @type {State} */
+
+ function documentContinued(code) {
+ // Try new containers.
self.containerState = {};
return effects.attempt(
containerConstruct,
@@ -28779,16 +34465,20 @@ function initializeDocument(effects) {
flowStart
)(code)
}
+ /** @type {State} */
function containerContinue(code) {
- stack.push([self.currentConstruct, self.containerState]);
- self.containerState = undefined;
+ continued++;
+ stack.push([self.currentConstruct, self.containerState]); // Try another.
+
return documentContinued(code)
}
+ /** @type {State} */
function flowStart(code) {
if (code === null) {
- exitContainers(0, true);
+ if (childFlow) closeFlow();
+ exitContainers(0);
effects.consume(code);
return
}
@@ -28801,870 +34491,221 @@ function initializeDocument(effects) {
});
return flowContinue(code)
}
+ /** @type {State} */
function flowContinue(code) {
if (code === null) {
- continueFlow(effects.exit('chunkFlow'));
- return flowStart(code)
+ writeToChild(effects.exit('chunkFlow'), true);
+ exitContainers(0);
+ effects.consume(code);
+ return
}
- if (markdownLineEnding$h(code)) {
+ if (markdownLineEnding(code)) {
effects.consume(code);
- continueFlow(effects.exit('chunkFlow'));
- return effects.check(inspectConstruct, documentAfterPeek)
+ writeToChild(effects.exit('chunkFlow')); // Get ready for the next line.
+
+ continued = 0;
+ self.interrupt = undefined;
+ return start
}
effects.consume(code);
return flowContinue
}
+ /**
+ * @param {Token} token
+ * @param {boolean} [eof]
+ * @returns {void}
+ */
- function documentAfterPeek(code) {
- exitContainers(
- inspectResult.continued,
- inspectResult && inspectResult.flowEnd
- );
- continued = 0;
- return start(code)
- }
-
- function continueFlow(token) {
+ function writeToChild(token, eof) {
+ const stream = self.sliceStream(token);
+ if (eof) stream.push(null);
+ token.previous = childToken;
if (childToken) childToken.next = token;
childToken = token;
- childFlow.lazy = inspectResult && inspectResult.lazy;
childFlow.defineSkip(token.start);
- childFlow.write(self.sliceStream(token));
- }
-
- function exitContainers(size, end) {
- var index = stack.length; // Close the flow.
-
- if (childFlow && end) {
- childFlow.write([null]);
- childToken = childFlow = undefined;
- } // Exit open containers.
-
- while (index-- > size) {
- self.containerState = stack[index][1];
- stack[index][0].exit.call(self, effects);
- }
-
- stack.length = size;
- }
-
- function tokenizeInspect(effects, ok) {
- var subcontinued = 0;
- inspectResult = {};
- return inspectStart
-
- function inspectStart(code) {
- if (subcontinued < stack.length) {
- self.containerState = stack[subcontinued][1];
- return effects.attempt(
- stack[subcontinued][0].continuation,
- inspectContinue,
- inspectLess
- )(code)
- } // If we’re continued but in a concrete flow, we can’t have more
- // containers.
-
- if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
- inspectResult.flowContinue = true;
- return inspectDone(code)
- }
-
- self.interrupt =
- childFlow.currentConstruct && childFlow.currentConstruct.interruptible;
- self.containerState = {};
- return effects.attempt(
- containerConstruct,
- inspectFlowEnd,
- inspectDone
- )(code)
- }
-
- function inspectContinue(code) {
- subcontinued++;
- return self.containerState._closeFlow
- ? inspectFlowEnd(code)
- : inspectStart(code)
- }
-
- function inspectLess(code) {
- if (childFlow.currentConstruct && childFlow.currentConstruct.lazy) {
- // Maybe another container?
- self.containerState = {};
- return effects.attempt(
- containerConstruct,
- inspectFlowEnd, // Maybe flow, or a blank line?
- effects.attempt(
- lazyFlowConstruct,
- inspectFlowEnd,
- effects.check(partialBlankLine$3, inspectFlowEnd, inspectLazy)
- )
- )(code)
- } // Otherwise we’re interrupting.
-
- return inspectFlowEnd(code)
- }
-
- function inspectLazy(code) {
- // Act as if all containers are continued.
- subcontinued = stack.length;
- inspectResult.lazy = true;
- inspectResult.flowContinue = true;
- return inspectDone(code)
- } // We’re done with flow if we have more containers, or an interruption.
-
- function inspectFlowEnd(code) {
- inspectResult.flowEnd = true;
- return inspectDone(code)
- }
-
- function inspectDone(code) {
- inspectResult.continued = subcontinued;
- self.interrupt = self.containerState = undefined;
- return ok(code)
- }
- }
-}
-
-function tokenizeContainer(effects, ok, nok) {
- return factorySpace$f(
- effects,
- effects.attempt(this.parser.constructs.document, ok, nok),
- 'linePrefix',
- this.parser.constructs.disable.null.indexOf('codeIndented') > -1
- ? undefined
- : 4
- )
-}
-
-function tokenizeLazyFlow(effects, ok, nok) {
- return factorySpace$f(
- effects,
- effects.lazy(this.parser.constructs.flow, ok, nok),
- 'linePrefix',
- this.parser.constructs.disable.null.indexOf('codeIndented') > -1
- ? undefined
- : 4
- )
-}
-
-document$3.tokenize = tokenize$1;
-
-var flow$7 = {};
-
-// Counts tabs based on their expanded size, and CR+LF as one character.
-
-function sizeChunks$2(chunks) {
- var index = -1;
- var size = 0;
-
- while (++index < chunks.length) {
- size += typeof chunks[index] === 'string' ? chunks[index].length : 1;
- }
-
- return size
-}
-
-var sizeChunks_1 = sizeChunks$2;
-
-var sizeChunks$1 = sizeChunks_1;
-
-function prefixSize$4(events, type) {
- var tail = events[events.length - 1];
- if (!tail || tail[1].type !== type) return 0
- return sizeChunks$1(tail[2].sliceStream(tail[1]))
-}
-
-var prefixSize_1 = prefixSize$4;
-
-var splice$2 = [].splice;
-
-var splice_1 = splice$2;
-
-var splice$1 = splice_1;
-
-// causes a stack overflow in V8 when trying to insert 100k items for instance.
-
-function chunkedSplice$8(list, start, remove, items) {
- var end = list.length;
- var chunkStart = 0;
- var parameters; // Make start between zero and `end` (included).
-
- if (start < 0) {
- start = -start > end ? 0 : end + start;
- } else {
- start = start > end ? end : start;
- }
-
- remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.
-
- if (items.length < 10000) {
- parameters = Array.from(items);
- parameters.unshift(start, remove);
- splice$1.apply(list, parameters);
- } else {
- // Delete `remove` items starting from `start`
- if (remove) splice$1.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.
-
- while (chunkStart < items.length) {
- parameters = items.slice(chunkStart, chunkStart + 10000);
- parameters.unshift(start, 0);
- splice$1.apply(list, parameters);
- chunkStart += 10000;
- start += 10000;
- }
- }
-}
-
-var chunkedSplice_1 = chunkedSplice$8;
-
-var assign$4 = assign_1;
-
-function shallow$6(object) {
- return assign$4({}, object)
-}
-
-var shallow_1 = shallow$6;
-
-var assign$3 = assign_1;
-var chunkedSplice$7 = chunkedSplice_1;
-var shallow$5 = shallow_1;
-
-function subtokenize$2(events) {
- var jumps = {};
- var index = -1;
- var event;
- var lineIndex;
- var otherIndex;
- var otherEvent;
- var parameters;
- var subevents;
- var more;
-
- while (++index < events.length) {
- while (index in jumps) {
- index = jumps[index];
- }
-
- event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text
- // is in the first content of a list item.
-
- if (
- index &&
- event[1].type === 'chunkFlow' &&
- events[index - 1][1].type === 'listItemPrefix'
- ) {
- subevents = event[1]._tokenizer.events;
- otherIndex = 0;
-
- if (
- otherIndex < subevents.length &&
- subevents[otherIndex][1].type === 'lineEndingBlank'
- ) {
- otherIndex += 2;
- }
-
- if (
- otherIndex < subevents.length &&
- subevents[otherIndex][1].type === 'content'
- ) {
- while (++otherIndex < subevents.length) {
- if (subevents[otherIndex][1].type === 'content') {
- break
- }
-
- if (subevents[otherIndex][1].type === 'chunkText') {
- subevents[otherIndex][1].isInFirstContentOfListItem = true;
- otherIndex++;
- }
- }
- }
- } // Enter.
-
- if (event[0] === 'enter') {
- if (event[1].contentType) {
- assign$3(jumps, subcontent(events, index));
- index = jumps[index];
- more = true;
- }
- } // Exit.
- else if (event[1]._container || event[1]._movePreviousLineEndings) {
- otherIndex = index;
- lineIndex = undefined;
+ childFlow.write(stream); // Alright, so we just added a lazy line:
+ //
+ // ```markdown
+ // > a
+ // b.
+ //
+ // Or:
+ //
+ // > ~~~c
+ // d
+ //
+ // Or:
+ //
+ // > | e |
+ // f
+ // ```
+ //
+ // The construct in the second example (fenced code) does not accept lazy
+ // lines, so it marked itself as done at the end of its first line, and
+ // then the content construct parses `d`.
+ // Most constructs in markdown match on the first line: if the first line
+ // forms a construct, a non-lazy line can’t “unmake” it.
+ //
+ // The construct in the third example is potentially a GFM table, and
+ // those are *weird*.
+ // It *could* be a table, from the first line, if the following line
+ // matches a condition.
+ // In this case, that second line is lazy, which “unmakes” the first line
+ // and turns the whole into one content block.
+ //
+ // We’ve now parsed the non-lazy and the lazy line, and can figure out
+ // whether the lazy line started a new flow block.
+ // If it did, we exit the current containers between the two flow blocks.
- while (otherIndex--) {
- otherEvent = events[otherIndex];
+ if (self.parser.lazy[token.start.line]) {
+ let index = childFlow.events.length;
+ while (index--) {
if (
- otherEvent[1].type === 'lineEnding' ||
- otherEvent[1].type === 'lineEndingBlank'
+ // The token starts before the line ending…
+ childFlow.events[index][1].start.offset < lineStartOffset &&
+ (!childFlow.events[index][1].end || // …or ends after it.
+ childFlow.events[index][1].end.offset > lineStartOffset)
) {
- if (otherEvent[0] === 'enter') {
- if (lineIndex) {
- events[lineIndex][1].type = 'lineEndingBlank';
- }
-
- otherEvent[1].type = 'lineEnding';
- lineIndex = otherIndex;
- }
- } else {
- break
+ // Exit: there’s still something open, which means it’s a lazy line
+ // part of something.
+ return
}
}
- if (lineIndex) {
- // Fix position.
- event[1].end = shallow$5(events[lineIndex][1].start); // Switch container exit w/ line endings.
-
- parameters = events.slice(lineIndex, index);
- parameters.unshift(event);
- chunkedSplice$7(events, lineIndex, index - lineIndex + 1, parameters);
- }
- }
- }
-
- return !more
-}
-
-function subcontent(events, eventIndex) {
- var token = events[eventIndex][1];
- var context = events[eventIndex][2];
- var startPosition = eventIndex - 1;
- var startPositions = [];
- var tokenizer =
- token._tokenizer || context.parser[token.contentType](token.start);
- var childEvents = tokenizer.events;
- var jumps = [];
- var gaps = {};
- var stream;
- var previous;
- var index;
- var entered;
- var end;
- var adjust; // Loop forward through the linked tokens to pass them in order to the
- // subtokenizer.
-
- while (token) {
- // Find the position of the event for this token.
- while (events[++startPosition][1] !== token) {
- // Empty.
- }
-
- startPositions.push(startPosition);
+ const indexBeforeExits = self.events.length;
+ let indexBeforeFlow = indexBeforeExits;
+ /** @type {boolean|undefined} */
- if (!token._tokenizer) {
- stream = context.sliceStream(token);
+ let seen;
+ /** @type {Point|undefined} */
- if (!token.next) {
- stream.push(null);
- }
-
- if (previous) {
- tokenizer.defineSkip(token.start);
- }
+ let point; // Find the previous chunk (the one before the lazy line).
- if (token.isInFirstContentOfListItem) {
- tokenizer._gfmTasklistFirstContentOfListItem = true;
- }
-
- tokenizer.write(stream);
-
- if (token.isInFirstContentOfListItem) {
- tokenizer._gfmTasklistFirstContentOfListItem = undefined;
- }
- } // Unravel the next token.
-
- previous = token;
- token = token.next;
- } // Now, loop back through all events (and linked tokens), to figure out which
- // parts belong where.
-
- token = previous;
- index = childEvents.length;
-
- while (index--) {
- // Make sure we’ve at least seen something (final eol is part of the last
- // token).
- if (childEvents[index][0] === 'enter') {
- entered = true;
- } else if (
- // Find a void token that includes a break.
- entered &&
- childEvents[index][1].type === childEvents[index - 1][1].type &&
- childEvents[index][1].start.line !== childEvents[index][1].end.line
- ) {
- add(childEvents.slice(index + 1, end));
- // Help GC.
- token._tokenizer = token.next = undefined;
- token = token.previous;
- end = index + 1;
- }
- }
-
- // Help GC.
- tokenizer.events = token._tokenizer = token.next = undefined; // Do head:
-
- add(childEvents.slice(0, end));
- index = -1;
- adjust = 0;
-
- while (++index < jumps.length) {
- gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
- adjust += jumps[index][1] - jumps[index][0] - 1;
- }
-
- return gaps
-
- function add(slice) {
- var start = startPositions.pop();
- jumps.unshift([start, start + slice.length - 1]);
- chunkedSplice$7(events, start, 2, slice);
- }
-}
-
-var subtokenize_1 = subtokenize$2;
-
-var markdownLineEnding$g = markdownLineEnding_1;
-var prefixSize$3 = prefixSize_1;
-var subtokenize$1 = subtokenize_1;
-var factorySpace$e = factorySpace$i;
-
-// No name because it must not be turned off.
-var content$2 = {
- tokenize: tokenizeContent,
- resolve: resolveContent,
- interruptible: true,
- lazy: true
-};
-var continuationConstruct = {
- tokenize: tokenizeContinuation,
- partial: true
-}; // Content is transparent: it’s parsed right now. That way, definitions are also
-// parsed right now: before text in paragraphs (specifically, media) are parsed.
-
-function resolveContent(events) {
- subtokenize$1(events);
- return events
-}
-
-function tokenizeContent(effects, ok) {
- var previous;
- return start
-
- function start(code) {
- effects.enter('content');
- previous = effects.enter('chunkContent', {
- contentType: 'content'
- });
- return data(code)
- }
-
- function data(code) {
- if (code === null) {
- return contentEnd(code)
- }
-
- if (markdownLineEnding$g(code)) {
- return effects.check(
- continuationConstruct,
- contentContinue,
- contentEnd
- )(code)
- } // Data.
-
- effects.consume(code);
- return data
- }
-
- function contentEnd(code) {
- effects.exit('chunkContent');
- effects.exit('content');
- return ok(code)
- }
-
- function contentContinue(code) {
- effects.consume(code);
- effects.exit('chunkContent');
- previous = previous.next = effects.enter('chunkContent', {
- contentType: 'content',
- previous: previous
- });
- return data
- }
-}
-
-function tokenizeContinuation(effects, ok, nok) {
- var self = this;
- return startLookahead
-
- function startLookahead(code) {
- effects.enter('lineEnding');
- effects.consume(code);
- effects.exit('lineEnding');
- return factorySpace$e(effects, prefixed, 'linePrefix')
- }
-
- function prefixed(code) {
- if (code === null || markdownLineEnding$g(code)) {
- return nok(code)
- }
-
- if (
- self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ||
- prefixSize$3(self.events, 'linePrefix') < 4
- ) {
- return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
- }
-
- return ok(code)
- }
-}
-
-var content_1 = content$2;
-
-Object.defineProperty(flow$7, '__esModule', {value: true});
-
-var content$1 = content_1;
-var factorySpace$d = factorySpace$i;
-var partialBlankLine$2 = partialBlankLine_1;
-
-var tokenize = initializeFlow;
-
-function initializeFlow(effects) {
- var self = this;
- var initial = effects.attempt(
- // Try to parse a blank line.
- partialBlankLine$2,
- atBlankEnding, // Try to parse initial flow (essentially, only code).
- effects.attempt(
- this.parser.constructs.flowInitial,
- afterConstruct,
- factorySpace$d(
- effects,
- effects.attempt(
- this.parser.constructs.flow,
- afterConstruct,
- effects.attempt(content$1, afterConstruct)
- ),
- 'linePrefix'
- )
- )
- );
- return initial
-
- function atBlankEnding(code) {
- if (code === null) {
- effects.consume(code);
- return
- }
-
- effects.enter('lineEndingBlank');
- effects.consume(code);
- effects.exit('lineEndingBlank');
- self.currentConstruct = undefined;
- return initial
- }
-
- function afterConstruct(code) {
- if (code === null) {
- effects.consume(code);
- return
- }
-
- effects.enter('lineEnding');
- effects.consume(code);
- effects.exit('lineEnding');
- self.currentConstruct = undefined;
- return initial
- }
-}
-
-flow$7.tokenize = tokenize;
-
-var text$5 = {};
-
-Object.defineProperty(text$5, '__esModule', {value: true});
-
-var assign$2 = assign_1;
-var shallow$4 = shallow_1;
-
-var text$4 = initializeFactory('text');
-var string$1 = initializeFactory('string');
-var resolver = {
- resolveAll: createResolver()
-};
-
-function initializeFactory(field) {
- return {
- tokenize: initializeText,
- resolveAll: createResolver(
- field === 'text' ? resolveAllLineSuffixes : undefined
- )
- }
-
- function initializeText(effects) {
- var self = this;
- var constructs = this.parser.constructs[field];
- var text = effects.attempt(constructs, start, notText);
- return start
-
- function start(code) {
- return atBreak(code) ? text(code) : notText(code)
- }
-
- function notText(code) {
- if (code === null) {
- effects.consume(code);
- return
- }
-
- effects.enter('data');
- effects.consume(code);
- return data
- }
-
- function data(code) {
- if (atBreak(code)) {
- effects.exit('data');
- return text(code)
- } // Data.
-
- effects.consume(code);
- return data
- }
-
- function atBreak(code) {
- var list = constructs[code];
- var index = -1;
-
- if (code === null) {
- return true
- }
-
- if (list) {
- while (++index < list.length) {
- if (
- !list[index].previous ||
- list[index].previous.call(self, self.previous)
- ) {
- return true
+ while (indexBeforeFlow--) {
+ if (
+ self.events[indexBeforeFlow][0] === 'exit' &&
+ self.events[indexBeforeFlow][1].type === 'chunkFlow'
+ ) {
+ if (seen) {
+ point = self.events[indexBeforeFlow][1].end;
+ break
}
- }
- }
- }
- }
-}
-function createResolver(extraResolver) {
- return resolveAllText
-
- function resolveAllText(events, context) {
- var index = -1;
- var enter; // A rather boring computation (to merge adjacent `data` events) which
- // improves mm performance by 29%.
-
- while (++index <= events.length) {
- if (enter === undefined) {
- if (events[index] && events[index][1].type === 'data') {
- enter = index;
- index++;
+ seen = true;
}
- } else if (!events[index] || events[index][1].type !== 'data') {
- // Don’t do anything if there is one data token.
- if (index !== enter + 2) {
- events[enter][1].end = events[index - 1][1].end;
- events.splice(enter + 2, index - enter - 2);
- index = enter + 2;
- }
-
- enter = undefined;
}
- }
- return extraResolver ? extraResolver(events, context) : events
- }
-} // A rather ugly set of instructions which again looks at chunks in the input
-// stream.
-// The reason to do this here is that it is *much* faster to parse in reverse.
-// And that we can’t hook into `null` to split the line suffix before an EOF.
-// To do: figure out if we can make this into a clean utility, or even in core.
-// As it will be useful for GFMs literal autolink extension (and maybe even
-// tables?)
-
-function resolveAllLineSuffixes(events, context) {
- var eventIndex = -1;
- var chunks;
- var data;
- var chunk;
- var index;
- var bufferIndex;
- var size;
- var tabs;
- var token;
-
- while (++eventIndex <= events.length) {
- if (
- (eventIndex === events.length ||
- events[eventIndex][1].type === 'lineEnding') &&
- events[eventIndex - 1][1].type === 'data'
- ) {
- data = events[eventIndex - 1][1];
- chunks = context.sliceStream(data);
- index = chunks.length;
- bufferIndex = -1;
- size = 0;
- tabs = undefined;
-
- while (index--) {
- chunk = chunks[index];
-
- if (typeof chunk === 'string') {
- bufferIndex = chunk.length;
+ exitContainers(continued); // Fix positions.
- while (chunk.charCodeAt(bufferIndex - 1) === 32) {
- size++;
- bufferIndex--;
- }
-
- if (bufferIndex) break
- bufferIndex = -1;
- } // Number
- else if (chunk === -2) {
- tabs = true;
- size++;
- } else if (chunk === -1);
- else {
- // Replacement character, exit.
- index++;
- break
- }
- }
+ index = indexBeforeExits;
- if (size) {
- token = {
- type:
- eventIndex === events.length || tabs || size < 2
- ? 'lineSuffix'
- : 'hardBreakTrailing',
- start: {
- line: data.end.line,
- column: data.end.column - size,
- offset: data.end.offset - size,
- _index: data.start._index + index,
- _bufferIndex: index
- ? bufferIndex
- : data.start._bufferIndex + bufferIndex
- },
- end: shallow$4(data.end)
- };
- data.end = shallow$4(token.start);
+ while (index < self.events.length) {
+ self.events[index][1].end = Object.assign({}, point);
+ index++;
+ } // Inject the exits earlier (they’re still also at the end).
- if (data.start.offset === data.end.offset) {
- assign$2(data, token);
- } else {
- events.splice(
- eventIndex,
- 0,
- ['enter', token, context],
- ['exit', token, context]
- );
- eventIndex += 2;
- }
- }
+ splice(
+ self.events,
+ indexBeforeFlow + 1,
+ 0,
+ self.events.slice(indexBeforeExits)
+ ); // Discard the duplicate exits.
- eventIndex++;
+ self.events.length = index;
}
}
+ /**
+ * @param {number} size
+ * @returns {void}
+ */
- return events
-}
-
-text$5.resolver = resolver;
-text$5.string = string$1;
-text$5.text = text$4;
-
-function miniflat$3(value) {
- return value === null || value === undefined
- ? []
- : 'length' in value
- ? value
- : [value]
-}
-
-var miniflat_1 = miniflat$3;
-
-var hasOwnProperty$1 = hasOwnProperty$2;
-var chunkedSplice$6 = chunkedSplice_1;
-var miniflat$2 = miniflat_1;
+ function exitContainers(size) {
+ let index = stack.length; // Exit open containers.
-function combineExtensions$2(extensions) {
- var all = {};
- var index = -1;
+ while (index-- > size) {
+ const entry = stack[index];
+ self.containerState = entry[1];
+ entry[0].exit.call(self, effects);
+ }
- while (++index < extensions.length) {
- extension$1(all, extensions[index]);
+ stack.length = size;
}
- return all
-}
-
-function extension$1(all, extension) {
- var hook;
- var left;
- var right;
- var code;
-
- for (hook in extension) {
- left = hasOwnProperty$1.call(all, hook) ? all[hook] : (all[hook] = {});
- right = extension[hook];
-
- for (code in right) {
- left[code] = constructs$3(
- miniflat$2(right[code]),
- hasOwnProperty$1.call(left, code) ? left[code] : []
- );
- }
+ function closeFlow() {
+ childFlow.write([null]);
+ childToken = undefined;
+ childFlow = undefined;
+ self.containerState._closeFlow = undefined;
}
}
+/** @type {Tokenizer} */
-function constructs$3(list, existing) {
- var index = -1;
- var before = [];
-
- while (++index < list.length) {
-(list[index].add === 'after' ? existing : before).push(list[index]);
- }
-
- chunkedSplice$6(existing, 0, 0, before);
- return existing
+function tokenizeContainer(effects, ok, nok) {
+ return factorySpace(
+ effects,
+ effects.attempt(this.parser.constructs.document, ok, nok),
+ 'linePrefix',
+ this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
+ )
}
-var combineExtensions_1 = combineExtensions$2;
-
-var chunkedSplice$5 = chunkedSplice_1;
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-function chunkedPush$3(list, items) {
- if (list.length) {
- chunkedSplice$5(list, list.length, 0, items);
- return list
+/**
+ * Classify whether a character code represents whitespace, punctuation, or
+ * something else.
+ *
+ * Used for attention (emphasis, strong), whose sequences can open or close
+ * based on the class of surrounding characters.
+ *
+ * Note that eof (`null`) is seen as whitespace.
+ *
+ * @param {Code} code
+ * @returns {number|undefined}
+ */
+function classifyCharacter(code) {
+ if (
+ code === null ||
+ markdownLineEndingOrSpace(code) ||
+ unicodeWhitespace(code)
+ ) {
+ return 1
}
- return items
+ if (unicodePunctuation(code)) {
+ return 2
+ }
}
-var chunkedPush_1 = chunkedPush$3;
+/**
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ */
-function resolveAll$4(constructs, events, context) {
- var called = [];
- var index = -1;
- var resolve;
+/**
+ * Call all `resolveAll`s.
+ *
+ * @param {{resolveAll?: Resolver}[]} constructs
+ * @param {Event[]} events
+ * @param {TokenizeContext} context
+ * @returns {Event[]}
+ */
+function resolveAll(constructs, events, context) {
+ /** @type {Resolver[]} */
+ const called = [];
+ let index = -1;
while (++index < constructs.length) {
- resolve = constructs[index].resolveAll;
+ const resolve = constructs[index].resolveAll;
- if (resolve && called.indexOf(resolve) < 0) {
+ if (resolve && !called.includes(resolve)) {
events = resolve(events, context);
called.push(resolve);
}
@@ -29673,491 +34714,55 @@ function resolveAll$4(constructs, events, context) {
return events
}
-var resolveAll_1 = resolveAll$4;
-
-var fromCharCode$2 = fromCharCode_1;
-
-function serializeChunks$1(chunks) {
- var index = -1;
- var result = [];
- var chunk;
- var value;
- var atTab;
-
- while (++index < chunks.length) {
- chunk = chunks[index];
-
- if (typeof chunk === 'string') {
- value = chunk;
- } else if (chunk === -5) {
- value = '\r';
- } else if (chunk === -4) {
- value = '\n';
- } else if (chunk === -3) {
- value = '\r' + '\n';
- } else if (chunk === -2) {
- value = '\t';
- } else if (chunk === -1) {
- if (atTab) continue
- value = ' ';
- } else {
- // Currently only replacement character.
- value = fromCharCode$2(chunk);
- }
-
- atTab = chunk === -2;
- result.push(value);
- }
-
- return result.join('')
-}
-
-var serializeChunks_1 = serializeChunks$1;
-
-function sliceChunks$1(chunks, token) {
- var startIndex = token.start._index;
- var startBufferIndex = token.start._bufferIndex;
- var endIndex = token.end._index;
- var endBufferIndex = token.end._bufferIndex;
- var view;
-
- if (startIndex === endIndex) {
- view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
- } else {
- view = chunks.slice(startIndex, endIndex);
-
- if (startBufferIndex > -1) {
- view[0] = view[0].slice(startBufferIndex);
- }
-
- if (endBufferIndex > 0) {
- view.push(chunks[endIndex].slice(0, endBufferIndex));
- }
- }
-
- return view
-}
-
-var sliceChunks_1 = sliceChunks$1;
-
-var assign$1 = assign_1;
-var markdownLineEnding$f = markdownLineEnding_1;
-var chunkedPush$2 = chunkedPush_1;
-var chunkedSplice$4 = chunkedSplice_1;
-var miniflat$1 = miniflat_1;
-var resolveAll$3 = resolveAll_1;
-var serializeChunks = serializeChunks_1;
-var shallow$3 = shallow_1;
-var sliceChunks = sliceChunks_1;
-
-// Create a tokenizer.
-// Tokenizers deal with one type of data (e.g., containers, flow, text).
-// The parser is the object dealing with it all.
-// `initialize` works like other constructs, except that only its `tokenize`
-// function is used, in which case it doesn’t receive an `ok` or `nok`.
-// `from` can be given to set the point before the first character, although
-// when further lines are indented, they must be set with `defineSkip`.
-function createTokenizer$1(parser, initialize, from) {
- var point = from
- ? shallow$3(from)
- : {
- line: 1,
- column: 1,
- offset: 0
- };
- var columnStart = {};
- var resolveAllConstructs = [];
- var chunks = [];
- var stack = [];
-
- var effects = {
- consume: consume,
- enter: enter,
- exit: exit,
- attempt: constructFactory(onsuccessfulconstruct),
- check: constructFactory(onsuccessfulcheck),
- interrupt: constructFactory(onsuccessfulcheck, {
- interrupt: true
- }),
- lazy: constructFactory(onsuccessfulcheck, {
- lazy: true
- })
- }; // State and tools for resolving and serializing.
-
- var context = {
- previous: null,
- events: [],
- parser: parser,
- sliceStream: sliceStream,
- sliceSerialize: sliceSerialize,
- now: now,
- defineSkip: skip,
- write: write
- }; // The state function.
-
- var state = initialize.tokenize.call(context, effects); // Track which character we expect to be consumed, to catch bugs.
-
- if (initialize.resolveAll) {
- resolveAllConstructs.push(initialize);
- } // Store where we are in the input stream.
-
- point._index = 0;
- point._bufferIndex = -1;
- return context
-
- function write(slice) {
- chunks = chunkedPush$2(chunks, slice);
- main(); // Exit if we’re not done, resolve might change stuff.
-
- if (chunks[chunks.length - 1] !== null) {
- return []
- }
-
- addResult(initialize, 0); // Otherwise, resolve, and exit.
-
- context.events = resolveAll$3(resolveAllConstructs, context.events, context);
- return context.events
- } //
- // Tools.
- //
-
- function sliceSerialize(token) {
- return serializeChunks(sliceStream(token))
- }
-
- function sliceStream(token) {
- return sliceChunks(chunks, token)
- }
-
- function now() {
- return shallow$3(point)
- }
-
- function skip(value) {
- columnStart[value.line] = value.column;
- accountForPotentialSkip();
- } //
- // State management.
- //
- // Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
- // `consume`).
- // Here is where we walk through the chunks, which either include strings of
- // several characters, or numerical character codes.
- // The reason to do this in a loop instead of a call is so the stack can
- // drain.
-
- function main() {
- var chunkIndex;
- var chunk;
-
- while (point._index < chunks.length) {
- chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.
-
- if (typeof chunk === 'string') {
- chunkIndex = point._index;
-
- if (point._bufferIndex < 0) {
- point._bufferIndex = 0;
- }
-
- while (
- point._index === chunkIndex &&
- point._bufferIndex < chunk.length
- ) {
- go(chunk.charCodeAt(point._bufferIndex));
- }
- } else {
- go(chunk);
- }
- }
- } // Deal with one code.
-
- function go(code) {
- state = state(code);
- } // Move a character forward.
-
- function consume(code) {
- if (markdownLineEnding$f(code)) {
- point.line++;
- point.column = 1;
- point.offset += code === -3 ? 2 : 1;
- accountForPotentialSkip();
- } else if (code !== -1) {
- point.column++;
- point.offset++;
- } // Not in a string chunk.
-
- if (point._bufferIndex < 0) {
- point._index++;
- } else {
- point._bufferIndex++; // At end of string chunk.
-
- if (point._bufferIndex === chunks[point._index].length) {
- point._bufferIndex = -1;
- point._index++;
- }
- } // Expose the previous character.
-
- context.previous = code; // Mark as consumed.
- } // Start a token.
-
- function enter(type, fields) {
- var token = fields || {};
- token.type = type;
- token.start = now();
- context.events.push(['enter', token, context]);
- stack.push(token);
- return token
- } // Stop a token.
-
- function exit(type) {
- var token = stack.pop();
- token.end = now();
- context.events.push(['exit', token, context]);
- return token
- } // Use results.
-
- function onsuccessfulconstruct(construct, info) {
- addResult(construct, info.from);
- } // Discard results.
-
- function onsuccessfulcheck(construct, info) {
- info.restore();
- } // Factory to attempt/check/interrupt.
-
- function constructFactory(onreturn, fields) {
- return hook // Handle either an object mapping codes to constructs, a list of
- // constructs, or a single construct.
-
- function hook(constructs, returnState, bogusState) {
- var listOfConstructs;
- var constructIndex;
- var currentConstruct;
- var info;
- return constructs.tokenize || 'length' in constructs
- ? handleListOfConstructs(miniflat$1(constructs))
- : handleMapOfConstructs
-
- function handleMapOfConstructs(code) {
- if (code in constructs || null in constructs) {
- return handleListOfConstructs(
- constructs.null
- ? /* c8 ignore next */
- miniflat$1(constructs[code]).concat(miniflat$1(constructs.null))
- : constructs[code]
- )(code)
- }
-
- return bogusState(code)
- }
-
- function handleListOfConstructs(list) {
- listOfConstructs = list;
- constructIndex = 0;
- return handleConstruct(list[constructIndex])
- }
-
- function handleConstruct(construct) {
- return start
-
- function start(code) {
- // To do: not nede to store if there is no bogus state, probably?
- // Currently doesn’t work because `inspect` in document does a check
- // w/o a bogus, which doesn’t make sense. But it does seem to help perf
- // by not storing.
- info = store();
- currentConstruct = construct;
-
- if (!construct.partial) {
- context.currentConstruct = construct;
- }
-
- if (
- construct.name &&
- context.parser.constructs.disable.null.indexOf(construct.name) > -1
- ) {
- return nok()
- }
-
- return construct.tokenize.call(
- fields ? assign$1({}, context, fields) : context,
- effects,
- ok,
- nok
- )(code)
- }
- }
-
- function ok(code) {
- onreturn(currentConstruct, info);
- return returnState
- }
-
- function nok(code) {
- info.restore();
-
- if (++constructIndex < listOfConstructs.length) {
- return handleConstruct(listOfConstructs[constructIndex])
- }
-
- return bogusState
- }
- }
- }
-
- function addResult(construct, from) {
- if (construct.resolveAll && resolveAllConstructs.indexOf(construct) < 0) {
- resolveAllConstructs.push(construct);
- }
-
- if (construct.resolve) {
- chunkedSplice$4(
- context.events,
- from,
- context.events.length - from,
- construct.resolve(context.events.slice(from), context)
- );
- }
-
- if (construct.resolveTo) {
- context.events = construct.resolveTo(context.events, context);
- }
- }
-
- function store() {
- var startPoint = now();
- var startPrevious = context.previous;
- var startCurrentConstruct = context.currentConstruct;
- var startEventsIndex = context.events.length;
- var startStack = Array.from(stack);
- return {
- restore: restore,
- from: startEventsIndex
- }
-
- function restore() {
- point = startPoint;
- context.previous = startPrevious;
- context.currentConstruct = startCurrentConstruct;
- context.events.length = startEventsIndex;
- stack = startStack;
- accountForPotentialSkip();
- }
- }
-
- function accountForPotentialSkip() {
- if (point.line in columnStart && point.column < 2) {
- point.column = columnStart[point.line];
- point.offset += columnStart[point.line] - 1;
- }
- }
-}
-
-var createTokenizer_1 = createTokenizer$1;
-
-var constructs$2 = {};
-
-function markdownLineEndingOrSpace$9(code) {
- return code < 0 || code === 32
-}
-
-var markdownLineEndingOrSpace_1 = markdownLineEndingOrSpace$9;
-
-// This module is generated by `script/`.
-//
-// CommonMark handles attention (emphasis, strong) markers based on what comes
-// before or after them.
-// One such difference is if those characters are Unicode punctuation.
-// This script is generated from the Unicode data.
-var unicodePunctuation$3 = /[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;
-
-var unicodePunctuationRegex$2 = unicodePunctuation$3;
-
-var fromCharCode$1 = fromCharCode_1;
-
-function regexCheck$9(regex) {
- return check
-
- function check(code) {
- return regex.test(fromCharCode$1(code))
- }
-}
-
-var regexCheck_1 = regexCheck$9;
-
-var unicodePunctuationRegex$1 = unicodePunctuationRegex$2;
-var regexCheck$8 = regexCheck_1;
-
-// In fact adds to the bundle size.
-
-var unicodePunctuation$2 = regexCheck$8(unicodePunctuationRegex$1);
-
-var unicodePunctuation_1 = unicodePunctuation$2;
-
-var regexCheck$7 = regexCheck_1;
-
-var unicodeWhitespace$2 = regexCheck$7(/\s/);
-
-var unicodeWhitespace_1 = unicodeWhitespace$2;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Point} Point
+ */
-var markdownLineEndingOrSpace$8 = markdownLineEndingOrSpace_1;
-var unicodePunctuation$1 = unicodePunctuation_1;
-var unicodeWhitespace$1 = unicodeWhitespace_1;
+/** @type {Construct} */
+const attention = {
+ name: 'attention',
+ tokenize: tokenizeAttention,
+ resolveAll: resolveAllAttention
+};
+/**
+ * Take all events and resolve attention to emphasis or strong.
+ *
+ * @type {Resolver}
+ */
-// Classify whether a character is unicode whitespace, unicode punctuation, or
-// anything else.
-// Used for attention (emphasis, strong), whose sequences can open or close
-// based on the class of surrounding characters.
-function classifyCharacter$2(code) {
- if (
- code === null ||
- markdownLineEndingOrSpace$8(code) ||
- unicodeWhitespace$1(code)
- ) {
- return 1
- }
+function resolveAllAttention(events, context) {
+ let index = -1;
+ /** @type {number} */
- if (unicodePunctuation$1(code)) {
- return 2
- }
-}
+ let open;
+ /** @type {Token} */
-var classifyCharacter_1 = classifyCharacter$2;
+ let group;
+ /** @type {Token} */
-// chunks (replacement characters, tabs, or line endings).
+ let text;
+ /** @type {Token} */
-function movePoint$1(point, offset) {
- point.column += offset;
- point.offset += offset;
- point._bufferIndex += offset;
- return point
-}
+ let openingSequence;
+ /** @type {Token} */
-var movePoint_1 = movePoint$1;
+ let closingSequence;
+ /** @type {number} */
-var chunkedPush$1 = chunkedPush_1;
-var chunkedSplice$3 = chunkedSplice_1;
-var classifyCharacter$1 = classifyCharacter_1;
-var movePoint = movePoint_1;
-var resolveAll$2 = resolveAll_1;
-var shallow$2 = shallow_1;
+ let use;
+ /** @type {Event[]} */
-var attention$1 = {
- name: 'attention',
- tokenize: tokenizeAttention,
- resolveAll: resolveAllAttention
-};
+ let nextEvents;
+ /** @type {number} */
-function resolveAllAttention(events, context) {
- var index = -1;
- var open;
- var group;
- var text;
- var openingSequence;
- var closingSequence;
- var use;
- var nextEvents;
- var offset; // Walk through all events.
+ let offset; // Walk through all events.
//
// Note: performance of this is fine on an mb of normal markdown, but it’s
// a bottleneck for malicious stuff.
@@ -30203,54 +34808,58 @@ function resolveAllAttention(events, context) {
events[index][1].end.offset - events[index][1].start.offset > 1
? 2
: 1;
+ const start = Object.assign({}, events[open][1].end);
+ const end = Object.assign({}, events[index][1].start);
+ movePoint(start, -use);
+ movePoint(end, use);
openingSequence = {
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
- start: movePoint(shallow$2(events[open][1].end), -use),
- end: shallow$2(events[open][1].end)
+ start,
+ end: Object.assign({}, events[open][1].end)
};
closingSequence = {
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
- start: shallow$2(events[index][1].start),
- end: movePoint(shallow$2(events[index][1].start), use)
+ start: Object.assign({}, events[index][1].start),
+ end
};
text = {
type: use > 1 ? 'strongText' : 'emphasisText',
- start: shallow$2(events[open][1].end),
- end: shallow$2(events[index][1].start)
+ start: Object.assign({}, events[open][1].end),
+ end: Object.assign({}, events[index][1].start)
};
group = {
type: use > 1 ? 'strong' : 'emphasis',
- start: shallow$2(openingSequence.start),
- end: shallow$2(closingSequence.end)
+ start: Object.assign({}, openingSequence.start),
+ end: Object.assign({}, closingSequence.end)
};
- events[open][1].end = shallow$2(openingSequence.start);
- events[index][1].start = shallow$2(closingSequence.end);
+ events[open][1].end = Object.assign({}, openingSequence.start);
+ events[index][1].start = Object.assign({}, closingSequence.end);
nextEvents = []; // If there are more markers in the opening, add them before.
if (events[open][1].end.offset - events[open][1].start.offset) {
- nextEvents = chunkedPush$1(nextEvents, [
+ nextEvents = push(nextEvents, [
['enter', events[open][1], context],
['exit', events[open][1], context]
]);
} // Opening.
- nextEvents = chunkedPush$1(nextEvents, [
+ nextEvents = push(nextEvents, [
['enter', group, context],
['enter', openingSequence, context],
['exit', openingSequence, context],
['enter', text, context]
]); // Between.
- nextEvents = chunkedPush$1(
+ nextEvents = push(
nextEvents,
- resolveAll$2(
+ resolveAll(
context.parser.constructs.insideSpan.null,
events.slice(open + 1, index),
context
)
); // Closing.
- nextEvents = chunkedPush$1(nextEvents, [
+ nextEvents = push(nextEvents, [
['exit', text, context],
['enter', closingSequence, context],
['exit', closingSequence, context],
@@ -30259,7 +34868,7 @@ function resolveAllAttention(events, context) {
if (events[index][1].end.offset - events[index][1].start.offset) {
offset = 2;
- nextEvents = chunkedPush$1(nextEvents, [
+ nextEvents = push(nextEvents, [
['enter', events[index][1], context],
['exit', events[index][1], context]
]);
@@ -30267,7 +34876,7 @@ function resolveAllAttention(events, context) {
offset = 0;
}
- chunkedSplice$3(events, open - 1, index - open + 3, nextEvents);
+ splice(events, open - 1, index - open + 3, nextEvents);
index = open + nextEvents.length - offset - 2;
break
}
@@ -30285,83 +34894,72 @@ function resolveAllAttention(events, context) {
return events
}
+/** @type {Tokenizer} */
function tokenizeAttention(effects, ok) {
- var before = classifyCharacter$1(this.previous);
- var marker;
+ const before = classifyCharacter(this.previous);
+ /** @type {NonNullable<Code>} */
+
+ let marker;
return start
+ /** @type {State} */
function start(code) {
effects.enter('attentionSequence');
marker = code;
return sequence(code)
}
+ /** @type {State} */
function sequence(code) {
- var token;
- var after;
- var open;
- var close;
-
if (code === marker) {
effects.consume(code);
return sequence
}
- token = effects.exit('attentionSequence');
- after = classifyCharacter$1(code);
- open = !after || (after === 2 && before);
- close = !before || (before === 2 && after);
- token._open = marker === 42 ? open : open && (before || !close);
- token._close = marker === 42 ? close : close && (after || !open);
+ const token = effects.exit('attentionSequence');
+ const after = classifyCharacter(code);
+ const open = !after || (after === 2 && before);
+ const close = !before || (before === 2 && after);
+ token._open = Boolean(marker === 42 ? open : open && (before || !close));
+ token._close = Boolean(marker === 42 ? close : close && (after || !open));
return ok(code)
}
}
+/**
+ * Move a point a bit.
+ *
+ * Note: `move` only works inside lines! It’s not possible to move past other
+ * chunks (replacement characters, tabs, or line endings).
+ *
+ * @param {Point} point
+ * @param {number} offset
+ * @returns {void}
+ */
-var attention_1 = attention$1;
-
-var regexCheck$6 = regexCheck_1;
-
-var asciiAlpha$4 = regexCheck$6(/[A-Za-z]/);
-
-var asciiAlpha_1 = asciiAlpha$4;
-
-var regexCheck$5 = regexCheck_1;
-
-var asciiAlphanumeric$5 = regexCheck$5(/[\dA-Za-z]/);
-
-var asciiAlphanumeric_1 = asciiAlphanumeric$5;
-
-var regexCheck$4 = regexCheck_1;
-
-var asciiAtext$1 = regexCheck$4(/[#-'*+\--9=?A-Z^-~]/);
-
-var asciiAtext_1 = asciiAtext$1;
-
-// Note: EOF is seen as ASCII control here, because `null < 32 == true`.
-function asciiControl$3(code) {
- return (
- // Special whitespace codes (which have negative values), C0 and Control
- // character DEL
- code < 32 || code === 127
- )
+function movePoint(point, offset) {
+ point.column += offset;
+ point.offset += offset;
+ point._bufferIndex += offset;
}
-var asciiControl_1 = asciiControl$3;
-
-var asciiAlpha$3 = asciiAlpha_1;
-var asciiAlphanumeric$4 = asciiAlphanumeric_1;
-var asciiAtext = asciiAtext_1;
-var asciiControl$2 = asciiControl_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
-var autolink$1 = {
+/** @type {Construct} */
+const autolink = {
name: 'autolink',
tokenize: tokenizeAutolink
};
+/** @type {Tokenizer} */
function tokenizeAutolink(effects, ok, nok) {
- var size = 1;
+ let size = 1;
return start
+ /** @type {State} */
function start(code) {
effects.enter('autolink');
@@ -30371,21 +34969,24 @@ function tokenizeAutolink(effects, ok, nok) {
effects.enter('autolinkProtocol');
return open
}
+ /** @type {State} */
function open(code) {
- if (asciiAlpha$3(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
return schemeOrEmailAtext
}
return asciiAtext(code) ? emailAtext(code) : nok(code)
}
+ /** @type {State} */
function schemeOrEmailAtext(code) {
- return code === 43 || code === 45 || code === 46 || asciiAlphanumeric$4(code)
+ return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)
? schemeInsideOrEmailAtext(code)
: emailAtext(code)
}
+ /** @type {State} */
function schemeInsideOrEmailAtext(code) {
if (code === 58) {
@@ -30394,7 +34995,7 @@ function tokenizeAutolink(effects, ok, nok) {
}
if (
- (code === 43 || code === 45 || code === 46 || asciiAlphanumeric$4(code)) &&
+ (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&
size++ < 32
) {
effects.consume(code);
@@ -30403,6 +35004,7 @@ function tokenizeAutolink(effects, ok, nok) {
return emailAtext(code)
}
+ /** @type {State} */
function urlInside(code) {
if (code === 62) {
@@ -30410,13 +35012,14 @@ function tokenizeAutolink(effects, ok, nok) {
return end(code)
}
- if (code === 32 || code === 60 || asciiControl$2(code)) {
+ if (code === null || code === 32 || code === 60 || asciiControl(code)) {
return nok(code)
}
effects.consume(code);
return urlInside
}
+ /** @type {State} */
function emailAtext(code) {
if (code === 64) {
@@ -30432,10 +35035,12 @@ function tokenizeAutolink(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function emailAtSignOrDot(code) {
- return asciiAlphanumeric$4(code) ? emailLabel(code) : nok(code)
+ return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)
}
+ /** @type {State} */
function emailLabel(code) {
if (code === 46) {
@@ -30452,15 +35057,17 @@ function tokenizeAutolink(effects, ok, nok) {
return emailValue(code)
}
+ /** @type {State} */
function emailValue(code) {
- if ((code === 45 || asciiAlphanumeric$4(code)) && size++ < 63) {
+ if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
effects.consume(code);
return code === 45 ? emailValue : emailLabel
}
return nok(code)
}
+ /** @type {State} */
function end(code) {
effects.enter('autolinkMarker');
@@ -30471,12 +35078,37 @@ function tokenizeAutolink(effects, ok, nok) {
}
}
-var autolink_1 = autolink$1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {Construct} */
+const blankLine = {
+ tokenize: tokenizeBlankLine,
+ partial: true
+};
+/** @type {Tokenizer} */
-var markdownSpace$8 = markdownSpace_1;
-var factorySpace$c = factorySpace$i;
+function tokenizeBlankLine(effects, ok, nok) {
+ return factorySpace(effects, afterWhitespace, 'linePrefix')
+ /** @type {State} */
+
+ function afterWhitespace(code) {
+ return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
+ }
+}
-var blockQuote$1 = {
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Exiter} Exiter
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {Construct} */
+const blockQuote = {
name: 'blockQuote',
tokenize: tokenizeBlockQuoteStart,
continuation: {
@@ -30484,18 +35116,22 @@ var blockQuote$1 = {
},
exit: exit$1
};
+/** @type {Tokenizer} */
function tokenizeBlockQuoteStart(effects, ok, nok) {
- var self = this;
+ const self = this;
return start
+ /** @type {State} */
function start(code) {
if (code === 62) {
- if (!self.containerState.open) {
+ const state = self.containerState;
+
+ if (!state.open) {
effects.enter('blockQuote', {
_container: true
});
- self.containerState.open = true;
+ state.open = true;
}
effects.enter('blockQuotePrefix');
@@ -30507,9 +35143,10 @@ function tokenizeBlockQuoteStart(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function after(code) {
- if (markdownSpace$8(code)) {
+ if (markdownSpace(code)) {
effects.enter('blockQuotePrefixWhitespace');
effects.consume(code);
effects.exit('blockQuotePrefixWhitespace');
@@ -30521,39 +35158,38 @@ function tokenizeBlockQuoteStart(effects, ok, nok) {
return ok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeBlockQuoteContinuation(effects, ok, nok) {
- return factorySpace$c(
+ return factorySpace(
effects,
- effects.attempt(blockQuote$1, ok, nok),
+ effects.attempt(blockQuote, ok, nok),
'linePrefix',
- this.parser.constructs.disable.null.indexOf('codeIndented') > -1
- ? undefined
- : 4
+ this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
)
}
+/** @type {Exiter} */
function exit$1(effects) {
effects.exit('blockQuote');
}
-var blockQuote_1 = blockQuote$1;
-
-var regexCheck$3 = regexCheck_1;
-
-var asciiPunctuation$1 = regexCheck$3(/[!-/:-@[-`{-~]/);
-
-var asciiPunctuation_1 = asciiPunctuation$1;
-
-var asciiPunctuation = asciiPunctuation_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
-var characterEscape$2 = {
+/** @type {Construct} */
+const characterEscape$1 = {
name: 'characterEscape',
tokenize: tokenizeCharacterEscape
};
+/** @type {Tokenizer} */
function tokenizeCharacterEscape(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
effects.enter('characterEscape');
@@ -30562,6 +35198,7 @@ function tokenizeCharacterEscape(effects, ok, nok) {
effects.exit('escapeMarker');
return open
}
+ /** @type {State} */
function open(code) {
if (asciiPunctuation(code)) {
@@ -30576,4499 +35213,2269 @@ function tokenizeCharacterEscape(effects, ok, nok) {
}
}
-var characterEscape_1 = characterEscape$2;
-
-const AEli$2 = "Æ";
-const AElig$2 = "Æ";
-const AM$2 = "&";
-const AMP$2 = "&";
-const Aacut$2 = "Á";
-const Aacute$2 = "Á";
-const Abreve$2 = "Ă";
-const Acir$2 = "Â";
-const Acirc$2 = "Â";
-const Acy$2 = "А";
-const Afr$2 = "𝔄";
-const Agrav$2 = "À";
-const Agrave$2 = "À";
-const Alpha$2 = "Α";
-const Amacr$2 = "Ā";
-const And$2 = "⩓";
-const Aogon$2 = "Ą";
-const Aopf$2 = "𝔸";
-const ApplyFunction$2 = "⁡";
-const Arin$2 = "Å";
-const Aring$2 = "Å";
-const Ascr$2 = "𝒜";
-const Assign$2 = "≔";
-const Atild$2 = "Ã";
-const Atilde$2 = "Ã";
-const Aum$2 = "Ä";
-const Auml$2 = "Ä";
-const Backslash$2 = "∖";
-const Barv$2 = "⫧";
-const Barwed$2 = "⌆";
-const Bcy$2 = "Б";
-const Because$2 = "∵";
-const Bernoullis$2 = "ℬ";
-const Beta$2 = "Β";
-const Bfr$2 = "𝔅";
-const Bopf$2 = "𝔹";
-const Breve$2 = "˘";
-const Bscr$2 = "ℬ";
-const Bumpeq$2 = "≎";
-const CHcy$2 = "Ч";
-const COP$2 = "©";
-const COPY$2 = "©";
-const Cacute$2 = "Ć";
-const Cap$2 = "⋒";
-const CapitalDifferentialD$2 = "ⅅ";
-const Cayleys$2 = "ℭ";
-const Ccaron$2 = "Č";
-const Ccedi$2 = "Ç";
-const Ccedil$2 = "Ç";
-const Ccirc$2 = "Ĉ";
-const Cconint$2 = "∰";
-const Cdot$2 = "Ċ";
-const Cedilla$2 = "¸";
-const CenterDot$2 = "·";
-const Cfr$2 = "ℭ";
-const Chi$2 = "Χ";
-const CircleDot$2 = "⊙";
-const CircleMinus$2 = "⊖";
-const CirclePlus$2 = "⊕";
-const CircleTimes$2 = "⊗";
-const ClockwiseContourIntegral$2 = "∲";
-const CloseCurlyDoubleQuote$2 = "”";
-const CloseCurlyQuote$2 = "’";
-const Colon$2 = "∷";
-const Colone$2 = "⩴";
-const Congruent$2 = "≡";
-const Conint$2 = "∯";
-const ContourIntegral$2 = "∮";
-const Copf$2 = "ℂ";
-const Coproduct$2 = "∐";
-const CounterClockwiseContourIntegral$2 = "∳";
-const Cross$2 = "⨯";
-const Cscr$2 = "𝒞";
-const Cup$2 = "⋓";
-const CupCap$2 = "≍";
-const DD$2 = "ⅅ";
-const DDotrahd$2 = "⤑";
-const DJcy$2 = "Ђ";
-const DScy$2 = "Ѕ";
-const DZcy$2 = "Џ";
-const Dagger$2 = "‡";
-const Darr$2 = "↡";
-const Dashv$2 = "⫤";
-const Dcaron$2 = "Ď";
-const Dcy$2 = "Д";
-const Del$2 = "∇";
-const Delta$2 = "Δ";
-const Dfr$2 = "𝔇";
-const DiacriticalAcute$2 = "´";
-const DiacriticalDot$2 = "˙";
-const DiacriticalDoubleAcute$2 = "˝";
-const DiacriticalGrave$2 = "`";
-const DiacriticalTilde$2 = "˜";
-const Diamond$2 = "⋄";
-const DifferentialD$2 = "ⅆ";
-const Dopf$2 = "𝔻";
-const Dot$2 = "¨";
-const DotDot$2 = "⃜";
-const DotEqual$2 = "≐";
-const DoubleContourIntegral$2 = "∯";
-const DoubleDot$2 = "¨";
-const DoubleDownArrow$2 = "⇓";
-const DoubleLeftArrow$2 = "⇐";
-const DoubleLeftRightArrow$2 = "⇔";
-const DoubleLeftTee$2 = "⫤";
-const DoubleLongLeftArrow$2 = "⟸";
-const DoubleLongLeftRightArrow$2 = "⟺";
-const DoubleLongRightArrow$2 = "⟹";
-const DoubleRightArrow$2 = "⇒";
-const DoubleRightTee$2 = "⊨";
-const DoubleUpArrow$2 = "⇑";
-const DoubleUpDownArrow$2 = "⇕";
-const DoubleVerticalBar$2 = "∥";
-const DownArrow$2 = "↓";
-const DownArrowBar$2 = "⤓";
-const DownArrowUpArrow$2 = "⇵";
-const DownBreve$2 = "̑";
-const DownLeftRightVector$2 = "⥐";
-const DownLeftTeeVector$2 = "⥞";
-const DownLeftVector$2 = "↽";
-const DownLeftVectorBar$2 = "⥖";
-const DownRightTeeVector$2 = "⥟";
-const DownRightVector$2 = "⇁";
-const DownRightVectorBar$2 = "⥗";
-const DownTee$2 = "⊤";
-const DownTeeArrow$2 = "↧";
-const Downarrow$2 = "⇓";
-const Dscr$2 = "𝒟";
-const Dstrok$2 = "Đ";
-const ENG$2 = "Ŋ";
-const ET$2 = "Ð";
-const ETH$2 = "Ð";
-const Eacut$2 = "É";
-const Eacute$2 = "É";
-const Ecaron$2 = "Ě";
-const Ecir$2 = "Ê";
-const Ecirc$2 = "Ê";
-const Ecy$2 = "Э";
-const Edot$2 = "Ė";
-const Efr$2 = "𝔈";
-const Egrav$2 = "È";
-const Egrave$2 = "È";
-const Element$2 = "∈";
-const Emacr$2 = "Ē";
-const EmptySmallSquare$2 = "◻";
-const EmptyVerySmallSquare$2 = "▫";
-const Eogon$2 = "Ę";
-const Eopf$2 = "𝔼";
-const Epsilon$2 = "Ε";
-const Equal$2 = "⩵";
-const EqualTilde$2 = "≂";
-const Equilibrium$2 = "⇌";
-const Escr$2 = "ℰ";
-const Esim$2 = "⩳";
-const Eta$2 = "Η";
-const Eum$2 = "Ë";
-const Euml$2 = "Ë";
-const Exists$2 = "∃";
-const ExponentialE$2 = "ⅇ";
-const Fcy$2 = "Ф";
-const Ffr$2 = "𝔉";
-const FilledSmallSquare$2 = "◼";
-const FilledVerySmallSquare$2 = "▪";
-const Fopf$2 = "𝔽";
-const ForAll$2 = "∀";
-const Fouriertrf$2 = "ℱ";
-const Fscr$2 = "ℱ";
-const GJcy$2 = "Ѓ";
-const G$2 = ">";
-const GT$2 = ">";
-const Gamma$2 = "Γ";
-const Gammad$2 = "Ϝ";
-const Gbreve$2 = "Ğ";
-const Gcedil$2 = "Ģ";
-const Gcirc$2 = "Ĝ";
-const Gcy$2 = "Г";
-const Gdot$2 = "Ġ";
-const Gfr$2 = "𝔊";
-const Gg$2 = "⋙";
-const Gopf$2 = "𝔾";
-const GreaterEqual$2 = "≥";
-const GreaterEqualLess$2 = "⋛";
-const GreaterFullEqual$2 = "≧";
-const GreaterGreater$2 = "⪢";
-const GreaterLess$2 = "≷";
-const GreaterSlantEqual$2 = "⩾";
-const GreaterTilde$2 = "≳";
-const Gscr$2 = "𝒢";
-const Gt$2 = "≫";
-const HARDcy$2 = "Ъ";
-const Hacek$2 = "ˇ";
-const Hat$2 = "^";
-const Hcirc$2 = "Ĥ";
-const Hfr$2 = "ℌ";
-const HilbertSpace$2 = "ℋ";
-const Hopf$2 = "ℍ";
-const HorizontalLine$2 = "─";
-const Hscr$2 = "ℋ";
-const Hstrok$2 = "Ħ";
-const HumpDownHump$2 = "≎";
-const HumpEqual$2 = "≏";
-const IEcy$2 = "Е";
-const IJlig$2 = "IJ";
-const IOcy$2 = "Ё";
-const Iacut$2 = "Í";
-const Iacute$2 = "Í";
-const Icir$2 = "Î";
-const Icirc$2 = "Î";
-const Icy$2 = "И";
-const Idot$2 = "İ";
-const Ifr$2 = "ℑ";
-const Igrav$2 = "Ì";
-const Igrave$2 = "Ì";
-const Im$2 = "ℑ";
-const Imacr$2 = "Ī";
-const ImaginaryI$2 = "ⅈ";
-const Implies$2 = "⇒";
-const Int$2 = "∬";
-const Integral$2 = "∫";
-const Intersection$2 = "⋂";
-const InvisibleComma$2 = "⁣";
-const InvisibleTimes$2 = "⁢";
-const Iogon$2 = "Į";
-const Iopf$2 = "𝕀";
-const Iota$2 = "Ι";
-const Iscr$2 = "ℐ";
-const Itilde$2 = "Ĩ";
-const Iukcy$2 = "І";
-const Ium$2 = "Ï";
-const Iuml$2 = "Ï";
-const Jcirc$2 = "Ĵ";
-const Jcy$2 = "Й";
-const Jfr$2 = "𝔍";
-const Jopf$2 = "𝕁";
-const Jscr$2 = "𝒥";
-const Jsercy$2 = "Ј";
-const Jukcy$2 = "Є";
-const KHcy$2 = "Х";
-const KJcy$2 = "Ќ";
-const Kappa$2 = "Κ";
-const Kcedil$2 = "Ķ";
-const Kcy$2 = "К";
-const Kfr$2 = "𝔎";
-const Kopf$2 = "𝕂";
-const Kscr$2 = "𝒦";
-const LJcy$2 = "Љ";
-const L$2 = "<";
-const LT$2 = "<";
-const Lacute$2 = "Ĺ";
-const Lambda$2 = "Λ";
-const Lang$2 = "⟪";
-const Laplacetrf$2 = "ℒ";
-const Larr$2 = "↞";
-const Lcaron$2 = "Ľ";
-const Lcedil$2 = "Ļ";
-const Lcy$2 = "Л";
-const LeftAngleBracket$2 = "⟨";
-const LeftArrow$2 = "←";
-const LeftArrowBar$2 = "⇤";
-const LeftArrowRightArrow$2 = "⇆";
-const LeftCeiling$2 = "⌈";
-const LeftDoubleBracket$2 = "⟦";
-const LeftDownTeeVector$2 = "⥡";
-const LeftDownVector$2 = "⇃";
-const LeftDownVectorBar$2 = "⥙";
-const LeftFloor$2 = "⌊";
-const LeftRightArrow$2 = "↔";
-const LeftRightVector$2 = "⥎";
-const LeftTee$2 = "⊣";
-const LeftTeeArrow$2 = "↤";
-const LeftTeeVector$2 = "⥚";
-const LeftTriangle$2 = "⊲";
-const LeftTriangleBar$2 = "⧏";
-const LeftTriangleEqual$2 = "⊴";
-const LeftUpDownVector$2 = "⥑";
-const LeftUpTeeVector$2 = "⥠";
-const LeftUpVector$2 = "↿";
-const LeftUpVectorBar$2 = "⥘";
-const LeftVector$2 = "↼";
-const LeftVectorBar$2 = "⥒";
-const Leftarrow$2 = "⇐";
-const Leftrightarrow$2 = "⇔";
-const LessEqualGreater$2 = "⋚";
-const LessFullEqual$2 = "≦";
-const LessGreater$2 = "≶";
-const LessLess$2 = "⪡";
-const LessSlantEqual$2 = "⩽";
-const LessTilde$2 = "≲";
-const Lfr$2 = "𝔏";
-const Ll$2 = "⋘";
-const Lleftarrow$2 = "⇚";
-const Lmidot$2 = "Ŀ";
-const LongLeftArrow$2 = "⟵";
-const LongLeftRightArrow$2 = "⟷";
-const LongRightArrow$2 = "⟶";
-const Longleftarrow$2 = "⟸";
-const Longleftrightarrow$2 = "⟺";
-const Longrightarrow$2 = "⟹";
-const Lopf$2 = "𝕃";
-const LowerLeftArrow$2 = "↙";
-const LowerRightArrow$2 = "↘";
-const Lscr$2 = "ℒ";
-const Lsh$2 = "↰";
-const Lstrok$2 = "Ł";
-const Lt$2 = "≪";
-const Mcy$2 = "М";
-const MediumSpace$2 = " ";
-const Mellintrf$2 = "ℳ";
-const Mfr$2 = "𝔐";
-const MinusPlus$2 = "∓";
-const Mopf$2 = "𝕄";
-const Mscr$2 = "ℳ";
-const Mu$2 = "Μ";
-const NJcy$2 = "Њ";
-const Nacute$2 = "Ń";
-const Ncaron$2 = "Ň";
-const Ncedil$2 = "Ņ";
-const Ncy$2 = "Н";
-const NegativeMediumSpace$2 = "​";
-const NegativeThickSpace$2 = "​";
-const NegativeThinSpace$2 = "​";
-const NegativeVeryThinSpace$2 = "​";
-const NestedGreaterGreater$2 = "≫";
-const NestedLessLess$2 = "≪";
-const NewLine$2 = "\n";
-const Nfr$2 = "𝔑";
-const NoBreak$2 = "⁠";
-const NonBreakingSpace$2 = " ";
-const Nopf$2 = "ℕ";
-const Not$2 = "⫬";
-const NotCongruent$2 = "≢";
-const NotCupCap$2 = "≭";
-const NotDoubleVerticalBar$2 = "∦";
-const NotElement$2 = "∉";
-const NotEqual$2 = "≠";
-const NotEqualTilde$2 = "≂̸";
-const NotExists$2 = "∄";
-const NotGreater$2 = "≯";
-const NotGreaterEqual$2 = "≱";
-const NotGreaterFullEqual$2 = "≧̸";
-const NotGreaterGreater$2 = "≫̸";
-const NotGreaterLess$2 = "≹";
-const NotGreaterSlantEqual$2 = "⩾̸";
-const NotGreaterTilde$2 = "≵";
-const NotHumpDownHump$2 = "≎̸";
-const NotHumpEqual$2 = "≏̸";
-const NotLeftTriangle$2 = "⋪";
-const NotLeftTriangleBar$2 = "⧏̸";
-const NotLeftTriangleEqual$2 = "⋬";
-const NotLess$2 = "≮";
-const NotLessEqual$2 = "≰";
-const NotLessGreater$2 = "≸";
-const NotLessLess$2 = "≪̸";
-const NotLessSlantEqual$2 = "⩽̸";
-const NotLessTilde$2 = "≴";
-const NotNestedGreaterGreater$2 = "⪢̸";
-const NotNestedLessLess$2 = "⪡̸";
-const NotPrecedes$2 = "⊀";
-const NotPrecedesEqual$2 = "⪯̸";
-const NotPrecedesSlantEqual$2 = "⋠";
-const NotReverseElement$2 = "∌";
-const NotRightTriangle$2 = "⋫";
-const NotRightTriangleBar$2 = "⧐̸";
-const NotRightTriangleEqual$2 = "⋭";
-const NotSquareSubset$2 = "⊏̸";
-const NotSquareSubsetEqual$2 = "⋢";
-const NotSquareSuperset$2 = "⊐̸";
-const NotSquareSupersetEqual$2 = "⋣";
-const NotSubset$2 = "⊂⃒";
-const NotSubsetEqual$2 = "⊈";
-const NotSucceeds$2 = "⊁";
-const NotSucceedsEqual$2 = "⪰̸";
-const NotSucceedsSlantEqual$2 = "⋡";
-const NotSucceedsTilde$2 = "≿̸";
-const NotSuperset$2 = "⊃⃒";
-const NotSupersetEqual$2 = "⊉";
-const NotTilde$2 = "≁";
-const NotTildeEqual$2 = "≄";
-const NotTildeFullEqual$2 = "≇";
-const NotTildeTilde$2 = "≉";
-const NotVerticalBar$2 = "∤";
-const Nscr$2 = "𝒩";
-const Ntild$2 = "Ñ";
-const Ntilde$2 = "Ñ";
-const Nu$2 = "Ν";
-const OElig$2 = "Œ";
-const Oacut$2 = "Ó";
-const Oacute$2 = "Ó";
-const Ocir$2 = "Ô";
-const Ocirc$2 = "Ô";
-const Ocy$2 = "О";
-const Odblac$2 = "Ő";
-const Ofr$2 = "𝔒";
-const Ograv$2 = "Ò";
-const Ograve$2 = "Ò";
-const Omacr$2 = "Ō";
-const Omega$2 = "Ω";
-const Omicron$2 = "Ο";
-const Oopf$2 = "𝕆";
-const OpenCurlyDoubleQuote$2 = "“";
-const OpenCurlyQuote$2 = "‘";
-const Or$2 = "⩔";
-const Oscr$2 = "𝒪";
-const Oslas$2 = "Ø";
-const Oslash$2 = "Ø";
-const Otild$2 = "Õ";
-const Otilde$2 = "Õ";
-const Otimes$2 = "⨷";
-const Oum$2 = "Ö";
-const Ouml$2 = "Ö";
-const OverBar$2 = "‾";
-const OverBrace$2 = "⏞";
-const OverBracket$2 = "⎴";
-const OverParenthesis$2 = "⏜";
-const PartialD$2 = "∂";
-const Pcy$2 = "П";
-const Pfr$2 = "𝔓";
-const Phi$2 = "Φ";
-const Pi$2 = "Π";
-const PlusMinus$2 = "±";
-const Poincareplane$2 = "ℌ";
-const Popf$2 = "ℙ";
-const Pr$2 = "⪻";
-const Precedes$2 = "≺";
-const PrecedesEqual$2 = "⪯";
-const PrecedesSlantEqual$2 = "≼";
-const PrecedesTilde$2 = "≾";
-const Prime$2 = "″";
-const Product$2 = "∏";
-const Proportion$2 = "∷";
-const Proportional$2 = "∝";
-const Pscr$2 = "𝒫";
-const Psi$2 = "Ψ";
-const QUO$2 = "\"";
-const QUOT$2 = "\"";
-const Qfr$2 = "𝔔";
-const Qopf$2 = "ℚ";
-const Qscr$2 = "𝒬";
-const RBarr$2 = "⤐";
-const RE$2 = "®";
-const REG$2 = "®";
-const Racute$2 = "Ŕ";
-const Rang$2 = "⟫";
-const Rarr$2 = "↠";
-const Rarrtl$2 = "⤖";
-const Rcaron$2 = "Ř";
-const Rcedil$2 = "Ŗ";
-const Rcy$2 = "Р";
-const Re$2 = "ℜ";
-const ReverseElement$2 = "∋";
-const ReverseEquilibrium$2 = "⇋";
-const ReverseUpEquilibrium$2 = "⥯";
-const Rfr$2 = "ℜ";
-const Rho$2 = "Ρ";
-const RightAngleBracket$2 = "⟩";
-const RightArrow$2 = "→";
-const RightArrowBar$2 = "⇥";
-const RightArrowLeftArrow$2 = "⇄";
-const RightCeiling$2 = "⌉";
-const RightDoubleBracket$2 = "⟧";
-const RightDownTeeVector$2 = "⥝";
-const RightDownVector$2 = "⇂";
-const RightDownVectorBar$2 = "⥕";
-const RightFloor$2 = "⌋";
-const RightTee$2 = "⊢";
-const RightTeeArrow$2 = "↦";
-const RightTeeVector$2 = "⥛";
-const RightTriangle$2 = "⊳";
-const RightTriangleBar$2 = "⧐";
-const RightTriangleEqual$2 = "⊵";
-const RightUpDownVector$2 = "⥏";
-const RightUpTeeVector$2 = "⥜";
-const RightUpVector$2 = "↾";
-const RightUpVectorBar$2 = "⥔";
-const RightVector$2 = "⇀";
-const RightVectorBar$2 = "⥓";
-const Rightarrow$2 = "⇒";
-const Ropf$2 = "ℝ";
-const RoundImplies$2 = "⥰";
-const Rrightarrow$2 = "⇛";
-const Rscr$2 = "ℛ";
-const Rsh$2 = "↱";
-const RuleDelayed$2 = "⧴";
-const SHCHcy$2 = "Щ";
-const SHcy$2 = "Ш";
-const SOFTcy$2 = "Ь";
-const Sacute$2 = "Ś";
-const Sc$2 = "⪼";
-const Scaron$2 = "Š";
-const Scedil$2 = "Ş";
-const Scirc$2 = "Ŝ";
-const Scy$2 = "С";
-const Sfr$2 = "𝔖";
-const ShortDownArrow$2 = "↓";
-const ShortLeftArrow$2 = "←";
-const ShortRightArrow$2 = "→";
-const ShortUpArrow$2 = "↑";
-const Sigma$2 = "Σ";
-const SmallCircle$2 = "∘";
-const Sopf$2 = "𝕊";
-const Sqrt$2 = "√";
-const Square$2 = "□";
-const SquareIntersection$2 = "⊓";
-const SquareSubset$2 = "⊏";
-const SquareSubsetEqual$2 = "⊑";
-const SquareSuperset$2 = "⊐";
-const SquareSupersetEqual$2 = "⊒";
-const SquareUnion$2 = "⊔";
-const Sscr$2 = "𝒮";
-const Star$2 = "⋆";
-const Sub$2 = "⋐";
-const Subset$2 = "⋐";
-const SubsetEqual$2 = "⊆";
-const Succeeds$2 = "≻";
-const SucceedsEqual$2 = "⪰";
-const SucceedsSlantEqual$2 = "≽";
-const SucceedsTilde$2 = "≿";
-const SuchThat$2 = "∋";
-const Sum$2 = "∑";
-const Sup$2 = "⋑";
-const Superset$2 = "⊃";
-const SupersetEqual$2 = "⊇";
-const Supset$2 = "⋑";
-const THOR$2 = "Þ";
-const THORN$2 = "Þ";
-const TRADE$2 = "™";
-const TSHcy$2 = "Ћ";
-const TScy$2 = "Ц";
-const Tab$2 = "\t";
-const Tau$2 = "Τ";
-const Tcaron$2 = "Ť";
-const Tcedil$2 = "Ţ";
-const Tcy$2 = "Т";
-const Tfr$2 = "𝔗";
-const Therefore$2 = "∴";
-const Theta$2 = "Θ";
-const ThickSpace$2 = "  ";
-const ThinSpace$2 = " ";
-const Tilde$2 = "∼";
-const TildeEqual$2 = "≃";
-const TildeFullEqual$2 = "≅";
-const TildeTilde$2 = "≈";
-const Topf$2 = "𝕋";
-const TripleDot$2 = "⃛";
-const Tscr$2 = "𝒯";
-const Tstrok$2 = "Ŧ";
-const Uacut$2 = "Ú";
-const Uacute$2 = "Ú";
-const Uarr$2 = "↟";
-const Uarrocir$2 = "⥉";
-const Ubrcy$2 = "Ў";
-const Ubreve$2 = "Ŭ";
-const Ucir$2 = "Û";
-const Ucirc$2 = "Û";
-const Ucy$2 = "У";
-const Udblac$2 = "Ű";
-const Ufr$2 = "𝔘";
-const Ugrav$2 = "Ù";
-const Ugrave$2 = "Ù";
-const Umacr$2 = "Ū";
-const UnderBar$2 = "_";
-const UnderBrace$2 = "⏟";
-const UnderBracket$2 = "⎵";
-const UnderParenthesis$2 = "⏝";
-const Union$2 = "⋃";
-const UnionPlus$2 = "⊎";
-const Uogon$2 = "Ų";
-const Uopf$2 = "𝕌";
-const UpArrow$2 = "↑";
-const UpArrowBar$2 = "⤒";
-const UpArrowDownArrow$2 = "⇅";
-const UpDownArrow$2 = "↕";
-const UpEquilibrium$2 = "⥮";
-const UpTee$2 = "⊥";
-const UpTeeArrow$2 = "↥";
-const Uparrow$2 = "⇑";
-const Updownarrow$2 = "⇕";
-const UpperLeftArrow$2 = "↖";
-const UpperRightArrow$2 = "↗";
-const Upsi$2 = "ϒ";
-const Upsilon$2 = "Υ";
-const Uring$2 = "Ů";
-const Uscr$2 = "𝒰";
-const Utilde$2 = "Ũ";
-const Uum$2 = "Ü";
-const Uuml$2 = "Ü";
-const VDash$2 = "⊫";
-const Vbar$2 = "⫫";
-const Vcy$2 = "В";
-const Vdash$2 = "⊩";
-const Vdashl$2 = "⫦";
-const Vee$2 = "⋁";
-const Verbar$2 = "‖";
-const Vert$2 = "‖";
-const VerticalBar$2 = "∣";
-const VerticalLine$2 = "|";
-const VerticalSeparator$2 = "❘";
-const VerticalTilde$2 = "≀";
-const VeryThinSpace$2 = " ";
-const Vfr$2 = "𝔙";
-const Vopf$2 = "𝕍";
-const Vscr$2 = "𝒱";
-const Vvdash$2 = "⊪";
-const Wcirc$2 = "Ŵ";
-const Wedge$2 = "⋀";
-const Wfr$2 = "𝔚";
-const Wopf$2 = "𝕎";
-const Wscr$2 = "𝒲";
-const Xfr$2 = "𝔛";
-const Xi$2 = "Ξ";
-const Xopf$2 = "𝕏";
-const Xscr$2 = "𝒳";
-const YAcy$2 = "Я";
-const YIcy$2 = "Ї";
-const YUcy$2 = "Ю";
-const Yacut$2 = "Ý";
-const Yacute$2 = "Ý";
-const Ycirc$2 = "Ŷ";
-const Ycy$2 = "Ы";
-const Yfr$2 = "𝔜";
-const Yopf$2 = "𝕐";
-const Yscr$2 = "𝒴";
-const Yuml$2 = "Ÿ";
-const ZHcy$2 = "Ж";
-const Zacute$2 = "Ź";
-const Zcaron$2 = "Ž";
-const Zcy$2 = "З";
-const Zdot$2 = "Ż";
-const ZeroWidthSpace$2 = "​";
-const Zeta$2 = "Ζ";
-const Zfr$2 = "ℨ";
-const Zopf$2 = "ℤ";
-const Zscr$2 = "𝒵";
-const aacut$2 = "á";
-const aacute$2 = "á";
-const abreve$2 = "ă";
-const ac$2 = "∾";
-const acE$2 = "∾̳";
-const acd$2 = "∿";
-const acir$2 = "â";
-const acirc$2 = "â";
-const acut$2 = "´";
-const acute$2 = "´";
-const acy$2 = "а";
-const aeli$2 = "æ";
-const aelig$2 = "æ";
-const af$2 = "⁡";
-const afr$2 = "𝔞";
-const agrav$2 = "à";
-const agrave$2 = "à";
-const alefsym$2 = "ℵ";
-const aleph$2 = "ℵ";
-const alpha$2 = "α";
-const amacr$2 = "ā";
-const amalg$2 = "⨿";
-const am$2 = "&";
-const amp$2 = "&";
-const and$2 = "∧";
-const andand$2 = "⩕";
-const andd$2 = "⩜";
-const andslope$2 = "⩘";
-const andv$2 = "⩚";
-const ang$2 = "∠";
-const ange$2 = "⦤";
-const angle$2 = "∠";
-const angmsd$2 = "∡";
-const angmsdaa$2 = "⦨";
-const angmsdab$2 = "⦩";
-const angmsdac$2 = "⦪";
-const angmsdad$2 = "⦫";
-const angmsdae$2 = "⦬";
-const angmsdaf$2 = "⦭";
-const angmsdag$2 = "⦮";
-const angmsdah$2 = "⦯";
-const angrt$2 = "∟";
-const angrtvb$2 = "⊾";
-const angrtvbd$2 = "⦝";
-const angsph$2 = "∢";
-const angst$2 = "Å";
-const angzarr$2 = "⍼";
-const aogon$2 = "ą";
-const aopf$2 = "𝕒";
-const ap$2 = "≈";
-const apE$2 = "⩰";
-const apacir$2 = "⩯";
-const ape$2 = "≊";
-const apid$2 = "≋";
-const apos$2 = "'";
-const approx$2 = "≈";
-const approxeq$2 = "≊";
-const arin$2 = "å";
-const aring$2 = "å";
-const ascr$2 = "𝒶";
-const ast$2 = "*";
-const asymp$2 = "≈";
-const asympeq$2 = "≍";
-const atild$2 = "ã";
-const atilde$2 = "ã";
-const aum$2 = "ä";
-const auml$2 = "ä";
-const awconint$2 = "∳";
-const awint$2 = "⨑";
-const bNot$2 = "⫭";
-const backcong$2 = "≌";
-const backepsilon$2 = "϶";
-const backprime$2 = "‵";
-const backsim$2 = "∽";
-const backsimeq$2 = "⋍";
-const barvee$2 = "⊽";
-const barwed$2 = "⌅";
-const barwedge$2 = "⌅";
-const bbrk$2 = "⎵";
-const bbrktbrk$2 = "⎶";
-const bcong$2 = "≌";
-const bcy$2 = "б";
-const bdquo$2 = "„";
-const becaus$2 = "∵";
-const because$2 = "∵";
-const bemptyv$2 = "⦰";
-const bepsi$2 = "϶";
-const bernou$2 = "ℬ";
-const beta$2 = "β";
-const beth$2 = "ℶ";
-const between$2 = "≬";
-const bfr$2 = "𝔟";
-const bigcap$2 = "⋂";
-const bigcirc$2 = "◯";
-const bigcup$2 = "⋃";
-const bigodot$2 = "⨀";
-const bigoplus$2 = "⨁";
-const bigotimes$2 = "⨂";
-const bigsqcup$2 = "⨆";
-const bigstar$2 = "★";
-const bigtriangledown$2 = "▽";
-const bigtriangleup$2 = "△";
-const biguplus$2 = "⨄";
-const bigvee$2 = "⋁";
-const bigwedge$2 = "⋀";
-const bkarow$2 = "⤍";
-const blacklozenge$2 = "⧫";
-const blacksquare$2 = "▪";
-const blacktriangle$2 = "▴";
-const blacktriangledown$2 = "▾";
-const blacktriangleleft$2 = "◂";
-const blacktriangleright$2 = "▸";
-const blank$2 = "␣";
-const blk12$2 = "▒";
-const blk14$2 = "░";
-const blk34$2 = "▓";
-const block$2 = "█";
-const bne$2 = "=⃥";
-const bnequiv$2 = "≡⃥";
-const bnot$2 = "⌐";
-const bopf$2 = "𝕓";
-const bot$2 = "⊥";
-const bottom$2 = "⊥";
-const bowtie$2 = "⋈";
-const boxDL$2 = "╗";
-const boxDR$2 = "╔";
-const boxDl$2 = "╖";
-const boxDr$2 = "╓";
-const boxH$2 = "═";
-const boxHD$2 = "╦";
-const boxHU$2 = "╩";
-const boxHd$2 = "╤";
-const boxHu$2 = "╧";
-const boxUL$2 = "╝";
-const boxUR$2 = "╚";
-const boxUl$2 = "╜";
-const boxUr$2 = "╙";
-const boxV$2 = "║";
-const boxVH$2 = "╬";
-const boxVL$2 = "╣";
-const boxVR$2 = "╠";
-const boxVh$2 = "╫";
-const boxVl$2 = "╢";
-const boxVr$2 = "╟";
-const boxbox$2 = "⧉";
-const boxdL$2 = "╕";
-const boxdR$2 = "╒";
-const boxdl$2 = "┐";
-const boxdr$2 = "┌";
-const boxh$2 = "─";
-const boxhD$2 = "╥";
-const boxhU$2 = "╨";
-const boxhd$2 = "┬";
-const boxhu$2 = "┴";
-const boxminus$2 = "⊟";
-const boxplus$2 = "⊞";
-const boxtimes$2 = "⊠";
-const boxuL$2 = "╛";
-const boxuR$2 = "╘";
-const boxul$2 = "┘";
-const boxur$2 = "└";
-const boxv$2 = "│";
-const boxvH$2 = "╪";
-const boxvL$2 = "╡";
-const boxvR$2 = "╞";
-const boxvh$2 = "┼";
-const boxvl$2 = "┤";
-const boxvr$2 = "├";
-const bprime$2 = "‵";
-const breve$2 = "˘";
-const brvba$2 = "¦";
-const brvbar$2 = "¦";
-const bscr$2 = "𝒷";
-const bsemi$2 = "⁏";
-const bsim$2 = "∽";
-const bsime$2 = "⋍";
-const bsol$2 = "\\";
-const bsolb$2 = "⧅";
-const bsolhsub$2 = "⟈";
-const bull$2 = "•";
-const bullet$2 = "•";
-const bump$2 = "≎";
-const bumpE$2 = "⪮";
-const bumpe$2 = "≏";
-const bumpeq$2 = "≏";
-const cacute$2 = "ć";
-const cap$2 = "∩";
-const capand$2 = "⩄";
-const capbrcup$2 = "⩉";
-const capcap$2 = "⩋";
-const capcup$2 = "⩇";
-const capdot$2 = "⩀";
-const caps$2 = "∩︀";
-const caret$2 = "⁁";
-const caron$2 = "ˇ";
-const ccaps$2 = "⩍";
-const ccaron$2 = "č";
-const ccedi$2 = "ç";
-const ccedil$2 = "ç";
-const ccirc$2 = "ĉ";
-const ccups$2 = "⩌";
-const ccupssm$2 = "⩐";
-const cdot$2 = "ċ";
-const cedi$2 = "¸";
-const cedil$2 = "¸";
-const cemptyv$2 = "⦲";
-const cen$2 = "¢";
-const cent$2 = "¢";
-const centerdot$2 = "·";
-const cfr$2 = "𝔠";
-const chcy$2 = "ч";
-const check$3 = "✓";
-const checkmark$2 = "✓";
-const chi$2 = "χ";
-const cir$2 = "○";
-const cirE$2 = "⧃";
-const circ$2 = "ˆ";
-const circeq$2 = "≗";
-const circlearrowleft$2 = "↺";
-const circlearrowright$2 = "↻";
-const circledR$2 = "®";
-const circledS$2 = "Ⓢ";
-const circledast$2 = "⊛";
-const circledcirc$2 = "⊚";
-const circleddash$2 = "⊝";
-const cire$2 = "≗";
-const cirfnint$2 = "⨐";
-const cirmid$2 = "⫯";
-const cirscir$2 = "⧂";
-const clubs$2 = "♣";
-const clubsuit$2 = "♣";
-const colon$2 = ":";
-const colone$2 = "≔";
-const coloneq$2 = "≔";
-const comma$2 = ",";
-const commat$2 = "@";
-const comp$2 = "∁";
-const compfn$2 = "∘";
-const complement$2 = "∁";
-const complexes$2 = "ℂ";
-const cong$2 = "≅";
-const congdot$2 = "⩭";
-const conint$2 = "∮";
-const copf$2 = "𝕔";
-const coprod$2 = "∐";
-const cop$2 = "©";
-const copy$2 = "©";
-const copysr$2 = "℗";
-const crarr$2 = "↵";
-const cross$2 = "✗";
-const cscr$2 = "𝒸";
-const csub$2 = "⫏";
-const csube$2 = "⫑";
-const csup$2 = "⫐";
-const csupe$2 = "⫒";
-const ctdot$2 = "⋯";
-const cudarrl$2 = "⤸";
-const cudarrr$2 = "⤵";
-const cuepr$2 = "⋞";
-const cuesc$2 = "⋟";
-const cularr$2 = "↶";
-const cularrp$2 = "⤽";
-const cup$2 = "∪";
-const cupbrcap$2 = "⩈";
-const cupcap$2 = "⩆";
-const cupcup$2 = "⩊";
-const cupdot$2 = "⊍";
-const cupor$2 = "⩅";
-const cups$2 = "∪︀";
-const curarr$2 = "↷";
-const curarrm$2 = "⤼";
-const curlyeqprec$2 = "⋞";
-const curlyeqsucc$2 = "⋟";
-const curlyvee$2 = "⋎";
-const curlywedge$2 = "⋏";
-const curre$2 = "¤";
-const curren$2 = "¤";
-const curvearrowleft$2 = "↶";
-const curvearrowright$2 = "↷";
-const cuvee$2 = "⋎";
-const cuwed$2 = "⋏";
-const cwconint$2 = "∲";
-const cwint$2 = "∱";
-const cylcty$2 = "⌭";
-const dArr$2 = "⇓";
-const dHar$2 = "⥥";
-const dagger$2 = "†";
-const daleth$2 = "ℸ";
-const darr$2 = "↓";
-const dash$2 = "‐";
-const dashv$2 = "⊣";
-const dbkarow$2 = "⤏";
-const dblac$2 = "˝";
-const dcaron$2 = "ď";
-const dcy$2 = "д";
-const dd$2 = "ⅆ";
-const ddagger$2 = "‡";
-const ddarr$2 = "⇊";
-const ddotseq$2 = "⩷";
-const de$2 = "°";
-const deg$2 = "°";
-const delta$2 = "δ";
-const demptyv$2 = "⦱";
-const dfisht$2 = "⥿";
-const dfr$2 = "𝔡";
-const dharl$2 = "⇃";
-const dharr$2 = "⇂";
-const diam$2 = "⋄";
-const diamond$2 = "⋄";
-const diamondsuit$2 = "♦";
-const diams$2 = "♦";
-const die$2 = "¨";
-const digamma$2 = "ϝ";
-const disin$2 = "⋲";
-const div$2 = "÷";
-const divid$2 = "÷";
-const divide$2 = "÷";
-const divideontimes$2 = "⋇";
-const divonx$2 = "⋇";
-const djcy$2 = "ђ";
-const dlcorn$2 = "⌞";
-const dlcrop$2 = "⌍";
-const dollar$2 = "$";
-const dopf$2 = "𝕕";
-const dot$2 = "˙";
-const doteq$2 = "≐";
-const doteqdot$2 = "≑";
-const dotminus$2 = "∸";
-const dotplus$2 = "∔";
-const dotsquare$2 = "⊡";
-const doublebarwedge$2 = "⌆";
-const downarrow$2 = "↓";
-const downdownarrows$2 = "⇊";
-const downharpoonleft$2 = "⇃";
-const downharpoonright$2 = "⇂";
-const drbkarow$2 = "⤐";
-const drcorn$2 = "⌟";
-const drcrop$2 = "⌌";
-const dscr$2 = "𝒹";
-const dscy$2 = "ѕ";
-const dsol$2 = "⧶";
-const dstrok$2 = "đ";
-const dtdot$2 = "⋱";
-const dtri$2 = "▿";
-const dtrif$2 = "▾";
-const duarr$2 = "⇵";
-const duhar$2 = "⥯";
-const dwangle$2 = "⦦";
-const dzcy$2 = "џ";
-const dzigrarr$2 = "⟿";
-const eDDot$2 = "⩷";
-const eDot$2 = "≑";
-const eacut$2 = "é";
-const eacute$2 = "é";
-const easter$2 = "⩮";
-const ecaron$2 = "ě";
-const ecir$2 = "ê";
-const ecirc$2 = "ê";
-const ecolon$2 = "≕";
-const ecy$2 = "э";
-const edot$2 = "ė";
-const ee$2 = "ⅇ";
-const efDot$2 = "≒";
-const efr$2 = "𝔢";
-const eg$2 = "⪚";
-const egrav$2 = "è";
-const egrave$2 = "è";
-const egs$2 = "⪖";
-const egsdot$2 = "⪘";
-const el$2 = "⪙";
-const elinters$2 = "⏧";
-const ell$2 = "ℓ";
-const els$2 = "⪕";
-const elsdot$2 = "⪗";
-const emacr$2 = "ē";
-const empty$2 = "∅";
-const emptyset$2 = "∅";
-const emptyv$2 = "∅";
-const emsp13$2 = " ";
-const emsp14$2 = " ";
-const emsp$2 = " ";
-const eng$2 = "ŋ";
-const ensp$2 = " ";
-const eogon$2 = "ę";
-const eopf$2 = "𝕖";
-const epar$2 = "⋕";
-const eparsl$2 = "⧣";
-const eplus$2 = "⩱";
-const epsi$2 = "ε";
-const epsilon$2 = "ε";
-const epsiv$2 = "ϵ";
-const eqcirc$2 = "≖";
-const eqcolon$2 = "≕";
-const eqsim$2 = "≂";
-const eqslantgtr$2 = "⪖";
-const eqslantless$2 = "⪕";
-const equals$2 = "=";
-const equest$2 = "≟";
-const equiv$2 = "≡";
-const equivDD$2 = "⩸";
-const eqvparsl$2 = "⧥";
-const erDot$2 = "≓";
-const erarr$2 = "⥱";
-const escr$2 = "ℯ";
-const esdot$2 = "≐";
-const esim$2 = "≂";
-const eta$2 = "η";
-const et$2 = "ð";
-const eth$2 = "ð";
-const eum$2 = "ë";
-const euml$2 = "ë";
-const euro$2 = "€";
-const excl$2 = "!";
-const exist$2 = "∃";
-const expectation$2 = "ℰ";
-const exponentiale$2 = "ⅇ";
-const fallingdotseq$2 = "≒";
-const fcy$2 = "ф";
-const female$2 = "♀";
-const ffilig$2 = "ffi";
-const fflig$2 = "ff";
-const ffllig$2 = "ffl";
-const ffr$2 = "𝔣";
-const filig$2 = "fi";
-const fjlig$2 = "fj";
-const flat$2 = "♭";
-const fllig$2 = "fl";
-const fltns$2 = "▱";
-const fnof$2 = "ƒ";
-const fopf$2 = "𝕗";
-const forall$2 = "∀";
-const fork$2 = "⋔";
-const forkv$2 = "⫙";
-const fpartint$2 = "⨍";
-const frac1$2 = "¼";
-const frac12$2 = "½";
-const frac13$2 = "⅓";
-const frac14$2 = "¼";
-const frac15$2 = "⅕";
-const frac16$2 = "⅙";
-const frac18$2 = "⅛";
-const frac23$2 = "⅔";
-const frac25$2 = "⅖";
-const frac3$2 = "¾";
-const frac34$2 = "¾";
-const frac35$2 = "⅗";
-const frac38$2 = "⅜";
-const frac45$2 = "⅘";
-const frac56$2 = "⅚";
-const frac58$2 = "⅝";
-const frac78$2 = "⅞";
-const frasl$2 = "⁄";
-const frown$2 = "⌢";
-const fscr$2 = "𝒻";
-const gE$2 = "≧";
-const gEl$2 = "⪌";
-const gacute$2 = "ǵ";
-const gamma$2 = "γ";
-const gammad$2 = "ϝ";
-const gap$2 = "⪆";
-const gbreve$2 = "ğ";
-const gcirc$2 = "ĝ";
-const gcy$2 = "г";
-const gdot$2 = "ġ";
-const ge$2 = "≥";
-const gel$2 = "⋛";
-const geq$2 = "≥";
-const geqq$2 = "≧";
-const geqslant$2 = "⩾";
-const ges$2 = "⩾";
-const gescc$2 = "⪩";
-const gesdot$2 = "⪀";
-const gesdoto$2 = "⪂";
-const gesdotol$2 = "⪄";
-const gesl$2 = "⋛︀";
-const gesles$2 = "⪔";
-const gfr$2 = "𝔤";
-const gg$2 = "≫";
-const ggg$2 = "⋙";
-const gimel$2 = "ℷ";
-const gjcy$2 = "ѓ";
-const gl$2 = "≷";
-const glE$2 = "⪒";
-const gla$2 = "⪥";
-const glj$2 = "⪤";
-const gnE$2 = "≩";
-const gnap$2 = "⪊";
-const gnapprox$2 = "⪊";
-const gne$2 = "⪈";
-const gneq$2 = "⪈";
-const gneqq$2 = "≩";
-const gnsim$2 = "⋧";
-const gopf$2 = "𝕘";
-const grave$2 = "`";
-const gscr$2 = "ℊ";
-const gsim$2 = "≳";
-const gsime$2 = "⪎";
-const gsiml$2 = "⪐";
-const g$2 = ">";
-const gt$2 = ">";
-const gtcc$2 = "⪧";
-const gtcir$2 = "⩺";
-const gtdot$2 = "⋗";
-const gtlPar$2 = "⦕";
-const gtquest$2 = "⩼";
-const gtrapprox$2 = "⪆";
-const gtrarr$2 = "⥸";
-const gtrdot$2 = "⋗";
-const gtreqless$2 = "⋛";
-const gtreqqless$2 = "⪌";
-const gtrless$2 = "≷";
-const gtrsim$2 = "≳";
-const gvertneqq$2 = "≩︀";
-const gvnE$2 = "≩︀";
-const hArr$2 = "⇔";
-const hairsp$2 = " ";
-const half$2 = "½";
-const hamilt$2 = "ℋ";
-const hardcy$2 = "ъ";
-const harr$2 = "↔";
-const harrcir$2 = "⥈";
-const harrw$2 = "↭";
-const hbar$2 = "ℏ";
-const hcirc$2 = "ĥ";
-const hearts$2 = "♥";
-const heartsuit$2 = "♥";
-const hellip$2 = "…";
-const hercon$2 = "⊹";
-const hfr$2 = "𝔥";
-const hksearow$2 = "⤥";
-const hkswarow$2 = "⤦";
-const hoarr$2 = "⇿";
-const homtht$2 = "∻";
-const hookleftarrow$2 = "↩";
-const hookrightarrow$2 = "↪";
-const hopf$2 = "𝕙";
-const horbar$2 = "―";
-const hscr$2 = "𝒽";
-const hslash$2 = "ℏ";
-const hstrok$2 = "ħ";
-const hybull$2 = "⁃";
-const hyphen$2 = "‐";
-const iacut$2 = "í";
-const iacute$2 = "í";
-const ic$2 = "⁣";
-const icir$2 = "î";
-const icirc$2 = "î";
-const icy$2 = "и";
-const iecy$2 = "е";
-const iexc$2 = "¡";
-const iexcl$2 = "¡";
-const iff$2 = "⇔";
-const ifr$2 = "𝔦";
-const igrav$2 = "ì";
-const igrave$2 = "ì";
-const ii$2 = "ⅈ";
-const iiiint$2 = "⨌";
-const iiint$2 = "∭";
-const iinfin$2 = "⧜";
-const iiota$2 = "℩";
-const ijlig$2 = "ij";
-const imacr$2 = "ī";
-const image$3 = "ℑ";
-const imagline$2 = "ℐ";
-const imagpart$2 = "ℑ";
-const imath$2 = "ı";
-const imof$2 = "⊷";
-const imped$2 = "Ƶ";
-const incare$2 = "℅";
-const infin$2 = "∞";
-const infintie$2 = "⧝";
-const inodot$2 = "ı";
-const int$3 = "∫";
-const intcal$2 = "⊺";
-const integers$2 = "ℤ";
-const intercal$2 = "⊺";
-const intlarhk$2 = "⨗";
-const intprod$2 = "⨼";
-const iocy$2 = "ё";
-const iogon$2 = "į";
-const iopf$2 = "𝕚";
-const iota$2 = "ι";
-const iprod$2 = "⨼";
-const iques$2 = "¿";
-const iquest$2 = "¿";
-const iscr$2 = "𝒾";
-const isin$2 = "∈";
-const isinE$2 = "⋹";
-const isindot$2 = "⋵";
-const isins$2 = "⋴";
-const isinsv$2 = "⋳";
-const isinv$2 = "∈";
-const it$2 = "⁢";
-const itilde$2 = "ĩ";
-const iukcy$2 = "і";
-const ium$2 = "ï";
-const iuml$2 = "ï";
-const jcirc$2 = "ĵ";
-const jcy$2 = "й";
-const jfr$2 = "𝔧";
-const jmath$2 = "ȷ";
-const jopf$2 = "𝕛";
-const jscr$2 = "𝒿";
-const jsercy$2 = "ј";
-const jukcy$2 = "є";
-const kappa$2 = "κ";
-const kappav$2 = "ϰ";
-const kcedil$2 = "ķ";
-const kcy$2 = "к";
-const kfr$2 = "𝔨";
-const kgreen$2 = "ĸ";
-const khcy$2 = "х";
-const kjcy$2 = "ќ";
-const kopf$2 = "𝕜";
-const kscr$2 = "𝓀";
-const lAarr$2 = "⇚";
-const lArr$2 = "⇐";
-const lAtail$2 = "⤛";
-const lBarr$2 = "⤎";
-const lE$2 = "≦";
-const lEg$2 = "⪋";
-const lHar$2 = "⥢";
-const lacute$2 = "ĺ";
-const laemptyv$2 = "⦴";
-const lagran$2 = "ℒ";
-const lambda$2 = "λ";
-const lang$2 = "⟨";
-const langd$2 = "⦑";
-const langle$2 = "⟨";
-const lap$2 = "⪅";
-const laqu$2 = "«";
-const laquo$2 = "«";
-const larr$2 = "←";
-const larrb$2 = "⇤";
-const larrbfs$2 = "⤟";
-const larrfs$2 = "⤝";
-const larrhk$2 = "↩";
-const larrlp$2 = "↫";
-const larrpl$2 = "⤹";
-const larrsim$2 = "⥳";
-const larrtl$2 = "↢";
-const lat$2 = "⪫";
-const latail$2 = "⤙";
-const late$2 = "⪭";
-const lates$2 = "⪭︀";
-const lbarr$2 = "⤌";
-const lbbrk$2 = "❲";
-const lbrace$2 = "{";
-const lbrack$2 = "[";
-const lbrke$2 = "⦋";
-const lbrksld$2 = "⦏";
-const lbrkslu$2 = "⦍";
-const lcaron$2 = "ľ";
-const lcedil$2 = "ļ";
-const lceil$2 = "⌈";
-const lcub$2 = "{";
-const lcy$2 = "л";
-const ldca$2 = "⤶";
-const ldquo$2 = "“";
-const ldquor$2 = "„";
-const ldrdhar$2 = "⥧";
-const ldrushar$2 = "⥋";
-const ldsh$2 = "↲";
-const le$2 = "≤";
-const leftarrow$2 = "←";
-const leftarrowtail$2 = "↢";
-const leftharpoondown$2 = "↽";
-const leftharpoonup$2 = "↼";
-const leftleftarrows$2 = "⇇";
-const leftrightarrow$2 = "↔";
-const leftrightarrows$2 = "⇆";
-const leftrightharpoons$2 = "⇋";
-const leftrightsquigarrow$2 = "↭";
-const leftthreetimes$2 = "⋋";
-const leg$2 = "⋚";
-const leq$2 = "≤";
-const leqq$2 = "≦";
-const leqslant$2 = "⩽";
-const les$2 = "⩽";
-const lescc$2 = "⪨";
-const lesdot$2 = "⩿";
-const lesdoto$2 = "⪁";
-const lesdotor$2 = "⪃";
-const lesg$2 = "⋚︀";
-const lesges$2 = "⪓";
-const lessapprox$2 = "⪅";
-const lessdot$2 = "⋖";
-const lesseqgtr$2 = "⋚";
-const lesseqqgtr$2 = "⪋";
-const lessgtr$2 = "≶";
-const lesssim$2 = "≲";
-const lfisht$2 = "⥼";
-const lfloor$2 = "⌊";
-const lfr$2 = "𝔩";
-const lg$2 = "≶";
-const lgE$2 = "⪑";
-const lhard$2 = "↽";
-const lharu$2 = "↼";
-const lharul$2 = "⥪";
-const lhblk$2 = "▄";
-const ljcy$2 = "љ";
-const ll$2 = "≪";
-const llarr$2 = "⇇";
-const llcorner$2 = "⌞";
-const llhard$2 = "⥫";
-const lltri$2 = "◺";
-const lmidot$2 = "ŀ";
-const lmoust$2 = "⎰";
-const lmoustache$2 = "⎰";
-const lnE$2 = "≨";
-const lnap$2 = "⪉";
-const lnapprox$2 = "⪉";
-const lne$2 = "⪇";
-const lneq$2 = "⪇";
-const lneqq$2 = "≨";
-const lnsim$2 = "⋦";
-const loang$2 = "⟬";
-const loarr$2 = "⇽";
-const lobrk$2 = "⟦";
-const longleftarrow$2 = "⟵";
-const longleftrightarrow$2 = "⟷";
-const longmapsto$2 = "⟼";
-const longrightarrow$2 = "⟶";
-const looparrowleft$2 = "↫";
-const looparrowright$2 = "↬";
-const lopar$2 = "⦅";
-const lopf$2 = "𝕝";
-const loplus$2 = "⨭";
-const lotimes$2 = "⨴";
-const lowast$2 = "∗";
-const lowbar$2 = "_";
-const loz$2 = "◊";
-const lozenge$2 = "◊";
-const lozf$2 = "⧫";
-const lpar$2 = "(";
-const lparlt$2 = "⦓";
-const lrarr$2 = "⇆";
-const lrcorner$2 = "⌟";
-const lrhar$2 = "⇋";
-const lrhard$2 = "⥭";
-const lrm$2 = "‎";
-const lrtri$2 = "⊿";
-const lsaquo$2 = "‹";
-const lscr$2 = "𝓁";
-const lsh$2 = "↰";
-const lsim$2 = "≲";
-const lsime$2 = "⪍";
-const lsimg$2 = "⪏";
-const lsqb$2 = "[";
-const lsquo$2 = "‘";
-const lsquor$2 = "‚";
-const lstrok$2 = "ł";
-const l$2 = "<";
-const lt$3 = "<";
-const ltcc$2 = "⪦";
-const ltcir$2 = "⩹";
-const ltdot$2 = "⋖";
-const lthree$2 = "⋋";
-const ltimes$2 = "⋉";
-const ltlarr$2 = "⥶";
-const ltquest$2 = "⩻";
-const ltrPar$2 = "⦖";
-const ltri$2 = "◃";
-const ltrie$2 = "⊴";
-const ltrif$2 = "◂";
-const lurdshar$2 = "⥊";
-const luruhar$2 = "⥦";
-const lvertneqq$2 = "≨︀";
-const lvnE$2 = "≨︀";
-const mDDot$2 = "∺";
-const mac$2 = "¯";
-const macr$2 = "¯";
-const male$2 = "♂";
-const malt$2 = "✠";
-const maltese$2 = "✠";
-const map$5 = "↦";
-const mapsto$2 = "↦";
-const mapstodown$2 = "↧";
-const mapstoleft$2 = "↤";
-const mapstoup$2 = "↥";
-const marker$2 = "▮";
-const mcomma$2 = "⨩";
-const mcy$2 = "м";
-const mdash$2 = "—";
-const measuredangle$2 = "∡";
-const mfr$2 = "𝔪";
-const mho$2 = "℧";
-const micr$2 = "µ";
-const micro$2 = "µ";
-const mid$2 = "∣";
-const midast$2 = "*";
-const midcir$2 = "⫰";
-const middo$2 = "·";
-const middot$2 = "·";
-const minus$2 = "−";
-const minusb$2 = "⊟";
-const minusd$2 = "∸";
-const minusdu$2 = "⨪";
-const mlcp$2 = "⫛";
-const mldr$2 = "…";
-const mnplus$2 = "∓";
-const models$2 = "⊧";
-const mopf$2 = "𝕞";
-const mp$2 = "∓";
-const mscr$2 = "𝓂";
-const mstpos$2 = "∾";
-const mu$2 = "μ";
-const multimap$2 = "⊸";
-const mumap$2 = "⊸";
-const nGg$2 = "⋙̸";
-const nGt$2 = "≫⃒";
-const nGtv$2 = "≫̸";
-const nLeftarrow$2 = "⇍";
-const nLeftrightarrow$2 = "⇎";
-const nLl$2 = "⋘̸";
-const nLt$2 = "≪⃒";
-const nLtv$2 = "≪̸";
-const nRightarrow$2 = "⇏";
-const nVDash$2 = "⊯";
-const nVdash$2 = "⊮";
-const nabla$2 = "∇";
-const nacute$2 = "ń";
-const nang$2 = "∠⃒";
-const nap$2 = "≉";
-const napE$2 = "⩰̸";
-const napid$2 = "≋̸";
-const napos$2 = "ʼn";
-const napprox$2 = "≉";
-const natur$2 = "♮";
-const natural$2 = "♮";
-const naturals$2 = "ℕ";
-const nbs$2 = " ";
-const nbsp$2 = " ";
-const nbump$2 = "≎̸";
-const nbumpe$2 = "≏̸";
-const ncap$2 = "⩃";
-const ncaron$2 = "ň";
-const ncedil$2 = "ņ";
-const ncong$2 = "≇";
-const ncongdot$2 = "⩭̸";
-const ncup$2 = "⩂";
-const ncy$2 = "н";
-const ndash$2 = "–";
-const ne$2 = "≠";
-const neArr$2 = "⇗";
-const nearhk$2 = "⤤";
-const nearr$2 = "↗";
-const nearrow$2 = "↗";
-const nedot$2 = "≐̸";
-const nequiv$2 = "≢";
-const nesear$2 = "⤨";
-const nesim$2 = "≂̸";
-const nexist$2 = "∄";
-const nexists$2 = "∄";
-const nfr$2 = "𝔫";
-const ngE$2 = "≧̸";
-const nge$2 = "≱";
-const ngeq$2 = "≱";
-const ngeqq$2 = "≧̸";
-const ngeqslant$2 = "⩾̸";
-const nges$2 = "⩾̸";
-const ngsim$2 = "≵";
-const ngt$2 = "≯";
-const ngtr$2 = "≯";
-const nhArr$2 = "⇎";
-const nharr$2 = "↮";
-const nhpar$2 = "⫲";
-const ni$2 = "∋";
-const nis$2 = "⋼";
-const nisd$2 = "⋺";
-const niv$2 = "∋";
-const njcy$2 = "њ";
-const nlArr$2 = "⇍";
-const nlE$2 = "≦̸";
-const nlarr$2 = "↚";
-const nldr$2 = "‥";
-const nle$2 = "≰";
-const nleftarrow$2 = "↚";
-const nleftrightarrow$2 = "↮";
-const nleq$2 = "≰";
-const nleqq$2 = "≦̸";
-const nleqslant$2 = "⩽̸";
-const nles$2 = "⩽̸";
-const nless$2 = "≮";
-const nlsim$2 = "≴";
-const nlt$2 = "≮";
-const nltri$2 = "⋪";
-const nltrie$2 = "⋬";
-const nmid$2 = "∤";
-const nopf$2 = "𝕟";
-const no$2 = "¬";
-const not$2 = "¬";
-const notin$2 = "∉";
-const notinE$2 = "⋹̸";
-const notindot$2 = "⋵̸";
-const notinva$2 = "∉";
-const notinvb$2 = "⋷";
-const notinvc$2 = "⋶";
-const notni$2 = "∌";
-const notniva$2 = "∌";
-const notnivb$2 = "⋾";
-const notnivc$2 = "⋽";
-const npar$2 = "∦";
-const nparallel$2 = "∦";
-const nparsl$2 = "⫽⃥";
-const npart$2 = "∂̸";
-const npolint$2 = "⨔";
-const npr$2 = "⊀";
-const nprcue$2 = "⋠";
-const npre$2 = "⪯̸";
-const nprec$2 = "⊀";
-const npreceq$2 = "⪯̸";
-const nrArr$2 = "⇏";
-const nrarr$2 = "↛";
-const nrarrc$2 = "⤳̸";
-const nrarrw$2 = "↝̸";
-const nrightarrow$2 = "↛";
-const nrtri$2 = "⋫";
-const nrtrie$2 = "⋭";
-const nsc$2 = "⊁";
-const nsccue$2 = "⋡";
-const nsce$2 = "⪰̸";
-const nscr$2 = "𝓃";
-const nshortmid$2 = "∤";
-const nshortparallel$2 = "∦";
-const nsim$2 = "≁";
-const nsime$2 = "≄";
-const nsimeq$2 = "≄";
-const nsmid$2 = "∤";
-const nspar$2 = "∦";
-const nsqsube$2 = "⋢";
-const nsqsupe$2 = "⋣";
-const nsub$2 = "⊄";
-const nsubE$2 = "⫅̸";
-const nsube$2 = "⊈";
-const nsubset$2 = "⊂⃒";
-const nsubseteq$2 = "⊈";
-const nsubseteqq$2 = "⫅̸";
-const nsucc$2 = "⊁";
-const nsucceq$2 = "⪰̸";
-const nsup$2 = "⊅";
-const nsupE$2 = "⫆̸";
-const nsupe$2 = "⊉";
-const nsupset$2 = "⊃⃒";
-const nsupseteq$2 = "⊉";
-const nsupseteqq$2 = "⫆̸";
-const ntgl$2 = "≹";
-const ntild$2 = "ñ";
-const ntilde$2 = "ñ";
-const ntlg$2 = "≸";
-const ntriangleleft$2 = "⋪";
-const ntrianglelefteq$2 = "⋬";
-const ntriangleright$2 = "⋫";
-const ntrianglerighteq$2 = "⋭";
-const nu$2 = "ν";
-const num$2 = "#";
-const numero$2 = "№";
-const numsp$2 = " ";
-const nvDash$2 = "⊭";
-const nvHarr$2 = "⤄";
-const nvap$2 = "≍⃒";
-const nvdash$2 = "⊬";
-const nvge$2 = "≥⃒";
-const nvgt$2 = ">⃒";
-const nvinfin$2 = "⧞";
-const nvlArr$2 = "⤂";
-const nvle$2 = "≤⃒";
-const nvlt$2 = "<⃒";
-const nvltrie$2 = "⊴⃒";
-const nvrArr$2 = "⤃";
-const nvrtrie$2 = "⊵⃒";
-const nvsim$2 = "∼⃒";
-const nwArr$2 = "⇖";
-const nwarhk$2 = "⤣";
-const nwarr$2 = "↖";
-const nwarrow$2 = "↖";
-const nwnear$2 = "⤧";
-const oS$2 = "Ⓢ";
-const oacut$2 = "ó";
-const oacute$2 = "ó";
-const oast$2 = "⊛";
-const ocir$2 = "ô";
-const ocirc$2 = "ô";
-const ocy$2 = "о";
-const odash$2 = "⊝";
-const odblac$2 = "ő";
-const odiv$2 = "⨸";
-const odot$2 = "⊙";
-const odsold$2 = "⦼";
-const oelig$2 = "œ";
-const ofcir$2 = "⦿";
-const ofr$2 = "𝔬";
-const ogon$2 = "˛";
-const ograv$2 = "ò";
-const ograve$2 = "ò";
-const ogt$2 = "⧁";
-const ohbar$2 = "⦵";
-const ohm$2 = "Ω";
-const oint$2 = "∮";
-const olarr$2 = "↺";
-const olcir$2 = "⦾";
-const olcross$2 = "⦻";
-const oline$2 = "‾";
-const olt$2 = "⧀";
-const omacr$2 = "ō";
-const omega$2 = "ω";
-const omicron$2 = "ο";
-const omid$2 = "⦶";
-const ominus$2 = "⊖";
-const oopf$2 = "𝕠";
-const opar$2 = "⦷";
-const operp$2 = "⦹";
-const oplus$2 = "⊕";
-const or$2 = "∨";
-const orarr$2 = "↻";
-const ord$2 = "º";
-const order$2 = "ℴ";
-const orderof$2 = "ℴ";
-const ordf$2 = "ª";
-const ordm$2 = "º";
-const origof$2 = "⊶";
-const oror$2 = "⩖";
-const orslope$2 = "⩗";
-const orv$2 = "⩛";
-const oscr$2 = "ℴ";
-const oslas$2 = "ø";
-const oslash$2 = "ø";
-const osol$2 = "⊘";
-const otild$2 = "õ";
-const otilde$2 = "õ";
-const otimes$2 = "⊗";
-const otimesas$2 = "⨶";
-const oum$2 = "ö";
-const ouml$2 = "ö";
-const ovbar$2 = "⌽";
-const par$2 = "¶";
-const para$2 = "¶";
-const parallel$2 = "∥";
-const parsim$2 = "⫳";
-const parsl$2 = "⫽";
-const part$2 = "∂";
-const pcy$2 = "п";
-const percnt$2 = "%";
-const period$2 = ".";
-const permil$2 = "‰";
-const perp$2 = "⊥";
-const pertenk$2 = "‱";
-const pfr$2 = "𝔭";
-const phi$2 = "φ";
-const phiv$2 = "ϕ";
-const phmmat$2 = "ℳ";
-const phone$2 = "☎";
-const pi$2 = "π";
-const pitchfork$2 = "⋔";
-const piv$2 = "ϖ";
-const planck$2 = "ℏ";
-const planckh$2 = "ℎ";
-const plankv$2 = "ℏ";
-const plus$2 = "+";
-const plusacir$2 = "⨣";
-const plusb$2 = "⊞";
-const pluscir$2 = "⨢";
-const plusdo$2 = "∔";
-const plusdu$2 = "⨥";
-const pluse$2 = "⩲";
-const plusm$2 = "±";
-const plusmn$2 = "±";
-const plussim$2 = "⨦";
-const plustwo$2 = "⨧";
-const pm$2 = "±";
-const pointint$2 = "⨕";
-const popf$2 = "𝕡";
-const poun$2 = "£";
-const pound$2 = "£";
-const pr$2 = "≺";
-const prE$2 = "⪳";
-const prap$2 = "⪷";
-const prcue$2 = "≼";
-const pre$2 = "⪯";
-const prec$2 = "≺";
-const precapprox$2 = "⪷";
-const preccurlyeq$2 = "≼";
-const preceq$2 = "⪯";
-const precnapprox$2 = "⪹";
-const precneqq$2 = "⪵";
-const precnsim$2 = "⋨";
-const precsim$2 = "≾";
-const prime$2 = "′";
-const primes$2 = "ℙ";
-const prnE$2 = "⪵";
-const prnap$2 = "⪹";
-const prnsim$2 = "⋨";
-const prod$2 = "∏";
-const profalar$2 = "⌮";
-const profline$2 = "⌒";
-const profsurf$2 = "⌓";
-const prop$2 = "∝";
-const propto$2 = "∝";
-const prsim$2 = "≾";
-const prurel$2 = "⊰";
-const pscr$2 = "𝓅";
-const psi$2 = "ψ";
-const puncsp$2 = " ";
-const qfr$2 = "𝔮";
-const qint$2 = "⨌";
-const qopf$2 = "𝕢";
-const qprime$2 = "⁗";
-const qscr$2 = "𝓆";
-const quaternions$2 = "ℍ";
-const quatint$2 = "⨖";
-const quest$2 = "?";
-const questeq$2 = "≟";
-const quo$2 = "\"";
-const quot$2 = "\"";
-const rAarr$2 = "⇛";
-const rArr$2 = "⇒";
-const rAtail$2 = "⤜";
-const rBarr$2 = "⤏";
-const rHar$2 = "⥤";
-const race$2 = "∽̱";
-const racute$2 = "ŕ";
-const radic$2 = "√";
-const raemptyv$2 = "⦳";
-const rang$2 = "⟩";
-const rangd$2 = "⦒";
-const range$2 = "⦥";
-const rangle$2 = "⟩";
-const raqu$2 = "»";
-const raquo$2 = "»";
-const rarr$2 = "→";
-const rarrap$2 = "⥵";
-const rarrb$2 = "⇥";
-const rarrbfs$2 = "⤠";
-const rarrc$2 = "⤳";
-const rarrfs$2 = "⤞";
-const rarrhk$2 = "↪";
-const rarrlp$2 = "↬";
-const rarrpl$2 = "⥅";
-const rarrsim$2 = "⥴";
-const rarrtl$2 = "↣";
-const rarrw$2 = "↝";
-const ratail$2 = "⤚";
-const ratio$2 = "∶";
-const rationals$2 = "ℚ";
-const rbarr$2 = "⤍";
-const rbbrk$2 = "❳";
-const rbrace$2 = "}";
-const rbrack$2 = "]";
-const rbrke$2 = "⦌";
-const rbrksld$2 = "⦎";
-const rbrkslu$2 = "⦐";
-const rcaron$2 = "ř";
-const rcedil$2 = "ŗ";
-const rceil$2 = "⌉";
-const rcub$2 = "}";
-const rcy$2 = "р";
-const rdca$2 = "⤷";
-const rdldhar$2 = "⥩";
-const rdquo$2 = "”";
-const rdquor$2 = "”";
-const rdsh$2 = "↳";
-const real$2 = "ℜ";
-const realine$2 = "ℛ";
-const realpart$2 = "ℜ";
-const reals$2 = "ℝ";
-const rect$2 = "▭";
-const re$6 = "®";
-const reg$2 = "®";
-const rfisht$2 = "⥽";
-const rfloor$2 = "⌋";
-const rfr$2 = "𝔯";
-const rhard$2 = "⇁";
-const rharu$2 = "⇀";
-const rharul$2 = "⥬";
-const rho$2 = "ρ";
-const rhov$2 = "ϱ";
-const rightarrow$2 = "→";
-const rightarrowtail$2 = "↣";
-const rightharpoondown$2 = "⇁";
-const rightharpoonup$2 = "⇀";
-const rightleftarrows$2 = "⇄";
-const rightleftharpoons$2 = "⇌";
-const rightrightarrows$2 = "⇉";
-const rightsquigarrow$2 = "↝";
-const rightthreetimes$2 = "⋌";
-const ring$2 = "˚";
-const risingdotseq$2 = "≓";
-const rlarr$2 = "⇄";
-const rlhar$2 = "⇌";
-const rlm$2 = "‏";
-const rmoust$2 = "⎱";
-const rmoustache$2 = "⎱";
-const rnmid$2 = "⫮";
-const roang$2 = "⟭";
-const roarr$2 = "⇾";
-const robrk$2 = "⟧";
-const ropar$2 = "⦆";
-const ropf$2 = "𝕣";
-const roplus$2 = "⨮";
-const rotimes$2 = "⨵";
-const rpar$2 = ")";
-const rpargt$2 = "⦔";
-const rppolint$2 = "⨒";
-const rrarr$2 = "⇉";
-const rsaquo$2 = "›";
-const rscr$2 = "𝓇";
-const rsh$2 = "↱";
-const rsqb$2 = "]";
-const rsquo$2 = "’";
-const rsquor$2 = "’";
-const rthree$2 = "⋌";
-const rtimes$2 = "⋊";
-const rtri$2 = "▹";
-const rtrie$2 = "⊵";
-const rtrif$2 = "▸";
-const rtriltri$2 = "⧎";
-const ruluhar$2 = "⥨";
-const rx$2 = "℞";
-const sacute$2 = "ś";
-const sbquo$2 = "‚";
-const sc$2 = "≻";
-const scE$2 = "⪴";
-const scap$2 = "⪸";
-const scaron$2 = "š";
-const sccue$2 = "≽";
-const sce$2 = "⪰";
-const scedil$2 = "ş";
-const scirc$2 = "ŝ";
-const scnE$2 = "⪶";
-const scnap$2 = "⪺";
-const scnsim$2 = "⋩";
-const scpolint$2 = "⨓";
-const scsim$2 = "≿";
-const scy$2 = "с";
-const sdot$2 = "⋅";
-const sdotb$2 = "⊡";
-const sdote$2 = "⩦";
-const seArr$2 = "⇘";
-const searhk$2 = "⤥";
-const searr$2 = "↘";
-const searrow$2 = "↘";
-const sec$2 = "§";
-const sect$2 = "§";
-const semi$2 = ";";
-const seswar$2 = "⤩";
-const setminus$2 = "∖";
-const setmn$2 = "∖";
-const sext$2 = "✶";
-const sfr$2 = "𝔰";
-const sfrown$2 = "⌢";
-const sharp$2 = "♯";
-const shchcy$2 = "щ";
-const shcy$2 = "ш";
-const shortmid$2 = "∣";
-const shortparallel$2 = "∥";
-const sh$2 = "­";
-const shy$2 = "­";
-const sigma$2 = "σ";
-const sigmaf$2 = "ς";
-const sigmav$2 = "ς";
-const sim$2 = "∼";
-const simdot$2 = "⩪";
-const sime$2 = "≃";
-const simeq$2 = "≃";
-const simg$2 = "⪞";
-const simgE$2 = "⪠";
-const siml$2 = "⪝";
-const simlE$2 = "⪟";
-const simne$2 = "≆";
-const simplus$2 = "⨤";
-const simrarr$2 = "⥲";
-const slarr$2 = "←";
-const smallsetminus$2 = "∖";
-const smashp$2 = "⨳";
-const smeparsl$2 = "⧤";
-const smid$2 = "∣";
-const smile$2 = "⌣";
-const smt$2 = "⪪";
-const smte$2 = "⪬";
-const smtes$2 = "⪬︀";
-const softcy$2 = "ь";
-const sol$2 = "/";
-const solb$2 = "⧄";
-const solbar$2 = "⌿";
-const sopf$2 = "𝕤";
-const spades$2 = "♠";
-const spadesuit$2 = "♠";
-const spar$2 = "∥";
-const sqcap$2 = "⊓";
-const sqcaps$2 = "⊓︀";
-const sqcup$2 = "⊔";
-const sqcups$2 = "⊔︀";
-const sqsub$2 = "⊏";
-const sqsube$2 = "⊑";
-const sqsubset$2 = "⊏";
-const sqsubseteq$2 = "⊑";
-const sqsup$2 = "⊐";
-const sqsupe$2 = "⊒";
-const sqsupset$2 = "⊐";
-const sqsupseteq$2 = "⊒";
-const squ$2 = "□";
-const square$2 = "□";
-const squarf$2 = "▪";
-const squf$2 = "▪";
-const srarr$2 = "→";
-const sscr$2 = "𝓈";
-const ssetmn$2 = "∖";
-const ssmile$2 = "⌣";
-const sstarf$2 = "⋆";
-const star$2 = "☆";
-const starf$2 = "★";
-const straightepsilon$2 = "ϵ";
-const straightphi$2 = "ϕ";
-const strns$2 = "¯";
-const sub$2 = "⊂";
-const subE$2 = "⫅";
-const subdot$2 = "⪽";
-const sube$2 = "⊆";
-const subedot$2 = "⫃";
-const submult$2 = "⫁";
-const subnE$2 = "⫋";
-const subne$2 = "⊊";
-const subplus$2 = "⪿";
-const subrarr$2 = "⥹";
-const subset$2 = "⊂";
-const subseteq$2 = "⊆";
-const subseteqq$2 = "⫅";
-const subsetneq$2 = "⊊";
-const subsetneqq$2 = "⫋";
-const subsim$2 = "⫇";
-const subsub$2 = "⫕";
-const subsup$2 = "⫓";
-const succ$2 = "≻";
-const succapprox$2 = "⪸";
-const succcurlyeq$2 = "≽";
-const succeq$2 = "⪰";
-const succnapprox$2 = "⪺";
-const succneqq$2 = "⪶";
-const succnsim$2 = "⋩";
-const succsim$2 = "≿";
-const sum$2 = "∑";
-const sung$2 = "♪";
-const sup$2 = "⊃";
-const sup1$2 = "¹";
-const sup2$2 = "²";
-const sup3$2 = "³";
-const supE$2 = "⫆";
-const supdot$2 = "⪾";
-const supdsub$2 = "⫘";
-const supe$2 = "⊇";
-const supedot$2 = "⫄";
-const suphsol$2 = "⟉";
-const suphsub$2 = "⫗";
-const suplarr$2 = "⥻";
-const supmult$2 = "⫂";
-const supnE$2 = "⫌";
-const supne$2 = "⊋";
-const supplus$2 = "⫀";
-const supset$2 = "⊃";
-const supseteq$2 = "⊇";
-const supseteqq$2 = "⫆";
-const supsetneq$2 = "⊋";
-const supsetneqq$2 = "⫌";
-const supsim$2 = "⫈";
-const supsub$2 = "⫔";
-const supsup$2 = "⫖";
-const swArr$2 = "⇙";
-const swarhk$2 = "⤦";
-const swarr$2 = "↙";
-const swarrow$2 = "↙";
-const swnwar$2 = "⤪";
-const szli$2 = "ß";
-const szlig$2 = "ß";
-const target$2 = "⌖";
-const tau$2 = "τ";
-const tbrk$2 = "⎴";
-const tcaron$2 = "ť";
-const tcedil$2 = "ţ";
-const tcy$2 = "т";
-const tdot$2 = "⃛";
-const telrec$2 = "⌕";
-const tfr$2 = "𝔱";
-const there4$2 = "∴";
-const therefore$2 = "∴";
-const theta$2 = "θ";
-const thetasym$2 = "ϑ";
-const thetav$2 = "ϑ";
-const thickapprox$2 = "≈";
-const thicksim$2 = "∼";
-const thinsp$2 = " ";
-const thkap$2 = "≈";
-const thksim$2 = "∼";
-const thor$2 = "þ";
-const thorn$2 = "þ";
-const tilde$2 = "˜";
-const time$2 = "×";
-const times$2 = "×";
-const timesb$2 = "⊠";
-const timesbar$2 = "⨱";
-const timesd$2 = "⨰";
-const tint$2 = "∭";
-const toea$2 = "⤨";
-const top$2 = "⊤";
-const topbot$2 = "⌶";
-const topcir$2 = "⫱";
-const topf$2 = "𝕥";
-const topfork$2 = "⫚";
-const tosa$2 = "⤩";
-const tprime$2 = "‴";
-const trade$2 = "™";
-const triangle$2 = "▵";
-const triangledown$2 = "▿";
-const triangleleft$2 = "◃";
-const trianglelefteq$2 = "⊴";
-const triangleq$2 = "≜";
-const triangleright$2 = "▹";
-const trianglerighteq$2 = "⊵";
-const tridot$2 = "◬";
-const trie$2 = "≜";
-const triminus$2 = "⨺";
-const triplus$2 = "⨹";
-const trisb$2 = "⧍";
-const tritime$2 = "⨻";
-const trpezium$2 = "⏢";
-const tscr$2 = "𝓉";
-const tscy$2 = "ц";
-const tshcy$2 = "ћ";
-const tstrok$2 = "ŧ";
-const twixt$2 = "≬";
-const twoheadleftarrow$2 = "↞";
-const twoheadrightarrow$2 = "↠";
-const uArr$2 = "⇑";
-const uHar$2 = "⥣";
-const uacut$2 = "ú";
-const uacute$2 = "ú";
-const uarr$2 = "↑";
-const ubrcy$2 = "ў";
-const ubreve$2 = "ŭ";
-const ucir$2 = "û";
-const ucirc$2 = "û";
-const ucy$2 = "у";
-const udarr$2 = "⇅";
-const udblac$2 = "ű";
-const udhar$2 = "⥮";
-const ufisht$2 = "⥾";
-const ufr$2 = "𝔲";
-const ugrav$2 = "ù";
-const ugrave$2 = "ù";
-const uharl$2 = "↿";
-const uharr$2 = "↾";
-const uhblk$2 = "▀";
-const ulcorn$2 = "⌜";
-const ulcorner$2 = "⌜";
-const ulcrop$2 = "⌏";
-const ultri$2 = "◸";
-const umacr$2 = "ū";
-const um$2 = "¨";
-const uml$2 = "¨";
-const uogon$2 = "ų";
-const uopf$2 = "𝕦";
-const uparrow$2 = "↑";
-const updownarrow$2 = "↕";
-const upharpoonleft$2 = "↿";
-const upharpoonright$2 = "↾";
-const uplus$2 = "⊎";
-const upsi$2 = "υ";
-const upsih$2 = "ϒ";
-const upsilon$2 = "υ";
-const upuparrows$2 = "⇈";
-const urcorn$2 = "⌝";
-const urcorner$2 = "⌝";
-const urcrop$2 = "⌎";
-const uring$2 = "ů";
-const urtri$2 = "◹";
-const uscr$2 = "𝓊";
-const utdot$2 = "⋰";
-const utilde$2 = "ũ";
-const utri$2 = "▵";
-const utrif$2 = "▴";
-const uuarr$2 = "⇈";
-const uum$2 = "ü";
-const uuml$2 = "ü";
-const uwangle$2 = "⦧";
-const vArr$2 = "⇕";
-const vBar$2 = "⫨";
-const vBarv$2 = "⫩";
-const vDash$2 = "⊨";
-const vangrt$2 = "⦜";
-const varepsilon$2 = "ϵ";
-const varkappa$2 = "ϰ";
-const varnothing$2 = "∅";
-const varphi$2 = "ϕ";
-const varpi$2 = "ϖ";
-const varpropto$2 = "∝";
-const varr$2 = "↕";
-const varrho$2 = "ϱ";
-const varsigma$2 = "ς";
-const varsubsetneq$2 = "⊊︀";
-const varsubsetneqq$2 = "⫋︀";
-const varsupsetneq$2 = "⊋︀";
-const varsupsetneqq$2 = "⫌︀";
-const vartheta$2 = "ϑ";
-const vartriangleleft$2 = "⊲";
-const vartriangleright$2 = "⊳";
-const vcy$2 = "в";
-const vdash$2 = "⊢";
-const vee$2 = "∨";
-const veebar$2 = "⊻";
-const veeeq$2 = "≚";
-const vellip$2 = "⋮";
-const verbar$2 = "|";
-const vert$2 = "|";
-const vfr$2 = "𝔳";
-const vltri$2 = "⊲";
-const vnsub$2 = "⊂⃒";
-const vnsup$2 = "⊃⃒";
-const vopf$2 = "𝕧";
-const vprop$2 = "∝";
-const vrtri$2 = "⊳";
-const vscr$2 = "𝓋";
-const vsubnE$2 = "⫋︀";
-const vsubne$2 = "⊊︀";
-const vsupnE$2 = "⫌︀";
-const vsupne$2 = "⊋︀";
-const vzigzag$2 = "⦚";
-const wcirc$2 = "ŵ";
-const wedbar$2 = "⩟";
-const wedge$2 = "∧";
-const wedgeq$2 = "≙";
-const weierp$2 = "℘";
-const wfr$2 = "𝔴";
-const wopf$2 = "𝕨";
-const wp$2 = "℘";
-const wr$2 = "≀";
-const wreath$2 = "≀";
-const wscr$2 = "𝓌";
-const xcap$2 = "⋂";
-const xcirc$2 = "◯";
-const xcup$2 = "⋃";
-const xdtri$2 = "▽";
-const xfr$2 = "𝔵";
-const xhArr$2 = "⟺";
-const xharr$2 = "⟷";
-const xi$2 = "ξ";
-const xlArr$2 = "⟸";
-const xlarr$2 = "⟵";
-const xmap$2 = "⟼";
-const xnis$2 = "⋻";
-const xodot$2 = "⨀";
-const xopf$2 = "𝕩";
-const xoplus$2 = "⨁";
-const xotime$2 = "⨂";
-const xrArr$2 = "⟹";
-const xrarr$2 = "⟶";
-const xscr$2 = "𝓍";
-const xsqcup$2 = "⨆";
-const xuplus$2 = "⨄";
-const xutri$2 = "△";
-const xvee$2 = "⋁";
-const xwedge$2 = "⋀";
-const yacut$2 = "ý";
-const yacute$2 = "ý";
-const yacy$2 = "я";
-const ycirc$2 = "ŷ";
-const ycy$2 = "ы";
-const ye$2 = "¥";
-const yen$2 = "¥";
-const yfr$2 = "𝔶";
-const yicy$2 = "ї";
-const yopf$2 = "𝕪";
-const yscr$2 = "𝓎";
-const yucy$2 = "ю";
-const yum$2 = "ÿ";
-const yuml$2 = "ÿ";
-const zacute$2 = "ź";
-const zcaron$2 = "ž";
-const zcy$2 = "з";
-const zdot$2 = "ż";
-const zeetrf$2 = "ℨ";
-const zeta$2 = "ζ";
-const zfr$2 = "𝔷";
-const zhcy$2 = "ж";
-const zigrarr$2 = "⇝";
-const zopf$2 = "𝕫";
-const zscr$2 = "𝓏";
-const zwj$2 = "‍";
-const zwnj$2 = "‌";
-var require$$0$2 = {
- AEli: AEli$2,
- AElig: AElig$2,
- AM: AM$2,
- AMP: AMP$2,
- Aacut: Aacut$2,
- Aacute: Aacute$2,
- Abreve: Abreve$2,
- Acir: Acir$2,
- Acirc: Acirc$2,
- Acy: Acy$2,
- Afr: Afr$2,
- Agrav: Agrav$2,
- Agrave: Agrave$2,
- Alpha: Alpha$2,
- Amacr: Amacr$2,
- And: And$2,
- Aogon: Aogon$2,
- Aopf: Aopf$2,
- ApplyFunction: ApplyFunction$2,
- Arin: Arin$2,
- Aring: Aring$2,
- Ascr: Ascr$2,
- Assign: Assign$2,
- Atild: Atild$2,
- Atilde: Atilde$2,
- Aum: Aum$2,
- Auml: Auml$2,
- Backslash: Backslash$2,
- Barv: Barv$2,
- Barwed: Barwed$2,
- Bcy: Bcy$2,
- Because: Because$2,
- Bernoullis: Bernoullis$2,
- Beta: Beta$2,
- Bfr: Bfr$2,
- Bopf: Bopf$2,
- Breve: Breve$2,
- Bscr: Bscr$2,
- Bumpeq: Bumpeq$2,
- CHcy: CHcy$2,
- COP: COP$2,
- COPY: COPY$2,
- Cacute: Cacute$2,
- Cap: Cap$2,
- CapitalDifferentialD: CapitalDifferentialD$2,
- Cayleys: Cayleys$2,
- Ccaron: Ccaron$2,
- Ccedi: Ccedi$2,
- Ccedil: Ccedil$2,
- Ccirc: Ccirc$2,
- Cconint: Cconint$2,
- Cdot: Cdot$2,
- Cedilla: Cedilla$2,
- CenterDot: CenterDot$2,
- Cfr: Cfr$2,
- Chi: Chi$2,
- CircleDot: CircleDot$2,
- CircleMinus: CircleMinus$2,
- CirclePlus: CirclePlus$2,
- CircleTimes: CircleTimes$2,
- ClockwiseContourIntegral: ClockwiseContourIntegral$2,
- CloseCurlyDoubleQuote: CloseCurlyDoubleQuote$2,
- CloseCurlyQuote: CloseCurlyQuote$2,
- Colon: Colon$2,
- Colone: Colone$2,
- Congruent: Congruent$2,
- Conint: Conint$2,
- ContourIntegral: ContourIntegral$2,
- Copf: Copf$2,
- Coproduct: Coproduct$2,
- CounterClockwiseContourIntegral: CounterClockwiseContourIntegral$2,
- Cross: Cross$2,
- Cscr: Cscr$2,
- Cup: Cup$2,
- CupCap: CupCap$2,
- DD: DD$2,
- DDotrahd: DDotrahd$2,
- DJcy: DJcy$2,
- DScy: DScy$2,
- DZcy: DZcy$2,
- Dagger: Dagger$2,
- Darr: Darr$2,
- Dashv: Dashv$2,
- Dcaron: Dcaron$2,
- Dcy: Dcy$2,
- Del: Del$2,
- Delta: Delta$2,
- Dfr: Dfr$2,
- DiacriticalAcute: DiacriticalAcute$2,
- DiacriticalDot: DiacriticalDot$2,
- DiacriticalDoubleAcute: DiacriticalDoubleAcute$2,
- DiacriticalGrave: DiacriticalGrave$2,
- DiacriticalTilde: DiacriticalTilde$2,
- Diamond: Diamond$2,
- DifferentialD: DifferentialD$2,
- Dopf: Dopf$2,
- Dot: Dot$2,
- DotDot: DotDot$2,
- DotEqual: DotEqual$2,
- DoubleContourIntegral: DoubleContourIntegral$2,
- DoubleDot: DoubleDot$2,
- DoubleDownArrow: DoubleDownArrow$2,
- DoubleLeftArrow: DoubleLeftArrow$2,
- DoubleLeftRightArrow: DoubleLeftRightArrow$2,
- DoubleLeftTee: DoubleLeftTee$2,
- DoubleLongLeftArrow: DoubleLongLeftArrow$2,
- DoubleLongLeftRightArrow: DoubleLongLeftRightArrow$2,
- DoubleLongRightArrow: DoubleLongRightArrow$2,
- DoubleRightArrow: DoubleRightArrow$2,
- DoubleRightTee: DoubleRightTee$2,
- DoubleUpArrow: DoubleUpArrow$2,
- DoubleUpDownArrow: DoubleUpDownArrow$2,
- DoubleVerticalBar: DoubleVerticalBar$2,
- DownArrow: DownArrow$2,
- DownArrowBar: DownArrowBar$2,
- DownArrowUpArrow: DownArrowUpArrow$2,
- DownBreve: DownBreve$2,
- DownLeftRightVector: DownLeftRightVector$2,
- DownLeftTeeVector: DownLeftTeeVector$2,
- DownLeftVector: DownLeftVector$2,
- DownLeftVectorBar: DownLeftVectorBar$2,
- DownRightTeeVector: DownRightTeeVector$2,
- DownRightVector: DownRightVector$2,
- DownRightVectorBar: DownRightVectorBar$2,
- DownTee: DownTee$2,
- DownTeeArrow: DownTeeArrow$2,
- Downarrow: Downarrow$2,
- Dscr: Dscr$2,
- Dstrok: Dstrok$2,
- ENG: ENG$2,
- ET: ET$2,
- ETH: ETH$2,
- Eacut: Eacut$2,
- Eacute: Eacute$2,
- Ecaron: Ecaron$2,
- Ecir: Ecir$2,
- Ecirc: Ecirc$2,
- Ecy: Ecy$2,
- Edot: Edot$2,
- Efr: Efr$2,
- Egrav: Egrav$2,
- Egrave: Egrave$2,
- Element: Element$2,
- Emacr: Emacr$2,
- EmptySmallSquare: EmptySmallSquare$2,
- EmptyVerySmallSquare: EmptyVerySmallSquare$2,
- Eogon: Eogon$2,
- Eopf: Eopf$2,
- Epsilon: Epsilon$2,
- Equal: Equal$2,
- EqualTilde: EqualTilde$2,
- Equilibrium: Equilibrium$2,
- Escr: Escr$2,
- Esim: Esim$2,
- Eta: Eta$2,
- Eum: Eum$2,
- Euml: Euml$2,
- Exists: Exists$2,
- ExponentialE: ExponentialE$2,
- Fcy: Fcy$2,
- Ffr: Ffr$2,
- FilledSmallSquare: FilledSmallSquare$2,
- FilledVerySmallSquare: FilledVerySmallSquare$2,
- Fopf: Fopf$2,
- ForAll: ForAll$2,
- Fouriertrf: Fouriertrf$2,
- Fscr: Fscr$2,
- GJcy: GJcy$2,
- G: G$2,
- GT: GT$2,
- Gamma: Gamma$2,
- Gammad: Gammad$2,
- Gbreve: Gbreve$2,
- Gcedil: Gcedil$2,
- Gcirc: Gcirc$2,
- Gcy: Gcy$2,
- Gdot: Gdot$2,
- Gfr: Gfr$2,
- Gg: Gg$2,
- Gopf: Gopf$2,
- GreaterEqual: GreaterEqual$2,
- GreaterEqualLess: GreaterEqualLess$2,
- GreaterFullEqual: GreaterFullEqual$2,
- GreaterGreater: GreaterGreater$2,
- GreaterLess: GreaterLess$2,
- GreaterSlantEqual: GreaterSlantEqual$2,
- GreaterTilde: GreaterTilde$2,
- Gscr: Gscr$2,
- Gt: Gt$2,
- HARDcy: HARDcy$2,
- Hacek: Hacek$2,
- Hat: Hat$2,
- Hcirc: Hcirc$2,
- Hfr: Hfr$2,
- HilbertSpace: HilbertSpace$2,
- Hopf: Hopf$2,
- HorizontalLine: HorizontalLine$2,
- Hscr: Hscr$2,
- Hstrok: Hstrok$2,
- HumpDownHump: HumpDownHump$2,
- HumpEqual: HumpEqual$2,
- IEcy: IEcy$2,
- IJlig: IJlig$2,
- IOcy: IOcy$2,
- Iacut: Iacut$2,
- Iacute: Iacute$2,
- Icir: Icir$2,
- Icirc: Icirc$2,
- Icy: Icy$2,
- Idot: Idot$2,
- Ifr: Ifr$2,
- Igrav: Igrav$2,
- Igrave: Igrave$2,
- Im: Im$2,
- Imacr: Imacr$2,
- ImaginaryI: ImaginaryI$2,
- Implies: Implies$2,
- Int: Int$2,
- Integral: Integral$2,
- Intersection: Intersection$2,
- InvisibleComma: InvisibleComma$2,
- InvisibleTimes: InvisibleTimes$2,
- Iogon: Iogon$2,
- Iopf: Iopf$2,
- Iota: Iota$2,
- Iscr: Iscr$2,
- Itilde: Itilde$2,
- Iukcy: Iukcy$2,
- Ium: Ium$2,
- Iuml: Iuml$2,
- Jcirc: Jcirc$2,
- Jcy: Jcy$2,
- Jfr: Jfr$2,
- Jopf: Jopf$2,
- Jscr: Jscr$2,
- Jsercy: Jsercy$2,
- Jukcy: Jukcy$2,
- KHcy: KHcy$2,
- KJcy: KJcy$2,
- Kappa: Kappa$2,
- Kcedil: Kcedil$2,
- Kcy: Kcy$2,
- Kfr: Kfr$2,
- Kopf: Kopf$2,
- Kscr: Kscr$2,
- LJcy: LJcy$2,
- L: L$2,
- LT: LT$2,
- Lacute: Lacute$2,
- Lambda: Lambda$2,
- Lang: Lang$2,
- Laplacetrf: Laplacetrf$2,
- Larr: Larr$2,
- Lcaron: Lcaron$2,
- Lcedil: Lcedil$2,
- Lcy: Lcy$2,
- LeftAngleBracket: LeftAngleBracket$2,
- LeftArrow: LeftArrow$2,
- LeftArrowBar: LeftArrowBar$2,
- LeftArrowRightArrow: LeftArrowRightArrow$2,
- LeftCeiling: LeftCeiling$2,
- LeftDoubleBracket: LeftDoubleBracket$2,
- LeftDownTeeVector: LeftDownTeeVector$2,
- LeftDownVector: LeftDownVector$2,
- LeftDownVectorBar: LeftDownVectorBar$2,
- LeftFloor: LeftFloor$2,
- LeftRightArrow: LeftRightArrow$2,
- LeftRightVector: LeftRightVector$2,
- LeftTee: LeftTee$2,
- LeftTeeArrow: LeftTeeArrow$2,
- LeftTeeVector: LeftTeeVector$2,
- LeftTriangle: LeftTriangle$2,
- LeftTriangleBar: LeftTriangleBar$2,
- LeftTriangleEqual: LeftTriangleEqual$2,
- LeftUpDownVector: LeftUpDownVector$2,
- LeftUpTeeVector: LeftUpTeeVector$2,
- LeftUpVector: LeftUpVector$2,
- LeftUpVectorBar: LeftUpVectorBar$2,
- LeftVector: LeftVector$2,
- LeftVectorBar: LeftVectorBar$2,
- Leftarrow: Leftarrow$2,
- Leftrightarrow: Leftrightarrow$2,
- LessEqualGreater: LessEqualGreater$2,
- LessFullEqual: LessFullEqual$2,
- LessGreater: LessGreater$2,
- LessLess: LessLess$2,
- LessSlantEqual: LessSlantEqual$2,
- LessTilde: LessTilde$2,
- Lfr: Lfr$2,
- Ll: Ll$2,
- Lleftarrow: Lleftarrow$2,
- Lmidot: Lmidot$2,
- LongLeftArrow: LongLeftArrow$2,
- LongLeftRightArrow: LongLeftRightArrow$2,
- LongRightArrow: LongRightArrow$2,
- Longleftarrow: Longleftarrow$2,
- Longleftrightarrow: Longleftrightarrow$2,
- Longrightarrow: Longrightarrow$2,
- Lopf: Lopf$2,
- LowerLeftArrow: LowerLeftArrow$2,
- LowerRightArrow: LowerRightArrow$2,
- Lscr: Lscr$2,
- Lsh: Lsh$2,
- Lstrok: Lstrok$2,
- Lt: Lt$2,
- "Map": "⤅",
- Mcy: Mcy$2,
- MediumSpace: MediumSpace$2,
- Mellintrf: Mellintrf$2,
- Mfr: Mfr$2,
- MinusPlus: MinusPlus$2,
- Mopf: Mopf$2,
- Mscr: Mscr$2,
- Mu: Mu$2,
- NJcy: NJcy$2,
- Nacute: Nacute$2,
- Ncaron: Ncaron$2,
- Ncedil: Ncedil$2,
- Ncy: Ncy$2,
- NegativeMediumSpace: NegativeMediumSpace$2,
- NegativeThickSpace: NegativeThickSpace$2,
- NegativeThinSpace: NegativeThinSpace$2,
- NegativeVeryThinSpace: NegativeVeryThinSpace$2,
- NestedGreaterGreater: NestedGreaterGreater$2,
- NestedLessLess: NestedLessLess$2,
- NewLine: NewLine$2,
- Nfr: Nfr$2,
- NoBreak: NoBreak$2,
- NonBreakingSpace: NonBreakingSpace$2,
- Nopf: Nopf$2,
- Not: Not$2,
- NotCongruent: NotCongruent$2,
- NotCupCap: NotCupCap$2,
- NotDoubleVerticalBar: NotDoubleVerticalBar$2,
- NotElement: NotElement$2,
- NotEqual: NotEqual$2,
- NotEqualTilde: NotEqualTilde$2,
- NotExists: NotExists$2,
- NotGreater: NotGreater$2,
- NotGreaterEqual: NotGreaterEqual$2,
- NotGreaterFullEqual: NotGreaterFullEqual$2,
- NotGreaterGreater: NotGreaterGreater$2,
- NotGreaterLess: NotGreaterLess$2,
- NotGreaterSlantEqual: NotGreaterSlantEqual$2,
- NotGreaterTilde: NotGreaterTilde$2,
- NotHumpDownHump: NotHumpDownHump$2,
- NotHumpEqual: NotHumpEqual$2,
- NotLeftTriangle: NotLeftTriangle$2,
- NotLeftTriangleBar: NotLeftTriangleBar$2,
- NotLeftTriangleEqual: NotLeftTriangleEqual$2,
- NotLess: NotLess$2,
- NotLessEqual: NotLessEqual$2,
- NotLessGreater: NotLessGreater$2,
- NotLessLess: NotLessLess$2,
- NotLessSlantEqual: NotLessSlantEqual$2,
- NotLessTilde: NotLessTilde$2,
- NotNestedGreaterGreater: NotNestedGreaterGreater$2,
- NotNestedLessLess: NotNestedLessLess$2,
- NotPrecedes: NotPrecedes$2,
- NotPrecedesEqual: NotPrecedesEqual$2,
- NotPrecedesSlantEqual: NotPrecedesSlantEqual$2,
- NotReverseElement: NotReverseElement$2,
- NotRightTriangle: NotRightTriangle$2,
- NotRightTriangleBar: NotRightTriangleBar$2,
- NotRightTriangleEqual: NotRightTriangleEqual$2,
- NotSquareSubset: NotSquareSubset$2,
- NotSquareSubsetEqual: NotSquareSubsetEqual$2,
- NotSquareSuperset: NotSquareSuperset$2,
- NotSquareSupersetEqual: NotSquareSupersetEqual$2,
- NotSubset: NotSubset$2,
- NotSubsetEqual: NotSubsetEqual$2,
- NotSucceeds: NotSucceeds$2,
- NotSucceedsEqual: NotSucceedsEqual$2,
- NotSucceedsSlantEqual: NotSucceedsSlantEqual$2,
- NotSucceedsTilde: NotSucceedsTilde$2,
- NotSuperset: NotSuperset$2,
- NotSupersetEqual: NotSupersetEqual$2,
- NotTilde: NotTilde$2,
- NotTildeEqual: NotTildeEqual$2,
- NotTildeFullEqual: NotTildeFullEqual$2,
- NotTildeTilde: NotTildeTilde$2,
- NotVerticalBar: NotVerticalBar$2,
- Nscr: Nscr$2,
- Ntild: Ntild$2,
- Ntilde: Ntilde$2,
- Nu: Nu$2,
- OElig: OElig$2,
- Oacut: Oacut$2,
- Oacute: Oacute$2,
- Ocir: Ocir$2,
- Ocirc: Ocirc$2,
- Ocy: Ocy$2,
- Odblac: Odblac$2,
- Ofr: Ofr$2,
- Ograv: Ograv$2,
- Ograve: Ograve$2,
- Omacr: Omacr$2,
- Omega: Omega$2,
- Omicron: Omicron$2,
- Oopf: Oopf$2,
- OpenCurlyDoubleQuote: OpenCurlyDoubleQuote$2,
- OpenCurlyQuote: OpenCurlyQuote$2,
- Or: Or$2,
- Oscr: Oscr$2,
- Oslas: Oslas$2,
- Oslash: Oslash$2,
- Otild: Otild$2,
- Otilde: Otilde$2,
- Otimes: Otimes$2,
- Oum: Oum$2,
- Ouml: Ouml$2,
- OverBar: OverBar$2,
- OverBrace: OverBrace$2,
- OverBracket: OverBracket$2,
- OverParenthesis: OverParenthesis$2,
- PartialD: PartialD$2,
- Pcy: Pcy$2,
- Pfr: Pfr$2,
- Phi: Phi$2,
- Pi: Pi$2,
- PlusMinus: PlusMinus$2,
- Poincareplane: Poincareplane$2,
- Popf: Popf$2,
- Pr: Pr$2,
- Precedes: Precedes$2,
- PrecedesEqual: PrecedesEqual$2,
- PrecedesSlantEqual: PrecedesSlantEqual$2,
- PrecedesTilde: PrecedesTilde$2,
- Prime: Prime$2,
- Product: Product$2,
- Proportion: Proportion$2,
- Proportional: Proportional$2,
- Pscr: Pscr$2,
- Psi: Psi$2,
- QUO: QUO$2,
- QUOT: QUOT$2,
- Qfr: Qfr$2,
- Qopf: Qopf$2,
- Qscr: Qscr$2,
- RBarr: RBarr$2,
- RE: RE$2,
- REG: REG$2,
- Racute: Racute$2,
- Rang: Rang$2,
- Rarr: Rarr$2,
- Rarrtl: Rarrtl$2,
- Rcaron: Rcaron$2,
- Rcedil: Rcedil$2,
- Rcy: Rcy$2,
- Re: Re$2,
- ReverseElement: ReverseElement$2,
- ReverseEquilibrium: ReverseEquilibrium$2,
- ReverseUpEquilibrium: ReverseUpEquilibrium$2,
- Rfr: Rfr$2,
- Rho: Rho$2,
- RightAngleBracket: RightAngleBracket$2,
- RightArrow: RightArrow$2,
- RightArrowBar: RightArrowBar$2,
- RightArrowLeftArrow: RightArrowLeftArrow$2,
- RightCeiling: RightCeiling$2,
- RightDoubleBracket: RightDoubleBracket$2,
- RightDownTeeVector: RightDownTeeVector$2,
- RightDownVector: RightDownVector$2,
- RightDownVectorBar: RightDownVectorBar$2,
- RightFloor: RightFloor$2,
- RightTee: RightTee$2,
- RightTeeArrow: RightTeeArrow$2,
- RightTeeVector: RightTeeVector$2,
- RightTriangle: RightTriangle$2,
- RightTriangleBar: RightTriangleBar$2,
- RightTriangleEqual: RightTriangleEqual$2,
- RightUpDownVector: RightUpDownVector$2,
- RightUpTeeVector: RightUpTeeVector$2,
- RightUpVector: RightUpVector$2,
- RightUpVectorBar: RightUpVectorBar$2,
- RightVector: RightVector$2,
- RightVectorBar: RightVectorBar$2,
- Rightarrow: Rightarrow$2,
- Ropf: Ropf$2,
- RoundImplies: RoundImplies$2,
- Rrightarrow: Rrightarrow$2,
- Rscr: Rscr$2,
- Rsh: Rsh$2,
- RuleDelayed: RuleDelayed$2,
- SHCHcy: SHCHcy$2,
- SHcy: SHcy$2,
- SOFTcy: SOFTcy$2,
- Sacute: Sacute$2,
- Sc: Sc$2,
- Scaron: Scaron$2,
- Scedil: Scedil$2,
- Scirc: Scirc$2,
- Scy: Scy$2,
- Sfr: Sfr$2,
- ShortDownArrow: ShortDownArrow$2,
- ShortLeftArrow: ShortLeftArrow$2,
- ShortRightArrow: ShortRightArrow$2,
- ShortUpArrow: ShortUpArrow$2,
- Sigma: Sigma$2,
- SmallCircle: SmallCircle$2,
- Sopf: Sopf$2,
- Sqrt: Sqrt$2,
- Square: Square$2,
- SquareIntersection: SquareIntersection$2,
- SquareSubset: SquareSubset$2,
- SquareSubsetEqual: SquareSubsetEqual$2,
- SquareSuperset: SquareSuperset$2,
- SquareSupersetEqual: SquareSupersetEqual$2,
- SquareUnion: SquareUnion$2,
- Sscr: Sscr$2,
- Star: Star$2,
- Sub: Sub$2,
- Subset: Subset$2,
- SubsetEqual: SubsetEqual$2,
- Succeeds: Succeeds$2,
- SucceedsEqual: SucceedsEqual$2,
- SucceedsSlantEqual: SucceedsSlantEqual$2,
- SucceedsTilde: SucceedsTilde$2,
- SuchThat: SuchThat$2,
- Sum: Sum$2,
- Sup: Sup$2,
- Superset: Superset$2,
- SupersetEqual: SupersetEqual$2,
- Supset: Supset$2,
- THOR: THOR$2,
- THORN: THORN$2,
- TRADE: TRADE$2,
- TSHcy: TSHcy$2,
- TScy: TScy$2,
- Tab: Tab$2,
- Tau: Tau$2,
- Tcaron: Tcaron$2,
- Tcedil: Tcedil$2,
- Tcy: Tcy$2,
- Tfr: Tfr$2,
- Therefore: Therefore$2,
- Theta: Theta$2,
- ThickSpace: ThickSpace$2,
- ThinSpace: ThinSpace$2,
- Tilde: Tilde$2,
- TildeEqual: TildeEqual$2,
- TildeFullEqual: TildeFullEqual$2,
- TildeTilde: TildeTilde$2,
- Topf: Topf$2,
- TripleDot: TripleDot$2,
- Tscr: Tscr$2,
- Tstrok: Tstrok$2,
- Uacut: Uacut$2,
- Uacute: Uacute$2,
- Uarr: Uarr$2,
- Uarrocir: Uarrocir$2,
- Ubrcy: Ubrcy$2,
- Ubreve: Ubreve$2,
- Ucir: Ucir$2,
- Ucirc: Ucirc$2,
- Ucy: Ucy$2,
- Udblac: Udblac$2,
- Ufr: Ufr$2,
- Ugrav: Ugrav$2,
- Ugrave: Ugrave$2,
- Umacr: Umacr$2,
- UnderBar: UnderBar$2,
- UnderBrace: UnderBrace$2,
- UnderBracket: UnderBracket$2,
- UnderParenthesis: UnderParenthesis$2,
- Union: Union$2,
- UnionPlus: UnionPlus$2,
- Uogon: Uogon$2,
- Uopf: Uopf$2,
- UpArrow: UpArrow$2,
- UpArrowBar: UpArrowBar$2,
- UpArrowDownArrow: UpArrowDownArrow$2,
- UpDownArrow: UpDownArrow$2,
- UpEquilibrium: UpEquilibrium$2,
- UpTee: UpTee$2,
- UpTeeArrow: UpTeeArrow$2,
- Uparrow: Uparrow$2,
- Updownarrow: Updownarrow$2,
- UpperLeftArrow: UpperLeftArrow$2,
- UpperRightArrow: UpperRightArrow$2,
- Upsi: Upsi$2,
- Upsilon: Upsilon$2,
- Uring: Uring$2,
- Uscr: Uscr$2,
- Utilde: Utilde$2,
- Uum: Uum$2,
- Uuml: Uuml$2,
- VDash: VDash$2,
- Vbar: Vbar$2,
- Vcy: Vcy$2,
- Vdash: Vdash$2,
- Vdashl: Vdashl$2,
- Vee: Vee$2,
- Verbar: Verbar$2,
- Vert: Vert$2,
- VerticalBar: VerticalBar$2,
- VerticalLine: VerticalLine$2,
- VerticalSeparator: VerticalSeparator$2,
- VerticalTilde: VerticalTilde$2,
- VeryThinSpace: VeryThinSpace$2,
- Vfr: Vfr$2,
- Vopf: Vopf$2,
- Vscr: Vscr$2,
- Vvdash: Vvdash$2,
- Wcirc: Wcirc$2,
- Wedge: Wedge$2,
- Wfr: Wfr$2,
- Wopf: Wopf$2,
- Wscr: Wscr$2,
- Xfr: Xfr$2,
- Xi: Xi$2,
- Xopf: Xopf$2,
- Xscr: Xscr$2,
- YAcy: YAcy$2,
- YIcy: YIcy$2,
- YUcy: YUcy$2,
- Yacut: Yacut$2,
- Yacute: Yacute$2,
- Ycirc: Ycirc$2,
- Ycy: Ycy$2,
- Yfr: Yfr$2,
- Yopf: Yopf$2,
- Yscr: Yscr$2,
- Yuml: Yuml$2,
- ZHcy: ZHcy$2,
- Zacute: Zacute$2,
- Zcaron: Zcaron$2,
- Zcy: Zcy$2,
- Zdot: Zdot$2,
- ZeroWidthSpace: ZeroWidthSpace$2,
- Zeta: Zeta$2,
- Zfr: Zfr$2,
- Zopf: Zopf$2,
- Zscr: Zscr$2,
- aacut: aacut$2,
- aacute: aacute$2,
- abreve: abreve$2,
- ac: ac$2,
- acE: acE$2,
- acd: acd$2,
- acir: acir$2,
- acirc: acirc$2,
- acut: acut$2,
- acute: acute$2,
- acy: acy$2,
- aeli: aeli$2,
- aelig: aelig$2,
- af: af$2,
- afr: afr$2,
- agrav: agrav$2,
- agrave: agrave$2,
- alefsym: alefsym$2,
- aleph: aleph$2,
- alpha: alpha$2,
- amacr: amacr$2,
- amalg: amalg$2,
- am: am$2,
- amp: amp$2,
- and: and$2,
- andand: andand$2,
- andd: andd$2,
- andslope: andslope$2,
- andv: andv$2,
- ang: ang$2,
- ange: ange$2,
- angle: angle$2,
- angmsd: angmsd$2,
- angmsdaa: angmsdaa$2,
- angmsdab: angmsdab$2,
- angmsdac: angmsdac$2,
- angmsdad: angmsdad$2,
- angmsdae: angmsdae$2,
- angmsdaf: angmsdaf$2,
- angmsdag: angmsdag$2,
- angmsdah: angmsdah$2,
- angrt: angrt$2,
- angrtvb: angrtvb$2,
- angrtvbd: angrtvbd$2,
- angsph: angsph$2,
- angst: angst$2,
- angzarr: angzarr$2,
- aogon: aogon$2,
- aopf: aopf$2,
- ap: ap$2,
- apE: apE$2,
- apacir: apacir$2,
- ape: ape$2,
- apid: apid$2,
- apos: apos$2,
- approx: approx$2,
- approxeq: approxeq$2,
- arin: arin$2,
- aring: aring$2,
- ascr: ascr$2,
- ast: ast$2,
- asymp: asymp$2,
- asympeq: asympeq$2,
- atild: atild$2,
- atilde: atilde$2,
- aum: aum$2,
- auml: auml$2,
- awconint: awconint$2,
- awint: awint$2,
- bNot: bNot$2,
- backcong: backcong$2,
- backepsilon: backepsilon$2,
- backprime: backprime$2,
- backsim: backsim$2,
- backsimeq: backsimeq$2,
- barvee: barvee$2,
- barwed: barwed$2,
- barwedge: barwedge$2,
- bbrk: bbrk$2,
- bbrktbrk: bbrktbrk$2,
- bcong: bcong$2,
- bcy: bcy$2,
- bdquo: bdquo$2,
- becaus: becaus$2,
- because: because$2,
- bemptyv: bemptyv$2,
- bepsi: bepsi$2,
- bernou: bernou$2,
- beta: beta$2,
- beth: beth$2,
- between: between$2,
- bfr: bfr$2,
- bigcap: bigcap$2,
- bigcirc: bigcirc$2,
- bigcup: bigcup$2,
- bigodot: bigodot$2,
- bigoplus: bigoplus$2,
- bigotimes: bigotimes$2,
- bigsqcup: bigsqcup$2,
- bigstar: bigstar$2,
- bigtriangledown: bigtriangledown$2,
- bigtriangleup: bigtriangleup$2,
- biguplus: biguplus$2,
- bigvee: bigvee$2,
- bigwedge: bigwedge$2,
- bkarow: bkarow$2,
- blacklozenge: blacklozenge$2,
- blacksquare: blacksquare$2,
- blacktriangle: blacktriangle$2,
- blacktriangledown: blacktriangledown$2,
- blacktriangleleft: blacktriangleleft$2,
- blacktriangleright: blacktriangleright$2,
- blank: blank$2,
- blk12: blk12$2,
- blk14: blk14$2,
- blk34: blk34$2,
- block: block$2,
- bne: bne$2,
- bnequiv: bnequiv$2,
- bnot: bnot$2,
- bopf: bopf$2,
- bot: bot$2,
- bottom: bottom$2,
- bowtie: bowtie$2,
- boxDL: boxDL$2,
- boxDR: boxDR$2,
- boxDl: boxDl$2,
- boxDr: boxDr$2,
- boxH: boxH$2,
- boxHD: boxHD$2,
- boxHU: boxHU$2,
- boxHd: boxHd$2,
- boxHu: boxHu$2,
- boxUL: boxUL$2,
- boxUR: boxUR$2,
- boxUl: boxUl$2,
- boxUr: boxUr$2,
- boxV: boxV$2,
- boxVH: boxVH$2,
- boxVL: boxVL$2,
- boxVR: boxVR$2,
- boxVh: boxVh$2,
- boxVl: boxVl$2,
- boxVr: boxVr$2,
- boxbox: boxbox$2,
- boxdL: boxdL$2,
- boxdR: boxdR$2,
- boxdl: boxdl$2,
- boxdr: boxdr$2,
- boxh: boxh$2,
- boxhD: boxhD$2,
- boxhU: boxhU$2,
- boxhd: boxhd$2,
- boxhu: boxhu$2,
- boxminus: boxminus$2,
- boxplus: boxplus$2,
- boxtimes: boxtimes$2,
- boxuL: boxuL$2,
- boxuR: boxuR$2,
- boxul: boxul$2,
- boxur: boxur$2,
- boxv: boxv$2,
- boxvH: boxvH$2,
- boxvL: boxvL$2,
- boxvR: boxvR$2,
- boxvh: boxvh$2,
- boxvl: boxvl$2,
- boxvr: boxvr$2,
- bprime: bprime$2,
- breve: breve$2,
- brvba: brvba$2,
- brvbar: brvbar$2,
- bscr: bscr$2,
- bsemi: bsemi$2,
- bsim: bsim$2,
- bsime: bsime$2,
- bsol: bsol$2,
- bsolb: bsolb$2,
- bsolhsub: bsolhsub$2,
- bull: bull$2,
- bullet: bullet$2,
- bump: bump$2,
- bumpE: bumpE$2,
- bumpe: bumpe$2,
- bumpeq: bumpeq$2,
- cacute: cacute$2,
- cap: cap$2,
- capand: capand$2,
- capbrcup: capbrcup$2,
- capcap: capcap$2,
- capcup: capcup$2,
- capdot: capdot$2,
- caps: caps$2,
- caret: caret$2,
- caron: caron$2,
- ccaps: ccaps$2,
- ccaron: ccaron$2,
- ccedi: ccedi$2,
- ccedil: ccedil$2,
- ccirc: ccirc$2,
- ccups: ccups$2,
- ccupssm: ccupssm$2,
- cdot: cdot$2,
- cedi: cedi$2,
- cedil: cedil$2,
- cemptyv: cemptyv$2,
- cen: cen$2,
- cent: cent$2,
- centerdot: centerdot$2,
- cfr: cfr$2,
- chcy: chcy$2,
- check: check$3,
- checkmark: checkmark$2,
- chi: chi$2,
- cir: cir$2,
- cirE: cirE$2,
- circ: circ$2,
- circeq: circeq$2,
- circlearrowleft: circlearrowleft$2,
- circlearrowright: circlearrowright$2,
- circledR: circledR$2,
- circledS: circledS$2,
- circledast: circledast$2,
- circledcirc: circledcirc$2,
- circleddash: circleddash$2,
- cire: cire$2,
- cirfnint: cirfnint$2,
- cirmid: cirmid$2,
- cirscir: cirscir$2,
- clubs: clubs$2,
- clubsuit: clubsuit$2,
- colon: colon$2,
- colone: colone$2,
- coloneq: coloneq$2,
- comma: comma$2,
- commat: commat$2,
- comp: comp$2,
- compfn: compfn$2,
- complement: complement$2,
- complexes: complexes$2,
- cong: cong$2,
- congdot: congdot$2,
- conint: conint$2,
- copf: copf$2,
- coprod: coprod$2,
- cop: cop$2,
- copy: copy$2,
- copysr: copysr$2,
- crarr: crarr$2,
- cross: cross$2,
- cscr: cscr$2,
- csub: csub$2,
- csube: csube$2,
- csup: csup$2,
- csupe: csupe$2,
- ctdot: ctdot$2,
- cudarrl: cudarrl$2,
- cudarrr: cudarrr$2,
- cuepr: cuepr$2,
- cuesc: cuesc$2,
- cularr: cularr$2,
- cularrp: cularrp$2,
- cup: cup$2,
- cupbrcap: cupbrcap$2,
- cupcap: cupcap$2,
- cupcup: cupcup$2,
- cupdot: cupdot$2,
- cupor: cupor$2,
- cups: cups$2,
- curarr: curarr$2,
- curarrm: curarrm$2,
- curlyeqprec: curlyeqprec$2,
- curlyeqsucc: curlyeqsucc$2,
- curlyvee: curlyvee$2,
- curlywedge: curlywedge$2,
- curre: curre$2,
- curren: curren$2,
- curvearrowleft: curvearrowleft$2,
- curvearrowright: curvearrowright$2,
- cuvee: cuvee$2,
- cuwed: cuwed$2,
- cwconint: cwconint$2,
- cwint: cwint$2,
- cylcty: cylcty$2,
- dArr: dArr$2,
- dHar: dHar$2,
- dagger: dagger$2,
- daleth: daleth$2,
- darr: darr$2,
- dash: dash$2,
- dashv: dashv$2,
- dbkarow: dbkarow$2,
- dblac: dblac$2,
- dcaron: dcaron$2,
- dcy: dcy$2,
- dd: dd$2,
- ddagger: ddagger$2,
- ddarr: ddarr$2,
- ddotseq: ddotseq$2,
- de: de$2,
- deg: deg$2,
- delta: delta$2,
- demptyv: demptyv$2,
- dfisht: dfisht$2,
- dfr: dfr$2,
- dharl: dharl$2,
- dharr: dharr$2,
- diam: diam$2,
- diamond: diamond$2,
- diamondsuit: diamondsuit$2,
- diams: diams$2,
- die: die$2,
- digamma: digamma$2,
- disin: disin$2,
- div: div$2,
- divid: divid$2,
- divide: divide$2,
- divideontimes: divideontimes$2,
- divonx: divonx$2,
- djcy: djcy$2,
- dlcorn: dlcorn$2,
- dlcrop: dlcrop$2,
- dollar: dollar$2,
- dopf: dopf$2,
- dot: dot$2,
- doteq: doteq$2,
- doteqdot: doteqdot$2,
- dotminus: dotminus$2,
- dotplus: dotplus$2,
- dotsquare: dotsquare$2,
- doublebarwedge: doublebarwedge$2,
- downarrow: downarrow$2,
- downdownarrows: downdownarrows$2,
- downharpoonleft: downharpoonleft$2,
- downharpoonright: downharpoonright$2,
- drbkarow: drbkarow$2,
- drcorn: drcorn$2,
- drcrop: drcrop$2,
- dscr: dscr$2,
- dscy: dscy$2,
- dsol: dsol$2,
- dstrok: dstrok$2,
- dtdot: dtdot$2,
- dtri: dtri$2,
- dtrif: dtrif$2,
- duarr: duarr$2,
- duhar: duhar$2,
- dwangle: dwangle$2,
- dzcy: dzcy$2,
- dzigrarr: dzigrarr$2,
- eDDot: eDDot$2,
- eDot: eDot$2,
- eacut: eacut$2,
- eacute: eacute$2,
- easter: easter$2,
- ecaron: ecaron$2,
- ecir: ecir$2,
- ecirc: ecirc$2,
- ecolon: ecolon$2,
- ecy: ecy$2,
- edot: edot$2,
- ee: ee$2,
- efDot: efDot$2,
- efr: efr$2,
- eg: eg$2,
- egrav: egrav$2,
- egrave: egrave$2,
- egs: egs$2,
- egsdot: egsdot$2,
- el: el$2,
- elinters: elinters$2,
- ell: ell$2,
- els: els$2,
- elsdot: elsdot$2,
- emacr: emacr$2,
- empty: empty$2,
- emptyset: emptyset$2,
- emptyv: emptyv$2,
- emsp13: emsp13$2,
- emsp14: emsp14$2,
- emsp: emsp$2,
- eng: eng$2,
- ensp: ensp$2,
- eogon: eogon$2,
- eopf: eopf$2,
- epar: epar$2,
- eparsl: eparsl$2,
- eplus: eplus$2,
- epsi: epsi$2,
- epsilon: epsilon$2,
- epsiv: epsiv$2,
- eqcirc: eqcirc$2,
- eqcolon: eqcolon$2,
- eqsim: eqsim$2,
- eqslantgtr: eqslantgtr$2,
- eqslantless: eqslantless$2,
- equals: equals$2,
- equest: equest$2,
- equiv: equiv$2,
- equivDD: equivDD$2,
- eqvparsl: eqvparsl$2,
- erDot: erDot$2,
- erarr: erarr$2,
- escr: escr$2,
- esdot: esdot$2,
- esim: esim$2,
- eta: eta$2,
- et: et$2,
- eth: eth$2,
- eum: eum$2,
- euml: euml$2,
- euro: euro$2,
- excl: excl$2,
- exist: exist$2,
- expectation: expectation$2,
- exponentiale: exponentiale$2,
- fallingdotseq: fallingdotseq$2,
- fcy: fcy$2,
- female: female$2,
- ffilig: ffilig$2,
- fflig: fflig$2,
- ffllig: ffllig$2,
- ffr: ffr$2,
- filig: filig$2,
- fjlig: fjlig$2,
- flat: flat$2,
- fllig: fllig$2,
- fltns: fltns$2,
- fnof: fnof$2,
- fopf: fopf$2,
- forall: forall$2,
- fork: fork$2,
- forkv: forkv$2,
- fpartint: fpartint$2,
- frac1: frac1$2,
- frac12: frac12$2,
- frac13: frac13$2,
- frac14: frac14$2,
- frac15: frac15$2,
- frac16: frac16$2,
- frac18: frac18$2,
- frac23: frac23$2,
- frac25: frac25$2,
- frac3: frac3$2,
- frac34: frac34$2,
- frac35: frac35$2,
- frac38: frac38$2,
- frac45: frac45$2,
- frac56: frac56$2,
- frac58: frac58$2,
- frac78: frac78$2,
- frasl: frasl$2,
- frown: frown$2,
- fscr: fscr$2,
- gE: gE$2,
- gEl: gEl$2,
- gacute: gacute$2,
- gamma: gamma$2,
- gammad: gammad$2,
- gap: gap$2,
- gbreve: gbreve$2,
- gcirc: gcirc$2,
- gcy: gcy$2,
- gdot: gdot$2,
- ge: ge$2,
- gel: gel$2,
- geq: geq$2,
- geqq: geqq$2,
- geqslant: geqslant$2,
- ges: ges$2,
- gescc: gescc$2,
- gesdot: gesdot$2,
- gesdoto: gesdoto$2,
- gesdotol: gesdotol$2,
- gesl: gesl$2,
- gesles: gesles$2,
- gfr: gfr$2,
- gg: gg$2,
- ggg: ggg$2,
- gimel: gimel$2,
- gjcy: gjcy$2,
- gl: gl$2,
- glE: glE$2,
- gla: gla$2,
- glj: glj$2,
- gnE: gnE$2,
- gnap: gnap$2,
- gnapprox: gnapprox$2,
- gne: gne$2,
- gneq: gneq$2,
- gneqq: gneqq$2,
- gnsim: gnsim$2,
- gopf: gopf$2,
- grave: grave$2,
- gscr: gscr$2,
- gsim: gsim$2,
- gsime: gsime$2,
- gsiml: gsiml$2,
- g: g$2,
- gt: gt$2,
- gtcc: gtcc$2,
- gtcir: gtcir$2,
- gtdot: gtdot$2,
- gtlPar: gtlPar$2,
- gtquest: gtquest$2,
- gtrapprox: gtrapprox$2,
- gtrarr: gtrarr$2,
- gtrdot: gtrdot$2,
- gtreqless: gtreqless$2,
- gtreqqless: gtreqqless$2,
- gtrless: gtrless$2,
- gtrsim: gtrsim$2,
- gvertneqq: gvertneqq$2,
- gvnE: gvnE$2,
- hArr: hArr$2,
- hairsp: hairsp$2,
- half: half$2,
- hamilt: hamilt$2,
- hardcy: hardcy$2,
- harr: harr$2,
- harrcir: harrcir$2,
- harrw: harrw$2,
- hbar: hbar$2,
- hcirc: hcirc$2,
- hearts: hearts$2,
- heartsuit: heartsuit$2,
- hellip: hellip$2,
- hercon: hercon$2,
- hfr: hfr$2,
- hksearow: hksearow$2,
- hkswarow: hkswarow$2,
- hoarr: hoarr$2,
- homtht: homtht$2,
- hookleftarrow: hookleftarrow$2,
- hookrightarrow: hookrightarrow$2,
- hopf: hopf$2,
- horbar: horbar$2,
- hscr: hscr$2,
- hslash: hslash$2,
- hstrok: hstrok$2,
- hybull: hybull$2,
- hyphen: hyphen$2,
- iacut: iacut$2,
- iacute: iacute$2,
- ic: ic$2,
- icir: icir$2,
- icirc: icirc$2,
- icy: icy$2,
- iecy: iecy$2,
- iexc: iexc$2,
- iexcl: iexcl$2,
- iff: iff$2,
- ifr: ifr$2,
- igrav: igrav$2,
- igrave: igrave$2,
- ii: ii$2,
- iiiint: iiiint$2,
- iiint: iiint$2,
- iinfin: iinfin$2,
- iiota: iiota$2,
- ijlig: ijlig$2,
- imacr: imacr$2,
- image: image$3,
- imagline: imagline$2,
- imagpart: imagpart$2,
- imath: imath$2,
- imof: imof$2,
- imped: imped$2,
- "in": "∈",
- incare: incare$2,
- infin: infin$2,
- infintie: infintie$2,
- inodot: inodot$2,
- int: int$3,
- intcal: intcal$2,
- integers: integers$2,
- intercal: intercal$2,
- intlarhk: intlarhk$2,
- intprod: intprod$2,
- iocy: iocy$2,
- iogon: iogon$2,
- iopf: iopf$2,
- iota: iota$2,
- iprod: iprod$2,
- iques: iques$2,
- iquest: iquest$2,
- iscr: iscr$2,
- isin: isin$2,
- isinE: isinE$2,
- isindot: isindot$2,
- isins: isins$2,
- isinsv: isinsv$2,
- isinv: isinv$2,
- it: it$2,
- itilde: itilde$2,
- iukcy: iukcy$2,
- ium: ium$2,
- iuml: iuml$2,
- jcirc: jcirc$2,
- jcy: jcy$2,
- jfr: jfr$2,
- jmath: jmath$2,
- jopf: jopf$2,
- jscr: jscr$2,
- jsercy: jsercy$2,
- jukcy: jukcy$2,
- kappa: kappa$2,
- kappav: kappav$2,
- kcedil: kcedil$2,
- kcy: kcy$2,
- kfr: kfr$2,
- kgreen: kgreen$2,
- khcy: khcy$2,
- kjcy: kjcy$2,
- kopf: kopf$2,
- kscr: kscr$2,
- lAarr: lAarr$2,
- lArr: lArr$2,
- lAtail: lAtail$2,
- lBarr: lBarr$2,
- lE: lE$2,
- lEg: lEg$2,
- lHar: lHar$2,
- lacute: lacute$2,
- laemptyv: laemptyv$2,
- lagran: lagran$2,
- lambda: lambda$2,
- lang: lang$2,
- langd: langd$2,
- langle: langle$2,
- lap: lap$2,
- laqu: laqu$2,
- laquo: laquo$2,
- larr: larr$2,
- larrb: larrb$2,
- larrbfs: larrbfs$2,
- larrfs: larrfs$2,
- larrhk: larrhk$2,
- larrlp: larrlp$2,
- larrpl: larrpl$2,
- larrsim: larrsim$2,
- larrtl: larrtl$2,
- lat: lat$2,
- latail: latail$2,
- late: late$2,
- lates: lates$2,
- lbarr: lbarr$2,
- lbbrk: lbbrk$2,
- lbrace: lbrace$2,
- lbrack: lbrack$2,
- lbrke: lbrke$2,
- lbrksld: lbrksld$2,
- lbrkslu: lbrkslu$2,
- lcaron: lcaron$2,
- lcedil: lcedil$2,
- lceil: lceil$2,
- lcub: lcub$2,
- lcy: lcy$2,
- ldca: ldca$2,
- ldquo: ldquo$2,
- ldquor: ldquor$2,
- ldrdhar: ldrdhar$2,
- ldrushar: ldrushar$2,
- ldsh: ldsh$2,
- le: le$2,
- leftarrow: leftarrow$2,
- leftarrowtail: leftarrowtail$2,
- leftharpoondown: leftharpoondown$2,
- leftharpoonup: leftharpoonup$2,
- leftleftarrows: leftleftarrows$2,
- leftrightarrow: leftrightarrow$2,
- leftrightarrows: leftrightarrows$2,
- leftrightharpoons: leftrightharpoons$2,
- leftrightsquigarrow: leftrightsquigarrow$2,
- leftthreetimes: leftthreetimes$2,
- leg: leg$2,
- leq: leq$2,
- leqq: leqq$2,
- leqslant: leqslant$2,
- les: les$2,
- lescc: lescc$2,
- lesdot: lesdot$2,
- lesdoto: lesdoto$2,
- lesdotor: lesdotor$2,
- lesg: lesg$2,
- lesges: lesges$2,
- lessapprox: lessapprox$2,
- lessdot: lessdot$2,
- lesseqgtr: lesseqgtr$2,
- lesseqqgtr: lesseqqgtr$2,
- lessgtr: lessgtr$2,
- lesssim: lesssim$2,
- lfisht: lfisht$2,
- lfloor: lfloor$2,
- lfr: lfr$2,
- lg: lg$2,
- lgE: lgE$2,
- lhard: lhard$2,
- lharu: lharu$2,
- lharul: lharul$2,
- lhblk: lhblk$2,
- ljcy: ljcy$2,
- ll: ll$2,
- llarr: llarr$2,
- llcorner: llcorner$2,
- llhard: llhard$2,
- lltri: lltri$2,
- lmidot: lmidot$2,
- lmoust: lmoust$2,
- lmoustache: lmoustache$2,
- lnE: lnE$2,
- lnap: lnap$2,
- lnapprox: lnapprox$2,
- lne: lne$2,
- lneq: lneq$2,
- lneqq: lneqq$2,
- lnsim: lnsim$2,
- loang: loang$2,
- loarr: loarr$2,
- lobrk: lobrk$2,
- longleftarrow: longleftarrow$2,
- longleftrightarrow: longleftrightarrow$2,
- longmapsto: longmapsto$2,
- longrightarrow: longrightarrow$2,
- looparrowleft: looparrowleft$2,
- looparrowright: looparrowright$2,
- lopar: lopar$2,
- lopf: lopf$2,
- loplus: loplus$2,
- lotimes: lotimes$2,
- lowast: lowast$2,
- lowbar: lowbar$2,
- loz: loz$2,
- lozenge: lozenge$2,
- lozf: lozf$2,
- lpar: lpar$2,
- lparlt: lparlt$2,
- lrarr: lrarr$2,
- lrcorner: lrcorner$2,
- lrhar: lrhar$2,
- lrhard: lrhard$2,
- lrm: lrm$2,
- lrtri: lrtri$2,
- lsaquo: lsaquo$2,
- lscr: lscr$2,
- lsh: lsh$2,
- lsim: lsim$2,
- lsime: lsime$2,
- lsimg: lsimg$2,
- lsqb: lsqb$2,
- lsquo: lsquo$2,
- lsquor: lsquor$2,
- lstrok: lstrok$2,
- l: l$2,
- lt: lt$3,
- ltcc: ltcc$2,
- ltcir: ltcir$2,
- ltdot: ltdot$2,
- lthree: lthree$2,
- ltimes: ltimes$2,
- ltlarr: ltlarr$2,
- ltquest: ltquest$2,
- ltrPar: ltrPar$2,
- ltri: ltri$2,
- ltrie: ltrie$2,
- ltrif: ltrif$2,
- lurdshar: lurdshar$2,
- luruhar: luruhar$2,
- lvertneqq: lvertneqq$2,
- lvnE: lvnE$2,
- mDDot: mDDot$2,
- mac: mac$2,
- macr: macr$2,
- male: male$2,
- malt: malt$2,
- maltese: maltese$2,
- map: map$5,
- mapsto: mapsto$2,
- mapstodown: mapstodown$2,
- mapstoleft: mapstoleft$2,
- mapstoup: mapstoup$2,
- marker: marker$2,
- mcomma: mcomma$2,
- mcy: mcy$2,
- mdash: mdash$2,
- measuredangle: measuredangle$2,
- mfr: mfr$2,
- mho: mho$2,
- micr: micr$2,
- micro: micro$2,
- mid: mid$2,
- midast: midast$2,
- midcir: midcir$2,
- middo: middo$2,
- middot: middot$2,
- minus: minus$2,
- minusb: minusb$2,
- minusd: minusd$2,
- minusdu: minusdu$2,
- mlcp: mlcp$2,
- mldr: mldr$2,
- mnplus: mnplus$2,
- models: models$2,
- mopf: mopf$2,
- mp: mp$2,
- mscr: mscr$2,
- mstpos: mstpos$2,
- mu: mu$2,
- multimap: multimap$2,
- mumap: mumap$2,
- nGg: nGg$2,
- nGt: nGt$2,
- nGtv: nGtv$2,
- nLeftarrow: nLeftarrow$2,
- nLeftrightarrow: nLeftrightarrow$2,
- nLl: nLl$2,
- nLt: nLt$2,
- nLtv: nLtv$2,
- nRightarrow: nRightarrow$2,
- nVDash: nVDash$2,
- nVdash: nVdash$2,
- nabla: nabla$2,
- nacute: nacute$2,
- nang: nang$2,
- nap: nap$2,
- napE: napE$2,
- napid: napid$2,
- napos: napos$2,
- napprox: napprox$2,
- natur: natur$2,
- natural: natural$2,
- naturals: naturals$2,
- nbs: nbs$2,
- nbsp: nbsp$2,
- nbump: nbump$2,
- nbumpe: nbumpe$2,
- ncap: ncap$2,
- ncaron: ncaron$2,
- ncedil: ncedil$2,
- ncong: ncong$2,
- ncongdot: ncongdot$2,
- ncup: ncup$2,
- ncy: ncy$2,
- ndash: ndash$2,
- ne: ne$2,
- neArr: neArr$2,
- nearhk: nearhk$2,
- nearr: nearr$2,
- nearrow: nearrow$2,
- nedot: nedot$2,
- nequiv: nequiv$2,
- nesear: nesear$2,
- nesim: nesim$2,
- nexist: nexist$2,
- nexists: nexists$2,
- nfr: nfr$2,
- ngE: ngE$2,
- nge: nge$2,
- ngeq: ngeq$2,
- ngeqq: ngeqq$2,
- ngeqslant: ngeqslant$2,
- nges: nges$2,
- ngsim: ngsim$2,
- ngt: ngt$2,
- ngtr: ngtr$2,
- nhArr: nhArr$2,
- nharr: nharr$2,
- nhpar: nhpar$2,
- ni: ni$2,
- nis: nis$2,
- nisd: nisd$2,
- niv: niv$2,
- njcy: njcy$2,
- nlArr: nlArr$2,
- nlE: nlE$2,
- nlarr: nlarr$2,
- nldr: nldr$2,
- nle: nle$2,
- nleftarrow: nleftarrow$2,
- nleftrightarrow: nleftrightarrow$2,
- nleq: nleq$2,
- nleqq: nleqq$2,
- nleqslant: nleqslant$2,
- nles: nles$2,
- nless: nless$2,
- nlsim: nlsim$2,
- nlt: nlt$2,
- nltri: nltri$2,
- nltrie: nltrie$2,
- nmid: nmid$2,
- nopf: nopf$2,
- no: no$2,
- not: not$2,
- notin: notin$2,
- notinE: notinE$2,
- notindot: notindot$2,
- notinva: notinva$2,
- notinvb: notinvb$2,
- notinvc: notinvc$2,
- notni: notni$2,
- notniva: notniva$2,
- notnivb: notnivb$2,
- notnivc: notnivc$2,
- npar: npar$2,
- nparallel: nparallel$2,
- nparsl: nparsl$2,
- npart: npart$2,
- npolint: npolint$2,
- npr: npr$2,
- nprcue: nprcue$2,
- npre: npre$2,
- nprec: nprec$2,
- npreceq: npreceq$2,
- nrArr: nrArr$2,
- nrarr: nrarr$2,
- nrarrc: nrarrc$2,
- nrarrw: nrarrw$2,
- nrightarrow: nrightarrow$2,
- nrtri: nrtri$2,
- nrtrie: nrtrie$2,
- nsc: nsc$2,
- nsccue: nsccue$2,
- nsce: nsce$2,
- nscr: nscr$2,
- nshortmid: nshortmid$2,
- nshortparallel: nshortparallel$2,
- nsim: nsim$2,
- nsime: nsime$2,
- nsimeq: nsimeq$2,
- nsmid: nsmid$2,
- nspar: nspar$2,
- nsqsube: nsqsube$2,
- nsqsupe: nsqsupe$2,
- nsub: nsub$2,
- nsubE: nsubE$2,
- nsube: nsube$2,
- nsubset: nsubset$2,
- nsubseteq: nsubseteq$2,
- nsubseteqq: nsubseteqq$2,
- nsucc: nsucc$2,
- nsucceq: nsucceq$2,
- nsup: nsup$2,
- nsupE: nsupE$2,
- nsupe: nsupe$2,
- nsupset: nsupset$2,
- nsupseteq: nsupseteq$2,
- nsupseteqq: nsupseteqq$2,
- ntgl: ntgl$2,
- ntild: ntild$2,
- ntilde: ntilde$2,
- ntlg: ntlg$2,
- ntriangleleft: ntriangleleft$2,
- ntrianglelefteq: ntrianglelefteq$2,
- ntriangleright: ntriangleright$2,
- ntrianglerighteq: ntrianglerighteq$2,
- nu: nu$2,
- num: num$2,
- numero: numero$2,
- numsp: numsp$2,
- nvDash: nvDash$2,
- nvHarr: nvHarr$2,
- nvap: nvap$2,
- nvdash: nvdash$2,
- nvge: nvge$2,
- nvgt: nvgt$2,
- nvinfin: nvinfin$2,
- nvlArr: nvlArr$2,
- nvle: nvle$2,
- nvlt: nvlt$2,
- nvltrie: nvltrie$2,
- nvrArr: nvrArr$2,
- nvrtrie: nvrtrie$2,
- nvsim: nvsim$2,
- nwArr: nwArr$2,
- nwarhk: nwarhk$2,
- nwarr: nwarr$2,
- nwarrow: nwarrow$2,
- nwnear: nwnear$2,
- oS: oS$2,
- oacut: oacut$2,
- oacute: oacute$2,
- oast: oast$2,
- ocir: ocir$2,
- ocirc: ocirc$2,
- ocy: ocy$2,
- odash: odash$2,
- odblac: odblac$2,
- odiv: odiv$2,
- odot: odot$2,
- odsold: odsold$2,
- oelig: oelig$2,
- ofcir: ofcir$2,
- ofr: ofr$2,
- ogon: ogon$2,
- ograv: ograv$2,
- ograve: ograve$2,
- ogt: ogt$2,
- ohbar: ohbar$2,
- ohm: ohm$2,
- oint: oint$2,
- olarr: olarr$2,
- olcir: olcir$2,
- olcross: olcross$2,
- oline: oline$2,
- olt: olt$2,
- omacr: omacr$2,
- omega: omega$2,
- omicron: omicron$2,
- omid: omid$2,
- ominus: ominus$2,
- oopf: oopf$2,
- opar: opar$2,
- operp: operp$2,
- oplus: oplus$2,
- or: or$2,
- orarr: orarr$2,
- ord: ord$2,
- order: order$2,
- orderof: orderof$2,
- ordf: ordf$2,
- ordm: ordm$2,
- origof: origof$2,
- oror: oror$2,
- orslope: orslope$2,
- orv: orv$2,
- oscr: oscr$2,
- oslas: oslas$2,
- oslash: oslash$2,
- osol: osol$2,
- otild: otild$2,
- otilde: otilde$2,
- otimes: otimes$2,
- otimesas: otimesas$2,
- oum: oum$2,
- ouml: ouml$2,
- ovbar: ovbar$2,
- par: par$2,
- para: para$2,
- parallel: parallel$2,
- parsim: parsim$2,
- parsl: parsl$2,
- part: part$2,
- pcy: pcy$2,
- percnt: percnt$2,
- period: period$2,
- permil: permil$2,
- perp: perp$2,
- pertenk: pertenk$2,
- pfr: pfr$2,
- phi: phi$2,
- phiv: phiv$2,
- phmmat: phmmat$2,
- phone: phone$2,
- pi: pi$2,
- pitchfork: pitchfork$2,
- piv: piv$2,
- planck: planck$2,
- planckh: planckh$2,
- plankv: plankv$2,
- plus: plus$2,
- plusacir: plusacir$2,
- plusb: plusb$2,
- pluscir: pluscir$2,
- plusdo: plusdo$2,
- plusdu: plusdu$2,
- pluse: pluse$2,
- plusm: plusm$2,
- plusmn: plusmn$2,
- plussim: plussim$2,
- plustwo: plustwo$2,
- pm: pm$2,
- pointint: pointint$2,
- popf: popf$2,
- poun: poun$2,
- pound: pound$2,
- pr: pr$2,
- prE: prE$2,
- prap: prap$2,
- prcue: prcue$2,
- pre: pre$2,
- prec: prec$2,
- precapprox: precapprox$2,
- preccurlyeq: preccurlyeq$2,
- preceq: preceq$2,
- precnapprox: precnapprox$2,
- precneqq: precneqq$2,
- precnsim: precnsim$2,
- precsim: precsim$2,
- prime: prime$2,
- primes: primes$2,
- prnE: prnE$2,
- prnap: prnap$2,
- prnsim: prnsim$2,
- prod: prod$2,
- profalar: profalar$2,
- profline: profline$2,
- profsurf: profsurf$2,
- prop: prop$2,
- propto: propto$2,
- prsim: prsim$2,
- prurel: prurel$2,
- pscr: pscr$2,
- psi: psi$2,
- puncsp: puncsp$2,
- qfr: qfr$2,
- qint: qint$2,
- qopf: qopf$2,
- qprime: qprime$2,
- qscr: qscr$2,
- quaternions: quaternions$2,
- quatint: quatint$2,
- quest: quest$2,
- questeq: questeq$2,
- quo: quo$2,
- quot: quot$2,
- rAarr: rAarr$2,
- rArr: rArr$2,
- rAtail: rAtail$2,
- rBarr: rBarr$2,
- rHar: rHar$2,
- race: race$2,
- racute: racute$2,
- radic: radic$2,
- raemptyv: raemptyv$2,
- rang: rang$2,
- rangd: rangd$2,
- range: range$2,
- rangle: rangle$2,
- raqu: raqu$2,
- raquo: raquo$2,
- rarr: rarr$2,
- rarrap: rarrap$2,
- rarrb: rarrb$2,
- rarrbfs: rarrbfs$2,
- rarrc: rarrc$2,
- rarrfs: rarrfs$2,
- rarrhk: rarrhk$2,
- rarrlp: rarrlp$2,
- rarrpl: rarrpl$2,
- rarrsim: rarrsim$2,
- rarrtl: rarrtl$2,
- rarrw: rarrw$2,
- ratail: ratail$2,
- ratio: ratio$2,
- rationals: rationals$2,
- rbarr: rbarr$2,
- rbbrk: rbbrk$2,
- rbrace: rbrace$2,
- rbrack: rbrack$2,
- rbrke: rbrke$2,
- rbrksld: rbrksld$2,
- rbrkslu: rbrkslu$2,
- rcaron: rcaron$2,
- rcedil: rcedil$2,
- rceil: rceil$2,
- rcub: rcub$2,
- rcy: rcy$2,
- rdca: rdca$2,
- rdldhar: rdldhar$2,
- rdquo: rdquo$2,
- rdquor: rdquor$2,
- rdsh: rdsh$2,
- real: real$2,
- realine: realine$2,
- realpart: realpart$2,
- reals: reals$2,
- rect: rect$2,
- re: re$6,
- reg: reg$2,
- rfisht: rfisht$2,
- rfloor: rfloor$2,
- rfr: rfr$2,
- rhard: rhard$2,
- rharu: rharu$2,
- rharul: rharul$2,
- rho: rho$2,
- rhov: rhov$2,
- rightarrow: rightarrow$2,
- rightarrowtail: rightarrowtail$2,
- rightharpoondown: rightharpoondown$2,
- rightharpoonup: rightharpoonup$2,
- rightleftarrows: rightleftarrows$2,
- rightleftharpoons: rightleftharpoons$2,
- rightrightarrows: rightrightarrows$2,
- rightsquigarrow: rightsquigarrow$2,
- rightthreetimes: rightthreetimes$2,
- ring: ring$2,
- risingdotseq: risingdotseq$2,
- rlarr: rlarr$2,
- rlhar: rlhar$2,
- rlm: rlm$2,
- rmoust: rmoust$2,
- rmoustache: rmoustache$2,
- rnmid: rnmid$2,
- roang: roang$2,
- roarr: roarr$2,
- robrk: robrk$2,
- ropar: ropar$2,
- ropf: ropf$2,
- roplus: roplus$2,
- rotimes: rotimes$2,
- rpar: rpar$2,
- rpargt: rpargt$2,
- rppolint: rppolint$2,
- rrarr: rrarr$2,
- rsaquo: rsaquo$2,
- rscr: rscr$2,
- rsh: rsh$2,
- rsqb: rsqb$2,
- rsquo: rsquo$2,
- rsquor: rsquor$2,
- rthree: rthree$2,
- rtimes: rtimes$2,
- rtri: rtri$2,
- rtrie: rtrie$2,
- rtrif: rtrif$2,
- rtriltri: rtriltri$2,
- ruluhar: ruluhar$2,
- rx: rx$2,
- sacute: sacute$2,
- sbquo: sbquo$2,
- sc: sc$2,
- scE: scE$2,
- scap: scap$2,
- scaron: scaron$2,
- sccue: sccue$2,
- sce: sce$2,
- scedil: scedil$2,
- scirc: scirc$2,
- scnE: scnE$2,
- scnap: scnap$2,
- scnsim: scnsim$2,
- scpolint: scpolint$2,
- scsim: scsim$2,
- scy: scy$2,
- sdot: sdot$2,
- sdotb: sdotb$2,
- sdote: sdote$2,
- seArr: seArr$2,
- searhk: searhk$2,
- searr: searr$2,
- searrow: searrow$2,
- sec: sec$2,
- sect: sect$2,
- semi: semi$2,
- seswar: seswar$2,
- setminus: setminus$2,
- setmn: setmn$2,
- sext: sext$2,
- sfr: sfr$2,
- sfrown: sfrown$2,
- sharp: sharp$2,
- shchcy: shchcy$2,
- shcy: shcy$2,
- shortmid: shortmid$2,
- shortparallel: shortparallel$2,
- sh: sh$2,
- shy: shy$2,
- sigma: sigma$2,
- sigmaf: sigmaf$2,
- sigmav: sigmav$2,
- sim: sim$2,
- simdot: simdot$2,
- sime: sime$2,
- simeq: simeq$2,
- simg: simg$2,
- simgE: simgE$2,
- siml: siml$2,
- simlE: simlE$2,
- simne: simne$2,
- simplus: simplus$2,
- simrarr: simrarr$2,
- slarr: slarr$2,
- smallsetminus: smallsetminus$2,
- smashp: smashp$2,
- smeparsl: smeparsl$2,
- smid: smid$2,
- smile: smile$2,
- smt: smt$2,
- smte: smte$2,
- smtes: smtes$2,
- softcy: softcy$2,
- sol: sol$2,
- solb: solb$2,
- solbar: solbar$2,
- sopf: sopf$2,
- spades: spades$2,
- spadesuit: spadesuit$2,
- spar: spar$2,
- sqcap: sqcap$2,
- sqcaps: sqcaps$2,
- sqcup: sqcup$2,
- sqcups: sqcups$2,
- sqsub: sqsub$2,
- sqsube: sqsube$2,
- sqsubset: sqsubset$2,
- sqsubseteq: sqsubseteq$2,
- sqsup: sqsup$2,
- sqsupe: sqsupe$2,
- sqsupset: sqsupset$2,
- sqsupseteq: sqsupseteq$2,
- squ: squ$2,
- square: square$2,
- squarf: squarf$2,
- squf: squf$2,
- srarr: srarr$2,
- sscr: sscr$2,
- ssetmn: ssetmn$2,
- ssmile: ssmile$2,
- sstarf: sstarf$2,
- star: star$2,
- starf: starf$2,
- straightepsilon: straightepsilon$2,
- straightphi: straightphi$2,
- strns: strns$2,
- sub: sub$2,
- subE: subE$2,
- subdot: subdot$2,
- sube: sube$2,
- subedot: subedot$2,
- submult: submult$2,
- subnE: subnE$2,
- subne: subne$2,
- subplus: subplus$2,
- subrarr: subrarr$2,
- subset: subset$2,
- subseteq: subseteq$2,
- subseteqq: subseteqq$2,
- subsetneq: subsetneq$2,
- subsetneqq: subsetneqq$2,
- subsim: subsim$2,
- subsub: subsub$2,
- subsup: subsup$2,
- succ: succ$2,
- succapprox: succapprox$2,
- succcurlyeq: succcurlyeq$2,
- succeq: succeq$2,
- succnapprox: succnapprox$2,
- succneqq: succneqq$2,
- succnsim: succnsim$2,
- succsim: succsim$2,
- sum: sum$2,
- sung: sung$2,
- sup: sup$2,
- sup1: sup1$2,
- sup2: sup2$2,
- sup3: sup3$2,
- supE: supE$2,
- supdot: supdot$2,
- supdsub: supdsub$2,
- supe: supe$2,
- supedot: supedot$2,
- suphsol: suphsol$2,
- suphsub: suphsub$2,
- suplarr: suplarr$2,
- supmult: supmult$2,
- supnE: supnE$2,
- supne: supne$2,
- supplus: supplus$2,
- supset: supset$2,
- supseteq: supseteq$2,
- supseteqq: supseteqq$2,
- supsetneq: supsetneq$2,
- supsetneqq: supsetneqq$2,
- supsim: supsim$2,
- supsub: supsub$2,
- supsup: supsup$2,
- swArr: swArr$2,
- swarhk: swarhk$2,
- swarr: swarr$2,
- swarrow: swarrow$2,
- swnwar: swnwar$2,
- szli: szli$2,
- szlig: szlig$2,
- target: target$2,
- tau: tau$2,
- tbrk: tbrk$2,
- tcaron: tcaron$2,
- tcedil: tcedil$2,
- tcy: tcy$2,
- tdot: tdot$2,
- telrec: telrec$2,
- tfr: tfr$2,
- there4: there4$2,
- therefore: therefore$2,
- theta: theta$2,
- thetasym: thetasym$2,
- thetav: thetav$2,
- thickapprox: thickapprox$2,
- thicksim: thicksim$2,
- thinsp: thinsp$2,
- thkap: thkap$2,
- thksim: thksim$2,
- thor: thor$2,
- thorn: thorn$2,
- tilde: tilde$2,
- time: time$2,
- times: times$2,
- timesb: timesb$2,
- timesbar: timesbar$2,
- timesd: timesd$2,
- tint: tint$2,
- toea: toea$2,
- top: top$2,
- topbot: topbot$2,
- topcir: topcir$2,
- topf: topf$2,
- topfork: topfork$2,
- tosa: tosa$2,
- tprime: tprime$2,
- trade: trade$2,
- triangle: triangle$2,
- triangledown: triangledown$2,
- triangleleft: triangleleft$2,
- trianglelefteq: trianglelefteq$2,
- triangleq: triangleq$2,
- triangleright: triangleright$2,
- trianglerighteq: trianglerighteq$2,
- tridot: tridot$2,
- trie: trie$2,
- triminus: triminus$2,
- triplus: triplus$2,
- trisb: trisb$2,
- tritime: tritime$2,
- trpezium: trpezium$2,
- tscr: tscr$2,
- tscy: tscy$2,
- tshcy: tshcy$2,
- tstrok: tstrok$2,
- twixt: twixt$2,
- twoheadleftarrow: twoheadleftarrow$2,
- twoheadrightarrow: twoheadrightarrow$2,
- uArr: uArr$2,
- uHar: uHar$2,
- uacut: uacut$2,
- uacute: uacute$2,
- uarr: uarr$2,
- ubrcy: ubrcy$2,
- ubreve: ubreve$2,
- ucir: ucir$2,
- ucirc: ucirc$2,
- ucy: ucy$2,
- udarr: udarr$2,
- udblac: udblac$2,
- udhar: udhar$2,
- ufisht: ufisht$2,
- ufr: ufr$2,
- ugrav: ugrav$2,
- ugrave: ugrave$2,
- uharl: uharl$2,
- uharr: uharr$2,
- uhblk: uhblk$2,
- ulcorn: ulcorn$2,
- ulcorner: ulcorner$2,
- ulcrop: ulcrop$2,
- ultri: ultri$2,
- umacr: umacr$2,
- um: um$2,
- uml: uml$2,
- uogon: uogon$2,
- uopf: uopf$2,
- uparrow: uparrow$2,
- updownarrow: updownarrow$2,
- upharpoonleft: upharpoonleft$2,
- upharpoonright: upharpoonright$2,
- uplus: uplus$2,
- upsi: upsi$2,
- upsih: upsih$2,
- upsilon: upsilon$2,
- upuparrows: upuparrows$2,
- urcorn: urcorn$2,
- urcorner: urcorner$2,
- urcrop: urcrop$2,
- uring: uring$2,
- urtri: urtri$2,
- uscr: uscr$2,
- utdot: utdot$2,
- utilde: utilde$2,
- utri: utri$2,
- utrif: utrif$2,
- uuarr: uuarr$2,
- uum: uum$2,
- uuml: uuml$2,
- uwangle: uwangle$2,
- vArr: vArr$2,
- vBar: vBar$2,
- vBarv: vBarv$2,
- vDash: vDash$2,
- vangrt: vangrt$2,
- varepsilon: varepsilon$2,
- varkappa: varkappa$2,
- varnothing: varnothing$2,
- varphi: varphi$2,
- varpi: varpi$2,
- varpropto: varpropto$2,
- varr: varr$2,
- varrho: varrho$2,
- varsigma: varsigma$2,
- varsubsetneq: varsubsetneq$2,
- varsubsetneqq: varsubsetneqq$2,
- varsupsetneq: varsupsetneq$2,
- varsupsetneqq: varsupsetneqq$2,
- vartheta: vartheta$2,
- vartriangleleft: vartriangleleft$2,
- vartriangleright: vartriangleright$2,
- vcy: vcy$2,
- vdash: vdash$2,
- vee: vee$2,
- veebar: veebar$2,
- veeeq: veeeq$2,
- vellip: vellip$2,
- verbar: verbar$2,
- vert: vert$2,
- vfr: vfr$2,
- vltri: vltri$2,
- vnsub: vnsub$2,
- vnsup: vnsup$2,
- vopf: vopf$2,
- vprop: vprop$2,
- vrtri: vrtri$2,
- vscr: vscr$2,
- vsubnE: vsubnE$2,
- vsubne: vsubne$2,
- vsupnE: vsupnE$2,
- vsupne: vsupne$2,
- vzigzag: vzigzag$2,
- wcirc: wcirc$2,
- wedbar: wedbar$2,
- wedge: wedge$2,
- wedgeq: wedgeq$2,
- weierp: weierp$2,
- wfr: wfr$2,
- wopf: wopf$2,
- wp: wp$2,
- wr: wr$2,
- wreath: wreath$2,
- wscr: wscr$2,
- xcap: xcap$2,
- xcirc: xcirc$2,
- xcup: xcup$2,
- xdtri: xdtri$2,
- xfr: xfr$2,
- xhArr: xhArr$2,
- xharr: xharr$2,
- xi: xi$2,
- xlArr: xlArr$2,
- xlarr: xlarr$2,
- xmap: xmap$2,
- xnis: xnis$2,
- xodot: xodot$2,
- xopf: xopf$2,
- xoplus: xoplus$2,
- xotime: xotime$2,
- xrArr: xrArr$2,
- xrarr: xrarr$2,
- xscr: xscr$2,
- xsqcup: xsqcup$2,
- xuplus: xuplus$2,
- xutri: xutri$2,
- xvee: xvee$2,
- xwedge: xwedge$2,
- yacut: yacut$2,
- yacute: yacute$2,
- yacy: yacy$2,
- ycirc: ycirc$2,
- ycy: ycy$2,
- ye: ye$2,
- yen: yen$2,
- yfr: yfr$2,
- yicy: yicy$2,
- yopf: yopf$2,
- yscr: yscr$2,
- yucy: yucy$2,
- yum: yum$2,
- yuml: yuml$2,
- zacute: zacute$2,
- zcaron: zcaron$2,
- zcy: zcy$2,
- zdot: zdot$2,
- zeetrf: zeetrf$2,
- zeta: zeta$2,
- zfr: zfr$2,
- zhcy: zhcy$2,
- zigrarr: zigrarr$2,
- zopf: zopf$2,
- zscr: zscr$2,
- zwj: zwj$2,
- zwnj: zwnj$2
+var characterEntities = {
+ 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: '‌'
};
-var characterEntities$2 = require$$0$2;
-
-var decodeEntity_1$2 = decodeEntity$3;
-
-var own$9 = {}.hasOwnProperty;
+var own$5 = {}.hasOwnProperty;
-function decodeEntity$3(characters) {
- return own$9.call(characterEntities$2, characters)
- ? characterEntities$2[characters]
+/**
+ * @param {string} characters
+ * @returns {string|false}
+ */
+function decodeEntity(characters) {
+ return own$5.call(characterEntities, characters)
+ ? characterEntities[characters]
: false
}
-var regexCheck$2 = regexCheck_1;
-
-var asciiDigit$3 = regexCheck$2(/\d/);
-
-var asciiDigit_1 = asciiDigit$3;
-
-var regexCheck$1 = regexCheck_1;
-
-var asciiHexDigit$1 = regexCheck$1(/[\dA-Fa-f]/);
-
-var asciiHexDigit_1 = asciiHexDigit$1;
-
-var decodeEntity$2 = decodeEntity_1$2;
-var asciiAlphanumeric$3 = asciiAlphanumeric_1;
-var asciiDigit$2 = asciiDigit_1;
-var asciiHexDigit = asciiHexDigit_1;
-
-function _interopDefaultLegacy$1(e) {
- return e && typeof e === 'object' && 'default' in e ? e : {default: e}
-}
-
-var decodeEntity__default = /*#__PURE__*/ _interopDefaultLegacy$1(decodeEntity$2);
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var characterReference$2 = {
+/** @type {Construct} */
+const characterReference$1 = {
name: 'characterReference',
tokenize: tokenizeCharacterReference
};
+/** @type {Tokenizer} */
function tokenizeCharacterReference(effects, ok, nok) {
- var self = this;
- var size = 0;
- var max;
- var test;
+ const self = this;
+ let size = 0;
+ /** @type {number} */
+
+ let max;
+ /** @type {(code: Code) => code is number} */
+
+ let test;
return start
+ /** @type {State} */
function start(code) {
effects.enter('characterReference');
@@ -35077,6 +37484,7 @@ function tokenizeCharacterReference(effects, ok, nok) {
effects.exit('characterReferenceMarker');
return open
}
+ /** @type {State} */
function open(code) {
if (code === 35) {
@@ -35088,9 +37496,10 @@ function tokenizeCharacterReference(effects, ok, nok) {
effects.enter('characterReferenceValue');
max = 31;
- test = asciiAlphanumeric$3;
+ test = asciiAlphanumeric;
return value(code)
}
+ /** @type {State} */
function numeric(code) {
if (code === 88 || code === 120) {
@@ -35105,19 +37514,21 @@ function tokenizeCharacterReference(effects, ok, nok) {
effects.enter('characterReferenceValue');
max = 7;
- test = asciiDigit$2;
+ test = asciiDigit;
return value(code)
}
+ /** @type {State} */
function value(code) {
- var token;
+ /** @type {Token} */
+ let token;
if (code === 59 && size) {
token = effects.exit('characterReferenceValue');
if (
- test === asciiAlphanumeric$3 &&
- !decodeEntity__default['default'](self.sliceSerialize(token))
+ test === asciiAlphanumeric &&
+ !decodeEntity(self.sliceSerialize(token))
) {
return nok(code)
}
@@ -35138,29 +37549,46 @@ function tokenizeCharacterReference(effects, ok, nok) {
}
}
-var characterReference_1 = characterReference$2;
-
-var markdownLineEnding$e = markdownLineEnding_1;
-var markdownLineEndingOrSpace$7 = markdownLineEndingOrSpace_1;
-var prefixSize$2 = prefixSize_1;
-var factorySpace$b = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var codeFenced$1 = {
+/** @type {Construct} */
+const codeFenced = {
name: 'codeFenced',
tokenize: tokenizeCodeFenced,
concrete: true
};
+/** @type {Tokenizer} */
function tokenizeCodeFenced(effects, ok, nok) {
- var self = this;
- var closingFenceConstruct = {
+ const self = this;
+ /** @type {Construct} */
+
+ const closingFenceConstruct = {
tokenize: tokenizeClosingFence,
partial: true
};
- var initialPrefix = prefixSize$2(this.events, 'linePrefix');
- var sizeOpen = 0;
- var marker;
+ /** @type {Construct} */
+
+ const nonLazyLine = {
+ tokenize: tokenizeNonLazyLine,
+ partial: true
+ };
+ const tail = this.events[this.events.length - 1];
+ const initialPrefix =
+ tail && tail[1].type === 'linePrefix'
+ ? tail[2].sliceSerialize(tail[1], true).length
+ : 0;
+ let sizeOpen = 0;
+ /** @type {NonNullable<Code>} */
+
+ let marker;
return start
+ /** @type {State} */
function start(code) {
effects.enter('codeFenced');
@@ -35169,6 +37597,7 @@ function tokenizeCodeFenced(effects, ok, nok) {
marker = code;
return sequenceOpen(code)
}
+ /** @type {State} */
function sequenceOpen(code) {
if (code === marker) {
@@ -35180,11 +37609,12 @@ function tokenizeCodeFenced(effects, ok, nok) {
effects.exit('codeFencedFenceSequence');
return sizeOpen < 3
? nok(code)
- : factorySpace$b(effects, infoOpen, 'whitespace')(code)
+ : factorySpace(effects, infoOpen, 'whitespace')(code)
}
+ /** @type {State} */
function infoOpen(code) {
- if (code === null || markdownLineEnding$e(code)) {
+ if (code === null || markdownLineEnding(code)) {
return openAfter(code)
}
@@ -35194,21 +37624,23 @@ function tokenizeCodeFenced(effects, ok, nok) {
});
return info(code)
}
+ /** @type {State} */
function info(code) {
- if (code === null || markdownLineEndingOrSpace$7(code)) {
+ if (code === null || markdownLineEndingOrSpace(code)) {
effects.exit('chunkString');
effects.exit('codeFencedFenceInfo');
- return factorySpace$b(effects, infoAfter, 'whitespace')(code)
+ return factorySpace(effects, infoAfter, 'whitespace')(code)
}
if (code === 96 && code === marker) return nok(code)
effects.consume(code);
return info
}
+ /** @type {State} */
function infoAfter(code) {
- if (code === null || markdownLineEnding$e(code)) {
+ if (code === null || markdownLineEnding(code)) {
return openAfter(code)
}
@@ -35218,9 +37650,10 @@ function tokenizeCodeFenced(effects, ok, nok) {
});
return meta(code)
}
+ /** @type {State} */
function meta(code) {
- if (code === null || markdownLineEnding$e(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('chunkString');
effects.exit('codeFencedFenceMeta');
return openAfter(code)
@@ -35230,65 +37663,97 @@ function tokenizeCodeFenced(effects, ok, nok) {
effects.consume(code);
return meta
}
+ /** @type {State} */
function openAfter(code) {
effects.exit('codeFencedFence');
- return self.interrupt ? ok(code) : content(code)
+ return self.interrupt ? ok(code) : contentStart(code)
}
+ /** @type {State} */
- function content(code) {
+ function contentStart(code) {
if (code === null) {
return after(code)
}
- if (markdownLineEnding$e(code)) {
- effects.enter('lineEnding');
- effects.consume(code);
- effects.exit('lineEnding');
+ if (markdownLineEnding(code)) {
return effects.attempt(
- closingFenceConstruct,
- after,
- initialPrefix
- ? factorySpace$b(effects, content, 'linePrefix', initialPrefix + 1)
- : content
- )
+ nonLazyLine,
+ effects.attempt(
+ closingFenceConstruct,
+ after,
+ initialPrefix
+ ? factorySpace(
+ effects,
+ contentStart,
+ 'linePrefix',
+ initialPrefix + 1
+ )
+ : contentStart
+ ),
+ after
+ )(code)
}
effects.enter('codeFlowValue');
return contentContinue(code)
}
+ /** @type {State} */
function contentContinue(code) {
- if (code === null || markdownLineEnding$e(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('codeFlowValue');
- return content(code)
+ return contentStart(code)
}
effects.consume(code);
return contentContinue
}
+ /** @type {State} */
function after(code) {
effects.exit('codeFenced');
return ok(code)
}
+ /** @type {Tokenizer} */
+
+ function tokenizeNonLazyLine(effects, ok, nok) {
+ const self = this;
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ effects.enter('lineEnding');
+ effects.consume(code);
+ effects.exit('lineEnding');
+ return lineStart
+ }
+ /** @type {State} */
+
+ function lineStart(code) {
+ return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+ }
+ }
+ /** @type {Tokenizer} */
function tokenizeClosingFence(effects, ok, nok) {
- var size = 0;
- return factorySpace$b(
+ let size = 0;
+ return factorySpace(
effects,
closingSequenceStart,
'linePrefix',
- this.parser.constructs.disable.null.indexOf('codeIndented') > -1
+ this.parser.constructs.disable.null.includes('codeIndented')
? undefined
: 4
)
+ /** @type {State} */
function closingSequenceStart(code) {
effects.enter('codeFencedFence');
effects.enter('codeFencedFenceSequence');
return closingSequence(code)
}
+ /** @type {State} */
function closingSequence(code) {
if (code === marker) {
@@ -35299,11 +37764,12 @@ function tokenizeCodeFenced(effects, ok, nok) {
if (size < sizeOpen) return nok(code)
effects.exit('codeFencedFenceSequence');
- return factorySpace$b(effects, closingSequenceEnd, 'whitespace')(code)
+ return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)
}
+ /** @type {State} */
function closingSequenceEnd(code) {
- if (code === null || markdownLineEnding$e(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('codeFencedFence');
return ok(code)
}
@@ -35313,52 +37779,64 @@ function tokenizeCodeFenced(effects, ok, nok) {
}
}
-var codeFenced_1 = codeFenced$1;
-
-var markdownLineEnding$d = markdownLineEnding_1;
-var chunkedSplice$2 = chunkedSplice_1;
-var prefixSize$1 = prefixSize_1;
-var factorySpace$a = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
-var codeIndented$1 = {
+/** @type {Construct} */
+const codeIndented = {
name: 'codeIndented',
- tokenize: tokenizeCodeIndented,
- resolve: resolveCodeIndented
+ tokenize: tokenizeCodeIndented
};
-var indentedContentConstruct = {
+/** @type {Construct} */
+
+const indentedContent = {
tokenize: tokenizeIndentedContent,
partial: true
};
-
-function resolveCodeIndented(events, context) {
- var code = {
- type: 'codeIndented',
- start: events[0][1].start,
- end: events[events.length - 1][1].end
- };
- chunkedSplice$2(events, 0, 0, [['enter', code, context]]);
- chunkedSplice$2(events, events.length, 0, [['exit', code, context]]);
- return events
-}
+/** @type {Tokenizer} */
function tokenizeCodeIndented(effects, ok, nok) {
- return effects.attempt(indentedContentConstruct, afterPrefix, nok)
+ const self = this;
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ effects.enter('codeIndented');
+ return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)
+ }
+ /** @type {State} */
+
+ function afterStartPrefix(code) {
+ const tail = self.events[self.events.length - 1];
+ return tail &&
+ tail[1].type === 'linePrefix' &&
+ tail[2].sliceSerialize(tail[1], true).length >= 4
+ ? afterPrefix(code)
+ : nok(code)
+ }
+ /** @type {State} */
function afterPrefix(code) {
if (code === null) {
- return ok(code)
+ return after(code)
}
- if (markdownLineEnding$d(code)) {
- return effects.attempt(indentedContentConstruct, afterPrefix, ok)(code)
+ if (markdownLineEnding(code)) {
+ return effects.attempt(indentedContent, afterPrefix, after)(code)
}
effects.enter('codeFlowValue');
return content(code)
}
+ /** @type {State} */
function content(code) {
- if (code === null || markdownLineEnding$d(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('codeFlowValue');
return afterPrefix(code)
}
@@ -35366,40 +37844,76 @@ function tokenizeCodeIndented(effects, ok, nok) {
effects.consume(code);
return content
}
+ /** @type {State} */
+
+ function after(code) {
+ effects.exit('codeIndented');
+ return ok(code)
+ }
}
+/** @type {Tokenizer} */
function tokenizeIndentedContent(effects, ok, nok) {
- var self = this;
- return factorySpace$a(effects, afterPrefix, 'linePrefix', 4 + 1)
+ const self = this;
+ return start
+ /** @type {State} */
- function afterPrefix(code) {
- if (markdownLineEnding$d(code)) {
+ function start(code) {
+ // If this is a lazy line, it can’t be code.
+ if (self.parser.lazy[self.now().line]) {
+ return nok(code)
+ }
+
+ if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return factorySpace$a(effects, afterPrefix, 'linePrefix', 4 + 1)
+ return start
}
- return prefixSize$1(self.events, 'linePrefix') < 4 ? nok(code) : ok(code)
+ return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)
}
-}
+ /** @type {State} */
-var codeIndented_1 = codeIndented$1;
+ function afterPrefix(code) {
+ const tail = self.events[self.events.length - 1];
+ return tail &&
+ tail[1].type === 'linePrefix' &&
+ tail[2].sliceSerialize(tail[1], true).length >= 4
+ ? ok(code)
+ : markdownLineEnding(code)
+ ? start(code)
+ : nok(code)
+ }
+}
-var markdownLineEnding$c = markdownLineEnding_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Previous} Previous
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
-var codeText$1 = {
+/** @type {Construct} */
+const codeText = {
name: 'codeText',
tokenize: tokenizeCodeText,
resolve: resolveCodeText,
previous: previous$1
};
+/** @type {Resolver} */
function resolveCodeText(events) {
- var tailExitIndex = events.length - 4;
- var headEnterIndex = 3;
- var index;
- var enter; // If we start and end with an EOL or a space.
+ let tailExitIndex = events.length - 4;
+ let headEnterIndex = 3;
+ /** @type {number} */
+
+ let index;
+ /** @type {number|undefined} */
+
+ let enter; // If we start and end with an EOL or a space.
if (
(events[headEnterIndex][1].type === 'lineEnding' ||
@@ -35412,8 +37926,8 @@ function resolveCodeText(events) {
while (++index < tailExitIndex) {
if (events[index][1].type === 'codeTextData') {
// Then we have padding.
- events[tailExitIndex][1].type = events[headEnterIndex][1].type =
- 'codeTextPadding';
+ events[headEnterIndex][1].type = 'codeTextPadding';
+ events[tailExitIndex][1].type = 'codeTextPadding';
headEnterIndex += 2;
tailExitIndex -= 2;
break
@@ -35448,6 +37962,7 @@ function resolveCodeText(events) {
return events
}
+/** @type {Previous} */
function previous$1(code) {
// If there is a previous code, there will always be a tail.
@@ -35456,18 +37971,25 @@ function previous$1(code) {
this.events[this.events.length - 1][1].type === 'characterEscape'
)
}
+/** @type {Tokenizer} */
function tokenizeCodeText(effects, ok, nok) {
- var sizeOpen = 0;
- var size;
- var token;
+ let sizeOpen = 0;
+ /** @type {number} */
+
+ let size;
+ /** @type {Token} */
+
+ let token;
return start
+ /** @type {State} */
function start(code) {
effects.enter('codeText');
effects.enter('codeTextSequence');
return openingSequence(code)
}
+ /** @type {State} */
function openingSequence(code) {
if (code === 96) {
@@ -35479,6 +38001,7 @@ function tokenizeCodeText(effects, ok, nok) {
effects.exit('codeTextSequence');
return gap(code)
}
+ /** @type {State} */
function gap(code) {
// EOF.
@@ -35500,7 +38023,7 @@ function tokenizeCodeText(effects, ok, nok) {
return gap
}
- if (markdownLineEnding$c(code)) {
+ if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
@@ -35511,12 +38034,14 @@ function tokenizeCodeText(effects, ok, nok) {
return data(code)
} // In code.
+ /** @type {State} */
+
function data(code) {
if (
code === null ||
code === 32 ||
code === 96 ||
- markdownLineEnding$c(code)
+ markdownLineEnding(code)
) {
effects.exit('codeTextData');
return gap(code)
@@ -35526,6 +38051,8 @@ function tokenizeCodeText(effects, ok, nok) {
return data
} // Closing fence.
+ /** @type {State} */
+
function closingSequence(code) {
// More.
if (code === 96) {
@@ -35545,14 +38072,394 @@ function tokenizeCodeText(effects, ok, nok) {
}
}
-var codeText_1 = codeText$1;
+/**
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Event} Event
+ */
+
+/**
+ * Tokenize subcontent.
+ *
+ * @param {Event[]} events
+ * @returns {boolean}
+ */
+function subtokenize(events) {
+ /** @type {Record<string, number>} */
+ const jumps = {};
+ let index = -1;
+ /** @type {Event} */
+
+ let event;
+ /** @type {number|undefined} */
+
+ let lineIndex;
+ /** @type {number} */
+
+ let otherIndex;
+ /** @type {Event} */
+
+ let otherEvent;
+ /** @type {Event[]} */
+
+ let parameters;
+ /** @type {Event[]} */
+
+ let subevents;
+ /** @type {boolean|undefined} */
+
+ let more;
+
+ while (++index < events.length) {
+ while (index in jumps) {
+ index = jumps[index];
+ }
+
+ event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text
+ // is in the first content of a list item.
+
+ if (
+ index &&
+ event[1].type === 'chunkFlow' &&
+ events[index - 1][1].type === 'listItemPrefix'
+ ) {
+ subevents = event[1]._tokenizer.events;
+ otherIndex = 0;
+
+ if (
+ otherIndex < subevents.length &&
+ subevents[otherIndex][1].type === 'lineEndingBlank'
+ ) {
+ otherIndex += 2;
+ }
+
+ if (
+ otherIndex < subevents.length &&
+ subevents[otherIndex][1].type === 'content'
+ ) {
+ while (++otherIndex < subevents.length) {
+ if (subevents[otherIndex][1].type === 'content') {
+ break
+ }
+
+ if (subevents[otherIndex][1].type === 'chunkText') {
+ subevents[otherIndex][1]._isInFirstContentOfListItem = true;
+ otherIndex++;
+ }
+ }
+ }
+ } // Enter.
+
+ if (event[0] === 'enter') {
+ if (event[1].contentType) {
+ Object.assign(jumps, subcontent(events, index));
+ index = jumps[index];
+ more = true;
+ }
+ } // Exit.
+ else if (event[1]._container) {
+ otherIndex = index;
+ lineIndex = undefined;
+
+ while (otherIndex--) {
+ otherEvent = events[otherIndex];
+
+ if (
+ otherEvent[1].type === 'lineEnding' ||
+ otherEvent[1].type === 'lineEndingBlank'
+ ) {
+ if (otherEvent[0] === 'enter') {
+ if (lineIndex) {
+ events[lineIndex][1].type = 'lineEndingBlank';
+ }
+
+ otherEvent[1].type = 'lineEnding';
+ lineIndex = otherIndex;
+ }
+ } else {
+ break
+ }
+ }
+
+ if (lineIndex) {
+ // Fix position.
+ event[1].end = Object.assign({}, events[lineIndex][1].start); // Switch container exit w/ line endings.
+
+ parameters = events.slice(lineIndex, index);
+ parameters.unshift(event);
+ splice(events, lineIndex, index - lineIndex + 1, parameters);
+ }
+ }
+ }
+
+ return !more
+}
+/**
+ * Tokenize embedded tokens.
+ *
+ * @param {Event[]} events
+ * @param {number} eventIndex
+ * @returns {Record<string, number>}
+ */
+
+function subcontent(events, eventIndex) {
+ const token = events[eventIndex][1];
+ const context = events[eventIndex][2];
+ let startPosition = eventIndex - 1;
+ /** @type {number[]} */
+
+ const startPositions = [];
+ const tokenizer =
+ token._tokenizer || context.parser[token.contentType](token.start);
+ const childEvents = tokenizer.events;
+ /** @type {[number, number][]} */
+
+ const jumps = [];
+ /** @type {Record<string, number>} */
+
+ const gaps = {};
+ /** @type {Chunk[]} */
+
+ let stream;
+ /** @type {Token|undefined} */
+
+ let previous;
+ let index = -1;
+ /** @type {Token|undefined} */
+
+ let current = token;
+ let adjust = 0;
+ let start = 0;
+ const breaks = [start]; // Loop forward through the linked tokens to pass them in order to the
+ // subtokenizer.
+
+ while (current) {
+ // Find the position of the event for this token.
+ while (events[++startPosition][1] !== current) {
+ // Empty.
+ }
+
+ startPositions.push(startPosition);
+
+ if (!current._tokenizer) {
+ stream = context.sliceStream(current);
+
+ if (!current.next) {
+ stream.push(null);
+ }
+
+ if (previous) {
+ tokenizer.defineSkip(current.start);
+ }
+
+ if (current._isInFirstContentOfListItem) {
+ tokenizer._gfmTasklistFirstContentOfListItem = true;
+ }
+
+ tokenizer.write(stream);
+
+ if (current._isInFirstContentOfListItem) {
+ tokenizer._gfmTasklistFirstContentOfListItem = undefined;
+ }
+ } // Unravel the next token.
+
+ previous = current;
+ current = current.next;
+ } // Now, loop back through all events (and linked tokens), to figure out which
+ // parts belong where.
+
+ current = token;
+
+ while (++index < childEvents.length) {
+ if (
+ // Find a void token that includes a break.
+ childEvents[index][0] === 'exit' &&
+ childEvents[index - 1][0] === 'enter' &&
+ childEvents[index][1].type === childEvents[index - 1][1].type &&
+ childEvents[index][1].start.line !== childEvents[index][1].end.line
+ ) {
+ start = index + 1;
+ breaks.push(start); // Help GC.
+
+ current._tokenizer = undefined;
+ current.previous = undefined;
+ current = current.next;
+ }
+ } // Help GC.
+
+ tokenizer.events = []; // If there’s one more token (which is the cases for lines that end in an
+ // EOF), that’s perfect: the last point we found starts it.
+ // If there isn’t then make sure any remaining content is added to it.
+
+ if (current) {
+ // Help GC.
+ current._tokenizer = undefined;
+ current.previous = undefined;
+ } else {
+ breaks.pop();
+ } // Now splice the events from the subtokenizer into the current events,
+ // moving back to front so that splice indices aren’t affected.
+
+ index = breaks.length;
+
+ while (index--) {
+ const slice = childEvents.slice(breaks[index], breaks[index + 1]);
+ const start = startPositions.pop();
+ jumps.unshift([start, start + slice.length - 1]);
+ splice(events, start, 2, slice);
+ }
+
+ index = -1;
+
+ while (++index < jumps.length) {
+ gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
+ adjust += jumps[index][1] - jumps[index][0] - 1;
+ }
+
+ return gaps
+}
+
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/**
+ * No name because it must not be turned off.
+ * @type {Construct}
+ */
+const content = {
+ tokenize: tokenizeContent,
+ resolve: resolveContent
+};
+/** @type {Construct} */
+
+const continuationConstruct = {
+ tokenize: tokenizeContinuation,
+ partial: true
+};
+/**
+ * Content is transparent: it’s parsed right now. That way, definitions are also
+ * parsed right now: before text in paragraphs (specifically, media) are parsed.
+ *
+ * @type {Resolver}
+ */
+
+function resolveContent(events) {
+ subtokenize(events);
+ return events
+}
+/** @type {Tokenizer} */
+
+function tokenizeContent(effects, ok) {
+ /** @type {Token} */
+ let previous;
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ effects.enter('content');
+ previous = effects.enter('chunkContent', {
+ contentType: 'content'
+ });
+ return data(code)
+ }
+ /** @type {State} */
+
+ function data(code) {
+ if (code === null) {
+ return contentEnd(code)
+ }
+
+ if (markdownLineEnding(code)) {
+ return effects.check(
+ continuationConstruct,
+ contentContinue,
+ contentEnd
+ )(code)
+ } // Data.
+
+ effects.consume(code);
+ return data
+ }
+ /** @type {State} */
+
+ function contentEnd(code) {
+ effects.exit('chunkContent');
+ effects.exit('content');
+ return ok(code)
+ }
+ /** @type {State} */
+
+ function contentContinue(code) {
+ effects.consume(code);
+ effects.exit('chunkContent');
+ previous.next = effects.enter('chunkContent', {
+ contentType: 'content',
+ previous
+ });
+ previous = previous.next;
+ return data
+ }
+}
+/** @type {Tokenizer} */
+
+function tokenizeContinuation(effects, ok, nok) {
+ const self = this;
+ return startLookahead
+ /** @type {State} */
-var asciiControl$1 = asciiControl_1;
-var markdownLineEndingOrSpace$6 = markdownLineEndingOrSpace_1;
-var markdownLineEnding$b = markdownLineEnding_1;
+ function startLookahead(code) {
+ effects.exit('chunkContent');
+ effects.enter('lineEnding');
+ effects.consume(code);
+ effects.exit('lineEnding');
+ return factorySpace(effects, prefixed, 'linePrefix')
+ }
+ /** @type {State} */
+
+ function prefixed(code) {
+ if (code === null || markdownLineEnding(code)) {
+ return nok(code)
+ }
+
+ const tail = self.events[self.events.length - 1];
+
+ if (
+ !self.parser.constructs.disable.null.includes('codeIndented') &&
+ tail &&
+ tail[1].type === 'linePrefix' &&
+ tail[2].sliceSerialize(tail[1], true).length >= 4
+ ) {
+ return ok(code)
+ }
+
+ return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
+ }
+}
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} literalType
+ * @param {string} literalMarkerType
+ * @param {string} rawType
+ * @param {string} stringType
+ * @param {number} [max=Infinity]
+ * @returns {State}
+ */
// eslint-disable-next-line max-params
-function destinationFactory(
+function factoryDestination(
effects,
ok,
nok,
@@ -35563,9 +38470,10 @@ function destinationFactory(
stringType,
max
) {
- var limit = max || Infinity;
- var balance = 0;
+ const limit = max || Number.POSITIVE_INFINITY;
+ let balance = 0;
return start
+ /** @type {State} */
function start(code) {
if (code === 60) {
@@ -35577,7 +38485,7 @@ function destinationFactory(
return destinationEnclosedBefore
}
- if (asciiControl$1(code) || code === 41) {
+ if (code === null || code === 41 || asciiControl(code)) {
return nok(code)
}
@@ -35589,6 +38497,7 @@ function destinationFactory(
});
return destinationRaw(code)
}
+ /** @type {State} */
function destinationEnclosedBefore(code) {
if (code === 62) {
@@ -35606,6 +38515,7 @@ function destinationFactory(
});
return destinationEnclosed(code)
}
+ /** @type {State} */
function destinationEnclosed(code) {
if (code === 62) {
@@ -35614,13 +38524,14 @@ function destinationFactory(
return destinationEnclosedBefore(code)
}
- if (code === null || code === 60 || markdownLineEnding$b(code)) {
+ if (code === null || code === 60 || markdownLineEnding(code)) {
return nok(code)
}
effects.consume(code);
return code === 92 ? destinationEnclosedEscape : destinationEnclosed
}
+ /** @type {State} */
function destinationEnclosedEscape(code) {
if (code === 60 || code === 62 || code === 92) {
@@ -35630,6 +38541,7 @@ function destinationFactory(
return destinationEnclosed(code)
}
+ /** @type {State} */
function destinationRaw(code) {
if (code === 40) {
@@ -35651,7 +38563,7 @@ function destinationFactory(
return destinationRaw
}
- if (code === null || markdownLineEndingOrSpace$6(code)) {
+ if (code === null || markdownLineEndingOrSpace(code)) {
if (balance) return nok(code)
effects.exit('chunkString');
effects.exit(stringType);
@@ -35660,10 +38572,11 @@ function destinationFactory(
return ok(code)
}
- if (asciiControl$1(code)) return nok(code)
+ if (asciiControl(code)) return nok(code)
effects.consume(code);
return code === 92 ? destinationRawEscape : destinationRaw
}
+ /** @type {State} */
function destinationRawEscape(code) {
if (code === 40 || code === 41 || code === 92) {
@@ -35675,17 +38588,31 @@ function destinationFactory(
}
}
-var factoryDestination$2 = destinationFactory;
-
-var markdownLineEnding$a = markdownLineEnding_1;
-var markdownSpace$7 = markdownSpace_1;
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').State} State
+ */
+/**
+ * @this {TokenizeContext}
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} markerType
+ * @param {string} stringType
+ * @returns {State}
+ */
// eslint-disable-next-line max-params
-function labelFactory(effects, ok, nok, type, markerType, stringType) {
- var self = this;
- var size = 0;
- var data;
+function factoryLabel(effects, ok, nok, type, markerType, stringType) {
+ const self = this;
+ let size = 0;
+ /** @type {boolean} */
+
+ let data;
return start
+ /** @type {State} */
function start(code) {
effects.enter(type);
@@ -35695,17 +38622,18 @@ function labelFactory(effects, ok, nok, type, markerType, stringType) {
effects.enter(stringType);
return atBreak
}
+ /** @type {State} */
function atBreak(code) {
if (
code === null ||
code === 91 ||
(code === 93 && !data) ||
- /* c8 ignore next */
+ /* Hidden footnotes hook */
+
+ /* c8 ignore next 3 */
(code === 94 &&
- /* c8 ignore next */
!size &&
- /* c8 ignore next */
'_hiddenFootnoteSupport' in self.parser.constructs) ||
size > 999
) {
@@ -35721,7 +38649,7 @@ function labelFactory(effects, ok, nok, type, markerType, stringType) {
return ok
}
- if (markdownLineEnding$a(code)) {
+ if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
@@ -35733,13 +38661,14 @@ function labelFactory(effects, ok, nok, type, markerType, stringType) {
});
return label(code)
}
+ /** @type {State} */
function label(code) {
if (
code === null ||
code === 91 ||
code === 93 ||
- markdownLineEnding$a(code) ||
+ markdownLineEnding(code) ||
size++ > 999
) {
effects.exit('chunkString');
@@ -35747,9 +38676,10 @@ function labelFactory(effects, ok, nok, type, markerType, stringType) {
}
effects.consume(code);
- data = data || !markdownSpace$7(code);
+ data = data || !markdownSpace(code);
return code === 92 ? labelEscape : label
}
+ /** @type {State} */
function labelEscape(code) {
if (code === 91 || code === 92 || code === 93) {
@@ -35762,45 +38692,27 @@ function labelFactory(effects, ok, nok, type, markerType, stringType) {
}
}
-var factoryLabel$2 = labelFactory;
-
-var markdownLineEnding$9 = markdownLineEnding_1;
-var markdownSpace$6 = markdownSpace_1;
-var factorySpace$9 = factorySpace$i;
-
-function whitespaceFactory(effects, ok) {
- var seen;
- return start
-
- function start(code) {
- if (markdownLineEnding$9(code)) {
- effects.enter('lineEnding');
- effects.consume(code);
- effects.exit('lineEnding');
- seen = true;
- return start
- }
-
- if (markdownSpace$6(code)) {
- return factorySpace$9(
- effects,
- start,
- seen ? 'linePrefix' : 'lineSuffix'
- )(code)
- }
-
- return ok(code)
- }
-}
-
-var factoryWhitespace$2 = whitespaceFactory;
-
-var markdownLineEnding$8 = markdownLineEnding_1;
-var factorySpace$8 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-function titleFactory(effects, ok, nok, type, markerType, stringType) {
- var marker;
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {string} type
+ * @param {string} markerType
+ * @param {string} stringType
+ * @returns {State}
+ */
+// eslint-disable-next-line max-params
+function factoryTitle(effects, ok, nok, type, markerType, stringType) {
+ /** @type {NonNullable<Code>} */
+ let marker;
return start
+ /** @type {State} */
function start(code) {
effects.enter(type);
@@ -35810,6 +38722,7 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
marker = code === 40 ? 41 : code;
return atFirstTitleBreak
}
+ /** @type {State} */
function atFirstTitleBreak(code) {
if (code === marker) {
@@ -35823,6 +38736,7 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
effects.enter(stringType);
return atTitleBreak(code)
}
+ /** @type {State} */
function atTitleBreak(code) {
if (code === marker) {
@@ -35834,11 +38748,11 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
return nok(code)
} // Note: blank lines can’t exist in content.
- if (markdownLineEnding$8(code)) {
+ if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return factorySpace$8(effects, atTitleBreak, 'linePrefix')
+ return factorySpace(effects, atTitleBreak, 'linePrefix')
}
effects.enter('chunkString', {
@@ -35846,9 +38760,10 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
});
return title(code)
}
+ /** @type {State} */
function title(code) {
- if (code === marker || code === null || markdownLineEnding$8(code)) {
+ if (code === marker || code === null || markdownLineEnding(code)) {
effects.exit('chunkString');
return atTitleBreak(code)
}
@@ -35856,6 +38771,7 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
effects.consume(code);
return code === 92 ? titleEscape : title
}
+ /** @type {State} */
function titleEscape(code) {
if (code === marker || code === 92) {
@@ -35867,34 +38783,93 @@ function titleFactory(effects, ok, nok, type, markerType, stringType) {
}
}
-var factoryTitle$2 = titleFactory;
+/**
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ */
-var markdownLineEnding$7 = markdownLineEnding_1;
-var markdownLineEndingOrSpace$5 = markdownLineEndingOrSpace_1;
-var normalizeIdentifier$3 = normalizeIdentifier_1;
-var factoryDestination$1 = factoryDestination$2;
-var factoryLabel$1 = factoryLabel$2;
-var factorySpace$7 = factorySpace$i;
-var factoryWhitespace$1 = factoryWhitespace$2;
-var factoryTitle$1 = factoryTitle$2;
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ */
+function factoryWhitespace(effects, ok) {
+ /** @type {boolean} */
+ let seen;
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ if (markdownLineEnding(code)) {
+ effects.enter('lineEnding');
+ effects.consume(code);
+ effects.exit('lineEnding');
+ seen = true;
+ return start
+ }
-var definition$2 = {
+ if (markdownSpace(code)) {
+ return factorySpace(
+ effects,
+ start,
+ seen ? 'linePrefix' : 'lineSuffix'
+ )(code)
+ }
+
+ return ok(code)
+ }
+}
+
+/**
+ * Normalize an identifier (such as used in definitions).
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeIdentifier(value) {
+ return (
+ value // Collapse Markdown whitespace.
+ .replace(/[\t\n\r ]+/g, ' ') // Trim.
+ .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase
+ // counterpart is uppercased will result in a different uppercase
+ // character.
+ // Hence, to get that form, we perform both lower- and uppercase.
+ // Upper case makes sure keys will not interact with default prototypal
+ // methods: no method is uppercase.
+ .toLowerCase()
+ .toUpperCase()
+ )
+}
+
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {Construct} */
+const definition$1 = {
name: 'definition',
tokenize: tokenizeDefinition
};
-var titleConstruct = {
+/** @type {Construct} */
+
+const titleConstruct = {
tokenize: tokenizeTitle,
partial: true
};
+/** @type {Tokenizer} */
function tokenizeDefinition(effects, ok, nok) {
- var self = this;
- var identifier;
+ const self = this;
+ /** @type {string} */
+
+ let identifier;
return start
+ /** @type {State} */
function start(code) {
effects.enter('definition');
- return factoryLabel$1.call(
+ return factoryLabel.call(
self,
effects,
labelAfter,
@@ -35904,9 +38879,10 @@ function tokenizeDefinition(effects, ok, nok) {
'definitionLabelString'
)(code)
}
+ /** @type {State} */
function labelAfter(code) {
- identifier = normalizeIdentifier$3(
+ identifier = normalizeIdentifier(
self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
);
@@ -35915,14 +38891,14 @@ function tokenizeDefinition(effects, ok, nok) {
effects.consume(code);
effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.
- return factoryWhitespace$1(
+ return factoryWhitespace(
effects,
- factoryDestination$1(
+ factoryDestination(
effects,
effects.attempt(
titleConstruct,
- factorySpace$7(effects, after, 'whitespace'),
- factorySpace$7(effects, after, 'whitespace')
+ factorySpace(effects, after, 'whitespace'),
+ factorySpace(effects, after, 'whitespace')
),
nok,
'definitionDestination',
@@ -35936,12 +38912,13 @@ function tokenizeDefinition(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function after(code) {
- if (code === null || markdownLineEnding$7(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('definition');
- if (self.parser.defined.indexOf(identifier) < 0) {
+ if (!self.parser.defined.includes(identifier)) {
self.parser.defined.push(identifier);
}
@@ -35951,21 +38928,24 @@ function tokenizeDefinition(effects, ok, nok) {
return nok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeTitle(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
- return markdownLineEndingOrSpace$5(code)
- ? factoryWhitespace$1(effects, before)(code)
+ return markdownLineEndingOrSpace(code)
+ ? factoryWhitespace(effects, before)(code)
: nok(code)
}
+ /** @type {State} */
function before(code) {
if (code === 34 || code === 39 || code === 40) {
- return factoryTitle$1(
+ return factoryTitle(
effects,
- factorySpace$7(effects, after, 'whitespace'),
+ factorySpace(effects, after, 'whitespace'),
nok,
'definitionTitle',
'definitionTitleMarker',
@@ -35975,23 +38955,29 @@ function tokenizeTitle(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function after(code) {
- return code === null || markdownLineEnding$7(code) ? ok(code) : nok(code)
+ return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
}
}
-var definition_1$1 = definition$2;
-
-var markdownLineEnding$6 = markdownLineEnding_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
-var hardBreakEscape$1 = {
+/** @type {Construct} */
+const hardBreakEscape = {
name: 'hardBreakEscape',
tokenize: tokenizeHardBreakEscape
};
+/** @type {Tokenizer} */
function tokenizeHardBreakEscape(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
effects.enter('hardBreakEscape');
@@ -35999,9 +38985,10 @@ function tokenizeHardBreakEscape(effects, ok, nok) {
effects.consume(code);
return open
}
+ /** @type {State} */
function open(code) {
- if (markdownLineEnding$6(code)) {
+ if (markdownLineEnding(code)) {
effects.exit('escapeMarker');
effects.exit('hardBreakEscape');
return ok(code)
@@ -36011,25 +38998,31 @@ function tokenizeHardBreakEscape(effects, ok, nok) {
}
}
-var hardBreakEscape_1 = hardBreakEscape$1;
-
-var markdownLineEnding$5 = markdownLineEnding_1;
-var markdownLineEndingOrSpace$4 = markdownLineEndingOrSpace_1;
-var markdownSpace$5 = markdownSpace_1;
-var chunkedSplice$1 = chunkedSplice_1;
-var factorySpace$6 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ */
-var headingAtx$1 = {
+/** @type {Construct} */
+const headingAtx = {
name: 'headingAtx',
tokenize: tokenizeHeadingAtx,
resolve: resolveHeadingAtx
};
+/** @type {Resolver} */
function resolveHeadingAtx(events, context) {
- var contentEnd = events.length - 2;
- var contentStart = 3;
- var content;
- var text; // Prefix whitespace, part of the opening.
+ let contentEnd = events.length - 2;
+ let contentStart = 3;
+ /** @type {Token} */
+
+ let content;
+ /** @type {Token} */
+
+ let text; // Prefix whitespace, part of the opening.
if (events[contentStart][1].type === 'whitespace') {
contentStart += 2;
@@ -36061,9 +39054,10 @@ function resolveHeadingAtx(events, context) {
type: 'chunkText',
start: events[contentStart][1].start,
end: events[contentEnd][1].end,
+ // @ts-expect-error Constants are fine to assign.
contentType: 'text'
};
- chunkedSplice$1(events, contentStart, contentEnd - contentStart + 1, [
+ splice(events, contentStart, contentEnd - contentStart + 1, [
['enter', content, context],
['enter', text, context],
['exit', text, context],
@@ -36073,17 +39067,20 @@ function resolveHeadingAtx(events, context) {
return events
}
+/** @type {Tokenizer} */
function tokenizeHeadingAtx(effects, ok, nok) {
- var self = this;
- var size = 0;
+ const self = this;
+ let size = 0;
return start
+ /** @type {State} */
function start(code) {
effects.enter('atxHeading');
effects.enter('atxHeadingSequence');
return fenceOpenInside(code)
}
+ /** @type {State} */
function fenceOpenInside(code) {
if (code === 35 && size++ < 6) {
@@ -36091,13 +39088,14 @@ function tokenizeHeadingAtx(effects, ok, nok) {
return fenceOpenInside
}
- if (code === null || markdownLineEndingOrSpace$4(code)) {
+ if (code === null || markdownLineEndingOrSpace(code)) {
effects.exit('atxHeadingSequence');
return self.interrupt ? ok(code) : headingBreak(code)
}
return nok(code)
}
+ /** @type {State} */
function headingBreak(code) {
if (code === 35) {
@@ -36105,18 +39103,19 @@ function tokenizeHeadingAtx(effects, ok, nok) {
return sequence(code)
}
- if (code === null || markdownLineEnding$5(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('atxHeading');
return ok(code)
}
- if (markdownSpace$5(code)) {
- return factorySpace$6(effects, headingBreak, 'whitespace')(code)
+ if (markdownSpace(code)) {
+ return factorySpace(effects, headingBreak, 'whitespace')(code)
}
effects.enter('atxHeadingText');
return data(code)
}
+ /** @type {State} */
function sequence(code) {
if (code === 35) {
@@ -36127,9 +39126,10 @@ function tokenizeHeadingAtx(effects, ok, nok) {
effects.exit('atxHeadingSequence');
return headingBreak(code)
}
+ /** @type {State} */
function data(code) {
- if (code === null || code === 35 || markdownLineEndingOrSpace$4(code)) {
+ if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
effects.exit('atxHeadingText');
return headingBreak(code)
}
@@ -36139,10 +39139,17 @@ function tokenizeHeadingAtx(effects, ok, nok) {
}
}
-var headingAtx_1 = headingAtx$1;
-
-// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.
-var basics = [
+/**
+ * List of lowercase HTML tag names which when parsing HTML (flow), result
+ * in more relaxed rules (condition 6): because they are known blocks, the
+ * HTML-like syntax doesn’t have to be strictly parsed.
+ * For tag names not in this list, a more strict algorithm (condition 7) is used
+ * to detect whether the HTML-like syntax is seen as HTML (flow) or not.
+ *
+ * This is copied from:
+ * <https://spec.commonmark.org/0.29/#html-blocks>.
+ */
+const htmlBlockNames = [
'address',
'article',
'aside',
@@ -36207,36 +39214,45 @@ var basics = [
'ul'
];
-var htmlBlockNames$1 = basics;
-
-// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.
-var raws = ['pre', 'script', 'style', 'textarea'];
-
-var htmlRawNames$1 = raws;
+/**
+ * List of lowercase HTML tag names which when parsing HTML (flow), result in
+ * HTML that can include lines w/o exiting, until a closing tag also in this
+ * list is found (condition 1).
+ *
+ * This module is copied from:
+ * <https://spec.commonmark.org/0.29/#html-blocks>.
+ *
+ * Note that `textarea` is not available in `CommonMark@0.29` but has been
+ * merged to the primary branch and is slated to be released in the next release
+ * of CommonMark.
+ */
+const htmlRawNames = ['pre', 'script', 'style', 'textarea'];
-var asciiAlpha$2 = asciiAlpha_1;
-var asciiAlphanumeric$2 = asciiAlphanumeric_1;
-var markdownLineEnding$4 = markdownLineEnding_1;
-var markdownLineEndingOrSpace$3 = markdownLineEndingOrSpace_1;
-var markdownSpace$4 = markdownSpace_1;
-var fromCharCode = fromCharCode_1;
-var htmlBlockNames = htmlBlockNames$1;
-var htmlRawNames = htmlRawNames$1;
-var partialBlankLine$1 = partialBlankLine_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/** @type {Construct} */
-var htmlFlow$1 = {
+const htmlFlow = {
name: 'htmlFlow',
tokenize: tokenizeHtmlFlow,
resolveTo: resolveToHtmlFlow,
concrete: true
};
-var nextBlankConstruct = {
+/** @type {Construct} */
+
+const nextBlankConstruct = {
tokenize: tokenizeNextBlank,
partial: true
};
+/** @type {Resolver} */
function resolveToHtmlFlow(events) {
- var index = events.length;
+ let index = events.length;
while (index--) {
if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {
@@ -36255,15 +39271,27 @@ function resolveToHtmlFlow(events) {
return events
}
+/** @type {Tokenizer} */
function tokenizeHtmlFlow(effects, ok, nok) {
- var self = this;
- var kind;
- var startTag;
- var buffer;
- var index;
- var marker;
+ const self = this;
+ /** @type {number} */
+
+ let kind;
+ /** @type {boolean} */
+
+ let startTag;
+ /** @type {string} */
+
+ let buffer;
+ /** @type {number} */
+
+ let index;
+ /** @type {Code} */
+
+ let marker;
return start
+ /** @type {State} */
function start(code) {
effects.enter('htmlFlow');
@@ -36271,6 +39299,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
effects.consume(code);
return open
}
+ /** @type {State} */
function open(code) {
if (code === 33) {
@@ -36291,15 +39320,16 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return self.interrupt ? ok : continuationDeclarationInside
}
- if (asciiAlpha$2(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
- buffer = fromCharCode(code);
+ buffer = String.fromCharCode(code);
startTag = true;
return tagName
}
return nok(code)
}
+ /** @type {State} */
function declarationStart(code) {
if (code === 45) {
@@ -36316,7 +39346,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return cdataOpenInside
}
- if (asciiAlpha$2(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
kind = 4;
return self.interrupt ? ok : continuationDeclarationInside
@@ -36324,6 +39354,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function commentOpenInside(code) {
if (code === 45) {
@@ -36333,6 +39364,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function cdataOpenInside(code) {
if (code === buffer.charCodeAt(index++)) {
@@ -36346,34 +39378,36 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function tagCloseStart(code) {
- if (asciiAlpha$2(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
- buffer = fromCharCode(code);
+ buffer = String.fromCharCode(code);
return tagName
}
return nok(code)
}
+ /** @type {State} */
function tagName(code) {
if (
code === null ||
code === 47 ||
code === 62 ||
- markdownLineEndingOrSpace$3(code)
+ markdownLineEndingOrSpace(code)
) {
if (
code !== 47 &&
startTag &&
- htmlRawNames.indexOf(buffer.toLowerCase()) > -1
+ htmlRawNames.includes(buffer.toLowerCase())
) {
kind = 1;
return self.interrupt ? ok(code) : continuation(code)
}
- if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {
+ if (htmlBlockNames.includes(buffer.toLowerCase())) {
kind = 6;
if (code === 47) {
@@ -36384,23 +39418,24 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return self.interrupt ? ok(code) : continuation(code)
}
- kind = 7; // Do not support complete HTML when interrupting.
+ kind = 7; // Do not support complete HTML when interrupting
- return self.interrupt
+ return self.interrupt && !self.parser.lazy[self.now().line]
? nok(code)
: startTag
? completeAttributeNameBefore(code)
: completeClosingTagAfter(code)
}
- if (code === 45 || asciiAlphanumeric$2(code)) {
+ if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
- buffer += fromCharCode(code);
+ buffer += String.fromCharCode(code);
return tagName
}
return nok(code)
}
+ /** @type {State} */
function basicSelfClosing(code) {
if (code === 62) {
@@ -36410,15 +39445,17 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function completeClosingTagAfter(code) {
- if (markdownSpace$4(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return completeClosingTagAfter
}
return completeEnd(code)
}
+ /** @type {State} */
function completeAttributeNameBefore(code) {
if (code === 47) {
@@ -36426,18 +39463,19 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return completeEnd
}
- if (code === 58 || code === 95 || asciiAlpha$2(code)) {
+ if (code === 58 || code === 95 || asciiAlpha(code)) {
effects.consume(code);
return completeAttributeName
}
- if (markdownSpace$4(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeNameBefore
}
return completeEnd(code)
}
+ /** @type {State} */
function completeAttributeName(code) {
if (
@@ -36445,7 +39483,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
code === 46 ||
code === 58 ||
code === 95 ||
- asciiAlphanumeric$2(code)
+ asciiAlphanumeric(code)
) {
effects.consume(code);
return completeAttributeName
@@ -36453,6 +39491,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return completeAttributeNameAfter(code)
}
+ /** @type {State} */
function completeAttributeNameAfter(code) {
if (code === 61) {
@@ -36460,13 +39499,14 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return completeAttributeValueBefore
}
- if (markdownSpace$4(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeNameAfter
}
return completeAttributeNameBefore(code)
}
+ /** @type {State} */
function completeAttributeValueBefore(code) {
if (
@@ -36485,28 +39525,30 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return completeAttributeValueQuoted
}
- if (markdownSpace$4(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeValueBefore
}
- marker = undefined;
+ marker = null;
return completeAttributeValueUnquoted(code)
}
+ /** @type {State} */
function completeAttributeValueQuoted(code) {
+ if (code === null || markdownLineEnding(code)) {
+ return nok(code)
+ }
+
if (code === marker) {
effects.consume(code);
return completeAttributeValueQuotedAfter
}
- if (code === null || markdownLineEnding$4(code)) {
- return nok(code)
- }
-
effects.consume(code);
return completeAttributeValueQuoted
}
+ /** @type {State} */
function completeAttributeValueUnquoted(code) {
if (
@@ -36517,7 +39559,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
code === 61 ||
code === 62 ||
code === 96 ||
- markdownLineEndingOrSpace$3(code)
+ markdownLineEndingOrSpace(code)
) {
return completeAttributeNameAfter(code)
}
@@ -36525,14 +39567,16 @@ function tokenizeHtmlFlow(effects, ok, nok) {
effects.consume(code);
return completeAttributeValueUnquoted
}
+ /** @type {State} */
function completeAttributeValueQuotedAfter(code) {
- if (code === 47 || code === 62 || markdownSpace$4(code)) {
+ if (code === 47 || code === 62 || markdownSpace(code)) {
return completeAttributeNameBefore(code)
}
return nok(code)
}
+ /** @type {State} */
function completeEnd(code) {
if (code === 62) {
@@ -36542,17 +39586,19 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function completeAfter(code) {
- if (markdownSpace$4(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return completeAfter
}
- return code === null || markdownLineEnding$4(code)
+ return code === null || markdownLineEnding(code)
? continuation(code)
: nok(code)
}
+ /** @type {State} */
function continuation(code) {
if (code === 45 && kind === 2) {
@@ -36580,7 +39626,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return continuationCharacterDataInside
}
- if (markdownLineEnding$4(code) && (kind === 6 || kind === 7)) {
+ if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {
return effects.check(
nextBlankConstruct,
continuationClose,
@@ -36588,34 +39634,59 @@ function tokenizeHtmlFlow(effects, ok, nok) {
)(code)
}
- if (code === null || markdownLineEnding$4(code)) {
+ if (code === null || markdownLineEnding(code)) {
return continuationAtLineEnding(code)
}
effects.consume(code);
return continuation
}
+ /** @type {State} */
function continuationAtLineEnding(code) {
effects.exit('htmlFlowData');
return htmlContinueStart(code)
}
+ /** @type {State} */
function htmlContinueStart(code) {
if (code === null) {
return done(code)
}
- if (markdownLineEnding$4(code)) {
+ if (markdownLineEnding(code)) {
+ return effects.attempt(
+ {
+ tokenize: htmlLineEnd,
+ partial: true
+ },
+ htmlContinueStart,
+ done
+ )(code)
+ }
+
+ effects.enter('htmlFlowData');
+ return continuation(code)
+ }
+ /** @type {Tokenizer} */
+
+ function htmlLineEnd(effects, ok, nok) {
+ return start
+ /** @type {State} */
+
+ function start(code) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return htmlContinueStart
+ return lineStart
}
+ /** @type {State} */
- effects.enter('htmlFlowData');
- return continuation(code)
+ function lineStart(code) {
+ return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+ }
}
+ /** @type {State} */
function continuationCommentInside(code) {
if (code === 45) {
@@ -36625,6 +39696,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return continuation(code)
}
+ /** @type {State} */
function continuationRawTagOpen(code) {
if (code === 47) {
@@ -36635,21 +39707,23 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return continuation(code)
}
+ /** @type {State} */
function continuationRawEndTag(code) {
- if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {
+ if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {
effects.consume(code);
return continuationClose
}
- if (asciiAlpha$2(code) && buffer.length < 8) {
+ if (asciiAlpha(code) && buffer.length < 8) {
effects.consume(code);
- buffer += fromCharCode(code);
+ buffer += String.fromCharCode(code);
return continuationRawEndTag
}
return continuation(code)
}
+ /** @type {State} */
function continuationCharacterDataInside(code) {
if (code === 93) {
@@ -36659,6 +39733,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return continuation(code)
}
+ /** @type {State} */
function continuationDeclarationInside(code) {
if (code === 62) {
@@ -36668,9 +39743,10 @@ function tokenizeHtmlFlow(effects, ok, nok) {
return continuation(code)
}
+ /** @type {State} */
function continuationClose(code) {
- if (code === null || markdownLineEnding$4(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('htmlFlowData');
return done(code)
}
@@ -36678,46 +39754,58 @@ function tokenizeHtmlFlow(effects, ok, nok) {
effects.consume(code);
return continuationClose
}
+ /** @type {State} */
function done(code) {
effects.exit('htmlFlow');
return ok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeNextBlank(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
effects.exit('htmlFlowData');
effects.enter('lineEndingBlank');
effects.consume(code);
effects.exit('lineEndingBlank');
- return effects.attempt(partialBlankLine$1, ok, nok)
+ return effects.attempt(blankLine, ok, nok)
}
}
-var htmlFlow_1 = htmlFlow$1;
-
-var asciiAlpha$1 = asciiAlpha_1;
-var asciiAlphanumeric$1 = asciiAlphanumeric_1;
-var markdownLineEnding$3 = markdownLineEnding_1;
-var markdownLineEndingOrSpace$2 = markdownLineEndingOrSpace_1;
-var markdownSpace$3 = markdownSpace_1;
-var factorySpace$5 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var htmlText$1 = {
+/** @type {Construct} */
+const htmlText = {
name: 'htmlText',
tokenize: tokenizeHtmlText
};
+/** @type {Tokenizer} */
function tokenizeHtmlText(effects, ok, nok) {
- var self = this;
- var marker;
- var buffer;
- var index;
- var returnState;
+ const self = this;
+ /** @type {NonNullable<Code>|undefined} */
+
+ let marker;
+ /** @type {string} */
+
+ let buffer;
+ /** @type {number} */
+
+ let index;
+ /** @type {State} */
+
+ let returnState;
return start
+ /** @type {State} */
function start(code) {
effects.enter('htmlText');
@@ -36725,6 +39813,7 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return open
}
+ /** @type {State} */
function open(code) {
if (code === 33) {
@@ -36742,13 +39831,14 @@ function tokenizeHtmlText(effects, ok, nok) {
return instruction
}
- if (asciiAlpha$1(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
return tagOpen
}
return nok(code)
}
+ /** @type {State} */
function declarationOpen(code) {
if (code === 45) {
@@ -36763,13 +39853,14 @@ function tokenizeHtmlText(effects, ok, nok) {
return cdataOpen
}
- if (asciiAlpha$1(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
return declaration
}
return nok(code)
}
+ /** @type {State} */
function commentOpen(code) {
if (code === 45) {
@@ -36779,6 +39870,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function commentStart(code) {
if (code === null || code === 62) {
@@ -36792,6 +39884,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return comment(code)
}
+ /** @type {State} */
function commentStartDash(code) {
if (code === null || code === 62) {
@@ -36800,6 +39893,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return comment(code)
}
+ /** @type {State} */
function comment(code) {
if (code === null) {
@@ -36811,7 +39905,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return commentClose
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = comment;
return atLineEnding(code)
}
@@ -36819,6 +39913,7 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return comment
}
+ /** @type {State} */
function commentClose(code) {
if (code === 45) {
@@ -36828,6 +39923,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return comment(code)
}
+ /** @type {State} */
function cdataOpen(code) {
if (code === buffer.charCodeAt(index++)) {
@@ -36837,6 +39933,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function cdata(code) {
if (code === null) {
@@ -36848,7 +39945,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return cdataClose
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = cdata;
return atLineEnding(code)
}
@@ -36856,6 +39953,7 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return cdata
}
+ /** @type {State} */
function cdataClose(code) {
if (code === 93) {
@@ -36865,6 +39963,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return cdata(code)
}
+ /** @type {State} */
function cdataEnd(code) {
if (code === 62) {
@@ -36878,13 +39977,14 @@ function tokenizeHtmlText(effects, ok, nok) {
return cdata(code)
}
+ /** @type {State} */
function declaration(code) {
if (code === null || code === 62) {
return end(code)
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = declaration;
return atLineEnding(code)
}
@@ -36892,6 +39992,7 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return declaration
}
+ /** @type {State} */
function instruction(code) {
if (code === null) {
@@ -36903,7 +40004,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return instructionClose
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = instruction;
return atLineEnding(code)
}
@@ -36911,55 +40012,61 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return instruction
}
+ /** @type {State} */
function instructionClose(code) {
return code === 62 ? end(code) : instruction(code)
}
+ /** @type {State} */
function tagCloseStart(code) {
- if (asciiAlpha$1(code)) {
+ if (asciiAlpha(code)) {
effects.consume(code);
return tagClose
}
return nok(code)
}
+ /** @type {State} */
function tagClose(code) {
- if (code === 45 || asciiAlphanumeric$1(code)) {
+ if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
return tagClose
}
return tagCloseBetween(code)
}
+ /** @type {State} */
function tagCloseBetween(code) {
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = tagCloseBetween;
return atLineEnding(code)
}
- if (markdownSpace$3(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return tagCloseBetween
}
return end(code)
}
+ /** @type {State} */
function tagOpen(code) {
- if (code === 45 || asciiAlphanumeric$1(code)) {
+ if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
return tagOpen
}
- if (code === 47 || code === 62 || markdownLineEndingOrSpace$2(code)) {
+ if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code)
}
return nok(code)
}
+ /** @type {State} */
function tagOpenBetween(code) {
if (code === 47) {
@@ -36967,23 +40074,24 @@ function tokenizeHtmlText(effects, ok, nok) {
return end
}
- if (code === 58 || code === 95 || asciiAlpha$1(code)) {
+ if (code === 58 || code === 95 || asciiAlpha(code)) {
effects.consume(code);
return tagOpenAttributeName
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = tagOpenBetween;
return atLineEnding(code)
}
- if (markdownSpace$3(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return tagOpenBetween
}
return end(code)
}
+ /** @type {State} */
function tagOpenAttributeName(code) {
if (
@@ -36991,7 +40099,7 @@ function tokenizeHtmlText(effects, ok, nok) {
code === 46 ||
code === 58 ||
code === 95 ||
- asciiAlphanumeric$1(code)
+ asciiAlphanumeric(code)
) {
effects.consume(code);
return tagOpenAttributeName
@@ -36999,6 +40107,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return tagOpenAttributeNameAfter(code)
}
+ /** @type {State} */
function tagOpenAttributeNameAfter(code) {
if (code === 61) {
@@ -37006,18 +40115,19 @@ function tokenizeHtmlText(effects, ok, nok) {
return tagOpenAttributeValueBefore
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = tagOpenAttributeNameAfter;
return atLineEnding(code)
}
- if (markdownSpace$3(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return tagOpenAttributeNameAfter
}
return tagOpenBetween(code)
}
+ /** @type {State} */
function tagOpenAttributeValueBefore(code) {
if (
@@ -37036,12 +40146,12 @@ function tokenizeHtmlText(effects, ok, nok) {
return tagOpenAttributeValueQuoted
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = tagOpenAttributeValueBefore;
return atLineEnding(code)
}
- if (markdownSpace$3(code)) {
+ if (markdownSpace(code)) {
effects.consume(code);
return tagOpenAttributeValueBefore
}
@@ -37050,6 +40160,7 @@ function tokenizeHtmlText(effects, ok, nok) {
marker = undefined;
return tagOpenAttributeValueUnquoted
}
+ /** @type {State} */
function tagOpenAttributeValueQuoted(code) {
if (code === marker) {
@@ -37061,7 +40172,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return nok(code)
}
- if (markdownLineEnding$3(code)) {
+ if (markdownLineEnding(code)) {
returnState = tagOpenAttributeValueQuoted;
return atLineEnding(code)
}
@@ -37069,14 +40180,16 @@ function tokenizeHtmlText(effects, ok, nok) {
effects.consume(code);
return tagOpenAttributeValueQuoted
}
+ /** @type {State} */
function tagOpenAttributeValueQuotedAfter(code) {
- if (code === 62 || code === 47 || markdownLineEndingOrSpace$2(code)) {
+ if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code)
}
return nok(code)
}
+ /** @type {State} */
function tagOpenAttributeValueUnquoted(code) {
if (
@@ -37090,7 +40203,7 @@ function tokenizeHtmlText(effects, ok, nok) {
return nok(code)
}
- if (code === 62 || markdownLineEndingOrSpace$2(code)) {
+ if (code === 62 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code)
}
@@ -37099,25 +40212,29 @@ function tokenizeHtmlText(effects, ok, nok) {
} // We can’t have blank lines in content, so no need to worry about empty
// tokens.
+ /** @type {State} */
+
function atLineEnding(code) {
effects.exit('htmlTextData');
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return factorySpace$5(
+ return factorySpace(
effects,
afterPrefix,
'linePrefix',
- self.parser.constructs.disable.null.indexOf('codeIndented') > -1
+ self.parser.constructs.disable.null.includes('codeIndented')
? undefined
: 4
)
}
+ /** @type {State} */
function afterPrefix(code) {
effects.enter('htmlTextData');
return returnState(code)
}
+ /** @type {State} */
function end(code) {
if (code === 62) {
@@ -37131,47 +40248,53 @@ function tokenizeHtmlText(effects, ok, nok) {
}
}
-var htmlText_1 = htmlText$1;
-
-var markdownLineEndingOrSpace$1 = markdownLineEndingOrSpace_1;
-var chunkedPush = chunkedPush_1;
-var chunkedSplice = chunkedSplice_1;
-var normalizeIdentifier$2 = normalizeIdentifier_1;
-var resolveAll$1 = resolveAll_1;
-var shallow$1 = shallow_1;
-var factoryDestination = factoryDestination$2;
-var factoryLabel = factoryLabel$2;
-var factoryTitle = factoryTitle$2;
-var factoryWhitespace = factoryWhitespace$2;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var labelEnd$3 = {
+/** @type {Construct} */
+const labelEnd = {
name: 'labelEnd',
tokenize: tokenizeLabelEnd,
resolveTo: resolveToLabelEnd,
resolveAll: resolveAllLabelEnd
};
-var resourceConstruct = {
+/** @type {Construct} */
+
+const resourceConstruct = {
tokenize: tokenizeResource
};
-var fullReferenceConstruct = {
+/** @type {Construct} */
+
+const fullReferenceConstruct = {
tokenize: tokenizeFullReference
};
-var collapsedReferenceConstruct = {
+/** @type {Construct} */
+
+const collapsedReferenceConstruct = {
tokenize: tokenizeCollapsedReference
};
+/** @type {Resolver} */
function resolveAllLabelEnd(events) {
- var index = -1;
- var token;
+ let index = -1;
+ /** @type {Token} */
+
+ let token;
while (++index < events.length) {
token = events[index][1];
if (
- !token._used &&
- (token.type === 'labelImage' ||
- token.type === 'labelLink' ||
- token.type === 'labelEnd')
+ token.type === 'labelImage' ||
+ token.type === 'labelLink' ||
+ token.type === 'labelEnd'
) {
// Remove the marker.
events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);
@@ -37182,17 +40305,23 @@ function resolveAllLabelEnd(events) {
return events
}
+/** @type {Resolver} */
function resolveToLabelEnd(events, context) {
- var index = events.length;
- var offset = 0;
- var group;
- var label;
- var text;
- var token;
- var open;
- var close;
- var media; // Find an opening.
+ let index = events.length;
+ let offset = 0;
+ /** @type {Token} */
+
+ let token;
+ /** @type {number|undefined} */
+
+ let open;
+ /** @type {number|undefined} */
+
+ let close;
+ /** @type {Event[]} */
+
+ let media; // Find an opening.
while (index--) {
token = events[index][1];
@@ -37228,58 +40357,63 @@ function resolveToLabelEnd(events, context) {
}
}
- group = {
+ const group = {
type: events[open][1].type === 'labelLink' ? 'link' : 'image',
- start: shallow$1(events[open][1].start),
- end: shallow$1(events[events.length - 1][1].end)
+ start: Object.assign({}, events[open][1].start),
+ end: Object.assign({}, events[events.length - 1][1].end)
};
- label = {
+ const label = {
type: 'label',
- start: shallow$1(events[open][1].start),
- end: shallow$1(events[close][1].end)
+ start: Object.assign({}, events[open][1].start),
+ end: Object.assign({}, events[close][1].end)
};
- text = {
+ const text = {
type: 'labelText',
- start: shallow$1(events[open + offset + 2][1].end),
- end: shallow$1(events[close - 2][1].start)
+ start: Object.assign({}, events[open + offset + 2][1].end),
+ end: Object.assign({}, events[close - 2][1].start)
};
media = [
['enter', group, context],
['enter', label, context]
]; // Opening marker.
- media = chunkedPush(media, events.slice(open + 1, open + offset + 3)); // Text open.
+ media = push(media, events.slice(open + 1, open + offset + 3)); // Text open.
- media = chunkedPush(media, [['enter', text, context]]); // Between.
+ media = push(media, [['enter', text, context]]); // Between.
- media = chunkedPush(
+ media = push(
media,
- resolveAll$1(
+ resolveAll(
context.parser.constructs.insideSpan.null,
events.slice(open + offset + 4, close - 3),
context
)
); // Text close, marker close, label close.
- media = chunkedPush(media, [
+ media = push(media, [
['exit', text, context],
events[close - 2],
events[close - 1],
['exit', label, context]
]); // Reference, resource, or so.
- media = chunkedPush(media, events.slice(close + 1)); // Media close.
+ media = push(media, events.slice(close + 1)); // Media close.
- media = chunkedPush(media, [['exit', group, context]]);
- chunkedSplice(events, open, events.length, media);
+ media = push(media, [['exit', group, context]]);
+ splice(events, open, events.length, media);
return events
}
+/** @type {Tokenizer} */
function tokenizeLabelEnd(effects, ok, nok) {
- var self = this;
- var index = self.events.length;
- var labelStart;
- var defined; // Find an opening.
+ const self = this;
+ let index = self.events.length;
+ /** @type {Token} */
+
+ let labelStart;
+ /** @type {boolean} */
+
+ let defined; // Find an opening.
while (index--) {
if (
@@ -37293,6 +40427,7 @@ function tokenizeLabelEnd(effects, ok, nok) {
}
return start
+ /** @type {State} */
function start(code) {
if (!labelStart) {
@@ -37300,15 +40435,14 @@ function tokenizeLabelEnd(effects, ok, nok) {
} // It’s a balanced bracket, but contains a link.
if (labelStart._inactive) return balanced(code)
- defined =
- self.parser.defined.indexOf(
- normalizeIdentifier$2(
- self.sliceSerialize({
- start: labelStart.end,
- end: self.now()
- })
- )
- ) > -1;
+ defined = self.parser.defined.includes(
+ normalizeIdentifier(
+ self.sliceSerialize({
+ start: labelStart.end,
+ end: self.now()
+ })
+ )
+ );
effects.enter('labelEnd');
effects.enter('labelMarker');
effects.consume(code);
@@ -37316,6 +40450,7 @@ function tokenizeLabelEnd(effects, ok, nok) {
effects.exit('labelEnd');
return afterLabelEnd
}
+ /** @type {State} */
function afterLabelEnd(code) {
// Resource: `[asd](fgh)`.
@@ -37339,15 +40474,18 @@ function tokenizeLabelEnd(effects, ok, nok) {
return defined ? ok(code) : balanced(code)
}
+ /** @type {State} */
function balanced(code) {
labelStart._balanced = true;
return nok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeResource(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
effects.enter('resource');
@@ -37356,6 +40494,7 @@ function tokenizeResource(effects, ok, nok) {
effects.exit('resourceMarker');
return factoryWhitespace(effects, open)
}
+ /** @type {State} */
function open(code) {
if (code === 41) {
@@ -37374,12 +40513,14 @@ function tokenizeResource(effects, ok, nok) {
3
)(code)
}
+ /** @type {State} */
function destinationAfter(code) {
- return markdownLineEndingOrSpace$1(code)
+ return markdownLineEndingOrSpace(code)
? factoryWhitespace(effects, between)(code)
: end(code)
}
+ /** @type {State} */
function between(code) {
if (code === 34 || code === 39 || code === 40) {
@@ -37395,6 +40536,7 @@ function tokenizeResource(effects, ok, nok) {
return end(code)
}
+ /** @type {State} */
function end(code) {
if (code === 41) {
@@ -37408,10 +40550,12 @@ function tokenizeResource(effects, ok, nok) {
return nok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeFullReference(effects, ok, nok) {
- var self = this;
+ const self = this;
return start
+ /** @type {State} */
function start(code) {
return factoryLabel.call(
@@ -37424,20 +40568,23 @@ function tokenizeFullReference(effects, ok, nok) {
'referenceString'
)(code)
}
+ /** @type {State} */
function afterLabel(code) {
- return self.parser.defined.indexOf(
- normalizeIdentifier$2(
+ return self.parser.defined.includes(
+ normalizeIdentifier(
self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
)
- ) < 0
- ? nok(code)
- : ok(code)
+ )
+ ? ok(code)
+ : nok(code)
}
}
+/** @type {Tokenizer} */
function tokenizeCollapsedReference(effects, ok, nok) {
return start
+ /** @type {State} */
function start(code) {
effects.enter('reference');
@@ -37446,6 +40593,7 @@ function tokenizeCollapsedReference(effects, ok, nok) {
effects.exit('referenceMarker');
return open
}
+ /** @type {State} */
function open(code) {
if (code === 93) {
@@ -37460,19 +40608,24 @@ function tokenizeCollapsedReference(effects, ok, nok) {
}
}
-var labelEnd_1 = labelEnd$3;
-
-var labelEnd$2 = labelEnd_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
+/** @type {Construct} */
-var labelStartImage$1 = {
+const labelStartImage = {
name: 'labelStartImage',
tokenize: tokenizeLabelStartImage,
- resolveAll: labelEnd$2.resolveAll
+ resolveAll: labelEnd.resolveAll
};
+/** @type {Tokenizer} */
function tokenizeLabelStartImage(effects, ok, nok) {
- var self = this;
+ const self = this;
return start
+ /** @type {State} */
function start(code) {
effects.enter('labelImage');
@@ -37481,6 +40634,7 @@ function tokenizeLabelStartImage(effects, ok, nok) {
effects.exit('labelImageMarker');
return open
}
+ /** @type {State} */
function open(code) {
if (code === 91) {
@@ -37493,31 +40647,36 @@ function tokenizeLabelStartImage(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function after(code) {
- /* c8 ignore next */
- return code === 94 &&
- /* c8 ignore next */
- '_hiddenFootnoteSupport' in self.parser.constructs
- ? /* c8 ignore next */
- nok(code)
+ /* Hidden footnotes hook */
+
+ /* c8 ignore next 3 */
+ return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
+ ? nok(code)
: ok(code)
}
}
-var labelStartImage_1 = labelStartImage$1;
-
-var labelEnd$1 = labelEnd_1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
+/** @type {Construct} */
-var labelStartLink$1 = {
+const labelStartLink = {
name: 'labelStartLink',
tokenize: tokenizeLabelStartLink,
- resolveAll: labelEnd$1.resolveAll
+ resolveAll: labelEnd.resolveAll
};
+/** @type {Tokenizer} */
function tokenizeLabelStartLink(effects, ok, nok) {
- var self = this;
+ const self = this;
return start
+ /** @type {State} */
function start(code) {
effects.enter('labelLink');
@@ -37527,59 +40686,71 @@ function tokenizeLabelStartLink(effects, ok, nok) {
effects.exit('labelLink');
return after
}
+ /** @type {State} */
function after(code) {
- /* c8 ignore next */
- return code === 94 &&
- /* c8 ignore next */
- '_hiddenFootnoteSupport' in self.parser.constructs
- ? /* c8 ignore next */
- nok(code)
+ /* Hidden footnotes hook. */
+
+ /* c8 ignore next 3 */
+ return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
+ ? nok(code)
: ok(code)
}
}
-var labelStartLink_1 = labelStartLink$1;
-
-var factorySpace$4 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ */
-var lineEnding$1 = {
+/** @type {Construct} */
+const lineEnding = {
name: 'lineEnding',
tokenize: tokenizeLineEnding
};
+/** @type {Tokenizer} */
function tokenizeLineEnding(effects, ok) {
return start
+ /** @type {State} */
function start(code) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
- return factorySpace$4(effects, ok, 'linePrefix')
+ return factorySpace(effects, ok, 'linePrefix')
}
}
-var lineEnding_1 = lineEnding$1;
-
-var markdownLineEnding$2 = markdownLineEnding_1;
-var markdownSpace$2 = markdownSpace_1;
-var factorySpace$3 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var thematicBreak$3 = {
+/** @type {Construct} */
+const thematicBreak$1 = {
name: 'thematicBreak',
tokenize: tokenizeThematicBreak
};
+/** @type {Tokenizer} */
function tokenizeThematicBreak(effects, ok, nok) {
- var size = 0;
- var marker;
+ let size = 0;
+ /** @type {NonNullable<Code>} */
+
+ let marker;
return start
+ /** @type {State} */
function start(code) {
effects.enter('thematicBreak');
marker = code;
return atBreak(code)
}
+ /** @type {State} */
function atBreak(code) {
if (code === marker) {
@@ -37587,17 +40758,18 @@ function tokenizeThematicBreak(effects, ok, nok) {
return sequence(code)
}
- if (markdownSpace$2(code)) {
- return factorySpace$3(effects, atBreak, 'whitespace')(code)
+ if (markdownSpace(code)) {
+ return factorySpace(effects, atBreak, 'whitespace')(code)
}
- if (size < 3 || (code !== null && !markdownLineEnding$2(code))) {
+ if (size < 3 || (code !== null && !markdownLineEnding(code))) {
return nok(code)
}
effects.exit('thematicBreak');
return ok(code)
}
+ /** @type {State} */
function sequence(code) {
if (code === marker) {
@@ -37611,17 +40783,17 @@ function tokenizeThematicBreak(effects, ok, nok) {
}
}
-var thematicBreak_1$1 = thematicBreak$3;
-
-var asciiDigit$1 = asciiDigit_1;
-var markdownSpace$1 = markdownSpace_1;
-var prefixSize = prefixSize_1;
-var sizeChunks = sizeChunks_1;
-var factorySpace$2 = factorySpace$i;
-var partialBlankLine = partialBlankLine_1;
-var thematicBreak$2 = thematicBreak_1$1;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Exiter} Exiter
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+/** @type {Construct} */
-var list$2 = {
+const list$1 = {
name: 'list',
tokenize: tokenizeListStart,
continuation: {
@@ -37629,23 +40801,36 @@ var list$2 = {
},
exit: tokenizeListEnd
};
-var listItemPrefixWhitespaceConstruct = {
+/** @type {Construct} */
+
+const listItemPrefixWhitespaceConstruct = {
tokenize: tokenizeListItemPrefixWhitespace,
partial: true
};
-var indentConstruct = {
+/** @type {Construct} */
+
+const indentConstruct = {
tokenize: tokenizeIndent,
partial: true
};
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
function tokenizeListStart(effects, ok, nok) {
- var self = this;
- var initialSize = prefixSize(self.events, 'linePrefix');
- var size = 0;
+ const self = this;
+ const tail = self.events[self.events.length - 1];
+ let initialSize =
+ tail && tail[1].type === 'linePrefix'
+ ? tail[2].sliceSerialize(tail[1], true).length
+ : 0;
+ let size = 0;
return start
+ /** @type {State} */
function start(code) {
- var kind =
+ const kind =
self.containerState.type ||
(code === 42 || code === 43 || code === 45
? 'listUnordered'
@@ -37654,7 +40839,7 @@ function tokenizeListStart(effects, ok, nok) {
if (
kind === 'listUnordered'
? !self.containerState.marker || code === self.containerState.marker
- : asciiDigit$1(code)
+ : asciiDigit(code)
) {
if (!self.containerState.type) {
self.containerState.type = kind;
@@ -37666,7 +40851,7 @@ function tokenizeListStart(effects, ok, nok) {
if (kind === 'listUnordered') {
effects.enter('listItemPrefix');
return code === 42 || code === 45
- ? effects.check(thematicBreak$2, nok, atMarker)(code)
+ ? effects.check(thematicBreak$1, nok, atMarker)(code)
: atMarker(code)
}
@@ -37679,9 +40864,10 @@ function tokenizeListStart(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function inside(code) {
- if (asciiDigit$1(code) && ++size < 10) {
+ if (asciiDigit(code) && ++size < 10) {
effects.consume(code);
return inside
}
@@ -37698,6 +40884,9 @@ function tokenizeListStart(effects, ok, nok) {
return nok(code)
}
+ /**
+ * @type {State}
+ **/
function atMarker(code) {
effects.enter('listItemMarker');
@@ -37705,7 +40894,7 @@ function tokenizeListStart(effects, ok, nok) {
effects.exit('listItemMarker');
self.containerState.marker = self.containerState.marker || code;
return effects.check(
- partialBlankLine, // Can’t be empty when interrupting.
+ blankLine, // Can’t be empty when interrupting.
self.interrupt ? nok : onBlank,
effects.attempt(
listItemPrefixWhitespaceConstruct,
@@ -37714,15 +40903,17 @@ function tokenizeListStart(effects, ok, nok) {
)
)
}
+ /** @type {State} */
function onBlank(code) {
self.containerState.initialBlankLine = true;
initialSize++;
return endOfPrefix(code)
}
+ /** @type {State} */
function otherPrefix(code) {
- if (markdownSpace$1(code)) {
+ if (markdownSpace(code)) {
effects.enter('listItemPrefixWhitespace');
effects.consume(code);
effects.exit('listItemPrefixWhitespace');
@@ -37731,18 +40922,25 @@ function tokenizeListStart(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function endOfPrefix(code) {
self.containerState.size =
- initialSize + sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));
+ initialSize +
+ self.sliceSerialize(effects.exit('listItemPrefix'), true).length;
return ok(code)
}
}
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
function tokenizeListContinuation(effects, ok, nok) {
- var self = this;
+ const self = this;
self.containerState._closeFlow = undefined;
- return effects.check(partialBlankLine, onBlank, notBlank)
+ return effects.check(blankLine, onBlank, notBlank)
+ /** @type {State} */
function onBlank(code) {
self.containerState.furtherBlankLines =
@@ -37750,98 +40948,129 @@ function tokenizeListContinuation(effects, ok, nok) {
self.containerState.initialBlankLine; // We have a blank line.
// Still, try to consume at most the items size.
- return factorySpace$2(
+ return factorySpace(
effects,
ok,
'listItemIndent',
self.containerState.size + 1
)(code)
}
+ /** @type {State} */
function notBlank(code) {
- if (self.containerState.furtherBlankLines || !markdownSpace$1(code)) {
- self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;
+ if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
+ self.containerState.furtherBlankLines = undefined;
+ self.containerState.initialBlankLine = undefined;
return notInCurrentItem(code)
}
- self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;
+ self.containerState.furtherBlankLines = undefined;
+ self.containerState.initialBlankLine = undefined;
return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)
}
+ /** @type {State} */
function notInCurrentItem(code) {
// While we do continue, we signal that the flow should be closed.
self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.
self.interrupt = undefined;
- return factorySpace$2(
+ return factorySpace(
effects,
- effects.attempt(list$2, ok, nok),
+ effects.attempt(list$1, ok, nok),
'linePrefix',
- self.parser.constructs.disable.null.indexOf('codeIndented') > -1
+ self.parser.constructs.disable.null.includes('codeIndented')
? undefined
: 4
)(code)
}
}
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
function tokenizeIndent(effects, ok, nok) {
- var self = this;
- return factorySpace$2(
+ const self = this;
+ return factorySpace(
effects,
afterPrefix,
'listItemIndent',
self.containerState.size + 1
)
+ /** @type {State} */
function afterPrefix(code) {
- return prefixSize(self.events, 'listItemIndent') ===
- self.containerState.size
+ const tail = self.events[self.events.length - 1];
+ return tail &&
+ tail[1].type === 'listItemIndent' &&
+ tail[2].sliceSerialize(tail[1], true).length === self.containerState.size
? ok(code)
: nok(code)
}
}
+/**
+ * @type {Exiter}
+ * @this {TokenizeContextWithState}
+ */
function tokenizeListEnd(effects) {
effects.exit(this.containerState.type);
}
+/**
+ * @type {Tokenizer}
+ * @this {TokenizeContextWithState}
+ */
function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
- var self = this;
- return factorySpace$2(
+ const self = this;
+ return factorySpace(
effects,
afterPrefix,
'listItemPrefixWhitespace',
- self.parser.constructs.disable.null.indexOf('codeIndented') > -1
+ self.parser.constructs.disable.null.includes('codeIndented')
? undefined
: 4 + 1
)
+ /** @type {State} */
function afterPrefix(code) {
- return markdownSpace$1(code) ||
- !prefixSize(self.events, 'listItemPrefixWhitespace')
- ? nok(code)
- : ok(code)
+ const tail = self.events[self.events.length - 1];
+ return !markdownSpace(code) &&
+ tail &&
+ tail[1].type === 'listItemPrefixWhitespace'
+ ? ok(code)
+ : nok(code)
}
}
-var list_1$1 = list$2;
-
-var markdownLineEnding$1 = markdownLineEnding_1;
-var shallow = shallow_1;
-var factorySpace$1 = factorySpace$i;
+/**
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var setextUnderline$1 = {
+/** @type {Construct} */
+const setextUnderline = {
name: 'setextUnderline',
tokenize: tokenizeSetextUnderline,
resolveTo: resolveToSetextUnderline
};
+/** @type {Resolver} */
function resolveToSetextUnderline(events, context) {
- var index = events.length;
- var content;
- var text;
- var definition;
- var heading; // Find the opening of the content.
+ let index = events.length;
+ /** @type {number|undefined} */
+
+ let content;
+ /** @type {number|undefined} */
+
+ let text;
+ /** @type {number|undefined} */
+
+ let definition; // Find the opening of the content.
// It’ll always exist: we don’t tokenize if it isn’t there.
while (index--) {
@@ -37867,10 +41096,10 @@ function resolveToSetextUnderline(events, context) {
}
}
- heading = {
+ const heading = {
type: 'setextHeading',
- start: shallow(events[text][1].start),
- end: shallow(events[events.length - 1][1].end)
+ start: Object.assign({}, events[text][1].start),
+ end: Object.assign({}, events[events.length - 1][1].end)
}; // Change the paragraph to setext heading text.
events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,
@@ -37879,7 +41108,7 @@ function resolveToSetextUnderline(events, context) {
if (definition) {
events.splice(text, 0, ['enter', heading, context]);
events.splice(definition + 1, 0, ['exit', events[content][1], context]);
- events[content][1].end = shallow(events[definition][1].end);
+ events[content][1].end = Object.assign({}, events[definition][1].end);
} else {
events[content][1] = heading;
} // Add the heading exit at the end.
@@ -37887,12 +41116,17 @@ function resolveToSetextUnderline(events, context) {
events.push(['exit', heading, context]);
return events
}
+/** @type {Tokenizer} */
function tokenizeSetextUnderline(effects, ok, nok) {
- var self = this;
- var index = self.events.length;
- var marker;
- var paragraph; // Find an opening.
+ const self = this;
+ let index = self.events.length;
+ /** @type {NonNullable<Code>} */
+
+ let marker;
+ /** @type {boolean} */
+
+ let paragraph; // Find an opening.
while (index--) {
// Skip enter/exit of line ending, line prefix, and content.
@@ -37908,9 +41142,10 @@ function tokenizeSetextUnderline(effects, ok, nok) {
}
return start
+ /** @type {State} */
function start(code) {
- if (!self.lazy && (self.interrupt || paragraph)) {
+ if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {
effects.enter('setextHeadingLine');
effects.enter('setextHeadingLineSequence');
marker = code;
@@ -37919,6 +41154,7 @@ function tokenizeSetextUnderline(effects, ok, nok) {
return nok(code)
}
+ /** @type {State} */
function closingSequence(code) {
if (code === marker) {
@@ -37927,11 +41163,12 @@ function tokenizeSetextUnderline(effects, ok, nok) {
}
effects.exit('setextHeadingLineSequence');
- return factorySpace$1(effects, closingSequenceEnd, 'lineSuffix')(code)
+ return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)
}
+ /** @type {State} */
function closingSequenceEnd(code) {
- if (code === null || markdownLineEnding$1(code)) {
+ if (code === null || markdownLineEnding(code)) {
effects.exit('setextHeadingLine');
return ok(code)
}
@@ -37940,185 +41177,1037 @@ function tokenizeSetextUnderline(effects, ok, nok) {
}
}
-var setextUnderline_1 = setextUnderline$1;
-
-Object.defineProperty(constructs$2, '__esModule', {value: true});
-
-var text$1$1 = text$5;
-var attention = attention_1;
-var autolink = autolink_1;
-var blockQuote = blockQuote_1;
-var characterEscape$1 = characterEscape_1;
-var characterReference$1 = characterReference_1;
-var codeFenced = codeFenced_1;
-var codeIndented = codeIndented_1;
-var codeText = codeText_1;
-var definition$1 = definition_1$1;
-var hardBreakEscape = hardBreakEscape_1;
-var headingAtx = headingAtx_1;
-var htmlFlow = htmlFlow_1;
-var htmlText = htmlText_1;
-var labelEnd = labelEnd_1;
-var labelStartImage = labelStartImage_1;
-var labelStartLink = labelStartLink_1;
-var lineEnding = lineEnding_1;
-var list$1 = list_1$1;
-var setextUnderline = setextUnderline_1;
-var thematicBreak$1 = thematicBreak_1$1;
-
-var document$2 = {
- 42: list$1,
- // Asterisk
- 43: list$1,
- // Plus sign
- 45: list$1,
- // Dash
- 48: list$1,
- // 0
- 49: list$1,
- // 1
- 50: list$1,
- // 2
- 51: list$1,
- // 3
- 52: list$1,
- // 4
- 53: list$1,
- // 5
- 54: list$1,
- // 6
- 55: list$1,
- // 7
- 56: list$1,
- // 8
- 57: list$1,
- // 9
- 62: blockQuote // Greater than
-};
-var contentInitial = {
- 91: definition$1 // Left square bracket
-};
-var flowInitial = {
- '-2': codeIndented,
- // Horizontal tab
- '-1': codeIndented,
- // Virtual space
- 32: codeIndented // Space
-};
-var flow$6 = {
- 35: headingAtx,
- // Number sign
- 42: thematicBreak$1,
- // Asterisk
- 45: [setextUnderline, thematicBreak$1],
- // Dash
- 60: htmlFlow,
- // Less than
- 61: setextUnderline,
- // Equals to
- 95: thematicBreak$1,
- // Underscore
- 96: codeFenced,
- // Grave accent
- 126: codeFenced // Tilde
-};
-var string = {
- 38: characterReference$1,
- // Ampersand
- 92: characterEscape$1 // Backslash
-};
-var text$3 = {
- '-5': lineEnding,
- // Carriage return
- '-4': lineEnding,
- // Line feed
- '-3': lineEnding,
- // Carriage return + line feed
- 33: labelStartImage,
- // Exclamation mark
- 38: characterReference$1,
- // Ampersand
- 42: attention,
- // Asterisk
- 60: [autolink, htmlText],
- // Less than
- 91: labelStartLink,
- // Left square bracket
- 92: [hardBreakEscape, characterEscape$1],
- // Backslash
- 93: labelEnd,
- // Right square bracket
- 95: attention,
- // Underscore
- 96: codeText // Grave accent
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').State} State
+ */
+
+/** @type {InitialConstruct} */
+const flow$1 = {
+ tokenize: initializeFlow
};
-var insideSpan = {
- null: [attention, text$1$1.resolver]
+/** @type {Initializer} */
+
+function initializeFlow(effects) {
+ const self = this;
+ const initial = effects.attempt(
+ // Try to parse a blank line.
+ blankLine,
+ atBlankEnding, // Try to parse initial flow (essentially, only code).
+ effects.attempt(
+ this.parser.constructs.flowInitial,
+ afterConstruct,
+ factorySpace(
+ effects,
+ effects.attempt(
+ this.parser.constructs.flow,
+ afterConstruct,
+ effects.attempt(content, afterConstruct)
+ ),
+ 'linePrefix'
+ )
+ )
+ );
+ return initial
+ /** @type {State} */
+
+ function atBlankEnding(code) {
+ if (code === null) {
+ effects.consume(code);
+ return
+ }
+
+ effects.enter('lineEndingBlank');
+ effects.consume(code);
+ effects.exit('lineEndingBlank');
+ self.currentConstruct = undefined;
+ return initial
+ }
+ /** @type {State} */
+
+ function afterConstruct(code) {
+ if (code === null) {
+ effects.consume(code);
+ return
+ }
+
+ effects.enter('lineEnding');
+ effects.consume(code);
+ effects.exit('lineEnding');
+ self.currentConstruct = undefined;
+ return initial
+ }
+}
+
+/**
+ * @typedef {import('micromark-util-types').Resolver} Resolver
+ * @typedef {import('micromark-util-types').Initializer} Initializer
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Code} Code
+ */
+const resolver = {
+ resolveAll: createResolver()
};
-var disable = {
+const string$1 = initializeFactory('string');
+const text$3 = initializeFactory('text');
+/**
+ * @param {'string'|'text'} field
+ * @returns {InitialConstruct}
+ */
+
+function initializeFactory(field) {
+ return {
+ tokenize: initializeText,
+ resolveAll: createResolver(
+ field === 'text' ? resolveAllLineSuffixes : undefined
+ )
+ }
+ /** @type {Initializer} */
+
+ function initializeText(effects) {
+ const self = this;
+ const constructs = this.parser.constructs[field];
+ const text = effects.attempt(constructs, start, notText);
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ return atBreak(code) ? text(code) : notText(code)
+ }
+ /** @type {State} */
+
+ function notText(code) {
+ if (code === null) {
+ effects.consume(code);
+ return
+ }
+
+ effects.enter('data');
+ effects.consume(code);
+ return data
+ }
+ /** @type {State} */
+
+ function data(code) {
+ if (atBreak(code)) {
+ effects.exit('data');
+ return text(code)
+ } // Data.
+
+ effects.consume(code);
+ return data
+ }
+ /**
+ * @param {Code} code
+ * @returns {boolean}
+ */
+
+ function atBreak(code) {
+ if (code === null) {
+ return true
+ }
+
+ const list = constructs[code];
+ let index = -1;
+
+ if (list) {
+ while (++index < list.length) {
+ const item = list[index];
+
+ if (!item.previous || item.previous.call(self, self.previous)) {
+ return true
+ }
+ }
+ }
+
+ return false
+ }
+ }
+}
+/**
+ * @param {Resolver} [extraResolver]
+ * @returns {Resolver}
+ */
+
+function createResolver(extraResolver) {
+ return resolveAllText
+ /** @type {Resolver} */
+
+ function resolveAllText(events, context) {
+ let index = -1;
+ /** @type {number|undefined} */
+
+ let enter; // A rather boring computation (to merge adjacent `data` events) which
+ // improves mm performance by 29%.
+
+ while (++index <= events.length) {
+ if (enter === undefined) {
+ if (events[index] && events[index][1].type === 'data') {
+ enter = index;
+ index++;
+ }
+ } else if (!events[index] || events[index][1].type !== 'data') {
+ // Don’t do anything if there is one data token.
+ if (index !== enter + 2) {
+ events[enter][1].end = events[index - 1][1].end;
+ events.splice(enter + 2, index - enter - 2);
+ index = enter + 2;
+ }
+
+ enter = undefined;
+ }
+ }
+
+ return extraResolver ? extraResolver(events, context) : events
+ }
+}
+/**
+ * A rather ugly set of instructions which again looks at chunks in the input
+ * stream.
+ * The reason to do this here is that it is *much* faster to parse in reverse.
+ * And that we can’t hook into `null` to split the line suffix before an EOF.
+ * To do: figure out if we can make this into a clean utility, or even in core.
+ * As it will be useful for GFMs literal autolink extension (and maybe even
+ * tables?)
+ *
+ * @type {Resolver}
+ */
+
+function resolveAllLineSuffixes(events, context) {
+ let eventIndex = -1;
+
+ while (++eventIndex <= events.length) {
+ if (
+ (eventIndex === events.length ||
+ events[eventIndex][1].type === 'lineEnding') &&
+ events[eventIndex - 1][1].type === 'data'
+ ) {
+ const data = events[eventIndex - 1][1];
+ const chunks = context.sliceStream(data);
+ let index = chunks.length;
+ let bufferIndex = -1;
+ let size = 0;
+ /** @type {boolean|undefined} */
+
+ let tabs;
+
+ while (index--) {
+ const chunk = chunks[index];
+
+ if (typeof chunk === 'string') {
+ bufferIndex = chunk.length;
+
+ while (chunk.charCodeAt(bufferIndex - 1) === 32) {
+ size++;
+ bufferIndex--;
+ }
+
+ if (bufferIndex) break
+ bufferIndex = -1;
+ } // Number
+ else if (chunk === -2) {
+ tabs = true;
+ size++;
+ } else if (chunk === -1) ; else {
+ // Replacement character, exit.
+ index++;
+ break
+ }
+ }
+
+ if (size) {
+ const token = {
+ type:
+ eventIndex === events.length || tabs || size < 2
+ ? 'lineSuffix'
+ : 'hardBreakTrailing',
+ start: {
+ line: data.end.line,
+ column: data.end.column - size,
+ offset: data.end.offset - size,
+ _index: data.start._index + index,
+ _bufferIndex: index
+ ? bufferIndex
+ : data.start._bufferIndex + bufferIndex
+ },
+ end: Object.assign({}, data.end)
+ };
+ data.end = Object.assign({}, token.start);
+
+ if (data.start.offset === data.end.offset) {
+ Object.assign(data, token);
+ } else {
+ events.splice(
+ eventIndex,
+ 0,
+ ['enter', token, context],
+ ['exit', token, context]
+ );
+ eventIndex += 2;
+ }
+ }
+
+ eventIndex++;
+ }
+ }
+
+ return events
+}
+
+/**
+ * @typedef {import('micromark-util-types').Code} Code
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Point} Point
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').Effects} Effects
+ * @typedef {import('micromark-util-types').State} State
+ * @typedef {import('micromark-util-types').Construct} Construct
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').ParseContext} ParseContext
+ */
+
+/**
+ * Create a tokenizer.
+ * Tokenizers deal with one type of data (e.g., containers, flow, text).
+ * The parser is the object dealing with it all.
+ * `initialize` works like other constructs, except that only its `tokenize`
+ * function is used, in which case it doesn’t receive an `ok` or `nok`.
+ * `from` can be given to set the point before the first character, although
+ * when further lines are indented, they must be set with `defineSkip`.
+ *
+ * @param {ParseContext} parser
+ * @param {InitialConstruct} initialize
+ * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]
+ * @returns {TokenizeContext}
+ */
+function createTokenizer(parser, initialize, from) {
+ /** @type {Point} */
+ let point = Object.assign(
+ from
+ ? Object.assign({}, from)
+ : {
+ line: 1,
+ column: 1,
+ offset: 0
+ },
+ {
+ _index: 0,
+ _bufferIndex: -1
+ }
+ );
+ /** @type {Record<string, number>} */
+
+ const columnStart = {};
+ /** @type {Construct[]} */
+
+ const resolveAllConstructs = [];
+ /** @type {Chunk[]} */
+
+ let chunks = [];
+ /** @type {Token[]} */
+
+ let stack = [];
+ /**
+ * Tools used for tokenizing.
+ *
+ * @type {Effects}
+ */
+
+ const effects = {
+ consume,
+ enter,
+ exit,
+ attempt: constructFactory(onsuccessfulconstruct),
+ check: constructFactory(onsuccessfulcheck),
+ interrupt: constructFactory(onsuccessfulcheck, {
+ interrupt: true
+ })
+ };
+ /**
+ * State and tools for resolving and serializing.
+ *
+ * @type {TokenizeContext}
+ */
+
+ const context = {
+ previous: null,
+ code: null,
+ containerState: {},
+ events: [],
+ parser,
+ sliceStream,
+ sliceSerialize,
+ now,
+ defineSkip,
+ write
+ };
+ /**
+ * The state function.
+ *
+ * @type {State|void}
+ */
+
+ let state = initialize.tokenize.call(context, effects);
+
+ if (initialize.resolveAll) {
+ resolveAllConstructs.push(initialize);
+ }
+
+ return context
+ /** @type {TokenizeContext['write']} */
+
+ function write(slice) {
+ chunks = push(chunks, slice);
+ main(); // Exit if we’re not done, resolve might change stuff.
+
+ if (chunks[chunks.length - 1] !== null) {
+ return []
+ }
+
+ addResult(initialize, 0); // Otherwise, resolve, and exit.
+
+ context.events = resolveAll(resolveAllConstructs, context.events, context);
+ return context.events
+ } //
+ // Tools.
+ //
+
+ /** @type {TokenizeContext['sliceSerialize']} */
+
+ function sliceSerialize(token, expandTabs) {
+ return serializeChunks(sliceStream(token), expandTabs)
+ }
+ /** @type {TokenizeContext['sliceStream']} */
+
+ function sliceStream(token) {
+ return sliceChunks(chunks, token)
+ }
+ /** @type {TokenizeContext['now']} */
+
+ function now() {
+ return Object.assign({}, point)
+ }
+ /** @type {TokenizeContext['defineSkip']} */
+
+ function defineSkip(value) {
+ columnStart[value.line] = value.column;
+ accountForPotentialSkip();
+ } //
+ // State management.
+ //
+
+ /**
+ * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
+ * `consume`).
+ * Here is where we walk through the chunks, which either include strings of
+ * several characters, or numerical character codes.
+ * The reason to do this in a loop instead of a call is so the stack can
+ * drain.
+ *
+ * @returns {void}
+ */
+
+ function main() {
+ /** @type {number} */
+ let chunkIndex;
+
+ while (point._index < chunks.length) {
+ const chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.
+
+ if (typeof chunk === 'string') {
+ chunkIndex = point._index;
+
+ if (point._bufferIndex < 0) {
+ point._bufferIndex = 0;
+ }
+
+ while (
+ point._index === chunkIndex &&
+ point._bufferIndex < chunk.length
+ ) {
+ go(chunk.charCodeAt(point._bufferIndex));
+ }
+ } else {
+ go(chunk);
+ }
+ }
+ }
+ /**
+ * Deal with one code.
+ *
+ * @param {Code} code
+ * @returns {void}
+ */
+
+ function go(code) {
+ state = state(code);
+ }
+ /** @type {Effects['consume']} */
+
+ function consume(code) {
+ if (markdownLineEnding(code)) {
+ point.line++;
+ point.column = 1;
+ point.offset += code === -3 ? 2 : 1;
+ accountForPotentialSkip();
+ } else if (code !== -1) {
+ point.column++;
+ point.offset++;
+ } // Not in a string chunk.
+
+ if (point._bufferIndex < 0) {
+ point._index++;
+ } else {
+ point._bufferIndex++; // At end of string chunk.
+ // @ts-expect-error Points w/ non-negative `_bufferIndex` reference
+ // strings.
+
+ if (point._bufferIndex === chunks[point._index].length) {
+ point._bufferIndex = -1;
+ point._index++;
+ }
+ } // Expose the previous character.
+
+ context.previous = code; // Mark as consumed.
+ }
+ /** @type {Effects['enter']} */
+
+ function enter(type, fields) {
+ /** @type {Token} */
+ // @ts-expect-error Patch instead of assign required fields to help GC.
+ const token = fields || {};
+ token.type = type;
+ token.start = now();
+ context.events.push(['enter', token, context]);
+ stack.push(token);
+ return token
+ }
+ /** @type {Effects['exit']} */
+
+ function exit(type) {
+ const token = stack.pop();
+ token.end = now();
+ context.events.push(['exit', token, context]);
+ return token
+ }
+ /**
+ * Use results.
+ *
+ * @type {ReturnHandle}
+ */
+
+ function onsuccessfulconstruct(construct, info) {
+ addResult(construct, info.from);
+ }
+ /**
+ * Discard results.
+ *
+ * @type {ReturnHandle}
+ */
+
+ function onsuccessfulcheck(_, info) {
+ info.restore();
+ }
+ /**
+ * Factory to attempt/check/interrupt.
+ *
+ * @param {ReturnHandle} onreturn
+ * @param {Record<string, unknown>} [fields]
+ */
+
+ function constructFactory(onreturn, fields) {
+ return hook
+ /**
+ * Handle either an object mapping codes to constructs, a list of
+ * constructs, or a single construct.
+ *
+ * @param {Construct|Construct[]|ConstructRecord} constructs
+ * @param {State} returnState
+ * @param {State} [bogusState]
+ * @returns {State}
+ */
+
+ function hook(constructs, returnState, bogusState) {
+ /** @type {Construct[]} */
+ let listOfConstructs;
+ /** @type {number} */
+
+ let constructIndex;
+ /** @type {Construct} */
+
+ let currentConstruct;
+ /** @type {Info} */
+
+ let info;
+ return Array.isArray(constructs)
+ ? /* c8 ignore next 1 */
+ handleListOfConstructs(constructs)
+ : 'tokenize' in constructs // @ts-expect-error Looks like a construct.
+ ? handleListOfConstructs([constructs])
+ : handleMapOfConstructs(constructs)
+ /**
+ * Handle a list of construct.
+ *
+ * @param {ConstructRecord} map
+ * @returns {State}
+ */
+
+ function handleMapOfConstructs(map) {
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ const def = code !== null && map[code];
+ const all = code !== null && map.null;
+ const list = [
+ // To do: add more extension tests.
+
+ /* c8 ignore next 2 */
+ ...(Array.isArray(def) ? def : def ? [def] : []),
+ ...(Array.isArray(all) ? all : all ? [all] : [])
+ ];
+ return handleListOfConstructs(list)(code)
+ }
+ }
+ /**
+ * Handle a list of construct.
+ *
+ * @param {Construct[]} list
+ * @returns {State}
+ */
+
+ function handleListOfConstructs(list) {
+ listOfConstructs = list;
+ constructIndex = 0;
+
+ if (list.length === 0) {
+ return bogusState
+ }
+
+ return handleConstruct(list[constructIndex])
+ }
+ /**
+ * Handle a single construct.
+ *
+ * @param {Construct} construct
+ * @returns {State}
+ */
+
+ function handleConstruct(construct) {
+ return start
+ /** @type {State} */
+
+ function start(code) {
+ // To do: not needed to store if there is no bogus state, probably?
+ // Currently doesn’t work because `inspect` in document does a check
+ // w/o a bogus, which doesn’t make sense. But it does seem to help perf
+ // by not storing.
+ info = store();
+ currentConstruct = construct;
+
+ if (!construct.partial) {
+ context.currentConstruct = construct;
+ }
+
+ if (
+ construct.name &&
+ context.parser.constructs.disable.null.includes(construct.name)
+ ) {
+ return nok()
+ }
+
+ return construct.tokenize.call(
+ // If we do have fields, create an object w/ `context` as its
+ // prototype.
+ // This allows a “live binding”, which is needed for `interrupt`.
+ fields ? Object.assign(Object.create(context), fields) : context,
+ effects,
+ ok,
+ nok
+ )(code)
+ }
+ }
+ /** @type {State} */
+
+ function ok(code) {
+ onreturn(currentConstruct, info);
+ return returnState
+ }
+ /** @type {State} */
+
+ function nok(code) {
+ info.restore();
+
+ if (++constructIndex < listOfConstructs.length) {
+ return handleConstruct(listOfConstructs[constructIndex])
+ }
+
+ return bogusState
+ }
+ }
+ }
+ /**
+ * @param {Construct} construct
+ * @param {number} from
+ * @returns {void}
+ */
+
+ function addResult(construct, from) {
+ if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
+ resolveAllConstructs.push(construct);
+ }
+
+ if (construct.resolve) {
+ splice(
+ context.events,
+ from,
+ context.events.length - from,
+ construct.resolve(context.events.slice(from), context)
+ );
+ }
+
+ if (construct.resolveTo) {
+ context.events = construct.resolveTo(context.events, context);
+ }
+ }
+ /**
+ * Store state.
+ *
+ * @returns {Info}
+ */
+
+ function store() {
+ const startPoint = now();
+ const startPrevious = context.previous;
+ const startCurrentConstruct = context.currentConstruct;
+ const startEventsIndex = context.events.length;
+ const startStack = Array.from(stack);
+ return {
+ restore,
+ from: startEventsIndex
+ }
+ /**
+ * Restore state.
+ *
+ * @returns {void}
+ */
+
+ function restore() {
+ point = startPoint;
+ context.previous = startPrevious;
+ context.currentConstruct = startCurrentConstruct;
+ context.events.length = startEventsIndex;
+ stack = startStack;
+ accountForPotentialSkip();
+ }
+ }
+ /**
+ * Move the current point a bit forward in the line when it’s on a column
+ * skip.
+ *
+ * @returns {void}
+ */
+
+ function accountForPotentialSkip() {
+ if (point.line in columnStart && point.column < 2) {
+ point.column = columnStart[point.line];
+ point.offset += columnStart[point.line] - 1;
+ }
+ }
+}
+/**
+ * Get the chunks from a slice of chunks in the range of a token.
+ *
+ * @param {Chunk[]} chunks
+ * @param {Pick<Token, 'start'|'end'>} token
+ * @returns {Chunk[]}
+ */
+
+function sliceChunks(chunks, token) {
+ const startIndex = token.start._index;
+ const startBufferIndex = token.start._bufferIndex;
+ const endIndex = token.end._index;
+ const endBufferIndex = token.end._bufferIndex;
+ /** @type {Chunk[]} */
+
+ let view;
+
+ if (startIndex === endIndex) {
+ // @ts-expect-error `_bufferIndex` is used on string chunks.
+ view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
+ } else {
+ view = chunks.slice(startIndex, endIndex);
+
+ if (startBufferIndex > -1) {
+ // @ts-expect-error `_bufferIndex` is used on string chunks.
+ view[0] = view[0].slice(startBufferIndex);
+ }
+
+ if (endBufferIndex > 0) {
+ // @ts-expect-error `_bufferIndex` is used on string chunks.
+ view.push(chunks[endIndex].slice(0, endBufferIndex));
+ }
+ }
+
+ return view
+}
+/**
+ * Get the string value of a slice of chunks.
+ *
+ * @param {Chunk[]} chunks
+ * @param {boolean} [expandTabs=false]
+ * @returns {string}
+ */
+
+function serializeChunks(chunks, expandTabs) {
+ let index = -1;
+ /** @type {string[]} */
+
+ const result = [];
+ /** @type {boolean|undefined} */
+
+ let atTab;
+
+ while (++index < chunks.length) {
+ const chunk = chunks[index];
+ /** @type {string} */
+
+ let value;
+
+ if (typeof chunk === 'string') {
+ value = chunk;
+ } else
+ switch (chunk) {
+ case -5: {
+ value = '\r';
+ break
+ }
+
+ case -4: {
+ value = '\n';
+ break
+ }
+
+ case -3: {
+ value = '\r' + '\n';
+ break
+ }
+
+ case -2: {
+ value = expandTabs ? ' ' : '\t';
+ break
+ }
+
+ case -1: {
+ if (!expandTabs && atTab) continue
+ value = ' ';
+ break
+ }
+
+ default: {
+ // Currently only replacement character.
+ value = String.fromCharCode(chunk);
+ }
+ }
+
+ atTab = chunk === -2;
+ result.push(value);
+ }
+
+ return result.join('')
+}
+
+/**
+ * @typedef {import('micromark-util-types').Extension} Extension
+ */
+/** @type {Extension['document']} */
+
+const document$1 = {
+ [42]: list$1,
+ [43]: list$1,
+ [45]: list$1,
+ [48]: list$1,
+ [49]: list$1,
+ [50]: list$1,
+ [51]: list$1,
+ [52]: list$1,
+ [53]: list$1,
+ [54]: list$1,
+ [55]: list$1,
+ [56]: list$1,
+ [57]: list$1,
+ [62]: blockQuote
+};
+/** @type {Extension['contentInitial']} */
+
+const contentInitial = {
+ [91]: definition$1
+};
+/** @type {Extension['flowInitial']} */
+
+const flowInitial = {
+ [-2]: codeIndented,
+ [-1]: codeIndented,
+ [32]: codeIndented
+};
+/** @type {Extension['flow']} */
+
+const flow = {
+ [35]: headingAtx,
+ [42]: thematicBreak$1,
+ [45]: [setextUnderline, thematicBreak$1],
+ [60]: htmlFlow,
+ [61]: setextUnderline,
+ [95]: thematicBreak$1,
+ [96]: codeFenced,
+ [126]: codeFenced
+};
+/** @type {Extension['string']} */
+
+const string = {
+ [38]: characterReference$1,
+ [92]: characterEscape$1
+};
+/** @type {Extension['text']} */
+
+const text$2 = {
+ [-5]: lineEnding,
+ [-4]: lineEnding,
+ [-3]: lineEnding,
+ [33]: labelStartImage,
+ [38]: characterReference$1,
+ [42]: attention,
+ [60]: [autolink, htmlText],
+ [91]: labelStartLink,
+ [92]: [hardBreakEscape, characterEscape$1],
+ [93]: labelEnd,
+ [95]: attention,
+ [96]: codeText
+};
+/** @type {Extension['insideSpan']} */
+
+const insideSpan = {
+ null: [attention, resolver]
+};
+/** @type {Extension['disable']} */
+
+const disable = {
null: []
};
-constructs$2.contentInitial = contentInitial;
-constructs$2.disable = disable;
-constructs$2.document = document$2;
-constructs$2.flow = flow$6;
-constructs$2.flowInitial = flowInitial;
-constructs$2.insideSpan = insideSpan;
-constructs$2.string = string;
-constructs$2.text = text$3;
-
-var content = content$3;
-var document$1 = document$3;
-var flow$5 = flow$7;
-var text$2 = text$5;
-var combineExtensions$1 = combineExtensions_1;
-var createTokenizer = createTokenizer_1;
-var miniflat = miniflat_1;
-var constructs$1 = constructs$2;
-
-function parse$3(options) {
- var settings = options || {};
- var parser = {
+var defaultConstructs = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ document: document$1,
+ contentInitial: contentInitial,
+ flowInitial: flowInitial,
+ flow: flow,
+ string: string,
+ text: text$2,
+ insideSpan: insideSpan,
+ disable: disable
+});
+
+/**
+ * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
+ * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension
+ * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
+ * @typedef {import('micromark-util-types').ParseContext} ParseContext
+ * @typedef {import('micromark-util-types').Create} Create
+ */
+/**
+ * @param {ParseOptions} [options]
+ * @returns {ParseContext}
+ */
+
+function parse(options = {}) {
+ /** @type {FullNormalizedExtension} */
+ // @ts-expect-error `defaultConstructs` is full, so the result will be too.
+ const constructs = combineExtensions(
+ // @ts-expect-error Same as above.
+ [defaultConstructs].concat(options.extensions || [])
+ );
+ /** @type {ParseContext} */
+
+ const parser = {
defined: [],
- constructs: combineExtensions$1(
- [constructs$1].concat(miniflat(settings.extensions))
- ),
- content: create(content),
- document: create(document$1),
- flow: create(flow$5),
- string: create(text$2.string),
- text: create(text$2.text)
+ lazy: {},
+ constructs,
+ content: create(content$1),
+ document: create(document$2),
+ flow: create(flow$1),
+ string: create(string$1),
+ text: create(text$3)
};
return parser
+ /**
+ * @param {InitialConstruct} initial
+ */
- function create(initializer) {
+ function create(initial) {
return creator
+ /** @type {Create} */
function creator(from) {
- return createTokenizer(parser, initializer, from)
+ return createTokenizer(parser, initial, from)
}
}
}
-var parse_1$1 = parse$3;
+/**
+ * @typedef {import('micromark-util-types').Encoding} Encoding
+ * @typedef {import('micromark-util-types').Value} Value
+ * @typedef {import('micromark-util-types').Chunk} Chunk
+ * @typedef {import('micromark-util-types').Code} Code
+ */
-var search = /[\0\t\n\r]/g;
+/**
+ * @callback Preprocessor
+ * @param {Value} value
+ * @param {Encoding} [encoding]
+ * @param {boolean} [end=false]
+ * @returns {Chunk[]}
+ */
+const search = /[\0\t\n\r]/g;
+/**
+ * @returns {Preprocessor}
+ */
function preprocess() {
- var start = true;
- var column = 1;
- var buffer = '';
- var atCarriageReturn;
+ let column = 1;
+ let buffer = '';
+ /** @type {boolean|undefined} */
+
+ let start = true;
+ /** @type {boolean|undefined} */
+
+ let atCarriageReturn;
return preprocessor
+ /** @type {Preprocessor} */
function preprocessor(value, encoding, end) {
- var chunks = [];
- var match;
- var next;
- var startPosition;
- var endPosition;
- var code;
+ /** @type {Chunk[]} */
+ const chunks = [];
+ /** @type {RegExpMatchArray|null} */
+
+ let match;
+ /** @type {number} */
+
+ let next;
+ /** @type {number} */
+
+ let startPosition;
+ /** @type {number} */
+
+ let endPosition;
+ /** @type {Code} */
+
+ let code; // @ts-expect-error `Buffer` does allow an encoding.
+
value = buffer + value.toString(encoding);
startPosition = 0;
buffer = '';
@@ -38134,7 +42223,8 @@ function preprocess() {
while (startPosition < value.length) {
search.lastIndex = startPosition;
match = search.exec(value);
- endPosition = match ? match.index : value.length;
+ endPosition =
+ match && match.index !== undefined ? match.index : value.length;
code = value.charCodeAt(endPosition);
if (!match) {
@@ -38156,21 +42246,32 @@ function preprocess() {
column += endPosition - startPosition;
}
- if (code === 0) {
- chunks.push(65533);
- column++;
- } else if (code === 9) {
- next = Math.ceil(column / 4) * 4;
- chunks.push(-2);
-
- while (column++ < next) chunks.push(-1);
- } else if (code === 10) {
- chunks.push(-4);
- column = 1;
- } // Must be carriage return.
- else {
- atCarriageReturn = true;
- column = 1;
+ switch (code) {
+ case 0: {
+ chunks.push(65533);
+ column++;
+ break
+ }
+
+ case 9: {
+ next = Math.ceil(column / 4) * 4;
+ chunks.push(-2);
+
+ while (column++ < next) chunks.push(-1);
+
+ break
+ }
+
+ case 10: {
+ chunks.push(-4);
+ column = 1;
+ break
+ }
+
+ default: {
+ atCarriageReturn = true;
+ column = 1;
+ }
}
}
@@ -38187,11 +42288,15 @@ function preprocess() {
}
}
-var preprocess_1 = preprocess;
-
-var subtokenize = subtokenize_1;
+/**
+ * @typedef {import('micromark-util-types').Event} Event
+ */
+/**
+ * @param {Event[]} events
+ * @returns {Event[]}
+ */
-function postprocess$1(events) {
+function postprocess(events) {
while (!subtokenize(events)) {
// Empty
}
@@ -38199,4497 +42304,108 @@ function postprocess$1(events) {
return events
}
-var postprocess_1 = postprocess$1;
-
-const AEli$1 = "Æ";
-const AElig$1 = "Æ";
-const AM$1 = "&";
-const AMP$1 = "&";
-const Aacut$1 = "Á";
-const Aacute$1 = "Á";
-const Abreve$1 = "Ă";
-const Acir$1 = "Â";
-const Acirc$1 = "Â";
-const Acy$1 = "А";
-const Afr$1 = "𝔄";
-const Agrav$1 = "À";
-const Agrave$1 = "À";
-const Alpha$1 = "Α";
-const Amacr$1 = "Ā";
-const And$1 = "⩓";
-const Aogon$1 = "Ą";
-const Aopf$1 = "𝔸";
-const ApplyFunction$1 = "⁡";
-const Arin$1 = "Å";
-const Aring$1 = "Å";
-const Ascr$1 = "𝒜";
-const Assign$1 = "≔";
-const Atild$1 = "Ã";
-const Atilde$1 = "Ã";
-const Aum$1 = "Ä";
-const Auml$1 = "Ä";
-const Backslash$1 = "∖";
-const Barv$1 = "⫧";
-const Barwed$1 = "⌆";
-const Bcy$1 = "Б";
-const Because$1 = "∵";
-const Bernoullis$1 = "ℬ";
-const Beta$1 = "Β";
-const Bfr$1 = "𝔅";
-const Bopf$1 = "𝔹";
-const Breve$1 = "˘";
-const Bscr$1 = "ℬ";
-const Bumpeq$1 = "≎";
-const CHcy$1 = "Ч";
-const COP$1 = "©";
-const COPY$1 = "©";
-const Cacute$1 = "Ć";
-const Cap$1 = "⋒";
-const CapitalDifferentialD$1 = "ⅅ";
-const Cayleys$1 = "ℭ";
-const Ccaron$1 = "Č";
-const Ccedi$1 = "Ç";
-const Ccedil$1 = "Ç";
-const Ccirc$1 = "Ĉ";
-const Cconint$1 = "∰";
-const Cdot$1 = "Ċ";
-const Cedilla$1 = "¸";
-const CenterDot$1 = "·";
-const Cfr$1 = "ℭ";
-const Chi$1 = "Χ";
-const CircleDot$1 = "⊙";
-const CircleMinus$1 = "⊖";
-const CirclePlus$1 = "⊕";
-const CircleTimes$1 = "⊗";
-const ClockwiseContourIntegral$1 = "∲";
-const CloseCurlyDoubleQuote$1 = "”";
-const CloseCurlyQuote$1 = "’";
-const Colon$1 = "∷";
-const Colone$1 = "⩴";
-const Congruent$1 = "≡";
-const Conint$1 = "∯";
-const ContourIntegral$1 = "∮";
-const Copf$1 = "ℂ";
-const Coproduct$1 = "∐";
-const CounterClockwiseContourIntegral$1 = "∳";
-const Cross$1 = "⨯";
-const Cscr$1 = "𝒞";
-const Cup$1 = "⋓";
-const CupCap$1 = "≍";
-const DD$1 = "ⅅ";
-const DDotrahd$1 = "⤑";
-const DJcy$1 = "Ђ";
-const DScy$1 = "Ѕ";
-const DZcy$1 = "Џ";
-const Dagger$1 = "‡";
-const Darr$1 = "↡";
-const Dashv$1 = "⫤";
-const Dcaron$1 = "Ď";
-const Dcy$1 = "Д";
-const Del$1 = "∇";
-const Delta$1 = "Δ";
-const Dfr$1 = "𝔇";
-const DiacriticalAcute$1 = "´";
-const DiacriticalDot$1 = "˙";
-const DiacriticalDoubleAcute$1 = "˝";
-const DiacriticalGrave$1 = "`";
-const DiacriticalTilde$1 = "˜";
-const Diamond$1 = "⋄";
-const DifferentialD$1 = "ⅆ";
-const Dopf$1 = "𝔻";
-const Dot$1 = "¨";
-const DotDot$1 = "⃜";
-const DotEqual$1 = "≐";
-const DoubleContourIntegral$1 = "∯";
-const DoubleDot$1 = "¨";
-const DoubleDownArrow$1 = "⇓";
-const DoubleLeftArrow$1 = "⇐";
-const DoubleLeftRightArrow$1 = "⇔";
-const DoubleLeftTee$1 = "⫤";
-const DoubleLongLeftArrow$1 = "⟸";
-const DoubleLongLeftRightArrow$1 = "⟺";
-const DoubleLongRightArrow$1 = "⟹";
-const DoubleRightArrow$1 = "⇒";
-const DoubleRightTee$1 = "⊨";
-const DoubleUpArrow$1 = "⇑";
-const DoubleUpDownArrow$1 = "⇕";
-const DoubleVerticalBar$1 = "∥";
-const DownArrow$1 = "↓";
-const DownArrowBar$1 = "⤓";
-const DownArrowUpArrow$1 = "⇵";
-const DownBreve$1 = "̑";
-const DownLeftRightVector$1 = "⥐";
-const DownLeftTeeVector$1 = "⥞";
-const DownLeftVector$1 = "↽";
-const DownLeftVectorBar$1 = "⥖";
-const DownRightTeeVector$1 = "⥟";
-const DownRightVector$1 = "⇁";
-const DownRightVectorBar$1 = "⥗";
-const DownTee$1 = "⊤";
-const DownTeeArrow$1 = "↧";
-const Downarrow$1 = "⇓";
-const Dscr$1 = "𝒟";
-const Dstrok$1 = "Đ";
-const ENG$1 = "Ŋ";
-const ET$1 = "Ð";
-const ETH$1 = "Ð";
-const Eacut$1 = "É";
-const Eacute$1 = "É";
-const Ecaron$1 = "Ě";
-const Ecir$1 = "Ê";
-const Ecirc$1 = "Ê";
-const Ecy$1 = "Э";
-const Edot$1 = "Ė";
-const Efr$1 = "𝔈";
-const Egrav$1 = "È";
-const Egrave$1 = "È";
-const Element$1 = "∈";
-const Emacr$1 = "Ē";
-const EmptySmallSquare$1 = "◻";
-const EmptyVerySmallSquare$1 = "▫";
-const Eogon$1 = "Ę";
-const Eopf$1 = "𝔼";
-const Epsilon$1 = "Ε";
-const Equal$1 = "⩵";
-const EqualTilde$1 = "≂";
-const Equilibrium$1 = "⇌";
-const Escr$1 = "ℰ";
-const Esim$1 = "⩳";
-const Eta$1 = "Η";
-const Eum$1 = "Ë";
-const Euml$1 = "Ë";
-const Exists$1 = "∃";
-const ExponentialE$1 = "ⅇ";
-const Fcy$1 = "Ф";
-const Ffr$1 = "𝔉";
-const FilledSmallSquare$1 = "◼";
-const FilledVerySmallSquare$1 = "▪";
-const Fopf$1 = "𝔽";
-const ForAll$1 = "∀";
-const Fouriertrf$1 = "ℱ";
-const Fscr$1 = "ℱ";
-const GJcy$1 = "Ѓ";
-const G$1 = ">";
-const GT$1 = ">";
-const Gamma$1 = "Γ";
-const Gammad$1 = "Ϝ";
-const Gbreve$1 = "Ğ";
-const Gcedil$1 = "Ģ";
-const Gcirc$1 = "Ĝ";
-const Gcy$1 = "Г";
-const Gdot$1 = "Ġ";
-const Gfr$1 = "𝔊";
-const Gg$1 = "⋙";
-const Gopf$1 = "𝔾";
-const GreaterEqual$1 = "≥";
-const GreaterEqualLess$1 = "⋛";
-const GreaterFullEqual$1 = "≧";
-const GreaterGreater$1 = "⪢";
-const GreaterLess$1 = "≷";
-const GreaterSlantEqual$1 = "⩾";
-const GreaterTilde$1 = "≳";
-const Gscr$1 = "𝒢";
-const Gt$1 = "≫";
-const HARDcy$1 = "Ъ";
-const Hacek$1 = "ˇ";
-const Hat$1 = "^";
-const Hcirc$1 = "Ĥ";
-const Hfr$1 = "ℌ";
-const HilbertSpace$1 = "ℋ";
-const Hopf$1 = "ℍ";
-const HorizontalLine$1 = "─";
-const Hscr$1 = "ℋ";
-const Hstrok$1 = "Ħ";
-const HumpDownHump$1 = "≎";
-const HumpEqual$1 = "≏";
-const IEcy$1 = "Е";
-const IJlig$1 = "IJ";
-const IOcy$1 = "Ё";
-const Iacut$1 = "Í";
-const Iacute$1 = "Í";
-const Icir$1 = "Î";
-const Icirc$1 = "Î";
-const Icy$1 = "И";
-const Idot$1 = "İ";
-const Ifr$1 = "ℑ";
-const Igrav$1 = "Ì";
-const Igrave$1 = "Ì";
-const Im$1 = "ℑ";
-const Imacr$1 = "Ī";
-const ImaginaryI$1 = "ⅈ";
-const Implies$1 = "⇒";
-const Int$1 = "∬";
-const Integral$1 = "∫";
-const Intersection$1 = "⋂";
-const InvisibleComma$1 = "⁣";
-const InvisibleTimes$1 = "⁢";
-const Iogon$1 = "Į";
-const Iopf$1 = "𝕀";
-const Iota$1 = "Ι";
-const Iscr$1 = "ℐ";
-const Itilde$1 = "Ĩ";
-const Iukcy$1 = "І";
-const Ium$1 = "Ï";
-const Iuml$1 = "Ï";
-const Jcirc$1 = "Ĵ";
-const Jcy$1 = "Й";
-const Jfr$1 = "𝔍";
-const Jopf$1 = "𝕁";
-const Jscr$1 = "𝒥";
-const Jsercy$1 = "Ј";
-const Jukcy$1 = "Є";
-const KHcy$1 = "Х";
-const KJcy$1 = "Ќ";
-const Kappa$1 = "Κ";
-const Kcedil$1 = "Ķ";
-const Kcy$1 = "К";
-const Kfr$1 = "𝔎";
-const Kopf$1 = "𝕂";
-const Kscr$1 = "𝒦";
-const LJcy$1 = "Љ";
-const L$1 = "<";
-const LT$1 = "<";
-const Lacute$1 = "Ĺ";
-const Lambda$1 = "Λ";
-const Lang$1 = "⟪";
-const Laplacetrf$1 = "ℒ";
-const Larr$1 = "↞";
-const Lcaron$1 = "Ľ";
-const Lcedil$1 = "Ļ";
-const Lcy$1 = "Л";
-const LeftAngleBracket$1 = "⟨";
-const LeftArrow$1 = "←";
-const LeftArrowBar$1 = "⇤";
-const LeftArrowRightArrow$1 = "⇆";
-const LeftCeiling$1 = "⌈";
-const LeftDoubleBracket$1 = "⟦";
-const LeftDownTeeVector$1 = "⥡";
-const LeftDownVector$1 = "⇃";
-const LeftDownVectorBar$1 = "⥙";
-const LeftFloor$1 = "⌊";
-const LeftRightArrow$1 = "↔";
-const LeftRightVector$1 = "⥎";
-const LeftTee$1 = "⊣";
-const LeftTeeArrow$1 = "↤";
-const LeftTeeVector$1 = "⥚";
-const LeftTriangle$1 = "⊲";
-const LeftTriangleBar$1 = "⧏";
-const LeftTriangleEqual$1 = "⊴";
-const LeftUpDownVector$1 = "⥑";
-const LeftUpTeeVector$1 = "⥠";
-const LeftUpVector$1 = "↿";
-const LeftUpVectorBar$1 = "⥘";
-const LeftVector$1 = "↼";
-const LeftVectorBar$1 = "⥒";
-const Leftarrow$1 = "⇐";
-const Leftrightarrow$1 = "⇔";
-const LessEqualGreater$1 = "⋚";
-const LessFullEqual$1 = "≦";
-const LessGreater$1 = "≶";
-const LessLess$1 = "⪡";
-const LessSlantEqual$1 = "⩽";
-const LessTilde$1 = "≲";
-const Lfr$1 = "𝔏";
-const Ll$1 = "⋘";
-const Lleftarrow$1 = "⇚";
-const Lmidot$1 = "Ŀ";
-const LongLeftArrow$1 = "⟵";
-const LongLeftRightArrow$1 = "⟷";
-const LongRightArrow$1 = "⟶";
-const Longleftarrow$1 = "⟸";
-const Longleftrightarrow$1 = "⟺";
-const Longrightarrow$1 = "⟹";
-const Lopf$1 = "𝕃";
-const LowerLeftArrow$1 = "↙";
-const LowerRightArrow$1 = "↘";
-const Lscr$1 = "ℒ";
-const Lsh$1 = "↰";
-const Lstrok$1 = "Ł";
-const Lt$1 = "≪";
-const Mcy$1 = "М";
-const MediumSpace$1 = " ";
-const Mellintrf$1 = "ℳ";
-const Mfr$1 = "𝔐";
-const MinusPlus$1 = "∓";
-const Mopf$1 = "𝕄";
-const Mscr$1 = "ℳ";
-const Mu$1 = "Μ";
-const NJcy$1 = "Њ";
-const Nacute$1 = "Ń";
-const Ncaron$1 = "Ň";
-const Ncedil$1 = "Ņ";
-const Ncy$1 = "Н";
-const NegativeMediumSpace$1 = "​";
-const NegativeThickSpace$1 = "​";
-const NegativeThinSpace$1 = "​";
-const NegativeVeryThinSpace$1 = "​";
-const NestedGreaterGreater$1 = "≫";
-const NestedLessLess$1 = "≪";
-const NewLine$1 = "\n";
-const Nfr$1 = "𝔑";
-const NoBreak$1 = "⁠";
-const NonBreakingSpace$1 = " ";
-const Nopf$1 = "ℕ";
-const Not$1 = "⫬";
-const NotCongruent$1 = "≢";
-const NotCupCap$1 = "≭";
-const NotDoubleVerticalBar$1 = "∦";
-const NotElement$1 = "∉";
-const NotEqual$1 = "≠";
-const NotEqualTilde$1 = "≂̸";
-const NotExists$1 = "∄";
-const NotGreater$1 = "≯";
-const NotGreaterEqual$1 = "≱";
-const NotGreaterFullEqual$1 = "≧̸";
-const NotGreaterGreater$1 = "≫̸";
-const NotGreaterLess$1 = "≹";
-const NotGreaterSlantEqual$1 = "⩾̸";
-const NotGreaterTilde$1 = "≵";
-const NotHumpDownHump$1 = "≎̸";
-const NotHumpEqual$1 = "≏̸";
-const NotLeftTriangle$1 = "⋪";
-const NotLeftTriangleBar$1 = "⧏̸";
-const NotLeftTriangleEqual$1 = "⋬";
-const NotLess$1 = "≮";
-const NotLessEqual$1 = "≰";
-const NotLessGreater$1 = "≸";
-const NotLessLess$1 = "≪̸";
-const NotLessSlantEqual$1 = "⩽̸";
-const NotLessTilde$1 = "≴";
-const NotNestedGreaterGreater$1 = "⪢̸";
-const NotNestedLessLess$1 = "⪡̸";
-const NotPrecedes$1 = "⊀";
-const NotPrecedesEqual$1 = "⪯̸";
-const NotPrecedesSlantEqual$1 = "⋠";
-const NotReverseElement$1 = "∌";
-const NotRightTriangle$1 = "⋫";
-const NotRightTriangleBar$1 = "⧐̸";
-const NotRightTriangleEqual$1 = "⋭";
-const NotSquareSubset$1 = "⊏̸";
-const NotSquareSubsetEqual$1 = "⋢";
-const NotSquareSuperset$1 = "⊐̸";
-const NotSquareSupersetEqual$1 = "⋣";
-const NotSubset$1 = "⊂⃒";
-const NotSubsetEqual$1 = "⊈";
-const NotSucceeds$1 = "⊁";
-const NotSucceedsEqual$1 = "⪰̸";
-const NotSucceedsSlantEqual$1 = "⋡";
-const NotSucceedsTilde$1 = "≿̸";
-const NotSuperset$1 = "⊃⃒";
-const NotSupersetEqual$1 = "⊉";
-const NotTilde$1 = "≁";
-const NotTildeEqual$1 = "≄";
-const NotTildeFullEqual$1 = "≇";
-const NotTildeTilde$1 = "≉";
-const NotVerticalBar$1 = "∤";
-const Nscr$1 = "𝒩";
-const Ntild$1 = "Ñ";
-const Ntilde$1 = "Ñ";
-const Nu$1 = "Ν";
-const OElig$1 = "Œ";
-const Oacut$1 = "Ó";
-const Oacute$1 = "Ó";
-const Ocir$1 = "Ô";
-const Ocirc$1 = "Ô";
-const Ocy$1 = "О";
-const Odblac$1 = "Ő";
-const Ofr$1 = "𝔒";
-const Ograv$1 = "Ò";
-const Ograve$1 = "Ò";
-const Omacr$1 = "Ō";
-const Omega$1 = "Ω";
-const Omicron$1 = "Ο";
-const Oopf$1 = "𝕆";
-const OpenCurlyDoubleQuote$1 = "“";
-const OpenCurlyQuote$1 = "‘";
-const Or$1 = "⩔";
-const Oscr$1 = "𝒪";
-const Oslas$1 = "Ø";
-const Oslash$1 = "Ø";
-const Otild$1 = "Õ";
-const Otilde$1 = "Õ";
-const Otimes$1 = "⨷";
-const Oum$1 = "Ö";
-const Ouml$1 = "Ö";
-const OverBar$1 = "‾";
-const OverBrace$1 = "⏞";
-const OverBracket$1 = "⎴";
-const OverParenthesis$1 = "⏜";
-const PartialD$1 = "∂";
-const Pcy$1 = "П";
-const Pfr$1 = "𝔓";
-const Phi$1 = "Φ";
-const Pi$1 = "Π";
-const PlusMinus$1 = "±";
-const Poincareplane$1 = "ℌ";
-const Popf$1 = "ℙ";
-const Pr$1 = "⪻";
-const Precedes$1 = "≺";
-const PrecedesEqual$1 = "⪯";
-const PrecedesSlantEqual$1 = "≼";
-const PrecedesTilde$1 = "≾";
-const Prime$1 = "″";
-const Product$1 = "∏";
-const Proportion$1 = "∷";
-const Proportional$1 = "∝";
-const Pscr$1 = "𝒫";
-const Psi$1 = "Ψ";
-const QUO$1 = "\"";
-const QUOT$1 = "\"";
-const Qfr$1 = "𝔔";
-const Qopf$1 = "ℚ";
-const Qscr$1 = "𝒬";
-const RBarr$1 = "⤐";
-const RE$1 = "®";
-const REG$1 = "®";
-const Racute$1 = "Ŕ";
-const Rang$1 = "⟫";
-const Rarr$1 = "↠";
-const Rarrtl$1 = "⤖";
-const Rcaron$1 = "Ř";
-const Rcedil$1 = "Ŗ";
-const Rcy$1 = "Р";
-const Re$1 = "ℜ";
-const ReverseElement$1 = "∋";
-const ReverseEquilibrium$1 = "⇋";
-const ReverseUpEquilibrium$1 = "⥯";
-const Rfr$1 = "ℜ";
-const Rho$1 = "Ρ";
-const RightAngleBracket$1 = "⟩";
-const RightArrow$1 = "→";
-const RightArrowBar$1 = "⇥";
-const RightArrowLeftArrow$1 = "⇄";
-const RightCeiling$1 = "⌉";
-const RightDoubleBracket$1 = "⟧";
-const RightDownTeeVector$1 = "⥝";
-const RightDownVector$1 = "⇂";
-const RightDownVectorBar$1 = "⥕";
-const RightFloor$1 = "⌋";
-const RightTee$1 = "⊢";
-const RightTeeArrow$1 = "↦";
-const RightTeeVector$1 = "⥛";
-const RightTriangle$1 = "⊳";
-const RightTriangleBar$1 = "⧐";
-const RightTriangleEqual$1 = "⊵";
-const RightUpDownVector$1 = "⥏";
-const RightUpTeeVector$1 = "⥜";
-const RightUpVector$1 = "↾";
-const RightUpVectorBar$1 = "⥔";
-const RightVector$1 = "⇀";
-const RightVectorBar$1 = "⥓";
-const Rightarrow$1 = "⇒";
-const Ropf$1 = "ℝ";
-const RoundImplies$1 = "⥰";
-const Rrightarrow$1 = "⇛";
-const Rscr$1 = "ℛ";
-const Rsh$1 = "↱";
-const RuleDelayed$1 = "⧴";
-const SHCHcy$1 = "Щ";
-const SHcy$1 = "Ш";
-const SOFTcy$1 = "Ь";
-const Sacute$1 = "Ś";
-const Sc$1 = "⪼";
-const Scaron$1 = "Š";
-const Scedil$1 = "Ş";
-const Scirc$1 = "Ŝ";
-const Scy$1 = "С";
-const Sfr$1 = "𝔖";
-const ShortDownArrow$1 = "↓";
-const ShortLeftArrow$1 = "←";
-const ShortRightArrow$1 = "→";
-const ShortUpArrow$1 = "↑";
-const Sigma$1 = "Σ";
-const SmallCircle$1 = "∘";
-const Sopf$1 = "𝕊";
-const Sqrt$1 = "√";
-const Square$1 = "□";
-const SquareIntersection$1 = "⊓";
-const SquareSubset$1 = "⊏";
-const SquareSubsetEqual$1 = "⊑";
-const SquareSuperset$1 = "⊐";
-const SquareSupersetEqual$1 = "⊒";
-const SquareUnion$1 = "⊔";
-const Sscr$1 = "𝒮";
-const Star$1 = "⋆";
-const Sub$1 = "⋐";
-const Subset$1 = "⋐";
-const SubsetEqual$1 = "⊆";
-const Succeeds$1 = "≻";
-const SucceedsEqual$1 = "⪰";
-const SucceedsSlantEqual$1 = "≽";
-const SucceedsTilde$1 = "≿";
-const SuchThat$1 = "∋";
-const Sum$1 = "∑";
-const Sup$1 = "⋑";
-const Superset$1 = "⊃";
-const SupersetEqual$1 = "⊇";
-const Supset$1 = "⋑";
-const THOR$1 = "Þ";
-const THORN$1 = "Þ";
-const TRADE$1 = "™";
-const TSHcy$1 = "Ћ";
-const TScy$1 = "Ц";
-const Tab$1 = "\t";
-const Tau$1 = "Τ";
-const Tcaron$1 = "Ť";
-const Tcedil$1 = "Ţ";
-const Tcy$1 = "Т";
-const Tfr$1 = "𝔗";
-const Therefore$1 = "∴";
-const Theta$1 = "Θ";
-const ThickSpace$1 = "  ";
-const ThinSpace$1 = " ";
-const Tilde$1 = "∼";
-const TildeEqual$1 = "≃";
-const TildeFullEqual$1 = "≅";
-const TildeTilde$1 = "≈";
-const Topf$1 = "𝕋";
-const TripleDot$1 = "⃛";
-const Tscr$1 = "𝒯";
-const Tstrok$1 = "Ŧ";
-const Uacut$1 = "Ú";
-const Uacute$1 = "Ú";
-const Uarr$1 = "↟";
-const Uarrocir$1 = "⥉";
-const Ubrcy$1 = "Ў";
-const Ubreve$1 = "Ŭ";
-const Ucir$1 = "Û";
-const Ucirc$1 = "Û";
-const Ucy$1 = "У";
-const Udblac$1 = "Ű";
-const Ufr$1 = "𝔘";
-const Ugrav$1 = "Ù";
-const Ugrave$1 = "Ù";
-const Umacr$1 = "Ū";
-const UnderBar$1 = "_";
-const UnderBrace$1 = "⏟";
-const UnderBracket$1 = "⎵";
-const UnderParenthesis$1 = "⏝";
-const Union$1 = "⋃";
-const UnionPlus$1 = "⊎";
-const Uogon$1 = "Ų";
-const Uopf$1 = "𝕌";
-const UpArrow$1 = "↑";
-const UpArrowBar$1 = "⤒";
-const UpArrowDownArrow$1 = "⇅";
-const UpDownArrow$1 = "↕";
-const UpEquilibrium$1 = "⥮";
-const UpTee$1 = "⊥";
-const UpTeeArrow$1 = "↥";
-const Uparrow$1 = "⇑";
-const Updownarrow$1 = "⇕";
-const UpperLeftArrow$1 = "↖";
-const UpperRightArrow$1 = "↗";
-const Upsi$1 = "ϒ";
-const Upsilon$1 = "Υ";
-const Uring$1 = "Ů";
-const Uscr$1 = "𝒰";
-const Utilde$1 = "Ũ";
-const Uum$1 = "Ü";
-const Uuml$1 = "Ü";
-const VDash$1 = "⊫";
-const Vbar$1 = "⫫";
-const Vcy$1 = "В";
-const Vdash$1 = "⊩";
-const Vdashl$1 = "⫦";
-const Vee$1 = "⋁";
-const Verbar$1 = "‖";
-const Vert$1 = "‖";
-const VerticalBar$1 = "∣";
-const VerticalLine$1 = "|";
-const VerticalSeparator$1 = "❘";
-const VerticalTilde$1 = "≀";
-const VeryThinSpace$1 = " ";
-const Vfr$1 = "𝔙";
-const Vopf$1 = "𝕍";
-const Vscr$1 = "𝒱";
-const Vvdash$1 = "⊪";
-const Wcirc$1 = "Ŵ";
-const Wedge$1 = "⋀";
-const Wfr$1 = "𝔚";
-const Wopf$1 = "𝕎";
-const Wscr$1 = "𝒲";
-const Xfr$1 = "𝔛";
-const Xi$1 = "Ξ";
-const Xopf$1 = "𝕏";
-const Xscr$1 = "𝒳";
-const YAcy$1 = "Я";
-const YIcy$1 = "Ї";
-const YUcy$1 = "Ю";
-const Yacut$1 = "Ý";
-const Yacute$1 = "Ý";
-const Ycirc$1 = "Ŷ";
-const Ycy$1 = "Ы";
-const Yfr$1 = "𝔜";
-const Yopf$1 = "𝕐";
-const Yscr$1 = "𝒴";
-const Yuml$1 = "Ÿ";
-const ZHcy$1 = "Ж";
-const Zacute$1 = "Ź";
-const Zcaron$1 = "Ž";
-const Zcy$1 = "З";
-const Zdot$1 = "Ż";
-const ZeroWidthSpace$1 = "​";
-const Zeta$1 = "Ζ";
-const Zfr$1 = "ℨ";
-const Zopf$1 = "ℤ";
-const Zscr$1 = "𝒵";
-const aacut$1 = "á";
-const aacute$1 = "á";
-const abreve$1 = "ă";
-const ac$1 = "∾";
-const acE$1 = "∾̳";
-const acd$1 = "∿";
-const acir$1 = "â";
-const acirc$1 = "â";
-const acut$1 = "´";
-const acute$1 = "´";
-const acy$1 = "а";
-const aeli$1 = "æ";
-const aelig$1 = "æ";
-const af$1 = "⁡";
-const afr$1 = "𝔞";
-const agrav$1 = "à";
-const agrave$1 = "à";
-const alefsym$1 = "ℵ";
-const aleph$1 = "ℵ";
-const alpha$1 = "α";
-const amacr$1 = "ā";
-const amalg$1 = "⨿";
-const am$1 = "&";
-const amp$1 = "&";
-const and$1 = "∧";
-const andand$1 = "⩕";
-const andd$1 = "⩜";
-const andslope$1 = "⩘";
-const andv$1 = "⩚";
-const ang$1 = "∠";
-const ange$1 = "⦤";
-const angle$1 = "∠";
-const angmsd$1 = "∡";
-const angmsdaa$1 = "⦨";
-const angmsdab$1 = "⦩";
-const angmsdac$1 = "⦪";
-const angmsdad$1 = "⦫";
-const angmsdae$1 = "⦬";
-const angmsdaf$1 = "⦭";
-const angmsdag$1 = "⦮";
-const angmsdah$1 = "⦯";
-const angrt$1 = "∟";
-const angrtvb$1 = "⊾";
-const angrtvbd$1 = "⦝";
-const angsph$1 = "∢";
-const angst$1 = "Å";
-const angzarr$1 = "⍼";
-const aogon$1 = "ą";
-const aopf$1 = "𝕒";
-const ap$1 = "≈";
-const apE$1 = "⩰";
-const apacir$1 = "⩯";
-const ape$1 = "≊";
-const apid$1 = "≋";
-const apos$1 = "'";
-const approx$1 = "≈";
-const approxeq$1 = "≊";
-const arin$1 = "å";
-const aring$1 = "å";
-const ascr$1 = "𝒶";
-const ast$1 = "*";
-const asymp$1 = "≈";
-const asympeq$1 = "≍";
-const atild$1 = "ã";
-const atilde$1 = "ã";
-const aum$1 = "ä";
-const auml$1 = "ä";
-const awconint$1 = "∳";
-const awint$1 = "⨑";
-const bNot$1 = "⫭";
-const backcong$1 = "≌";
-const backepsilon$1 = "϶";
-const backprime$1 = "‵";
-const backsim$1 = "∽";
-const backsimeq$1 = "⋍";
-const barvee$1 = "⊽";
-const barwed$1 = "⌅";
-const barwedge$1 = "⌅";
-const bbrk$1 = "⎵";
-const bbrktbrk$1 = "⎶";
-const bcong$1 = "≌";
-const bcy$1 = "б";
-const bdquo$1 = "„";
-const becaus$1 = "∵";
-const because$1 = "∵";
-const bemptyv$1 = "⦰";
-const bepsi$1 = "϶";
-const bernou$1 = "ℬ";
-const beta$1 = "β";
-const beth$1 = "ℶ";
-const between$1 = "≬";
-const bfr$1 = "𝔟";
-const bigcap$1 = "⋂";
-const bigcirc$1 = "◯";
-const bigcup$1 = "⋃";
-const bigodot$1 = "⨀";
-const bigoplus$1 = "⨁";
-const bigotimes$1 = "⨂";
-const bigsqcup$1 = "⨆";
-const bigstar$1 = "★";
-const bigtriangledown$1 = "▽";
-const bigtriangleup$1 = "△";
-const biguplus$1 = "⨄";
-const bigvee$1 = "⋁";
-const bigwedge$1 = "⋀";
-const bkarow$1 = "⤍";
-const blacklozenge$1 = "⧫";
-const blacksquare$1 = "▪";
-const blacktriangle$1 = "▴";
-const blacktriangledown$1 = "▾";
-const blacktriangleleft$1 = "◂";
-const blacktriangleright$1 = "▸";
-const blank$1 = "␣";
-const blk12$1 = "▒";
-const blk14$1 = "░";
-const blk34$1 = "▓";
-const block$1 = "█";
-const bne$1 = "=⃥";
-const bnequiv$1 = "≡⃥";
-const bnot$1 = "⌐";
-const bopf$1 = "𝕓";
-const bot$1 = "⊥";
-const bottom$1 = "⊥";
-const bowtie$1 = "⋈";
-const boxDL$1 = "╗";
-const boxDR$1 = "╔";
-const boxDl$1 = "╖";
-const boxDr$1 = "╓";
-const boxH$1 = "═";
-const boxHD$1 = "╦";
-const boxHU$1 = "╩";
-const boxHd$1 = "╤";
-const boxHu$1 = "╧";
-const boxUL$1 = "╝";
-const boxUR$1 = "╚";
-const boxUl$1 = "╜";
-const boxUr$1 = "╙";
-const boxV$1 = "║";
-const boxVH$1 = "╬";
-const boxVL$1 = "╣";
-const boxVR$1 = "╠";
-const boxVh$1 = "╫";
-const boxVl$1 = "╢";
-const boxVr$1 = "╟";
-const boxbox$1 = "⧉";
-const boxdL$1 = "╕";
-const boxdR$1 = "╒";
-const boxdl$1 = "┐";
-const boxdr$1 = "┌";
-const boxh$1 = "─";
-const boxhD$1 = "╥";
-const boxhU$1 = "╨";
-const boxhd$1 = "┬";
-const boxhu$1 = "┴";
-const boxminus$1 = "⊟";
-const boxplus$1 = "⊞";
-const boxtimes$1 = "⊠";
-const boxuL$1 = "╛";
-const boxuR$1 = "╘";
-const boxul$1 = "┘";
-const boxur$1 = "└";
-const boxv$1 = "│";
-const boxvH$1 = "╪";
-const boxvL$1 = "╡";
-const boxvR$1 = "╞";
-const boxvh$1 = "┼";
-const boxvl$1 = "┤";
-const boxvr$1 = "├";
-const bprime$1 = "‵";
-const breve$1 = "˘";
-const brvba$1 = "¦";
-const brvbar$1 = "¦";
-const bscr$1 = "𝒷";
-const bsemi$1 = "⁏";
-const bsim$1 = "∽";
-const bsime$1 = "⋍";
-const bsol$1 = "\\";
-const bsolb$1 = "⧅";
-const bsolhsub$1 = "⟈";
-const bull$1 = "•";
-const bullet$1 = "•";
-const bump$1 = "≎";
-const bumpE$1 = "⪮";
-const bumpe$1 = "≏";
-const bumpeq$1 = "≏";
-const cacute$1 = "ć";
-const cap$1 = "∩";
-const capand$1 = "⩄";
-const capbrcup$1 = "⩉";
-const capcap$1 = "⩋";
-const capcup$1 = "⩇";
-const capdot$1 = "⩀";
-const caps$1 = "∩︀";
-const caret$1 = "⁁";
-const caron$1 = "ˇ";
-const ccaps$1 = "⩍";
-const ccaron$1 = "č";
-const ccedi$1 = "ç";
-const ccedil$1 = "ç";
-const ccirc$1 = "ĉ";
-const ccups$1 = "⩌";
-const ccupssm$1 = "⩐";
-const cdot$1 = "ċ";
-const cedi$1 = "¸";
-const cedil$1 = "¸";
-const cemptyv$1 = "⦲";
-const cen$1 = "¢";
-const cent$1 = "¢";
-const centerdot$1 = "·";
-const cfr$1 = "𝔠";
-const chcy$1 = "ч";
-const check$2 = "✓";
-const checkmark$1 = "✓";
-const chi$1 = "χ";
-const cir$1 = "○";
-const cirE$1 = "⧃";
-const circ$1 = "ˆ";
-const circeq$1 = "≗";
-const circlearrowleft$1 = "↺";
-const circlearrowright$1 = "↻";
-const circledR$1 = "®";
-const circledS$1 = "Ⓢ";
-const circledast$1 = "⊛";
-const circledcirc$1 = "⊚";
-const circleddash$1 = "⊝";
-const cire$1 = "≗";
-const cirfnint$1 = "⨐";
-const cirmid$1 = "⫯";
-const cirscir$1 = "⧂";
-const clubs$1 = "♣";
-const clubsuit$1 = "♣";
-const colon$1 = ":";
-const colone$1 = "≔";
-const coloneq$1 = "≔";
-const comma$1 = ",";
-const commat$1 = "@";
-const comp$1 = "∁";
-const compfn$1 = "∘";
-const complement$1 = "∁";
-const complexes$1 = "ℂ";
-const cong$1 = "≅";
-const congdot$1 = "⩭";
-const conint$1 = "∮";
-const copf$1 = "𝕔";
-const coprod$1 = "∐";
-const cop$1 = "©";
-const copy$1 = "©";
-const copysr$1 = "℗";
-const crarr$1 = "↵";
-const cross$1 = "✗";
-const cscr$1 = "𝒸";
-const csub$1 = "⫏";
-const csube$1 = "⫑";
-const csup$1 = "⫐";
-const csupe$1 = "⫒";
-const ctdot$1 = "⋯";
-const cudarrl$1 = "⤸";
-const cudarrr$1 = "⤵";
-const cuepr$1 = "⋞";
-const cuesc$1 = "⋟";
-const cularr$1 = "↶";
-const cularrp$1 = "⤽";
-const cup$1 = "∪";
-const cupbrcap$1 = "⩈";
-const cupcap$1 = "⩆";
-const cupcup$1 = "⩊";
-const cupdot$1 = "⊍";
-const cupor$1 = "⩅";
-const cups$1 = "∪︀";
-const curarr$1 = "↷";
-const curarrm$1 = "⤼";
-const curlyeqprec$1 = "⋞";
-const curlyeqsucc$1 = "⋟";
-const curlyvee$1 = "⋎";
-const curlywedge$1 = "⋏";
-const curre$1 = "¤";
-const curren$1 = "¤";
-const curvearrowleft$1 = "↶";
-const curvearrowright$1 = "↷";
-const cuvee$1 = "⋎";
-const cuwed$1 = "⋏";
-const cwconint$1 = "∲";
-const cwint$1 = "∱";
-const cylcty$1 = "⌭";
-const dArr$1 = "⇓";
-const dHar$1 = "⥥";
-const dagger$1 = "†";
-const daleth$1 = "ℸ";
-const darr$1 = "↓";
-const dash$1 = "‐";
-const dashv$1 = "⊣";
-const dbkarow$1 = "⤏";
-const dblac$1 = "˝";
-const dcaron$1 = "ď";
-const dcy$1 = "д";
-const dd$1 = "ⅆ";
-const ddagger$1 = "‡";
-const ddarr$1 = "⇊";
-const ddotseq$1 = "⩷";
-const de$1 = "°";
-const deg$1 = "°";
-const delta$1 = "δ";
-const demptyv$1 = "⦱";
-const dfisht$1 = "⥿";
-const dfr$1 = "𝔡";
-const dharl$1 = "⇃";
-const dharr$1 = "⇂";
-const diam$1 = "⋄";
-const diamond$1 = "⋄";
-const diamondsuit$1 = "♦";
-const diams$1 = "♦";
-const die$1 = "¨";
-const digamma$1 = "ϝ";
-const disin$1 = "⋲";
-const div$1 = "÷";
-const divid$1 = "÷";
-const divide$1 = "÷";
-const divideontimes$1 = "⋇";
-const divonx$1 = "⋇";
-const djcy$1 = "ђ";
-const dlcorn$1 = "⌞";
-const dlcrop$1 = "⌍";
-const dollar$1 = "$";
-const dopf$1 = "𝕕";
-const dot$1 = "˙";
-const doteq$1 = "≐";
-const doteqdot$1 = "≑";
-const dotminus$1 = "∸";
-const dotplus$1 = "∔";
-const dotsquare$1 = "⊡";
-const doublebarwedge$1 = "⌆";
-const downarrow$1 = "↓";
-const downdownarrows$1 = "⇊";
-const downharpoonleft$1 = "⇃";
-const downharpoonright$1 = "⇂";
-const drbkarow$1 = "⤐";
-const drcorn$1 = "⌟";
-const drcrop$1 = "⌌";
-const dscr$1 = "𝒹";
-const dscy$1 = "ѕ";
-const dsol$1 = "⧶";
-const dstrok$1 = "đ";
-const dtdot$1 = "⋱";
-const dtri$1 = "▿";
-const dtrif$1 = "▾";
-const duarr$1 = "⇵";
-const duhar$1 = "⥯";
-const dwangle$1 = "⦦";
-const dzcy$1 = "џ";
-const dzigrarr$1 = "⟿";
-const eDDot$1 = "⩷";
-const eDot$1 = "≑";
-const eacut$1 = "é";
-const eacute$1 = "é";
-const easter$1 = "⩮";
-const ecaron$1 = "ě";
-const ecir$1 = "ê";
-const ecirc$1 = "ê";
-const ecolon$1 = "≕";
-const ecy$1 = "э";
-const edot$1 = "ė";
-const ee$1 = "ⅇ";
-const efDot$1 = "≒";
-const efr$1 = "𝔢";
-const eg$1 = "⪚";
-const egrav$1 = "è";
-const egrave$1 = "è";
-const egs$1 = "⪖";
-const egsdot$1 = "⪘";
-const el$1 = "⪙";
-const elinters$1 = "⏧";
-const ell$1 = "ℓ";
-const els$1 = "⪕";
-const elsdot$1 = "⪗";
-const emacr$1 = "ē";
-const empty$1 = "∅";
-const emptyset$1 = "∅";
-const emptyv$1 = "∅";
-const emsp13$1 = " ";
-const emsp14$1 = " ";
-const emsp$1 = " ";
-const eng$1 = "ŋ";
-const ensp$1 = " ";
-const eogon$1 = "ę";
-const eopf$1 = "𝕖";
-const epar$1 = "⋕";
-const eparsl$1 = "⧣";
-const eplus$1 = "⩱";
-const epsi$1 = "ε";
-const epsilon$1 = "ε";
-const epsiv$1 = "ϵ";
-const eqcirc$1 = "≖";
-const eqcolon$1 = "≕";
-const eqsim$1 = "≂";
-const eqslantgtr$1 = "⪖";
-const eqslantless$1 = "⪕";
-const equals$1 = "=";
-const equest$1 = "≟";
-const equiv$1 = "≡";
-const equivDD$1 = "⩸";
-const eqvparsl$1 = "⧥";
-const erDot$1 = "≓";
-const erarr$1 = "⥱";
-const escr$1 = "ℯ";
-const esdot$1 = "≐";
-const esim$1 = "≂";
-const eta$1 = "η";
-const et$1 = "ð";
-const eth$1 = "ð";
-const eum$1 = "ë";
-const euml$1 = "ë";
-const euro$1 = "€";
-const excl$1 = "!";
-const exist$1 = "∃";
-const expectation$1 = "ℰ";
-const exponentiale$1 = "ⅇ";
-const fallingdotseq$1 = "≒";
-const fcy$1 = "ф";
-const female$1 = "♀";
-const ffilig$1 = "ffi";
-const fflig$1 = "ff";
-const ffllig$1 = "ffl";
-const ffr$1 = "𝔣";
-const filig$1 = "fi";
-const fjlig$1 = "fj";
-const flat$1 = "♭";
-const fllig$1 = "fl";
-const fltns$1 = "▱";
-const fnof$1 = "ƒ";
-const fopf$1 = "𝕗";
-const forall$1 = "∀";
-const fork$1 = "⋔";
-const forkv$1 = "⫙";
-const fpartint$1 = "⨍";
-const frac1$1 = "¼";
-const frac12$1 = "½";
-const frac13$1 = "⅓";
-const frac14$1 = "¼";
-const frac15$1 = "⅕";
-const frac16$1 = "⅙";
-const frac18$1 = "⅛";
-const frac23$1 = "⅔";
-const frac25$1 = "⅖";
-const frac3$1 = "¾";
-const frac34$1 = "¾";
-const frac35$1 = "⅗";
-const frac38$1 = "⅜";
-const frac45$1 = "⅘";
-const frac56$1 = "⅚";
-const frac58$1 = "⅝";
-const frac78$1 = "⅞";
-const frasl$1 = "⁄";
-const frown$1 = "⌢";
-const fscr$1 = "𝒻";
-const gE$1 = "≧";
-const gEl$1 = "⪌";
-const gacute$1 = "ǵ";
-const gamma$1 = "γ";
-const gammad$1 = "ϝ";
-const gap$1 = "⪆";
-const gbreve$1 = "ğ";
-const gcirc$1 = "ĝ";
-const gcy$1 = "г";
-const gdot$1 = "ġ";
-const ge$1 = "≥";
-const gel$1 = "⋛";
-const geq$1 = "≥";
-const geqq$1 = "≧";
-const geqslant$1 = "⩾";
-const ges$1 = "⩾";
-const gescc$1 = "⪩";
-const gesdot$1 = "⪀";
-const gesdoto$1 = "⪂";
-const gesdotol$1 = "⪄";
-const gesl$1 = "⋛︀";
-const gesles$1 = "⪔";
-const gfr$1 = "𝔤";
-const gg$1 = "≫";
-const ggg$1 = "⋙";
-const gimel$1 = "ℷ";
-const gjcy$1 = "ѓ";
-const gl$1 = "≷";
-const glE$1 = "⪒";
-const gla$1 = "⪥";
-const glj$1 = "⪤";
-const gnE$1 = "≩";
-const gnap$1 = "⪊";
-const gnapprox$1 = "⪊";
-const gne$1 = "⪈";
-const gneq$1 = "⪈";
-const gneqq$1 = "≩";
-const gnsim$1 = "⋧";
-const gopf$1 = "𝕘";
-const grave$1 = "`";
-const gscr$1 = "ℊ";
-const gsim$1 = "≳";
-const gsime$1 = "⪎";
-const gsiml$1 = "⪐";
-const g$1 = ">";
-const gt$1 = ">";
-const gtcc$1 = "⪧";
-const gtcir$1 = "⩺";
-const gtdot$1 = "⋗";
-const gtlPar$1 = "⦕";
-const gtquest$1 = "⩼";
-const gtrapprox$1 = "⪆";
-const gtrarr$1 = "⥸";
-const gtrdot$1 = "⋗";
-const gtreqless$1 = "⋛";
-const gtreqqless$1 = "⪌";
-const gtrless$1 = "≷";
-const gtrsim$1 = "≳";
-const gvertneqq$1 = "≩︀";
-const gvnE$1 = "≩︀";
-const hArr$1 = "⇔";
-const hairsp$1 = " ";
-const half$1 = "½";
-const hamilt$1 = "ℋ";
-const hardcy$1 = "ъ";
-const harr$1 = "↔";
-const harrcir$1 = "⥈";
-const harrw$1 = "↭";
-const hbar$1 = "ℏ";
-const hcirc$1 = "ĥ";
-const hearts$1 = "♥";
-const heartsuit$1 = "♥";
-const hellip$1 = "…";
-const hercon$1 = "⊹";
-const hfr$1 = "𝔥";
-const hksearow$1 = "⤥";
-const hkswarow$1 = "⤦";
-const hoarr$1 = "⇿";
-const homtht$1 = "∻";
-const hookleftarrow$1 = "↩";
-const hookrightarrow$1 = "↪";
-const hopf$1 = "𝕙";
-const horbar$1 = "―";
-const hscr$1 = "𝒽";
-const hslash$1 = "ℏ";
-const hstrok$1 = "ħ";
-const hybull$1 = "⁃";
-const hyphen$1 = "‐";
-const iacut$1 = "í";
-const iacute$1 = "í";
-const ic$1 = "⁣";
-const icir$1 = "î";
-const icirc$1 = "î";
-const icy$1 = "и";
-const iecy$1 = "е";
-const iexc$1 = "¡";
-const iexcl$1 = "¡";
-const iff$1 = "⇔";
-const ifr$1 = "𝔦";
-const igrav$1 = "ì";
-const igrave$1 = "ì";
-const ii$1 = "ⅈ";
-const iiiint$1 = "⨌";
-const iiint$1 = "∭";
-const iinfin$1 = "⧜";
-const iiota$1 = "℩";
-const ijlig$1 = "ij";
-const imacr$1 = "ī";
-const image$2 = "ℑ";
-const imagline$1 = "ℐ";
-const imagpart$1 = "ℑ";
-const imath$1 = "ı";
-const imof$1 = "⊷";
-const imped$1 = "Ƶ";
-const incare$1 = "℅";
-const infin$1 = "∞";
-const infintie$1 = "⧝";
-const inodot$1 = "ı";
-const int$2 = "∫";
-const intcal$1 = "⊺";
-const integers$1 = "ℤ";
-const intercal$1 = "⊺";
-const intlarhk$1 = "⨗";
-const intprod$1 = "⨼";
-const iocy$1 = "ё";
-const iogon$1 = "į";
-const iopf$1 = "𝕚";
-const iota$1 = "ι";
-const iprod$1 = "⨼";
-const iques$1 = "¿";
-const iquest$1 = "¿";
-const iscr$1 = "𝒾";
-const isin$1 = "∈";
-const isinE$1 = "⋹";
-const isindot$1 = "⋵";
-const isins$1 = "⋴";
-const isinsv$1 = "⋳";
-const isinv$1 = "∈";
-const it$1 = "⁢";
-const itilde$1 = "ĩ";
-const iukcy$1 = "і";
-const ium$1 = "ï";
-const iuml$1 = "ï";
-const jcirc$1 = "ĵ";
-const jcy$1 = "й";
-const jfr$1 = "𝔧";
-const jmath$1 = "ȷ";
-const jopf$1 = "𝕛";
-const jscr$1 = "𝒿";
-const jsercy$1 = "ј";
-const jukcy$1 = "є";
-const kappa$1 = "κ";
-const kappav$1 = "ϰ";
-const kcedil$1 = "ķ";
-const kcy$1 = "к";
-const kfr$1 = "𝔨";
-const kgreen$1 = "ĸ";
-const khcy$1 = "х";
-const kjcy$1 = "ќ";
-const kopf$1 = "𝕜";
-const kscr$1 = "𝓀";
-const lAarr$1 = "⇚";
-const lArr$1 = "⇐";
-const lAtail$1 = "⤛";
-const lBarr$1 = "⤎";
-const lE$1 = "≦";
-const lEg$1 = "⪋";
-const lHar$1 = "⥢";
-const lacute$1 = "ĺ";
-const laemptyv$1 = "⦴";
-const lagran$1 = "ℒ";
-const lambda$1 = "λ";
-const lang$1 = "⟨";
-const langd$1 = "⦑";
-const langle$1 = "⟨";
-const lap$1 = "⪅";
-const laqu$1 = "«";
-const laquo$1 = "«";
-const larr$1 = "←";
-const larrb$1 = "⇤";
-const larrbfs$1 = "⤟";
-const larrfs$1 = "⤝";
-const larrhk$1 = "↩";
-const larrlp$1 = "↫";
-const larrpl$1 = "⤹";
-const larrsim$1 = "⥳";
-const larrtl$1 = "↢";
-const lat$1 = "⪫";
-const latail$1 = "⤙";
-const late$1 = "⪭";
-const lates$1 = "⪭︀";
-const lbarr$1 = "⤌";
-const lbbrk$1 = "❲";
-const lbrace$1 = "{";
-const lbrack$1 = "[";
-const lbrke$1 = "⦋";
-const lbrksld$1 = "⦏";
-const lbrkslu$1 = "⦍";
-const lcaron$1 = "ľ";
-const lcedil$1 = "ļ";
-const lceil$1 = "⌈";
-const lcub$1 = "{";
-const lcy$1 = "л";
-const ldca$1 = "⤶";
-const ldquo$1 = "“";
-const ldquor$1 = "„";
-const ldrdhar$1 = "⥧";
-const ldrushar$1 = "⥋";
-const ldsh$1 = "↲";
-const le$1 = "≤";
-const leftarrow$1 = "←";
-const leftarrowtail$1 = "↢";
-const leftharpoondown$1 = "↽";
-const leftharpoonup$1 = "↼";
-const leftleftarrows$1 = "⇇";
-const leftrightarrow$1 = "↔";
-const leftrightarrows$1 = "⇆";
-const leftrightharpoons$1 = "⇋";
-const leftrightsquigarrow$1 = "↭";
-const leftthreetimes$1 = "⋋";
-const leg$1 = "⋚";
-const leq$1 = "≤";
-const leqq$1 = "≦";
-const leqslant$1 = "⩽";
-const les$1 = "⩽";
-const lescc$1 = "⪨";
-const lesdot$1 = "⩿";
-const lesdoto$1 = "⪁";
-const lesdotor$1 = "⪃";
-const lesg$1 = "⋚︀";
-const lesges$1 = "⪓";
-const lessapprox$1 = "⪅";
-const lessdot$1 = "⋖";
-const lesseqgtr$1 = "⋚";
-const lesseqqgtr$1 = "⪋";
-const lessgtr$1 = "≶";
-const lesssim$1 = "≲";
-const lfisht$1 = "⥼";
-const lfloor$1 = "⌊";
-const lfr$1 = "𝔩";
-const lg$1 = "≶";
-const lgE$1 = "⪑";
-const lhard$1 = "↽";
-const lharu$1 = "↼";
-const lharul$1 = "⥪";
-const lhblk$1 = "▄";
-const ljcy$1 = "љ";
-const ll$1 = "≪";
-const llarr$1 = "⇇";
-const llcorner$1 = "⌞";
-const llhard$1 = "⥫";
-const lltri$1 = "◺";
-const lmidot$1 = "ŀ";
-const lmoust$1 = "⎰";
-const lmoustache$1 = "⎰";
-const lnE$1 = "≨";
-const lnap$1 = "⪉";
-const lnapprox$1 = "⪉";
-const lne$1 = "⪇";
-const lneq$1 = "⪇";
-const lneqq$1 = "≨";
-const lnsim$1 = "⋦";
-const loang$1 = "⟬";
-const loarr$1 = "⇽";
-const lobrk$1 = "⟦";
-const longleftarrow$1 = "⟵";
-const longleftrightarrow$1 = "⟷";
-const longmapsto$1 = "⟼";
-const longrightarrow$1 = "⟶";
-const looparrowleft$1 = "↫";
-const looparrowright$1 = "↬";
-const lopar$1 = "⦅";
-const lopf$1 = "𝕝";
-const loplus$1 = "⨭";
-const lotimes$1 = "⨴";
-const lowast$1 = "∗";
-const lowbar$1 = "_";
-const loz$1 = "◊";
-const lozenge$1 = "◊";
-const lozf$1 = "⧫";
-const lpar$1 = "(";
-const lparlt$1 = "⦓";
-const lrarr$1 = "⇆";
-const lrcorner$1 = "⌟";
-const lrhar$1 = "⇋";
-const lrhard$1 = "⥭";
-const lrm$1 = "‎";
-const lrtri$1 = "⊿";
-const lsaquo$1 = "‹";
-const lscr$1 = "𝓁";
-const lsh$1 = "↰";
-const lsim$1 = "≲";
-const lsime$1 = "⪍";
-const lsimg$1 = "⪏";
-const lsqb$1 = "[";
-const lsquo$1 = "‘";
-const lsquor$1 = "‚";
-const lstrok$1 = "ł";
-const l$1 = "<";
-const lt$2 = "<";
-const ltcc$1 = "⪦";
-const ltcir$1 = "⩹";
-const ltdot$1 = "⋖";
-const lthree$1 = "⋋";
-const ltimes$1 = "⋉";
-const ltlarr$1 = "⥶";
-const ltquest$1 = "⩻";
-const ltrPar$1 = "⦖";
-const ltri$1 = "◃";
-const ltrie$1 = "⊴";
-const ltrif$1 = "◂";
-const lurdshar$1 = "⥊";
-const luruhar$1 = "⥦";
-const lvertneqq$1 = "≨︀";
-const lvnE$1 = "≨︀";
-const mDDot$1 = "∺";
-const mac$1 = "¯";
-const macr$1 = "¯";
-const male$1 = "♂";
-const malt$1 = "✠";
-const maltese$1 = "✠";
-const map$4 = "↦";
-const mapsto$1 = "↦";
-const mapstodown$1 = "↧";
-const mapstoleft$1 = "↤";
-const mapstoup$1 = "↥";
-const marker$1 = "▮";
-const mcomma$1 = "⨩";
-const mcy$1 = "м";
-const mdash$1 = "—";
-const measuredangle$1 = "∡";
-const mfr$1 = "𝔪";
-const mho$1 = "℧";
-const micr$1 = "µ";
-const micro$1 = "µ";
-const mid$1 = "∣";
-const midast$1 = "*";
-const midcir$1 = "⫰";
-const middo$1 = "·";
-const middot$1 = "·";
-const minus$1 = "−";
-const minusb$1 = "⊟";
-const minusd$1 = "∸";
-const minusdu$1 = "⨪";
-const mlcp$1 = "⫛";
-const mldr$1 = "…";
-const mnplus$1 = "∓";
-const models$1 = "⊧";
-const mopf$1 = "𝕞";
-const mp$1 = "∓";
-const mscr$1 = "𝓂";
-const mstpos$1 = "∾";
-const mu$1 = "μ";
-const multimap$1 = "⊸";
-const mumap$1 = "⊸";
-const nGg$1 = "⋙̸";
-const nGt$1 = "≫⃒";
-const nGtv$1 = "≫̸";
-const nLeftarrow$1 = "⇍";
-const nLeftrightarrow$1 = "⇎";
-const nLl$1 = "⋘̸";
-const nLt$1 = "≪⃒";
-const nLtv$1 = "≪̸";
-const nRightarrow$1 = "⇏";
-const nVDash$1 = "⊯";
-const nVdash$1 = "⊮";
-const nabla$1 = "∇";
-const nacute$1 = "ń";
-const nang$1 = "∠⃒";
-const nap$1 = "≉";
-const napE$1 = "⩰̸";
-const napid$1 = "≋̸";
-const napos$1 = "ʼn";
-const napprox$1 = "≉";
-const natur$1 = "♮";
-const natural$1 = "♮";
-const naturals$1 = "ℕ";
-const nbs$1 = " ";
-const nbsp$1 = " ";
-const nbump$1 = "≎̸";
-const nbumpe$1 = "≏̸";
-const ncap$1 = "⩃";
-const ncaron$1 = "ň";
-const ncedil$1 = "ņ";
-const ncong$1 = "≇";
-const ncongdot$1 = "⩭̸";
-const ncup$1 = "⩂";
-const ncy$1 = "н";
-const ndash$1 = "–";
-const ne$1 = "≠";
-const neArr$1 = "⇗";
-const nearhk$1 = "⤤";
-const nearr$1 = "↗";
-const nearrow$1 = "↗";
-const nedot$1 = "≐̸";
-const nequiv$1 = "≢";
-const nesear$1 = "⤨";
-const nesim$1 = "≂̸";
-const nexist$1 = "∄";
-const nexists$1 = "∄";
-const nfr$1 = "𝔫";
-const ngE$1 = "≧̸";
-const nge$1 = "≱";
-const ngeq$1 = "≱";
-const ngeqq$1 = "≧̸";
-const ngeqslant$1 = "⩾̸";
-const nges$1 = "⩾̸";
-const ngsim$1 = "≵";
-const ngt$1 = "≯";
-const ngtr$1 = "≯";
-const nhArr$1 = "⇎";
-const nharr$1 = "↮";
-const nhpar$1 = "⫲";
-const ni$1 = "∋";
-const nis$1 = "⋼";
-const nisd$1 = "⋺";
-const niv$1 = "∋";
-const njcy$1 = "њ";
-const nlArr$1 = "⇍";
-const nlE$1 = "≦̸";
-const nlarr$1 = "↚";
-const nldr$1 = "‥";
-const nle$1 = "≰";
-const nleftarrow$1 = "↚";
-const nleftrightarrow$1 = "↮";
-const nleq$1 = "≰";
-const nleqq$1 = "≦̸";
-const nleqslant$1 = "⩽̸";
-const nles$1 = "⩽̸";
-const nless$1 = "≮";
-const nlsim$1 = "≴";
-const nlt$1 = "≮";
-const nltri$1 = "⋪";
-const nltrie$1 = "⋬";
-const nmid$1 = "∤";
-const nopf$1 = "𝕟";
-const no$1 = "¬";
-const not$1 = "¬";
-const notin$1 = "∉";
-const notinE$1 = "⋹̸";
-const notindot$1 = "⋵̸";
-const notinva$1 = "∉";
-const notinvb$1 = "⋷";
-const notinvc$1 = "⋶";
-const notni$1 = "∌";
-const notniva$1 = "∌";
-const notnivb$1 = "⋾";
-const notnivc$1 = "⋽";
-const npar$1 = "∦";
-const nparallel$1 = "∦";
-const nparsl$1 = "⫽⃥";
-const npart$1 = "∂̸";
-const npolint$1 = "⨔";
-const npr$1 = "⊀";
-const nprcue$1 = "⋠";
-const npre$1 = "⪯̸";
-const nprec$1 = "⊀";
-const npreceq$1 = "⪯̸";
-const nrArr$1 = "⇏";
-const nrarr$1 = "↛";
-const nrarrc$1 = "⤳̸";
-const nrarrw$1 = "↝̸";
-const nrightarrow$1 = "↛";
-const nrtri$1 = "⋫";
-const nrtrie$1 = "⋭";
-const nsc$1 = "⊁";
-const nsccue$1 = "⋡";
-const nsce$1 = "⪰̸";
-const nscr$1 = "𝓃";
-const nshortmid$1 = "∤";
-const nshortparallel$1 = "∦";
-const nsim$1 = "≁";
-const nsime$1 = "≄";
-const nsimeq$1 = "≄";
-const nsmid$1 = "∤";
-const nspar$1 = "∦";
-const nsqsube$1 = "⋢";
-const nsqsupe$1 = "⋣";
-const nsub$1 = "⊄";
-const nsubE$1 = "⫅̸";
-const nsube$1 = "⊈";
-const nsubset$1 = "⊂⃒";
-const nsubseteq$1 = "⊈";
-const nsubseteqq$1 = "⫅̸";
-const nsucc$1 = "⊁";
-const nsucceq$1 = "⪰̸";
-const nsup$1 = "⊅";
-const nsupE$1 = "⫆̸";
-const nsupe$1 = "⊉";
-const nsupset$1 = "⊃⃒";
-const nsupseteq$1 = "⊉";
-const nsupseteqq$1 = "⫆̸";
-const ntgl$1 = "≹";
-const ntild$1 = "ñ";
-const ntilde$1 = "ñ";
-const ntlg$1 = "≸";
-const ntriangleleft$1 = "⋪";
-const ntrianglelefteq$1 = "⋬";
-const ntriangleright$1 = "⋫";
-const ntrianglerighteq$1 = "⋭";
-const nu$1 = "ν";
-const num$1 = "#";
-const numero$1 = "№";
-const numsp$1 = " ";
-const nvDash$1 = "⊭";
-const nvHarr$1 = "⤄";
-const nvap$1 = "≍⃒";
-const nvdash$1 = "⊬";
-const nvge$1 = "≥⃒";
-const nvgt$1 = ">⃒";
-const nvinfin$1 = "⧞";
-const nvlArr$1 = "⤂";
-const nvle$1 = "≤⃒";
-const nvlt$1 = "<⃒";
-const nvltrie$1 = "⊴⃒";
-const nvrArr$1 = "⤃";
-const nvrtrie$1 = "⊵⃒";
-const nvsim$1 = "∼⃒";
-const nwArr$1 = "⇖";
-const nwarhk$1 = "⤣";
-const nwarr$1 = "↖";
-const nwarrow$1 = "↖";
-const nwnear$1 = "⤧";
-const oS$1 = "Ⓢ";
-const oacut$1 = "ó";
-const oacute$1 = "ó";
-const oast$1 = "⊛";
-const ocir$1 = "ô";
-const ocirc$1 = "ô";
-const ocy$1 = "о";
-const odash$1 = "⊝";
-const odblac$1 = "ő";
-const odiv$1 = "⨸";
-const odot$1 = "⊙";
-const odsold$1 = "⦼";
-const oelig$1 = "œ";
-const ofcir$1 = "⦿";
-const ofr$1 = "𝔬";
-const ogon$1 = "˛";
-const ograv$1 = "ò";
-const ograve$1 = "ò";
-const ogt$1 = "⧁";
-const ohbar$1 = "⦵";
-const ohm$1 = "Ω";
-const oint$1 = "∮";
-const olarr$1 = "↺";
-const olcir$1 = "⦾";
-const olcross$1 = "⦻";
-const oline$1 = "‾";
-const olt$1 = "⧀";
-const omacr$1 = "ō";
-const omega$1 = "ω";
-const omicron$1 = "ο";
-const omid$1 = "⦶";
-const ominus$1 = "⊖";
-const oopf$1 = "𝕠";
-const opar$1 = "⦷";
-const operp$1 = "⦹";
-const oplus$1 = "⊕";
-const or$1 = "∨";
-const orarr$1 = "↻";
-const ord$1 = "º";
-const order$1 = "ℴ";
-const orderof$1 = "ℴ";
-const ordf$1 = "ª";
-const ordm$1 = "º";
-const origof$1 = "⊶";
-const oror$1 = "⩖";
-const orslope$1 = "⩗";
-const orv$1 = "⩛";
-const oscr$1 = "ℴ";
-const oslas$1 = "ø";
-const oslash$1 = "ø";
-const osol$1 = "⊘";
-const otild$1 = "õ";
-const otilde$1 = "õ";
-const otimes$1 = "⊗";
-const otimesas$1 = "⨶";
-const oum$1 = "ö";
-const ouml$1 = "ö";
-const ovbar$1 = "⌽";
-const par$1 = "¶";
-const para$1 = "¶";
-const parallel$1 = "∥";
-const parsim$1 = "⫳";
-const parsl$1 = "⫽";
-const part$1 = "∂";
-const pcy$1 = "п";
-const percnt$1 = "%";
-const period$1 = ".";
-const permil$1 = "‰";
-const perp$1 = "⊥";
-const pertenk$1 = "‱";
-const pfr$1 = "𝔭";
-const phi$1 = "φ";
-const phiv$1 = "ϕ";
-const phmmat$1 = "ℳ";
-const phone$1 = "☎";
-const pi$1 = "π";
-const pitchfork$1 = "⋔";
-const piv$1 = "ϖ";
-const planck$1 = "ℏ";
-const planckh$1 = "ℎ";
-const plankv$1 = "ℏ";
-const plus$1 = "+";
-const plusacir$1 = "⨣";
-const plusb$1 = "⊞";
-const pluscir$1 = "⨢";
-const plusdo$1 = "∔";
-const plusdu$1 = "⨥";
-const pluse$1 = "⩲";
-const plusm$1 = "±";
-const plusmn$1 = "±";
-const plussim$1 = "⨦";
-const plustwo$1 = "⨧";
-const pm$1 = "±";
-const pointint$1 = "⨕";
-const popf$1 = "𝕡";
-const poun$1 = "£";
-const pound$1 = "£";
-const pr$1 = "≺";
-const prE$1 = "⪳";
-const prap$1 = "⪷";
-const prcue$1 = "≼";
-const pre$1 = "⪯";
-const prec$1 = "≺";
-const precapprox$1 = "⪷";
-const preccurlyeq$1 = "≼";
-const preceq$1 = "⪯";
-const precnapprox$1 = "⪹";
-const precneqq$1 = "⪵";
-const precnsim$1 = "⋨";
-const precsim$1 = "≾";
-const prime$1 = "′";
-const primes$1 = "ℙ";
-const prnE$1 = "⪵";
-const prnap$1 = "⪹";
-const prnsim$1 = "⋨";
-const prod$1 = "∏";
-const profalar$1 = "⌮";
-const profline$1 = "⌒";
-const profsurf$1 = "⌓";
-const prop$1 = "∝";
-const propto$1 = "∝";
-const prsim$1 = "≾";
-const prurel$1 = "⊰";
-const pscr$1 = "𝓅";
-const psi$1 = "ψ";
-const puncsp$1 = " ";
-const qfr$1 = "𝔮";
-const qint$1 = "⨌";
-const qopf$1 = "𝕢";
-const qprime$1 = "⁗";
-const qscr$1 = "𝓆";
-const quaternions$1 = "ℍ";
-const quatint$1 = "⨖";
-const quest$1 = "?";
-const questeq$1 = "≟";
-const quo$1 = "\"";
-const quot$1 = "\"";
-const rAarr$1 = "⇛";
-const rArr$1 = "⇒";
-const rAtail$1 = "⤜";
-const rBarr$1 = "⤏";
-const rHar$1 = "⥤";
-const race$1 = "∽̱";
-const racute$1 = "ŕ";
-const radic$1 = "√";
-const raemptyv$1 = "⦳";
-const rang$1 = "⟩";
-const rangd$1 = "⦒";
-const range$1 = "⦥";
-const rangle$1 = "⟩";
-const raqu$1 = "»";
-const raquo$1 = "»";
-const rarr$1 = "→";
-const rarrap$1 = "⥵";
-const rarrb$1 = "⇥";
-const rarrbfs$1 = "⤠";
-const rarrc$1 = "⤳";
-const rarrfs$1 = "⤞";
-const rarrhk$1 = "↪";
-const rarrlp$1 = "↬";
-const rarrpl$1 = "⥅";
-const rarrsim$1 = "⥴";
-const rarrtl$1 = "↣";
-const rarrw$1 = "↝";
-const ratail$1 = "⤚";
-const ratio$1 = "∶";
-const rationals$1 = "ℚ";
-const rbarr$1 = "⤍";
-const rbbrk$1 = "❳";
-const rbrace$1 = "}";
-const rbrack$1 = "]";
-const rbrke$1 = "⦌";
-const rbrksld$1 = "⦎";
-const rbrkslu$1 = "⦐";
-const rcaron$1 = "ř";
-const rcedil$1 = "ŗ";
-const rceil$1 = "⌉";
-const rcub$1 = "}";
-const rcy$1 = "р";
-const rdca$1 = "⤷";
-const rdldhar$1 = "⥩";
-const rdquo$1 = "”";
-const rdquor$1 = "”";
-const rdsh$1 = "↳";
-const real$1 = "ℜ";
-const realine$1 = "ℛ";
-const realpart$1 = "ℜ";
-const reals$1 = "ℝ";
-const rect$1 = "▭";
-const re$5 = "®";
-const reg$1 = "®";
-const rfisht$1 = "⥽";
-const rfloor$1 = "⌋";
-const rfr$1 = "𝔯";
-const rhard$1 = "⇁";
-const rharu$1 = "⇀";
-const rharul$1 = "⥬";
-const rho$1 = "ρ";
-const rhov$1 = "ϱ";
-const rightarrow$1 = "→";
-const rightarrowtail$1 = "↣";
-const rightharpoondown$1 = "⇁";
-const rightharpoonup$1 = "⇀";
-const rightleftarrows$1 = "⇄";
-const rightleftharpoons$1 = "⇌";
-const rightrightarrows$1 = "⇉";
-const rightsquigarrow$1 = "↝";
-const rightthreetimes$1 = "⋌";
-const ring$1 = "˚";
-const risingdotseq$1 = "≓";
-const rlarr$1 = "⇄";
-const rlhar$1 = "⇌";
-const rlm$1 = "‏";
-const rmoust$1 = "⎱";
-const rmoustache$1 = "⎱";
-const rnmid$1 = "⫮";
-const roang$1 = "⟭";
-const roarr$1 = "⇾";
-const robrk$1 = "⟧";
-const ropar$1 = "⦆";
-const ropf$1 = "𝕣";
-const roplus$1 = "⨮";
-const rotimes$1 = "⨵";
-const rpar$1 = ")";
-const rpargt$1 = "⦔";
-const rppolint$1 = "⨒";
-const rrarr$1 = "⇉";
-const rsaquo$1 = "›";
-const rscr$1 = "𝓇";
-const rsh$1 = "↱";
-const rsqb$1 = "]";
-const rsquo$1 = "’";
-const rsquor$1 = "’";
-const rthree$1 = "⋌";
-const rtimes$1 = "⋊";
-const rtri$1 = "▹";
-const rtrie$1 = "⊵";
-const rtrif$1 = "▸";
-const rtriltri$1 = "⧎";
-const ruluhar$1 = "⥨";
-const rx$1 = "℞";
-const sacute$1 = "ś";
-const sbquo$1 = "‚";
-const sc$1 = "≻";
-const scE$1 = "⪴";
-const scap$1 = "⪸";
-const scaron$1 = "š";
-const sccue$1 = "≽";
-const sce$1 = "⪰";
-const scedil$1 = "ş";
-const scirc$1 = "ŝ";
-const scnE$1 = "⪶";
-const scnap$1 = "⪺";
-const scnsim$1 = "⋩";
-const scpolint$1 = "⨓";
-const scsim$1 = "≿";
-const scy$1 = "с";
-const sdot$1 = "⋅";
-const sdotb$1 = "⊡";
-const sdote$1 = "⩦";
-const seArr$1 = "⇘";
-const searhk$1 = "⤥";
-const searr$1 = "↘";
-const searrow$1 = "↘";
-const sec$1 = "§";
-const sect$1 = "§";
-const semi$1 = ";";
-const seswar$1 = "⤩";
-const setminus$1 = "∖";
-const setmn$1 = "∖";
-const sext$1 = "✶";
-const sfr$1 = "𝔰";
-const sfrown$1 = "⌢";
-const sharp$1 = "♯";
-const shchcy$1 = "щ";
-const shcy$1 = "ш";
-const shortmid$1 = "∣";
-const shortparallel$1 = "∥";
-const sh$1 = "­";
-const shy$1 = "­";
-const sigma$1 = "σ";
-const sigmaf$1 = "ς";
-const sigmav$1 = "ς";
-const sim$1 = "∼";
-const simdot$1 = "⩪";
-const sime$1 = "≃";
-const simeq$1 = "≃";
-const simg$1 = "⪞";
-const simgE$1 = "⪠";
-const siml$1 = "⪝";
-const simlE$1 = "⪟";
-const simne$1 = "≆";
-const simplus$1 = "⨤";
-const simrarr$1 = "⥲";
-const slarr$1 = "←";
-const smallsetminus$1 = "∖";
-const smashp$1 = "⨳";
-const smeparsl$1 = "⧤";
-const smid$1 = "∣";
-const smile$1 = "⌣";
-const smt$1 = "⪪";
-const smte$1 = "⪬";
-const smtes$1 = "⪬︀";
-const softcy$1 = "ь";
-const sol$1 = "/";
-const solb$1 = "⧄";
-const solbar$1 = "⌿";
-const sopf$1 = "𝕤";
-const spades$1 = "♠";
-const spadesuit$1 = "♠";
-const spar$1 = "∥";
-const sqcap$1 = "⊓";
-const sqcaps$1 = "⊓︀";
-const sqcup$1 = "⊔";
-const sqcups$1 = "⊔︀";
-const sqsub$1 = "⊏";
-const sqsube$1 = "⊑";
-const sqsubset$1 = "⊏";
-const sqsubseteq$1 = "⊑";
-const sqsup$1 = "⊐";
-const sqsupe$1 = "⊒";
-const sqsupset$1 = "⊐";
-const sqsupseteq$1 = "⊒";
-const squ$1 = "□";
-const square$1 = "□";
-const squarf$1 = "▪";
-const squf$1 = "▪";
-const srarr$1 = "→";
-const sscr$1 = "𝓈";
-const ssetmn$1 = "∖";
-const ssmile$1 = "⌣";
-const sstarf$1 = "⋆";
-const star$1 = "☆";
-const starf$1 = "★";
-const straightepsilon$1 = "ϵ";
-const straightphi$1 = "ϕ";
-const strns$1 = "¯";
-const sub$1 = "⊂";
-const subE$1 = "⫅";
-const subdot$1 = "⪽";
-const sube$1 = "⊆";
-const subedot$1 = "⫃";
-const submult$1 = "⫁";
-const subnE$1 = "⫋";
-const subne$1 = "⊊";
-const subplus$1 = "⪿";
-const subrarr$1 = "⥹";
-const subset$1 = "⊂";
-const subseteq$1 = "⊆";
-const subseteqq$1 = "⫅";
-const subsetneq$1 = "⊊";
-const subsetneqq$1 = "⫋";
-const subsim$1 = "⫇";
-const subsub$1 = "⫕";
-const subsup$1 = "⫓";
-const succ$1 = "≻";
-const succapprox$1 = "⪸";
-const succcurlyeq$1 = "≽";
-const succeq$1 = "⪰";
-const succnapprox$1 = "⪺";
-const succneqq$1 = "⪶";
-const succnsim$1 = "⋩";
-const succsim$1 = "≿";
-const sum$1 = "∑";
-const sung$1 = "♪";
-const sup$1 = "⊃";
-const sup1$1 = "¹";
-const sup2$1 = "²";
-const sup3$1 = "³";
-const supE$1 = "⫆";
-const supdot$1 = "⪾";
-const supdsub$1 = "⫘";
-const supe$1 = "⊇";
-const supedot$1 = "⫄";
-const suphsol$1 = "⟉";
-const suphsub$1 = "⫗";
-const suplarr$1 = "⥻";
-const supmult$1 = "⫂";
-const supnE$1 = "⫌";
-const supne$1 = "⊋";
-const supplus$1 = "⫀";
-const supset$1 = "⊃";
-const supseteq$1 = "⊇";
-const supseteqq$1 = "⫆";
-const supsetneq$1 = "⊋";
-const supsetneqq$1 = "⫌";
-const supsim$1 = "⫈";
-const supsub$1 = "⫔";
-const supsup$1 = "⫖";
-const swArr$1 = "⇙";
-const swarhk$1 = "⤦";
-const swarr$1 = "↙";
-const swarrow$1 = "↙";
-const swnwar$1 = "⤪";
-const szli$1 = "ß";
-const szlig$1 = "ß";
-const target$1 = "⌖";
-const tau$1 = "τ";
-const tbrk$1 = "⎴";
-const tcaron$1 = "ť";
-const tcedil$1 = "ţ";
-const tcy$1 = "т";
-const tdot$1 = "⃛";
-const telrec$1 = "⌕";
-const tfr$1 = "𝔱";
-const there4$1 = "∴";
-const therefore$1 = "∴";
-const theta$1 = "θ";
-const thetasym$1 = "ϑ";
-const thetav$1 = "ϑ";
-const thickapprox$1 = "≈";
-const thicksim$1 = "∼";
-const thinsp$1 = " ";
-const thkap$1 = "≈";
-const thksim$1 = "∼";
-const thor$1 = "þ";
-const thorn$1 = "þ";
-const tilde$1 = "˜";
-const time$1 = "×";
-const times$1 = "×";
-const timesb$1 = "⊠";
-const timesbar$1 = "⨱";
-const timesd$1 = "⨰";
-const tint$1 = "∭";
-const toea$1 = "⤨";
-const top$1 = "⊤";
-const topbot$1 = "⌶";
-const topcir$1 = "⫱";
-const topf$1 = "𝕥";
-const topfork$1 = "⫚";
-const tosa$1 = "⤩";
-const tprime$1 = "‴";
-const trade$1 = "™";
-const triangle$1 = "▵";
-const triangledown$1 = "▿";
-const triangleleft$1 = "◃";
-const trianglelefteq$1 = "⊴";
-const triangleq$1 = "≜";
-const triangleright$1 = "▹";
-const trianglerighteq$1 = "⊵";
-const tridot$1 = "◬";
-const trie$1 = "≜";
-const triminus$1 = "⨺";
-const triplus$1 = "⨹";
-const trisb$1 = "⧍";
-const tritime$1 = "⨻";
-const trpezium$1 = "⏢";
-const tscr$1 = "𝓉";
-const tscy$1 = "ц";
-const tshcy$1 = "ћ";
-const tstrok$1 = "ŧ";
-const twixt$1 = "≬";
-const twoheadleftarrow$1 = "↞";
-const twoheadrightarrow$1 = "↠";
-const uArr$1 = "⇑";
-const uHar$1 = "⥣";
-const uacut$1 = "ú";
-const uacute$1 = "ú";
-const uarr$1 = "↑";
-const ubrcy$1 = "ў";
-const ubreve$1 = "ŭ";
-const ucir$1 = "û";
-const ucirc$1 = "û";
-const ucy$1 = "у";
-const udarr$1 = "⇅";
-const udblac$1 = "ű";
-const udhar$1 = "⥮";
-const ufisht$1 = "⥾";
-const ufr$1 = "𝔲";
-const ugrav$1 = "ù";
-const ugrave$1 = "ù";
-const uharl$1 = "↿";
-const uharr$1 = "↾";
-const uhblk$1 = "▀";
-const ulcorn$1 = "⌜";
-const ulcorner$1 = "⌜";
-const ulcrop$1 = "⌏";
-const ultri$1 = "◸";
-const umacr$1 = "ū";
-const um$1 = "¨";
-const uml$1 = "¨";
-const uogon$1 = "ų";
-const uopf$1 = "𝕦";
-const uparrow$1 = "↑";
-const updownarrow$1 = "↕";
-const upharpoonleft$1 = "↿";
-const upharpoonright$1 = "↾";
-const uplus$1 = "⊎";
-const upsi$1 = "υ";
-const upsih$1 = "ϒ";
-const upsilon$1 = "υ";
-const upuparrows$1 = "⇈";
-const urcorn$1 = "⌝";
-const urcorner$1 = "⌝";
-const urcrop$1 = "⌎";
-const uring$1 = "ů";
-const urtri$1 = "◹";
-const uscr$1 = "𝓊";
-const utdot$1 = "⋰";
-const utilde$1 = "ũ";
-const utri$1 = "▵";
-const utrif$1 = "▴";
-const uuarr$1 = "⇈";
-const uum$1 = "ü";
-const uuml$1 = "ü";
-const uwangle$1 = "⦧";
-const vArr$1 = "⇕";
-const vBar$1 = "⫨";
-const vBarv$1 = "⫩";
-const vDash$1 = "⊨";
-const vangrt$1 = "⦜";
-const varepsilon$1 = "ϵ";
-const varkappa$1 = "ϰ";
-const varnothing$1 = "∅";
-const varphi$1 = "ϕ";
-const varpi$1 = "ϖ";
-const varpropto$1 = "∝";
-const varr$1 = "↕";
-const varrho$1 = "ϱ";
-const varsigma$1 = "ς";
-const varsubsetneq$1 = "⊊︀";
-const varsubsetneqq$1 = "⫋︀";
-const varsupsetneq$1 = "⊋︀";
-const varsupsetneqq$1 = "⫌︀";
-const vartheta$1 = "ϑ";
-const vartriangleleft$1 = "⊲";
-const vartriangleright$1 = "⊳";
-const vcy$1 = "в";
-const vdash$1 = "⊢";
-const vee$1 = "∨";
-const veebar$1 = "⊻";
-const veeeq$1 = "≚";
-const vellip$1 = "⋮";
-const verbar$1 = "|";
-const vert$1 = "|";
-const vfr$1 = "𝔳";
-const vltri$1 = "⊲";
-const vnsub$1 = "⊂⃒";
-const vnsup$1 = "⊃⃒";
-const vopf$1 = "𝕧";
-const vprop$1 = "∝";
-const vrtri$1 = "⊳";
-const vscr$1 = "𝓋";
-const vsubnE$1 = "⫋︀";
-const vsubne$1 = "⊊︀";
-const vsupnE$1 = "⫌︀";
-const vsupne$1 = "⊋︀";
-const vzigzag$1 = "⦚";
-const wcirc$1 = "ŵ";
-const wedbar$1 = "⩟";
-const wedge$1 = "∧";
-const wedgeq$1 = "≙";
-const weierp$1 = "℘";
-const wfr$1 = "𝔴";
-const wopf$1 = "𝕨";
-const wp$1 = "℘";
-const wr$1 = "≀";
-const wreath$1 = "≀";
-const wscr$1 = "𝓌";
-const xcap$1 = "⋂";
-const xcirc$1 = "◯";
-const xcup$1 = "⋃";
-const xdtri$1 = "▽";
-const xfr$1 = "𝔵";
-const xhArr$1 = "⟺";
-const xharr$1 = "⟷";
-const xi$1 = "ξ";
-const xlArr$1 = "⟸";
-const xlarr$1 = "⟵";
-const xmap$1 = "⟼";
-const xnis$1 = "⋻";
-const xodot$1 = "⨀";
-const xopf$1 = "𝕩";
-const xoplus$1 = "⨁";
-const xotime$1 = "⨂";
-const xrArr$1 = "⟹";
-const xrarr$1 = "⟶";
-const xscr$1 = "𝓍";
-const xsqcup$1 = "⨆";
-const xuplus$1 = "⨄";
-const xutri$1 = "△";
-const xvee$1 = "⋁";
-const xwedge$1 = "⋀";
-const yacut$1 = "ý";
-const yacute$1 = "ý";
-const yacy$1 = "я";
-const ycirc$1 = "ŷ";
-const ycy$1 = "ы";
-const ye$1 = "¥";
-const yen$1 = "¥";
-const yfr$1 = "𝔶";
-const yicy$1 = "ї";
-const yopf$1 = "𝕪";
-const yscr$1 = "𝓎";
-const yucy$1 = "ю";
-const yum$1 = "ÿ";
-const yuml$1 = "ÿ";
-const zacute$1 = "ź";
-const zcaron$1 = "ž";
-const zcy$1 = "з";
-const zdot$1 = "ż";
-const zeetrf$1 = "ℨ";
-const zeta$1 = "ζ";
-const zfr$1 = "𝔷";
-const zhcy$1 = "ж";
-const zigrarr$1 = "⇝";
-const zopf$1 = "𝕫";
-const zscr$1 = "𝓏";
-const zwj$1 = "‍";
-const zwnj$1 = "‌";
-var require$$0$1 = {
- AEli: AEli$1,
- AElig: AElig$1,
- AM: AM$1,
- AMP: AMP$1,
- Aacut: Aacut$1,
- Aacute: Aacute$1,
- Abreve: Abreve$1,
- Acir: Acir$1,
- Acirc: Acirc$1,
- Acy: Acy$1,
- Afr: Afr$1,
- Agrav: Agrav$1,
- Agrave: Agrave$1,
- Alpha: Alpha$1,
- Amacr: Amacr$1,
- And: And$1,
- Aogon: Aogon$1,
- Aopf: Aopf$1,
- ApplyFunction: ApplyFunction$1,
- Arin: Arin$1,
- Aring: Aring$1,
- Ascr: Ascr$1,
- Assign: Assign$1,
- Atild: Atild$1,
- Atilde: Atilde$1,
- Aum: Aum$1,
- Auml: Auml$1,
- Backslash: Backslash$1,
- Barv: Barv$1,
- Barwed: Barwed$1,
- Bcy: Bcy$1,
- Because: Because$1,
- Bernoullis: Bernoullis$1,
- Beta: Beta$1,
- Bfr: Bfr$1,
- Bopf: Bopf$1,
- Breve: Breve$1,
- Bscr: Bscr$1,
- Bumpeq: Bumpeq$1,
- CHcy: CHcy$1,
- COP: COP$1,
- COPY: COPY$1,
- Cacute: Cacute$1,
- Cap: Cap$1,
- CapitalDifferentialD: CapitalDifferentialD$1,
- Cayleys: Cayleys$1,
- Ccaron: Ccaron$1,
- Ccedi: Ccedi$1,
- Ccedil: Ccedil$1,
- Ccirc: Ccirc$1,
- Cconint: Cconint$1,
- Cdot: Cdot$1,
- Cedilla: Cedilla$1,
- CenterDot: CenterDot$1,
- Cfr: Cfr$1,
- Chi: Chi$1,
- CircleDot: CircleDot$1,
- CircleMinus: CircleMinus$1,
- CirclePlus: CirclePlus$1,
- CircleTimes: CircleTimes$1,
- ClockwiseContourIntegral: ClockwiseContourIntegral$1,
- CloseCurlyDoubleQuote: CloseCurlyDoubleQuote$1,
- CloseCurlyQuote: CloseCurlyQuote$1,
- Colon: Colon$1,
- Colone: Colone$1,
- Congruent: Congruent$1,
- Conint: Conint$1,
- ContourIntegral: ContourIntegral$1,
- Copf: Copf$1,
- Coproduct: Coproduct$1,
- CounterClockwiseContourIntegral: CounterClockwiseContourIntegral$1,
- Cross: Cross$1,
- Cscr: Cscr$1,
- Cup: Cup$1,
- CupCap: CupCap$1,
- DD: DD$1,
- DDotrahd: DDotrahd$1,
- DJcy: DJcy$1,
- DScy: DScy$1,
- DZcy: DZcy$1,
- Dagger: Dagger$1,
- Darr: Darr$1,
- Dashv: Dashv$1,
- Dcaron: Dcaron$1,
- Dcy: Dcy$1,
- Del: Del$1,
- Delta: Delta$1,
- Dfr: Dfr$1,
- DiacriticalAcute: DiacriticalAcute$1,
- DiacriticalDot: DiacriticalDot$1,
- DiacriticalDoubleAcute: DiacriticalDoubleAcute$1,
- DiacriticalGrave: DiacriticalGrave$1,
- DiacriticalTilde: DiacriticalTilde$1,
- Diamond: Diamond$1,
- DifferentialD: DifferentialD$1,
- Dopf: Dopf$1,
- Dot: Dot$1,
- DotDot: DotDot$1,
- DotEqual: DotEqual$1,
- DoubleContourIntegral: DoubleContourIntegral$1,
- DoubleDot: DoubleDot$1,
- DoubleDownArrow: DoubleDownArrow$1,
- DoubleLeftArrow: DoubleLeftArrow$1,
- DoubleLeftRightArrow: DoubleLeftRightArrow$1,
- DoubleLeftTee: DoubleLeftTee$1,
- DoubleLongLeftArrow: DoubleLongLeftArrow$1,
- DoubleLongLeftRightArrow: DoubleLongLeftRightArrow$1,
- DoubleLongRightArrow: DoubleLongRightArrow$1,
- DoubleRightArrow: DoubleRightArrow$1,
- DoubleRightTee: DoubleRightTee$1,
- DoubleUpArrow: DoubleUpArrow$1,
- DoubleUpDownArrow: DoubleUpDownArrow$1,
- DoubleVerticalBar: DoubleVerticalBar$1,
- DownArrow: DownArrow$1,
- DownArrowBar: DownArrowBar$1,
- DownArrowUpArrow: DownArrowUpArrow$1,
- DownBreve: DownBreve$1,
- DownLeftRightVector: DownLeftRightVector$1,
- DownLeftTeeVector: DownLeftTeeVector$1,
- DownLeftVector: DownLeftVector$1,
- DownLeftVectorBar: DownLeftVectorBar$1,
- DownRightTeeVector: DownRightTeeVector$1,
- DownRightVector: DownRightVector$1,
- DownRightVectorBar: DownRightVectorBar$1,
- DownTee: DownTee$1,
- DownTeeArrow: DownTeeArrow$1,
- Downarrow: Downarrow$1,
- Dscr: Dscr$1,
- Dstrok: Dstrok$1,
- ENG: ENG$1,
- ET: ET$1,
- ETH: ETH$1,
- Eacut: Eacut$1,
- Eacute: Eacute$1,
- Ecaron: Ecaron$1,
- Ecir: Ecir$1,
- Ecirc: Ecirc$1,
- Ecy: Ecy$1,
- Edot: Edot$1,
- Efr: Efr$1,
- Egrav: Egrav$1,
- Egrave: Egrave$1,
- Element: Element$1,
- Emacr: Emacr$1,
- EmptySmallSquare: EmptySmallSquare$1,
- EmptyVerySmallSquare: EmptyVerySmallSquare$1,
- Eogon: Eogon$1,
- Eopf: Eopf$1,
- Epsilon: Epsilon$1,
- Equal: Equal$1,
- EqualTilde: EqualTilde$1,
- Equilibrium: Equilibrium$1,
- Escr: Escr$1,
- Esim: Esim$1,
- Eta: Eta$1,
- Eum: Eum$1,
- Euml: Euml$1,
- Exists: Exists$1,
- ExponentialE: ExponentialE$1,
- Fcy: Fcy$1,
- Ffr: Ffr$1,
- FilledSmallSquare: FilledSmallSquare$1,
- FilledVerySmallSquare: FilledVerySmallSquare$1,
- Fopf: Fopf$1,
- ForAll: ForAll$1,
- Fouriertrf: Fouriertrf$1,
- Fscr: Fscr$1,
- GJcy: GJcy$1,
- G: G$1,
- GT: GT$1,
- Gamma: Gamma$1,
- Gammad: Gammad$1,
- Gbreve: Gbreve$1,
- Gcedil: Gcedil$1,
- Gcirc: Gcirc$1,
- Gcy: Gcy$1,
- Gdot: Gdot$1,
- Gfr: Gfr$1,
- Gg: Gg$1,
- Gopf: Gopf$1,
- GreaterEqual: GreaterEqual$1,
- GreaterEqualLess: GreaterEqualLess$1,
- GreaterFullEqual: GreaterFullEqual$1,
- GreaterGreater: GreaterGreater$1,
- GreaterLess: GreaterLess$1,
- GreaterSlantEqual: GreaterSlantEqual$1,
- GreaterTilde: GreaterTilde$1,
- Gscr: Gscr$1,
- Gt: Gt$1,
- HARDcy: HARDcy$1,
- Hacek: Hacek$1,
- Hat: Hat$1,
- Hcirc: Hcirc$1,
- Hfr: Hfr$1,
- HilbertSpace: HilbertSpace$1,
- Hopf: Hopf$1,
- HorizontalLine: HorizontalLine$1,
- Hscr: Hscr$1,
- Hstrok: Hstrok$1,
- HumpDownHump: HumpDownHump$1,
- HumpEqual: HumpEqual$1,
- IEcy: IEcy$1,
- IJlig: IJlig$1,
- IOcy: IOcy$1,
- Iacut: Iacut$1,
- Iacute: Iacute$1,
- Icir: Icir$1,
- Icirc: Icirc$1,
- Icy: Icy$1,
- Idot: Idot$1,
- Ifr: Ifr$1,
- Igrav: Igrav$1,
- Igrave: Igrave$1,
- Im: Im$1,
- Imacr: Imacr$1,
- ImaginaryI: ImaginaryI$1,
- Implies: Implies$1,
- Int: Int$1,
- Integral: Integral$1,
- Intersection: Intersection$1,
- InvisibleComma: InvisibleComma$1,
- InvisibleTimes: InvisibleTimes$1,
- Iogon: Iogon$1,
- Iopf: Iopf$1,
- Iota: Iota$1,
- Iscr: Iscr$1,
- Itilde: Itilde$1,
- Iukcy: Iukcy$1,
- Ium: Ium$1,
- Iuml: Iuml$1,
- Jcirc: Jcirc$1,
- Jcy: Jcy$1,
- Jfr: Jfr$1,
- Jopf: Jopf$1,
- Jscr: Jscr$1,
- Jsercy: Jsercy$1,
- Jukcy: Jukcy$1,
- KHcy: KHcy$1,
- KJcy: KJcy$1,
- Kappa: Kappa$1,
- Kcedil: Kcedil$1,
- Kcy: Kcy$1,
- Kfr: Kfr$1,
- Kopf: Kopf$1,
- Kscr: Kscr$1,
- LJcy: LJcy$1,
- L: L$1,
- LT: LT$1,
- Lacute: Lacute$1,
- Lambda: Lambda$1,
- Lang: Lang$1,
- Laplacetrf: Laplacetrf$1,
- Larr: Larr$1,
- Lcaron: Lcaron$1,
- Lcedil: Lcedil$1,
- Lcy: Lcy$1,
- LeftAngleBracket: LeftAngleBracket$1,
- LeftArrow: LeftArrow$1,
- LeftArrowBar: LeftArrowBar$1,
- LeftArrowRightArrow: LeftArrowRightArrow$1,
- LeftCeiling: LeftCeiling$1,
- LeftDoubleBracket: LeftDoubleBracket$1,
- LeftDownTeeVector: LeftDownTeeVector$1,
- LeftDownVector: LeftDownVector$1,
- LeftDownVectorBar: LeftDownVectorBar$1,
- LeftFloor: LeftFloor$1,
- LeftRightArrow: LeftRightArrow$1,
- LeftRightVector: LeftRightVector$1,
- LeftTee: LeftTee$1,
- LeftTeeArrow: LeftTeeArrow$1,
- LeftTeeVector: LeftTeeVector$1,
- LeftTriangle: LeftTriangle$1,
- LeftTriangleBar: LeftTriangleBar$1,
- LeftTriangleEqual: LeftTriangleEqual$1,
- LeftUpDownVector: LeftUpDownVector$1,
- LeftUpTeeVector: LeftUpTeeVector$1,
- LeftUpVector: LeftUpVector$1,
- LeftUpVectorBar: LeftUpVectorBar$1,
- LeftVector: LeftVector$1,
- LeftVectorBar: LeftVectorBar$1,
- Leftarrow: Leftarrow$1,
- Leftrightarrow: Leftrightarrow$1,
- LessEqualGreater: LessEqualGreater$1,
- LessFullEqual: LessFullEqual$1,
- LessGreater: LessGreater$1,
- LessLess: LessLess$1,
- LessSlantEqual: LessSlantEqual$1,
- LessTilde: LessTilde$1,
- Lfr: Lfr$1,
- Ll: Ll$1,
- Lleftarrow: Lleftarrow$1,
- Lmidot: Lmidot$1,
- LongLeftArrow: LongLeftArrow$1,
- LongLeftRightArrow: LongLeftRightArrow$1,
- LongRightArrow: LongRightArrow$1,
- Longleftarrow: Longleftarrow$1,
- Longleftrightarrow: Longleftrightarrow$1,
- Longrightarrow: Longrightarrow$1,
- Lopf: Lopf$1,
- LowerLeftArrow: LowerLeftArrow$1,
- LowerRightArrow: LowerRightArrow$1,
- Lscr: Lscr$1,
- Lsh: Lsh$1,
- Lstrok: Lstrok$1,
- Lt: Lt$1,
- "Map": "⤅",
- Mcy: Mcy$1,
- MediumSpace: MediumSpace$1,
- Mellintrf: Mellintrf$1,
- Mfr: Mfr$1,
- MinusPlus: MinusPlus$1,
- Mopf: Mopf$1,
- Mscr: Mscr$1,
- Mu: Mu$1,
- NJcy: NJcy$1,
- Nacute: Nacute$1,
- Ncaron: Ncaron$1,
- Ncedil: Ncedil$1,
- Ncy: Ncy$1,
- NegativeMediumSpace: NegativeMediumSpace$1,
- NegativeThickSpace: NegativeThickSpace$1,
- NegativeThinSpace: NegativeThinSpace$1,
- NegativeVeryThinSpace: NegativeVeryThinSpace$1,
- NestedGreaterGreater: NestedGreaterGreater$1,
- NestedLessLess: NestedLessLess$1,
- NewLine: NewLine$1,
- Nfr: Nfr$1,
- NoBreak: NoBreak$1,
- NonBreakingSpace: NonBreakingSpace$1,
- Nopf: Nopf$1,
- Not: Not$1,
- NotCongruent: NotCongruent$1,
- NotCupCap: NotCupCap$1,
- NotDoubleVerticalBar: NotDoubleVerticalBar$1,
- NotElement: NotElement$1,
- NotEqual: NotEqual$1,
- NotEqualTilde: NotEqualTilde$1,
- NotExists: NotExists$1,
- NotGreater: NotGreater$1,
- NotGreaterEqual: NotGreaterEqual$1,
- NotGreaterFullEqual: NotGreaterFullEqual$1,
- NotGreaterGreater: NotGreaterGreater$1,
- NotGreaterLess: NotGreaterLess$1,
- NotGreaterSlantEqual: NotGreaterSlantEqual$1,
- NotGreaterTilde: NotGreaterTilde$1,
- NotHumpDownHump: NotHumpDownHump$1,
- NotHumpEqual: NotHumpEqual$1,
- NotLeftTriangle: NotLeftTriangle$1,
- NotLeftTriangleBar: NotLeftTriangleBar$1,
- NotLeftTriangleEqual: NotLeftTriangleEqual$1,
- NotLess: NotLess$1,
- NotLessEqual: NotLessEqual$1,
- NotLessGreater: NotLessGreater$1,
- NotLessLess: NotLessLess$1,
- NotLessSlantEqual: NotLessSlantEqual$1,
- NotLessTilde: NotLessTilde$1,
- NotNestedGreaterGreater: NotNestedGreaterGreater$1,
- NotNestedLessLess: NotNestedLessLess$1,
- NotPrecedes: NotPrecedes$1,
- NotPrecedesEqual: NotPrecedesEqual$1,
- NotPrecedesSlantEqual: NotPrecedesSlantEqual$1,
- NotReverseElement: NotReverseElement$1,
- NotRightTriangle: NotRightTriangle$1,
- NotRightTriangleBar: NotRightTriangleBar$1,
- NotRightTriangleEqual: NotRightTriangleEqual$1,
- NotSquareSubset: NotSquareSubset$1,
- NotSquareSubsetEqual: NotSquareSubsetEqual$1,
- NotSquareSuperset: NotSquareSuperset$1,
- NotSquareSupersetEqual: NotSquareSupersetEqual$1,
- NotSubset: NotSubset$1,
- NotSubsetEqual: NotSubsetEqual$1,
- NotSucceeds: NotSucceeds$1,
- NotSucceedsEqual: NotSucceedsEqual$1,
- NotSucceedsSlantEqual: NotSucceedsSlantEqual$1,
- NotSucceedsTilde: NotSucceedsTilde$1,
- NotSuperset: NotSuperset$1,
- NotSupersetEqual: NotSupersetEqual$1,
- NotTilde: NotTilde$1,
- NotTildeEqual: NotTildeEqual$1,
- NotTildeFullEqual: NotTildeFullEqual$1,
- NotTildeTilde: NotTildeTilde$1,
- NotVerticalBar: NotVerticalBar$1,
- Nscr: Nscr$1,
- Ntild: Ntild$1,
- Ntilde: Ntilde$1,
- Nu: Nu$1,
- OElig: OElig$1,
- Oacut: Oacut$1,
- Oacute: Oacute$1,
- Ocir: Ocir$1,
- Ocirc: Ocirc$1,
- Ocy: Ocy$1,
- Odblac: Odblac$1,
- Ofr: Ofr$1,
- Ograv: Ograv$1,
- Ograve: Ograve$1,
- Omacr: Omacr$1,
- Omega: Omega$1,
- Omicron: Omicron$1,
- Oopf: Oopf$1,
- OpenCurlyDoubleQuote: OpenCurlyDoubleQuote$1,
- OpenCurlyQuote: OpenCurlyQuote$1,
- Or: Or$1,
- Oscr: Oscr$1,
- Oslas: Oslas$1,
- Oslash: Oslash$1,
- Otild: Otild$1,
- Otilde: Otilde$1,
- Otimes: Otimes$1,
- Oum: Oum$1,
- Ouml: Ouml$1,
- OverBar: OverBar$1,
- OverBrace: OverBrace$1,
- OverBracket: OverBracket$1,
- OverParenthesis: OverParenthesis$1,
- PartialD: PartialD$1,
- Pcy: Pcy$1,
- Pfr: Pfr$1,
- Phi: Phi$1,
- Pi: Pi$1,
- PlusMinus: PlusMinus$1,
- Poincareplane: Poincareplane$1,
- Popf: Popf$1,
- Pr: Pr$1,
- Precedes: Precedes$1,
- PrecedesEqual: PrecedesEqual$1,
- PrecedesSlantEqual: PrecedesSlantEqual$1,
- PrecedesTilde: PrecedesTilde$1,
- Prime: Prime$1,
- Product: Product$1,
- Proportion: Proportion$1,
- Proportional: Proportional$1,
- Pscr: Pscr$1,
- Psi: Psi$1,
- QUO: QUO$1,
- QUOT: QUOT$1,
- Qfr: Qfr$1,
- Qopf: Qopf$1,
- Qscr: Qscr$1,
- RBarr: RBarr$1,
- RE: RE$1,
- REG: REG$1,
- Racute: Racute$1,
- Rang: Rang$1,
- Rarr: Rarr$1,
- Rarrtl: Rarrtl$1,
- Rcaron: Rcaron$1,
- Rcedil: Rcedil$1,
- Rcy: Rcy$1,
- Re: Re$1,
- ReverseElement: ReverseElement$1,
- ReverseEquilibrium: ReverseEquilibrium$1,
- ReverseUpEquilibrium: ReverseUpEquilibrium$1,
- Rfr: Rfr$1,
- Rho: Rho$1,
- RightAngleBracket: RightAngleBracket$1,
- RightArrow: RightArrow$1,
- RightArrowBar: RightArrowBar$1,
- RightArrowLeftArrow: RightArrowLeftArrow$1,
- RightCeiling: RightCeiling$1,
- RightDoubleBracket: RightDoubleBracket$1,
- RightDownTeeVector: RightDownTeeVector$1,
- RightDownVector: RightDownVector$1,
- RightDownVectorBar: RightDownVectorBar$1,
- RightFloor: RightFloor$1,
- RightTee: RightTee$1,
- RightTeeArrow: RightTeeArrow$1,
- RightTeeVector: RightTeeVector$1,
- RightTriangle: RightTriangle$1,
- RightTriangleBar: RightTriangleBar$1,
- RightTriangleEqual: RightTriangleEqual$1,
- RightUpDownVector: RightUpDownVector$1,
- RightUpTeeVector: RightUpTeeVector$1,
- RightUpVector: RightUpVector$1,
- RightUpVectorBar: RightUpVectorBar$1,
- RightVector: RightVector$1,
- RightVectorBar: RightVectorBar$1,
- Rightarrow: Rightarrow$1,
- Ropf: Ropf$1,
- RoundImplies: RoundImplies$1,
- Rrightarrow: Rrightarrow$1,
- Rscr: Rscr$1,
- Rsh: Rsh$1,
- RuleDelayed: RuleDelayed$1,
- SHCHcy: SHCHcy$1,
- SHcy: SHcy$1,
- SOFTcy: SOFTcy$1,
- Sacute: Sacute$1,
- Sc: Sc$1,
- Scaron: Scaron$1,
- Scedil: Scedil$1,
- Scirc: Scirc$1,
- Scy: Scy$1,
- Sfr: Sfr$1,
- ShortDownArrow: ShortDownArrow$1,
- ShortLeftArrow: ShortLeftArrow$1,
- ShortRightArrow: ShortRightArrow$1,
- ShortUpArrow: ShortUpArrow$1,
- Sigma: Sigma$1,
- SmallCircle: SmallCircle$1,
- Sopf: Sopf$1,
- Sqrt: Sqrt$1,
- Square: Square$1,
- SquareIntersection: SquareIntersection$1,
- SquareSubset: SquareSubset$1,
- SquareSubsetEqual: SquareSubsetEqual$1,
- SquareSuperset: SquareSuperset$1,
- SquareSupersetEqual: SquareSupersetEqual$1,
- SquareUnion: SquareUnion$1,
- Sscr: Sscr$1,
- Star: Star$1,
- Sub: Sub$1,
- Subset: Subset$1,
- SubsetEqual: SubsetEqual$1,
- Succeeds: Succeeds$1,
- SucceedsEqual: SucceedsEqual$1,
- SucceedsSlantEqual: SucceedsSlantEqual$1,
- SucceedsTilde: SucceedsTilde$1,
- SuchThat: SuchThat$1,
- Sum: Sum$1,
- Sup: Sup$1,
- Superset: Superset$1,
- SupersetEqual: SupersetEqual$1,
- Supset: Supset$1,
- THOR: THOR$1,
- THORN: THORN$1,
- TRADE: TRADE$1,
- TSHcy: TSHcy$1,
- TScy: TScy$1,
- Tab: Tab$1,
- Tau: Tau$1,
- Tcaron: Tcaron$1,
- Tcedil: Tcedil$1,
- Tcy: Tcy$1,
- Tfr: Tfr$1,
- Therefore: Therefore$1,
- Theta: Theta$1,
- ThickSpace: ThickSpace$1,
- ThinSpace: ThinSpace$1,
- Tilde: Tilde$1,
- TildeEqual: TildeEqual$1,
- TildeFullEqual: TildeFullEqual$1,
- TildeTilde: TildeTilde$1,
- Topf: Topf$1,
- TripleDot: TripleDot$1,
- Tscr: Tscr$1,
- Tstrok: Tstrok$1,
- Uacut: Uacut$1,
- Uacute: Uacute$1,
- Uarr: Uarr$1,
- Uarrocir: Uarrocir$1,
- Ubrcy: Ubrcy$1,
- Ubreve: Ubreve$1,
- Ucir: Ucir$1,
- Ucirc: Ucirc$1,
- Ucy: Ucy$1,
- Udblac: Udblac$1,
- Ufr: Ufr$1,
- Ugrav: Ugrav$1,
- Ugrave: Ugrave$1,
- Umacr: Umacr$1,
- UnderBar: UnderBar$1,
- UnderBrace: UnderBrace$1,
- UnderBracket: UnderBracket$1,
- UnderParenthesis: UnderParenthesis$1,
- Union: Union$1,
- UnionPlus: UnionPlus$1,
- Uogon: Uogon$1,
- Uopf: Uopf$1,
- UpArrow: UpArrow$1,
- UpArrowBar: UpArrowBar$1,
- UpArrowDownArrow: UpArrowDownArrow$1,
- UpDownArrow: UpDownArrow$1,
- UpEquilibrium: UpEquilibrium$1,
- UpTee: UpTee$1,
- UpTeeArrow: UpTeeArrow$1,
- Uparrow: Uparrow$1,
- Updownarrow: Updownarrow$1,
- UpperLeftArrow: UpperLeftArrow$1,
- UpperRightArrow: UpperRightArrow$1,
- Upsi: Upsi$1,
- Upsilon: Upsilon$1,
- Uring: Uring$1,
- Uscr: Uscr$1,
- Utilde: Utilde$1,
- Uum: Uum$1,
- Uuml: Uuml$1,
- VDash: VDash$1,
- Vbar: Vbar$1,
- Vcy: Vcy$1,
- Vdash: Vdash$1,
- Vdashl: Vdashl$1,
- Vee: Vee$1,
- Verbar: Verbar$1,
- Vert: Vert$1,
- VerticalBar: VerticalBar$1,
- VerticalLine: VerticalLine$1,
- VerticalSeparator: VerticalSeparator$1,
- VerticalTilde: VerticalTilde$1,
- VeryThinSpace: VeryThinSpace$1,
- Vfr: Vfr$1,
- Vopf: Vopf$1,
- Vscr: Vscr$1,
- Vvdash: Vvdash$1,
- Wcirc: Wcirc$1,
- Wedge: Wedge$1,
- Wfr: Wfr$1,
- Wopf: Wopf$1,
- Wscr: Wscr$1,
- Xfr: Xfr$1,
- Xi: Xi$1,
- Xopf: Xopf$1,
- Xscr: Xscr$1,
- YAcy: YAcy$1,
- YIcy: YIcy$1,
- YUcy: YUcy$1,
- Yacut: Yacut$1,
- Yacute: Yacute$1,
- Ycirc: Ycirc$1,
- Ycy: Ycy$1,
- Yfr: Yfr$1,
- Yopf: Yopf$1,
- Yscr: Yscr$1,
- Yuml: Yuml$1,
- ZHcy: ZHcy$1,
- Zacute: Zacute$1,
- Zcaron: Zcaron$1,
- Zcy: Zcy$1,
- Zdot: Zdot$1,
- ZeroWidthSpace: ZeroWidthSpace$1,
- Zeta: Zeta$1,
- Zfr: Zfr$1,
- Zopf: Zopf$1,
- Zscr: Zscr$1,
- aacut: aacut$1,
- aacute: aacute$1,
- abreve: abreve$1,
- ac: ac$1,
- acE: acE$1,
- acd: acd$1,
- acir: acir$1,
- acirc: acirc$1,
- acut: acut$1,
- acute: acute$1,
- acy: acy$1,
- aeli: aeli$1,
- aelig: aelig$1,
- af: af$1,
- afr: afr$1,
- agrav: agrav$1,
- agrave: agrave$1,
- alefsym: alefsym$1,
- aleph: aleph$1,
- alpha: alpha$1,
- amacr: amacr$1,
- amalg: amalg$1,
- am: am$1,
- amp: amp$1,
- and: and$1,
- andand: andand$1,
- andd: andd$1,
- andslope: andslope$1,
- andv: andv$1,
- ang: ang$1,
- ange: ange$1,
- angle: angle$1,
- angmsd: angmsd$1,
- angmsdaa: angmsdaa$1,
- angmsdab: angmsdab$1,
- angmsdac: angmsdac$1,
- angmsdad: angmsdad$1,
- angmsdae: angmsdae$1,
- angmsdaf: angmsdaf$1,
- angmsdag: angmsdag$1,
- angmsdah: angmsdah$1,
- angrt: angrt$1,
- angrtvb: angrtvb$1,
- angrtvbd: angrtvbd$1,
- angsph: angsph$1,
- angst: angst$1,
- angzarr: angzarr$1,
- aogon: aogon$1,
- aopf: aopf$1,
- ap: ap$1,
- apE: apE$1,
- apacir: apacir$1,
- ape: ape$1,
- apid: apid$1,
- apos: apos$1,
- approx: approx$1,
- approxeq: approxeq$1,
- arin: arin$1,
- aring: aring$1,
- ascr: ascr$1,
- ast: ast$1,
- asymp: asymp$1,
- asympeq: asympeq$1,
- atild: atild$1,
- atilde: atilde$1,
- aum: aum$1,
- auml: auml$1,
- awconint: awconint$1,
- awint: awint$1,
- bNot: bNot$1,
- backcong: backcong$1,
- backepsilon: backepsilon$1,
- backprime: backprime$1,
- backsim: backsim$1,
- backsimeq: backsimeq$1,
- barvee: barvee$1,
- barwed: barwed$1,
- barwedge: barwedge$1,
- bbrk: bbrk$1,
- bbrktbrk: bbrktbrk$1,
- bcong: bcong$1,
- bcy: bcy$1,
- bdquo: bdquo$1,
- becaus: becaus$1,
- because: because$1,
- bemptyv: bemptyv$1,
- bepsi: bepsi$1,
- bernou: bernou$1,
- beta: beta$1,
- beth: beth$1,
- between: between$1,
- bfr: bfr$1,
- bigcap: bigcap$1,
- bigcirc: bigcirc$1,
- bigcup: bigcup$1,
- bigodot: bigodot$1,
- bigoplus: bigoplus$1,
- bigotimes: bigotimes$1,
- bigsqcup: bigsqcup$1,
- bigstar: bigstar$1,
- bigtriangledown: bigtriangledown$1,
- bigtriangleup: bigtriangleup$1,
- biguplus: biguplus$1,
- bigvee: bigvee$1,
- bigwedge: bigwedge$1,
- bkarow: bkarow$1,
- blacklozenge: blacklozenge$1,
- blacksquare: blacksquare$1,
- blacktriangle: blacktriangle$1,
- blacktriangledown: blacktriangledown$1,
- blacktriangleleft: blacktriangleleft$1,
- blacktriangleright: blacktriangleright$1,
- blank: blank$1,
- blk12: blk12$1,
- blk14: blk14$1,
- blk34: blk34$1,
- block: block$1,
- bne: bne$1,
- bnequiv: bnequiv$1,
- bnot: bnot$1,
- bopf: bopf$1,
- bot: bot$1,
- bottom: bottom$1,
- bowtie: bowtie$1,
- boxDL: boxDL$1,
- boxDR: boxDR$1,
- boxDl: boxDl$1,
- boxDr: boxDr$1,
- boxH: boxH$1,
- boxHD: boxHD$1,
- boxHU: boxHU$1,
- boxHd: boxHd$1,
- boxHu: boxHu$1,
- boxUL: boxUL$1,
- boxUR: boxUR$1,
- boxUl: boxUl$1,
- boxUr: boxUr$1,
- boxV: boxV$1,
- boxVH: boxVH$1,
- boxVL: boxVL$1,
- boxVR: boxVR$1,
- boxVh: boxVh$1,
- boxVl: boxVl$1,
- boxVr: boxVr$1,
- boxbox: boxbox$1,
- boxdL: boxdL$1,
- boxdR: boxdR$1,
- boxdl: boxdl$1,
- boxdr: boxdr$1,
- boxh: boxh$1,
- boxhD: boxhD$1,
- boxhU: boxhU$1,
- boxhd: boxhd$1,
- boxhu: boxhu$1,
- boxminus: boxminus$1,
- boxplus: boxplus$1,
- boxtimes: boxtimes$1,
- boxuL: boxuL$1,
- boxuR: boxuR$1,
- boxul: boxul$1,
- boxur: boxur$1,
- boxv: boxv$1,
- boxvH: boxvH$1,
- boxvL: boxvL$1,
- boxvR: boxvR$1,
- boxvh: boxvh$1,
- boxvl: boxvl$1,
- boxvr: boxvr$1,
- bprime: bprime$1,
- breve: breve$1,
- brvba: brvba$1,
- brvbar: brvbar$1,
- bscr: bscr$1,
- bsemi: bsemi$1,
- bsim: bsim$1,
- bsime: bsime$1,
- bsol: bsol$1,
- bsolb: bsolb$1,
- bsolhsub: bsolhsub$1,
- bull: bull$1,
- bullet: bullet$1,
- bump: bump$1,
- bumpE: bumpE$1,
- bumpe: bumpe$1,
- bumpeq: bumpeq$1,
- cacute: cacute$1,
- cap: cap$1,
- capand: capand$1,
- capbrcup: capbrcup$1,
- capcap: capcap$1,
- capcup: capcup$1,
- capdot: capdot$1,
- caps: caps$1,
- caret: caret$1,
- caron: caron$1,
- ccaps: ccaps$1,
- ccaron: ccaron$1,
- ccedi: ccedi$1,
- ccedil: ccedil$1,
- ccirc: ccirc$1,
- ccups: ccups$1,
- ccupssm: ccupssm$1,
- cdot: cdot$1,
- cedi: cedi$1,
- cedil: cedil$1,
- cemptyv: cemptyv$1,
- cen: cen$1,
- cent: cent$1,
- centerdot: centerdot$1,
- cfr: cfr$1,
- chcy: chcy$1,
- check: check$2,
- checkmark: checkmark$1,
- chi: chi$1,
- cir: cir$1,
- cirE: cirE$1,
- circ: circ$1,
- circeq: circeq$1,
- circlearrowleft: circlearrowleft$1,
- circlearrowright: circlearrowright$1,
- circledR: circledR$1,
- circledS: circledS$1,
- circledast: circledast$1,
- circledcirc: circledcirc$1,
- circleddash: circleddash$1,
- cire: cire$1,
- cirfnint: cirfnint$1,
- cirmid: cirmid$1,
- cirscir: cirscir$1,
- clubs: clubs$1,
- clubsuit: clubsuit$1,
- colon: colon$1,
- colone: colone$1,
- coloneq: coloneq$1,
- comma: comma$1,
- commat: commat$1,
- comp: comp$1,
- compfn: compfn$1,
- complement: complement$1,
- complexes: complexes$1,
- cong: cong$1,
- congdot: congdot$1,
- conint: conint$1,
- copf: copf$1,
- coprod: coprod$1,
- cop: cop$1,
- copy: copy$1,
- copysr: copysr$1,
- crarr: crarr$1,
- cross: cross$1,
- cscr: cscr$1,
- csub: csub$1,
- csube: csube$1,
- csup: csup$1,
- csupe: csupe$1,
- ctdot: ctdot$1,
- cudarrl: cudarrl$1,
- cudarrr: cudarrr$1,
- cuepr: cuepr$1,
- cuesc: cuesc$1,
- cularr: cularr$1,
- cularrp: cularrp$1,
- cup: cup$1,
- cupbrcap: cupbrcap$1,
- cupcap: cupcap$1,
- cupcup: cupcup$1,
- cupdot: cupdot$1,
- cupor: cupor$1,
- cups: cups$1,
- curarr: curarr$1,
- curarrm: curarrm$1,
- curlyeqprec: curlyeqprec$1,
- curlyeqsucc: curlyeqsucc$1,
- curlyvee: curlyvee$1,
- curlywedge: curlywedge$1,
- curre: curre$1,
- curren: curren$1,
- curvearrowleft: curvearrowleft$1,
- curvearrowright: curvearrowright$1,
- cuvee: cuvee$1,
- cuwed: cuwed$1,
- cwconint: cwconint$1,
- cwint: cwint$1,
- cylcty: cylcty$1,
- dArr: dArr$1,
- dHar: dHar$1,
- dagger: dagger$1,
- daleth: daleth$1,
- darr: darr$1,
- dash: dash$1,
- dashv: dashv$1,
- dbkarow: dbkarow$1,
- dblac: dblac$1,
- dcaron: dcaron$1,
- dcy: dcy$1,
- dd: dd$1,
- ddagger: ddagger$1,
- ddarr: ddarr$1,
- ddotseq: ddotseq$1,
- de: de$1,
- deg: deg$1,
- delta: delta$1,
- demptyv: demptyv$1,
- dfisht: dfisht$1,
- dfr: dfr$1,
- dharl: dharl$1,
- dharr: dharr$1,
- diam: diam$1,
- diamond: diamond$1,
- diamondsuit: diamondsuit$1,
- diams: diams$1,
- die: die$1,
- digamma: digamma$1,
- disin: disin$1,
- div: div$1,
- divid: divid$1,
- divide: divide$1,
- divideontimes: divideontimes$1,
- divonx: divonx$1,
- djcy: djcy$1,
- dlcorn: dlcorn$1,
- dlcrop: dlcrop$1,
- dollar: dollar$1,
- dopf: dopf$1,
- dot: dot$1,
- doteq: doteq$1,
- doteqdot: doteqdot$1,
- dotminus: dotminus$1,
- dotplus: dotplus$1,
- dotsquare: dotsquare$1,
- doublebarwedge: doublebarwedge$1,
- downarrow: downarrow$1,
- downdownarrows: downdownarrows$1,
- downharpoonleft: downharpoonleft$1,
- downharpoonright: downharpoonright$1,
- drbkarow: drbkarow$1,
- drcorn: drcorn$1,
- drcrop: drcrop$1,
- dscr: dscr$1,
- dscy: dscy$1,
- dsol: dsol$1,
- dstrok: dstrok$1,
- dtdot: dtdot$1,
- dtri: dtri$1,
- dtrif: dtrif$1,
- duarr: duarr$1,
- duhar: duhar$1,
- dwangle: dwangle$1,
- dzcy: dzcy$1,
- dzigrarr: dzigrarr$1,
- eDDot: eDDot$1,
- eDot: eDot$1,
- eacut: eacut$1,
- eacute: eacute$1,
- easter: easter$1,
- ecaron: ecaron$1,
- ecir: ecir$1,
- ecirc: ecirc$1,
- ecolon: ecolon$1,
- ecy: ecy$1,
- edot: edot$1,
- ee: ee$1,
- efDot: efDot$1,
- efr: efr$1,
- eg: eg$1,
- egrav: egrav$1,
- egrave: egrave$1,
- egs: egs$1,
- egsdot: egsdot$1,
- el: el$1,
- elinters: elinters$1,
- ell: ell$1,
- els: els$1,
- elsdot: elsdot$1,
- emacr: emacr$1,
- empty: empty$1,
- emptyset: emptyset$1,
- emptyv: emptyv$1,
- emsp13: emsp13$1,
- emsp14: emsp14$1,
- emsp: emsp$1,
- eng: eng$1,
- ensp: ensp$1,
- eogon: eogon$1,
- eopf: eopf$1,
- epar: epar$1,
- eparsl: eparsl$1,
- eplus: eplus$1,
- epsi: epsi$1,
- epsilon: epsilon$1,
- epsiv: epsiv$1,
- eqcirc: eqcirc$1,
- eqcolon: eqcolon$1,
- eqsim: eqsim$1,
- eqslantgtr: eqslantgtr$1,
- eqslantless: eqslantless$1,
- equals: equals$1,
- equest: equest$1,
- equiv: equiv$1,
- equivDD: equivDD$1,
- eqvparsl: eqvparsl$1,
- erDot: erDot$1,
- erarr: erarr$1,
- escr: escr$1,
- esdot: esdot$1,
- esim: esim$1,
- eta: eta$1,
- et: et$1,
- eth: eth$1,
- eum: eum$1,
- euml: euml$1,
- euro: euro$1,
- excl: excl$1,
- exist: exist$1,
- expectation: expectation$1,
- exponentiale: exponentiale$1,
- fallingdotseq: fallingdotseq$1,
- fcy: fcy$1,
- female: female$1,
- ffilig: ffilig$1,
- fflig: fflig$1,
- ffllig: ffllig$1,
- ffr: ffr$1,
- filig: filig$1,
- fjlig: fjlig$1,
- flat: flat$1,
- fllig: fllig$1,
- fltns: fltns$1,
- fnof: fnof$1,
- fopf: fopf$1,
- forall: forall$1,
- fork: fork$1,
- forkv: forkv$1,
- fpartint: fpartint$1,
- frac1: frac1$1,
- frac12: frac12$1,
- frac13: frac13$1,
- frac14: frac14$1,
- frac15: frac15$1,
- frac16: frac16$1,
- frac18: frac18$1,
- frac23: frac23$1,
- frac25: frac25$1,
- frac3: frac3$1,
- frac34: frac34$1,
- frac35: frac35$1,
- frac38: frac38$1,
- frac45: frac45$1,
- frac56: frac56$1,
- frac58: frac58$1,
- frac78: frac78$1,
- frasl: frasl$1,
- frown: frown$1,
- fscr: fscr$1,
- gE: gE$1,
- gEl: gEl$1,
- gacute: gacute$1,
- gamma: gamma$1,
- gammad: gammad$1,
- gap: gap$1,
- gbreve: gbreve$1,
- gcirc: gcirc$1,
- gcy: gcy$1,
- gdot: gdot$1,
- ge: ge$1,
- gel: gel$1,
- geq: geq$1,
- geqq: geqq$1,
- geqslant: geqslant$1,
- ges: ges$1,
- gescc: gescc$1,
- gesdot: gesdot$1,
- gesdoto: gesdoto$1,
- gesdotol: gesdotol$1,
- gesl: gesl$1,
- gesles: gesles$1,
- gfr: gfr$1,
- gg: gg$1,
- ggg: ggg$1,
- gimel: gimel$1,
- gjcy: gjcy$1,
- gl: gl$1,
- glE: glE$1,
- gla: gla$1,
- glj: glj$1,
- gnE: gnE$1,
- gnap: gnap$1,
- gnapprox: gnapprox$1,
- gne: gne$1,
- gneq: gneq$1,
- gneqq: gneqq$1,
- gnsim: gnsim$1,
- gopf: gopf$1,
- grave: grave$1,
- gscr: gscr$1,
- gsim: gsim$1,
- gsime: gsime$1,
- gsiml: gsiml$1,
- g: g$1,
- gt: gt$1,
- gtcc: gtcc$1,
- gtcir: gtcir$1,
- gtdot: gtdot$1,
- gtlPar: gtlPar$1,
- gtquest: gtquest$1,
- gtrapprox: gtrapprox$1,
- gtrarr: gtrarr$1,
- gtrdot: gtrdot$1,
- gtreqless: gtreqless$1,
- gtreqqless: gtreqqless$1,
- gtrless: gtrless$1,
- gtrsim: gtrsim$1,
- gvertneqq: gvertneqq$1,
- gvnE: gvnE$1,
- hArr: hArr$1,
- hairsp: hairsp$1,
- half: half$1,
- hamilt: hamilt$1,
- hardcy: hardcy$1,
- harr: harr$1,
- harrcir: harrcir$1,
- harrw: harrw$1,
- hbar: hbar$1,
- hcirc: hcirc$1,
- hearts: hearts$1,
- heartsuit: heartsuit$1,
- hellip: hellip$1,
- hercon: hercon$1,
- hfr: hfr$1,
- hksearow: hksearow$1,
- hkswarow: hkswarow$1,
- hoarr: hoarr$1,
- homtht: homtht$1,
- hookleftarrow: hookleftarrow$1,
- hookrightarrow: hookrightarrow$1,
- hopf: hopf$1,
- horbar: horbar$1,
- hscr: hscr$1,
- hslash: hslash$1,
- hstrok: hstrok$1,
- hybull: hybull$1,
- hyphen: hyphen$1,
- iacut: iacut$1,
- iacute: iacute$1,
- ic: ic$1,
- icir: icir$1,
- icirc: icirc$1,
- icy: icy$1,
- iecy: iecy$1,
- iexc: iexc$1,
- iexcl: iexcl$1,
- iff: iff$1,
- ifr: ifr$1,
- igrav: igrav$1,
- igrave: igrave$1,
- ii: ii$1,
- iiiint: iiiint$1,
- iiint: iiint$1,
- iinfin: iinfin$1,
- iiota: iiota$1,
- ijlig: ijlig$1,
- imacr: imacr$1,
- image: image$2,
- imagline: imagline$1,
- imagpart: imagpart$1,
- imath: imath$1,
- imof: imof$1,
- imped: imped$1,
- "in": "∈",
- incare: incare$1,
- infin: infin$1,
- infintie: infintie$1,
- inodot: inodot$1,
- int: int$2,
- intcal: intcal$1,
- integers: integers$1,
- intercal: intercal$1,
- intlarhk: intlarhk$1,
- intprod: intprod$1,
- iocy: iocy$1,
- iogon: iogon$1,
- iopf: iopf$1,
- iota: iota$1,
- iprod: iprod$1,
- iques: iques$1,
- iquest: iquest$1,
- iscr: iscr$1,
- isin: isin$1,
- isinE: isinE$1,
- isindot: isindot$1,
- isins: isins$1,
- isinsv: isinsv$1,
- isinv: isinv$1,
- it: it$1,
- itilde: itilde$1,
- iukcy: iukcy$1,
- ium: ium$1,
- iuml: iuml$1,
- jcirc: jcirc$1,
- jcy: jcy$1,
- jfr: jfr$1,
- jmath: jmath$1,
- jopf: jopf$1,
- jscr: jscr$1,
- jsercy: jsercy$1,
- jukcy: jukcy$1,
- kappa: kappa$1,
- kappav: kappav$1,
- kcedil: kcedil$1,
- kcy: kcy$1,
- kfr: kfr$1,
- kgreen: kgreen$1,
- khcy: khcy$1,
- kjcy: kjcy$1,
- kopf: kopf$1,
- kscr: kscr$1,
- lAarr: lAarr$1,
- lArr: lArr$1,
- lAtail: lAtail$1,
- lBarr: lBarr$1,
- lE: lE$1,
- lEg: lEg$1,
- lHar: lHar$1,
- lacute: lacute$1,
- laemptyv: laemptyv$1,
- lagran: lagran$1,
- lambda: lambda$1,
- lang: lang$1,
- langd: langd$1,
- langle: langle$1,
- lap: lap$1,
- laqu: laqu$1,
- laquo: laquo$1,
- larr: larr$1,
- larrb: larrb$1,
- larrbfs: larrbfs$1,
- larrfs: larrfs$1,
- larrhk: larrhk$1,
- larrlp: larrlp$1,
- larrpl: larrpl$1,
- larrsim: larrsim$1,
- larrtl: larrtl$1,
- lat: lat$1,
- latail: latail$1,
- late: late$1,
- lates: lates$1,
- lbarr: lbarr$1,
- lbbrk: lbbrk$1,
- lbrace: lbrace$1,
- lbrack: lbrack$1,
- lbrke: lbrke$1,
- lbrksld: lbrksld$1,
- lbrkslu: lbrkslu$1,
- lcaron: lcaron$1,
- lcedil: lcedil$1,
- lceil: lceil$1,
- lcub: lcub$1,
- lcy: lcy$1,
- ldca: ldca$1,
- ldquo: ldquo$1,
- ldquor: ldquor$1,
- ldrdhar: ldrdhar$1,
- ldrushar: ldrushar$1,
- ldsh: ldsh$1,
- le: le$1,
- leftarrow: leftarrow$1,
- leftarrowtail: leftarrowtail$1,
- leftharpoondown: leftharpoondown$1,
- leftharpoonup: leftharpoonup$1,
- leftleftarrows: leftleftarrows$1,
- leftrightarrow: leftrightarrow$1,
- leftrightarrows: leftrightarrows$1,
- leftrightharpoons: leftrightharpoons$1,
- leftrightsquigarrow: leftrightsquigarrow$1,
- leftthreetimes: leftthreetimes$1,
- leg: leg$1,
- leq: leq$1,
- leqq: leqq$1,
- leqslant: leqslant$1,
- les: les$1,
- lescc: lescc$1,
- lesdot: lesdot$1,
- lesdoto: lesdoto$1,
- lesdotor: lesdotor$1,
- lesg: lesg$1,
- lesges: lesges$1,
- lessapprox: lessapprox$1,
- lessdot: lessdot$1,
- lesseqgtr: lesseqgtr$1,
- lesseqqgtr: lesseqqgtr$1,
- lessgtr: lessgtr$1,
- lesssim: lesssim$1,
- lfisht: lfisht$1,
- lfloor: lfloor$1,
- lfr: lfr$1,
- lg: lg$1,
- lgE: lgE$1,
- lhard: lhard$1,
- lharu: lharu$1,
- lharul: lharul$1,
- lhblk: lhblk$1,
- ljcy: ljcy$1,
- ll: ll$1,
- llarr: llarr$1,
- llcorner: llcorner$1,
- llhard: llhard$1,
- lltri: lltri$1,
- lmidot: lmidot$1,
- lmoust: lmoust$1,
- lmoustache: lmoustache$1,
- lnE: lnE$1,
- lnap: lnap$1,
- lnapprox: lnapprox$1,
- lne: lne$1,
- lneq: lneq$1,
- lneqq: lneqq$1,
- lnsim: lnsim$1,
- loang: loang$1,
- loarr: loarr$1,
- lobrk: lobrk$1,
- longleftarrow: longleftarrow$1,
- longleftrightarrow: longleftrightarrow$1,
- longmapsto: longmapsto$1,
- longrightarrow: longrightarrow$1,
- looparrowleft: looparrowleft$1,
- looparrowright: looparrowright$1,
- lopar: lopar$1,
- lopf: lopf$1,
- loplus: loplus$1,
- lotimes: lotimes$1,
- lowast: lowast$1,
- lowbar: lowbar$1,
- loz: loz$1,
- lozenge: lozenge$1,
- lozf: lozf$1,
- lpar: lpar$1,
- lparlt: lparlt$1,
- lrarr: lrarr$1,
- lrcorner: lrcorner$1,
- lrhar: lrhar$1,
- lrhard: lrhard$1,
- lrm: lrm$1,
- lrtri: lrtri$1,
- lsaquo: lsaquo$1,
- lscr: lscr$1,
- lsh: lsh$1,
- lsim: lsim$1,
- lsime: lsime$1,
- lsimg: lsimg$1,
- lsqb: lsqb$1,
- lsquo: lsquo$1,
- lsquor: lsquor$1,
- lstrok: lstrok$1,
- l: l$1,
- lt: lt$2,
- ltcc: ltcc$1,
- ltcir: ltcir$1,
- ltdot: ltdot$1,
- lthree: lthree$1,
- ltimes: ltimes$1,
- ltlarr: ltlarr$1,
- ltquest: ltquest$1,
- ltrPar: ltrPar$1,
- ltri: ltri$1,
- ltrie: ltrie$1,
- ltrif: ltrif$1,
- lurdshar: lurdshar$1,
- luruhar: luruhar$1,
- lvertneqq: lvertneqq$1,
- lvnE: lvnE$1,
- mDDot: mDDot$1,
- mac: mac$1,
- macr: macr$1,
- male: male$1,
- malt: malt$1,
- maltese: maltese$1,
- map: map$4,
- mapsto: mapsto$1,
- mapstodown: mapstodown$1,
- mapstoleft: mapstoleft$1,
- mapstoup: mapstoup$1,
- marker: marker$1,
- mcomma: mcomma$1,
- mcy: mcy$1,
- mdash: mdash$1,
- measuredangle: measuredangle$1,
- mfr: mfr$1,
- mho: mho$1,
- micr: micr$1,
- micro: micro$1,
- mid: mid$1,
- midast: midast$1,
- midcir: midcir$1,
- middo: middo$1,
- middot: middot$1,
- minus: minus$1,
- minusb: minusb$1,
- minusd: minusd$1,
- minusdu: minusdu$1,
- mlcp: mlcp$1,
- mldr: mldr$1,
- mnplus: mnplus$1,
- models: models$1,
- mopf: mopf$1,
- mp: mp$1,
- mscr: mscr$1,
- mstpos: mstpos$1,
- mu: mu$1,
- multimap: multimap$1,
- mumap: mumap$1,
- nGg: nGg$1,
- nGt: nGt$1,
- nGtv: nGtv$1,
- nLeftarrow: nLeftarrow$1,
- nLeftrightarrow: nLeftrightarrow$1,
- nLl: nLl$1,
- nLt: nLt$1,
- nLtv: nLtv$1,
- nRightarrow: nRightarrow$1,
- nVDash: nVDash$1,
- nVdash: nVdash$1,
- nabla: nabla$1,
- nacute: nacute$1,
- nang: nang$1,
- nap: nap$1,
- napE: napE$1,
- napid: napid$1,
- napos: napos$1,
- napprox: napprox$1,
- natur: natur$1,
- natural: natural$1,
- naturals: naturals$1,
- nbs: nbs$1,
- nbsp: nbsp$1,
- nbump: nbump$1,
- nbumpe: nbumpe$1,
- ncap: ncap$1,
- ncaron: ncaron$1,
- ncedil: ncedil$1,
- ncong: ncong$1,
- ncongdot: ncongdot$1,
- ncup: ncup$1,
- ncy: ncy$1,
- ndash: ndash$1,
- ne: ne$1,
- neArr: neArr$1,
- nearhk: nearhk$1,
- nearr: nearr$1,
- nearrow: nearrow$1,
- nedot: nedot$1,
- nequiv: nequiv$1,
- nesear: nesear$1,
- nesim: nesim$1,
- nexist: nexist$1,
- nexists: nexists$1,
- nfr: nfr$1,
- ngE: ngE$1,
- nge: nge$1,
- ngeq: ngeq$1,
- ngeqq: ngeqq$1,
- ngeqslant: ngeqslant$1,
- nges: nges$1,
- ngsim: ngsim$1,
- ngt: ngt$1,
- ngtr: ngtr$1,
- nhArr: nhArr$1,
- nharr: nharr$1,
- nhpar: nhpar$1,
- ni: ni$1,
- nis: nis$1,
- nisd: nisd$1,
- niv: niv$1,
- njcy: njcy$1,
- nlArr: nlArr$1,
- nlE: nlE$1,
- nlarr: nlarr$1,
- nldr: nldr$1,
- nle: nle$1,
- nleftarrow: nleftarrow$1,
- nleftrightarrow: nleftrightarrow$1,
- nleq: nleq$1,
- nleqq: nleqq$1,
- nleqslant: nleqslant$1,
- nles: nles$1,
- nless: nless$1,
- nlsim: nlsim$1,
- nlt: nlt$1,
- nltri: nltri$1,
- nltrie: nltrie$1,
- nmid: nmid$1,
- nopf: nopf$1,
- no: no$1,
- not: not$1,
- notin: notin$1,
- notinE: notinE$1,
- notindot: notindot$1,
- notinva: notinva$1,
- notinvb: notinvb$1,
- notinvc: notinvc$1,
- notni: notni$1,
- notniva: notniva$1,
- notnivb: notnivb$1,
- notnivc: notnivc$1,
- npar: npar$1,
- nparallel: nparallel$1,
- nparsl: nparsl$1,
- npart: npart$1,
- npolint: npolint$1,
- npr: npr$1,
- nprcue: nprcue$1,
- npre: npre$1,
- nprec: nprec$1,
- npreceq: npreceq$1,
- nrArr: nrArr$1,
- nrarr: nrarr$1,
- nrarrc: nrarrc$1,
- nrarrw: nrarrw$1,
- nrightarrow: nrightarrow$1,
- nrtri: nrtri$1,
- nrtrie: nrtrie$1,
- nsc: nsc$1,
- nsccue: nsccue$1,
- nsce: nsce$1,
- nscr: nscr$1,
- nshortmid: nshortmid$1,
- nshortparallel: nshortparallel$1,
- nsim: nsim$1,
- nsime: nsime$1,
- nsimeq: nsimeq$1,
- nsmid: nsmid$1,
- nspar: nspar$1,
- nsqsube: nsqsube$1,
- nsqsupe: nsqsupe$1,
- nsub: nsub$1,
- nsubE: nsubE$1,
- nsube: nsube$1,
- nsubset: nsubset$1,
- nsubseteq: nsubseteq$1,
- nsubseteqq: nsubseteqq$1,
- nsucc: nsucc$1,
- nsucceq: nsucceq$1,
- nsup: nsup$1,
- nsupE: nsupE$1,
- nsupe: nsupe$1,
- nsupset: nsupset$1,
- nsupseteq: nsupseteq$1,
- nsupseteqq: nsupseteqq$1,
- ntgl: ntgl$1,
- ntild: ntild$1,
- ntilde: ntilde$1,
- ntlg: ntlg$1,
- ntriangleleft: ntriangleleft$1,
- ntrianglelefteq: ntrianglelefteq$1,
- ntriangleright: ntriangleright$1,
- ntrianglerighteq: ntrianglerighteq$1,
- nu: nu$1,
- num: num$1,
- numero: numero$1,
- numsp: numsp$1,
- nvDash: nvDash$1,
- nvHarr: nvHarr$1,
- nvap: nvap$1,
- nvdash: nvdash$1,
- nvge: nvge$1,
- nvgt: nvgt$1,
- nvinfin: nvinfin$1,
- nvlArr: nvlArr$1,
- nvle: nvle$1,
- nvlt: nvlt$1,
- nvltrie: nvltrie$1,
- nvrArr: nvrArr$1,
- nvrtrie: nvrtrie$1,
- nvsim: nvsim$1,
- nwArr: nwArr$1,
- nwarhk: nwarhk$1,
- nwarr: nwarr$1,
- nwarrow: nwarrow$1,
- nwnear: nwnear$1,
- oS: oS$1,
- oacut: oacut$1,
- oacute: oacute$1,
- oast: oast$1,
- ocir: ocir$1,
- ocirc: ocirc$1,
- ocy: ocy$1,
- odash: odash$1,
- odblac: odblac$1,
- odiv: odiv$1,
- odot: odot$1,
- odsold: odsold$1,
- oelig: oelig$1,
- ofcir: ofcir$1,
- ofr: ofr$1,
- ogon: ogon$1,
- ograv: ograv$1,
- ograve: ograve$1,
- ogt: ogt$1,
- ohbar: ohbar$1,
- ohm: ohm$1,
- oint: oint$1,
- olarr: olarr$1,
- olcir: olcir$1,
- olcross: olcross$1,
- oline: oline$1,
- olt: olt$1,
- omacr: omacr$1,
- omega: omega$1,
- omicron: omicron$1,
- omid: omid$1,
- ominus: ominus$1,
- oopf: oopf$1,
- opar: opar$1,
- operp: operp$1,
- oplus: oplus$1,
- or: or$1,
- orarr: orarr$1,
- ord: ord$1,
- order: order$1,
- orderof: orderof$1,
- ordf: ordf$1,
- ordm: ordm$1,
- origof: origof$1,
- oror: oror$1,
- orslope: orslope$1,
- orv: orv$1,
- oscr: oscr$1,
- oslas: oslas$1,
- oslash: oslash$1,
- osol: osol$1,
- otild: otild$1,
- otilde: otilde$1,
- otimes: otimes$1,
- otimesas: otimesas$1,
- oum: oum$1,
- ouml: ouml$1,
- ovbar: ovbar$1,
- par: par$1,
- para: para$1,
- parallel: parallel$1,
- parsim: parsim$1,
- parsl: parsl$1,
- part: part$1,
- pcy: pcy$1,
- percnt: percnt$1,
- period: period$1,
- permil: permil$1,
- perp: perp$1,
- pertenk: pertenk$1,
- pfr: pfr$1,
- phi: phi$1,
- phiv: phiv$1,
- phmmat: phmmat$1,
- phone: phone$1,
- pi: pi$1,
- pitchfork: pitchfork$1,
- piv: piv$1,
- planck: planck$1,
- planckh: planckh$1,
- plankv: plankv$1,
- plus: plus$1,
- plusacir: plusacir$1,
- plusb: plusb$1,
- pluscir: pluscir$1,
- plusdo: plusdo$1,
- plusdu: plusdu$1,
- pluse: pluse$1,
- plusm: plusm$1,
- plusmn: plusmn$1,
- plussim: plussim$1,
- plustwo: plustwo$1,
- pm: pm$1,
- pointint: pointint$1,
- popf: popf$1,
- poun: poun$1,
- pound: pound$1,
- pr: pr$1,
- prE: prE$1,
- prap: prap$1,
- prcue: prcue$1,
- pre: pre$1,
- prec: prec$1,
- precapprox: precapprox$1,
- preccurlyeq: preccurlyeq$1,
- preceq: preceq$1,
- precnapprox: precnapprox$1,
- precneqq: precneqq$1,
- precnsim: precnsim$1,
- precsim: precsim$1,
- prime: prime$1,
- primes: primes$1,
- prnE: prnE$1,
- prnap: prnap$1,
- prnsim: prnsim$1,
- prod: prod$1,
- profalar: profalar$1,
- profline: profline$1,
- profsurf: profsurf$1,
- prop: prop$1,
- propto: propto$1,
- prsim: prsim$1,
- prurel: prurel$1,
- pscr: pscr$1,
- psi: psi$1,
- puncsp: puncsp$1,
- qfr: qfr$1,
- qint: qint$1,
- qopf: qopf$1,
- qprime: qprime$1,
- qscr: qscr$1,
- quaternions: quaternions$1,
- quatint: quatint$1,
- quest: quest$1,
- questeq: questeq$1,
- quo: quo$1,
- quot: quot$1,
- rAarr: rAarr$1,
- rArr: rArr$1,
- rAtail: rAtail$1,
- rBarr: rBarr$1,
- rHar: rHar$1,
- race: race$1,
- racute: racute$1,
- radic: radic$1,
- raemptyv: raemptyv$1,
- rang: rang$1,
- rangd: rangd$1,
- range: range$1,
- rangle: rangle$1,
- raqu: raqu$1,
- raquo: raquo$1,
- rarr: rarr$1,
- rarrap: rarrap$1,
- rarrb: rarrb$1,
- rarrbfs: rarrbfs$1,
- rarrc: rarrc$1,
- rarrfs: rarrfs$1,
- rarrhk: rarrhk$1,
- rarrlp: rarrlp$1,
- rarrpl: rarrpl$1,
- rarrsim: rarrsim$1,
- rarrtl: rarrtl$1,
- rarrw: rarrw$1,
- ratail: ratail$1,
- ratio: ratio$1,
- rationals: rationals$1,
- rbarr: rbarr$1,
- rbbrk: rbbrk$1,
- rbrace: rbrace$1,
- rbrack: rbrack$1,
- rbrke: rbrke$1,
- rbrksld: rbrksld$1,
- rbrkslu: rbrkslu$1,
- rcaron: rcaron$1,
- rcedil: rcedil$1,
- rceil: rceil$1,
- rcub: rcub$1,
- rcy: rcy$1,
- rdca: rdca$1,
- rdldhar: rdldhar$1,
- rdquo: rdquo$1,
- rdquor: rdquor$1,
- rdsh: rdsh$1,
- real: real$1,
- realine: realine$1,
- realpart: realpart$1,
- reals: reals$1,
- rect: rect$1,
- re: re$5,
- reg: reg$1,
- rfisht: rfisht$1,
- rfloor: rfloor$1,
- rfr: rfr$1,
- rhard: rhard$1,
- rharu: rharu$1,
- rharul: rharul$1,
- rho: rho$1,
- rhov: rhov$1,
- rightarrow: rightarrow$1,
- rightarrowtail: rightarrowtail$1,
- rightharpoondown: rightharpoondown$1,
- rightharpoonup: rightharpoonup$1,
- rightleftarrows: rightleftarrows$1,
- rightleftharpoons: rightleftharpoons$1,
- rightrightarrows: rightrightarrows$1,
- rightsquigarrow: rightsquigarrow$1,
- rightthreetimes: rightthreetimes$1,
- ring: ring$1,
- risingdotseq: risingdotseq$1,
- rlarr: rlarr$1,
- rlhar: rlhar$1,
- rlm: rlm$1,
- rmoust: rmoust$1,
- rmoustache: rmoustache$1,
- rnmid: rnmid$1,
- roang: roang$1,
- roarr: roarr$1,
- robrk: robrk$1,
- ropar: ropar$1,
- ropf: ropf$1,
- roplus: roplus$1,
- rotimes: rotimes$1,
- rpar: rpar$1,
- rpargt: rpargt$1,
- rppolint: rppolint$1,
- rrarr: rrarr$1,
- rsaquo: rsaquo$1,
- rscr: rscr$1,
- rsh: rsh$1,
- rsqb: rsqb$1,
- rsquo: rsquo$1,
- rsquor: rsquor$1,
- rthree: rthree$1,
- rtimes: rtimes$1,
- rtri: rtri$1,
- rtrie: rtrie$1,
- rtrif: rtrif$1,
- rtriltri: rtriltri$1,
- ruluhar: ruluhar$1,
- rx: rx$1,
- sacute: sacute$1,
- sbquo: sbquo$1,
- sc: sc$1,
- scE: scE$1,
- scap: scap$1,
- scaron: scaron$1,
- sccue: sccue$1,
- sce: sce$1,
- scedil: scedil$1,
- scirc: scirc$1,
- scnE: scnE$1,
- scnap: scnap$1,
- scnsim: scnsim$1,
- scpolint: scpolint$1,
- scsim: scsim$1,
- scy: scy$1,
- sdot: sdot$1,
- sdotb: sdotb$1,
- sdote: sdote$1,
- seArr: seArr$1,
- searhk: searhk$1,
- searr: searr$1,
- searrow: searrow$1,
- sec: sec$1,
- sect: sect$1,
- semi: semi$1,
- seswar: seswar$1,
- setminus: setminus$1,
- setmn: setmn$1,
- sext: sext$1,
- sfr: sfr$1,
- sfrown: sfrown$1,
- sharp: sharp$1,
- shchcy: shchcy$1,
- shcy: shcy$1,
- shortmid: shortmid$1,
- shortparallel: shortparallel$1,
- sh: sh$1,
- shy: shy$1,
- sigma: sigma$1,
- sigmaf: sigmaf$1,
- sigmav: sigmav$1,
- sim: sim$1,
- simdot: simdot$1,
- sime: sime$1,
- simeq: simeq$1,
- simg: simg$1,
- simgE: simgE$1,
- siml: siml$1,
- simlE: simlE$1,
- simne: simne$1,
- simplus: simplus$1,
- simrarr: simrarr$1,
- slarr: slarr$1,
- smallsetminus: smallsetminus$1,
- smashp: smashp$1,
- smeparsl: smeparsl$1,
- smid: smid$1,
- smile: smile$1,
- smt: smt$1,
- smte: smte$1,
- smtes: smtes$1,
- softcy: softcy$1,
- sol: sol$1,
- solb: solb$1,
- solbar: solbar$1,
- sopf: sopf$1,
- spades: spades$1,
- spadesuit: spadesuit$1,
- spar: spar$1,
- sqcap: sqcap$1,
- sqcaps: sqcaps$1,
- sqcup: sqcup$1,
- sqcups: sqcups$1,
- sqsub: sqsub$1,
- sqsube: sqsube$1,
- sqsubset: sqsubset$1,
- sqsubseteq: sqsubseteq$1,
- sqsup: sqsup$1,
- sqsupe: sqsupe$1,
- sqsupset: sqsupset$1,
- sqsupseteq: sqsupseteq$1,
- squ: squ$1,
- square: square$1,
- squarf: squarf$1,
- squf: squf$1,
- srarr: srarr$1,
- sscr: sscr$1,
- ssetmn: ssetmn$1,
- ssmile: ssmile$1,
- sstarf: sstarf$1,
- star: star$1,
- starf: starf$1,
- straightepsilon: straightepsilon$1,
- straightphi: straightphi$1,
- strns: strns$1,
- sub: sub$1,
- subE: subE$1,
- subdot: subdot$1,
- sube: sube$1,
- subedot: subedot$1,
- submult: submult$1,
- subnE: subnE$1,
- subne: subne$1,
- subplus: subplus$1,
- subrarr: subrarr$1,
- subset: subset$1,
- subseteq: subseteq$1,
- subseteqq: subseteqq$1,
- subsetneq: subsetneq$1,
- subsetneqq: subsetneqq$1,
- subsim: subsim$1,
- subsub: subsub$1,
- subsup: subsup$1,
- succ: succ$1,
- succapprox: succapprox$1,
- succcurlyeq: succcurlyeq$1,
- succeq: succeq$1,
- succnapprox: succnapprox$1,
- succneqq: succneqq$1,
- succnsim: succnsim$1,
- succsim: succsim$1,
- sum: sum$1,
- sung: sung$1,
- sup: sup$1,
- sup1: sup1$1,
- sup2: sup2$1,
- sup3: sup3$1,
- supE: supE$1,
- supdot: supdot$1,
- supdsub: supdsub$1,
- supe: supe$1,
- supedot: supedot$1,
- suphsol: suphsol$1,
- suphsub: suphsub$1,
- suplarr: suplarr$1,
- supmult: supmult$1,
- supnE: supnE$1,
- supne: supne$1,
- supplus: supplus$1,
- supset: supset$1,
- supseteq: supseteq$1,
- supseteqq: supseteqq$1,
- supsetneq: supsetneq$1,
- supsetneqq: supsetneqq$1,
- supsim: supsim$1,
- supsub: supsub$1,
- supsup: supsup$1,
- swArr: swArr$1,
- swarhk: swarhk$1,
- swarr: swarr$1,
- swarrow: swarrow$1,
- swnwar: swnwar$1,
- szli: szli$1,
- szlig: szlig$1,
- target: target$1,
- tau: tau$1,
- tbrk: tbrk$1,
- tcaron: tcaron$1,
- tcedil: tcedil$1,
- tcy: tcy$1,
- tdot: tdot$1,
- telrec: telrec$1,
- tfr: tfr$1,
- there4: there4$1,
- therefore: therefore$1,
- theta: theta$1,
- thetasym: thetasym$1,
- thetav: thetav$1,
- thickapprox: thickapprox$1,
- thicksim: thicksim$1,
- thinsp: thinsp$1,
- thkap: thkap$1,
- thksim: thksim$1,
- thor: thor$1,
- thorn: thorn$1,
- tilde: tilde$1,
- time: time$1,
- times: times$1,
- timesb: timesb$1,
- timesbar: timesbar$1,
- timesd: timesd$1,
- tint: tint$1,
- toea: toea$1,
- top: top$1,
- topbot: topbot$1,
- topcir: topcir$1,
- topf: topf$1,
- topfork: topfork$1,
- tosa: tosa$1,
- tprime: tprime$1,
- trade: trade$1,
- triangle: triangle$1,
- triangledown: triangledown$1,
- triangleleft: triangleleft$1,
- trianglelefteq: trianglelefteq$1,
- triangleq: triangleq$1,
- triangleright: triangleright$1,
- trianglerighteq: trianglerighteq$1,
- tridot: tridot$1,
- trie: trie$1,
- triminus: triminus$1,
- triplus: triplus$1,
- trisb: trisb$1,
- tritime: tritime$1,
- trpezium: trpezium$1,
- tscr: tscr$1,
- tscy: tscy$1,
- tshcy: tshcy$1,
- tstrok: tstrok$1,
- twixt: twixt$1,
- twoheadleftarrow: twoheadleftarrow$1,
- twoheadrightarrow: twoheadrightarrow$1,
- uArr: uArr$1,
- uHar: uHar$1,
- uacut: uacut$1,
- uacute: uacute$1,
- uarr: uarr$1,
- ubrcy: ubrcy$1,
- ubreve: ubreve$1,
- ucir: ucir$1,
- ucirc: ucirc$1,
- ucy: ucy$1,
- udarr: udarr$1,
- udblac: udblac$1,
- udhar: udhar$1,
- ufisht: ufisht$1,
- ufr: ufr$1,
- ugrav: ugrav$1,
- ugrave: ugrave$1,
- uharl: uharl$1,
- uharr: uharr$1,
- uhblk: uhblk$1,
- ulcorn: ulcorn$1,
- ulcorner: ulcorner$1,
- ulcrop: ulcrop$1,
- ultri: ultri$1,
- umacr: umacr$1,
- um: um$1,
- uml: uml$1,
- uogon: uogon$1,
- uopf: uopf$1,
- uparrow: uparrow$1,
- updownarrow: updownarrow$1,
- upharpoonleft: upharpoonleft$1,
- upharpoonright: upharpoonright$1,
- uplus: uplus$1,
- upsi: upsi$1,
- upsih: upsih$1,
- upsilon: upsilon$1,
- upuparrows: upuparrows$1,
- urcorn: urcorn$1,
- urcorner: urcorner$1,
- urcrop: urcrop$1,
- uring: uring$1,
- urtri: urtri$1,
- uscr: uscr$1,
- utdot: utdot$1,
- utilde: utilde$1,
- utri: utri$1,
- utrif: utrif$1,
- uuarr: uuarr$1,
- uum: uum$1,
- uuml: uuml$1,
- uwangle: uwangle$1,
- vArr: vArr$1,
- vBar: vBar$1,
- vBarv: vBarv$1,
- vDash: vDash$1,
- vangrt: vangrt$1,
- varepsilon: varepsilon$1,
- varkappa: varkappa$1,
- varnothing: varnothing$1,
- varphi: varphi$1,
- varpi: varpi$1,
- varpropto: varpropto$1,
- varr: varr$1,
- varrho: varrho$1,
- varsigma: varsigma$1,
- varsubsetneq: varsubsetneq$1,
- varsubsetneqq: varsubsetneqq$1,
- varsupsetneq: varsupsetneq$1,
- varsupsetneqq: varsupsetneqq$1,
- vartheta: vartheta$1,
- vartriangleleft: vartriangleleft$1,
- vartriangleright: vartriangleright$1,
- vcy: vcy$1,
- vdash: vdash$1,
- vee: vee$1,
- veebar: veebar$1,
- veeeq: veeeq$1,
- vellip: vellip$1,
- verbar: verbar$1,
- vert: vert$1,
- vfr: vfr$1,
- vltri: vltri$1,
- vnsub: vnsub$1,
- vnsup: vnsup$1,
- vopf: vopf$1,
- vprop: vprop$1,
- vrtri: vrtri$1,
- vscr: vscr$1,
- vsubnE: vsubnE$1,
- vsubne: vsubne$1,
- vsupnE: vsupnE$1,
- vsupne: vsupne$1,
- vzigzag: vzigzag$1,
- wcirc: wcirc$1,
- wedbar: wedbar$1,
- wedge: wedge$1,
- wedgeq: wedgeq$1,
- weierp: weierp$1,
- wfr: wfr$1,
- wopf: wopf$1,
- wp: wp$1,
- wr: wr$1,
- wreath: wreath$1,
- wscr: wscr$1,
- xcap: xcap$1,
- xcirc: xcirc$1,
- xcup: xcup$1,
- xdtri: xdtri$1,
- xfr: xfr$1,
- xhArr: xhArr$1,
- xharr: xharr$1,
- xi: xi$1,
- xlArr: xlArr$1,
- xlarr: xlarr$1,
- xmap: xmap$1,
- xnis: xnis$1,
- xodot: xodot$1,
- xopf: xopf$1,
- xoplus: xoplus$1,
- xotime: xotime$1,
- xrArr: xrArr$1,
- xrarr: xrarr$1,
- xscr: xscr$1,
- xsqcup: xsqcup$1,
- xuplus: xuplus$1,
- xutri: xutri$1,
- xvee: xvee$1,
- xwedge: xwedge$1,
- yacut: yacut$1,
- yacute: yacute$1,
- yacy: yacy$1,
- ycirc: ycirc$1,
- ycy: ycy$1,
- ye: ye$1,
- yen: yen$1,
- yfr: yfr$1,
- yicy: yicy$1,
- yopf: yopf$1,
- yscr: yscr$1,
- yucy: yucy$1,
- yum: yum$1,
- yuml: yuml$1,
- zacute: zacute$1,
- zcaron: zcaron$1,
- zcy: zcy$1,
- zdot: zdot$1,
- zeetrf: zeetrf$1,
- zeta: zeta$1,
- zfr: zfr$1,
- zhcy: zhcy$1,
- zigrarr: zigrarr$1,
- zopf: zopf$1,
- zscr: zscr$1,
- zwj: zwj$1,
- zwnj: zwnj$1
-};
-
-var characterEntities$1 = require$$0$1;
-
-var decodeEntity_1$1 = decodeEntity$1;
+/**
+ * Turn the number (in string form as either hexa- or plain decimal) coming from
+ * a numeric character reference into a character.
+ *
+ * @param {string} value
+ * Value to decode.
+ * @param {number} base
+ * Numeric base.
+ * @returns {string}
+ */
+function decodeNumericCharacterReference(value, base) {
+ const code = Number.parseInt(value, base);
-var own$8 = {}.hasOwnProperty;
+ if (
+ // C0 except for HT, LF, FF, CR, space
+ code < 9 ||
+ code === 11 ||
+ (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.
+ (code > 126 && code < 160) || // Lone high surrogates and low surrogates.
+ (code > 55295 && code < 57344) || // Noncharacters.
+ (code > 64975 && code < 65008) ||
+ (code & 65535) === 65535 ||
+ (code & 65535) === 65534 || // Out of range
+ code > 1114111
+ ) {
+ return '\uFFFD'
+ }
-function decodeEntity$1(characters) {
- return own$8.call(characterEntities$1, characters)
- ? characterEntities$1[characters]
- : false
+ return String.fromCharCode(code)
}
-var dist = fromMarkdown$1;
-
-// These three are compiled away in the `dist/`
+/**
+ * @typedef {import('micromark-util-types').Encoding} Encoding
+ * @typedef {import('micromark-util-types').Event} Event
+ * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
+ * @typedef {import('micromark-util-types').Token} Token
+ * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
+ * @typedef {import('micromark-util-types').Value} Value
+ * @typedef {Root|Root['children'][number]} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist').Point} Point
+ * @typedef {import('mdast').Break} Break
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('mdast').Definition} Definition
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('mdast').HTML} HTML
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('mdast').List} List
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('mdast').Text} Text
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ */
+const own$4 = {}.hasOwnProperty;
+/**
+ * @param value Markdown to parse (`string` or `Buffer`).
+ * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).
+ * @param [options] Configuration
+ */
-var toString$4 = mdastUtilToString$1;
-var assign = assign_1;
-var own$7 = hasOwnProperty$2;
-var normalizeIdentifier$1 = normalizeIdentifier_1;
-var safeFromInt = safeFromInt_1;
-var parser = parse_1$1;
-var preprocessor = preprocess_1;
-var postprocess = postprocess_1;
-var decode$1 = decodeEntity_1$1;
-var stringifyPosition$2 = unistUtilStringifyPosition;
+const fromMarkdown =
+ /**
+ * @type {(
+ * ((value: Value, encoding: Encoding, options?: Options) => Root) &
+ * ((value: Value, options?: Options) => Root)
+ * )}
+ */
-function fromMarkdown$1(value, encoding, options) {
- if (typeof encoding !== 'string') {
- options = encoding;
- encoding = undefined;
- }
+ /**
+ * @param {Value} value
+ * @param {Encoding} [encoding]
+ * @param {Options} [options]
+ * @returns {Root}
+ */
+ function (value, encoding, options) {
+ if (typeof encoding !== 'string') {
+ options = encoding;
+ encoding = undefined;
+ }
- return compiler(options)(
- postprocess(
- parser(options).document().write(preprocessor()(value, encoding, true))
+ return compiler(options)(
+ postprocess(
+ parse(options).document().write(preprocess()(value, encoding, true))
+ )
)
- )
-}
+ };
+/**
+ * Note this compiler only understand complete buffering, not streaming.
+ *
+ * @param {Options} [options]
+ */
-// Note this compiler only understand complete buffering, not streaming.
-function compiler(options) {
- var settings = options || {};
- var config = configure$2(
+function compiler(options = {}) {
+ /** @type {NormalizedExtension} */
+ // @ts-expect-error: our base has all required fields, so the result will too.
+ const config = configure$1(
{
transforms: [],
canContainEols: [
@@ -42699,7 +42415,6 @@ function compiler(options) {
'paragraph',
'strong'
],
-
enter: {
autolink: opener(link),
autolinkProtocol: onenterdata,
@@ -42743,7 +42458,6 @@ function compiler(options) {
strong: opener(strong),
thematicBreak: opener(thematicBreak)
},
-
exit: {
atxHeading: closer(),
atxHeadingSequence: onexitatxheadingsequence,
@@ -42795,34 +42509,46 @@ function compiler(options) {
thematicBreak: closer()
}
},
-
- settings.mdastExtensions || []
+ options.mdastExtensions || []
);
+ /** @type {CompileData} */
- var data = {};
-
+ const data = {};
return compile
+ /**
+ * @param {Array.<Event>} events
+ * @returns {Root}
+ */
function compile(events) {
- var tree = {type: 'root', children: []};
- var stack = [tree];
- var tokenStack = [];
- var listStack = [];
- var index = -1;
- var handler;
- var listStart;
-
- var context = {
- stack: stack,
- tokenStack: tokenStack,
- config: config,
- enter: enter,
- exit: exit,
- buffer: buffer,
- resume: resume,
- setData: setData,
- getData: getData
+ /** @type {Root} */
+ let tree = {
+ type: 'root',
+ children: []
};
+ /** @type {CompileContext['stack']} */
+
+ const stack = [tree];
+ /** @type {CompileContext['tokenStack']} */
+
+ const tokenStack = [];
+ /** @type {Array.<number>} */
+
+ const listStack = [];
+ /** @type {Omit<CompileContext, 'sliceSerialize'>} */
+
+ const context = {
+ stack,
+ tokenStack,
+ config,
+ enter,
+ exit,
+ buffer,
+ resume,
+ setData,
+ getData
+ };
+ let index = -1;
while (++index < events.length) {
// We preprocess lists to add `listItem` tokens, and to infer whether
@@ -42834,8 +42560,8 @@ function compiler(options) {
if (events[index][0] === 'enter') {
listStack.push(index);
} else {
- listStart = listStack.pop(index);
- index = prepareList(events, listStart, index);
+ const tail = listStack.pop();
+ index = prepareList(events, tail, index);
}
}
}
@@ -42843,64 +42569,88 @@ function compiler(options) {
index = -1;
while (++index < events.length) {
- handler = config[events[index][0]];
+ const handler = config[events[index][0]];
- if (own$7.call(handler, events[index][1].type)) {
+ if (own$4.call(handler, events[index][1].type)) {
handler[events[index][1].type].call(
- assign({sliceSerialize: events[index][2].sliceSerialize}, context),
+ Object.assign(
+ {
+ sliceSerialize: events[index][2].sliceSerialize
+ },
+ context
+ ),
events[index][1]
);
}
}
- if (tokenStack.length) {
+ if (tokenStack.length > 0) {
throw new Error(
'Cannot close document, a token (`' +
tokenStack[tokenStack.length - 1].type +
'`, ' +
- stringifyPosition$2({
+ stringifyPosition$1({
start: tokenStack[tokenStack.length - 1].start,
end: tokenStack[tokenStack.length - 1].end
}) +
') is still open'
)
- }
+ } // Figure out `root` position.
- // Figure out `root` position.
tree.position = {
start: point(
- events.length ? events[0][1].start : {line: 1, column: 1, offset: 0}
+ events.length > 0
+ ? events[0][1].start
+ : {
+ line: 1,
+ column: 1,
+ offset: 0
+ }
),
-
end: point(
- events.length
+ events.length > 0
? events[events.length - 2][1].end
- : {line: 1, column: 1, offset: 0}
+ : {
+ line: 1,
+ column: 1,
+ offset: 0
+ }
)
};
-
index = -1;
+
while (++index < config.transforms.length) {
tree = config.transforms[index](tree) || tree;
}
return tree
}
+ /**
+ * @param {Array.<Event>} events
+ * @param {number} start
+ * @param {number} length
+ * @returns {number}
+ */
function prepareList(events, start, length) {
- var index = start - 1;
- var containerBalance = -1;
- var listSpread = false;
- var listItem;
- var tailIndex;
- var lineIndex;
- var tailEvent;
- var event;
- var firstBlankLineIndex;
- var atMarker;
+ let index = start - 1;
+ let containerBalance = -1;
+ let listSpread = false;
+ /** @type {Token|undefined} */
+
+ let listItem;
+ /** @type {number|undefined} */
+
+ let lineIndex;
+ /** @type {number|undefined} */
+
+ let firstBlankLineIndex;
+ /** @type {boolean|undefined} */
+
+ let atMarker;
while (++index <= length) {
- event = events[index];
+ const event = events[index];
if (
event[1].type === 'listUnordered' ||
@@ -42947,11 +42697,11 @@ function compiler(options) {
event[1].type === 'listOrdered'))
) {
if (listItem) {
- tailIndex = index;
+ let tailIndex = index;
lineIndex = undefined;
while (tailIndex--) {
- tailEvent = events[tailIndex];
+ const tailEvent = events[tailIndex];
if (
tailEvent[1].type === 'lineEnding' ||
@@ -42981,26 +42731,26 @@ function compiler(options) {
firstBlankLineIndex &&
(!lineIndex || firstBlankLineIndex < lineIndex)
) {
+ // @ts-expect-error Patched.
listItem._spread = true;
- }
+ } // Fix position.
- // Fix position.
- listItem.end = point(
+ listItem.end = Object.assign(
+ {},
lineIndex ? events[lineIndex][1].start : event[1].end
);
-
events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);
index++;
length++;
- }
+ } // Create a new list item.
- // Create a new list item.
if (event[1].type === 'listItemPrefix') {
listItem = {
type: 'listItem',
+ // @ts-expect-error Patched
_spread: false,
- start: point(event[1].start)
- };
+ start: Object.assign({}, event[1].start)
+ }; // @ts-expect-error: `listItem` is most definitely defined, TS...
events.splice(index, 0, ['enter', listItem, event[2]]);
index++;
@@ -43009,64 +42759,124 @@ function compiler(options) {
atMarker = true;
}
}
- }
+ } // @ts-expect-error Patched.
events[start][1]._spread = listSpread;
return length
}
+ /**
+ * @type {CompileContext['setData']}
+ * @param [value]
+ */
function setData(key, value) {
data[key] = value;
}
+ /**
+ * @type {CompileContext['getData']}
+ * @template {string} K
+ * @param {K} key
+ * @returns {CompileData[K]}
+ */
function getData(key) {
return data[key]
}
+ /**
+ * @param {Point} d
+ * @returns {Point}
+ */
function point(d) {
- return {line: d.line, column: d.column, offset: d.offset}
+ return {
+ line: d.line,
+ column: d.column,
+ offset: d.offset
+ }
}
+ /**
+ * @param {(token: Token) => Node} create
+ * @param {Handle} [and]
+ * @returns {Handle}
+ */
function opener(create, and) {
return open
+ /**
+ * @this {CompileContext}
+ * @param {Token} token
+ * @returns {void}
+ */
function open(token) {
enter.call(this, create(token), token);
if (and) and.call(this, token);
}
}
+ /** @type {CompileContext['buffer']} */
function buffer() {
- this.stack.push({type: 'fragment', children: []});
+ // @ts-expect-error: Custom node type to collect text.
+ this.stack.push({
+ type: 'fragment',
+ children: []
+ });
}
+ /**
+ * @type {CompileContext['enter']}
+ * @template {Node} N
+ * @this {CompileContext}
+ * @param {N} node
+ * @param {Token} token
+ * @returns {N}
+ */
function enter(node, token) {
- this.stack[this.stack.length - 1].children.push(node);
+ /** @type {Parent} */
+ // @ts-expect-error: Assume parent.
+ const parent = this.stack[this.stack.length - 1];
+ parent.children.push(node);
this.stack.push(node);
- this.tokenStack.push(token);
- node.position = {start: point(token.start)};
+ this.tokenStack.push(token); // @ts-expect-error: `end` will be patched later.
+
+ node.position = {
+ start: point(token.start)
+ };
return node
}
+ /**
+ * @param {Handle} [and]
+ * @returns {Handle}
+ */
function closer(and) {
return close
+ /**
+ * @this {CompileContext}
+ * @param {Token} token
+ * @returns {void}
+ */
function close(token) {
if (and) and.call(this, token);
exit.call(this, token);
}
}
+ /** @type {CompileContext['exit']} */
function exit(token) {
- var node = this.stack.pop();
- var open = this.tokenStack.pop();
+ const node = this.stack.pop();
+ const open = this.tokenStack.pop();
if (!open) {
throw new Error(
'Cannot close `' +
token.type +
'` (' +
- stringifyPosition$2({start: token.start, end: token.end}) +
+ stringifyPosition$1({
+ start: token.start,
+ end: token.end
+ }) +
'): it’s not open'
)
} else if (open.type !== token.type) {
@@ -43074,11 +42884,17 @@ function compiler(options) {
'Cannot close `' +
token.type +
'` (' +
- stringifyPosition$2({start: token.start, end: token.end}) +
+ stringifyPosition$1({
+ start: token.start,
+ end: token.end
+ }) +
'): a different token (`' +
open.type +
'`, ' +
- stringifyPosition$2({start: open.start, end: open.end}) +
+ stringifyPosition$1({
+ start: open.start,
+ end: open.end
+ }) +
') is open'
)
}
@@ -43086,39 +42902,46 @@ function compiler(options) {
node.position.end = point(token.end);
return node
}
+ /**
+ * @this {CompileContext}
+ * @returns {string}
+ */
function resume() {
- return toString$4(this.stack.pop())
- }
-
- //
+ return toString(this.stack.pop())
+ } //
// Handlers.
//
+ /** @type {Handle} */
+
function onenterlistordered() {
setData('expectingFirstListItemValue', true);
}
+ /** @type {Handle} */
function onenterlistitemvalue(token) {
if (getData('expectingFirstListItemValue')) {
- this.stack[this.stack.length - 2].start = parseInt(
+ this.stack[this.stack.length - 2].start = Number.parseInt(
this.sliceSerialize(token),
10
);
-
setData('expectingFirstListItemValue');
}
}
+ /** @type {Handle} */
function onexitcodefencedfenceinfo() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].lang = data;
}
+ /** @type {Handle} */
function onexitcodefencedfencemeta() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].meta = data;
}
+ /** @type {Handle} */
function onexitcodefencedfence() {
// Exit if this is the closing fence.
@@ -43126,127 +42949,149 @@ function compiler(options) {
this.buffer();
setData('flowCodeInside', true);
}
+ /** @type {Handle} */
function onexitcodefenced() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].value = data.replace(
/^(\r?\n|\r)|(\r?\n|\r)$/g,
''
);
-
setData('flowCodeInside');
}
+ /** @type {Handle} */
function onexitcodeindented() {
- var data = this.resume();
- this.stack[this.stack.length - 1].value = data;
+ const data = this.resume();
+ this.stack[this.stack.length - 1].value = data.replace(/(\r?\n|\r)$/g, '');
}
+ /** @type {Handle} */
function onexitdefinitionlabelstring(token) {
// Discard label, use the source content instead.
- var label = this.resume();
+ const label = this.resume();
this.stack[this.stack.length - 1].label = label;
- this.stack[this.stack.length - 1].identifier = normalizeIdentifier$1(
+ this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
}
+ /** @type {Handle} */
function onexitdefinitiontitlestring() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].title = data;
}
+ /** @type {Handle} */
function onexitdefinitiondestinationstring() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].url = data;
}
+ /** @type {Handle} */
function onexitatxheadingsequence(token) {
if (!this.stack[this.stack.length - 1].depth) {
- this.stack[this.stack.length - 1].depth = this.sliceSerialize(
- token
- ).length;
+ this.stack[this.stack.length - 1].depth =
+ this.sliceSerialize(token).length;
}
}
+ /** @type {Handle} */
function onexitsetextheadingtext() {
setData('setextHeadingSlurpLineEnding', true);
}
+ /** @type {Handle} */
function onexitsetextheadinglinesequence(token) {
this.stack[this.stack.length - 1].depth =
this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;
}
+ /** @type {Handle} */
function onexitsetextheading() {
setData('setextHeadingSlurpLineEnding');
}
+ /** @type {Handle} */
function onenterdata(token) {
- var siblings = this.stack[this.stack.length - 1].children;
- var tail = siblings[siblings.length - 1];
+ /** @type {Parent} */
+ // @ts-expect-error: assume parent.
+ const parent = this.stack[this.stack.length - 1];
+ /** @type {Node} */
+ // @ts-expect-error: assume child.
+
+ let tail = parent.children[parent.children.length - 1];
if (!tail || tail.type !== 'text') {
// Add a new text node.
- tail = text();
- tail.position = {start: point(token.start)};
- this.stack[this.stack.length - 1].children.push(tail);
+ tail = text(); // @ts-expect-error: we’ll add `end` later.
+
+ tail.position = {
+ start: point(token.start)
+ };
+ parent.children.push(tail);
}
this.stack.push(tail);
}
+ /** @type {Handle} */
function onexitdata(token) {
- var tail = this.stack.pop();
+ const tail = this.stack.pop();
tail.value += this.sliceSerialize(token);
tail.position.end = point(token.end);
}
+ /** @type {Handle} */
function onexitlineending(token) {
- var context = this.stack[this.stack.length - 1];
+ /** @type {Parent} */
+ // @ts-expect-error: supposed to be a parent.
+ const context = this.stack[this.stack.length - 1];
// If we’re at a hard break, include the line ending in there.
if (getData('atHardBreak')) {
- context.children[context.children.length - 1].position.end = point(
- token.end
- );
-
+ const tail = context.children[context.children.length - 1];
+ tail.position.end = point(token.end);
setData('atHardBreak');
return
}
if (
!getData('setextHeadingSlurpLineEnding') &&
- config.canContainEols.indexOf(context.type) > -1
+ config.canContainEols.includes(context.type)
) {
onenterdata.call(this, token);
onexitdata.call(this, token);
}
}
+ /** @type {Handle} */
function onexithardbreak() {
setData('atHardBreak', true);
}
+ /** @type {Handle} */
function onexithtmlflow() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
+ /** @type {Handle} */
function onexithtmltext() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
+ /** @type {Handle} */
function onexitcodetext() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
+ /** @type {Handle} */
function onexitlink() {
- var context = this.stack[this.stack.length - 1];
+ const context = this.stack[this.stack.length - 1]; // To do: clean.
- // To do: clean.
if (getData('inReference')) {
context.type += 'Reference';
context.referenceType = getData('referenceType') || 'shortcut';
@@ -43260,11 +43105,11 @@ function compiler(options) {
setData('referenceType');
}
+ /** @type {Handle} */
function onexitimage() {
- var context = this.stack[this.stack.length - 1];
+ const context = this.stack[this.stack.length - 1]; // To do: clean.
- // To do: clean.
if (getData('inReference')) {
context.type += 'Reference';
context.referenceType = getData('referenceType') || 'shortcut';
@@ -43278,20 +43123,20 @@ function compiler(options) {
setData('referenceType');
}
+ /** @type {Handle} */
function onexitlabeltext(token) {
- this.stack[this.stack.length - 2].identifier = normalizeIdentifier$1(
+ this.stack[this.stack.length - 2].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
}
+ /** @type {Handle} */
function onexitlabel() {
- var fragment = this.stack[this.stack.length - 1];
- var value = this.resume();
-
- this.stack[this.stack.length - 1].label = value;
+ const fragment = this.stack[this.stack.length - 1];
+ const value = this.resume();
+ this.stack[this.stack.length - 1].label = value; // Assume a reference.
- // Assume a reference.
setData('inReference', true);
if (this.stack[this.stack.length - 1].type === 'link') {
@@ -43300,225 +43145,374 @@ function compiler(options) {
this.stack[this.stack.length - 1].alt = value;
}
}
+ /** @type {Handle} */
function onexitresourcedestinationstring() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].url = data;
}
+ /** @type {Handle} */
function onexitresourcetitlestring() {
- var data = this.resume();
+ const data = this.resume();
this.stack[this.stack.length - 1].title = data;
}
+ /** @type {Handle} */
function onexitresource() {
setData('inReference');
}
+ /** @type {Handle} */
function onenterreference() {
setData('referenceType', 'collapsed');
}
+ /** @type {Handle} */
function onexitreferencestring(token) {
- var label = this.resume();
+ const label = this.resume();
this.stack[this.stack.length - 1].label = label;
- this.stack[this.stack.length - 1].identifier = normalizeIdentifier$1(
+ this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
setData('referenceType', 'full');
}
+ /** @type {Handle} */
function onexitcharacterreferencemarker(token) {
setData('characterReferenceType', token.type);
}
+ /** @type {Handle} */
function onexitcharacterreferencevalue(token) {
- var data = this.sliceSerialize(token);
- var type = getData('characterReferenceType');
- var value;
- var tail;
+ const data = this.sliceSerialize(token);
+ const type = getData('characterReferenceType');
+ /** @type {string} */
+
+ let value;
if (type) {
- value = safeFromInt(
+ value = decodeNumericCharacterReference(
data,
type === 'characterReferenceMarkerNumeric' ? 10 : 16
);
-
setData('characterReferenceType');
} else {
- value = decode$1(data);
+ // @ts-expect-error `decodeEntity` can return false for invalid named
+ // character references, but everything we’ve tokenized is valid.
+ value = decodeEntity(data);
}
- tail = this.stack.pop();
+ const tail = this.stack.pop();
tail.value += value;
tail.position.end = point(token.end);
}
+ /** @type {Handle} */
function onexitautolinkprotocol(token) {
onexitdata.call(this, token);
this.stack[this.stack.length - 1].url = this.sliceSerialize(token);
}
+ /** @type {Handle} */
function onexitautolinkemail(token) {
onexitdata.call(this, token);
this.stack[this.stack.length - 1].url =
'mailto:' + this.sliceSerialize(token);
- }
-
- //
+ } //
// Creaters.
//
+ /** @returns {Blockquote} */
+
function blockQuote() {
- return {type: 'blockquote', children: []}
+ return {
+ type: 'blockquote',
+ children: []
+ }
}
+ /** @returns {Code} */
function codeFlow() {
- return {type: 'code', lang: null, meta: null, value: ''}
+ // @ts-expect-error: we’ve always used `null`.
+ return {
+ type: 'code',
+ lang: null,
+ meta: null,
+ value: ''
+ }
}
+ /** @returns {InlineCode} */
function codeText() {
- return {type: 'inlineCode', value: ''}
+ return {
+ type: 'inlineCode',
+ value: ''
+ }
}
+ /** @returns {Definition} */
function definition() {
return {
type: 'definition',
identifier: '',
+ // @ts-expect-error: we’ve always used `null`.
label: null,
+ // @ts-expect-error: we’ve always used `null`.
title: null,
url: ''
}
}
+ /** @returns {Emphasis} */
function emphasis() {
- return {type: 'emphasis', children: []}
+ return {
+ type: 'emphasis',
+ children: []
+ }
}
+ /** @returns {Heading} */
function heading() {
- return {type: 'heading', depth: undefined, children: []}
+ // @ts-expect-error `depth` will be set later.
+ return {
+ type: 'heading',
+ depth: undefined,
+ children: []
+ }
}
+ /** @returns {Break} */
function hardBreak() {
- return {type: 'break'}
+ return {
+ type: 'break'
+ }
}
+ /** @returns {HTML} */
function html() {
- return {type: 'html', value: ''}
+ return {
+ type: 'html',
+ value: ''
+ }
}
+ /** @returns {Image} */
function image() {
- return {type: 'image', title: null, url: '', alt: null}
+ // @ts-expect-error: we’ve always used `null`.
+ return {
+ type: 'image',
+ title: null,
+ url: '',
+ alt: null
+ }
}
+ /** @returns {Link} */
function link() {
- return {type: 'link', title: null, url: '', children: []}
+ // @ts-expect-error: we’ve always used `null`.
+ return {
+ type: 'link',
+ title: null,
+ url: '',
+ children: []
+ }
}
+ /**
+ * @param {Token} token
+ * @returns {List}
+ */
function list(token) {
return {
type: 'list',
ordered: token.type === 'listOrdered',
+ // @ts-expect-error: we’ve always used `null`.
start: null,
+ // @ts-expect-error Patched.
spread: token._spread,
children: []
}
}
+ /**
+ * @param {Token} token
+ * @returns {ListItem}
+ */
function listItem(token) {
return {
type: 'listItem',
+ // @ts-expect-error Patched.
spread: token._spread,
+ // @ts-expect-error: we’ve always used `null`.
checked: null,
children: []
}
}
+ /** @returns {Paragraph} */
function paragraph() {
- return {type: 'paragraph', children: []}
+ return {
+ type: 'paragraph',
+ children: []
+ }
}
+ /** @returns {Strong} */
function strong() {
- return {type: 'strong', children: []}
+ return {
+ type: 'strong',
+ children: []
+ }
}
+ /** @returns {Text} */
function text() {
- return {type: 'text', value: ''}
+ return {
+ type: 'text',
+ value: ''
+ }
}
+ /** @returns {ThematicBreak} */
function thematicBreak() {
- return {type: 'thematicBreak'}
+ return {
+ type: 'thematicBreak'
+ }
}
}
+/**
+ * @param {Extension} combined
+ * @param {Array.<Extension|Array.<Extension>>} extensions
+ * @returns {Extension}
+ */
-function configure$2(config, extensions) {
- var index = -1;
+function configure$1(combined, extensions) {
+ let index = -1;
while (++index < extensions.length) {
- extension(config, extensions[index]);
+ const value = extensions[index];
+
+ if (Array.isArray(value)) {
+ configure$1(combined, value);
+ } else {
+ extension(combined, value);
+ }
}
- return config
+ return combined
}
+/**
+ * @param {Extension} combined
+ * @param {Extension} extension
+ * @returns {void}
+ */
-function extension(config, extension) {
- var key;
- var left;
+function extension(combined, extension) {
+ /** @type {string} */
+ let key;
for (key in extension) {
- left = own$7.call(config, key) ? config[key] : (config[key] = {});
+ if (own$4.call(extension, key)) {
+ const list = key === 'canContainEols' || key === 'transforms';
+ const maybe = own$4.call(combined, key) ? combined[key] : undefined;
+ /* c8 ignore next */
- if (key === 'canContainEols' || key === 'transforms') {
- config[key] = [].concat(left, extension[key]);
- } else {
- Object.assign(left, extension[key]);
+ const left = maybe || (combined[key] = list ? [] : {});
+ const right = extension[key];
+
+ if (right) {
+ if (list) {
+ // @ts-expect-error: `left` is an array.
+ combined[key] = [...left, ...right];
+ } else {
+ Object.assign(left, right);
+ }
+ }
}
}
}
-var mdastUtilFromMarkdown = dist;
-
-var remarkParse = parse$2;
-
-var fromMarkdown = mdastUtilFromMarkdown;
-
-function parse$2(options) {
- var self = this;
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast-util-from-markdown').Options} Options
+ */
- this.Parser = parse;
+/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */
+function remarkParse(options) {
+ /** @type {import('unified').ParserFunction<Root>} */
+ const parser = (doc) => {
+ // Assume options.
+ const settings = /** @type {Options} */ (this.data('settings'));
- function parse(doc) {
return fromMarkdown(
doc,
- Object.assign({}, self.data('settings'), options, {
+ Object.assign({}, settings, options, {
// Note: these options are not in the readme.
// The goal is for them to be set by plugins on `data` instead of being
// passed by users.
- extensions: self.data('micromarkExtensions') || [],
- mdastExtensions: self.data('fromMarkdownExtensions') || []
+ extensions: this.data('micromarkExtensions') || [],
+ mdastExtensions: this.data('fromMarkdownExtensions') || []
})
)
- }
+ };
+
+ Object.assign(this, {Parser: parser});
}
-var zwitch$1 = factory$4;
+var own$3 = {}.hasOwnProperty;
-var noop$1 = Function.prototype;
-var own$6 = {}.hasOwnProperty;
+/**
+ * @callback Handler
+ * @param {...unknown} value
+ * @return {unknown}
+ *
+ * @typedef {Record<string, Handler>} Handlers
+ *
+ * @typedef {Object} Options
+ * @property {Handler} [unknown]
+ * @property {Handler} [invalid]
+ * @property {Handlers} [handlers]
+ */
-// Handle values based on a property.
-function factory$4(key, options) {
+/**
+ * Handle values based on a property.
+ *
+ * @param {string} key
+ * @param {Options} [options]
+ */
+function zwitch(key, options) {
var settings = options || {};
+ /**
+ * Handle one value.
+ * Based on the bound `key`, a respective handler will be called.
+ * If `value` is not an object, or doesn’t have a `key` property, the special
+ * “invalid” handler will be called.
+ * If `value` has an unknown `key`, the special “unknown” handler will be
+ * called.
+ *
+ * All arguments, and the context object, are passed through to the handler,
+ * and it’s result is returned.
+ *
+ * @param {...unknown} [value]
+ * @this {unknown}
+ * @returns {unknown}
+ * @property {Handler} invalid
+ * @property {Handler} unknown
+ * @property {Handlers} handlers
+ */
function one(value) {
var fn = one.invalid;
var handlers = one.handlers;
- if (value && own$6.call(value, key)) {
- fn = own$6.call(handlers, value[key]) ? handlers[value[key]] : one.unknown;
+ if (value && own$3.call(value, key)) {
+ fn = own$3.call(handlers, value[key]) ? handlers[value[key]] : one.unknown;
}
- return (fn || noop$1).apply(this, arguments)
+ if (fn) {
+ return fn.apply(this, arguments)
+ }
}
one.handlers = settings.handlers || {};
@@ -43528,25 +43522,37 @@ function factory$4(key, options) {
return one
}
-var configure_1 = configure$1;
+/**
+ * @typedef {import('./types.js').Options} Options
+ * @typedef {import('./types.js').Context} Context
+ */
-function configure$1(base, extension) {
- var index = -1;
- var key;
+/**
+ * @param {Context} base
+ * @param {Options} extension
+ * @returns {Context}
+ */
+function configure(base, extension) {
+ let index = -1;
+ /** @type {string} */
+ let key;
// First do subextensions.
if (extension.extensions) {
while (++index < extension.extensions.length) {
- configure$1(base, extension.extensions[index]);
+ configure(base, extension.extensions[index]);
}
}
for (key in extension) {
if (key === 'extensions') ; else if (key === 'unsafe' || key === 'join') {
- base[key] = base[key].concat(extension[key] || []);
+ /* c8 ignore next 2 */
+ // @ts-expect-error: hush.
+ base[key] = [...(base[key] || []), ...(extension[key] || [])];
} else if (key === 'handlers') {
base[key] = Object.assign(base[key], extension[key] || {});
} else {
+ // @ts-expect-error: hush.
base.options[key] = extension[key];
}
}
@@ -43554,37 +43560,49 @@ function configure$1(base, extension) {
return base
}
-var handle = {};
-
-var containerFlow$1 = flow$4;
-
-var repeat$5 = repeatString;
+/**
+ * @typedef {import('../types.js').Node} Node
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').Join} Join
+ * @typedef {import('../types.js').Context} Context
+ */
-function flow$4(parent, context) {
- var children = parent.children || [];
- var results = [];
- var index = -1;
- var child;
+/**
+ * @param {Parent} parent
+ * @param {Context} context
+ * @returns {string}
+ */
+function containerFlow(parent, context) {
+ const children = parent.children || [];
+ /** @type {Array.<string>} */
+ const results = [];
+ let index = -1;
while (++index < children.length) {
- child = children[index];
+ const child = children[index];
results.push(
context.handle(child, parent, context, {before: '\n', after: '\n'})
);
- if (index + 1 < children.length) {
+ if (index < children.length - 1) {
results.push(between(child, children[index + 1]));
}
}
return results.join('')
+ /**
+ * @param {Node} left
+ * @param {Node} right
+ * @returns {string}
+ */
function between(left, right) {
- var index = -1;
- var result;
+ let index = context.join.length;
+ /** @type {ReturnType<Join>} */
+ let result;
- while (++index < context.join.length) {
+ while (index--) {
result = context.join[index](left, right, parent, context);
if (result === true || result === 1) {
@@ -43592,7 +43610,7 @@ function flow$4(parent, context) {
}
if (typeof result === 'number') {
- return repeat$5('\n', 1 + Number(result))
+ return '\n'.repeat(1 + result)
}
if (result === false) {
@@ -43604,17 +43622,30 @@ function flow$4(parent, context) {
}
}
-var indentLines_1 = indentLines$4;
+/**
+ * @callback Map
+ * @param {string} value
+ * @param {number} line
+ * @param {boolean} blank
+ * @returns {string}
+ */
-var eol$1 = /\r?\n|\r/g;
+const eol = /\r?\n|\r/g;
-function indentLines$4(value, map) {
- var result = [];
- var start = 0;
- var line = 0;
- var match;
+/**
+ * @param {string} value
+ * @param {Map} map
+ * @returns {string}
+ */
+function indentLines(value, map) {
+ /** @type {Array.<string>} */
+ const result = [];
+ let start = 0;
+ let line = 0;
+ /** @type {RegExpExecArray|null} */
+ let match;
- while ((match = eol$1.exec(value))) {
+ while ((match = eol.exec(value))) {
one(value.slice(start, match.index));
result.push(match[0]);
start = match.index + match[0].length;
@@ -43625,39 +43656,59 @@ function indentLines$4(value, map) {
return result.join('')
+ /**
+ * @param {string} value
+ */
function one(value) {
result.push(map(value, line, !value));
}
}
-var blockquote_1 = blockquote;
-
-var flow$3 = containerFlow$1;
-var indentLines$3 = indentLines_1;
+/**
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ */
+/**
+ * @type {Handle}
+ * @param {Blockquote} node
+ */
function blockquote(node, _, context) {
- var exit = context.enter('blockquote');
- var value = indentLines$3(flow$3(node, context), map$3);
+ const exit = context.enter('blockquote');
+ const value = indentLines(containerFlow(node, context), map$1);
exit();
return value
}
-function map$3(line, index, blank) {
+/** @type {Map} */
+function map$1(line, _, blank) {
return '>' + (blank ? '' : ' ') + line
}
-var patternInScope_1 = patternInScope$2;
+/**
+ * @typedef {import('../types.js').Unsafe} Unsafe
+ */
-function patternInScope$2(stack, pattern) {
+/**
+ * @param {Array.<string>} stack
+ * @param {Unsafe} pattern
+ * @returns {boolean}
+ */
+function patternInScope(stack, pattern) {
return (
listInScope(stack, pattern.inConstruct, true) &&
- !listInScope(stack, pattern.notInConstruct)
+ !listInScope(stack, pattern.notInConstruct, false)
)
}
+/**
+ * @param {Array.<string>} stack
+ * @param {Unsafe['inConstruct']} list
+ * @param {boolean} none
+ * @returns {boolean}
+ */
function listInScope(stack, list, none) {
- var index;
-
if (!list) {
return none
}
@@ -43666,10 +43717,10 @@ function listInScope(stack, list, none) {
list = [list];
}
- index = -1;
+ let index = -1;
while (++index < list.length) {
- if (stack.indexOf(list[index]) !== -1) {
+ if (stack.includes(list[index])) {
return true
}
}
@@ -43677,19 +43728,24 @@ function listInScope(stack, list, none) {
return false
}
-var _break = hardBreak;
-
-var patternInScope$1 = patternInScope_1;
+/**
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('mdast').Break} Break
+ */
-function hardBreak(node, _, context, safe) {
- var index = -1;
+/**
+ * @type {Handle}
+ * @param {Break} _
+ */
+function hardBreak(_, _1, context, safe) {
+ let index = -1;
while (++index < context.unsafe.length) {
// If we can’t put eols in this construct (setext headings, tables), use a
// space instead.
if (
context.unsafe[index].character === '\n' &&
- patternInScope$1(context.stack, context.unsafe[index])
+ patternInScope(context.stack, context.unsafe[index])
) {
return /[ \t]/.test(safe.before) ? '' : ' '
}
@@ -43698,60 +43754,74 @@ function hardBreak(node, _, context, safe) {
return '\\\n'
}
-var longestStreak_1 = longestStreak;
-
-// Get the count of the longest repeating streak of `character` in `value`.
+/**
+ * Get the count of the longest repeating streak of `character` in `value`.
+ *
+ * @param {string} value Content.
+ * @param {string} character Single character to look for
+ * @returns {number} Count of most frequent adjacent `character`s in `value`
+ */
function longestStreak(value, character) {
+ var source = String(value);
+ var index = source.indexOf(character);
+ var expected = index;
var count = 0;
- var maximum = 0;
- var expected;
- var index;
+ var max = 0;
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;
+ if (++count > max) {
+ max = count;
}
} else {
count = 1;
}
expected = index + 1;
- index = value.indexOf(character, expected);
+ index = source.indexOf(character, expected);
}
- return maximum
+ return max
}
-var formatCodeAsIndented_1 = formatCodeAsIndented$2;
+/**
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../types.js').Context} Context
+ */
-function formatCodeAsIndented$2(node, context) {
- return (
+/**
+ * @param {Code} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatCodeAsIndented(node, context) {
+ return Boolean(
!context.options.fences &&
- node.value &&
- // If there’s no info…
- !node.lang &&
- // And there’s a non-whitespace character…
- /[^ \r\n]/.test(node.value) &&
- // And the value doesn’t start or end in a blank…
- !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
+ node.value &&
+ // If there’s no info…
+ !node.lang &&
+ // And there’s a non-whitespace character…
+ /[^ \r\n]/.test(node.value) &&
+ // And the value doesn’t start or end in a blank…
+ !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
)
}
-var checkFence_1 = checkFence$1;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkFence$1(context) {
- var marker = context.options.fence || '`';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['fence'], undefined>}
+ */
+function checkFence(context) {
+ const marker = context.options.fence || '`';
if (marker !== '`' && marker !== '~') {
throw new Error(
@@ -43764,25 +43834,25 @@ function checkFence$1(context) {
return marker
}
-var patternCompile_1 = patternCompile$3;
-
-function patternCompile$3(pattern) {
- var before;
- var after;
+/**
+ * @typedef {import('../types.js').Unsafe} Unsafe
+ */
+/**
+ * @param {Unsafe} pattern
+ * @returns {RegExp}
+ */
+function patternCompile(pattern) {
if (!pattern._compiled) {
- before = pattern.before ? '(?:' + pattern.before + ')' : '';
- after = pattern.after ? '(?:' + pattern.after + ')' : '';
-
- if (pattern.atBreak) {
- before = '[\\r\\n][\\t ]*' + before;
- }
+ const before =
+ (pattern.atBreak ? '[\\r\\n][\\t ]*' : '') +
+ (pattern.before ? '(?:' + pattern.before + ')' : '');
pattern._compiled = new RegExp(
(before ? '(' + before + ')' : '') +
(/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
pattern.character +
- (after || ''),
+ (pattern.after ? '(?:' + pattern.after + ')' : ''),
'g'
);
}
@@ -43790,45 +43860,44 @@ function patternCompile$3(pattern) {
return pattern._compiled
}
-var safe_1 = safe$7;
-
-var patternCompile$2 = patternCompile_1;
-var patternInScope = patternInScope_1;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').SafeOptions} SafeOptions
+ */
-function safe$7(context, input, config) {
- var value = (config.before || '') + (input || '') + (config.after || '');
- var positions = [];
- var result = [];
- var infos = {};
- var index = -1;
- var before;
- var after;
- var position;
- var pattern;
- var expression;
- var match;
- var start;
- var end;
+/**
+ * @param {Context} context
+ * @param {string|null|undefined} input
+ * @param {SafeOptions & {encode?: Array.<string>}} config
+ * @returns {string}
+ */
+function safe(context, input, config) {
+ const value = (config.before || '') + (input || '') + (config.after || '');
+ /** @type {Array.<number>} */
+ const positions = [];
+ /** @type {Array.<string>} */
+ const result = [];
+ /** @type {Record<number, {before: boolean, after: boolean}>} */
+ const infos = {};
+ let index = -1;
while (++index < context.unsafe.length) {
- pattern = context.unsafe[index];
+ const pattern = context.unsafe[index];
if (!patternInScope(context.stack, pattern)) {
continue
}
- expression = patternCompile$2(pattern);
+ const expression = patternCompile(pattern);
+ /** @type {RegExpExecArray|null} */
+ let match;
while ((match = expression.exec(value))) {
- before = 'before' in pattern || pattern.atBreak;
- after = 'after' in pattern;
-
- position = match.index + (before ? match[1].length : 0);
+ const before = 'before' in pattern || Boolean(pattern.atBreak);
+ const after = 'after' in pattern;
+ const position = match.index + (before ? match[1].length : 0);
- if (positions.indexOf(position) === -1) {
- positions.push(position);
- infos[position] = {before: before, after: after};
- } else {
+ if (positions.includes(position)) {
if (infos[position].before && !before) {
infos[position].before = false;
}
@@ -43836,24 +43905,24 @@ function safe$7(context, input, config) {
if (infos[position].after && !after) {
infos[position].after = false;
}
+ } else {
+ positions.push(position);
+ infos[position] = {before, after};
}
}
}
positions.sort(numerical);
- start = config.before ? config.before.length : 0;
- end = value.length - (config.after ? config.after.length : 0);
+ let start = config.before ? config.before.length : 0;
+ const end = value.length - (config.after ? config.after.length : 0);
index = -1;
while (++index < positions.length) {
- position = positions[index];
+ const position = positions[index];
- if (
- // Character before or after matched:
- position < start ||
- position >= end
- ) {
+ // Character before or after matched:
+ if (position < start || position >= end) {
continue
}
@@ -43881,7 +43950,7 @@ function safe$7(context, input, config) {
if (
/[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
- (!config.encode || config.encode.indexOf(value.charAt(position)) === -1)
+ (!config.encode || !config.encode.includes(value.charAt(position)))
) {
// Character escape.
result.push('\\');
@@ -43899,18 +43968,31 @@ function safe$7(context, input, config) {
return result.join('')
}
+/**
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
function numerical(a, b) {
return a - b
}
+/**
+ * @param {string} value
+ * @param {string} after
+ * @returns {string}
+ */
function escapeBackslashes(value, after) {
- var expression = /\\(?=[!-/:-@[-`{-~])/g;
- var positions = [];
- var results = [];
- var index = -1;
- var start = 0;
- var whole = value + after;
- var match;
+ const expression = /\\(?=[!-/:-@[-`{-~])/g;
+ /** @type {Array.<number>} */
+ const positions = [];
+ /** @type {Array.<string>} */
+ const results = [];
+ const whole = value + after;
+ let index = -1;
+ let start = 0;
+ /** @type {RegExpExecArray|null} */
+ let match;
while ((match = expression.exec(whole))) {
positions.push(match.index);
@@ -43930,35 +44012,39 @@ function escapeBackslashes(value, after) {
return results.join('')
}
-var code_1 = code$1;
-
-var repeat$4 = repeatString;
-var streak = longestStreak_1;
-var formatCodeAsIndented$1 = formatCodeAsIndented_1;
-var checkFence = checkFence_1;
-var indentLines$2 = indentLines_1;
-var safe$6 = safe_1;
+/**
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ */
+/**
+ * @type {Handle}
+ * @param {Code} node
+ */
function code$1(node, _, context) {
- var marker = checkFence(context);
- var raw = node.value || '';
- var suffix = marker === '`' ? 'GraveAccent' : 'Tilde';
- var value;
- var sequence;
- var exit;
- var subexit;
-
- if (formatCodeAsIndented$1(node, context)) {
+ const marker = checkFence(context);
+ const raw = node.value || '';
+ const suffix = marker === '`' ? 'GraveAccent' : 'Tilde';
+ /** @type {string} */
+ let value;
+ /** @type {Exit} */
+ let exit;
+
+ if (formatCodeAsIndented(node, context)) {
exit = context.enter('codeIndented');
- value = indentLines$2(raw, map$2);
+ value = indentLines(raw, map);
} else {
- sequence = repeat$4(marker, Math.max(streak(raw, marker) + 1, 3));
+ const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
+ /** @type {Exit} */
+ let subexit;
exit = context.enter('codeFenced');
value = sequence;
if (node.lang) {
subexit = context.enter('codeFencedLang' + suffix);
- value += safe$6(context, node.lang, {
+ value += safe(context, node.lang, {
before: '`',
after: ' ',
encode: ['`']
@@ -43970,7 +44056,7 @@ function code$1(node, _, context) {
subexit = context.enter('codeFencedMeta' + suffix);
value +=
' ' +
- safe$6(context, node.meta, {
+ safe(context, node.meta, {
before: ' ',
after: '\n',
encode: ['`']
@@ -43991,4485 +44077,34 @@ function code$1(node, _, context) {
return value
}
-function map$2(line, _, blank) {
+/** @type {Map} */
+function map(line, _, blank) {
return (blank ? '' : ' ') + line
}
-const AEli = "Æ";
-const AElig = "Æ";
-const AM = "&";
-const AMP = "&";
-const Aacut = "Á";
-const Aacute = "Á";
-const Abreve = "Ă";
-const Acir = "Â";
-const Acirc = "Â";
-const Acy = "А";
-const Afr = "𝔄";
-const Agrav = "À";
-const Agrave = "À";
-const Alpha = "Α";
-const Amacr = "Ā";
-const And = "⩓";
-const Aogon = "Ą";
-const Aopf = "𝔸";
-const ApplyFunction = "⁡";
-const Arin = "Å";
-const Aring = "Å";
-const Ascr = "𝒜";
-const Assign = "≔";
-const Atild = "Ã";
-const Atilde = "Ã";
-const Aum = "Ä";
-const Auml = "Ä";
-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 = "©";
-const Cacute = "Ć";
-const Cap = "⋒";
-const CapitalDifferentialD = "ⅅ";
-const Cayleys = "ℭ";
-const Ccaron = "Č";
-const Ccedi = "Ç";
-const Ccedil = "Ç";
-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 = "Ð";
-const Eacut = "É";
-const Eacute = "É";
-const Ecaron = "Ě";
-const Ecir = "Ê";
-const Ecirc = "Ê";
-const Ecy = "Э";
-const Edot = "Ė";
-const Efr = "𝔈";
-const Egrav = "È";
-const Egrave = "È";
-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 = "Ë";
-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 = ">";
-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 = "Í";
-const Icir = "Î";
-const Icirc = "Î";
-const Icy = "И";
-const Idot = "İ";
-const Ifr = "ℑ";
-const Igrav = "Ì";
-const Igrave = "Ì";
-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 = "Ï";
-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 = "<";
-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 = "Ñ";
-const Nu = "Ν";
-const OElig = "Œ";
-const Oacut = "Ó";
-const Oacute = "Ó";
-const Ocir = "Ô";
-const Ocirc = "Ô";
-const Ocy = "О";
-const Odblac = "Ő";
-const Ofr = "𝔒";
-const Ograv = "Ò";
-const Ograve = "Ò";
-const Omacr = "Ō";
-const Omega = "Ω";
-const Omicron = "Ο";
-const Oopf = "𝕆";
-const OpenCurlyDoubleQuote = "“";
-const OpenCurlyQuote = "‘";
-const Or = "⩔";
-const Oscr = "𝒪";
-const Oslas = "Ø";
-const Oslash = "Ø";
-const Otild = "Õ";
-const Otilde = "Õ";
-const Otimes = "⨷";
-const Oum = "Ö";
-const Ouml = "Ö";
-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 = "\"";
-const Qfr = "𝔔";
-const Qopf = "ℚ";
-const Qscr = "𝒬";
-const RBarr = "⤐";
-const RE = "®";
-const REG = "®";
-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 = "Þ";
-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 = "Ú";
-const Uarr = "↟";
-const Uarrocir = "⥉";
-const Ubrcy = "Ў";
-const Ubreve = "Ŭ";
-const Ucir = "Û";
-const Ucirc = "Û";
-const Ucy = "У";
-const Udblac = "Ű";
-const Ufr = "𝔘";
-const Ugrav = "Ù";
-const Ugrave = "Ù";
-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 = "Ü";
-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 = "Ý";
-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 = "á";
-const abreve = "ă";
-const ac = "∾";
-const acE = "∾̳";
-const acd = "∿";
-const acir = "â";
-const acirc = "â";
-const acut = "´";
-const acute = "´";
-const acy = "а";
-const aeli = "æ";
-const aelig = "æ";
-const af = "⁡";
-const afr = "𝔞";
-const agrav = "à";
-const agrave = "à";
-const alefsym = "ℵ";
-const aleph = "ℵ";
-const alpha = "α";
-const amacr = "ā";
-const amalg = "⨿";
-const am = "&";
-const amp = "&";
-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 = "å";
-const ascr = "𝒶";
-const ast = "*";
-const asymp = "≈";
-const asympeq = "≍";
-const atild = "ã";
-const atilde = "ã";
-const aum = "ä";
-const auml = "ä";
-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 = "¦";
-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 = "ç";
-const ccirc = "ĉ";
-const ccups = "⩌";
-const ccupssm = "⩐";
-const cdot = "ċ";
-const cedi = "¸";
-const cedil = "¸";
-const cemptyv = "⦲";
-const cen = "¢";
-const cent = "¢";
-const centerdot = "·";
-const cfr = "𝔠";
-const chcy = "ч";
-const check$1 = "✓";
-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 = "©";
-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 = "¤";
-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 = "°";
-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 = "÷";
-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 = "é";
-const easter = "⩮";
-const ecaron = "ě";
-const ecir = "ê";
-const ecirc = "ê";
-const ecolon = "≕";
-const ecy = "э";
-const edot = "ė";
-const ee = "ⅇ";
-const efDot = "≒";
-const efr = "𝔢";
-const eg = "⪚";
-const egrav = "è";
-const egrave = "è";
-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 = "ð";
-const eum = "ë";
-const euml = "ë";
-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 = "½";
-const frac13 = "⅓";
-const frac14 = "¼";
-const frac15 = "⅕";
-const frac16 = "⅙";
-const frac18 = "⅛";
-const frac23 = "⅔";
-const frac25 = "⅖";
-const frac3 = "¾";
-const frac34 = "¾";
-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 = ">";
-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 = "í";
-const ic = "⁣";
-const icir = "î";
-const icirc = "î";
-const icy = "и";
-const iecy = "е";
-const iexc = "¡";
-const iexcl = "¡";
-const iff = "⇔";
-const ifr = "𝔦";
-const igrav = "ì";
-const igrave = "ì";
-const ii = "ⅈ";
-const iiiint = "⨌";
-const iiint = "∭";
-const iinfin = "⧜";
-const iiota = "℩";
-const ijlig = "ij";
-const imacr = "ī";
-const image$1 = "ℑ";
-const imagline = "ℐ";
-const imagpart = "ℑ";
-const imath = "ı";
-const imof = "⊷";
-const imped = "Ƶ";
-const incare = "℅";
-const infin = "∞";
-const infintie = "⧝";
-const inodot = "ı";
-const int$1 = "∫";
-const intcal = "⊺";
-const integers = "ℤ";
-const intercal = "⊺";
-const intlarhk = "⨗";
-const intprod = "⨼";
-const iocy = "ё";
-const iogon = "į";
-const iopf = "𝕚";
-const iota = "ι";
-const iprod = "⨼";
-const iques = "¿";
-const iquest = "¿";
-const iscr = "𝒾";
-const isin = "∈";
-const isinE = "⋹";
-const isindot = "⋵";
-const isins = "⋴";
-const isinsv = "⋳";
-const isinv = "∈";
-const it = "⁢";
-const itilde = "ĩ";
-const iukcy = "і";
-const ium = "ï";
-const iuml = "ï";
-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 = "«";
-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 = "¯";
-const male = "♂";
-const malt = "✠";
-const maltese = "✠";
-const map$1 = "↦";
-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 = "µ";
-const mid = "∣";
-const midast = "*";
-const midcir = "⫰";
-const middo = "·";
-const middot = "·";
-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 = " ";
-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 = "¬";
-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 = "ñ";
-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 = "ó";
-const oast = "⊛";
-const ocir = "ô";
-const ocirc = "ô";
-const ocy = "о";
-const odash = "⊝";
-const odblac = "ő";
-const odiv = "⨸";
-const odot = "⊙";
-const odsold = "⦼";
-const oelig = "œ";
-const ofcir = "⦿";
-const ofr = "𝔬";
-const ogon = "˛";
-const ograv = "ò";
-const ograve = "ò";
-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 = "ℴ";
-const orderof = "ℴ";
-const ordf = "ª";
-const ordm = "º";
-const origof = "⊶";
-const oror = "⩖";
-const orslope = "⩗";
-const orv = "⩛";
-const oscr = "ℴ";
-const oslas = "ø";
-const oslash = "ø";
-const osol = "⊘";
-const otild = "õ";
-const otilde = "õ";
-const otimes = "⊗";
-const otimesas = "⨶";
-const oum = "ö";
-const ouml = "ö";
-const ovbar = "⌽";
-const par = "¶";
-const para = "¶";
-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 = "±";
-const plussim = "⨦";
-const plustwo = "⨧";
-const pm = "±";
-const pointint = "⨕";
-const popf = "𝕡";
-const poun = "£";
-const pound = "£";
-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 = "\"";
-const rAarr = "⇛";
-const rArr = "⇒";
-const rAtail = "⤜";
-const rBarr = "⤏";
-const rHar = "⥤";
-const race = "∽̱";
-const racute = "ŕ";
-const radic = "√";
-const raemptyv = "⦳";
-const rang = "⟩";
-const rangd = "⦒";
-const range = "⦥";
-const rangle = "⟩";
-const raqu = "»";
-const raquo = "»";
-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$4 = "®";
-const reg = "®";
-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 = "§";
-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 = "­";
-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 = "☆";
-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 = "¹";
-const sup2 = "²";
-const sup3 = "³";
-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 = "ß";
-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 = "þ";
-const tilde = "˜";
-const time = "×";
-const times = "×";
-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 = "ú";
-const uarr = "↑";
-const ubrcy = "ў";
-const ubreve = "ŭ";
-const ucir = "û";
-const ucirc = "û";
-const ucy = "у";
-const udarr = "⇅";
-const udblac = "ű";
-const udhar = "⥮";
-const ufisht = "⥾";
-const ufr = "𝔲";
-const ugrav = "ù";
-const ugrave = "ù";
-const uharl = "↿";
-const uharr = "↾";
-const uhblk = "▀";
-const ulcorn = "⌜";
-const ulcorner = "⌜";
-const ulcrop = "⌏";
-const ultri = "◸";
-const umacr = "ū";
-const um = "¨";
-const uml = "¨";
-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 = "ü";
-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 = "ý";
-const yacy = "я";
-const ycirc = "ŷ";
-const ycy = "ы";
-const ye = "¥";
-const yen = "¥";
-const yfr = "𝔶";
-const yicy = "ї";
-const yopf = "𝕪";
-const yscr = "𝓎";
-const yucy = "ю";
-const yum = "ÿ";
-const yuml = "ÿ";
-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 require$$0 = {
- AEli: AEli,
- AElig: AElig,
- AM: AM,
- AMP: AMP,
- Aacut: Aacut,
- Aacute: Aacute,
- Abreve: Abreve,
- Acir: Acir,
- Acirc: Acirc,
- Acy: Acy,
- Afr: Afr,
- Agrav: Agrav,
- Agrave: Agrave,
- Alpha: Alpha,
- Amacr: Amacr,
- And: And,
- Aogon: Aogon,
- Aopf: Aopf,
- ApplyFunction: ApplyFunction,
- Arin: Arin,
- Aring: Aring,
- Ascr: Ascr,
- Assign: Assign,
- Atild: Atild,
- Atilde: Atilde,
- Aum: Aum,
- Auml: Auml,
- 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,
- Cacute: Cacute,
- Cap: Cap,
- CapitalDifferentialD: CapitalDifferentialD,
- Cayleys: Cayleys,
- Ccaron: Ccaron,
- Ccedi: Ccedi,
- Ccedil: Ccedil,
- 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,
- Eacut: Eacut,
- Eacute: Eacute,
- Ecaron: Ecaron,
- Ecir: Ecir,
- Ecirc: Ecirc,
- Ecy: Ecy,
- Edot: Edot,
- Efr: Efr,
- Egrav: Egrav,
- Egrave: Egrave,
- 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,
- 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,
- 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,
- Icir: Icir,
- Icirc: Icirc,
- Icy: Icy,
- Idot: Idot,
- Ifr: Ifr,
- Igrav: Igrav,
- Igrave: Igrave,
- 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,
- 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,
- 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,
- "Map": "⤅",
- 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,
- Nu: Nu,
- OElig: OElig,
- Oacut: Oacut,
- Oacute: Oacute,
- Ocir: Ocir,
- Ocirc: Ocirc,
- Ocy: Ocy,
- Odblac: Odblac,
- Ofr: Ofr,
- Ograv: Ograv,
- Ograve: Ograve,
- Omacr: Omacr,
- Omega: Omega,
- Omicron: Omicron,
- Oopf: Oopf,
- OpenCurlyDoubleQuote: OpenCurlyDoubleQuote,
- OpenCurlyQuote: OpenCurlyQuote,
- Or: Or,
- Oscr: Oscr,
- Oslas: Oslas,
- Oslash: Oslash,
- Otild: Otild,
- Otilde: Otilde,
- Otimes: Otimes,
- Oum: Oum,
- Ouml: Ouml,
- 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,
- Qfr: Qfr,
- Qopf: Qopf,
- Qscr: Qscr,
- RBarr: RBarr,
- RE: RE,
- REG: REG,
- 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,
- 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,
- Uarr: Uarr,
- Uarrocir: Uarrocir,
- Ubrcy: Ubrcy,
- Ubreve: Ubreve,
- Ucir: Ucir,
- Ucirc: Ucirc,
- Ucy: Ucy,
- Udblac: Udblac,
- Ufr: Ufr,
- Ugrav: Ugrav,
- Ugrave: Ugrave,
- 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,
- 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,
- 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,
- abreve: abreve,
- ac: ac,
- acE: acE,
- acd: acd,
- acir: acir,
- acirc: acirc,
- acut: acut,
- acute: acute,
- acy: acy,
- aeli: aeli,
- aelig: aelig,
- af: af,
- afr: afr,
- agrav: agrav,
- agrave: agrave,
- alefsym: alefsym,
- aleph: aleph,
- alpha: alpha,
- amacr: amacr,
- amalg: amalg,
- am: am,
- amp: amp,
- 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,
- ascr: ascr,
- ast: ast,
- asymp: asymp,
- asympeq: asympeq,
- atild: atild,
- atilde: atilde,
- aum: aum,
- auml: auml,
- 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,
- 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,
- ccirc: ccirc,
- ccups: ccups,
- ccupssm: ccupssm,
- cdot: cdot,
- cedi: cedi,
- cedil: cedil,
- cemptyv: cemptyv,
- cen: cen,
- cent: cent,
- centerdot: centerdot,
- cfr: cfr,
- chcy: chcy,
- check: check$1,
- 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,
- 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,
- 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,
- 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,
- 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,
- easter: easter,
- ecaron: ecaron,
- ecir: ecir,
- ecirc: ecirc,
- ecolon: ecolon,
- ecy: ecy,
- edot: edot,
- ee: ee,
- efDot: efDot,
- efr: efr,
- eg: eg,
- egrav: egrav,
- egrave: egrave,
- 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,
- eum: eum,
- euml: euml,
- 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,
- frac13: frac13,
- frac14: frac14,
- frac15: frac15,
- frac16: frac16,
- frac18: frac18,
- frac23: frac23,
- frac25: frac25,
- frac3: frac3,
- frac34: frac34,
- 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,
- 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,
- ic: ic,
- icir: icir,
- icirc: icirc,
- icy: icy,
- iecy: iecy,
- iexc: iexc,
- iexcl: iexcl,
- iff: iff,
- ifr: ifr,
- igrav: igrav,
- igrave: igrave,
- ii: ii,
- iiiint: iiiint,
- iiint: iiint,
- iinfin: iinfin,
- iiota: iiota,
- ijlig: ijlig,
- imacr: imacr,
- image: image$1,
- imagline: imagline,
- imagpart: imagpart,
- imath: imath,
- imof: imof,
- imped: imped,
- "in": "∈",
- incare: incare,
- infin: infin,
- infintie: infintie,
- inodot: inodot,
- int: int$1,
- intcal: intcal,
- integers: integers,
- intercal: intercal,
- intlarhk: intlarhk,
- intprod: intprod,
- iocy: iocy,
- iogon: iogon,
- iopf: iopf,
- iota: iota,
- iprod: iprod,
- iques: iques,
- iquest: iquest,
- iscr: iscr,
- isin: isin,
- isinE: isinE,
- isindot: isindot,
- isins: isins,
- isinsv: isinsv,
- isinv: isinv,
- it: it,
- itilde: itilde,
- iukcy: iukcy,
- ium: ium,
- iuml: iuml,
- 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,
- 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,
- male: male,
- malt: malt,
- maltese: maltese,
- map: map$1,
- 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,
- mid: mid,
- midast: midast,
- midcir: midcir,
- middo: middo,
- middot: middot,
- 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,
- 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,
- 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,
- 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,
- oast: oast,
- ocir: ocir,
- ocirc: ocirc,
- ocy: ocy,
- odash: odash,
- odblac: odblac,
- odiv: odiv,
- odot: odot,
- odsold: odsold,
- oelig: oelig,
- ofcir: ofcir,
- ofr: ofr,
- ogon: ogon,
- ograv: ograv,
- ograve: ograve,
- 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,
- orderof: orderof,
- ordf: ordf,
- ordm: ordm,
- origof: origof,
- oror: oror,
- orslope: orslope,
- orv: orv,
- oscr: oscr,
- oslas: oslas,
- oslash: oslash,
- osol: osol,
- otild: otild,
- otilde: otilde,
- otimes: otimes,
- otimesas: otimesas,
- oum: oum,
- ouml: ouml,
- ovbar: ovbar,
- par: par,
- para: para,
- 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,
- plussim: plussim,
- plustwo: plustwo,
- pm: pm,
- pointint: pointint,
- popf: popf,
- poun: poun,
- pound: pound,
- 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,
- rAarr: rAarr,
- rArr: rArr,
- rAtail: rAtail,
- rBarr: rBarr,
- rHar: rHar,
- race: race,
- racute: racute,
- radic: radic,
- raemptyv: raemptyv,
- rang: rang,
- rangd: rangd,
- range: range,
- rangle: rangle,
- raqu: raqu,
- raquo: raquo,
- 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$4,
- reg: reg,
- 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,
- 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,
- 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,
- 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,
- sup2: sup2,
- sup3: sup3,
- 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,
- 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,
- tilde: tilde,
- time: time,
- times: times,
- 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,
- uarr: uarr,
- ubrcy: ubrcy,
- ubreve: ubreve,
- ucir: ucir,
- ucirc: ucirc,
- ucy: ucy,
- udarr: udarr,
- udblac: udblac,
- udhar: udhar,
- ufisht: ufisht,
- ufr: ufr,
- ugrav: ugrav,
- ugrave: ugrave,
- uharl: uharl,
- uharr: uharr,
- uhblk: uhblk,
- ulcorn: ulcorn,
- ulcorner: ulcorner,
- ulcrop: ulcrop,
- ultri: ultri,
- umacr: umacr,
- um: um,
- uml: uml,
- 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,
- 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,
- yacy: yacy,
- ycirc: ycirc,
- ycy: ycy,
- ye: ye,
- yen: yen,
- yfr: yfr,
- yicy: yicy,
- yopf: yopf,
- yscr: yscr,
- yucy: yucy,
- yum: yum,
- yuml: yuml,
- 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
-};
-
-var characterEntities = require$$0;
-
-var decodeEntity_1 = decodeEntity;
-
-var own$5 = {}.hasOwnProperty;
-
-function decodeEntity(characters) {
- return own$5.call(characterEntities, characters)
- ? characterEntities[characters]
- : false
-}
-
-var association_1 = association$3;
-
-var decode = decodeEntity_1;
+/**
+ * @typedef {import('mdast').Association} Association
+ */
-var characterEscape = /\\([!-/:-@[-`{-~])/g;
-var characterReference = /&(#(\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
+const characterEscape = /\\([!-/:-@[-`{-~])/g;
+const characterReference = /&(#(\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
-// The `label` of an association is the string value: character escapes and
-// references work, and casing is intact.
-// The `identifier` is used to match one association to another: controversially,
-// character escapes and references don’t work in this matching: `&copy;` does
-// not match `©`, and `\+` does not match `+`.
-// But casing is ignored (and whitespace) is trimmed and collapsed: ` A\nb`
-// matches `a b`.
-// So, we do prefer the label when figuring out how we’re going to serialize:
-// it has whitespace, casing, and we can ignore most useless character escapes
-// and all character references.
-function association$3(node) {
+/**
+ * The `label` of an association is the string value: character escapes and
+ * references work, and casing is intact.
+ * The `identifier` is used to match one association to another: controversially,
+ * character escapes and references don’t work in this matching: `&copy;` does
+ * not match `©`, and `\+` does not match `+`.
+ * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\nb`
+ * matches `a b`.
+ * So, we do prefer the label when figuring out how we’re going to serialize:
+ * it has whitespace, casing, and we can ignore most useless character escapes
+ * and all character references.
+ *
+ * @param {Association} node
+ * @returns {string}
+ */
+function association(node) {
if (node.label || !node.identifier) {
return node.label || ''
}
@@ -48479,14 +44114,26 @@ function association$3(node) {
.replace(characterReference, decodeIfPossible)
}
+/**
+ * @param {string} $0
+ * @param {string} $1
+ * @returns {string}
+ */
function decodeIfPossible($0, $1) {
- return decode($1) || $0
+ return decodeEntity($1) || $0
}
-var checkQuote_1 = checkQuote$3;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkQuote$3(context) {
- var marker = context.options.quote || '"';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['quote'], undefined>}
+ */
+function checkQuote(context) {
+ const marker = context.options.quote || '"';
if (marker !== '"' && marker !== "'") {
throw new Error(
@@ -48499,19 +44146,22 @@ function checkQuote$3(context) {
return marker
}
-var definition_1 = definition;
-
-var association$2 = association_1;
-var checkQuote$2 = checkQuote_1;
-var safe$5 = safe_1;
+/**
+ * @typedef {import('mdast').Definition} Definition
+ * @typedef {import('../types.js').Handle} Handle
+ */
+/**
+ * @type {Handle}
+ * @param {Definition} node
+ */
function definition(node, _, context) {
- var marker = checkQuote$2(context);
- var suffix = marker === '"' ? 'Quote' : 'Apostrophe';
- var exit = context.enter('definition');
- var subexit = context.enter('label');
- var value =
- '[' + safe$5(context, association$2(node), {before: '[', after: ']'}) + ']: ';
+ const marker = checkQuote(context);
+ const suffix = marker === '"' ? 'Quote' : 'Apostrophe';
+ const exit = context.enter('definition');
+ let subexit = context.enter('label');
+ let value =
+ '[' + safe(context, association(node), {before: '[', after: ']'}) + ']: ';
subexit();
@@ -48522,11 +44172,11 @@ function definition(node, _, context) {
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
- value += '<' + safe$5(context, node.url, {before: '<', after: '>'}) + '>';
+ value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
- value += safe$5(context, node.url, {before: ' ', after: ' '});
+ value += safe(context, node.url, {before: ' ', after: ' '});
}
subexit();
@@ -48536,7 +44186,7 @@ function definition(node, _, context) {
value +=
' ' +
marker +
- safe$5(context, node.title, {before: marker, after: marker}) +
+ safe(context, node.title, {before: marker, after: marker}) +
marker;
subexit();
}
@@ -48546,10 +44196,17 @@ function definition(node, _, context) {
return value
}
-var checkEmphasis_1 = checkEmphasis$1;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkEmphasis$1(context) {
- var marker = context.options.emphasis || '*';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['emphasis'], undefined>}
+ */
+function checkEmphasis(context) {
+ const marker = context.options.emphasis || '*';
if (marker !== '*' && marker !== '_') {
throw new Error(
@@ -48562,22 +44219,34 @@ function checkEmphasis$1(context) {
return marker
}
-var containerPhrasing$1 = phrasing$6;
+/**
+ * @typedef {import('../types.js').Node} Node
+ * @typedef {import('../types.js').Parent} Parent
+ * @typedef {import('../types.js').SafeOptions} SafeOptions
+ * @typedef {import('../types.js').Context} Context
+ */
-function phrasing$6(parent, context, safeOptions) {
- var children = parent.children || [];
- var results = [];
- var index = -1;
- var before = safeOptions.before;
- var after;
- var handle;
- var child;
+/**
+ * @param {Parent} parent
+ * @param {Context} context
+ * @param {SafeOptions} safeOptions
+ * @returns {string}
+ */
+function containerPhrasing(parent, context, safeOptions) {
+ const children = parent.children || [];
+ /** @type {Array.<string>} */
+ const results = [];
+ let index = -1;
+ let before = safeOptions.before;
while (++index < children.length) {
- child = children[index];
+ const child = children[index];
+ /** @type {string} */
+ let after;
if (index + 1 < children.length) {
- handle = context.handle.handlers[children[index + 1].type];
+ // @ts-expect-error: hush, it’s actually a `zwitch`.
+ let handle = context.handle.handlers[children[index + 1].type];
if (handle && handle.peek) handle = handle.peek;
after = handle
? handle(children[index + 1], parent, context, {
@@ -48607,12 +44276,7 @@ function phrasing$6(parent, context, safeOptions) {
before = ' ';
}
- results.push(
- context.handle(child, parent, context, {
- before: before,
- after: after
- })
- );
+ results.push(context.handle(child, parent, context, {before, after}));
before = results[results.length - 1].slice(-1);
}
@@ -48620,91 +44284,86 @@ function phrasing$6(parent, context, safeOptions) {
return results.join('')
}
-var emphasis_1 = emphasis;
-emphasis.peek = emphasisPeek;
+/**
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var checkEmphasis = checkEmphasis_1;
-var phrasing$5 = containerPhrasing$1;
+emphasis.peek = emphasisPeek;
// To do: there are cases where emphasis cannot “form” depending on the
// previous or next character of sequences.
// There’s no way around that though, except for injecting zero-width stuff.
// Do we need to safeguard against that?
+/**
+ * @type {Handle}
+ * @param {Emphasis} node
+ */
function emphasis(node, _, context) {
- var marker = checkEmphasis(context);
- var exit = context.enter('emphasis');
- var value = phrasing$5(node, context, {before: marker, after: marker});
+ const marker = checkEmphasis(context);
+ const exit = context.enter('emphasis');
+ const value = containerPhrasing(node, context, {
+ before: marker,
+ after: marker
+ });
exit();
return marker + value + marker
}
-function emphasisPeek(node, _, context) {
+/**
+ * @type {Handle}
+ * @param {Emphasis} _
+ */
+function emphasisPeek(_, _1, context) {
return context.options.emphasis || '*'
}
-var mdastUtilToString = toString$3;
-
-// Get the text content of a node.
-// Prefer the node’s plain-text fields, otherwise serialize its children,
-// and if the given value is an array, serialize the nodes in it.
-function toString$3(node) {
- return (
- (node &&
- (node.value ||
- node.alt ||
- node.title ||
- ('children' in node && all$1(node.children)) ||
- ('length' in node && all$1(node)))) ||
- ''
- )
-}
-
-function all$1(values) {
- var result = [];
- var index = -1;
-
- while (++index < values.length) {
- result[index] = toString$3(values[index]);
- }
-
- return result.join('')
-}
-
-var formatHeadingAsSetext_1 = formatHeadingAsSetext$2;
-
-var toString$2 = mdastUtilToString;
+/**
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../types.js').Context} Context
+ */
-function formatHeadingAsSetext$2(node, context) {
- return (
- context.options.setext && (!node.depth || node.depth < 3) && toString$2(node)
+/**
+ * @param {Heading} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatHeadingAsSetext(node, context) {
+ return Boolean(
+ context.options.setext && (!node.depth || node.depth < 3) && toString(node)
)
}
-var heading_1 = heading;
-
-var repeat$3 = repeatString;
-var formatHeadingAsSetext$1 = formatHeadingAsSetext_1;
-var phrasing$4 = containerPhrasing$1;
+/**
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ */
+/**
+ * @type {Handle}
+ * @param {Heading} node
+ */
function heading(node, _, context) {
- var rank = Math.max(Math.min(6, node.depth || 1), 1);
- var exit;
- var subexit;
- var value;
- var sequence;
+ const rank = Math.max(Math.min(6, node.depth || 1), 1);
+ /** @type {Exit} */
+ let exit;
+ /** @type {Exit} */
+ let subexit;
+ /** @type {string} */
+ let value;
- if (formatHeadingAsSetext$1(node, context)) {
+ if (formatHeadingAsSetext(node, context)) {
exit = context.enter('headingSetext');
subexit = context.enter('phrasing');
- value = phrasing$4(node, context, {before: '\n', after: '\n'});
+ value = containerPhrasing(node, context, {before: '\n', after: '\n'});
subexit();
exit();
return (
value +
'\n' +
- repeat$3(
- rank === 1 ? '=' : '-',
+ (rank === 1 ? '=' : '-').repeat(
// The whole size…
value.length -
// Minus the position of the character after the last EOL (or
@@ -48714,10 +44373,10 @@ function heading(node, _, context) {
)
}
- sequence = repeat$3('#', rank);
+ const sequence = '#'.repeat(rank);
exit = context.enter('headingAtx');
subexit = context.enter('phrasing');
- value = phrasing$4(node, context, {before: '# ', after: '\n'});
+ value = containerPhrasing(node, context, {before: '# ', after: '\n'});
value = value ? sequence + ' ' + value : sequence;
if (context.options.closeAtx) {
value += ' ' + sequence;
@@ -48729,29 +44388,45 @@ function heading(node, _, context) {
return value
}
-var html_1 = html;
+/**
+ * @typedef {import('mdast').HTML} HTML
+ * @typedef {import('../types.js').Handle} Handle
+ */
+
html.peek = htmlPeek;
+/**
+ * @type {Handle}
+ * @param {HTML} node
+ */
function html(node) {
return node.value || ''
}
+/**
+ * @type {Handle}
+ */
function htmlPeek() {
return '<'
}
-var image_1 = image;
-image.peek = imagePeek;
+/**
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var checkQuote$1 = checkQuote_1;
-var safe$4 = safe_1;
+image.peek = imagePeek;
+/**
+ * @type {Handle}
+ * @param {Image} node
+ */
function image(node, _, context) {
- var quote = checkQuote$1(context);
- var suffix = quote === '"' ? 'Quote' : 'Apostrophe';
- var exit = context.enter('image');
- var subexit = context.enter('label');
- var value = '![' + safe$4(context, node.alt, {before: '[', after: ']'}) + '](';
+ const quote = checkQuote(context);
+ const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
+ const exit = context.enter('image');
+ let subexit = context.enter('label');
+ let value = '![' + safe(context, node.alt, {before: '[', after: ']'}) + '](';
subexit();
@@ -48762,11 +44437,11 @@ function image(node, _, context) {
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
- value += '<' + safe$4(context, node.url, {before: '<', after: '>'}) + '>';
+ value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
- value += safe$4(context, node.url, {
+ value += safe(context, node.url, {
before: '(',
after: node.title ? ' ' : ')'
});
@@ -48779,7 +44454,7 @@ function image(node, _, context) {
value +=
' ' +
quote +
- safe$4(context, node.title, {before: quote, after: quote}) +
+ safe(context, node.title, {before: quote, after: quote}) +
quote;
subexit();
}
@@ -48790,31 +44465,37 @@ function image(node, _, context) {
return value
}
+/**
+ * @type {Handle}
+ */
function imagePeek() {
return '!'
}
-var imageReference_1 = imageReference;
-imageReference.peek = imageReferencePeek;
+/**
+ * @typedef {import('mdast').ImageReference} ImageReference
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var association$1 = association_1;
-var safe$3 = safe_1;
+imageReference.peek = imageReferencePeek;
+/**
+ * @type {Handle}
+ * @param {ImageReference} node
+ */
function imageReference(node, _, context) {
- var type = node.referenceType;
- var exit = context.enter('imageReference');
- var subexit = context.enter('label');
- var alt = safe$3(context, node.alt, {before: '[', after: ']'});
- var value = '![' + alt + ']';
- var reference;
- var stack;
+ const type = node.referenceType;
+ const exit = context.enter('imageReference');
+ let subexit = context.enter('label');
+ const alt = safe(context, node.alt, {before: '[', after: ']'});
+ let value = '![' + alt + ']';
subexit();
// Hide the fact that we’re in phrasing, because escapes don’t work.
- stack = context.stack;
+ const stack = context.stack;
context.stack = [];
subexit = context.enter('reference');
- reference = safe$3(context, association$1(node), {before: '[', after: ']'});
+ const reference = safe(context, association(node), {before: '[', after: ']'});
subexit();
context.stack = stack;
exit();
@@ -48828,23 +44509,28 @@ function imageReference(node, _, context) {
return value
}
+/**
+ * @type {Handle}
+ */
function imageReferencePeek() {
return '!'
}
-var inlineCode_1 = inlineCode$1;
-inlineCode$1.peek = inlineCodePeek$1;
+/**
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var patternCompile$1 = patternCompile_1;
+inlineCode.peek = inlineCodePeek;
-function inlineCode$1(node, parent, context) {
- var value = node.value || '';
- var sequence = '`';
- var index = -1;
- var pattern;
- var expression;
- var match;
- var position;
+/**
+ * @type {Handle}
+ * @param {InlineCode} node
+ */
+function inlineCode(node, _, context) {
+ let value = node.value || '';
+ let sequence = '`';
+ let index = -1;
// If there is a single grave accent on its own in the code, use a fence of
// two.
@@ -48857,8 +44543,7 @@ function inlineCode$1(node, parent, context) {
// first or last character are a space, eol, or tick, then pad with spaces.
if (
/[^ \r\n]/.test(value) &&
- (/[ \r\n`]/.test(value.charAt(0)) ||
- /[ \r\n`]/.test(value.charAt(value.length - 1)))
+ ((/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value)) || /^`|`$/.test(value))
) {
value = ' ' + value + ' ';
}
@@ -48871,17 +44556,18 @@ function inlineCode$1(node, parent, context) {
// transformed to spaces when going from markdown to HTML anyway, we can swap
// them out.
while (++index < context.unsafe.length) {
- pattern = context.unsafe[index];
+ const pattern = context.unsafe[index];
+ const expression = patternCompile(pattern);
+ /** @type {RegExpExecArray|null} */
+ let match;
// Only look for `atBreak`s.
// Btw: note that `atBreak` patterns will always start the regex at LF or
// CR.
if (!pattern.atBreak) continue
- expression = patternCompile$1(pattern);
-
while ((match = expression.exec(value))) {
- position = match.index;
+ let position = match.index;
// Support CRLF (patterns only look for one of the characters).
if (
@@ -48898,59 +44584,75 @@ function inlineCode$1(node, parent, context) {
return sequence + value + sequence
}
-function inlineCodePeek$1() {
+/**
+ * @type {Handle}
+ */
+function inlineCodePeek() {
return '`'
}
-var formatLinkAsAutolink_1 = formatLinkAsAutolink$1;
-
-var toString$1 = mdastUtilToString;
+/**
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../types.js').Context} Context
+ */
-function formatLinkAsAutolink$1(node, context) {
- var raw = toString$1(node);
+/**
+ * @param {Link} node
+ * @param {Context} context
+ * @returns {boolean}
+ */
+function formatLinkAsAutolink(node, context) {
+ const raw = toString(node);
- return (
+ return Boolean(
!context.options.resourceLink &&
- // If there’s a url…
- node.url &&
- // And there’s a no title…
- !node.title &&
- // And the content of `node` is a single text node…
- node.children &&
- node.children.length === 1 &&
- node.children[0].type === 'text' &&
- // And if the url is the same as the content…
- (raw === node.url || 'mailto:' + raw === node.url) &&
- // And that starts w/ a protocol…
- /^[a-z][a-z+.-]+:/i.test(node.url) &&
- // And that doesn’t contain ASCII control codes (character escapes and
- // references don’t work) or angle brackets…
- !/[\0- <>\u007F]/.test(node.url)
+ // If there’s a url…
+ node.url &&
+ // And there’s a no title…
+ !node.title &&
+ // And the content of `node` is a single text node…
+ node.children &&
+ node.children.length === 1 &&
+ node.children[0].type === 'text' &&
+ // And if the url is the same as the content…
+ (raw === node.url || 'mailto:' + raw === node.url) &&
+ // And that starts w/ a protocol…
+ /^[a-z][a-z+.-]+:/i.test(node.url) &&
+ // And that doesn’t contain ASCII control codes (character escapes and
+ // references don’t work) or angle brackets…
+ !/[\0- <>\u007F]/.test(node.url)
)
}
-var link_1 = link;
-link.peek = linkPeek;
+/**
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('../types.js').Exit} Exit
+ */
-var checkQuote = checkQuote_1;
-var formatLinkAsAutolink = formatLinkAsAutolink_1;
-var phrasing$3 = containerPhrasing$1;
-var safe$2 = safe_1;
+link.peek = linkPeek;
+/**
+ * @type {Handle}
+ * @param {Link} node
+ */
function link(node, _, context) {
- var quote = checkQuote(context);
- var suffix = quote === '"' ? 'Quote' : 'Apostrophe';
- var exit;
- var subexit;
- var value;
- var stack;
+ const quote = checkQuote(context);
+ const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
+ /** @type {Exit} */
+ let exit;
+ /** @type {Exit} */
+ let subexit;
+ /** @type {string} */
+ let value;
if (formatLinkAsAutolink(node, context)) {
// Hide the fact that we’re in phrasing, because escapes don’t work.
- stack = context.stack;
+ const stack = context.stack;
context.stack = [];
exit = context.enter('autolink');
- value = '<' + phrasing$3(node, context, {before: '<', after: '>'}) + '>';
+ value =
+ '<' + containerPhrasing(node, context, {before: '<', after: '>'}) + '>';
exit();
context.stack = stack;
return value
@@ -48958,7 +44660,8 @@ function link(node, _, context) {
exit = context.enter('link');
subexit = context.enter('label');
- value = '[' + phrasing$3(node, context, {before: '[', after: ']'}) + '](';
+ value =
+ '[' + containerPhrasing(node, context, {before: '[', after: ']'}) + '](';
subexit();
if (
@@ -48968,11 +44671,11 @@ function link(node, _, context) {
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
- value += '<' + safe$2(context, node.url, {before: '<', after: '>'}) + '>';
+ value += '<' + safe(context, node.url, {before: '<', after: '>'}) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
- value += safe$2(context, node.url, {
+ value += safe(context, node.url, {
before: '(',
after: node.title ? ' ' : ')'
});
@@ -48985,7 +44688,7 @@ function link(node, _, context) {
value +=
' ' +
quote +
- safe$2(context, node.title, {before: quote, after: quote}) +
+ safe(context, node.title, {before: quote, after: quote}) +
quote;
subexit();
}
@@ -48996,32 +44699,38 @@ function link(node, _, context) {
return value
}
+/**
+ * @type {Handle}
+ * @param {Link} node
+ */
function linkPeek(node, _, context) {
return formatLinkAsAutolink(node, context) ? '<' : '['
}
-var linkReference_1 = linkReference;
-linkReference.peek = linkReferencePeek;
+/**
+ * @typedef {import('mdast').LinkReference} LinkReference
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var association = association_1;
-var phrasing$2 = containerPhrasing$1;
-var safe$1 = safe_1;
+linkReference.peek = linkReferencePeek;
+/**
+ * @type {Handle}
+ * @param {LinkReference} node
+ */
function linkReference(node, _, context) {
- var type = node.referenceType;
- var exit = context.enter('linkReference');
- var subexit = context.enter('label');
- var text = phrasing$2(node, context, {before: '[', after: ']'});
- var value = '[' + text + ']';
- var reference;
- var stack;
+ const type = node.referenceType;
+ const exit = context.enter('linkReference');
+ let subexit = context.enter('label');
+ const text = containerPhrasing(node, context, {before: '[', after: ']'});
+ let value = '[' + text + ']';
subexit();
// Hide the fact that we’re in phrasing, because escapes don’t work.
- stack = context.stack;
+ const stack = context.stack;
context.stack = [];
subexit = context.enter('reference');
- reference = safe$1(context, association(node), {before: '[', after: ']'});
+ const reference = safe(context, association(node), {before: '[', after: ']'});
subexit();
context.stack = stack;
exit();
@@ -49035,25 +44744,40 @@ function linkReference(node, _, context) {
return value
}
+/**
+ * @type {Handle}
+ */
function linkReferencePeek() {
return '['
}
-var list_1 = list;
-
-var flow$2 = containerFlow$1;
+/**
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../types.js').Handle} Handle
+ */
+/**
+ * @type {Handle}
+ * @param {List} node
+ */
function list(node, _, context) {
- var exit = context.enter('list');
- var value = flow$2(node, context);
+ const exit = context.enter('list');
+ const value = containerFlow(node, context);
exit();
return value
}
-var checkBullet_1 = checkBullet$2;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkBullet$2(context) {
- var marker = context.options.bullet || '*';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['bullet'], undefined>}
+ */
+function checkBullet(context) {
+ const marker = context.options.bullet || '*';
if (marker !== '*' && marker !== '+' && marker !== '-') {
throw new Error(
@@ -49066,11 +44790,20 @@ function checkBullet$2(context) {
return marker
}
-var checkListItemIndent_1 = checkListItemIndent$2;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkListItemIndent$2(context) {
- var style = context.options.listItemIndent || 'tab';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['listItemIndent'], undefined>}
+ */
+function checkListItemIndent(context) {
+ const style = context.options.listItemIndent || 'tab';
+ // To do: remove in a major.
+ // @ts-expect-error: deprecated.
if (style === 1 || style === '1') {
return 'one'
}
@@ -49086,79 +44819,102 @@ function checkListItemIndent$2(context) {
return style
}
-var listItem_1 = listItem$1;
-
-var repeat$2 = repeatString;
-var checkBullet$1 = checkBullet_1;
-var checkListItemIndent$1 = checkListItemIndent_1;
-var flow$1 = containerFlow$1;
-var indentLines$1 = indentLines_1;
+/**
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../util/indent-lines.js').Map} Map
+ * @typedef {import('../types.js').Options} Options
+ * @typedef {import('../types.js').Handle} Handle
+ */
-function listItem$1(node, parent, context) {
- var bullet = checkBullet$1(context);
- var listItemIndent = checkListItemIndent$1(context);
- var size;
- var value;
- var exit;
+/**
+ * @type {Handle}
+ * @param {ListItem} node
+ */
+function listItem(node, parent, context) {
+ const listItemIndent = checkListItemIndent(context);
+ /** @type {string} */
+ let bullet = checkBullet(context);
- if (parent && parent.ordered) {
+ if (parent && parent.type === 'list' && parent.ordered) {
bullet =
- (parent.start > -1 ? parent.start : 1) +
+ (typeof parent.start === 'number' && parent.start > -1
+ ? parent.start
+ : 1) +
(context.options.incrementListMarker === false
? 0
: parent.children.indexOf(node)) +
'.';
}
- size = bullet.length + 1;
+ let size = bullet.length + 1;
if (
listItemIndent === 'tab' ||
- (listItemIndent === 'mixed' && ((parent && parent.spread) || node.spread))
+ (listItemIndent === 'mixed' &&
+ ((parent && 'spread' in parent && parent.spread) || node.spread))
) {
size = Math.ceil(size / 4) * 4;
}
- exit = context.enter('listItem');
- value = indentLines$1(flow$1(node, context), map);
+ const exit = context.enter('listItem');
+ const value = indentLines(containerFlow(node, context), map);
exit();
return value
+ /** @type {Map} */
function map(line, index, blank) {
if (index) {
- return (blank ? '' : repeat$2(' ', size)) + line
+ return (blank ? '' : ' '.repeat(size)) + line
}
- return (blank ? bullet : bullet + repeat$2(' ', size - bullet.length)) + line
+ return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
}
}
-var paragraph_1 = paragraph;
-
-var phrasing$1 = containerPhrasing$1;
+/**
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('../types.js').Handle} Handle
+ */
+/**
+ * @type {Handle}
+ * @param {Paragraph} node
+ */
function paragraph(node, _, context) {
- var exit = context.enter('paragraph');
- var subexit = context.enter('phrasing');
- var value = phrasing$1(node, context, {before: '\n', after: '\n'});
+ const exit = context.enter('paragraph');
+ const subexit = context.enter('phrasing');
+ const value = containerPhrasing(node, context, {before: '\n', after: '\n'});
subexit();
exit();
return value
}
-var root_1 = root;
-
-var flow = containerFlow$1;
+/**
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('../types.js').Handle} Handle
+ */
+/**
+ * @type {Handle}
+ * @param {Root} node
+ */
function root(node, _, context) {
- return flow(node, context)
+ return containerFlow(node, context)
}
-var checkStrong_1 = checkStrong$1;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkStrong$1(context) {
- var marker = context.options.strong || '*';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['strong'], undefined>}
+ */
+function checkStrong(context) {
+ const marker = context.options.strong || '*';
if (marker !== '*' && marker !== '_') {
throw new Error(
@@ -49171,40 +44927,64 @@ function checkStrong$1(context) {
return marker
}
-var strong_1 = strong;
-strong.peek = strongPeek;
+/**
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../types.js').Handle} Handle
+ */
-var checkStrong = checkStrong_1;
-var phrasing = containerPhrasing$1;
+strong.peek = strongPeek;
// To do: there are cases where emphasis cannot “form” depending on the
// previous or next character of sequences.
// There’s no way around that though, except for injecting zero-width stuff.
// Do we need to safeguard against that?
+/**
+ * @type {Handle}
+ * @param {Strong} node
+ */
function strong(node, _, context) {
- var marker = checkStrong(context);
- var exit = context.enter('strong');
- var value = phrasing(node, context, {before: marker, after: marker});
+ const marker = checkStrong(context);
+ const exit = context.enter('strong');
+ const value = containerPhrasing(node, context, {
+ before: marker,
+ after: marker
+ });
exit();
return marker + marker + value + marker + marker
}
-function strongPeek(node, _, context) {
+/**
+ * @type {Handle}
+ * @param {Strong} _
+ */
+function strongPeek(_, _1, context) {
return context.options.strong || '*'
}
-var text_1 = text$1;
-
-var safe = safe_1;
+/**
+ * @typedef {import('mdast').Text} Text
+ * @typedef {import('../types.js').Handle} Handle
+ */
-function text$1(node, parent, context, safeOptions) {
+/**
+ * @type {Handle}
+ * @param {Text} node
+ */
+function text$1(node, _, context, safeOptions) {
return safe(context, node.value, safeOptions)
}
-var checkRuleRepeat = checkRule$2;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkRule$2(context) {
- var repetition = context.options.ruleRepetition || 3;
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['ruleRepetition'], undefined>}
+ */
+function checkRuleRepetition(context) {
+ const repetition = context.options.ruleRepetition || 3;
if (repetition < 3) {
throw new Error(
@@ -49217,10 +44997,17 @@ function checkRule$2(context) {
return repetition
}
-var checkRule_1 = checkRule$1;
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
-function checkRule$1(context) {
- var marker = context.options.rule || '*';
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['rule'], undefined>}
+ */
+function checkRule(context) {
+ const marker = context.options.rule || '*';
if (marker !== '*' && marker !== '-' && marker !== '_') {
throw new Error(
@@ -49233,47 +45020,54 @@ function checkRule$1(context) {
return marker
}
-var thematicBreak_1 = thematicBreak;
-
-var repeat$1 = repeatString;
-var checkRepeat = checkRuleRepeat;
-var checkRule = checkRule_1;
+/**
+ * @typedef {import('../types.js').Handle} Handle
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ */
-function thematicBreak(node, parent, context) {
- var value = repeat$1(
- checkRule(context) + (context.options.ruleSpaces ? ' ' : ''),
- checkRepeat(context)
- );
+/**
+ * @type {Handle}
+ * @param {ThematicBreak} _
+ */
+function thematicBreak(_, _1, context) {
+ const value = (
+ checkRule(context) + (context.options.ruleSpaces ? ' ' : '')
+ ).repeat(checkRuleRepetition(context));
return context.options.ruleSpaces ? value.slice(0, -1) : value
}
-handle.blockquote = blockquote_1;
-handle.break = _break;
-handle.code = code_1;
-handle.definition = definition_1;
-handle.emphasis = emphasis_1;
-handle.hardBreak = _break;
-handle.heading = heading_1;
-handle.html = html_1;
-handle.image = image_1;
-handle.imageReference = imageReference_1;
-handle.inlineCode = inlineCode_1;
-handle.link = link_1;
-handle.linkReference = linkReference_1;
-handle.list = list_1;
-handle.listItem = listItem_1;
-handle.paragraph = paragraph_1;
-handle.root = root_1;
-handle.strong = strong_1;
-handle.text = text_1;
-handle.thematicBreak = thematicBreak_1;
-
-var join = [joinDefaults];
-
-var formatCodeAsIndented = formatCodeAsIndented_1;
-var formatHeadingAsSetext = formatHeadingAsSetext_1;
+const handle = {
+ blockquote,
+ break: hardBreak,
+ code: code$1,
+ definition,
+ emphasis,
+ hardBreak,
+ heading,
+ html,
+ image,
+ imageReference,
+ inlineCode,
+ link,
+ linkReference,
+ list,
+ listItem,
+ paragraph,
+ root,
+ strong,
+ text: text$1,
+ thematicBreak
+};
+/**
+ * @typedef {import('./types.js').Join} Join
+ */
+
+/** @type {Array.<Join>} */
+const join = [joinDefaults];
+
+/** @type {Join} */
function joinDefaults(left, right, parent, context) {
if (
// Two lists with the same marker.
@@ -49291,7 +45085,7 @@ function joinDefaults(left, right, parent, context) {
// Join children of a list or an item.
// In which case, `parent` has a `spread` field.
- if (typeof parent.spread === 'boolean') {
+ if ('spread' in parent && typeof parent.spread === 'boolean') {
if (
left.type === 'paragraph' &&
// Two paragraphs.
@@ -49307,7 +45101,12 @@ function joinDefaults(left, right, parent, context) {
}
}
-var unsafe = [
+/**
+ * @typedef {import('./types.js').Unsafe} Unsafe
+ */
+
+/** @type {Array.<Unsafe>} */
+const unsafe = [
{
character: '\t',
inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']
@@ -49418,44 +45217,49 @@ var unsafe = [
{atBreak: true, character: '~'}
];
-var lib = toMarkdown$1;
-
-var zwitch = zwitch$1;
-var configure = configure_1;
-var defaultHandlers = handle;
-var defaultJoin = join;
-var defaultUnsafe = unsafe;
+/**
+ * @typedef {import('./types.js').Node} Node
+ * @typedef {import('./types.js').Options} Options
+ * @typedef {import('./types.js').Context} Context
+ * @typedef {import('./types.js').Handle} Handle
+ * @typedef {import('./types.js').Join} Join
+ * @typedef {import('./types.js').Unsafe} Unsafe
+ */
-function toMarkdown$1(tree, options) {
- var settings = options || {};
- var context = {
- enter: enter,
+/**
+ * @param {Node} tree
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function toMarkdown(tree, options = {}) {
+ /** @type {Context} */
+ // @ts-expect-error: we’ll add `handle` later.
+ const context = {
+ enter,
stack: [],
unsafe: [],
join: [],
handlers: {},
options: {}
};
- var result;
- configure(context, {
- unsafe: defaultUnsafe,
- join: defaultJoin,
- handlers: defaultHandlers
- });
- configure(context, settings);
+ configure(context, {unsafe, join, handlers: handle});
+ configure(context, options);
if (context.options.tightDefinitions) {
- context.join = [joinDefinition].concat(context.join);
+ configure(context, {join: [joinDefinition]});
}
+ /** @type {Handle} */
context.handle = zwitch('type', {
- invalid: invalid,
- unknown: unknown,
+ invalid,
+ // @ts-expect-error: hush.
+ unknown,
+ // @ts-expect-error: hush.
handlers: context.handlers
});
- result = context.handle(tree, null, context, {before: '\n', after: '\n'});
+ let result = context.handle(tree, null, context, {before: '\n', after: '\n'});
if (
result &&
@@ -49467,6 +45271,7 @@ function toMarkdown$1(tree, options) {
return result
+ /** @type {Context['enter']} */
function enter(name) {
context.stack.push(name);
return exit
@@ -49477,14 +45282,23 @@ function toMarkdown$1(tree, options) {
}
}
+/**
+ * @type {Handle}
+ * @param {unknown} value
+ */
function invalid(value) {
throw new Error('Cannot handle value `' + value + '`, expected node')
}
+/**
+ * @type {Handle}
+ * @param {Node} node
+ */
function unknown(node) {
throw new Error('Cannot handle unknown node `' + node.type + '`')
}
+/** @type {Join} */
function joinDefinition(left, right) {
// No blank line between adjacent definitions.
if (left.type === 'definition' && left.type === right.type) {
@@ -49492,38 +45306,36 @@ function joinDefinition(left, right) {
}
}
-var mdastUtilToMarkdown = lib;
-
-var remarkStringify = stringify$1;
-
-var toMarkdown = mdastUtilToMarkdown;
-
-function stringify$1(options) {
- var self = this;
+/**
+ * @typedef {import('mdast').Root|import('mdast').Content} Node
+ * @typedef {import('mdast-util-to-markdown').Options} Options
+ */
- this.Compiler = compile;
+/** @type {import('unified').Plugin<[Options]|void[], Node, string>} */
+function remarkStringify(options) {
+ /** @type {import('unified').CompilerFunction<Node, string>} */
+ const compiler = (tree) => {
+ // Assume options.
+ const settings = /** @type {Options} */ (this.data('settings'));
- function compile(tree) {
return toMarkdown(
tree,
- Object.assign({}, self.data('settings'), options, {
+ Object.assign({}, settings, options, {
// Note: this option is not in the readme.
// The goal is for it to be set by plugins on `data` instead of being
// passed by users.
- extensions: self.data('toMarkdownExtensions') || []
+ extensions: this.data('toMarkdownExtensions') || []
})
)
- }
-}
+ };
-var unified = unified_1;
-var parse$1 = remarkParse;
-var stringify = remarkStringify;
+ Object.assign(this, {Compiler: compiler});
+}
-var remark = unified().use(parse$1).use(stringify).freeze();
+const remark = unified().use(remarkParse).use(remarkStringify).freeze();
const name$1 = "remark";
-const version$1 = "13.0.0";
+const version$1 = "14.0.1";
const description$1 = "Markdown processor powered by plugins part of the unified collective";
const license = "MIT";
const keywords = [
@@ -49552,21 +45364,32 @@ const author = "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)";
const contributors = [
"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
];
+const sideEffects = false;
+const type = "module";
+const main$1 = "index.js";
+const types = "index.d.ts";
const files = [
- "index.js",
- "types/index.d.ts"
+ "index.d.ts",
+ "index.js"
];
-const types$1 = "types/index.d.ts";
const dependencies$1 = {
- "remark-parse": "^9.0.0",
- "remark-stringify": "^9.0.0",
- unified: "^9.1.0"
+ "@types/mdast": "^3.0.0",
+ "remark-parse": "^10.0.0",
+ "remark-stringify": "^10.0.0",
+ unified: "^10.0.0"
};
const scripts$1 = {
- test: "tape test.js"
+ test: "node --conditions development test.js",
+ build: "rimraf \"*.d.ts\" && tsc && type-coverage"
};
const xo = false;
-var require$$3 = {
+const typeCoverage = {
+ atLeast: 100,
+ detail: true,
+ strict: true,
+ ignoreCatch: true
+};
+var proc = {
name: name$1,
version: version$1,
description: description$1,
@@ -49578,11 +45401,15 @@ var require$$3 = {
funding: funding,
author: author,
contributors: contributors,
+ sideEffects: sideEffects,
+ type: type,
+ main: main$1,
+ types: types,
files: files,
- types: types$1,
dependencies: dependencies$1,
scripts: scripts$1,
- xo: xo
+ xo: xo,
+ typeCoverage: typeCoverage
};
const name = "node-lint-md-cli-rollup";
@@ -49597,17 +45424,17 @@ const devDependencies = {
};
const dependencies = {
"markdown-extensions": "^1.1.1",
- remark: "^13.0.0",
+ remark: "^14.0.0",
"remark-gfm": "^2.0.0",
"remark-preset-lint-node": "^3.0.0",
- "unified-args": "^8.1.0"
+ "unified-args": "^9.0.0"
};
const main = "dist/index.js";
const scripts = {
build: "npx rollup -c",
- "build-node": "npm run build && npx shx cp dist/index.js ../lint-md.js"
+ "build-node": "npm run build && npx shx cp dist/index.mjs ../lint-md.mjs"
};
-var require$$4 = {
+var cli = {
name: name,
description: description,
version: version,
@@ -49708,7 +45535,7 @@ function location(file) {
* @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
*/
-const convert$2 =
+const convert =
/**
* @type {(
* (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
@@ -49728,15 +45555,15 @@ const convert$2 =
*/
function (test) {
if (test === undefined || test === null) {
- return ok$1
+ return ok
}
if (typeof test === 'string') {
- return typeFactory$1(test)
+ return typeFactory(test)
}
if (typeof test === 'object') {
- return Array.isArray(test) ? anyFactory$1(test) : propsFactory(test)
+ return Array.isArray(test) ? anyFactory(test) : propsFactory(test)
}
if (typeof test === 'function') {
@@ -49750,13 +45577,13 @@ const convert$2 =
* @param {Array.<Type|Props|TestFunctionAnything>} tests
* @returns {AssertAnything}
*/
-function anyFactory$1(tests) {
+function anyFactory(tests) {
/** @type {Array.<AssertAnything>} */
const checks = [];
let index = -1;
while (++index < tests.length) {
- checks[index] = convert$2(tests[index]);
+ checks[index] = convert(tests[index]);
}
return castFactory(any)
@@ -49811,7 +45638,7 @@ function propsFactory(check) {
* @param {Type} check
* @returns {AssertAnything}
*/
-function typeFactory$1(check) {
+function typeFactory(check) {
return castFactory(type)
/**
@@ -49843,7 +45670,7 @@ function castFactory(check) {
}
// Utility to return true.
-function ok$1() {
+function ok() {
return true
}
@@ -49851,7 +45678,7 @@ function ok$1() {
* @param {string} d
* @returns {string}
*/
-function color$3(d) {
+function color$2(d) {
return '\u001B[33m' + d + '\u001B[39m'
}
@@ -49864,17 +45691,17 @@ function color$3(d) {
/**
* Continue traversing as normal
*/
-const CONTINUE$3 = true;
+const CONTINUE$2 = true;
/**
* Do not traverse this node’s children
*/
-const SKIP$3 = 'skip';
+const SKIP$2 = 'skip';
/**
* Stop traversing immediately
*/
-const EXIT$3 = false;
+const EXIT$2 = false;
-const visitParents$3 =
+const visitParents$2 =
/**
* @type {(
* (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
@@ -49899,7 +45726,7 @@ const visitParents$3 =
test = null;
}
- var is = convert$2(test);
+ var is = convert(test);
var step = reverse ? -1 : 1;
factory(tree, null, [])();
@@ -49926,7 +45753,7 @@ const visitParents$3 =
Object.defineProperty(visit, 'name', {
value:
'node (' +
- color$3(value.type + (name ? '<' + name + '>' : '')) +
+ color$2(value.type + (name ? '<' + name + '>' : '')) +
')'
});
}
@@ -49946,12 +45773,12 @@ const visitParents$3 =
if (!test || is(node, index, parents[parents.length - 1] || null)) {
result = toResult$2(visitor(node, parents));
- if (result[0] === EXIT$3) {
+ if (result[0] === EXIT$2) {
return result
}
}
- if (node.children && result[0] !== SKIP$3) {
+ if (node.children && result[0] !== SKIP$2) {
// @ts-ignore looks like a parent.
offset = (reverse ? node.children.length : -1) + step;
// @ts-ignore looks like a parent.
@@ -49961,7 +45788,7 @@ const visitParents$3 =
while (offset > -1 && offset < node.children.length) {
subresult = factory(node.children[offset], offset, grandparents)();
- if (subresult[0] === EXIT$3) {
+ if (subresult[0] === EXIT$2) {
return subresult
}
@@ -49986,7 +45813,7 @@ function toResult$2(value) {
}
if (typeof value === 'number') {
- return [CONTINUE$3, value]
+ return [CONTINUE$2, value]
}
return [value]
@@ -49999,7 +45826,7 @@ function toResult$2(value) {
* @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
*/
-const visit$3 =
+const visit$1 =
/**
* @type {(
* (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
@@ -50023,7 +45850,7 @@ const visit$3 =
test = null;
}
- visitParents$3(tree, test, overload, reverse);
+ visitParents$2(tree, test, overload, reverse);
/**
* @param {Node} node
@@ -50113,7 +45940,7 @@ const visit$3 =
* @property {boolean} state
*/
-const own$4 = {}.hasOwnProperty;
+const own$2 = {}.hasOwnProperty;
/**
* @type {import('unified').Plugin<[Options]>}
@@ -50155,7 +45982,7 @@ function messageControl(options) {
/** @type {Mark[]} */
const globals = [];
- visit$3(tree, options.test, visitor);
+ visit$1(tree, options.test, visitor);
file.messages = file.messages.filter((m) => filter(m));
@@ -50323,7 +46150,7 @@ function messageControl(options) {
// Toggle all known rules.
if (!ruleId) {
for (ruleId in scope) {
- if (own$4.call(scope, ruleId)) {
+ if (own$2.call(scope, ruleId)) {
toggle(point, state, ruleId);
}
}
@@ -50390,7 +46217,7 @@ function detectGaps(tree, file) {
let gap;
// Find all gaps.
- visit$3(tree, one);
+ visit$1(tree, one);
// Get the end of the document.
// This detects if the last node was the last node.
@@ -50608,92 +46435,6 @@ function lintMessageControl() {
}
/**
- * @typedef {(error?: Error|null|undefined, ...output: any[]) => void} Callback
- * @typedef {(...input: any[]) => any} Middleware
- *
- * @typedef {(...input: any[]) => void} Run Call all middleware.
- * @typedef {(fn: Middleware) => Pipeline} Use Add `fn` (middleware) to the list.
- * @typedef {{run: Run, use: Use}} Pipeline
- */
-
-/**
- * Wrap `middleware`.
- * Can be sync or async; return a promise, receive a callback, or return new
- * values and errors.
- *
- * @param {Middleware} middleware
- * @param {Callback} callback
- */
-function wrap(middleware, callback) {
- /** @type {boolean} */
- let called;
-
- return wrapped
-
- /**
- * Call `middleware`.
- * @param {any[]} parameters
- * @returns {void}
- */
- function wrapped(...parameters) {
- const fnExpectsCallback = middleware.length > parameters.length;
- /** @type {any} */
- let result;
-
- if (fnExpectsCallback) {
- parameters.push(done);
- }
-
- try {
- result = middleware(...parameters);
- } catch (error) {
- /** @type {Error} */
- const exception = error;
-
- // Well, this is quite the pickle.
- // `middleware` received a callback and called it synchronously, but that
- // threw an error.
- // The only thing left to do is to throw the thing instead.
- if (fnExpectsCallback && called) {
- throw exception
- }
-
- return done(exception)
- }
-
- if (!fnExpectsCallback) {
- if (result instanceof Promise) {
- result.then(then, done);
- } else if (result instanceof Error) {
- done(result);
- } else {
- then(result);
- }
- }
- }
-
- /**
- * Call `callback`, only once.
- * @type {Callback}
- */
- function done(error, ...output) {
- if (!called) {
- called = true;
- callback(error, ...output);
- }
- }
-
- /**
- * Call `done` with one value.
- *
- * @param {any} [value]
- */
- function then(value) {
- done(null, value);
- }
-}
-
-/**
* @typedef {import('unist').Node} Node
* @typedef {import('vfile').VFile} VFile
*
@@ -50708,13 +46449,13 @@ function wrap(middleware, callback) {
* @returns {void}
*/
-const primitives = new Set(['string', 'number', 'boolean']);
+const primitives$G = new Set(['string', 'number', 'boolean']);
/**
* @param {string} id
* @param {Rule} rule
*/
-function lintRule(id, rule) {
+function lintRule$G(id, rule) {
const parts = id.split(':');
// Possibly useful if externalised later.
/* c8 ignore next */
@@ -50727,7 +46468,7 @@ function lintRule(id, rule) {
/** @type {import('unified').Plugin<[unknown]|void[]>} */
function plugin(raw) {
- const [severity, options] = coerce$2(ruleId, raw);
+ const [severity, options] = coerce$H(ruleId, raw);
if (!severity) return
@@ -50766,7 +46507,7 @@ function lintRule(id, rule) {
* @param {unknown} value
* @returns {SeverityTuple}
*/
-function coerce$2(name, value) {
+function coerce$H(name, value) {
/** @type {unknown[]} */
let result;
@@ -50778,7 +46519,7 @@ function coerce$2(name, value) {
Array.isArray(value) &&
// `isArray(unknown)` is turned into `any[]`:
// type-coverage:ignore-next-line
- primitives.has(typeof value[0])
+ primitives$G.has(typeof value[0])
) {
// `isArray(unknown)` is turned into `any[]`:
// type-coverage:ignore-next-line
@@ -50873,7 +46614,7 @@ function coerce$2(name, value) {
* ```
*/
-const remarkLintFinalNewline = lintRule(
+const remarkLintFinalNewline = lintRule$G(
'remark-lint:final-newline',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(_, file) => {
@@ -50888,6 +46629,134 @@ const remarkLintFinalNewline = lintRule(
var remarkLintFinalNewline$1 = remarkLintFinalNewline;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$F = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$F(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$G(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$G(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$F.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
var pluralize = {exports: {}};
/* global define */
@@ -51397,7 +47266,7 @@ var plural = pluralize.exports;
* @param {string} d
* @returns {string}
*/
-function color$2(d) {
+function color$1(d) {
return '\u001B[33m' + d + '\u001B[39m'
}
@@ -51410,15 +47279,15 @@ function color$2(d) {
/**
* Continue traversing as normal
*/
-const CONTINUE$2 = true;
+const CONTINUE$1 = true;
/**
* Do not traverse this node’s children
*/
-const SKIP$2 = 'skip';
+const SKIP$1 = 'skip';
/**
* Stop traversing immediately
*/
-const EXIT$2 = false;
+const EXIT$1 = false;
/**
* Visit children of tree which pass a test
@@ -51428,7 +47297,7 @@ const EXIT$2 = false;
* @param visitor Function to run for each node
* @param reverse Visit the tree in reverse order, defaults to false
*/
-const visitParents$2 =
+const visitParents$1 =
/**
* @type {(
* (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: Visitor<import('./complex-types').Matches<import('./complex-types').InclusiveDescendant<Tree>, Check>>, reverse?: boolean) => void) &
@@ -51450,7 +47319,7 @@ const visitParents$2 =
test = null;
}
- const is = convert$2(test);
+ const is = convert(test);
const step = reverse ? -1 : 1;
factory(tree, null, [])();
@@ -51478,7 +47347,7 @@ const visitParents$2 =
Object.defineProperty(visit, 'name', {
value:
'node (' +
- color$2(value.type + (name ? '<' + name + '>' : '')) +
+ color$1(value.type + (name ? '<' + name + '>' : '')) +
')'
});
}
@@ -51498,13 +47367,13 @@ const visitParents$2 =
if (!test || is(node, index, parents[parents.length - 1] || null)) {
result = toResult$1(visitor(node, parents));
- if (result[0] === EXIT$2) {
+ if (result[0] === EXIT$1) {
return result
}
}
// @ts-expect-error looks like a parent.
- if (node.children && result[0] !== SKIP$2) {
+ if (node.children && result[0] !== SKIP$1) {
// @ts-expect-error looks like a parent.
offset = (reverse ? node.children.length : -1) + step;
// @ts-expect-error looks like a parent.
@@ -51515,7 +47384,7 @@ const visitParents$2 =
// @ts-expect-error looks like a parent.
subresult = factory(node.children[offset], offset, grandparents)();
- if (subresult[0] === EXIT$2) {
+ if (subresult[0] === EXIT$1) {
return subresult
}
@@ -51540,7 +47409,7 @@ function toResult$1(value) {
}
if (typeof value === 'number') {
- return [CONTINUE$2, value]
+ return [CONTINUE$1, value]
}
return [value]
@@ -51561,7 +47430,7 @@ function toResult$1(value) {
* @param visitor Function to run for each node
* @param reverse Fisit the tree in reverse, defaults to false
*/
-const visit$2 =
+const visit =
/**
* @type {(
* (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: Visitor<import('unist-util-visit-parents/complex-types').Matches<import('unist-util-visit-parents/complex-types').InclusiveDescendant<Tree>, Check>>, reverse?: boolean) => void) &
@@ -51582,7 +47451,7 @@ const visit$2 =
test = null;
}
- visitParents$2(tree, test, overload, reverse);
+ visitParents$1(tree, test, overload, reverse);
/**
* @param {Node} node
@@ -51638,11 +47507,11 @@ const visit$2 =
* 4:2: Incorrect indentation before bullet: remove 1 space
*/
-const remarkLintListItemBulletIndent = lintRule(
+const remarkLintListItemBulletIndent = lintRule$F(
'remark-lint:list-item-bullet-indent',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'list', (list, _, grandparent) => {
+ visit(tree, 'list', (list, _, grandparent) => {
let index = -1;
while (++index < list.children.length) {
@@ -51677,6 +47546,134 @@ const remarkLintListItemBulletIndent = lintRule(
var remarkLintListItemBulletIndent$1 = remarkLintListItemBulletIndent;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$E = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$E(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$F(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$F(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$E.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @typedef {import('unist').Position} Position
* @typedef {import('unist').Point} Point
*
@@ -51690,15 +47687,15 @@ var remarkLintListItemBulletIndent$1 = remarkLintListItemBulletIndent;
* @property {PositionLike} [position]
*/
-var pointStart = point$2('start');
-var pointEnd = point$2('end');
+var pointStart = point('start');
+var pointEnd = point('end');
/**
* Get the positional info of `node`.
*
* @param {'start'|'end'} type
*/
-function point$2(type) {
+function point(type) {
return point
/**
@@ -51868,7 +47865,7 @@ function generated(node) {
* 1:1: Incorrect list-item indent style `💩`: use either `'tab-size'`, `'space'`, or `'mixed'`
*/
-const remarkLintListItemIndent = lintRule(
+const remarkLintListItemIndent = lintRule$E(
'remark-lint:list-item-indent',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'tab-size') => {
@@ -51882,7 +47879,7 @@ const remarkLintListItemIndent = lintRule(
);
}
- visit$2(tree, 'list', (node) => {
+ visit(tree, 'list', (node) => {
if (generated(node)) return
const spread = node.spread;
@@ -51926,59 +47923,131 @@ const remarkLintListItemIndent = lintRule(
var remarkLintListItemIndent$1 = remarkLintListItemIndent;
/**
- * @typedef Options
- * @property {boolean} [includeImageAlt=true]
- */
-
-/**
- * Get the text content of a node.
- * Prefer the node’s plain-text fields, otherwise serialize its children,
- * and if the given value is an array, serialize the nodes in it.
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
*
- * @param {unknown} node
- * @param {Options} [options]
- * @returns {string}
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
*/
-function toString(node, options) {
- var {includeImageAlt = true} = options || {};
- return one(node, includeImageAlt)
-}
+
+const primitives$D = new Set(['string', 'number', 'boolean']);
/**
- * @param {unknown} node
- * @param {boolean} includeImageAlt
- * @returns {string}
+ * @param {string} id
+ * @param {Rule} rule
*/
-function one(node, includeImageAlt) {
- return (
- (node &&
- typeof node === 'object' &&
- // @ts-ignore looks like a literal.
- (node.value ||
- // @ts-ignore looks like an image.
- (includeImageAlt ? node.alt : '') ||
- // @ts-ignore looks like a parent.
- ('children' in node && all(node.children, includeImageAlt)) ||
- (Array.isArray(node) && all(node, includeImageAlt)))) ||
- ''
- )
+function lintRule$D(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$E(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
}
/**
- * @param {Array.<unknown>} values
- * @param {boolean} includeImageAlt
- * @returns {string}
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
*/
-function all(values, includeImageAlt) {
- /** @type {Array.<string>} */
- var result = [];
- var index = -1;
+function coerce$E(name, value) {
+ /** @type {unknown[]} */
+ let result;
- while (++index < values.length) {
- result[index] = one(values[index], includeImageAlt);
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$D.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
}
- return result.join('')
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
}
/**
@@ -52023,11 +48092,11 @@ function all(values, includeImageAlt) {
// See: <https://en.wikipedia.org/wiki/URI_scheme#Generic_syntax>.
const protocol = /^[a-z][a-z+.-]+:\/?/i;
-const remarkLintNoAutoLinkWithoutProtocol = lintRule(
+const remarkLintNoAutoLinkWithoutProtocol = lintRule$D(
'remark-lint:no-auto-link-without-protocol',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'link', (node) => {
+ visit(tree, 'link', (node) => {
if (
!generated(node) &&
pointStart(node).column === pointStart(node.children[0]).column - 1 &&
@@ -52044,6 +48113,134 @@ const remarkLintNoAutoLinkWithoutProtocol = lintRule(
var remarkLintNoAutoLinkWithoutProtocol$1 = remarkLintNoAutoLinkWithoutProtocol;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$C = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$C(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$D(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$D(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$C.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52100,14 +48297,14 @@ var remarkLintNoAutoLinkWithoutProtocol$1 = remarkLintNoAutoLinkWithoutProtocol;
* 3:1: Missing marker in block quote
*/
-const remarkLintNoBlockquoteWithoutMarker = lintRule(
+const remarkLintNoBlockquoteWithoutMarker = lintRule$C(
'remark-lint:no-blockquote-without-marker',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
const loc = location(file);
- visit$2(tree, 'blockquote', (node) => {
+ visit(tree, 'blockquote', (node) => {
let index = -1;
while (++index < node.children.length) {
@@ -52141,6 +48338,134 @@ const remarkLintNoBlockquoteWithoutMarker = lintRule(
var remarkLintNoBlockquoteWithoutMarker$1 = remarkLintNoBlockquoteWithoutMarker;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$B = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$B(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$C(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$C(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$B.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52176,11 +48501,11 @@ var remarkLintNoBlockquoteWithoutMarker$1 = remarkLintNoBlockquoteWithoutMarker;
* 1:1-1:19: Don’t use literal URLs without angle brackets
*/
-const remarkLintNoLiteralUrls = lintRule(
+const remarkLintNoLiteralUrls = lintRule$B(
'remark-lint:no-literal-urls',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'link', (node) => {
+ visit(tree, 'link', (node) => {
const value = toString(node);
if (
@@ -52199,6 +48524,134 @@ const remarkLintNoLiteralUrls = lintRule(
var remarkLintNoLiteralUrls$1 = remarkLintNoLiteralUrls;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$A = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$A(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$B(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$B(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$A.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52255,7 +48708,7 @@ var remarkLintNoLiteralUrls$1 = remarkLintNoLiteralUrls;
* 1:1: Incorrect ordered list item marker style `💩`: use either `'.'` or `')'`
*/
-const remarkLintOrderedListMarkerStyle = lintRule(
+const remarkLintOrderedListMarkerStyle = lintRule$A(
'remark-lint:ordered-list-marker-style',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -52269,7 +48722,7 @@ const remarkLintOrderedListMarkerStyle = lintRule(
);
}
- visit$2(tree, 'list', (node) => {
+ visit(tree, 'list', (node) => {
let index = -1;
if (!node.ordered) return
@@ -52302,6 +48755,134 @@ const remarkLintOrderedListMarkerStyle = lintRule(
var remarkLintOrderedListMarkerStyle$1 = remarkLintOrderedListMarkerStyle;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$z = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$z(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$A(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$A(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$z.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52327,13 +48908,13 @@ var remarkLintOrderedListMarkerStyle$1 = remarkLintOrderedListMarkerStyle;
* 1:12-2:1: Use two spaces for hard line breaks
*/
-const remarkLintHardBreakSpaces = lintRule(
+const remarkLintHardBreakSpaces = lintRule$z(
'remark-lint:hard-break-spaces',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
- visit$2(tree, 'break', (node) => {
+ visit(tree, 'break', (node) => {
if (!generated(node)) {
const slice = value
.slice(pointStart(node).offset, pointEnd(node).offset)
@@ -52350,71 +48931,132 @@ const remarkLintHardBreakSpaces = lintRule(
var remarkLintHardBreakSpaces$1 = remarkLintHardBreakSpaces;
-var own$3 = {}.hasOwnProperty;
-
/**
* @typedef {import('unist').Node} Node
- * @typedef {import('unist').Position} Position
- * @typedef {import('unist').Point} Point
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
*/
+const primitives$y = new Set(['string', 'number', 'boolean']);
+
/**
- * Stringify one point, a position (start and end points), or a node’s
- * positional information.
- *
- * @param {Node|Position|Point} [value]
- * @returns {string}
+ * @param {string} id
+ * @param {Rule} rule
*/
-function stringifyPosition$1(value) {
- // Nothing.
- if (!value || typeof value !== 'object') {
- return ''
- }
+function lintRule$y(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
- // Node.
- if (own$3.call(value, 'position') || own$3.call(value, 'type')) {
- // @ts-ignore looks like a node.
- return position$3(value.position)
- }
+ Object.defineProperty(plugin, 'name', {value: id});
- // Position.
- if (own$3.call(value, 'start') || own$3.call(value, 'end')) {
- // @ts-ignore looks like a position.
- return position$3(value)
- }
+ return plugin
- // Point.
- if (own$3.call(value, 'line') || own$3.call(value, 'column')) {
- // @ts-ignore looks like a point.
- return point$1(value)
- }
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$z(ruleId, raw);
- // ?
- return ''
-}
+ if (!severity) return
-/**
- * @param {Point} point
- * @returns {string}
- */
-function point$1(point) {
- return index$1(point && point.line) + ':' + index$1(point && point.column)
-}
+ const fatal = severity === 2;
-/**
- * @param {Position} pos
- * @returns {string}
- */
-function position$3(pos) {
- return point$1(pos && pos.start) + '-' + point$1(pos && pos.end)
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
}
/**
- * @param {number} value
- * @returns {number}
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
*/
-function index$1(value) {
- return value && typeof value === 'number' ? value : 1
+function coerce$z(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$y.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
}
/**
@@ -52443,14 +49085,14 @@ function index$1(value) {
* 2:1-2:11: Do not use definitions with the same identifier (1:1)
*/
-const remarkLintNoDuplicateDefinitions = lintRule(
+const remarkLintNoDuplicateDefinitions = lintRule$y(
'remark-lint:no-duplicate-definitions',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
/** @type {Record<string, string>} */
const map = Object.create(null);
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
(node.type === 'definition' || node.type === 'footnoteDefinition') &&
!generated(node)
@@ -52476,6 +49118,134 @@ const remarkLintNoDuplicateDefinitions = lintRule(
var remarkLintNoDuplicateDefinitions$1 = remarkLintNoDuplicateDefinitions;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$x = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$x(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$y(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$y(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$x.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @typedef {import('mdast').Heading} Heading
* @typedef {'atx'|'atx-closed'|'setext'} Style
*/
@@ -52584,11 +49354,11 @@ function consolidate(depth, relative) {
* #··
*/
-const remarkLintNoHeadingContentIndent = lintRule(
+const remarkLintNoHeadingContentIndent = lintRule$x(
'remark-lint:no-heading-content-indent',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'heading', (node) => {
+ visit(tree, 'heading', (node) => {
if (generated(node)) {
return
}
@@ -52641,6 +49411,134 @@ const remarkLintNoHeadingContentIndent = lintRule(
var remarkLintNoHeadingContentIndent$1 = remarkLintNoHeadingContentIndent;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$w = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$w(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$x(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$x(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$w.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52667,13 +49565,13 @@ var remarkLintNoHeadingContentIndent$1 = remarkLintNoHeadingContentIndent;
* 1:7-1:38: Don’t pad `link` with inner spaces
*/
-const remarkLintNoInlinePadding = lintRule(
+const remarkLintNoInlinePadding = lintRule$w(
'remark-lint:no-inline-padding',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
// Note: `emphasis`, `strong`, `delete` (GFM) can’t have padding anymore
// since CM.
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
(node.type === 'link' || node.type === 'linkReference') &&
!generated(node)
@@ -52691,6 +49589,134 @@ const remarkLintNoInlinePadding = lintRule(
var remarkLintNoInlinePadding$1 = remarkLintNoInlinePadding;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$v = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$v(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$w(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$w(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$v.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52724,11 +49750,11 @@ var remarkLintNoInlinePadding$1 = remarkLintNoInlinePadding;
* 1:1-1:7: Use the trailing [] on reference images
*/
-const remarkLintNoShortcutReferenceImage = lintRule(
+const remarkLintNoShortcutReferenceImage = lintRule$v(
'remark-lint:no-shortcut-reference-image',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'imageReference', (node) => {
+ visit(tree, 'imageReference', (node) => {
if (!generated(node) && node.referenceType === 'shortcut') {
file.message('Use the trailing [] on reference images', node);
}
@@ -52739,6 +49765,134 @@ const remarkLintNoShortcutReferenceImage = lintRule(
var remarkLintNoShortcutReferenceImage$1 = remarkLintNoShortcutReferenceImage;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$u = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$u(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$v(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$v(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$u.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -52772,11 +49926,11 @@ var remarkLintNoShortcutReferenceImage$1 = remarkLintNoShortcutReferenceImage;
* 1:1-1:6: Use the trailing `[]` on reference links
*/
-const remarkLintNoShortcutReferenceLink = lintRule(
+const remarkLintNoShortcutReferenceLink = lintRule$u(
'remark-lint:no-shortcut-reference-link',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'linkReference', (node) => {
+ visit(tree, 'linkReference', (node) => {
if (!generated(node) && node.referenceType === 'shortcut') {
file.message('Use the trailing `[]` on reference links', node);
}
@@ -52787,24 +49941,131 @@ const remarkLintNoShortcutReferenceLink = lintRule(
var remarkLintNoShortcutReferenceLink$1 = remarkLintNoShortcutReferenceLink;
/**
- * Normalize an identifier (such as used in definitions).
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
*
- * @param {string} value
- * @returns {string}
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
*/
-function normalizeIdentifier(value) {
- return (
- value // Collapse Markdown whitespace.
- .replace(/[\t\n\r ]+/g, ' ') // Trim.
- .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase
- // counterpart is uppercased will result in a different uppercase
- // character.
- // Hence, to get that form, we perform both lower- and uppercase.
- // Upper case makes sure keys will not interact with default prototypal
- // methods: no method is uppercase.
- .toLowerCase()
- .toUpperCase()
- )
+
+const primitives$t = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$t(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$u(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$u(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$t.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
}
/**
@@ -52875,7 +50136,7 @@ function normalizeIdentifier(value) {
* 17:23-17:26: Found reference to undefined definition
*/
-const remarkLintNoUndefinedReferences = lintRule(
+const remarkLintNoUndefinedReferences = lintRule$t(
'remark-lint:no-undefined-references',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = {}) => {
@@ -52888,7 +50149,7 @@ const remarkLintNoUndefinedReferences = lintRule(
/** @type {Record<string, boolean>} */
const map = Object.create(null);
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
(node.type === 'definition' || node.type === 'footnoteDefinition') &&
!generated(node)
@@ -52897,7 +50158,7 @@ const remarkLintNoUndefinedReferences = lintRule(
}
});
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
// CM specifiers that references only form when defined.
// Still, they could be added by plugins, so let’s keep it.
/* c8 ignore next 10 */
@@ -52924,14 +50185,14 @@ const remarkLintNoUndefinedReferences = lintRule(
/** @type {Range[]} */
let ranges = [];
- visit$2(node, (child) => {
+ visit(node, (child) => {
// Ignore the node itself.
if (child === node) return
// Can’t have links in links, so reset ranges.
if (child.type === 'link' || child.type === 'linkReference') {
ranges = [];
- return SKIP$2
+ return SKIP$1
}
// Enter non-text.
@@ -52942,7 +50203,7 @@ const remarkLintNoUndefinedReferences = lintRule(
// Bail if there’s no positional info.
if (typeof start !== 'number' || typeof end !== 'number') {
- return EXIT$2
+ return EXIT$1
}
const source = contents.slice(start, end);
@@ -53040,7 +50301,7 @@ const remarkLintNoUndefinedReferences = lintRule(
handleRange(ranges[index]);
}
- return SKIP$2
+ return SKIP$1
/**
* @param {Range} range
@@ -53076,6 +50337,134 @@ const remarkLintNoUndefinedReferences = lintRule(
var remarkLintNoUndefinedReferences$1 = remarkLintNoUndefinedReferences;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$s = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$s(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$t(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$t(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$s.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2016 Titus Wormer
* @license MIT
@@ -53101,16 +50490,16 @@ var remarkLintNoUndefinedReferences$1 = remarkLintNoUndefinedReferences;
* 1:1-1:27: Found unused definition
*/
-const own$2 = {}.hasOwnProperty;
+const own$1 = {}.hasOwnProperty;
-const remarkLintNoUnusedDefinitions = lintRule(
+const remarkLintNoUnusedDefinitions = lintRule$s(
'remark-lint:no-unused-definitions',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
/** @type {Record<string, {node: DefinitionContent, used: boolean}>} */
const map = Object.create(null);
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
(node.type === 'definition' || node.type === 'footnoteDefinition') &&
!generated(node)
@@ -53119,7 +50508,7 @@ const remarkLintNoUnusedDefinitions = lintRule(
}
});
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
node.type === 'imageReference' ||
node.type === 'linkReference' ||
@@ -53137,7 +50526,7 @@ const remarkLintNoUnusedDefinitions = lintRule(
let identifier;
for (identifier in map) {
- if (own$2.call(map, identifier)) {
+ if (own$1.call(map, identifier)) {
const entry = map[identifier];
if (!entry.used) {
@@ -53156,35 +50545,162 @@ var remarkLintNoUnusedDefinitions$1 = remarkLintNoUnusedDefinitions;
* mistakes or stuff that fails across vendors.
*/
-/** @type {Preset} */
-const remarkPresetLintRecommended = {
- plugins: [
- remarkLint,
- // Unix compatibility.
- remarkLintFinalNewline$1,
- // Rendering across vendors differs greatly if using other styles.
- remarkLintListItemBulletIndent$1,
- [remarkLintListItemIndent$1, 'tab-size'],
- // Differs or unsupported across vendors.
- remarkLintNoAutoLinkWithoutProtocol$1,
- remarkLintNoBlockquoteWithoutMarker$1,
- remarkLintNoLiteralUrls$1,
- [remarkLintOrderedListMarkerStyle$1, '.'],
- // Mistakes.
- remarkLintHardBreakSpaces$1,
- remarkLintNoDuplicateDefinitions$1,
- remarkLintNoHeadingContentIndent$1,
- remarkLintNoInlinePadding$1,
- remarkLintNoShortcutReferenceImage$1,
- remarkLintNoShortcutReferenceLink$1,
- remarkLintNoUndefinedReferences$1,
- remarkLintNoUnusedDefinitions$1
- ]
-};
+const plugins$1 = [
+ remarkLint,
+ // Unix compatibility.
+ remarkLintFinalNewline$1,
+ // Rendering across vendors differs greatly if using other styles.
+ remarkLintListItemBulletIndent$1,
+ [remarkLintListItemIndent$1, 'tab-size'],
+ // Differs or unsupported across vendors.
+ remarkLintNoAutoLinkWithoutProtocol$1,
+ remarkLintNoBlockquoteWithoutMarker$1,
+ remarkLintNoLiteralUrls$1,
+ [remarkLintOrderedListMarkerStyle$1, '.'],
+ // Mistakes.
+ remarkLintHardBreakSpaces$1,
+ remarkLintNoDuplicateDefinitions$1,
+ remarkLintNoHeadingContentIndent$1,
+ remarkLintNoInlinePadding$1,
+ remarkLintNoShortcutReferenceImage$1,
+ remarkLintNoShortcutReferenceLink$1,
+ remarkLintNoUndefinedReferences$1,
+ remarkLintNoUnusedDefinitions$1
+];
+
+const remarkPresetLintRecommended = {plugins: plugins$1};
var remarkPresetLintRecommended$1 = remarkPresetLintRecommended;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$r = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$r(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$s(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$s(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$r.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53234,11 +50750,11 @@ var remarkPresetLintRecommended$1 = remarkPresetLintRecommended;
* 9:3: Add 1 space between block quote and content
*/
-const remarkLintBlockquoteIndentation = lintRule(
+const remarkLintBlockquoteIndentation = lintRule$r(
'remark-lint:blockquote-indentation',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
- visit$2(tree, 'blockquote', (node) => {
+ visit(tree, 'blockquote', (node) => {
if (generated(node) || node.children.length === 0) {
return
}
@@ -53277,6 +50793,134 @@ function check(node) {
}
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$q = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$q(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$r(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$r(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$q.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53355,7 +50999,7 @@ function check(node) {
* 1:1: Incorrect checked checkbox marker `💩`: use either `'x'`, or `'X'`
*/
-const remarkLintCheckboxCharacterStyle = lintRule(
+const remarkLintCheckboxCharacterStyle = lintRule$q(
'remark-lint:checkbox-character-style',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -53386,7 +51030,7 @@ const remarkLintCheckboxCharacterStyle = lintRule(
);
}
- visit$2(tree, 'listItem', (node) => {
+ visit(tree, 'listItem', (node) => {
const head = node.children[0];
const point = pointStart(head);
@@ -53439,6 +51083,134 @@ const remarkLintCheckboxCharacterStyle = lintRule(
var remarkLintCheckboxCharacterStyle$1 = remarkLintCheckboxCharacterStyle;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$p = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$p(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$q(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$q(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$p.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53470,14 +51242,14 @@ var remarkLintCheckboxCharacterStyle$1 = remarkLintCheckboxCharacterStyle;
* 4:7-4:10: Checkboxes should be followed by a single character
*/
-const remarkLintCheckboxContentIndent = lintRule(
+const remarkLintCheckboxContentIndent = lintRule$p(
'remark-lint:checkbox-content-indent',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
const loc = location(file);
- visit$2(tree, 'listItem', (node) => {
+ visit(tree, 'listItem', (node) => {
const head = node.children[0];
const point = pointStart(head);
@@ -53519,6 +51291,134 @@ const remarkLintCheckboxContentIndent = lintRule(
var remarkLintCheckboxContentIndent$1 = remarkLintCheckboxContentIndent;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$o = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$o(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$p(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$p(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$o.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53621,7 +51521,7 @@ var remarkLintCheckboxContentIndent$1 = remarkLintCheckboxContentIndent;
* 1:1: Incorrect code block style `💩`: use either `'consistent'`, `'fenced'`, or `'indented'`
*/
-const remarkLintCodeBlockStyle = lintRule(
+const remarkLintCodeBlockStyle = lintRule$o(
'remark-lint:code-block-style',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -53639,7 +51539,7 @@ const remarkLintCodeBlockStyle = lintRule(
);
}
- visit$2(tree, 'code', (node) => {
+ visit(tree, 'code', (node) => {
if (generated(node)) {
return
}
@@ -53664,6 +51564,134 @@ const remarkLintCodeBlockStyle = lintRule(
var remarkLintCodeBlockStyle$1 = remarkLintCodeBlockStyle;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$n = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$n(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$o(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$o(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$n.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53689,13 +51717,13 @@ var remarkLintCodeBlockStyle$1 = remarkLintCodeBlockStyle;
const label = /^\s*\[((?:\\[\s\S]|[^[\]])+)]/;
-const remarkLintDefinitionSpacing = lintRule(
+const remarkLintDefinitionSpacing = lintRule$n(
'remark-lint:definition-spacing',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (node.type === 'definition' || node.type === 'footnoteDefinition') {
const start = pointStart(node).offset;
const end = pointEnd(node).offset;
@@ -53718,6 +51746,134 @@ const remarkLintDefinitionSpacing = lintRule(
var remarkLintDefinitionSpacing$1 = remarkLintDefinitionSpacing;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$m = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$m(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$n(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$n(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$m.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53801,7 +51957,7 @@ var remarkLintDefinitionSpacing$1 = remarkLintDefinitionSpacing;
const fence = /^ {0,3}([~`])\1{2,}/;
-const remarkLintFencedCodeFlag = lintRule(
+const remarkLintFencedCodeFlag = lintRule$m(
'remark-lint:fenced-code-flag',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option) => {
@@ -53822,7 +51978,7 @@ const remarkLintFencedCodeFlag = lintRule(
}
}
- visit$2(tree, 'code', (node) => {
+ visit(tree, 'code', (node) => {
if (!generated(node)) {
if (node.lang) {
if (allowed.length > 0 && !allowed.includes(node.lang)) {
@@ -53846,6 +52002,134 @@ const remarkLintFencedCodeFlag = lintRule(
var remarkLintFencedCodeFlag$1 = remarkLintFencedCodeFlag;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$l = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$l(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$m(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$m(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$l.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -53936,7 +52220,7 @@ var remarkLintFencedCodeFlag$1 = remarkLintFencedCodeFlag;
* 1:1: Incorrect fenced code marker `💩`: use either `'consistent'`, `` '`' ``, or `'~'`
*/
-const remarkLintFencedCodeMarker = lintRule(
+const remarkLintFencedCodeMarker = lintRule$l(
'remark-lint:fenced-code-marker',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -53950,7 +52234,7 @@ const remarkLintFencedCodeMarker = lintRule(
);
}
- visit$2(tree, 'code', (node) => {
+ visit(tree, 'code', (node) => {
const start = pointStart(node).offset;
if (typeof start === 'number') {
@@ -53980,6 +52264,134 @@ const remarkLintFencedCodeMarker = lintRule(
var remarkLintFencedCodeMarker$1 = remarkLintFencedCodeMarker;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$k = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$k(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$l(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$l(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$k.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54007,7 +52419,7 @@ var remarkLintFencedCodeMarker$1 = remarkLintFencedCodeMarker;
* {"name": "readme.mkd", "setting": "mkd"}
*/
-const remarkLintFileExtension = lintRule(
+const remarkLintFileExtension = lintRule$k(
'remark-lint:file-extension',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(_, file, option = 'md') => {
@@ -54022,6 +52434,134 @@ const remarkLintFileExtension = lintRule(
var remarkLintFileExtension$1 = remarkLintFileExtension;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$j = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$j(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$k(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$k(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$j.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54063,13 +52603,13 @@ var remarkLintFileExtension$1 = remarkLintFileExtension;
* [example-2]: http://example.com/two/
*/
-const remarkLintFinalDefinition = lintRule(
+const remarkLintFinalDefinition = lintRule$j(
'remark-lint:final-definition',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
let last = 0;
- visit$2(
+ visit(
tree,
(node) => {
// Ignore generated and HTML comment nodes.
@@ -54104,6 +52644,134 @@ const remarkLintFinalDefinition = lintRule(
var remarkLintFinalDefinition$1 = remarkLintFinalDefinition;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$i = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$i(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$j(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$j(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$i.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54195,13 +52863,13 @@ var remarkLintFinalDefinition$1 = remarkLintFinalDefinition;
* 1:1-1:14: First heading level should be `2`
*/
-const re$3 = /<h([1-6])/;
+const re = /<h([1-6])/;
-const remarkLintFirstHeadingLevel = lintRule(
+const remarkLintFirstHeadingLevel = lintRule$i(
'remark-lint:first-heading-level',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 1) => {
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (!generated(node)) {
/** @type {Depth|undefined} */
let rank;
@@ -54217,7 +52885,7 @@ const remarkLintFirstHeadingLevel = lintRule(
file.message('First heading level should be `' + option + '`', node);
}
- return EXIT$2
+ return EXIT$1
}
}
});
@@ -54231,12 +52899,140 @@ var remarkLintFirstHeadingLevel$1 = remarkLintFirstHeadingLevel;
* @returns {Depth|undefined}
*/
function infer(node) {
- const results = node.value.match(re$3);
+ const results = node.value.match(re);
// @ts-expect-error: can be castes fine.
return results ? Number(results[1]) : undefined
}
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$h = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$h(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$i(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$i(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$h.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54314,7 +53110,7 @@ function infer(node) {
* 1:1: Incorrect heading style type `💩`: use either `'consistent'`, `'atx'`, `'atx-closed'`, or `'setext'`
*/
-const remarkLintHeadingStyle = lintRule(
+const remarkLintHeadingStyle = lintRule$h(
'remark-lint:heading-style',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -54331,7 +53127,7 @@ const remarkLintHeadingStyle = lintRule(
);
}
- visit$2(tree, 'heading', (node) => {
+ visit(tree, 'heading', (node) => {
if (!generated(node)) {
if (option === 'consistent') {
// Funky nodes perhaps cannot be detected.
@@ -54348,6 +53144,134 @@ const remarkLintHeadingStyle = lintRule(
var remarkLintHeadingStyle$1 = remarkLintHeadingStyle;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$g = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$g(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$h(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$h(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$g.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54445,14 +53369,14 @@ var remarkLintHeadingStyle$1 = remarkLintHeadingStyle;
* 4:12: Line must be at most 10 characters
*/
-const remarkLintMaximumLineLength = lintRule(
+const remarkLintMaximumLineLength = lintRule$g(
'remark-lint:maximum-line-length',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 80) => {
const value = String(file);
const lines = value.split(/\r?\n/);
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (
(node.type === 'heading' ||
node.type === 'table' ||
@@ -54474,7 +53398,7 @@ const remarkLintMaximumLineLength = lintRule(
// the wrap.
// However, when they do, and there’s whitespace after it, they are not
// allowed.
- visit$2(tree, (node, pos, parent_) => {
+ visit(tree, (node, pos, parent_) => {
const parent = /** @type {Parent} */ (parent_);
if (
@@ -54539,6 +53463,134 @@ const remarkLintMaximumLineLength = lintRule(
var remarkLintMaximumLineLength$1 = remarkLintMaximumLineLength;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$f = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$f(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$g(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$g(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$f.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54584,11 +53636,11 @@ var remarkLintMaximumLineLength$1 = remarkLintMaximumLineLength;
* 4:5: Remove 2 lines after node
*/
-const remarkLintNoConsecutiveBlankLines = lintRule(
+const remarkLintNoConsecutiveBlankLines = lintRule$f(
'remark-lint:no-consecutive-blank-lines',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, (node) => {
+ visit(tree, (node) => {
if (!generated(node) && 'children' in node) {
const head = node.children[0];
@@ -54649,6 +53701,134 @@ const remarkLintNoConsecutiveBlankLines = lintRule(
var remarkLintNoConsecutiveBlankLines$1 = remarkLintNoConsecutiveBlankLines;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$e = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$e(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$f(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$f(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$e.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54680,7 +53860,7 @@ var remarkLintNoConsecutiveBlankLines$1 = remarkLintNoConsecutiveBlankLines;
* 1:1: Do not start file names with `an`
*/
-const remarkLintNoFileNameArticles = lintRule(
+const remarkLintNoFileNameArticles = lintRule$e(
'remark-lint:no-file-name-articles',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(_, file) => {
@@ -54695,6 +53875,134 @@ const remarkLintNoFileNameArticles = lintRule(
var remarkLintNoFileNameArticles$1 = remarkLintNoFileNameArticles;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$d = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$d(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$e(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$e(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$d.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54711,7 +54019,7 @@ var remarkLintNoFileNameArticles$1 = remarkLintNoFileNameArticles;
* 1:1: Do not use consecutive dashes in a file name
*/
-const remarkLintNoFileNameConsecutiveDashes = lintRule(
+const remarkLintNoFileNameConsecutiveDashes = lintRule$d(
'remark-lint:no-file-name-consecutive-dashes',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(_, file) => {
@@ -54724,6 +54032,134 @@ const remarkLintNoFileNameConsecutiveDashes = lintRule(
var remarkLintNoFileNameConsecutiveDashes$1 = remarkLintNoFileNameConsecutiveDashes;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$c = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$c(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$d(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$d(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$c.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54745,7 +54181,7 @@ var remarkLintNoFileNameConsecutiveDashes$1 = remarkLintNoFileNameConsecutiveDas
* 1:1: Do not use initial or final dashes in a file name
*/
-const remarkLintNofileNameOuterDashes = lintRule(
+const remarkLintNofileNameOuterDashes = lintRule$c(
'remark-lint:no-file-name-outer-dashes',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(_, file) => {
@@ -54758,6 +54194,134 @@ const remarkLintNofileNameOuterDashes = lintRule(
var remarkLintNofileNameOuterDashes$1 = remarkLintNofileNameOuterDashes;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$b = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$b(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$c(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$c(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$b.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -54808,11 +54372,11 @@ var remarkLintNofileNameOuterDashes$1 = remarkLintNofileNameOuterDashes;
* 8:4: Remove 3 spaces before this heading
*/
-const remarkLintNoHeadingIndent = lintRule(
+const remarkLintNoHeadingIndent = lintRule$b(
'remark-lint:no-heading-indent',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'heading', (node, _, parent) => {
+ visit(tree, 'heading', (node, _, parent) => {
// Note: it’s rather complex to detect what the expected indent is in block
// quotes and lists, so let’s only do directly in root for now.
if (generated(node) || (parent && parent.type !== 'root')) {
@@ -54837,71 +54401,132 @@ const remarkLintNoHeadingIndent = lintRule(
var remarkLintNoHeadingIndent$1 = remarkLintNoHeadingIndent;
-var own$1 = {}.hasOwnProperty;
-
/**
* @typedef {import('unist').Node} Node
- * @typedef {import('unist').Position} Position
- * @typedef {import('unist').Point} Point
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
*/
+const primitives$a = new Set(['string', 'number', 'boolean']);
+
/**
- * Stringify one point, a position (start and end points), or a node’s
- * positional information.
- *
- * @param {Node|Position|Point} [value]
- * @returns {string}
+ * @param {string} id
+ * @param {Rule} rule
*/
-function stringifyPosition(value) {
- // Nothing.
- if (!value || typeof value !== 'object') {
- return ''
- }
+function lintRule$a(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
- // Node.
- if (own$1.call(value, 'position') || own$1.call(value, 'type')) {
- // @ts-ignore looks like a node.
- return position$2(value.position)
- }
+ Object.defineProperty(plugin, 'name', {value: id});
- // Position.
- if (own$1.call(value, 'start') || own$1.call(value, 'end')) {
- // @ts-ignore looks like a position.
- return position$2(value)
- }
+ return plugin
- // Point.
- if (own$1.call(value, 'line') || own$1.call(value, 'column')) {
- // @ts-ignore looks like a point.
- return point(value)
- }
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$b(ruleId, raw);
- // ?
- return ''
-}
+ if (!severity) return
-/**
- * @param {Point} point
- * @returns {string}
- */
-function point(point) {
- return index(point && point.line) + ':' + index(point && point.column)
-}
+ const fatal = severity === 2;
-/**
- * @param {Position} pos
- * @returns {string}
- */
-function position$2(pos) {
- return point(pos && pos.start) + '-' + point(pos && pos.end)
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
}
/**
- * @param {number} value
- * @returns {number}
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
*/
-function index(value) {
- return value && typeof value === 'number' ? value : 1
+function coerce$b(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$a.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
}
/**
@@ -54934,14 +54559,14 @@ function index(value) {
* 3:1-3:6: Don’t use multiple top level headings (1:1)
*/
-const remarkLintNoMultipleToplevelHeadings = lintRule(
+const remarkLintNoMultipleToplevelHeadings = lintRule$a(
'remark-lint:no-multiple-toplevel-headings',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 1) => {
/** @type {string|undefined} */
let duplicate;
- visit$2(tree, 'heading', (node) => {
+ visit(tree, 'heading', (node) => {
if (!generated(node) && node.depth === option) {
if (duplicate) {
file.message(
@@ -54949,7 +54574,7 @@ const remarkLintNoMultipleToplevelHeadings = lintRule(
node
);
} else {
- duplicate = stringifyPosition(pointStart(node));
+ duplicate = stringifyPosition$1(pointStart(node));
}
}
});
@@ -54959,6 +54584,134 @@ const remarkLintNoMultipleToplevelHeadings = lintRule(
var remarkLintNoMultipleToplevelHeadings$1 = remarkLintNoMultipleToplevelHeadings;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$9 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$9(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$a(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$a(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$9.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -55032,11 +54785,11 @@ const flags = new Set([
'zsh'
]);
-const remarkLintNoShellDollars = lintRule(
+const remarkLintNoShellDollars = lintRule$9(
'remark-lint:no-shell-dollars',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
- visit$2(tree, 'code', (node) => {
+ visit(tree, 'code', (node) => {
// Check both known shell code and unknown code.
if (!generated(node) && node.lang && flags.has(node.lang)) {
const lines = node.value
@@ -55065,6 +54818,134 @@ const remarkLintNoShellDollars = lintRule(
var remarkLintNoShellDollars$1 = remarkLintNoShellDollars;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$8 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$8(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$9(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$9(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$8.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -55130,14 +55011,14 @@ var remarkLintNoShellDollars$1 = remarkLintNoShellDollars;
* 3:6: Do not indent table rows
*/
-const remarkLintNoTableIndentation = lintRule(
+const remarkLintNoTableIndentation = lintRule$8(
'remark-lint:no-table-indentation',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
const loc = location(value);
- visit$2(tree, 'table', (node, _, parent) => {
+ visit(tree, 'table', (node, _, parent) => {
const end = pointEnd(node).line;
let line = pointStart(node).line;
let column = 0;
@@ -55184,7 +55065,7 @@ const remarkLintNoTableIndentation = lintRule(
line++;
}
- return SKIP$2
+ return SKIP$1
});
}
);
@@ -55192,6 +55073,134 @@ const remarkLintNoTableIndentation = lintRule(
var remarkLintNoTableIndentation$1 = remarkLintNoTableIndentation;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$7 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$7(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$8(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$8(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$7.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -55246,7 +55255,7 @@ var remarkLintNoTableIndentation$1 = remarkLintNoTableIndentation;
* 13:41: Use spaces instead of tabs
*/
-const remarkLintNoTabs = lintRule(
+const remarkLintNoTabs = lintRule$7(
'remark-lint:no-tabs',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(_, file) => {
@@ -55432,7 +55441,7 @@ function toThunk(obj, ctx) {
return obj;
}
- if (isObject$1(obj) || Array.isArray(obj)) {
+ if (isObject(obj) || Array.isArray(obj)) {
return objectToThunk.call(ctx, obj);
}
@@ -55566,7 +55575,7 @@ function isGeneratorFunction(obj) {
* @api private
*/
-function isObject$1(val) {
+function isObject(val) {
return val && Object == val.constructor;
}
@@ -55601,7 +55610,7 @@ var co = co_1;
* Export `wrapped`
*/
-var wrapped_1 = wrapped$2;
+var wrapped_1 = wrapped$1;
/**
* Wrap a function to support
@@ -55612,7 +55621,7 @@ var wrapped_1 = wrapped$2;
* @api public
*/
-function wrapped$2(fn) {
+function wrapped$1(fn) {
function wrap() {
var args = sliced(arguments);
var last = args[args.length - 1];
@@ -55702,15 +55711,15 @@ function promise(value) {
return value && 'function' == typeof value.then;
}
-var wrapped$1 = wrapped_1;
+var wrapped = wrapped_1;
-var unifiedLintRule$1 = factory$3;
+var unifiedLintRule = factory;
-function factory$3(id, rule) {
+function factory(id, rule) {
var parts = id.split(':');
var source = parts[0];
var ruleId = parts[1];
- var fn = wrapped$1(rule);
+ var fn = wrapped(rule);
/* istanbul ignore if - possibly useful if externalised later. */
if (!ruleId) {
@@ -55723,7 +55732,7 @@ function factory$3(id, rule) {
return attacher
function attacher(raw) {
- var config = coerce$1(ruleId, raw);
+ var config = coerce$7(ruleId, raw);
var severity = config[0];
var options = config[1];
var fatal = severity === 2;
@@ -55763,7 +55772,7 @@ function factory$3(id, rule) {
}
// Coerce a value to a severity--options tuple.
-function coerce$1(name, value) {
+function coerce$7(name, value) {
var def = 1;
var result;
var level;
@@ -55817,9 +55826,9 @@ function coerce$1(name, value) {
return result
}
-var rule$1 = unifiedLintRule$1;
+var rule = unifiedLintRule;
-var remarkLintNoTrailingSpaces = rule$1('remark-lint:no-trailing-spaces', noTrailingSpaces);
+var remarkLintNoTrailingSpaces = rule('remark-lint:no-trailing-spaces', noTrailingSpaces);
/**
* Lines that are just space characters are not present in
@@ -55842,4480 +55851,177 @@ function noTrailingSpaces(ast, file) {
}
}
-function* getLinksRecursively(node) {
- if (node.url) {
- yield node;
- }
- for (const child of node.children || []) {
- yield* getLinksRecursively(child);
- }
-}
-
-function validateLinks(tree, vfile) {
- const currentFileURL = url.pathToFileURL(require$$0__default$2['default'].join(vfile.cwd, vfile.path));
- let previousDefinitionLabel;
- for (const node of getLinksRecursively(tree)) {
- if (node.url[0] !== "#") {
- const targetURL = new URL(node.url, currentFileURL);
- if (targetURL.protocol === "file:" && !require$$0__default$3['default'].existsSync(targetURL)) {
- vfile.message("Broken link", node);
- } else if (targetURL.pathname === currentFileURL.pathname) {
- const expected = node.url.includes("#")
- ? node.url.slice(node.url.indexOf("#"))
- : "#";
- vfile.message(
- `Self-reference must start with hash (expected "${expected}", got "${node.url}")`,
- node
- );
- }
- }
- if (node.type === "definition") {
- if (previousDefinitionLabel && previousDefinitionLabel > node.label) {
- vfile.message(
- `Unordered reference ("${node.label}" should be before "${previousDefinitionLabel}")`,
- node
- );
- }
- previousDefinitionLabel = node.label;
- }
- }
-}
-
-const remarkLintNodejsLinks = lintRule(
- "remark-lint:nodejs-links",
- validateLinks
-);
-
-/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
-function isNothing(subject) {
- return (typeof subject === 'undefined') || (subject === null);
-}
-
-
-function isObject(subject) {
- return (typeof subject === 'object') && (subject !== null);
-}
-
-
-function toArray(sequence) {
- if (Array.isArray(sequence)) return sequence;
- else if (isNothing(sequence)) return [];
-
- return [ sequence ];
-}
-
-
-function extend(target, source) {
- var index, length, key, sourceKeys;
-
- if (source) {
- sourceKeys = Object.keys(source);
-
- for (index = 0, length = sourceKeys.length; index < length; index += 1) {
- key = sourceKeys[index];
- target[key] = source[key];
- }
- }
-
- return target;
-}
-
-
-function repeat(string, count) {
- var result = '', cycle;
-
- for (cycle = 0; cycle < count; cycle += 1) {
- result += string;
- }
-
- return result;
-}
-
-
-function isNegativeZero(number) {
- return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
-}
-
-
-var isNothing_1 = isNothing;
-var isObject_1 = isObject;
-var toArray_1 = toArray;
-var repeat_1 = repeat;
-var isNegativeZero_1 = isNegativeZero;
-var extend_1 = extend;
-
-var common = {
- isNothing: isNothing_1,
- isObject: isObject_1,
- toArray: toArray_1,
- repeat: repeat_1,
- isNegativeZero: isNegativeZero_1,
- extend: extend_1
-};
-
-// YAML error class. http://stackoverflow.com/questions/8458984
-
-
-function formatError(exception, compact) {
- var where = '', message = exception.reason || '(unknown reason)';
-
- if (!exception.mark) return message;
-
- if (exception.mark.name) {
- where += 'in "' + exception.mark.name + '" ';
- }
-
- where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
-
- if (!compact && exception.mark.snippet) {
- where += '\n\n' + exception.mark.snippet;
- }
-
- return message + ' ' + where;
-}
-
-
-function YAMLException$1(reason, mark) {
- // Super constructor
- Error.call(this);
-
- this.name = 'YAMLException';
- this.reason = reason;
- this.mark = mark;
- this.message = formatError(this, false);
-
- // Include stack trace in error object
- if (Error.captureStackTrace) {
- // Chrome and NodeJS
- Error.captureStackTrace(this, this.constructor);
- } else {
- // FF, IE 10+ and Safari 6+. Fallback for others
- this.stack = (new Error()).stack || '';
- }
-}
-
-
-// Inherit from Error
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
-
-
-YAMLException$1.prototype.toString = function toString(compact) {
- return this.name + ': ' + formatError(this, compact);
-};
-
-
-var exception = YAMLException$1;
-
-// get snippet for a single line, respecting maxLength
-function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
- var head = '';
- var tail = '';
- var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-
- if (position - lineStart > maxHalfLength) {
- head = ' ... ';
- lineStart = position - maxHalfLength + head.length;
- }
-
- if (lineEnd - position > maxHalfLength) {
- tail = ' ...';
- lineEnd = position + maxHalfLength - tail.length;
- }
-
- return {
- str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
- pos: position - lineStart + head.length // relative position
- };
-}
-
-
-function padStart(string, max) {
- return common.repeat(' ', max - string.length) + string;
-}
-
-
-function makeSnippet(mark, options) {
- options = Object.create(options || null);
-
- if (!mark.buffer) return null;
-
- if (!options.maxLength) options.maxLength = 79;
- if (typeof options.indent !== 'number') options.indent = 1;
- if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
- if (typeof options.linesAfter !== 'number') options.linesAfter = 2;
-
- var re = /\r?\n|\r|\0/g;
- var lineStarts = [ 0 ];
- var lineEnds = [];
- var match;
- var foundLineNo = -1;
-
- while ((match = re.exec(mark.buffer))) {
- lineEnds.push(match.index);
- lineStarts.push(match.index + match[0].length);
-
- if (mark.position <= match.index && foundLineNo < 0) {
- foundLineNo = lineStarts.length - 2;
- }
- }
-
- if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-
- var result = '', i, line;
- var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
- var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-
- for (i = 1; i <= options.linesBefore; i++) {
- if (foundLineNo - i < 0) break;
- line = getLine(
- mark.buffer,
- lineStarts[foundLineNo - i],
- lineEnds[foundLineNo - i],
- mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
- maxLineLength
- );
- result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n' + result;
- }
-
- line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
- result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n';
- result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
-
- for (i = 1; i <= options.linesAfter; i++) {
- if (foundLineNo + i >= lineEnds.length) break;
- line = getLine(
- mark.buffer,
- lineStarts[foundLineNo + i],
- lineEnds[foundLineNo + i],
- mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
- maxLineLength
- );
- result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n';
- }
-
- return result.replace(/\n$/, '');
-}
-
-
-var snippet = makeSnippet;
-
-var TYPE_CONSTRUCTOR_OPTIONS = [
- 'kind',
- 'multi',
- 'resolve',
- 'construct',
- 'instanceOf',
- 'predicate',
- 'represent',
- 'representName',
- '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$1(tag, options) {
- options = options || {};
-
- 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.');
- }
- });
-
- // TODO: Add tag format check.
- this.options = options; // keep original options in case user wants to extend this type later
- 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.representName = options['representName'] || null;
- this.defaultStyle = options['defaultStyle'] || null;
- this.multi = options['multi'] || false;
- this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
-
- if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
- throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
- }
-}
-
-var type = Type$1;
-
-/*eslint-disable max-len*/
-
-
-
-
-
-function compileList(schema, name) {
- var result = [];
-
- schema[name].forEach(function (currentType) {
- var newIndex = result.length;
-
- result.forEach(function (previousType, previousIndex) {
- if (previousType.tag === currentType.tag &&
- previousType.kind === currentType.kind &&
- previousType.multi === currentType.multi) {
-
- newIndex = previousIndex;
- }
- });
-
- result[newIndex] = currentType;
- });
-
- return result;
-}
-
-
-function compileMap(/* lists... */) {
- var result = {
- scalar: {},
- sequence: {},
- mapping: {},
- fallback: {},
- multi: {
- scalar: [],
- sequence: [],
- mapping: [],
- fallback: []
- }
- }, index, length;
-
- function collectType(type) {
- if (type.multi) {
- result.multi[type.kind].push(type);
- result.multi['fallback'].push(type);
- } else {
- 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$1(definition) {
- return this.extend(definition);
-}
-
-
-Schema$1.prototype.extend = function extend(definition) {
- var implicit = [];
- var explicit = [];
-
- if (definition instanceof type) {
- // Schema.extend(type)
- explicit.push(definition);
-
- } else if (Array.isArray(definition)) {
- // Schema.extend([ type1, type2, ... ])
- explicit = explicit.concat(definition);
-
- } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
- // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
- if (definition.implicit) implicit = implicit.concat(definition.implicit);
- if (definition.explicit) explicit = explicit.concat(definition.explicit);
-
- } else {
- throw new exception('Schema.extend argument should be a Type, [ Type ], ' +
- 'or a schema definition ({ implicit: [...], explicit: [...] })');
- }
-
- implicit.forEach(function (type$1) {
- if (!(type$1 instanceof type)) {
- throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
- }
-
- 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.');
- }
-
- if (type$1.multi) {
- throw new exception('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
- }
- });
-
- explicit.forEach(function (type$1) {
- if (!(type$1 instanceof type)) {
- throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
- }
- });
-
- var result = Object.create(Schema$1.prototype);
-
- result.implicit = (this.implicit || []).concat(implicit);
- result.explicit = (this.explicit || []).concat(explicit);
-
- result.compiledImplicit = compileList(result, 'implicit');
- result.compiledExplicit = compileList(result, 'explicit');
- result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
-
- return result;
-};
-
-
-var schema = Schema$1;
-
-var str = new type('tag:yaml.org,2002:str', {
- kind: 'scalar',
- construct: function (data) { return data !== null ? data : ''; }
-});
-
-var seq = new type('tag:yaml.org,2002:seq', {
- kind: 'sequence',
- construct: function (data) { return data !== null ? data : []; }
-});
-
-var map = new type('tag:yaml.org,2002:map', {
- kind: 'mapping',
- construct: function (data) { return data !== null ? data : {}; }
-});
-
-var failsafe = new schema({
- explicit: [
- str,
- seq,
- map
- ]
-});
-
-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;
-}
-
-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'; },
- empty: function () { return ''; }
- },
- defaultStyle: 'lowercase'
-});
-
-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]';
-}
-
-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'
-});
-
-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 !== '_';
- }
-
-
- if (ch === 'o') {
- // base 8
- index++;
-
- 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)
-
- // value should not start with `_`;
- if (ch === '_') return false;
-
- for (; index < max; index++) {
- ch = data[index];
- if (ch === '_') continue;
- if (!isDecCode(data.charCodeAt(index))) {
- return false;
- }
- hasDigits = true;
- }
-
- // Should have digits and should not end with `_`
- if (!hasDigits || ch === '_') return false;
-
- return true;
-}
-
-function constructYamlInteger(data) {
- var value = data, sign = 1, ch;
-
- 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.slice(2), 16);
- if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
- }
-
- return sign * parseInt(value, 10);
-}
-
-function isInteger(object) {
- return (Object.prototype.toString.call(object)) === '[object Number]' &&
- (object % 1 === 0 && !common.isNegativeZero(object));
-}
-
-var int = 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 ? '0o' + obj.toString(8) : '-0o' + 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' ]
- }
-});
-
-var YAML_FLOAT_PATTERN = new RegExp(
- // 2.5e4, 2.5 and integers
- '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
- // .2e4, .2
- // special case, seems not from spec
- '|\\.[0-9_]+(?:[eE][-+]?[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;
-
- value = data.replace(/_/g, '').toLowerCase();
- sign = value[0] === '-' ? -1 : 1;
-
- 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;
- }
- 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));
-}
-
-var float = new type('tag:yaml.org,2002:float', {
- kind: 'scalar',
- resolve: resolveYamlFloat,
- construct: constructYamlFloat,
- predicate: isFloat,
- represent: representYamlFloat,
- defaultStyle: 'lowercase'
-});
-
-var json = failsafe.extend({
- implicit: [
- _null,
- bool,
- int,
- float
- ]
-});
-
-var core = json;
-
-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();
-}
-
-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;
-}
-
-var merge = new type('tag:yaml.org,2002:merge', {
- kind: 'scalar',
- resolve: resolveYamlMerge
-});
-
-/*eslint-disable no-bitwise*/
-
-
-
-
-
-// [ 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);
- }
-
- return new Uint8Array(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(obj) {
- return Object.prototype.toString.call(obj) === '[object Uint8Array]';
-}
-
-var binary = new type('tag:yaml.org,2002:binary', {
- kind: 'scalar',
- resolve: resolveYamlBinary,
- construct: constructYamlBinary,
- predicate: isBinary,
- represent: representYamlBinary
-});
-
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-var _toString$2 = 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$2.call(pair) !== '[object Object]') return false;
-
- for (pairKey in pair) {
- if (_hasOwnProperty$3.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 : [];
-}
-
-var omap = new type('tag:yaml.org,2002:omap', {
- kind: 'sequence',
- resolve: resolveYamlOmap,
- construct: constructYamlOmap
-});
-
-var _toString$1 = 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$1.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;
-}
-
-var pairs = new type('tag:yaml.org,2002:pairs', {
- kind: 'sequence',
- resolve: resolveYamlPairs,
- construct: constructYamlPairs
-});
-
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-
-function resolveYamlSet(data) {
- if (data === null) return true;
-
- var key, object = data;
-
- for (key in object) {
- if (_hasOwnProperty$2.call(object, key)) {
- if (object[key] !== null) return false;
- }
- }
-
- return true;
-}
-
-function constructYamlSet(data) {
- return data !== null ? data : {};
-}
-
-var set = new type('tag:yaml.org,2002:set', {
- kind: 'mapping',
- resolve: resolveYamlSet,
- construct: constructYamlSet
-});
-
-var _default = core.extend({
- implicit: [
- timestamp,
- merge
- ],
- explicit: [
- binary,
- omap,
- pairs,
- set
- ]
-});
-
-/*eslint-disable max-len,no-use-before-define*/
-
-
-
-
-
-
-
-var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-
-
-var CONTEXT_FLOW_IN = 1;
-var CONTEXT_FLOW_OUT = 2;
-var CONTEXT_BLOCK_IN = 3;
-var CONTEXT_BLOCK_OUT = 4;
-
-
-var CHOMPING_CLIP = 1;
-var CHOMPING_STRIP = 2;
-var CHOMPING_KEEP = 3;
-
-
-var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
-var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
-var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
-
-
-function _class(obj) { return Object.prototype.toString.call(obj); }
-
-function is_EOL(c) {
- return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
-}
-
-function is_WHITE_SPACE(c) {
- return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
-}
-
-function is_WS_OR_EOL(c) {
- return (c === 0x09/* Tab */) ||
- (c === 0x20/* Space */) ||
- (c === 0x0A/* LF */) ||
- (c === 0x0D/* CR */);
-}
-
-function is_FLOW_INDICATOR(c) {
- return c === 0x2C/* , */ ||
- c === 0x5B/* [ */ ||
- c === 0x5D/* ] */ ||
- c === 0x7B/* { */ ||
- c === 0x7D/* } */;
-}
-
-function fromHexCode(c) {
- var lc;
-
- if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
- return c - 0x30;
- }
-
- /*eslint-disable no-bitwise*/
- lc = c | 0x20;
-
- if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
- return lc - 0x61 + 10;
- }
-
- return -1;
-}
-
-function escapedHexLen(c) {
- if (c === 0x78/* x */) { return 2; }
- if (c === 0x75/* u */) { return 4; }
- if (c === 0x55/* U */) { return 8; }
- return 0;
-}
-
-function fromDecimalCode(c) {
- if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
- return c - 0x30;
- }
-
- return -1;
-}
-
-function simpleEscapeSequence(c) {
- /* eslint-disable indent */
- return (c === 0x30/* 0 */) ? '\x00' :
- (c === 0x61/* a */) ? '\x07' :
- (c === 0x62/* b */) ? '\x08' :
- (c === 0x74/* t */) ? '\x09' :
- (c === 0x09/* Tab */) ? '\x09' :
- (c === 0x6E/* n */) ? '\x0A' :
- (c === 0x76/* v */) ? '\x0B' :
- (c === 0x66/* f */) ? '\x0C' :
- (c === 0x72/* r */) ? '\x0D' :
- (c === 0x65/* e */) ? '\x1B' :
- (c === 0x20/* Space */) ? ' ' :
- (c === 0x22/* " */) ? '\x22' :
- (c === 0x2F/* / */) ? '/' :
- (c === 0x5C/* \ */) ? '\x5C' :
- (c === 0x4E/* N */) ? '\x85' :
- (c === 0x5F/* _ */) ? '\xA0' :
- (c === 0x4C/* L */) ? '\u2028' :
- (c === 0x50/* P */) ? '\u2029' : '';
-}
-
-function charFromCodepoint(c) {
- if (c <= 0xFFFF) {
- return String.fromCharCode(c);
- }
- // Encode UTF-16 surrogate pair
- // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
- return String.fromCharCode(
- ((c - 0x010000) >> 10) + 0xD800,
- ((c - 0x010000) & 0x03FF) + 0xDC00
- );
-}
-
-var simpleEscapeCheck = new Array(256); // integer, for fast access
-var simpleEscapeMap = new Array(256);
-for (var i = 0; i < 256; i++) {
- simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
- simpleEscapeMap[i] = simpleEscapeSequence(i);
-}
-
-
-function State$1(input, options) {
- this.input = input;
-
- this.filename = options['filename'] || null;
- this.schema = options['schema'] || _default;
- this.onWarning = options['onWarning'] || null;
- // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
- // if such documents have no explicit %YAML directive
- this.legacy = options['legacy'] || false;
-
- this.json = options['json'] || false;
- this.listener = options['listener'] || null;
-
- this.implicitTypes = this.schema.compiledImplicit;
- this.typeMap = this.schema.compiledTypeMap;
-
- this.length = input.length;
- this.position = 0;
- this.line = 0;
- this.lineStart = 0;
- this.lineIndent = 0;
-
- // position of first leading tab in the current line,
- // used to make sure there are no tabs in the indentation
- this.firstTabInLine = -1;
-
- this.documents = [];
-
- /*
- this.version;
- this.checkLineBreaks;
- this.tagMap;
- this.anchorMap;
- this.tag;
- this.anchor;
- this.kind;
- this.result;*/
-
-}
-
-
-function generateError(state, message) {
- var mark = {
- name: state.filename,
- buffer: state.input.slice(0, -1), // omit trailing \0
- position: state.position,
- line: state.line,
- column: state.position - state.lineStart
- };
-
- mark.snippet = snippet(mark);
-
- return new exception(message, mark);
-}
-
-function throwError(state, message) {
- throw generateError(state, message);
-}
-
-function throwWarning(state, message) {
- if (state.onWarning) {
- state.onWarning.call(null, generateError(state, message));
- }
-}
-
-
-var directiveHandlers = {
-
- YAML: function handleYamlDirective(state, name, args) {
-
- var match, major, minor;
-
- if (state.version !== null) {
- throwError(state, 'duplication of %YAML directive');
- }
-
- if (args.length !== 1) {
- throwError(state, 'YAML directive accepts exactly one argument');
- }
-
- match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-
- if (match === null) {
- throwError(state, 'ill-formed argument of the YAML directive');
- }
-
- major = parseInt(match[1], 10);
- minor = parseInt(match[2], 10);
-
- if (major !== 1) {
- throwError(state, 'unacceptable YAML version of the document');
- }
-
- state.version = args[0];
- state.checkLineBreaks = (minor < 2);
-
- if (minor !== 1 && minor !== 2) {
- throwWarning(state, 'unsupported YAML version of the document');
- }
- },
-
- TAG: function handleTagDirective(state, name, args) {
-
- var handle, prefix;
-
- if (args.length !== 2) {
- throwError(state, 'TAG directive accepts exactly two arguments');
- }
-
- handle = args[0];
- prefix = args[1];
-
- if (!PATTERN_TAG_HANDLE.test(handle)) {
- throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
- }
-
- if (_hasOwnProperty$1.call(state.tagMap, handle)) {
- throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
- }
-
- if (!PATTERN_TAG_URI.test(prefix)) {
- throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
- }
-
- try {
- prefix = decodeURIComponent(prefix);
- } catch (err) {
- throwError(state, 'tag prefix is malformed: ' + prefix);
- }
-
- state.tagMap[handle] = prefix;
- }
-};
-
-
-function captureSegment(state, start, end, checkJson) {
- var _position, _length, _character, _result;
-
- if (start < end) {
- _result = state.input.slice(start, end);
-
- if (checkJson) {
- for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
- _character = _result.charCodeAt(_position);
- if (!(_character === 0x09 ||
- (0x20 <= _character && _character <= 0x10FFFF))) {
- throwError(state, 'expected valid JSON character');
- }
- }
- } else if (PATTERN_NON_PRINTABLE.test(_result)) {
- throwError(state, 'the stream contains non-printable characters');
- }
-
- state.result += _result;
- }
-}
-
-function mergeMappings(state, destination, source, overridableKeys) {
- var sourceKeys, key, index, quantity;
-
- if (!common.isObject(source)) {
- throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
- }
-
- sourceKeys = Object.keys(source);
-
- for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
- key = sourceKeys[index];
-
- if (!_hasOwnProperty$1.call(destination, key)) {
- destination[key] = source[key];
- overridableKeys[key] = true;
- }
- }
-}
-
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
- startLine, startLineStart, startPos) {
-
- var index, quantity;
-
- // The output is a plain object here, so keys can only be strings.
- // We need to convert keyNode to a string, but doing so can hang the process
- // (deeply nested arrays that explode exponentially using aliases).
- if (Array.isArray(keyNode)) {
- keyNode = Array.prototype.slice.call(keyNode);
-
- for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
- if (Array.isArray(keyNode[index])) {
- throwError(state, 'nested arrays are not supported inside keys');
- }
-
- if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
- keyNode[index] = '[object Object]';
- }
- }
- }
-
- // Avoid code execution in load() via toString property
- // (still use its own toString for arrays, timestamps,
- // and whatever user schema extensions happen to have @@toStringTag)
- if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
- keyNode = '[object Object]';
- }
-
-
- keyNode = String(keyNode);
-
- if (_result === null) {
- _result = {};
- }
-
- if (keyTag === 'tag:yaml.org,2002:merge') {
- if (Array.isArray(valueNode)) {
- for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
- mergeMappings(state, _result, valueNode[index], overridableKeys);
- }
- } else {
- mergeMappings(state, _result, valueNode, overridableKeys);
- }
- } else {
- if (!state.json &&
- !_hasOwnProperty$1.call(overridableKeys, keyNode) &&
- _hasOwnProperty$1.call(_result, keyNode)) {
- state.line = startLine || state.line;
- state.lineStart = startLineStart || state.lineStart;
- state.position = startPos || state.position;
- throwError(state, 'duplicated mapping key');
- }
-
- // used for this specific key only because Object.defineProperty is slow
- if (keyNode === '__proto__') {
- Object.defineProperty(_result, keyNode, {
- configurable: true,
- enumerable: true,
- writable: true,
- value: valueNode
- });
- } else {
- _result[keyNode] = valueNode;
- }
- delete overridableKeys[keyNode];
- }
-
- return _result;
-}
-
-function readLineBreak(state) {
- var ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch === 0x0A/* LF */) {
- state.position++;
- } else if (ch === 0x0D/* CR */) {
- state.position++;
- if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
- state.position++;
- }
- } else {
- throwError(state, 'a line break is expected');
- }
-
- state.line += 1;
- state.lineStart = state.position;
- state.firstTabInLine = -1;
-}
-
-function skipSeparationSpace(state, allowComments, checkIndent) {
- var lineBreaks = 0,
- ch = state.input.charCodeAt(state.position);
-
- while (ch !== 0) {
- while (is_WHITE_SPACE(ch)) {
- if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
- state.firstTabInLine = state.position;
- }
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (allowComments && ch === 0x23/* # */) {
- do {
- ch = state.input.charCodeAt(++state.position);
- } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
- }
-
- if (is_EOL(ch)) {
- readLineBreak(state);
-
- ch = state.input.charCodeAt(state.position);
- lineBreaks++;
- state.lineIndent = 0;
-
- while (ch === 0x20/* Space */) {
- state.lineIndent++;
- ch = state.input.charCodeAt(++state.position);
- }
- } else {
- break;
- }
- }
-
- if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
- throwWarning(state, 'deficient indentation');
- }
-
- return lineBreaks;
-}
-
-function testDocumentSeparator(state) {
- var _position = state.position,
- ch;
-
- ch = state.input.charCodeAt(_position);
-
- // Condition state.position === state.lineStart is tested
- // in parent on each call, for efficiency. No needs to test here again.
- if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
- ch === state.input.charCodeAt(_position + 1) &&
- ch === state.input.charCodeAt(_position + 2)) {
-
- _position += 3;
-
- ch = state.input.charCodeAt(_position);
-
- if (ch === 0 || is_WS_OR_EOL(ch)) {
- return true;
- }
- }
-
- return false;
-}
-
-function writeFoldedLines(state, count) {
- if (count === 1) {
- state.result += ' ';
- } else if (count > 1) {
- state.result += common.repeat('\n', count - 1);
- }
-}
-
-
-function readPlainScalar(state, nodeIndent, withinFlowCollection) {
- var preceding,
- following,
- captureStart,
- captureEnd,
- hasPendingContent,
- _line,
- _lineStart,
- _lineIndent,
- _kind = state.kind,
- _result = state.result,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (is_WS_OR_EOL(ch) ||
- is_FLOW_INDICATOR(ch) ||
- ch === 0x23/* # */ ||
- ch === 0x26/* & */ ||
- ch === 0x2A/* * */ ||
- ch === 0x21/* ! */ ||
- ch === 0x7C/* | */ ||
- ch === 0x3E/* > */ ||
- ch === 0x27/* ' */ ||
- ch === 0x22/* " */ ||
- ch === 0x25/* % */ ||
- ch === 0x40/* @ */ ||
- ch === 0x60/* ` */) {
- return false;
- }
-
- if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
- following = state.input.charCodeAt(state.position + 1);
-
- if (is_WS_OR_EOL(following) ||
- withinFlowCollection && is_FLOW_INDICATOR(following)) {
- return false;
- }
- }
-
- state.kind = 'scalar';
- state.result = '';
- captureStart = captureEnd = state.position;
- hasPendingContent = false;
-
- while (ch !== 0) {
- if (ch === 0x3A/* : */) {
- following = state.input.charCodeAt(state.position + 1);
-
- if (is_WS_OR_EOL(following) ||
- withinFlowCollection && is_FLOW_INDICATOR(following)) {
- break;
- }
-
- } else if (ch === 0x23/* # */) {
- preceding = state.input.charCodeAt(state.position - 1);
-
- if (is_WS_OR_EOL(preceding)) {
- break;
- }
-
- } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
- withinFlowCollection && is_FLOW_INDICATOR(ch)) {
- break;
-
- } else if (is_EOL(ch)) {
- _line = state.line;
- _lineStart = state.lineStart;
- _lineIndent = state.lineIndent;
- skipSeparationSpace(state, false, -1);
-
- if (state.lineIndent >= nodeIndent) {
- hasPendingContent = true;
- ch = state.input.charCodeAt(state.position);
- continue;
- } else {
- state.position = captureEnd;
- state.line = _line;
- state.lineStart = _lineStart;
- state.lineIndent = _lineIndent;
- break;
- }
- }
-
- if (hasPendingContent) {
- captureSegment(state, captureStart, captureEnd, false);
- writeFoldedLines(state, state.line - _line);
- captureStart = captureEnd = state.position;
- hasPendingContent = false;
- }
-
- if (!is_WHITE_SPACE(ch)) {
- captureEnd = state.position + 1;
- }
-
- ch = state.input.charCodeAt(++state.position);
- }
-
- captureSegment(state, captureStart, captureEnd, false);
-
- if (state.result) {
- return true;
- }
-
- state.kind = _kind;
- state.result = _result;
- return false;
-}
-
-function readSingleQuotedScalar(state, nodeIndent) {
- var ch,
- captureStart, captureEnd;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch !== 0x27/* ' */) {
- return false;
- }
-
- state.kind = 'scalar';
- state.result = '';
- state.position++;
- captureStart = captureEnd = state.position;
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- if (ch === 0x27/* ' */) {
- captureSegment(state, captureStart, state.position, true);
- ch = state.input.charCodeAt(++state.position);
-
- if (ch === 0x27/* ' */) {
- captureStart = state.position;
- state.position++;
- captureEnd = state.position;
- } else {
- return true;
- }
-
- } else if (is_EOL(ch)) {
- captureSegment(state, captureStart, captureEnd, true);
- writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
- captureStart = captureEnd = state.position;
-
- } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
- throwError(state, 'unexpected end of the document within a single quoted scalar');
-
- } else {
- state.position++;
- captureEnd = state.position;
- }
- }
-
- throwError(state, 'unexpected end of the stream within a single quoted scalar');
-}
-
-function readDoubleQuotedScalar(state, nodeIndent) {
- var captureStart,
- captureEnd,
- hexLength,
- hexResult,
- tmp,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch !== 0x22/* " */) {
- return false;
- }
-
- state.kind = 'scalar';
- state.result = '';
- state.position++;
- captureStart = captureEnd = state.position;
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- if (ch === 0x22/* " */) {
- captureSegment(state, captureStart, state.position, true);
- state.position++;
- return true;
-
- } else if (ch === 0x5C/* \ */) {
- captureSegment(state, captureStart, state.position, true);
- ch = state.input.charCodeAt(++state.position);
-
- if (is_EOL(ch)) {
- skipSeparationSpace(state, false, nodeIndent);
-
- // TODO: rework to inline fn with no type cast?
- } else if (ch < 256 && simpleEscapeCheck[ch]) {
- state.result += simpleEscapeMap[ch];
- state.position++;
-
- } else if ((tmp = escapedHexLen(ch)) > 0) {
- hexLength = tmp;
- hexResult = 0;
-
- for (; hexLength > 0; hexLength--) {
- ch = state.input.charCodeAt(++state.position);
-
- if ((tmp = fromHexCode(ch)) >= 0) {
- hexResult = (hexResult << 4) + tmp;
-
- } else {
- throwError(state, 'expected hexadecimal character');
- }
- }
-
- state.result += charFromCodepoint(hexResult);
-
- state.position++;
-
- } else {
- throwError(state, 'unknown escape sequence');
- }
-
- captureStart = captureEnd = state.position;
-
- } else if (is_EOL(ch)) {
- captureSegment(state, captureStart, captureEnd, true);
- writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
- captureStart = captureEnd = state.position;
-
- } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
- throwError(state, 'unexpected end of the document within a double quoted scalar');
-
- } else {
- state.position++;
- captureEnd = state.position;
- }
- }
-
- throwError(state, 'unexpected end of the stream within a double quoted scalar');
-}
-
-function readFlowCollection(state, nodeIndent) {
- var readNext = true,
- _line,
- _lineStart,
- _pos,
- _tag = state.tag,
- _result,
- _anchor = state.anchor,
- following,
- terminator,
- isPair,
- isExplicitPair,
- isMapping,
- overridableKeys = Object.create(null),
- keyNode,
- keyTag,
- valueNode,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch === 0x5B/* [ */) {
- terminator = 0x5D;/* ] */
- isMapping = false;
- _result = [];
- } else if (ch === 0x7B/* { */) {
- terminator = 0x7D;/* } */
- isMapping = true;
- _result = {};
- } else {
- return false;
- }
-
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = _result;
- }
-
- ch = state.input.charCodeAt(++state.position);
-
- while (ch !== 0) {
- skipSeparationSpace(state, true, nodeIndent);
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch === terminator) {
- state.position++;
- state.tag = _tag;
- state.anchor = _anchor;
- state.kind = isMapping ? 'mapping' : 'sequence';
- state.result = _result;
- return true;
- } else if (!readNext) {
- throwError(state, 'missed comma between flow collection entries');
- } else if (ch === 0x2C/* , */) {
- // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
- throwError(state, "expected the node content, but found ','");
- }
-
- keyTag = keyNode = valueNode = null;
- isPair = isExplicitPair = false;
-
- if (ch === 0x3F/* ? */) {
- following = state.input.charCodeAt(state.position + 1);
-
- if (is_WS_OR_EOL(following)) {
- isPair = isExplicitPair = true;
- state.position++;
- skipSeparationSpace(state, true, nodeIndent);
- }
- }
-
- _line = state.line; // Save the current line.
- _lineStart = state.lineStart;
- _pos = state.position;
- composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
- keyTag = state.tag;
- keyNode = state.result;
- skipSeparationSpace(state, true, nodeIndent);
-
- ch = state.input.charCodeAt(state.position);
-
- if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
- isPair = true;
- ch = state.input.charCodeAt(++state.position);
- skipSeparationSpace(state, true, nodeIndent);
- composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
- valueNode = state.result;
- }
-
- if (isMapping) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
- } else if (isPair) {
- _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
- } else {
- _result.push(keyNode);
- }
-
- skipSeparationSpace(state, true, nodeIndent);
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch === 0x2C/* , */) {
- readNext = true;
- ch = state.input.charCodeAt(++state.position);
- } else {
- readNext = false;
- }
- }
-
- throwError(state, 'unexpected end of the stream within a flow collection');
-}
-
-function readBlockScalar(state, nodeIndent) {
- var captureStart,
- folding,
- chomping = CHOMPING_CLIP,
- didReadContent = false,
- detectedIndent = false,
- textIndent = nodeIndent,
- emptyLines = 0,
- atMoreIndented = false,
- tmp,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch === 0x7C/* | */) {
- folding = false;
- } else if (ch === 0x3E/* > */) {
- folding = true;
- } else {
- return false;
- }
-
- state.kind = 'scalar';
- state.result = '';
-
- while (ch !== 0) {
- ch = state.input.charCodeAt(++state.position);
-
- if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
- if (CHOMPING_CLIP === chomping) {
- chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
- } else {
- throwError(state, 'repeat of a chomping mode identifier');
- }
-
- } else if ((tmp = fromDecimalCode(ch)) >= 0) {
- if (tmp === 0) {
- throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
- } else if (!detectedIndent) {
- textIndent = nodeIndent + tmp - 1;
- detectedIndent = true;
- } else {
- throwError(state, 'repeat of an indentation width identifier');
- }
-
- } else {
- break;
- }
- }
-
- if (is_WHITE_SPACE(ch)) {
- do { ch = state.input.charCodeAt(++state.position); }
- while (is_WHITE_SPACE(ch));
-
- if (ch === 0x23/* # */) {
- do { ch = state.input.charCodeAt(++state.position); }
- while (!is_EOL(ch) && (ch !== 0));
- }
- }
-
- while (ch !== 0) {
- readLineBreak(state);
- state.lineIndent = 0;
-
- ch = state.input.charCodeAt(state.position);
-
- while ((!detectedIndent || state.lineIndent < textIndent) &&
- (ch === 0x20/* Space */)) {
- state.lineIndent++;
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (!detectedIndent && state.lineIndent > textIndent) {
- textIndent = state.lineIndent;
- }
-
- if (is_EOL(ch)) {
- emptyLines++;
- continue;
- }
-
- // End of the scalar.
- if (state.lineIndent < textIndent) {
-
- // Perform the chomping.
- if (chomping === CHOMPING_KEEP) {
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
- } else if (chomping === CHOMPING_CLIP) {
- if (didReadContent) { // i.e. only if the scalar is not empty.
- state.result += '\n';
- }
- }
-
- // Break this `while` cycle and go to the funciton's epilogue.
- break;
- }
-
- // Folded style: use fancy rules to handle line breaks.
- if (folding) {
-
- // Lines starting with white space characters (more-indented lines) are not folded.
- if (is_WHITE_SPACE(ch)) {
- atMoreIndented = true;
- // except for the first content line (cf. Example 8.1)
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
-
- // End of more-indented block.
- } else if (atMoreIndented) {
- atMoreIndented = false;
- state.result += common.repeat('\n', emptyLines + 1);
-
- // Just one line break - perceive as the same line.
- } else if (emptyLines === 0) {
- if (didReadContent) { // i.e. only if we have already read some scalar content.
- state.result += ' ';
- }
-
- // Several line breaks - perceive as different lines.
- } else {
- state.result += common.repeat('\n', emptyLines);
- }
-
- // Literal style: just add exact number of line breaks between content lines.
- } else {
- // Keep all line breaks except the header line break.
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
- }
-
- didReadContent = true;
- detectedIndent = true;
- emptyLines = 0;
- captureStart = state.position;
-
- while (!is_EOL(ch) && (ch !== 0)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- captureSegment(state, captureStart, state.position, false);
- }
-
- return true;
-}
-
-function readBlockSequence(state, nodeIndent) {
- var _line,
- _tag = state.tag,
- _anchor = state.anchor,
- _result = [],
- following,
- detected = false,
- ch;
-
- // there is a leading tab before this token, so it can't be a block sequence/mapping;
- // it can still be flow sequence/mapping or a scalar
- if (state.firstTabInLine !== -1) return false;
-
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = _result;
- }
-
- ch = state.input.charCodeAt(state.position);
-
- while (ch !== 0) {
- if (state.firstTabInLine !== -1) {
- state.position = state.firstTabInLine;
- throwError(state, 'tab characters must not be used in indentation');
- }
-
- if (ch !== 0x2D/* - */) {
- break;
- }
-
- following = state.input.charCodeAt(state.position + 1);
-
- if (!is_WS_OR_EOL(following)) {
- break;
- }
-
- detected = true;
- state.position++;
-
- if (skipSeparationSpace(state, true, -1)) {
- if (state.lineIndent <= nodeIndent) {
- _result.push(null);
- ch = state.input.charCodeAt(state.position);
- continue;
- }
- }
-
- _line = state.line;
- composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
- _result.push(state.result);
- skipSeparationSpace(state, true, -1);
-
- ch = state.input.charCodeAt(state.position);
-
- if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
- throwError(state, 'bad indentation of a sequence entry');
- } else if (state.lineIndent < nodeIndent) {
- break;
- }
- }
-
- if (detected) {
- state.tag = _tag;
- state.anchor = _anchor;
- state.kind = 'sequence';
- state.result = _result;
- return true;
- }
- return false;
-}
-
-function readBlockMapping(state, nodeIndent, flowIndent) {
- var following,
- allowCompact,
- _line,
- _keyLine,
- _keyLineStart,
- _keyPos,
- _tag = state.tag,
- _anchor = state.anchor,
- _result = {},
- overridableKeys = Object.create(null),
- keyTag = null,
- keyNode = null,
- valueNode = null,
- atExplicitKey = false,
- detected = false,
- ch;
-
- // there is a leading tab before this token, so it can't be a block sequence/mapping;
- // it can still be flow sequence/mapping or a scalar
- if (state.firstTabInLine !== -1) return false;
-
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = _result;
- }
-
- ch = state.input.charCodeAt(state.position);
-
- while (ch !== 0) {
- if (!atExplicitKey && state.firstTabInLine !== -1) {
- state.position = state.firstTabInLine;
- throwError(state, 'tab characters must not be used in indentation');
- }
-
- following = state.input.charCodeAt(state.position + 1);
- _line = state.line; // Save the current line.
-
- //
- // Explicit notation case. There are two separate blocks:
- // first for the key (denoted by "?") and second for the value (denoted by ":")
- //
- if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
-
- if (ch === 0x3F/* ? */) {
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
- keyTag = keyNode = valueNode = null;
- }
-
- detected = true;
- atExplicitKey = true;
- allowCompact = true;
-
- } else if (atExplicitKey) {
- // i.e. 0x3A/* : */ === character after the explicit key.
- atExplicitKey = false;
- allowCompact = true;
-
- } else {
- throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
- }
-
- state.position += 1;
- ch = following;
-
- //
- // Implicit notation case. Flow-style node as the key first, then ":", and the value.
- //
- } else {
- _keyLine = state.line;
- _keyLineStart = state.lineStart;
- _keyPos = state.position;
-
- if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
- // Neither implicit nor explicit notation.
- // Reading is done. Go to the epilogue.
- break;
- }
-
- if (state.line === _line) {
- ch = state.input.charCodeAt(state.position);
-
- while (is_WHITE_SPACE(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (ch === 0x3A/* : */) {
- ch = state.input.charCodeAt(++state.position);
-
- if (!is_WS_OR_EOL(ch)) {
- throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
- }
-
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
- keyTag = keyNode = valueNode = null;
- }
-
- detected = true;
- atExplicitKey = false;
- allowCompact = false;
- keyTag = state.tag;
- keyNode = state.result;
-
- } else if (detected) {
- throwError(state, 'can not read an implicit mapping pair; a colon is missed');
-
- } else {
- state.tag = _tag;
- state.anchor = _anchor;
- return true; // Keep the result of `composeNode`.
- }
-
- } else if (detected) {
- throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
-
- } else {
- state.tag = _tag;
- state.anchor = _anchor;
- return true; // Keep the result of `composeNode`.
- }
- }
-
- //
- // Common reading code for both explicit and implicit notations.
- //
- if (state.line === _line || state.lineIndent > nodeIndent) {
- if (atExplicitKey) {
- _keyLine = state.line;
- _keyLineStart = state.lineStart;
- _keyPos = state.position;
- }
-
- if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
- if (atExplicitKey) {
- keyNode = state.result;
- } else {
- valueNode = state.result;
- }
- }
-
- if (!atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
- keyTag = keyNode = valueNode = null;
- }
-
- skipSeparationSpace(state, true, -1);
- ch = state.input.charCodeAt(state.position);
- }
-
- if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
- throwError(state, 'bad indentation of a mapping entry');
- } else if (state.lineIndent < nodeIndent) {
- break;
- }
- }
-
- //
- // Epilogue.
- //
-
- // Special case: last mapping's node contains only the key in explicit notation.
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
- }
-
- // Expose the resulting mapping.
- if (detected) {
- state.tag = _tag;
- state.anchor = _anchor;
- state.kind = 'mapping';
- state.result = _result;
- }
-
- return detected;
-}
-
-function readTagProperty(state) {
- var _position,
- isVerbatim = false,
- isNamed = false,
- tagHandle,
- tagName,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch !== 0x21/* ! */) return false;
-
- if (state.tag !== null) {
- throwError(state, 'duplication of a tag property');
- }
-
- ch = state.input.charCodeAt(++state.position);
-
- if (ch === 0x3C/* < */) {
- isVerbatim = true;
- ch = state.input.charCodeAt(++state.position);
-
- } else if (ch === 0x21/* ! */) {
- isNamed = true;
- tagHandle = '!!';
- ch = state.input.charCodeAt(++state.position);
-
- } else {
- tagHandle = '!';
- }
-
- _position = state.position;
-
- if (isVerbatim) {
- do { ch = state.input.charCodeAt(++state.position); }
- while (ch !== 0 && ch !== 0x3E/* > */);
-
- if (state.position < state.length) {
- tagName = state.input.slice(_position, state.position);
- ch = state.input.charCodeAt(++state.position);
- } else {
- throwError(state, 'unexpected end of the stream within a verbatim tag');
- }
- } else {
- while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-
- if (ch === 0x21/* ! */) {
- if (!isNamed) {
- tagHandle = state.input.slice(_position - 1, state.position + 1);
-
- if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
- throwError(state, 'named tag handle cannot contain such characters');
- }
-
- isNamed = true;
- _position = state.position + 1;
- } else {
- throwError(state, 'tag suffix cannot contain exclamation marks');
- }
- }
-
- ch = state.input.charCodeAt(++state.position);
- }
-
- tagName = state.input.slice(_position, state.position);
-
- if (PATTERN_FLOW_INDICATORS.test(tagName)) {
- throwError(state, 'tag suffix cannot contain flow indicator characters');
- }
- }
-
- if (tagName && !PATTERN_TAG_URI.test(tagName)) {
- throwError(state, 'tag name cannot contain such characters: ' + tagName);
- }
-
- try {
- tagName = decodeURIComponent(tagName);
- } catch (err) {
- throwError(state, 'tag name is malformed: ' + tagName);
- }
-
- if (isVerbatim) {
- state.tag = tagName;
-
- } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
- state.tag = state.tagMap[tagHandle] + tagName;
-
- } else if (tagHandle === '!') {
- state.tag = '!' + tagName;
-
- } else if (tagHandle === '!!') {
- state.tag = 'tag:yaml.org,2002:' + tagName;
-
- } else {
- throwError(state, 'undeclared tag handle "' + tagHandle + '"');
- }
-
- return true;
-}
-
-function readAnchorProperty(state) {
- var _position,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch !== 0x26/* & */) return false;
-
- if (state.anchor !== null) {
- throwError(state, 'duplication of an anchor property');
- }
-
- ch = state.input.charCodeAt(++state.position);
- _position = state.position;
-
- while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (state.position === _position) {
- throwError(state, 'name of an anchor node must contain at least one character');
- }
-
- state.anchor = state.input.slice(_position, state.position);
- return true;
-}
-
-function readAlias(state) {
- var _position, alias,
- ch;
-
- ch = state.input.charCodeAt(state.position);
-
- if (ch !== 0x2A/* * */) return false;
-
- ch = state.input.charCodeAt(++state.position);
- _position = state.position;
-
- while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (state.position === _position) {
- throwError(state, 'name of an alias node must contain at least one character');
- }
-
- alias = state.input.slice(_position, state.position);
-
- if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
- throwError(state, 'unidentified alias "' + alias + '"');
- }
-
- state.result = state.anchorMap[alias];
- skipSeparationSpace(state, true, -1);
- return true;
-}
-
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
- var allowBlockStyles,
- allowBlockScalars,
- allowBlockCollections,
- indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
- atNewLine = false,
- hasContent = false,
- typeIndex,
- typeQuantity,
- typeList,
- type,
- flowIndent,
- blockIndent;
-
- if (state.listener !== null) {
- state.listener('open', state);
- }
-
- state.tag = null;
- state.anchor = null;
- state.kind = null;
- state.result = null;
-
- allowBlockStyles = allowBlockScalars = allowBlockCollections =
- CONTEXT_BLOCK_OUT === nodeContext ||
- CONTEXT_BLOCK_IN === nodeContext;
-
- if (allowToSeek) {
- if (skipSeparationSpace(state, true, -1)) {
- atNewLine = true;
-
- if (state.lineIndent > parentIndent) {
- indentStatus = 1;
- } else if (state.lineIndent === parentIndent) {
- indentStatus = 0;
- } else if (state.lineIndent < parentIndent) {
- indentStatus = -1;
- }
- }
- }
-
- if (indentStatus === 1) {
- while (readTagProperty(state) || readAnchorProperty(state)) {
- if (skipSeparationSpace(state, true, -1)) {
- atNewLine = true;
- allowBlockCollections = allowBlockStyles;
-
- if (state.lineIndent > parentIndent) {
- indentStatus = 1;
- } else if (state.lineIndent === parentIndent) {
- indentStatus = 0;
- } else if (state.lineIndent < parentIndent) {
- indentStatus = -1;
- }
- } else {
- allowBlockCollections = false;
- }
- }
- }
-
- if (allowBlockCollections) {
- allowBlockCollections = atNewLine || allowCompact;
- }
-
- if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
- if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
- flowIndent = parentIndent;
- } else {
- flowIndent = parentIndent + 1;
- }
-
- blockIndent = state.position - state.lineStart;
-
- if (indentStatus === 1) {
- if (allowBlockCollections &&
- (readBlockSequence(state, blockIndent) ||
- readBlockMapping(state, blockIndent, flowIndent)) ||
- readFlowCollection(state, flowIndent)) {
- hasContent = true;
- } else {
- if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
- readSingleQuotedScalar(state, flowIndent) ||
- readDoubleQuotedScalar(state, flowIndent)) {
- hasContent = true;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
- } else if (readAlias(state)) {
- hasContent = true;
+const primitives$6 = new Set(['string', 'number', 'boolean']);
- if (state.tag !== null || state.anchor !== null) {
- throwError(state, 'alias node should not have any properties');
- }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$6(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
- } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
- hasContent = true;
+ Object.defineProperty(plugin, 'name', {value: id});
- if (state.tag === null) {
- state.tag = '?';
- }
- }
+ return plugin
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = state.result;
- }
- }
- } else if (indentStatus === 0) {
- // Special case: block sequences are allowed to have same indentation level as the parent.
- // http://www.yaml.org/spec/1.2/spec.html#id2799784
- hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
- }
- }
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$6(ruleId, raw);
- if (state.tag === null) {
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = state.result;
- }
+ if (!severity) return
- } else if (state.tag === '?') {
- // Implicit resolving is not allowed for non-scalar types, and '?'
- // non-specific tag is only automatically assigned to plain scalars.
- //
- // We only need to check kind conformity in case user explicitly assigns '?'
- // tag, for example like this: "!<?> [0]"
- //
- if (state.result !== null && state.kind !== 'scalar') {
- throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
- }
+ const fatal = severity === 2;
- for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
- type = state.implicitTypes[typeIndex];
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
- if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
- state.result = type.construct(state.result);
- state.tag = type.tag;
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = state.result;
- }
- break;
- }
- }
- } else if (state.tag !== '!') {
- if (_hasOwnProperty$1.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
- type = state.typeMap[state.kind || 'fallback'][state.tag];
- } else {
- // looking for multi type
- type = null;
- typeList = state.typeMap.multi[state.kind || 'fallback'];
+ wrap(rule, (error) => {
+ const messages = file.messages;
- for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
- if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
- type = typeList[typeIndex];
- break;
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
}
- }
- }
-
- if (!type) {
- throwError(state, 'unknown tag !<' + state.tag + '>');
- }
-
- if (state.result !== null && type.kind !== state.kind) {
- throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
- }
-
- if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
- throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
- } else {
- state.result = type.construct(state.result, state.tag);
- if (state.anchor !== null) {
- state.anchorMap[state.anchor] = state.result;
- }
- }
- }
-
- if (state.listener !== null) {
- state.listener('close', state);
- }
- return state.tag !== null || state.anchor !== null || hasContent;
-}
-
-function readDocument(state) {
- var documentStart = state.position,
- _position,
- directiveName,
- directiveArgs,
- hasDirectives = false,
- ch;
-
- state.version = null;
- state.checkLineBreaks = state.legacy;
- state.tagMap = Object.create(null);
- state.anchorMap = Object.create(null);
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- skipSeparationSpace(state, true, -1);
-
- ch = state.input.charCodeAt(state.position);
-
- if (state.lineIndent > 0 || ch !== 0x25/* % */) {
- break;
- }
-
- hasDirectives = true;
- ch = state.input.charCodeAt(++state.position);
- _position = state.position;
-
- while (ch !== 0 && !is_WS_OR_EOL(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- directiveName = state.input.slice(_position, state.position);
- directiveArgs = [];
-
- if (directiveName.length < 1) {
- throwError(state, 'directive name must not be less than one character in length');
- }
-
- while (ch !== 0) {
- while (is_WHITE_SPACE(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- if (ch === 0x23/* # */) {
- do { ch = state.input.charCodeAt(++state.position); }
- while (ch !== 0 && !is_EOL(ch));
- break;
- }
-
- if (is_EOL(ch)) break;
-
- _position = state.position;
-
- while (ch !== 0 && !is_WS_OR_EOL(ch)) {
- ch = state.input.charCodeAt(++state.position);
- }
-
- directiveArgs.push(state.input.slice(_position, state.position));
- }
-
- if (ch !== 0) readLineBreak(state);
-
- if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
- directiveHandlers[directiveName](state, directiveName, directiveArgs);
- } else {
- throwWarning(state, 'unknown document directive "' + directiveName + '"');
- }
- }
-
- skipSeparationSpace(state, true, -1);
-
- if (state.lineIndent === 0 &&
- state.input.charCodeAt(state.position) === 0x2D/* - */ &&
- state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
- state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
- state.position += 3;
- skipSeparationSpace(state, true, -1);
-
- } else if (hasDirectives) {
- throwError(state, 'directives end mark is expected');
- }
-
- composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
- skipSeparationSpace(state, true, -1);
-
- if (state.checkLineBreaks &&
- PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
- throwWarning(state, 'non-ASCII line breaks are interpreted as content');
- }
-
- state.documents.push(state.result);
-
- if (state.position === state.lineStart && testDocumentSeparator(state)) {
-
- if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
- state.position += 3;
- skipSeparationSpace(state, true, -1);
- }
- return;
- }
-
- if (state.position < (state.length - 1)) {
- throwError(state, 'end of the stream or a document separator is expected');
- } else {
- return;
- }
-}
-
-
-function loadDocuments(input, options) {
- input = String(input);
- options = options || {};
-
- if (input.length !== 0) {
-
- // Add tailing `\n` if not exists
- if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
- input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
- input += '\n';
- }
-
- // Strip BOM
- if (input.charCodeAt(0) === 0xFEFF) {
- input = input.slice(1);
- }
- }
-
- var state = new State$1(input, options);
-
- var nullpos = input.indexOf('\0');
-
- if (nullpos !== -1) {
- state.position = nullpos;
- throwError(state, 'null byte is not allowed in input');
- }
-
- // Use 0 as string terminator. That significantly simplifies bounds check.
- state.input += '\0';
-
- while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
- state.lineIndent += 1;
- state.position += 1;
- }
-
- while (state.position < (state.length - 1)) {
- readDocument(state);
- }
-
- return state.documents;
-}
-
-
-function loadAll$1(input, iterator, options) {
- if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
- options = iterator;
- iterator = null;
- }
-
- var documents = loadDocuments(input, options);
-
- if (typeof iterator !== 'function') {
- return documents;
- }
-
- for (var index = 0, length = documents.length; index < length; index += 1) {
- iterator(documents[index]);
- }
-}
-
-
-function load$1(input, options) {
- var documents = loadDocuments(input, options);
-
- if (documents.length === 0) {
- /*eslint-disable no-undefined*/
- return undefined;
- } else if (documents.length === 1) {
- return documents[0];
- }
- throw new exception('expected a single document in the stream, but found more');
-}
-
-
-var loadAll_1 = loadAll$1;
-var load_1 = load$1;
-
-var loader = {
- loadAll: loadAll_1,
- load: load_1
-};
-
-/*eslint-disable no-use-before-define*/
-
-
-
-
-
-var _toString = Object.prototype.toString;
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-var CHAR_BOM = 0xFEFF;
-var CHAR_TAB = 0x09; /* Tab */
-var CHAR_LINE_FEED = 0x0A; /* LF */
-var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
-var CHAR_SPACE = 0x20; /* Space */
-var CHAR_EXCLAMATION = 0x21; /* ! */
-var CHAR_DOUBLE_QUOTE = 0x22; /* " */
-var CHAR_SHARP = 0x23; /* # */
-var CHAR_PERCENT = 0x25; /* % */
-var CHAR_AMPERSAND = 0x26; /* & */
-var CHAR_SINGLE_QUOTE = 0x27; /* ' */
-var CHAR_ASTERISK = 0x2A; /* * */
-var CHAR_COMMA = 0x2C; /* , */
-var CHAR_MINUS = 0x2D; /* - */
-var CHAR_COLON = 0x3A; /* : */
-var CHAR_EQUALS = 0x3D; /* = */
-var CHAR_GREATER_THAN = 0x3E; /* > */
-var CHAR_QUESTION = 0x3F; /* ? */
-var CHAR_COMMERCIAL_AT = 0x40; /* @ */
-var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
-var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
-var CHAR_GRAVE_ACCENT = 0x60; /* ` */
-var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
-var CHAR_VERTICAL_LINE = 0x7C; /* | */
-var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
-
-var ESCAPE_SEQUENCES = {};
-
-ESCAPE_SEQUENCES[0x00] = '\\0';
-ESCAPE_SEQUENCES[0x07] = '\\a';
-ESCAPE_SEQUENCES[0x08] = '\\b';
-ESCAPE_SEQUENCES[0x09] = '\\t';
-ESCAPE_SEQUENCES[0x0A] = '\\n';
-ESCAPE_SEQUENCES[0x0B] = '\\v';
-ESCAPE_SEQUENCES[0x0C] = '\\f';
-ESCAPE_SEQUENCES[0x0D] = '\\r';
-ESCAPE_SEQUENCES[0x1B] = '\\e';
-ESCAPE_SEQUENCES[0x22] = '\\"';
-ESCAPE_SEQUENCES[0x5C] = '\\\\';
-ESCAPE_SEQUENCES[0x85] = '\\N';
-ESCAPE_SEQUENCES[0xA0] = '\\_';
-ESCAPE_SEQUENCES[0x2028] = '\\L';
-ESCAPE_SEQUENCES[0x2029] = '\\P';
-
-var DEPRECATED_BOOLEANS_SYNTAX = [
- 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
- 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
-];
-
-var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-
-function compileStyleMap(schema, map) {
- var result, keys, index, length, tag, style, type;
-
- if (map === null) return {};
-
- result = {};
- keys = Object.keys(map);
-
- for (index = 0, length = keys.length; index < length; index += 1) {
- tag = keys[index];
- style = String(map[tag]);
-
- if (tag.slice(0, 2) === '!!') {
- tag = 'tag:yaml.org,2002:' + tag.slice(2);
- }
- type = schema.compiledTypeMap['fallback'][tag];
-
- if (type && _hasOwnProperty.call(type.styleAliases, style)) {
- style = type.styleAliases[style];
- }
-
- result[tag] = style;
- }
-
- return result;
-}
-
-function encodeHex(character) {
- var string, handle, length;
-
- string = character.toString(16).toUpperCase();
-
- if (character <= 0xFF) {
- handle = 'x';
- length = 2;
- } else if (character <= 0xFFFF) {
- handle = 'u';
- length = 4;
- } else if (character <= 0xFFFFFFFF) {
- handle = 'U';
- length = 8;
- } else {
- throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
- }
-
- return '\\' + handle + common.repeat('0', length - string.length) + string;
-}
-
-
-var QUOTING_TYPE_SINGLE = 1,
- QUOTING_TYPE_DOUBLE = 2;
-
-function State(options) {
- this.schema = options['schema'] || _default;
- this.indent = Math.max(1, (options['indent'] || 2));
- this.noArrayIndent = options['noArrayIndent'] || false;
- this.skipInvalid = options['skipInvalid'] || false;
- this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
- this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
- this.sortKeys = options['sortKeys'] || false;
- this.lineWidth = options['lineWidth'] || 80;
- this.noRefs = options['noRefs'] || false;
- this.noCompatMode = options['noCompatMode'] || false;
- this.condenseFlow = options['condenseFlow'] || false;
- this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
- this.forceQuotes = options['forceQuotes'] || false;
- this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null;
-
- this.implicitTypes = this.schema.compiledImplicit;
- this.explicitTypes = this.schema.compiledExplicit;
-
- this.tag = null;
- this.result = '';
-
- this.duplicates = [];
- this.usedDuplicates = null;
-}
-
-// Indents every line in a string. Empty lines (\n only) are not indented.
-function indentString(string, spaces) {
- var ind = common.repeat(' ', spaces),
- position = 0,
- next = -1,
- result = '',
- line,
- length = string.length;
-
- while (position < length) {
- next = string.indexOf('\n', position);
- if (next === -1) {
- line = string.slice(position);
- position = length;
- } else {
- line = string.slice(position, next + 1);
- position = next + 1;
- }
-
- if (line.length && line !== '\n') result += ind;
-
- result += line;
- }
-
- return result;
-}
-
-function generateNextLine(state, level) {
- return '\n' + common.repeat(' ', state.indent * level);
-}
-
-function testImplicitResolving(state, str) {
- var index, length, type;
-
- for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
- type = state.implicitTypes[index];
-
- if (type.resolve(str)) {
- return true;
- }
- }
- return false;
-}
-
-// [33] s-white ::= s-space | s-tab
-function isWhitespace(c) {
- return c === CHAR_SPACE || c === CHAR_TAB;
-}
-
-// Returns true if the character can be printed without escaping.
-// From YAML 1.2: "any allowed characters known to be non-printable
-// should also be escaped. [However,] This isn’t mandatory"
-// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
-function isPrintable(c) {
- return (0x00020 <= c && c <= 0x00007E)
- || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
- || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
- || (0x10000 <= c && c <= 0x10FFFF);
-}
-
-// [34] ns-char ::= nb-char - s-white
-// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
-// [26] b-char ::= b-line-feed | b-carriage-return
-// Including s-white (for some reason, examples doesn't match specs in this aspect)
-// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
-function isNsCharOrWhitespace(c) {
- return isPrintable(c)
- && c !== CHAR_BOM
- // - b-char
- && c !== CHAR_CARRIAGE_RETURN
- && c !== CHAR_LINE_FEED;
-}
-
-// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out
-// c = flow-in ⇒ ns-plain-safe-in
-// c = block-key ⇒ ns-plain-safe-out
-// c = flow-key ⇒ ns-plain-safe-in
-// [128] ns-plain-safe-out ::= ns-char
-// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator
-// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” )
-// | ( /* An ns-char preceding */ “#” )
-// | ( “:” /* Followed by an ns-plain-safe(c) */ )
-function isPlainSafe(c, prev, inblock) {
- var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
- var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
- return (
- // ns-plain-safe
- inblock ? // c = flow-in
- cIsNsCharOrWhitespace
- : cIsNsCharOrWhitespace
- // - c-flow-indicator
- && c !== CHAR_COMMA
- && c !== CHAR_LEFT_SQUARE_BRACKET
- && c !== CHAR_RIGHT_SQUARE_BRACKET
- && c !== CHAR_LEFT_CURLY_BRACKET
- && c !== CHAR_RIGHT_CURLY_BRACKET
- )
- // ns-plain-char
- && c !== CHAR_SHARP // false on '#'
- && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
- || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
- || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
-}
-
-// Simplified test for values allowed as the first character in plain style.
-function isPlainSafeFirst(c) {
- // Uses a subset of ns-char - c-indicator
- // where ns-char = nb-char - s-white.
- // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
- return isPrintable(c) && c !== CHAR_BOM
- && !isWhitespace(c) // - s-white
- // - (c-indicator ::=
- // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
- && c !== CHAR_MINUS
- && c !== CHAR_QUESTION
- && c !== CHAR_COLON
- && c !== CHAR_COMMA
- && c !== CHAR_LEFT_SQUARE_BRACKET
- && c !== CHAR_RIGHT_SQUARE_BRACKET
- && c !== CHAR_LEFT_CURLY_BRACKET
- && c !== CHAR_RIGHT_CURLY_BRACKET
- // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
- && c !== CHAR_SHARP
- && c !== CHAR_AMPERSAND
- && c !== CHAR_ASTERISK
- && c !== CHAR_EXCLAMATION
- && c !== CHAR_VERTICAL_LINE
- && c !== CHAR_EQUALS
- && c !== CHAR_GREATER_THAN
- && c !== CHAR_SINGLE_QUOTE
- && c !== CHAR_DOUBLE_QUOTE
- // | “%” | “@” | “`”)
- && c !== CHAR_PERCENT
- && c !== CHAR_COMMERCIAL_AT
- && c !== CHAR_GRAVE_ACCENT;
-}
-
-// Simplified test for values allowed as the last character in plain style.
-function isPlainSafeLast(c) {
- // just not whitespace or colon, it will be checked to be plain character later
- return !isWhitespace(c) && c !== CHAR_COLON;
-}
-
-// Same as 'string'.codePointAt(pos), but works in older browsers.
-function codePointAt(string, pos) {
- var first = string.charCodeAt(pos), second;
- if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
- second = string.charCodeAt(pos + 1);
- if (second >= 0xDC00 && second <= 0xDFFF) {
- // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
- return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
- }
- }
- return first;
-}
-
-// Determines whether block indentation indicator is required.
-function needIndentIndicator(string) {
- var leadingSpaceRe = /^\n* /;
- return leadingSpaceRe.test(string);
-}
-
-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.
-// Pre-conditions: str.length > 0.
-// Post-conditions:
-// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
-// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
-// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
-function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
- testAmbiguousType, quotingType, forceQuotes, inblock) {
-
- var i;
- var char = 0;
- var prevChar = null;
- var hasLineBreak = false;
- var hasFoldableLine = false; // only checked if shouldTrackWidth
- var shouldTrackWidth = lineWidth !== -1;
- var previousLineBreak = -1; // count the first line correctly
- var plain = isPlainSafeFirst(codePointAt(string, 0))
- && isPlainSafeLast(codePointAt(string, string.length - 1));
-
- if (singleLineOnly || forceQuotes) {
- // Case: no block styles.
- // Check for disallowed characters to rule out plain and single.
- for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i);
- if (!isPrintable(char)) {
- return STYLE_DOUBLE;
- }
- plain = plain && isPlainSafe(char, prevChar, inblock);
- prevChar = char;
- }
- } else {
- // Case: block styles permitted.
- for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i);
- if (char === CHAR_LINE_FEED) {
- hasLineBreak = true;
- // Check if any line can be folded.
- if (shouldTrackWidth) {
- hasFoldableLine = hasFoldableLine ||
- // Foldable line = too long, and not more-indented.
- (i - previousLineBreak - 1 > lineWidth &&
- string[previousLineBreak + 1] !== ' ');
- previousLineBreak = i;
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
}
- } else if (!isPrintable(char)) {
- return STYLE_DOUBLE;
- }
- plain = plain && isPlainSafe(char, prevChar, inblock);
- prevChar = char;
- }
- // in case the end is missing a \n
- hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
- (i - previousLineBreak - 1 > lineWidth &&
- string[previousLineBreak + 1] !== ' '));
- }
- // Although every style can represent \n without escaping, prefer block styles
- // for multiline, since they're more readable and they don't add empty lines.
- // Also prefer folding a super-long line.
- if (!hasLineBreak && !hasFoldableLine) {
- // Strings interpretable as another type have to be quoted;
- // e.g. the string 'true' vs. the boolean true.
- if (plain && !forceQuotes && !testAmbiguousType(string)) {
- return STYLE_PLAIN;
- }
- return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
- }
- // Edge case: block indentation indicator can only have one digit.
- if (indentPerLevel > 9 && needIndentIndicator(string)) {
- return STYLE_DOUBLE;
- }
- // At this point we know block styles are valid.
- // Prefer literal style unless we want to fold.
- if (!forceQuotes) {
- return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
- }
- return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-}
-// Note: line breaking/folding is implemented for only the folded style.
-// NB. We drop the last trailing newline (if any) of a returned block scalar
-// since the dumper adds its own newline. This always works:
-// • No ending newline => unaffected; already using strip "-" chomping.
-// • Ending newline => removed then restored.
-// Importantly, this keeps the "+" chomp indicator from gaining an extra line.
-function writeScalar(state, string, level, iskey, inblock) {
- state.dump = (function () {
- if (string.length === 0) {
- return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
- }
- if (!state.noCompatMode) {
- if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
- return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
- }
- }
-
- var indent = state.indent * Math.max(1, level); // no 0-indent scalars
- // As indentation gets deeper, let the width decrease monotonically
- // to the lower bound min(state.lineWidth, 40).
- // Note that this implies
- // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
- // state.lineWidth > 40 + state.indent: width decreases until the lower bound.
- // This behaves better than a constant minimum width which disallows narrower options,
- // or an indent threshold which causes the width to suddenly increase.
- var lineWidth = state.lineWidth === -1
- ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-
- // Without knowing if keys are implicit/explicit, assume implicit for safety.
- var singleLineOnly = iskey
- // No block styles in flow mode.
- || (state.flowLevel > -1 && level >= state.flowLevel);
- function testAmbiguity(string) {
- return testImplicitResolving(state, string);
- }
-
- switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
- testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-
- case STYLE_PLAIN:
- return string;
- case STYLE_SINGLE:
- return "'" + string.replace(/'/g, "''") + "'";
- case STYLE_LITERAL:
- return '|' + blockHeader(string, state.indent)
- + dropEndingNewline(indentString(string, indent));
- case STYLE_FOLDED:
- return '>' + blockHeader(string, state.indent)
- + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
- case STYLE_DOUBLE:
- return '"' + escapeString(string) + '"';
- default:
- throw new exception('impossible error: invalid scalar style');
+ next();
+ })(tree, file, options);
}
- }());
-}
-
-// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
-function blockHeader(string, indentPerLevel) {
- var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
-
- // note the special case: the string '\n' counts as a "trailing" empty line.
- var clip = string[string.length - 1] === '\n';
- var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
- var chomp = keep ? '+' : (clip ? '' : '-');
-
- return indentIndicator + chomp + '\n';
-}
-
-// (See the note for writeScalar.)
-function dropEndingNewline(string) {
- return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
-}
-
-// Note: a long line without a suitable break point will exceed the width limit.
-// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
-function foldString(string, width) {
- // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
- // unless they're before or after a more-indented line, or at the very
- // beginning or end, in which case $k$ maps to $k$.
- // Therefore, parse each chunk as newline(s) followed by a content line.
- var lineRe = /(\n+)([^\n]*)/g;
-
- // first line (possibly an empty line)
- var result = (function () {
- var nextLF = string.indexOf('\n');
- nextLF = nextLF !== -1 ? nextLF : string.length;
- lineRe.lastIndex = nextLF;
- return foldLine(string.slice(0, nextLF), width);
- }());
- // If we haven't reached the first content line yet, don't add an extra \n.
- var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
- var moreIndented;
-
- // rest of the lines
- var match;
- while ((match = lineRe.exec(string))) {
- var prefix = match[1], line = match[2];
- moreIndented = (line[0] === ' ');
- result += prefix
- + (!prevMoreIndented && !moreIndented && line !== ''
- ? '\n' : '')
- + foldLine(line, width);
- prevMoreIndented = moreIndented;
}
-
- return result;
}
-// Greedy line breaking.
-// Picks the longest line under the limit each time,
-// otherwise settles for the shortest line over the limit.
-// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
-function foldLine(line, width) {
- if (line === '' || line[0] === ' ') return line;
-
- // Since a more-indented line adds a \n, breaks can't be followed by a space.
- var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
- var match;
- // start is an inclusive index. end, curr, and next are exclusive.
- var start = 0, end, curr = 0, next = 0;
- var result = '';
-
- // Invariants: 0 <= start <= length-1.
- // 0 <= curr <= next <= max(0, length-2). curr - start <= width.
- // Inside the loop:
- // A match implies length >= 2, so curr and next are <= length-2.
- while ((match = breakRe.exec(line))) {
- next = match.index;
- // maintain invariant: curr - start <= width
- if (next - start > width) {
- end = (curr > start) ? curr : next; // derive end <= length-2
- result += '\n' + line.slice(start, end);
- // skip the space that was output as \n
- start = end + 1; // derive start <= length-1
- }
- curr = next;
- }
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$6(name, value) {
+ /** @type {unknown[]} */
+ let result;
- // By the invariants, start <= length-1, so there is something left over.
- // It is either the whole string or a part starting from non-whitespace.
- result += '\n';
- // Insert a break if the remainder is too long and there is a break available.
- if (line.length - start > width && curr > start) {
- result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$6.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
} else {
- result += line.slice(start);
- }
-
- return result.slice(1); // drop extra \n joiner
-}
-
-// Escapes a double-quoted string.
-function escapeString(string) {
- var result = '';
- var char = 0;
- var escapeSeq;
-
- for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i);
- escapeSeq = ESCAPE_SEQUENCES[char];
-
- if (!escapeSeq && isPrintable(char)) {
- result += string[i];
- if (char >= 0x10000) result += string[i + 1];
- } else {
- result += escapeSeq || encodeHex(char);
- }
- }
-
- return result;
-}
-
-function writeFlowSequence(state, level, object) {
- var _result = '',
- _tag = state.tag,
- index,
- length,
- value;
-
- for (index = 0, length = object.length; index < length; index += 1) {
- value = object[index];
-
- if (state.replacer) {
- value = state.replacer.call(object, String(index), value);
- }
-
- // Write only valid elements, put null instead of invalid elements.
- if (writeNode(state, level, value, false, false) ||
- (typeof value === 'undefined' &&
- writeNode(state, level, null, false, false))) {
-
- if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
- _result += state.dump;
- }
- }
-
- state.tag = _tag;
- state.dump = '[' + _result + ']';
-}
-
-function writeBlockSequence(state, level, object, compact) {
- var _result = '',
- _tag = state.tag,
- index,
- length,
- value;
-
- for (index = 0, length = object.length; index < length; index += 1) {
- value = object[index];
-
- if (state.replacer) {
- value = state.replacer.call(object, String(index), value);
- }
-
- // Write only valid elements, put null instead of invalid elements.
- if (writeNode(state, level + 1, value, true, true, false, true) ||
- (typeof value === 'undefined' &&
- writeNode(state, level + 1, null, true, true, false, true))) {
-
- if (!compact || _result !== '') {
- _result += generateNextLine(state, level);
- }
-
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- _result += '-';
- } else {
- _result += '- ';
- }
-
- _result += state.dump;
- }
- }
-
- state.tag = _tag;
- state.dump = _result || '[]'; // Empty sequence if no valid values.
-}
-
-function writeFlowMapping(state, level, object) {
- var _result = '',
- _tag = state.tag,
- objectKeyList = Object.keys(object),
- index,
- length,
- objectKey,
- objectValue,
- pairBuffer;
-
- for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-
- pairBuffer = '';
- if (_result !== '') pairBuffer += ', ';
-
- if (state.condenseFlow) pairBuffer += '"';
-
- objectKey = objectKeyList[index];
- objectValue = object[objectKey];
-
- if (state.replacer) {
- objectValue = state.replacer.call(object, objectKey, objectValue);
- }
-
- if (!writeNode(state, level, objectKey, false, false)) {
- continue; // Skip this pair because of invalid key;
- }
-
- if (state.dump.length > 1024) pairBuffer += '? ';
-
- pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
-
- if (!writeNode(state, level, objectValue, false, false)) {
- continue; // Skip this pair because of invalid value.
- }
-
- pairBuffer += state.dump;
-
- // Both key and value are valid.
- _result += pairBuffer;
- }
-
- state.tag = _tag;
- state.dump = '{' + _result + '}';
-}
-
-function writeBlockMapping(state, level, object, compact) {
- var _result = '',
- _tag = state.tag,
- objectKeyList = Object.keys(object),
- index,
- length,
- objectKey,
- objectValue,
- explicitPair,
- pairBuffer;
-
- // Allow sorting keys so that the output file is deterministic
- if (state.sortKeys === true) {
- // Default sorting
- objectKeyList.sort();
- } else if (typeof state.sortKeys === 'function') {
- // Custom sort function
- objectKeyList.sort(state.sortKeys);
- } else if (state.sortKeys) {
- // Something is wrong
- throw new exception('sortKeys must be a boolean or a function');
+ result = [1, value];
}
- for (index = 0, length = objectKeyList.length; index < length; index += 1) {
- pairBuffer = '';
-
- if (!compact || _result !== '') {
- pairBuffer += generateNextLine(state, level);
- }
-
- objectKey = objectKeyList[index];
- objectValue = object[objectKey];
-
- if (state.replacer) {
- objectValue = state.replacer.call(object, objectKey, objectValue);
- }
-
- if (!writeNode(state, level + 1, objectKey, true, true, true)) {
- continue; // Skip this pair because of invalid key.
- }
-
- explicitPair = (state.tag !== null && state.tag !== '?') ||
- (state.dump && state.dump.length > 1024);
-
- if (explicitPair) {
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- pairBuffer += '?';
- } else {
- pairBuffer += '? ';
- }
- }
-
- pairBuffer += state.dump;
-
- if (explicitPair) {
- pairBuffer += generateNextLine(state, level);
- }
-
- if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
- continue; // Skip this pair because of invalid value.
- }
+ let level = result[0];
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- pairBuffer += ':';
+ 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 {
- pairBuffer += ': ';
- }
-
- pairBuffer += state.dump;
-
- // Both key and value are valid.
- _result += pairBuffer;
- }
-
- state.tag = _tag;
- state.dump = _result || '{}'; // Empty mapping if no valid pairs.
-}
-
-function detectType(state, object, explicit) {
- var _result, typeList, index, length, type, style;
-
- typeList = explicit ? state.explicitTypes : state.implicitTypes;
-
- for (index = 0, length = typeList.length; index < length; index += 1) {
- type = typeList[index];
-
- if ((type.instanceOf || type.predicate) &&
- (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
- (!type.predicate || type.predicate(object))) {
-
- if (explicit) {
- if (type.multi && type.representName) {
- state.tag = type.representName(object);
- } else {
- state.tag = type.tag;
- }
- } else {
- state.tag = '?';
- }
-
- if (type.represent) {
- style = state.styleMap[type.tag] || type.defaultStyle;
-
- if (_toString.call(type.represent) === '[object Function]') {
- _result = type.represent(object, 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');
- }
-
- state.dump = _result;
- }
-
- return true;
+ level = 1;
+ result = [level, result];
}
}
- return false;
-}
-
-// Serializes `object` and writes it to global `result`.
-// Returns true on success, or false on invalid object.
-//
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
- state.tag = null;
- state.dump = object;
-
- if (!detectType(state, object, false)) {
- detectType(state, object, true);
- }
-
- var type = _toString.call(state.dump);
- var inblock = block;
- var tagStr;
-
- if (block) {
- block = (state.flowLevel < 0 || state.flowLevel > level);
- }
-
- var objectOrArray = type === '[object Object]' || type === '[object Array]',
- duplicateIndex,
- duplicate;
-
- if (objectOrArray) {
- duplicateIndex = state.duplicates.indexOf(object);
- duplicate = duplicateIndex !== -1;
- }
-
- if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
- compact = false;
- }
-
- if (duplicate && state.usedDuplicates[duplicateIndex]) {
- state.dump = '*ref_' + duplicateIndex;
- } else {
- if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
- state.usedDuplicates[duplicateIndex] = true;
- }
- if (type === '[object Object]') {
- if (block && (Object.keys(state.dump).length !== 0)) {
- writeBlockMapping(state, level, state.dump, compact);
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + state.dump;
- }
- } else {
- writeFlowMapping(state, level, state.dump);
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
- }
- }
- } else if (type === '[object Array]') {
- if (block && (state.dump.length !== 0)) {
- if (state.noArrayIndent && !isblockseq && level > 0) {
- writeBlockSequence(state, level - 1, state.dump, compact);
- } else {
- writeBlockSequence(state, level, state.dump, compact);
- }
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + state.dump;
- }
- } else {
- writeFlowSequence(state, level, state.dump);
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
- }
- }
- } else if (type === '[object String]') {
- if (state.tag !== '?') {
- writeScalar(state, state.dump, level, iskey, inblock);
- }
- } else if (type === '[object Undefined]') {
- return false;
- } else {
- if (state.skipInvalid) return false;
- throw new exception('unacceptable kind of an object to dump ' + type);
- }
-
- if (state.tag !== null && state.tag !== '?') {
- // Need to encode all characters except those allowed by the spec:
- //
- // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
- // [36] ns-hex-digit ::= ns-dec-digit
- // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
- // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
- // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
- // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
- // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
- // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
- //
- // Also need to encode '!' because it has special meaning (end of tag prefix).
- //
- tagStr = encodeURI(
- state.tag[0] === '!' ? state.tag.slice(1) : state.tag
- ).replace(/!/g, '%21');
-
- if (state.tag[0] === '!') {
- tagStr = '!' + tagStr;
- } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
- tagStr = '!!' + tagStr.slice(18);
- } else {
- tagStr = '!<' + tagStr + '>';
- }
-
- state.dump = tagStr + ' ' + state.dump;
- }
+ if (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
}
- return true;
-}
-
-function getDuplicateReferences(object, state) {
- var objects = [],
- duplicatesIndexes = [],
- index,
- length;
-
- inspectNode(object, objects, duplicatesIndexes);
+ result[0] = level;
- for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
- state.duplicates.push(objects[duplicatesIndexes[index]]);
- }
- state.usedDuplicates = new Array(length);
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
}
-function inspectNode(object, objects, duplicatesIndexes) {
- var objectKeyList,
- index,
- length;
-
- if (object !== null && typeof object === 'object') {
- index = objects.indexOf(object);
- if (index !== -1) {
- if (duplicatesIndexes.indexOf(index) === -1) {
- duplicatesIndexes.push(index);
- }
- } else {
- objects.push(object);
-
- if (Array.isArray(object)) {
- for (index = 0, length = object.length; index < length; index += 1) {
- inspectNode(object[index], objects, duplicatesIndexes);
- }
- } else {
- objectKeyList = Object.keys(object);
-
- for (index = 0, length = objectKeyList.length; index < length; index += 1) {
- inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
- }
- }
- }
+function* getLinksRecursively(node) {
+ if (node.url) {
+ yield node;
}
-}
-
-function dump$1(input, options) {
- options = options || {};
-
- var state = new State(options);
-
- if (!state.noRefs) getDuplicateReferences(input, state);
-
- var value = input;
-
- if (state.replacer) {
- value = state.replacer.call({ '': value }, '', value);
+ for (const child of node.children || []) {
+ yield* getLinksRecursively(child);
}
-
- if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
-
- return '';
}
-var dump_1 = dump$1;
-
-var dumper = {
- dump: dump_1
-};
-
-function renamed(from, to) {
- return function () {
- throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
- 'Use yaml.' + to + ' instead, which is now safe by default.');
- };
-}
-
-
-var Type = type;
-var Schema = schema;
-var FAILSAFE_SCHEMA = failsafe;
-var JSON_SCHEMA = json;
-var CORE_SCHEMA = core;
-var DEFAULT_SCHEMA = _default;
-var load = loader.load;
-var loadAll = loader.loadAll;
-var dump = dumper.dump;
-var YAMLException = exception;
-
-// Re-export all types in case user wants to create custom schema
-var types = {
- binary: binary,
- float: float,
- map: map,
- null: _null,
- pairs: pairs,
- set: set,
- timestamp: timestamp,
- bool: bool,
- int: int,
- merge: merge,
- omap: omap,
- seq: seq,
- str: str
-};
-
-// Removed functions from JS-YAML 3.0.x
-var safeLoad = renamed('safeLoad', 'load');
-var safeLoadAll = renamed('safeLoadAll', 'loadAll');
-var safeDump = renamed('safeDump', 'dump');
-
-var jsYaml = {
- Type: Type,
- Schema: Schema,
- FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
- JSON_SCHEMA: JSON_SCHEMA,
- CORE_SCHEMA: CORE_SCHEMA,
- DEFAULT_SCHEMA: DEFAULT_SCHEMA,
- load: load,
- loadAll: loadAll,
- dump: dump,
- YAMLException: YAMLException,
- types: types,
- safeLoad: safeLoad,
- safeLoadAll: safeLoadAll,
- safeDump: safeDump
-};
-
-// Note: this is the semver.org version of the spec that it implements
-// Not necessarily the package version of this code.
-const SEMVER_SPEC_VERSION = '2.0.0';
-
-const MAX_LENGTH$2 = 256;
-const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
- /* istanbul ignore next */ 9007199254740991;
-
-// Max safe segment length for coercion.
-const MAX_SAFE_COMPONENT_LENGTH = 16;
-
-var constants = {
- SEMVER_SPEC_VERSION,
- MAX_LENGTH: MAX_LENGTH$2,
- MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
- MAX_SAFE_COMPONENT_LENGTH
-};
-
-var re$2 = {exports: {}};
-
-const debug$1 = (
- typeof process === 'object' &&
- process.env &&
- process.env.NODE_DEBUG &&
- /\bsemver\b/i.test(process.env.NODE_DEBUG)
-) ? (...args) => console.error('SEMVER', ...args)
- : () => {};
-
-var debug_1 = debug$1;
-
-(function (module, exports) {
-const { MAX_SAFE_COMPONENT_LENGTH } = constants;
-const debug = debug_1;
-exports = module.exports = {};
-
-// The actual regexps go on exports.re
-const re = exports.re = [];
-const src = exports.src = [];
-const t = exports.t = {};
-let R = 0;
-
-const createToken = (name, value, isGlobal) => {
- const index = R++;
- debug(index, value);
- t[name] = index;
- src[index] = value;
- re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
-};
-
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
-
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
-
-createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
-
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-
-createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
-
-// ## Main Version
-// Three dot-separated numeric identifiers.
-
-createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
- `(${src[t.NUMERICIDENTIFIER]})\\.` +
- `(${src[t.NUMERICIDENTIFIER]})`);
-
-createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
- `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
- `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
-
-createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
-}|${src[t.NONNUMERICIDENTIFIER]})`);
-
-createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
-}|${src[t.NONNUMERICIDENTIFIER]})`);
-
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
-
-createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
-}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-
-createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
-}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
-
-createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
-
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
-
-createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
-}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
-
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups. The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
-
-createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
-}${src[t.PRERELEASE]}?${
- src[t.BUILD]}?`);
-
-createToken('FULL', `^${src[t.FULLPLAIN]}$`);
-
-// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
-// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
-// common in the npm registry.
-createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
-}${src[t.PRERELEASELOOSE]}?${
- src[t.BUILD]}?`);
-
-createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
-
-createToken('GTLT', '((?:<|>)?=?)');
-
-// Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
-// Only the first item is strictly required.
-createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-
-createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
- `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
- `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
- `(?:${src[t.PRERELEASE]})?${
- src[t.BUILD]}?` +
- `)?)?`);
-
-createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
- `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
- `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
- `(?:${src[t.PRERELEASELOOSE]})?${
- src[t.BUILD]}?` +
- `)?)?`);
-
-createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-
-// Coercion.
-// Extract anything that could conceivably be a part of a valid semver
-createToken('COERCE', `${'(^|[^\\d])' +
- '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
- `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
- `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
- `(?:$|[^\\d])`);
-createToken('COERCERTL', src[t.COERCE], true);
-
-// Tilde ranges.
-// Meaning is "reasonably at or greater than"
-createToken('LONETILDE', '(?:~>?)');
-
-createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-exports.tildeTrimReplace = '$1~';
-
-createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-// Caret ranges.
-// Meaning is "at least and backwards compatible with"
-createToken('LONECARET', '(?:\\^)');
-
-createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-exports.caretTrimReplace = '$1^';
-
-createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-
-// An expression to strip any whitespace between the gtlt and the thing
-// it modifies, so that `> 1.2.3` ==> `>1.2.3`
-createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
-}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-exports.comparatorTrimReplace = '$1$2$3';
-
-// Something like `1.2.3 - 1.2.4`
-// Note that these all use the loose form, because they'll be
-// checked against either the strict or loose comparator form
-// later.
-createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
- `\\s+-\\s+` +
- `(${src[t.XRANGEPLAIN]})` +
- `\\s*$`);
-
-createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
- `\\s+-\\s+` +
- `(${src[t.XRANGEPLAINLOOSE]})` +
- `\\s*$`);
-
-// Star ranges basically just allow anything at all.
-createToken('STAR', '(<|>)?=?\\s*\\*');
-// >=0.0.0 is like a star
-createToken('GTE0', '^\\s*>=\\s*0\.0\.0\\s*$');
-createToken('GTE0PRE', '^\\s*>=\\s*0\.0\.0-0\\s*$');
-}(re$2, re$2.exports));
-
-// parse out just the options we care about so we always get a consistent
-// obj with keys in a consistent order.
-const opts = ['includePrerelease', 'loose', 'rtl'];
-const parseOptions$2 = options =>
- !options ? {}
- : typeof options !== 'object' ? { loose: true }
- : opts.filter(k => options[k]).reduce((options, k) => {
- options[k] = true;
- return options
- }, {});
-var parseOptions_1 = parseOptions$2;
-
-const numeric = /^[0-9]+$/;
-const compareIdentifiers$1 = (a, b) => {
- const anum = numeric.test(a);
- const bnum = numeric.test(b);
-
- if (anum && bnum) {
- a = +a;
- b = +b;
- }
-
- return a === b ? 0
- : (anum && !bnum) ? -1
- : (bnum && !anum) ? 1
- : a < b ? -1
- : 1
-};
-
-const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
-
-var identifiers = {
- compareIdentifiers: compareIdentifiers$1,
- rcompareIdentifiers
-};
-
-const debug = debug_1;
-const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants;
-const { re: re$1, t: t$1 } = re$2.exports;
-
-const parseOptions$1 = parseOptions_1;
-const { compareIdentifiers } = identifiers;
-class SemVer$2 {
- constructor (version, options) {
- options = parseOptions$1(options);
-
- if (version instanceof SemVer$2) {
- if (version.loose === !!options.loose &&
- version.includePrerelease === !!options.includePrerelease) {
- return version
- } else {
- version = version.version;
- }
- } else if (typeof version !== 'string') {
- throw new TypeError(`Invalid Version: ${version}`)
- }
-
- if (version.length > MAX_LENGTH$1) {
- throw new TypeError(
- `version is longer than ${MAX_LENGTH$1} characters`
- )
- }
-
- debug('SemVer', version, options);
- this.options = options;
- this.loose = !!options.loose;
- // this isn't actually relevant for versions, but keep it so that we
- // don't run into trouble passing this.options around.
- this.includePrerelease = !!options.includePrerelease;
-
- const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]);
-
- if (!m) {
- throw new TypeError(`Invalid Version: ${version}`)
- }
-
- this.raw = version;
-
- // these are actually numbers
- this.major = +m[1];
- this.minor = +m[2];
- this.patch = +m[3];
-
- if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
- throw new TypeError('Invalid major version')
- }
-
- if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
- throw new TypeError('Invalid minor version')
- }
-
- if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
- throw new TypeError('Invalid patch version')
- }
-
- // numberify any prerelease numeric ids
- if (!m[4]) {
- this.prerelease = [];
- } else {
- this.prerelease = m[4].split('.').map((id) => {
- if (/^[0-9]+$/.test(id)) {
- const num = +id;
- if (num >= 0 && num < MAX_SAFE_INTEGER) {
- return num
- }
- }
- return id
- });
- }
-
- this.build = m[5] ? m[5].split('.') : [];
- this.format();
- }
-
- format () {
- this.version = `${this.major}.${this.minor}.${this.patch}`;
- if (this.prerelease.length) {
- this.version += `-${this.prerelease.join('.')}`;
- }
- return this.version
- }
-
- toString () {
- return this.version
- }
-
- compare (other) {
- debug('SemVer.compare', this.version, this.options, other);
- if (!(other instanceof SemVer$2)) {
- if (typeof other === 'string' && other === this.version) {
- return 0
- }
- other = new SemVer$2(other, this.options);
- }
-
- if (other.version === this.version) {
- return 0
- }
-
- return this.compareMain(other) || this.comparePre(other)
- }
-
- compareMain (other) {
- if (!(other instanceof SemVer$2)) {
- other = new SemVer$2(other, this.options);
- }
-
- return (
- compareIdentifiers(this.major, other.major) ||
- compareIdentifiers(this.minor, other.minor) ||
- compareIdentifiers(this.patch, other.patch)
- )
- }
-
- comparePre (other) {
- if (!(other instanceof SemVer$2)) {
- other = new SemVer$2(other, this.options);
- }
-
- // NOT having a prerelease is > having one
- if (this.prerelease.length && !other.prerelease.length) {
- return -1
- } else if (!this.prerelease.length && other.prerelease.length) {
- return 1
- } else if (!this.prerelease.length && !other.prerelease.length) {
- return 0
- }
-
- let i = 0;
- do {
- const a = this.prerelease[i];
- const b = other.prerelease[i];
- debug('prerelease compare', i, a, b);
- if (a === undefined && b === undefined) {
- return 0
- } else if (b === undefined) {
- return 1
- } else if (a === undefined) {
- return -1
- } else if (a === b) {
- continue
- } else {
- return compareIdentifiers(a, b)
+function validateLinks(tree, vfile) {
+ const currentFileURL = pathToFileURL(path$b.join(vfile.cwd, vfile.path));
+ let previousDefinitionLabel;
+ for (const node of getLinksRecursively(tree)) {
+ if (node.url[0] !== "#") {
+ const targetURL = new URL(node.url, currentFileURL);
+ if (targetURL.protocol === "file:" && !require$$0$3.existsSync(targetURL)) {
+ vfile.message("Broken link", node);
+ } else if (targetURL.pathname === currentFileURL.pathname) {
+ const expected = node.url.includes("#")
+ ? node.url.slice(node.url.indexOf("#"))
+ : "#";
+ vfile.message(
+ `Self-reference must start with hash (expected "${expected}", got "${node.url}")`,
+ node
+ );
}
- } while (++i)
- }
-
- compareBuild (other) {
- if (!(other instanceof SemVer$2)) {
- other = new SemVer$2(other, this.options);
}
-
- let i = 0;
- do {
- const a = this.build[i];
- const b = other.build[i];
- debug('prerelease compare', i, a, b);
- if (a === undefined && b === undefined) {
- return 0
- } else if (b === undefined) {
- return 1
- } else if (a === undefined) {
- return -1
- } else if (a === b) {
- continue
- } else {
- return compareIdentifiers(a, b)
+ if (node.type === "definition") {
+ if (previousDefinitionLabel && previousDefinitionLabel > node.label) {
+ vfile.message(
+ `Unordered reference ("${node.label}" should be before "${previousDefinitionLabel}")`,
+ node
+ );
}
- } while (++i)
- }
-
- // preminor will bump the version up to the next minor release, and immediately
- // down to pre-release. premajor and prepatch work the same way.
- inc (release, identifier) {
- switch (release) {
- case 'premajor':
- this.prerelease.length = 0;
- this.patch = 0;
- this.minor = 0;
- this.major++;
- this.inc('pre', identifier);
- break
- case 'preminor':
- this.prerelease.length = 0;
- this.patch = 0;
- this.minor++;
- this.inc('pre', identifier);
- break
- case 'prepatch':
- // If this is already a prerelease, it will bump to the next version
- // drop any prereleases that might already exist, since they are not
- // relevant at this point.
- this.prerelease.length = 0;
- this.inc('patch', identifier);
- this.inc('pre', identifier);
- break
- // If the input is a non-prerelease version, this acts the same as
- // prepatch.
- case 'prerelease':
- if (this.prerelease.length === 0) {
- this.inc('patch', identifier);
- }
- this.inc('pre', identifier);
- break
-
- case 'major':
- // If this is a pre-major version, bump up to the same major version.
- // Otherwise increment major.
- // 1.0.0-5 bumps to 1.0.0
- // 1.1.0 bumps to 2.0.0
- if (
- this.minor !== 0 ||
- this.patch !== 0 ||
- this.prerelease.length === 0
- ) {
- this.major++;
- }
- this.minor = 0;
- this.patch = 0;
- this.prerelease = [];
- break
- case 'minor':
- // If this is a pre-minor version, bump up to the same minor version.
- // Otherwise increment minor.
- // 1.2.0-5 bumps to 1.2.0
- // 1.2.1 bumps to 1.3.0
- if (this.patch !== 0 || this.prerelease.length === 0) {
- this.minor++;
- }
- this.patch = 0;
- this.prerelease = [];
- break
- case 'patch':
- // If this is not a pre-release version, it will increment the patch.
- // If it is a pre-release it will bump up to the same patch version.
- // 1.2.0-5 patches to 1.2.0
- // 1.2.0 patches to 1.2.1
- if (this.prerelease.length === 0) {
- this.patch++;
- }
- this.prerelease = [];
- break
- // This probably shouldn't be used publicly.
- // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
- case 'pre':
- if (this.prerelease.length === 0) {
- this.prerelease = [0];
- } else {
- let i = this.prerelease.length;
- while (--i >= 0) {
- if (typeof this.prerelease[i] === 'number') {
- this.prerelease[i]++;
- i = -2;
- }
- }
- if (i === -1) {
- // didn't increment anything
- this.prerelease.push(0);
- }
- }
- if (identifier) {
- // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
- // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
- if (this.prerelease[0] === identifier) {
- if (isNaN(this.prerelease[1])) {
- this.prerelease = [identifier, 0];
- }
- } else {
- this.prerelease = [identifier, 0];
- }
- }
- break
-
- default:
- throw new Error(`invalid increment argument: ${release}`)
+ previousDefinitionLabel = node.label;
}
- this.format();
- this.raw = this.version;
- return this
}
}
-var semver = SemVer$2;
-
-const {MAX_LENGTH} = constants;
-const { re, t } = re$2.exports;
-const SemVer$1 = semver;
-
-const parseOptions = parseOptions_1;
-const parse = (version, options) => {
- options = parseOptions(options);
-
- if (version instanceof SemVer$1) {
- return version
- }
-
- if (typeof version !== 'string') {
- return null
- }
-
- if (version.length > MAX_LENGTH) {
- return null
- }
-
- const r = options.loose ? re[t.LOOSE] : re[t.FULL];
- if (!r.test(version)) {
- return null
- }
-
- try {
- return new SemVer$1(version, options)
- } catch (er) {
- return null
- }
-};
-
-var parse_1 = parse;
-
-const SemVer = semver;
-const compare$1 = (a, b, loose) =>
- new SemVer(a, loose).compare(new SemVer(b, loose));
-
-var compare_1 = compare$1;
-
-const compare = compare_1;
-const lt = (a, b, loose) => compare(a, b, loose) < 0;
-var lt_1 = lt;
+const remarkLintNodejsLinks = lintRule$6(
+ "remark-lint:nodejs-links",
+ validateLinks
+);
const allowedKeys = [
"added",
@@ -60529,7 +56235,7 @@ function validateMeta(node, file, meta) {
}
function validateYAMLComments(tree, file) {
- visit$2(tree, "html", function visitor(node) {
+ visit(tree, "html", function visitor(node) {
if (node.value.startsWith("<!--YAML\n"))
file.message(
"Expected `<!-- YAML`, found `<!--YAML`. Please add a space",
@@ -60546,134 +56252,118 @@ function validateYAMLComments(tree, file) {
});
}
-const remarkLintNodejsYamlComments = lintRule(
+const remarkLintNodejsYamlComments = lintRule$6(
"remark-lint:nodejs-yaml-comments",
validateYAMLComments
);
-var escapeStringRegexp$2 = string => {
+function escapeStringRegexp(string) {
if (typeof string !== 'string') {
throw new TypeError('Expected a string');
}
// Escape characters with special meaning either inside or outside character sets.
- // Use a simple backslash escape when it’s always valid, and a \unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+ // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
return string
.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
.replace(/-/g, '\\x2d');
-};
-
-var start$2 = factory$2('start');
-var end = factory$2('end');
-
-var unistUtilPosition = position$1;
-
-position$1.start = start$2;
-position$1.end = end;
-
-function position$1(node) {
- return {start: start$2(node), end: end(node)}
}
-function factory$2(type) {
- point.displayName = type;
-
- return point
-
- 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 wrapped = wrapped_1;
-
-var unifiedLintRule = factory$1;
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
-function factory$1(id, rule) {
- var parts = id.split(':');
- var source = parts[0];
- var ruleId = parts[1];
- var fn = wrapped(rule);
+const primitives$5 = new Set(['string', 'number', 'boolean']);
- /* istanbul ignore if - possibly useful if externalised later. */
- if (!ruleId) {
- ruleId = source;
- source = null;
- }
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$5(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
- attacher.displayName = id;
+ Object.defineProperty(plugin, 'name', {value: id});
- return attacher
+ return plugin
- function attacher(raw) {
- var config = coerce(ruleId, raw);
- var severity = config[0];
- var options = config[1];
- var fatal = severity === 2;
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$5(ruleId, raw);
- return severity ? transformer : undefined
+ if (!severity) return
- function transformer(tree, file, next) {
- var index = file.messages.length;
+ const fatal = severity === 2;
- fn(tree, file, options, done);
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
- function done(err) {
- var messages = file.messages;
- var message;
+ wrap(rule, (error) => {
+ const messages = file.messages;
// Add the error, if not already properly added.
- /* istanbul ignore if - only happens for incorrect plugins */
- if (err && messages.indexOf(err) === -1) {
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
try {
- file.fail(err);
- } catch (_) {}
+ file.fail(error);
+ } catch {}
}
- while (index < messages.length) {
- message = messages[index];
- message.ruleId = ruleId;
- message.source = source;
- message.fatal = fatal;
-
- index++;
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
}
next();
- }
+ })(tree, file, options);
}
}
}
-// Coerce a value to a severity--options tuple.
-function coerce(name, value) {
- var def = 1;
- var result;
- var level;
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$5(name, value) {
+ /** @type {unknown[]} */
+ let result;
- /* istanbul ignore if - Handled by unified in v6.0.0 */
if (typeof value === 'boolean') {
result = [value];
- } else if (value == null) {
- result = [def];
+ } else if (value === null || value === undefined) {
+ result = [1];
} else if (
- typeof value === 'object' &&
- (typeof value[0] === 'number' ||
- typeof value[0] === 'boolean' ||
- typeof value[0] === 'string')
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$5.has(typeof value[0])
) {
- result = value.concat();
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
} else {
result = [1, value];
}
- level = result[0];
+ let level = result[0];
if (typeof level === 'boolean') {
level = level ? 1 : 0;
@@ -60690,7 +56380,7 @@ function coerce(name, value) {
}
}
- if (level < 0 || level > 2) {
+ if (typeof level !== 'number' || level < 0 || level > 2) {
throw new Error(
'Incorrect severity `' +
level +
@@ -60703,285 +56393,24 @@ function coerce(name, value) {
result[0] = level;
+ // @ts-expect-error: it’s now a valid tuple.
return result
}
-var convert_1 = convert$1;
-
-function convert$1(test) {
- if (test == null) {
- return ok
- }
-
- if (typeof test === 'string') {
- return typeFactory(test)
- }
-
- if (typeof test === 'object') {
- return 'length' in test ? anyFactory(test) : allFactory(test)
- }
-
- if (typeof test === 'function') {
- return test
- }
-
- throw new Error('Expected function, string, or object as test')
-}
-
-// Utility assert each property in `test` is represented in `node`, and each
-// values are strictly equal.
-function allFactory(test) {
- return all
-
- function all(node) {
- var key;
-
- for (key in test) {
- if (node[key] !== test[key]) return false
- }
-
- return true
- }
-}
-
-function anyFactory(tests) {
- var checks = [];
- var index = -1;
-
- while (++index < tests.length) {
- checks[index] = convert$1(tests[index]);
- }
-
- return any
-
- function any() {
- var index = -1;
-
- while (++index < checks.length) {
- if (checks[index].apply(this, arguments)) {
- return true
- }
- }
-
- return false
- }
-}
-
-// Utility to convert a string into a function which checks a given node’s type
-// for said string.
-function typeFactory(test) {
- return type
-
- function type(node) {
- return Boolean(node && node.type === test)
- }
-}
-
-// Utility to return true.
-function ok() {
- return true
-}
-
-var color_1 = color$1;
-function color$1(d) {
- return '\u001B[33m' + d + '\u001B[39m'
-}
-
-var unistUtilVisitParents = visitParents$1;
-
-var convert = convert_1;
-var color = color_1;
-
-var CONTINUE$1 = true;
-var SKIP$1 = 'skip';
-var EXIT$1 = false;
-
-visitParents$1.CONTINUE = CONTINUE$1;
-visitParents$1.SKIP = SKIP$1;
-visitParents$1.EXIT = EXIT$1;
-
-function visitParents$1(tree, test, visitor, reverse) {
- var step;
- var is;
-
- if (typeof test === 'function' && typeof visitor !== 'function') {
- reverse = visitor;
- visitor = test;
- test = null;
- }
-
- is = convert(test);
- step = reverse ? -1 : 1;
-
- factory(tree, null, [])();
-
- function factory(node, index, parents) {
- var value = typeof node === 'object' && node !== null ? node : {};
- var name;
-
- if (typeof value.type === 'string') {
- name =
- typeof value.tagName === 'string'
- ? value.tagName
- : typeof value.name === 'string'
- ? value.name
- : undefined;
-
- visit.displayName =
- 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')';
- }
-
- return visit
-
- function visit() {
- var grandparents = parents.concat(node);
- var result = [];
- var subresult;
- var offset;
-
- if (!test || is(node, index, parents[parents.length - 1] || null)) {
- result = toResult(visitor(node, parents));
-
- if (result[0] === EXIT$1) {
- return result
- }
- }
-
- if (node.children && result[0] !== SKIP$1) {
- offset = (reverse ? node.children.length : -1) + step;
-
- while (offset > -1 && offset < node.children.length) {
- subresult = factory(node.children[offset], offset, grandparents)();
-
- if (subresult[0] === EXIT$1) {
- return subresult
- }
-
- offset =
- typeof subresult[1] === 'number' ? subresult[1] : offset + step;
- }
- }
-
- return result
- }
- }
-}
-
-function toResult(value) {
- if (value !== null && typeof value === 'object' && 'length' in value) {
- return value
- }
-
- if (typeof value === 'number') {
- return [CONTINUE$1, value]
- }
-
- return [value]
-}
-
-var unistUtilVisit = visit$1;
-
-var visitParents = unistUtilVisitParents;
-
-var CONTINUE = visitParents.CONTINUE;
-var SKIP = visitParents.SKIP;
-var EXIT = visitParents.EXIT;
-
-visit$1.CONTINUE = CONTINUE;
-visit$1.SKIP = SKIP;
-visit$1.EXIT = EXIT;
-
-function visit$1(tree, test, visitor, reverse) {
- if (typeof test === 'function' && typeof visitor !== 'function') {
- reverse = visitor;
- visitor = test;
- test = null;
- }
-
- visitParents(tree, test, overload, reverse);
-
- function overload(node, parents) {
- var parent = parents[parents.length - 1];
- var index = parent ? parent.children.indexOf(node) : null;
- return visitor(node, index, parent)
- }
-}
-
-var vfileLocation$1 = factory;
-
-function factory(file) {
- var value = String(file);
- var indices = [];
- var search = /\r?\n|\r/g;
-
- while (search.exec(value)) {
- indices.push(search.lastIndex);
- }
-
- indices.push(value.length + 1);
-
- return {
- toPoint: offsetToPoint,
- toPosition: offsetToPoint,
- toOffset: pointToOffset
- }
-
- // Get the line and column-based `point` for `offset` in the bound indices.
- function offsetToPoint(offset) {
- var index = -1;
-
- if (offset > -1 && offset < indices[indices.length - 1]) {
- while (++index < indices.length) {
- if (indices[index] > offset) {
- return {
- line: index + 1,
- column: offset - (indices[index - 1] || 0) + 1,
- offset: offset
- }
- }
- }
- }
-
- return {}
- }
-
- // Get the `offset` for a line and column-based `point` in the bound
- // indices.
- function pointToOffset(point) {
- var line = point && point.line;
- var column = point && point.column;
- var offset;
-
- if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {
- offset = (indices[line - 2] || 0) + column - 1 || 0;
- }
-
- return offset > -1 && offset < indices[indices.length - 1] ? offset : -1
- }
-}
-
-const escapeStringRegexp$1 = escapeStringRegexp$2;
-const position = unistUtilPosition;
-const rule = unifiedLintRule;
-const visit = unistUtilVisit;
-const vfileLocation = vfileLocation$1;
-
-const start$1 = position.start;
-
-var remarkLintProhibitedStrings = rule('remark-lint:prohibited-strings', prohibitedStrings);
+const remarkLintProhibitedStrings = lintRule$5('remark-lint:prohibited-strings', prohibitedStrings);
function testProhibited (val, content) {
let regexpFlags = 'g';
let no = val.no;
if (!no) {
- no = escapeStringRegexp$1(val.yes);
+ no = escapeStringRegexp(val.yes);
regexpFlags += 'i';
}
let regexpString = '(?<!\\.|@[a-zA-Z0-9/-]*)';
- const ignoreNextTo = val.ignoreNextTo ? escapeStringRegexp$1(val.ignoreNextTo) : '';
+ const ignoreNextTo = val.ignoreNextTo ? escapeStringRegexp(val.ignoreNextTo) : '';
const replaceCaptureGroups = !!val.replaceCaptureGroups;
// If it starts with a letter, make sure it is a word break.
@@ -61022,13 +56451,13 @@ function testProhibited (val, content) {
}
function prohibitedStrings (ast, file, strings) {
- const location = vfileLocation(file);
+ const myLocation = location(file);
visit(ast, 'text', checkText);
function checkText (node) {
const content = node.value;
- const initial = start$1(node).offset;
+ const initial = pointStart(node).offset;
strings.forEach((val) => {
const results = testProhibited(val, content);
@@ -61036,8 +56465,8 @@ function prohibitedStrings (ast, file, strings) {
results.forEach(({ result, index, yes }) => {
const message = val.yes ? `Use "${yes}" instead of "${result}"` : `Do not use "${result}"`;
file.message(message, {
- start: location.toPoint(initial + index),
- end: location.toPoint(initial + index + [...result].length)
+ start: myLocation.toPoint(initial + index),
+ end: myLocation.toPoint(initial + index + [...result].length)
});
});
}
@@ -61046,6 +56475,134 @@ function prohibitedStrings (ast, file, strings) {
}
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$4 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$4(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$4(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$4(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$4.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -61107,7 +56664,7 @@ function prohibitedStrings (ast, file, strings) {
* 1:1: Incorrect preferred rule style: provide a correct markdown rule or `'consistent'`
*/
-const remarkLintRuleStyle = lintRule(
+const remarkLintRuleStyle = lintRule$4(
'remark-lint:rule-style',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -61119,7 +56676,7 @@ const remarkLintRuleStyle = lintRule(
);
}
- visit$2(tree, 'thematicBreak', (node) => {
+ visit(tree, 'thematicBreak', (node) => {
const initial = pointStart(node).offset;
const final = pointEnd(node).offset;
@@ -61139,6 +56696,134 @@ const remarkLintRuleStyle = lintRule(
var remarkLintRuleStyle$1 = remarkLintRuleStyle;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$3 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$3(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$3(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$3(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$3.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -61198,7 +56883,7 @@ var remarkLintRuleStyle$1 = remarkLintRuleStyle;
* 1:1: Incorrect strong marker `💩`: use either `'consistent'`, `'*'`, or `'_'`
*/
-const remarkLintStrongMarker = lintRule(
+const remarkLintStrongMarker = lintRule$3(
'remark-lint:strong-marker',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -61212,7 +56897,7 @@ const remarkLintStrongMarker = lintRule(
);
}
- visit$2(tree, 'strong', (node) => {
+ visit(tree, 'strong', (node) => {
const start = pointStart(node).offset;
if (typeof start === 'number') {
@@ -61231,6 +56916,134 @@ const remarkLintStrongMarker = lintRule(
var remarkLintStrongMarker$1 = remarkLintStrongMarker;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$2 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$2(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$2(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$2(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$2.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -61402,7 +57215,7 @@ var remarkLintStrongMarker$1 = remarkLintStrongMarker;
* | Echo | Foxtrot |
*/
-const remarkLintTableCellPadding = lintRule(
+const remarkLintTableCellPadding = lintRule$2(
'remark-lint:table-cell-padding',
/** @type {import('unified-lint-rule').Rule<Root, Options>} */
(tree, file, option = 'consistent') => {
@@ -61418,7 +57231,7 @@ const remarkLintTableCellPadding = lintRule(
);
}
- visit$2(tree, 'table', (node) => {
+ visit(tree, 'table', (node) => {
const rows = node.children;
// To do: fix types to always have `align` defined.
/* c8 ignore next */
@@ -61487,7 +57300,7 @@ const remarkLintTableCellPadding = lintRule(
checkSide('end', entries[index], style, sizes);
}
- return SKIP$2
+ return SKIP$1
});
/**
@@ -61568,6 +57381,134 @@ function size(node) {
}
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives$1 = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule$1(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce$1(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce$1(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives$1.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -61609,13 +57550,13 @@ function size(node) {
const reasonStart = 'Missing initial pipe in table fence';
const reasonEnd = 'Missing final pipe in table fence';
-const remarkLintTablePipes = lintRule(
+const remarkLintTablePipes = lintRule$1(
'remark-lint:table-pipes',
/** @type {import('unified-lint-rule').Rule<Root, void>} */
(tree, file) => {
const value = String(file);
- visit$2(tree, 'table', (node) => {
+ visit(tree, 'table', (node) => {
let index = -1;
while (++index < node.children.length) {
@@ -61644,6 +57585,134 @@ const remarkLintTablePipes = lintRule(
var remarkLintTablePipes$1 = remarkLintTablePipes;
/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {0|1|2} Severity
+ * @typedef {'warn'|'on'|'off'|'error'} Label
+ * @typedef {[Severity, ...unknown[]]} SeverityTuple
+ *
+ * @callback Rule
+ * @param {Node} tree
+ * @param {VFile} file
+ * @param {unknown} options
+ * @returns {void}
+ */
+
+const primitives = new Set(['string', 'number', 'boolean']);
+
+/**
+ * @param {string} id
+ * @param {Rule} rule
+ */
+function lintRule(id, rule) {
+ const parts = id.split(':');
+ // Possibly useful if externalised later.
+ /* c8 ignore next */
+ const source = parts[1] ? parts[0] : undefined;
+ const ruleId = parts[1];
+
+ Object.defineProperty(plugin, 'name', {value: id});
+
+ return plugin
+
+ /** @type {import('unified').Plugin<[unknown]|void[]>} */
+ function plugin(raw) {
+ const [severity, options] = coerce(ruleId, raw);
+
+ if (!severity) return
+
+ const fatal = severity === 2;
+
+ return (tree, file, next) => {
+ let index = file.messages.length - 1;
+
+ wrap(rule, (error) => {
+ const messages = file.messages;
+
+ // Add the error, if not already properly added.
+ // Only happens for incorrect plugins.
+ /* c8 ignore next 6 */
+ // @ts-expect-error: errors could be `messages`.
+ if (error && !messages.includes(error)) {
+ try {
+ file.fail(error);
+ } catch {}
+ }
+
+ while (++index < messages.length) {
+ Object.assign(messages[index], {ruleId, source, fatal});
+ }
+
+ next();
+ })(tree, file, options);
+ }
+ }
+}
+
+/**
+ * Coerce a value to a severity--options tuple.
+ *
+ * @param {string} name
+ * @param {unknown} value
+ * @returns {SeverityTuple}
+ */
+function coerce(name, value) {
+ /** @type {unknown[]} */
+ let result;
+
+ if (typeof value === 'boolean') {
+ result = [value];
+ } else if (value === null || value === undefined) {
+ result = [1];
+ } else if (
+ Array.isArray(value) &&
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ primitives.has(typeof value[0])
+ ) {
+ // `isArray(unknown)` is turned into `any[]`:
+ // type-coverage:ignore-next-line
+ result = [...value];
+ } else {
+ result = [1, value];
+ }
+
+ let 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 (typeof level !== 'number' || level < 0 || level > 2) {
+ throw new Error(
+ 'Incorrect severity `' +
+ level +
+ '` for `' +
+ name +
+ '`, ' +
+ 'expected 0, 1, or 2'
+ )
+ }
+
+ result[0] = level;
+
+ // @ts-expect-error: it’s now a valid tuple.
+ return result
+}
+
+/**
* @author Titus Wormer
* @copyright 2015 Titus Wormer
* @license MIT
@@ -61734,7 +57803,7 @@ const remarkLintUnorderedListMarkerStyle = lintRule(
);
}
- visit$2(tree, 'list', (node) => {
+ visit(tree, 'list', (node) => {
if (node.ordered) return
let index = -1;
@@ -61766,10 +57835,10 @@ const remarkLintUnorderedListMarkerStyle = lintRule(
var remarkLintUnorderedListMarkerStyle$1 = remarkLintUnorderedListMarkerStyle;
-// @see https://github.com/nodejs/node/blob/master/doc/guides/doc-style-guide.md
+// @see https://github.com/nodejs/node/blob/HEAD/doc/guides/doc-style-guide.md
// Add in rules alphabetically
-const remarkPresetLintNode = [
+const plugins = [
// Leave preset at the top so it can be overridden
remarkPresetLintRecommended$1,
[remarkLintBlockquoteIndentation$1, 2],
@@ -61844,343 +57913,7 @@ const remarkPresetLintNode = [
[remarkLintUnorderedListMarkerStyle$1, "*"],
];
-var remarkPresetLintNode$1 = /*#__PURE__*/Object.freeze({
- __proto__: null,
- 'default': remarkPresetLintNode
-});
-
-var require$$5 = /*@__PURE__*/getAugmentedNamespace(remarkPresetLintNode$1);
-
-/**
- * Like `Array#splice`, but smarter for giant arrays.
- *
- * `Array#splice` takes all items to be inserted as individual argument which
- * causes a stack overflow in V8 when trying to insert 100k items for instance.
- *
- * Otherwise, this does not return the removed items, and takes `items` as an
- * array instead of rest parameters.
- *
- * @template {unknown} T
- * @param {T[]} list
- * @param {number} start
- * @param {number} remove
- * @param {T[]} items
- * @returns {void}
- */
-function splice(list, start, remove, items) {
- const end = list.length;
- let chunkStart = 0;
- /** @type {unknown[]} */
-
- let parameters; // Make start between zero and `end` (included).
-
- if (start < 0) {
- start = -start > end ? 0 : end + start;
- } else {
- start = start > end ? end : start;
- }
-
- remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.
-
- if (items.length < 10000) {
- parameters = Array.from(items);
- parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.
- ;[].splice.apply(list, parameters);
- } else {
- // Delete `remove` items starting from `start`
- if (remove) [].splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.
-
- while (chunkStart < items.length) {
- parameters = items.slice(chunkStart, chunkStart + 10000);
- parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.
- ;[].splice.apply(list, parameters);
- chunkStart += 10000;
- start += 10000;
- }
- }
-}
-
-/**
- * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension
- * @typedef {import('micromark-util-types').Extension} Extension
- * @typedef {import('micromark-util-types').Construct} Construct
- * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
- */
-
-const hasOwnProperty = {}.hasOwnProperty;
-
-/**
- * Combine several syntax extensions into one.
- *
- * @param {Extension[]} extensions List of syntax extensions.
- * @returns {NormalizedExtension} A single combined extension.
- */
-function combineExtensions(extensions) {
- /** @type {NormalizedExtension} */
- const all = {};
- let index = -1;
-
- while (++index < extensions.length) {
- syntaxExtension(all, extensions[index]);
- }
-
- return all
-}
-
-/**
- * Merge `extension` into `all`.
- *
- * @param {NormalizedExtension} all Extension to merge into.
- * @param {Extension} extension Extension to merge.
- * @returns {void}
- */
-function syntaxExtension(all, extension) {
- /** @type {string} */
- let hook;
-
- for (hook in extension) {
- const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
- const left = maybe || (all[hook] = {});
- const right = extension[hook];
- /** @type {string} */
- let code;
-
- for (code in right) {
- if (!hasOwnProperty.call(left, code)) left[code] = [];
- const value = right[code];
- constructs(
- // @ts-expect-error Looks like a list.
- left[code],
- Array.isArray(value) ? value : value ? [value] : []
- );
- }
- }
-}
-
-/**
- * Merge `list` into `existing` (both lists of constructs).
- * Mutates `existing`.
- *
- * @param {unknown[]} existing
- * @param {unknown[]} list
- * @returns {void}
- */
-function constructs(existing, list) {
- let index = -1;
- /** @type {unknown[]} */
- const before = [];
-
- while (++index < list.length) {
-(list[index].add === 'after' ? existing : before).push(list[index]);
- }
-
- splice(existing, 0, 0, before);
-}
-
-/**
- * Combine several HTML extensions into one.
- *
- * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.
- * @returns {HtmlExtension} A single combined extension.
- */
-function combineHtmlExtensions(htmlExtensions) {
- /** @type {HtmlExtension} */
- const handlers = {};
- let index = -1;
-
- while (++index < htmlExtensions.length) {
- htmlExtension(handlers, htmlExtensions[index]);
- }
-
- return handlers
-}
-
-/**
- * Merge `extension` into `all`.
- *
- * @param {HtmlExtension} all Extension to merge into.
- * @param {HtmlExtension} extension Extension to merge.
- * @returns {void}
- */
-function htmlExtension(all, extension) {
- /** @type {string} */
- let hook;
-
- for (hook in extension) {
- const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;
- const left = maybe || (all[hook] = {});
- const right = extension[hook];
- /** @type {string} */
- let type;
-
- if (right) {
- for (type in right) {
- left[type] = right[type];
- }
- }
- }
-}
-
-// This module is generated by `script/`.
-//
-// CommonMark handles attention (emphasis, strong) markers based on what comes
-// before or after them.
-// One such difference is if those characters are Unicode punctuation.
-// This script is generated from the Unicode data.
-const unicodePunctuationRegex =
- /[!-/:-@[-`{-~\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;
-
-/**
- * @typedef {import('micromark-util-types').Code} Code
- */
-/**
- * Check whether the character code represents an ASCII alpha (`a` through `z`,
- * case insensitive).
- *
- * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
- *
- * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
- * to U+005A (`Z`).
- *
- * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
- * to U+007A (`z`).
- */
-
-const asciiAlpha = regexCheck(/[A-Za-z]/);
-/**
- * Check whether the character code represents an ASCII digit (`0` through `9`).
- *
- * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
- * U+0039 (`9`).
- */
-
-const asciiDigit = regexCheck(/\d/);
-/**
- * Check whether the character code represents an ASCII alphanumeric (`a`
- * through `z`, case insensitive, or `0` through `9`).
- *
- * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
- * (see `asciiAlpha`).
- */
-
-const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
-/**
- * Check whether a character code is an ASCII control character.
- *
- * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
- * to U+001F (US), or U+007F (DEL).
- *
- * @param {Code} code
- * @returns {code is number}
- */
-
-function asciiControl(code) {
- return (
- // Special whitespace codes (which have negative values), C0 and Control
- // character DEL
- code !== null && (code < 32 || code === 127)
- )
-}
-/**
- * Check whether a character code is a markdown line ending (see
- * `markdownLineEnding`) or markdown space (see `markdownSpace`).
- *
- * @param {Code} code
- * @returns {code is number}
- */
-
-function markdownLineEndingOrSpace(code) {
- return code !== null && (code < 0 || code === 32)
-}
-/**
- * Check whether a character code is a markdown line ending.
- *
- * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
- * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
- *
- * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
- * RETURN (CR) are replaced by these virtual characters depending on whether
- * they occurred together.
- *
- * @param {Code} code
- * @returns {code is number}
- */
-
-function markdownLineEnding(code) {
- return code !== null && code < -2
-}
-/**
- * Check whether a character code is a markdown space.
- *
- * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
- * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
- *
- * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
- * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
- * SPACE (VS) characters, depending on the column at which the tab occurred.
- *
- * @param {Code} code
- * @returns {code is number}
- */
-
-function markdownSpace(code) {
- return code === -2 || code === -1 || code === 32
-}
-/**
- * Check whether the character code represents Unicode whitespace.
- *
- * Note that this does handle micromark specific markdown whitespace characters.
- * See `markdownLineEndingOrSpace` to check that.
- *
- * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
- * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
- * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
- *
- * See:
- * **\[UNICODE]**:
- * [The Unicode Standard](https://www.unicode.org/versions/).
- * Unicode Consortium.
- */
-
-const unicodeWhitespace = regexCheck(/\s/);
-/**
- * Check whether the character code represents Unicode punctuation.
- *
- * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
- * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
- * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
- * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
- * punctuation (see `asciiPunctuation`).
- *
- * See:
- * **\[UNICODE]**:
- * [The Unicode Standard](https://www.unicode.org/versions/).
- * Unicode Consortium.
- */
-// Size note: removing ASCII from the regex and using `asciiPunctuation` here
-// In fact adds to the bundle size.
-
-const unicodePunctuation = regexCheck(unicodePunctuationRegex);
-/**
- * Create a code check from a regex.
- *
- * @param {RegExp} regex
- * @returns {(code: Code) => code is number}
- */
-
-function regexCheck(regex) {
- return check
- /**
- * Check whether a code matches the bound regex.
- *
- * @param {Code} code Character code
- * @returns {code is number} Whether the character code matches the bound regex
- */
-
- function check(code) {
- return code !== null && regex.test(String.fromCharCode(code))
- }
-}
+const remarkPresetLintNode = { plugins };
/**
* @typedef {import('micromark-util-types').Extension} Extension
@@ -63007,67 +58740,6 @@ const gfmStrikethroughHtml = {
};
/**
- * @typedef {import('micromark-util-types').Code} Code
- */
-
-/**
- * Classify whether a character code represents whitespace, punctuation, or
- * something else.
- *
- * Used for attention (emphasis, strong), whose sequences can open or close
- * based on the class of surrounding characters.
- *
- * Note that eof (`null`) is seen as whitespace.
- *
- * @param {Code} code
- * @returns {number|undefined}
- */
-function classifyCharacter(code) {
- if (
- code === null ||
- markdownLineEndingOrSpace(code) ||
- unicodeWhitespace(code)
- ) {
- return 1
- }
-
- if (unicodePunctuation(code)) {
- return 2
- }
-}
-
-/**
- * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
- * @typedef {import('micromark-util-types').Event} Event
- * @typedef {import('micromark-util-types').Resolver} Resolver
- */
-
-/**
- * Call all `resolveAll`s.
- *
- * @param {{resolveAll?: Resolver}[]} constructs
- * @param {Event[]} events
- * @param {TokenizeContext} context
- * @returns {Event[]}
- */
-function resolveAll(constructs, events, context) {
- /** @type {Resolver[]} */
- const called = [];
- let index = -1;
-
- while (++index < constructs.length) {
- const resolve = constructs[index].resolveAll;
-
- if (resolve && !called.includes(resolve)) {
- events = resolve(events, context);
- called.push(resolve);
- }
- }
-
- return events
-}
-
-/**
* @typedef {import('micromark-util-types').Extension} Extension
* @typedef {import('micromark-util-types').Resolver} Resolver
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
@@ -63388,45 +59060,6 @@ function replace$1($0, $1) {
}
/**
- * @typedef {import('micromark-util-types').Effects} Effects
- * @typedef {import('micromark-util-types').State} State
- */
-/**
- * @param {Effects} effects
- * @param {State} ok
- * @param {string} type
- * @param {number} [max=Infinity]
- * @returns {State}
- */
-
-function factorySpace(effects, ok, type, max) {
- const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
- let size = 0;
- return start
- /** @type {State} */
-
- function start(code) {
- if (markdownSpace(code)) {
- effects.enter(type);
- return prefix(code)
- }
-
- return ok(code)
- }
- /** @type {State} */
-
- function prefix(code) {
- if (markdownSpace(code) && size++ < limit) {
- effects.consume(code);
- return prefix
- }
-
- effects.exit(type);
- return ok(code)
- }
-}
-
-/**
* @typedef {import('micromark-util-types').Extension} Extension
* @typedef {import('micromark-util-types').Resolver} Resolver
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
@@ -64233,7 +59866,7 @@ function spaceThenNonSpace(effects, ok, nok) {
* @param {Options} [options]
* @returns {Extension}
*/
-function gfm$1(options) {
+function gfm(options) {
return combineExtensions([
gfmAutolinkLiteral,
gfmStrikethrough(options),
@@ -64277,16 +59910,149 @@ function ccount(value, character) {
return count
}
-function escapeStringRegexp(string) {
- if (typeof string !== 'string') {
- throw new TypeError('Expected a string');
- }
+/**
+ * @param {string} d
+ * @returns {string}
+ */
+function color(d) {
+ return '\u001B[33m' + d + '\u001B[39m'
+}
- // Escape characters with special meaning either inside or outside character sets.
- // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
- return string
- .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
- .replace(/-/g, '\\x2d');
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist-util-is').Test} Test
+ */
+
+/**
+ * Continue traversing as normal
+ */
+const CONTINUE = true;
+/**
+ * Do not traverse this node’s children
+ */
+const SKIP = 'skip';
+/**
+ * Stop traversing immediately
+ */
+const EXIT = false;
+
+const visitParents =
+ /**
+ * @type {(
+ * (<T extends Node>(tree: Node, test: T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|import('unist-util-is').TestFunctionPredicate<T>>, visitor: Visitor<T>, reverse?: boolean) => void) &
+ * ((tree: Node, test: Test, visitor: Visitor<Node>, reverse?: boolean) => void) &
+ * ((tree: Node, visitor: Visitor<Node>, reverse?: boolean) => void)
+ * )}
+ */
+ (
+ /**
+ * Visit children of tree which pass a test
+ *
+ * @param {Node} tree Abstract syntax tree to walk
+ * @param {Test} test test Test node
+ * @param {Visitor<Node>} visitor Function to run for each node
+ * @param {boolean} [reverse] Fisit the tree in reverse, defaults to false
+ */
+ function (tree, test, visitor, reverse) {
+ if (typeof test === 'function' && typeof visitor !== 'function') {
+ reverse = visitor;
+ // @ts-ignore no visitor given, so `visitor` is test.
+ visitor = test;
+ test = null;
+ }
+
+ var is = convert(test);
+ var step = reverse ? -1 : 1;
+
+ factory(tree, null, [])();
+
+ /**
+ * @param {Node} node
+ * @param {number?} index
+ * @param {Array.<Parent>} parents
+ */
+ function factory(node, index, parents) {
+ /** @type {Object.<string, unknown>} */
+ var value = typeof node === 'object' && node !== null ? node : {};
+ /** @type {string} */
+ var name;
+
+ if (typeof value.type === 'string') {
+ name =
+ typeof value.tagName === 'string'
+ ? value.tagName
+ : typeof value.name === 'string'
+ ? value.name
+ : undefined;
+
+ Object.defineProperty(visit, 'name', {
+ value:
+ 'node (' +
+ color(value.type + (name ? '<' + name + '>' : '')) +
+ ')'
+ });
+ }
+
+ return visit
+
+ function visit() {
+ /** @type {ActionTuple} */
+ var result = [];
+ /** @type {ActionTuple} */
+ var subresult;
+ /** @type {number} */
+ var offset;
+ /** @type {Array.<Parent>} */
+ var grandparents;
+
+ if (!test || is(node, index, parents[parents.length - 1] || null)) {
+ result = toResult(visitor(node, parents));
+
+ if (result[0] === EXIT) {
+ return result
+ }
+ }
+
+ if (node.children && result[0] !== SKIP) {
+ // @ts-ignore looks like a parent.
+ offset = (reverse ? node.children.length : -1) + step;
+ // @ts-ignore looks like a parent.
+ grandparents = parents.concat(node);
+
+ // @ts-ignore looks like a parent.
+ while (offset > -1 && offset < node.children.length) {
+ subresult = factory(node.children[offset], offset, grandparents)();
+
+ if (subresult[0] === EXIT) {
+ return subresult
+ }
+
+ offset =
+ typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+ }
+ }
+
+ return result
+ }
+ }
+ }
+ );
+
+/**
+ * @param {VisitorResult} value
+ * @returns {ActionTuple}
+ */
+function toResult(value) {
+ if (Array.isArray(value)) {
+ return value
+ }
+
+ if (typeof value === 'number') {
+ return [CONTINUE, value]
+ }
+
+ return [value]
}
/**
@@ -64364,12 +60130,12 @@ const findAndReplace =
settings = {};
}
- const ignored = convert$2(settings.ignore || []);
+ const ignored = convert(settings.ignore || []);
const pairs = toPairs(schema);
let pairIndex = -1;
while (++pairIndex < pairs.length) {
- visitParents$3(tree, 'text', visitor);
+ visitParents(tree, 'text', visitor);
}
return tree
@@ -64526,7 +60292,6 @@ function toFunction(replace) {
}
/**
- * @typedef {import('mdast').Link} Link
* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
* @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform
* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
@@ -64579,6 +60344,7 @@ const gfmAutolinkLiteralToMarkdown = {
/** @type {FromMarkdownHandle} */
function enterLiteralAutolink(token) {
+ // @ts-expect-error: `null` is fine.
this.enter({type: 'link', title: null, url: '', children: []}, token);
}
@@ -64595,8 +60361,7 @@ function exitLiteralAutolinkHttp(token) {
/** @type {FromMarkdownHandle} */
function exitLiteralAutolinkWww(token) {
this.config.exit.data.call(this, token);
- const node = /** @type {Link} */ (this.stack[this.stack.length - 1]);
- node.url = 'http://' + this.sliceSerialize(token);
+ this.stack[this.stack.length - 1].url = 'http://' + this.sliceSerialize(token);
}
/** @type {FromMarkdownHandle} */
@@ -64614,8 +60379,8 @@ function transformGfmAutolinkLiterals(tree) {
findAndReplace(
tree,
[
- [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl],
- [/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/g, findEmail]
+ [/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/i, findUrl],
+ [/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/, findEmail]
],
{ignore: ['link', 'linkReference']}
);
@@ -64654,6 +60419,7 @@ function findUrl(_, protocol, domain, path, match) {
if (!parts[0]) return false
/** @type {PhrasingContent} */
+ // @ts-expect-error: `null` is fine.
const result = {
type: 'link',
title: null,
@@ -64683,6 +60449,7 @@ function findEmail(_, atext, label, match) {
return {
type: 'link',
+ // @ts-expect-error: `null` is fine.
title: null,
url: 'mailto:' + atext + '@' + label,
children: [{type: 'text', value: atext + '@' + label}]
@@ -64761,71 +60528,6 @@ function previous(match, email) {
}
/**
- * @typedef {import('../types.js').Node} Node
- * @typedef {import('../types.js').Parent} Parent
- * @typedef {import('../types.js').SafeOptions} SafeOptions
- * @typedef {import('../types.js').Context} Context
- */
-
-/**
- * @param {Parent} parent
- * @param {Context} context
- * @param {SafeOptions} safeOptions
- * @returns {string}
- */
-function containerPhrasing(parent, context, safeOptions) {
- const children = parent.children || [];
- /** @type {Array.<string>} */
- const results = [];
- let index = -1;
- let before = safeOptions.before;
-
- while (++index < children.length) {
- const child = children[index];
- /** @type {string} */
- let after;
-
- if (index + 1 < children.length) {
- // @ts-expect-error: hush, it’s actually a `zwitch`.
- let handle = context.handle.handlers[children[index + 1].type];
- if (handle && handle.peek) handle = handle.peek;
- after = handle
- ? handle(children[index + 1], parent, context, {
- before: '',
- after: ''
- }).charAt(0)
- : '';
- } else {
- after = safeOptions.after;
- }
-
- // In some cases, html (text) can be found in phrasing right after an eol.
- // When we’d serialize that, in most cases that would be seen as html
- // (flow).
- // As we can’t escape or so to prevent it from happening, we take a somewhat
- // reasonable approach: replace that eol with a space.
- // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>
- if (
- results.length > 0 &&
- (before === '\r' || before === '\n') &&
- child.type === 'html'
- ) {
- results[results.length - 1] = results[results.length - 1].replace(
- /(\r?\n|\r)$/,
- ' '
- );
- before = ' ';
- }
-
- results.push(context.handle(child, parent, context, {before, after}));
-
- before = results[results.length - 1].slice(-1);
- }
-
- return results.join('')
-}
-
-/**
* @typedef {import('mdast').Delete} Delete
* @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
* @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
@@ -64875,107 +60577,6 @@ function peekDelete() {
}
/**
- * @typedef {import('../types.js').Unsafe} Unsafe
- */
-
-/**
- * @param {Unsafe} pattern
- * @returns {RegExp}
- */
-function patternCompile(pattern) {
- if (!pattern._compiled) {
- const before =
- (pattern.atBreak ? '[\\r\\n][\\t ]*' : '') +
- (pattern.before ? '(?:' + pattern.before + ')' : '');
-
- pattern._compiled = new RegExp(
- (before ? '(' + before + ')' : '') +
- (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
- pattern.character +
- (pattern.after ? '(?:' + pattern.after + ')' : ''),
- 'g'
- );
- }
-
- return pattern._compiled
-}
-
-/**
- * @typedef {import('mdast').InlineCode} InlineCode
- * @typedef {import('../types.js').Handle} Handle
- */
-
-inlineCode.peek = inlineCodePeek;
-
-/**
- * @type {Handle}
- * @param {InlineCode} node
- */
-function inlineCode(node, _, context) {
- let value = node.value || '';
- let sequence = '`';
- let index = -1;
-
- // If there is a single grave accent on its own in the code, use a fence of
- // two.
- // If there are two in a row, use one.
- while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {
- sequence += '`';
- }
-
- // If this is not just spaces or eols (tabs don’t count), and either the
- // first or last character are a space, eol, or tick, then pad with spaces.
- if (
- /[^ \r\n]/.test(value) &&
- ((/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value)) || /^`|`$/.test(value))
- ) {
- value = ' ' + value + ' ';
- }
-
- // We have a potential problem: certain characters after eols could result in
- // blocks being seen.
- // For example, if someone injected the string `'\n# b'`, then that would
- // result in an ATX heading.
- // We can’t escape characters in `inlineCode`, but because eols are
- // transformed to spaces when going from markdown to HTML anyway, we can swap
- // them out.
- while (++index < context.unsafe.length) {
- const pattern = context.unsafe[index];
- const expression = patternCompile(pattern);
- /** @type {RegExpExecArray|null} */
- let match;
-
- // Only look for `atBreak`s.
- // Btw: note that `atBreak` patterns will always start the regex at LF or
- // CR.
- if (!pattern.atBreak) continue
-
- while ((match = expression.exec(value))) {
- let position = match.index;
-
- // Support CRLF (patterns only look for one of the characters).
- if (
- value.charCodeAt(position) === 10 /* `\n` */ &&
- value.charCodeAt(position - 1) === 13 /* `\r` */
- ) {
- position--;
- }
-
- value = value.slice(0, position) + ' ' + value.slice(match.index + 1);
- }
- }
-
- return sequence + value + sequence
-}
-
-/**
- * @type {Handle}
- */
-function inlineCodePeek() {
- return '`'
-}
-
-/**
* @typedef MarkdownTableOptions
* @property {string|null|Array.<string|null|undefined>} [align]
* @property {boolean} [padding=true]
@@ -65471,216 +61072,6 @@ function gfmTableToMarkdown(options) {
}
/**
- * @typedef {import('../types.js').Context} Context
- * @typedef {import('../types.js').Options} Options
- */
-
-/**
- * @param {Context} context
- * @returns {Exclude<Options['bullet'], undefined>}
- */
-function checkBullet(context) {
- const marker = context.options.bullet || '*';
-
- if (marker !== '*' && marker !== '+' && marker !== '-') {
- throw new Error(
- 'Cannot serialize items with `' +
- marker +
- '` for `options.bullet`, expected `*`, `+`, or `-`'
- )
- }
-
- return marker
-}
-
-/**
- * @typedef {import('../types.js').Context} Context
- * @typedef {import('../types.js').Options} Options
- */
-
-/**
- * @param {Context} context
- * @returns {Exclude<Options['listItemIndent'], undefined>}
- */
-function checkListItemIndent(context) {
- const style = context.options.listItemIndent || 'tab';
-
- // To do: remove in a major.
- // @ts-expect-error: deprecated.
- if (style === 1 || style === '1') {
- return 'one'
- }
-
- if (style !== 'tab' && style !== 'one' && style !== 'mixed') {
- throw new Error(
- 'Cannot serialize items with `' +
- style +
- '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'
- )
- }
-
- return style
-}
-
-/**
- * @typedef {import('../types.js').Node} Node
- * @typedef {import('../types.js').Parent} Parent
- * @typedef {import('../types.js').Join} Join
- * @typedef {import('../types.js').Context} Context
- */
-
-/**
- * @param {Parent} parent
- * @param {Context} context
- * @returns {string}
- */
-function containerFlow(parent, context) {
- const children = parent.children || [];
- /** @type {Array.<string>} */
- const results = [];
- let index = -1;
-
- while (++index < children.length) {
- const child = children[index];
-
- results.push(
- context.handle(child, parent, context, {before: '\n', after: '\n'})
- );
-
- if (index < children.length - 1) {
- results.push(between(child, children[index + 1]));
- }
- }
-
- return results.join('')
-
- /**
- * @param {Node} left
- * @param {Node} right
- * @returns {string}
- */
- function between(left, right) {
- let index = context.join.length;
- /** @type {ReturnType<Join>} */
- let result;
-
- while (index--) {
- result = context.join[index](left, right, parent, context);
-
- if (result === true || result === 1) {
- break
- }
-
- if (typeof result === 'number') {
- return '\n'.repeat(1 + result)
- }
-
- if (result === false) {
- return '\n\n<!---->\n\n'
- }
- }
-
- return '\n\n'
- }
-}
-
-/**
- * @callback Map
- * @param {string} value
- * @param {number} line
- * @param {boolean} blank
- * @returns {string}
- */
-
-const eol = /\r?\n|\r/g;
-
-/**
- * @param {string} value
- * @param {Map} map
- * @returns {string}
- */
-function indentLines(value, map) {
- /** @type {Array.<string>} */
- const result = [];
- let start = 0;
- let line = 0;
- /** @type {RegExpExecArray|null} */
- let match;
-
- while ((match = eol.exec(value))) {
- one(value.slice(start, match.index));
- result.push(match[0]);
- start = match.index + match[0].length;
- line++;
- }
-
- one(value.slice(start));
-
- return result.join('')
-
- /**
- * @param {string} value
- */
- function one(value) {
- result.push(map(value, line, !value));
- }
-}
-
-/**
- * @typedef {import('mdast').ListItem} ListItem
- * @typedef {import('mdast').List} List
- * @typedef {import('../util/indent-lines.js').Map} Map
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').Handle} Handle
- */
-
-/**
- * @type {Handle}
- * @param {ListItem} node
- */
-function listItem(node, parent, context) {
- const listItemIndent = checkListItemIndent(context);
- /** @type {string} */
- let bullet = checkBullet(context);
-
- if (parent && parent.type === 'list' && parent.ordered) {
- bullet =
- (typeof parent.start === 'number' && parent.start > -1
- ? parent.start
- : 1) +
- (context.options.incrementListMarker === false
- ? 0
- : parent.children.indexOf(node)) +
- '.';
- }
-
- let size = bullet.length + 1;
-
- if (
- listItemIndent === 'tab' ||
- (listItemIndent === 'mixed' &&
- ((parent && 'spread' in parent && parent.spread) || node.spread))
- ) {
- size = Math.ceil(size / 4) * 4;
- }
-
- const exit = context.enter('listItem');
- const value = indentLines(containerFlow(node, context), map);
- exit();
-
- return value
-
- /** @type {Map} */
- function map(line, index, blank) {
- if (index) {
- return (blank ? '' : ' '.repeat(size)) + line
- }
-
- return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
- }
-}
-
-/**
* @typedef {import('mdast').ListItem} ListItem
* @typedef {import('mdast').Paragraph} Paragraph
* @typedef {import('mdast').BlockContent} BlockContent
@@ -65829,7 +61220,7 @@ function gfmToMarkdown(options) {
function remarkGfm(options = {}) {
const data = this.data();
- add('micromarkExtensions', gfm$1(options));
+ add('micromarkExtensions', gfm(options));
add('fromMarkdownExtensions', gfmFromMarkdown);
add('toMarkdownExtensions', gfmToMarkdown(options));
@@ -65848,26 +61239,10 @@ function remarkGfm(options = {}) {
}
}
-var remarkGfm$1 = /*#__PURE__*/Object.freeze({
- __proto__: null,
- 'default': remarkGfm
-});
-
-var require$$6 = /*@__PURE__*/getAugmentedNamespace(remarkGfm$1);
-
// To aid in future maintenance, this layout closely matches remark-cli/cli.js.
-// https://github.com/remarkjs/remark/blob/master/packages/remark-cli/cli.js
-
-const start = unifiedArgs;
-const extensions = markdownExtensions;
-const processor = remark;
-const proc = require$$3;
-const cli = require$$4;
-const lintNode = require$$5;
-const gfm = require$$6;
-
-start({
- processor: processor().use(gfm).use(lintNode),
+
+args({
+ processor: remark().use(remarkGfm).use(remarkPresetLintNode),
name: proc.name,
description: cli.description,
version: [
@@ -65879,8 +61254,6 @@ start({
packageField: proc.name + 'Config',
rcName: '.' + proc.name + 'rc',
ignoreName: '.' + proc.name + 'ignore',
- extensions: extensions,
+ extensions: markdownExtensions,
detectConfig: false,
});
-
-module.exports = cliEntry;
diff --git a/tools/node-lint-md-cli-rollup/package-lock.json b/tools/node-lint-md-cli-rollup/package-lock.json
index baf5c94d62..3cfe12696f 100644
--- a/tools/node-lint-md-cli-rollup/package-lock.json
+++ b/tools/node-lint-md-cli-rollup/package-lock.json
@@ -579,11 +579,11 @@
}
},
"node_modules/escape-string-regexp": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
- "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+ "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
"engines": {
- "node": ">=10"
+ "node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
@@ -740,19 +740,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/hast-util-from-parse5/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/hast-util-is-element": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-2.1.1.tgz",
@@ -799,15 +786,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/hast-util-to-html/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/hast-util-whitespace": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.0.tgz",
@@ -1184,26 +1162,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
- "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
- "engines": {
- "node": ">=12"
- },
- "funding": {
- "url": "https://github.com/sponsors/sindresorhus"
- }
- },
- "node_modules/mdast-util-find-and-replace/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
@@ -2133,51 +2091,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-blockquote-indentation/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-blockquote-indentation/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-blockquote-indentation/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-blockquote-indentation/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-checkbox-character-style": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-checkbox-character-style/-/remark-lint-checkbox-character-style-4.0.0.tgz",
@@ -2209,51 +2122,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-checkbox-character-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-character-style/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-character-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-character-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-checkbox-content-indent": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-checkbox-content-indent/-/remark-lint-checkbox-content-indent-4.0.0.tgz",
@@ -2286,64 +2154,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-checkbox-content-indent/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-content-indent/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-content-indent/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-content-indent/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-checkbox-content-indent/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-code-block-style": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-code-block-style/-/remark-lint-code-block-style-3.0.0.tgz",
@@ -2376,51 +2186,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-code-block-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-code-block-style/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-code-block-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-code-block-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-definition-spacing": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-definition-spacing/-/remark-lint-definition-spacing-3.0.0.tgz",
@@ -2452,51 +2217,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-definition-spacing/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-definition-spacing/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-definition-spacing/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-definition-spacing/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-fenced-code-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-fenced-code-flag/-/remark-lint-fenced-code-flag-3.0.0.tgz",
@@ -2529,51 +2249,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-fenced-code-flag/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-flag/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-flag/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-flag/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-fenced-code-marker": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-fenced-code-marker/-/remark-lint-fenced-code-marker-3.0.0.tgz",
@@ -2605,51 +2280,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-fenced-code-marker/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-marker/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-marker/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-fenced-code-marker/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-file-extension": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-file-extension/-/remark-lint-file-extension-2.0.0.tgz",
@@ -2711,51 +2341,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-final-definition/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-final-definition/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-final-definition/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-final-definition/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-final-newline": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-final-newline/-/remark-lint-final-newline-2.0.0.tgz",
@@ -2816,42 +2401,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-first-heading-level/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-first-heading-level/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-first-heading-level/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-hard-break-spaces": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-hard-break-spaces/-/remark-lint-hard-break-spaces-3.0.0.tgz",
@@ -2884,51 +2433,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-hard-break-spaces/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-hard-break-spaces/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-hard-break-spaces/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-hard-break-spaces/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-heading-style": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-heading-style/-/remark-lint-heading-style-3.0.0.tgz",
@@ -2961,42 +2465,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-heading-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-heading-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-heading-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-list-item-bullet-indent": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-list-item-bullet-indent/-/remark-lint-list-item-bullet-indent-4.0.0.tgz",
@@ -3028,42 +2496,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-list-item-bullet-indent/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-list-item-bullet-indent/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-list-item-bullet-indent/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-list-item-indent": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-list-item-indent/-/remark-lint-list-item-indent-3.0.0.tgz",
@@ -3097,51 +2529,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-list-item-indent/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-list-item-indent/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-list-item-indent/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-list-item-indent/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-maximum-line-length": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-maximum-line-length/-/remark-lint-maximum-line-length-3.0.0.tgz",
@@ -3174,51 +2561,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-maximum-line-length/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-maximum-line-length/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-maximum-line-length/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-maximum-line-length/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-auto-link-without-protocol": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-auto-link-without-protocol/-/remark-lint-no-auto-link-without-protocol-3.0.0.tgz",
@@ -3252,51 +2594,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-auto-link-without-protocol/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-auto-link-without-protocol/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-auto-link-without-protocol/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-auto-link-without-protocol/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-blockquote-without-marker": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-blockquote-without-marker/-/remark-lint-no-blockquote-without-marker-5.0.0.tgz",
@@ -3330,64 +2627,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-blockquote-without-marker/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-blockquote-without-marker/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-blockquote-without-marker/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-blockquote-without-marker/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-blockquote-without-marker/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-consecutive-blank-lines": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-consecutive-blank-lines/-/remark-lint-no-consecutive-blank-lines-4.0.0.tgz",
@@ -3422,51 +2661,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-consecutive-blank-lines/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-consecutive-blank-lines/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-consecutive-blank-lines/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-consecutive-blank-lines/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-duplicate-definitions": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-duplicate-definitions/-/remark-lint-no-duplicate-definitions-3.0.0.tgz",
@@ -3500,51 +2694,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-duplicate-definitions/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-duplicate-definitions/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-duplicate-definitions/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-duplicate-definitions/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-file-name-articles": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-file-name-articles/-/remark-lint-no-file-name-articles-2.0.0.tgz",
@@ -3666,51 +2815,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-heading-content-indent/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-content-indent/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-content-indent/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-content-indent/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-heading-indent": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-heading-indent/-/remark-lint-no-heading-indent-4.0.0.tgz",
@@ -3744,51 +2848,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-heading-indent/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-indent/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-indent/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-heading-indent/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-inline-padding": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-inline-padding/-/remark-lint-no-inline-padding-4.0.0.tgz",
@@ -3821,42 +2880,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-inline-padding/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-inline-padding/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-inline-padding/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-literal-urls": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-literal-urls/-/remark-lint-no-literal-urls-3.0.0.tgz",
@@ -3890,51 +2913,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-literal-urls/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-literal-urls/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-literal-urls/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-literal-urls/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-multiple-toplevel-headings": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-multiple-toplevel-headings/-/remark-lint-no-multiple-toplevel-headings-3.0.0.tgz",
@@ -3968,51 +2946,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-multiple-toplevel-headings/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-multiple-toplevel-headings/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-multiple-toplevel-headings/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-multiple-toplevel-headings/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-shell-dollars": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-shell-dollars/-/remark-lint-no-shell-dollars-3.0.0.tgz",
@@ -4044,42 +2977,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-shell-dollars/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shell-dollars/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shell-dollars/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-shortcut-reference-image": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-image/-/remark-lint-no-shortcut-reference-image-3.0.0.tgz",
@@ -4111,42 +3008,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-shortcut-reference-image/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shortcut-reference-image/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shortcut-reference-image/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-shortcut-reference-link": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-shortcut-reference-link/-/remark-lint-no-shortcut-reference-link-3.0.0.tgz",
@@ -4178,42 +3039,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-shortcut-reference-link/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shortcut-reference-link/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-shortcut-reference-link/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-table-indentation": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-table-indentation/-/remark-lint-no-table-indentation-4.0.0.tgz",
@@ -4246,64 +3071,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-table-indentation/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-table-indentation/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-table-indentation/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-table-indentation/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-table-indentation/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-tabs": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-tabs/-/remark-lint-no-tabs-3.0.0.tgz",
@@ -4334,19 +3101,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-tabs/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-trailing-spaces": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/remark-lint-no-trailing-spaces/-/remark-lint-no-trailing-spaces-2.0.1.tgz",
@@ -4389,64 +3143,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-undefined-references/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-undefined-references/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-undefined-references/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-undefined-references/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-undefined-references/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-no-unused-definitions": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-no-unused-definitions/-/remark-lint-no-unused-definitions-3.0.0.tgz",
@@ -4478,42 +3174,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-no-unused-definitions/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-unused-definitions/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-no-unused-definitions/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-ordered-list-marker-style": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-ordered-list-marker-style/-/remark-lint-ordered-list-marker-style-3.0.0.tgz",
@@ -4546,63 +3206,33 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-ordered-list-marker-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-ordered-list-marker-style/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-ordered-list-marker-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
+ "node_modules/remark-lint-prohibited-strings": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-3.0.0.tgz",
+ "integrity": "sha512-Aw21KVeoOiDte6dNfeTfTgjKV19yWXpPjLxfJ3ShC22/r97gkGdOo4dnuwyEEAfKhr3uimtSf3rRQyGSudY5tQ==",
"dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
+ "escape-string-regexp": "^5.0.0",
+ "unified-lint-rule": "^2.0.0",
+ "unist-util-position": "^4.0.1",
+ "unist-util-visit": "^4.0.0",
+ "vfile-location": "^4.0.1"
}
},
- "node_modules/remark-lint-ordered-list-marker-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
+ "node_modules/remark-lint-prohibited-strings/node_modules/unified-lint-rule": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.1.tgz",
+ "integrity": "sha512-2RzZuuuWW+ifftM0zd/ZEng0Hb5lah+Zi+ZL/ybj8BrLO/TH2aQAMYvG+iC95aCg2FkWu/pcvVvHqsh2UMmzPg==",
"dependencies": {
"@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
+ "trough": "^2.0.0",
+ "unified": "^10.0.0",
+ "vfile": "^5.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-prohibited-strings": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-2.0.0.tgz",
- "integrity": "sha512-N94RTdAT4qmYNBczNZEZbnpGvtl9GiLPO/xdG569IpbbtNFh5l+Nf5Mx5B1VeJMC8/hAR7wShag03Zf29MOO6Q==",
- "dependencies": {
- "escape-string-regexp": "^4.0.0",
- "unified-lint-rule": "^1.0.2",
- "unist-util-position": "^3.1.0",
- "unist-util-visit": "^2.0.0",
- "vfile-location": "^3.0.1"
- }
- },
"node_modules/remark-lint-rule-style": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-rule-style/-/remark-lint-rule-style-3.0.0.tgz",
@@ -4634,51 +3264,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-rule-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-rule-style/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-rule-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-rule-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-strong-marker": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-strong-marker/-/remark-lint-strong-marker-3.0.0.tgz",
@@ -4710,51 +3295,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-strong-marker/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-strong-marker/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-strong-marker/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-strong-marker/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-table-cell-padding": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-table-cell-padding/-/remark-lint-table-cell-padding-4.0.0.tgz",
@@ -4787,51 +3327,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-table-cell-padding/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-cell-padding/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-cell-padding/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-cell-padding/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-table-pipes": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-table-pipes/-/remark-lint-table-pipes-4.0.0.tgz",
@@ -4863,51 +3358,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-table-pipes/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-pipes/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-pipes/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-table-pipes/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-lint-unordered-list-marker-style": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/remark-lint-unordered-list-marker-style/-/remark-lint-unordered-list-marker-style-3.0.0.tgz",
@@ -4940,51 +3390,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-lint-unordered-list-marker-style/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-unordered-list-marker-style/node_modules/unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-unordered-list-marker-style/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-lint-unordered-list-marker-style/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-parse": {
"version": "10.0.0",
"resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.0.tgz",
@@ -5000,9 +3405,9 @@
}
},
"node_modules/remark-preset-lint-node": {
- "version": "3.0.0",
- "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.0.tgz",
- "integrity": "sha512-H1YwlVi/K0xmFT2JaVqnySNHdW/gqd9EQRbGVcH2mkxLNLdO+FIawkSU+UVYIhsm63pKAkHFW8HEtdoEAkNxOg==",
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.1.tgz",
+ "integrity": "sha512-L7yhho9q9vmpsfMHO2gRKFNj36106iFM4KpodE+3k3rGg5dcmhV+zcsftNh5NGzbKKKYsGQj9C5XxCR/0NwKDg==",
"dependencies": {
"js-yaml": "^4.0.0",
"remark-lint-blockquote-indentation": "^3.0.0",
@@ -5028,7 +3433,7 @@
"remark-lint-no-table-indentation": "^4.0.0",
"remark-lint-no-tabs": "^3.0.0",
"remark-lint-no-trailing-spaces": "^2.0.1",
- "remark-lint-prohibited-strings": "^2.0.0",
+ "remark-lint-prohibited-strings": "^3.0.0",
"remark-lint-rule-style": "^3.0.0",
"remark-lint-strong-marker": "^3.0.0",
"remark-lint-table-cell-padding": "^4.0.0",
@@ -5058,42 +3463,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-preset-lint-node/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-preset-lint-node/node_modules/unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
- "node_modules/remark-preset-lint-node/node_modules/unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-preset-lint-recommended": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/remark-preset-lint-recommended/-/remark-preset-lint-recommended-6.0.0.tgz",
@@ -5180,15 +3549,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-preset-lint-recommended/node_modules/unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-preset-lint-recommended/node_modules/unist-util-visit": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
@@ -5216,19 +3576,6 @@
"url": "https://opencollective.com/unified"
}
},
- "node_modules/remark-preset-lint-recommended/node_modules/vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "dependencies": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- },
- "funding": {
- "type": "opencollective",
- "url": "https://opencollective.com/unified"
- }
- },
"node_modules/remark-stringify": {
"version": "10.0.0",
"resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-10.0.0.tgz",
@@ -5265,9 +3612,9 @@
}
},
"node_modules/rollup": {
- "version": "2.52.7",
- "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.52.7.tgz",
- "integrity": "sha512-55cSH4CCU6MaPr9TAOyrIC+7qFCHscL7tkNsm1MBfIJRRqRbCEY0mmeFn4Wg8FKsHtEH8r389Fz38r/o+kgXLg==",
+ "version": "2.56.2",
+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.56.2.tgz",
+ "integrity": "sha512-s8H00ZsRi29M2/lGdm1u8DJpJ9ML8SUOpVVBd33XNeEeL3NVaTiUcSBHzBdF3eAyR0l7VSpsuoVUGrRHq7aPwQ==",
"dev": true,
"bin": {
"rollup": "dist/bin/rollup"
@@ -5576,18 +3923,18 @@
}
},
"node_modules/unist-util-is": {
- "version": "4.0.4",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.4.tgz",
- "integrity": "sha512-3dF39j/u423v4BBQrk1AQ2Ve1FxY5W3JKwXxVFzBODQ6WEvccguhgp802qQLKSnxPODE6WuRZtV+ohlUg4meBA==",
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
+ "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ==",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
}
},
"node_modules/unist-util-position": {
- "version": "3.1.0",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.1.0.tgz",
- "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA==",
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
+ "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA==",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
@@ -5606,13 +3953,13 @@
}
},
"node_modules/unist-util-visit": {
- "version": "2.0.3",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
- "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
+ "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
"dependencies": {
"@types/unist": "^2.0.0",
- "unist-util-is": "^4.0.0",
- "unist-util-visit-parents": "^3.0.0"
+ "unist-util-is": "^5.0.0",
+ "unist-util-visit-parents": "^5.0.0"
},
"funding": {
"type": "opencollective",
@@ -5620,12 +3967,12 @@
}
},
"node_modules/unist-util-visit-parents": {
- "version": "3.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz",
- "integrity": "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==",
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
+ "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
"dependencies": {
"@types/unist": "^2.0.0",
- "unist-util-is": "^4.0.0"
+ "unist-util-is": "^5.0.0"
},
"funding": {
"type": "opencollective",
@@ -5653,9 +4000,13 @@
}
},
"node_modules/vfile-location": {
- "version": "3.2.0",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz",
- "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==",
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
+ "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
+ "dependencies": {
+ "@types/unist": "^2.0.0",
+ "vfile": "^5.0.0"
+ },
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
@@ -6209,9 +4560,9 @@
}
},
"escape-string-regexp": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
- "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+ "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="
},
"estree-walker": {
"version": "2.0.2",
@@ -6323,17 +4674,6 @@
"vfile": "^5.0.0",
"vfile-location": "^4.0.0",
"web-namespaces": "^2.0.0"
- },
- "dependencies": {
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
- }
}
},
"hast-util-is-element": {
@@ -6368,13 +4708,6 @@
"space-separated-tokens": "^2.0.0",
"stringify-entities": "^4.0.0",
"unist-util-is": "^5.0.0"
- },
- "dependencies": {
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- }
}
},
"hast-util-whitespace": {
@@ -6637,16 +4970,6 @@
"unist-util-visit-parents": "^4.0.0"
},
"dependencies": {
- "escape-string-regexp": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
- "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
"unist-util-visit-parents": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-4.1.1.tgz",
@@ -7229,35 +5552,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7283,35 +5577,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7338,44 +5603,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -7402,35 +5629,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7456,35 +5654,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7511,35 +5680,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7565,35 +5705,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7643,35 +5754,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7720,30 +5802,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7770,35 +5828,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7825,30 +5854,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7874,30 +5879,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7925,35 +5906,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -7980,35 +5932,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8036,35 +5959,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8092,44 +5986,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -8158,35 +6014,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8214,35 +6041,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8340,35 +6138,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8396,35 +6165,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8451,30 +6191,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8502,35 +6218,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8558,35 +6245,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8612,30 +6270,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8661,30 +6295,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8710,30 +6320,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8760,44 +6346,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -8822,15 +6370,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -8867,44 +6406,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -8930,30 +6431,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -8980,48 +6457,32 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
"remark-lint-prohibited-strings": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-2.0.0.tgz",
- "integrity": "sha512-N94RTdAT4qmYNBczNZEZbnpGvtl9GiLPO/xdG569IpbbtNFh5l+Nf5Mx5B1VeJMC8/hAR7wShag03Zf29MOO6Q==",
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/remark-lint-prohibited-strings/-/remark-lint-prohibited-strings-3.0.0.tgz",
+ "integrity": "sha512-Aw21KVeoOiDte6dNfeTfTgjKV19yWXpPjLxfJ3ShC22/r97gkGdOo4dnuwyEEAfKhr3uimtSf3rRQyGSudY5tQ==",
"requires": {
- "escape-string-regexp": "^4.0.0",
- "unified-lint-rule": "^1.0.2",
- "unist-util-position": "^3.1.0",
- "unist-util-visit": "^2.0.0",
- "vfile-location": "^3.0.1"
+ "escape-string-regexp": "^5.0.0",
+ "unified-lint-rule": "^2.0.0",
+ "unist-util-position": "^4.0.1",
+ "unist-util-visit": "^4.0.0",
+ "vfile-location": "^4.0.1"
+ },
+ "dependencies": {
+ "unified-lint-rule": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/unified-lint-rule/-/unified-lint-rule-2.0.1.tgz",
+ "integrity": "sha512-2RzZuuuWW+ifftM0zd/ZEng0Hb5lah+Zi+ZL/ybj8BrLO/TH2aQAMYvG+iC95aCg2FkWu/pcvVvHqsh2UMmzPg==",
+ "requires": {
+ "@types/unist": "^2.0.0",
+ "trough": "^2.0.0",
+ "unified": "^10.0.0",
+ "vfile": "^5.0.0"
+ }
+ }
}
},
"remark-lint-rule-style": {
@@ -9046,35 +6507,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9100,35 +6532,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9155,35 +6558,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9209,35 +6583,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9264,35 +6609,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-position": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
- "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9307,9 +6623,9 @@
}
},
"remark-preset-lint-node": {
- "version": "3.0.0",
- "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.0.tgz",
- "integrity": "sha512-H1YwlVi/K0xmFT2JaVqnySNHdW/gqd9EQRbGVcH2mkxLNLdO+FIawkSU+UVYIhsm63pKAkHFW8HEtdoEAkNxOg==",
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/remark-preset-lint-node/-/remark-preset-lint-node-3.0.1.tgz",
+ "integrity": "sha512-L7yhho9q9vmpsfMHO2gRKFNj36106iFM4KpodE+3k3rGg5dcmhV+zcsftNh5NGzbKKKYsGQj9C5XxCR/0NwKDg==",
"requires": {
"js-yaml": "^4.0.0",
"remark-lint-blockquote-indentation": "^3.0.0",
@@ -9335,7 +6651,7 @@
"remark-lint-no-table-indentation": "^4.0.0",
"remark-lint-no-tabs": "^3.0.0",
"remark-lint-no-trailing-spaces": "^2.0.1",
- "remark-lint-prohibited-strings": "^2.0.0",
+ "remark-lint-prohibited-strings": "^3.0.0",
"remark-lint-rule-style": "^3.0.0",
"remark-lint-strong-marker": "^3.0.0",
"remark-lint-table-cell-padding": "^4.0.0",
@@ -9357,30 +6673,6 @@
"unified": "^10.0.0",
"vfile": "^5.0.0"
}
- },
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
- "unist-util-visit": {
- "version": "4.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
- "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0",
- "unist-util-visit-parents": "^5.0.0"
- }
- },
- "unist-util-visit-parents": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
- "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
- "requires": {
- "@types/unist": "^2.0.0",
- "unist-util-is": "^5.0.0"
- }
}
}
},
@@ -9450,11 +6742,6 @@
"vfile-message": "^3.0.0"
}
},
- "unist-util-is": {
- "version": "5.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
- "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
- },
"unist-util-visit": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-3.1.0.tgz",
@@ -9473,15 +6760,6 @@
"@types/unist": "^2.0.0",
"unist-util-is": "^5.0.0"
}
- },
- "vfile-location": {
- "version": "4.0.1",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
- "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
- "requires": {
- "@types/unist": "^2.0.0",
- "vfile": "^5.0.0"
- }
}
}
},
@@ -9511,9 +6789,9 @@
}
},
"rollup": {
- "version": "2.52.7",
- "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.52.7.tgz",
- "integrity": "sha512-55cSH4CCU6MaPr9TAOyrIC+7qFCHscL7tkNsm1MBfIJRRqRbCEY0mmeFn4Wg8FKsHtEH8r389Fz38r/o+kgXLg==",
+ "version": "2.56.2",
+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.56.2.tgz",
+ "integrity": "sha512-s8H00ZsRi29M2/lGdm1u8DJpJ9ML8SUOpVVBd33XNeEeL3NVaTiUcSBHzBdF3eAyR0l7VSpsuoVUGrRHq7aPwQ==",
"dev": true,
"requires": {
"fsevents": "~2.3.2"
@@ -9726,14 +7004,14 @@
}
},
"unist-util-is": {
- "version": "4.0.4",
- "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.0.4.tgz",
- "integrity": "sha512-3dF39j/u423v4BBQrk1AQ2Ve1FxY5W3JKwXxVFzBODQ6WEvccguhgp802qQLKSnxPODE6WuRZtV+ohlUg4meBA=="
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.1.1.tgz",
+ "integrity": "sha512-F5CZ68eYzuSvJjGhCLPL3cYx45IxkqXSetCcRgUXtbcm50X2L9oOWQlfUfDdAf+6Pd27YDblBfdtmsThXmwpbQ=="
},
"unist-util-position": {
- "version": "3.1.0",
- "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.1.0.tgz",
- "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA=="
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.1.tgz",
+ "integrity": "sha512-mgy/zI9fQ2HlbOtTdr2w9lhVaiFUHWQnZrFF2EUoVOqtAUdzqMtNiD99qA5a1IcjWVR8O6aVYE9u7Z2z1v0SQA=="
},
"unist-util-stringify-position": {
"version": "3.0.0",
@@ -9744,22 +7022,22 @@
}
},
"unist-util-visit": {
- "version": "2.0.3",
- "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz",
- "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==",
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.0.0.tgz",
+ "integrity": "sha512-3HWTvrtU10/E7qgPznBfiOyG0TXj9W8c1GSfaI8L9GkaG1pLePiQPZ7E35a0R3ToQ/zcy4Im6aZ9WBgOTnv1MQ==",
"requires": {
"@types/unist": "^2.0.0",
- "unist-util-is": "^4.0.0",
- "unist-util-visit-parents": "^3.0.0"
+ "unist-util-is": "^5.0.0",
+ "unist-util-visit-parents": "^5.0.0"
}
},
"unist-util-visit-parents": {
- "version": "3.1.1",
- "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz",
- "integrity": "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==",
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.0.0.tgz",
+ "integrity": "sha512-CVaLOYPM/EaFTYMytbaju3Tw4QI3DHnHFnL358FkEu0hZOzSm/hqBdVwOQDR60jF5ZzhB1tlZlRH0ll/yekZIQ==",
"requires": {
"@types/unist": "^2.0.0",
- "unist-util-is": "^4.0.0"
+ "unist-util-is": "^5.0.0"
}
},
"util-deprecate": {
@@ -9779,9 +7057,13 @@
}
},
"vfile-location": {
- "version": "3.2.0",
- "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz",
- "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA=="
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.0.1.tgz",
+ "integrity": "sha512-JDxPlTbZrZCQXogGheBHjbRWjESSPEak770XwWPfw5mTc1v1nWGLB/apzZxsx8a0SJVfF8HK8ql8RD308vXRUw==",
+ "requires": {
+ "@types/unist": "^2.0.0",
+ "vfile": "^5.0.0"
+ }
},
"vfile-message": {
"version": "3.0.2",
diff --git a/tools/node-lint-md-cli-rollup/package.json b/tools/node-lint-md-cli-rollup/package.json
index 0602d902c2..56ad44b391 100644
--- a/tools/node-lint-md-cli-rollup/package.json
+++ b/tools/node-lint-md-cli-rollup/package.json
@@ -19,6 +19,6 @@
"main": "dist/index.js",
"scripts": {
"build": "npx rollup -c",
- "build-node": "npm run build && npx shx cp dist/index.js ../lint-md.js"
+ "build-node": "npm run build && npx shx cp dist/index.mjs ../lint-md.mjs"
}
}
diff --git a/tools/node-lint-md-cli-rollup/rollup.config.js b/tools/node-lint-md-cli-rollup/rollup.config.js
index 531103d729..0a2b2098e6 100644
--- a/tools/node-lint-md-cli-rollup/rollup.config.js
+++ b/tools/node-lint-md-cli-rollup/rollup.config.js
@@ -7,22 +7,18 @@ const json = require('@rollup/plugin-json');
module.exports = {
input: 'src/cli-entry.mjs',
output: {
- file: 'dist/index.js',
- format: 'cjs',
+ file: 'dist/index.mjs',
+ format: 'es',
sourcemap: false,
exports: 'none',
},
external: [
- 'stream',
- 'path',
- 'module',
- 'util',
- 'tty',
- 'os',
- 'fs',
- 'fsevents',
- 'events',
- 'assert',
+ 'node:events',
+ 'node:fs',
+ 'node:path',
+ 'node:process',
+ 'node:stream',
+ 'node:url',
],
plugins: [
{
@@ -47,7 +43,7 @@ module.exports = {
json({
preferConst: true
}),
- nodeResolve(), // tells Rollup how to find date-fns in node_modules
+ nodeResolve({ exportConditions: ['node'] }),
commonjs(),
{
name: 'banner',
diff --git a/vcbuild.bat b/vcbuild.bat
index 9a32b2b033..b5c5a53dd7 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -712,7 +712,7 @@ for /D %%D IN (doc\*) do (
set "lint_md_files="%%F" !lint_md_files!"
)
)
-%node_exe% tools\lint-md.js -q -f %lint_md_files%
+%node_exe% tools\lint-md.mjs -q -f %lint_md_files%
ENDLOCAL
goto exit
View Lorry Controller Status