actions/mawesome
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
mawesome/index.js
Simone Corsi 55cd9e9c58
build: fixes release build 
Switch to semantic release didnt commit compiled output
2022-05-11 09:44:55 +02:00

14433 lines
442 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/******/ (() => {
// webpackBootstrap
/******/ var __webpack_modules__ = {
/***/ 7351: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result['default'] = mod;
return result;
};
Object.defineProperty(exports, '__esModule', { value: true });
const os = __importStar(__nccwpck_require__(2037));
const utils_1 = __nccwpck_require__(5278);
/**
* Commands
*
* Command Format:
* ::name key=value,key=value::message
*
* Examples:
* ::warning::This is the message
* ::set-env name=MY_VAR::some value
*/
function issueCommand(command, properties, message) {
const cmd = new Command(command, properties, message);
process.stdout.write(cmd.toString() + os.EOL);
}
exports.issueCommand = issueCommand;
function issue(name, message = '') {
issueCommand(name, {}, message);
}
exports.issue = issue;
const CMD_STRING = '::';
class Command {
constructor(command, properties, message) {
if (!command) {
command = 'missing.command';
}
this.command = command;
this.properties = properties;
this.message = message;
}
toString() {
let cmdStr = CMD_STRING + this.command;
if (this.properties && Object.keys(this.properties).length > 0) {
cmdStr += ' ';
let first = true;
for (const key in this.properties) {
if (this.properties.hasOwnProperty(key)) {
const val = this.properties[key];
if (val) {
if (first) {
first = false;
} else {
cmdStr += ',';
}
cmdStr += `${key}=${escapeProperty(val)}`;
}
}
}
}
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
return cmdStr;
}
}
function escapeData(s) {
return utils_1
.toCommandValue(s)
.replace(/%/g, '%25')
.replace(/\r/g, '%0D')
.replace(/\n/g, '%0A');
}
function escapeProperty(s) {
return utils_1
.toCommandValue(s)
.replace(/%/g, '%25')
.replace(/\r/g, '%0D')
.replace(/\n/g, '%0A')
.replace(/:/g, '%3A')
.replace(/,/g, '%2C');
}
//# sourceMappingURL=command.js.map
/***/
},
/***/ 2186: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result['default'] = mod;
return result;
};
Object.defineProperty(exports, '__esModule', { value: true });
const command_1 = __nccwpck_require__(7351);
const file_command_1 = __nccwpck_require__(717);
const utils_1 = __nccwpck_require__(5278);
const os = __importStar(__nccwpck_require__(2037));
const path = __importStar(__nccwpck_require__(1017));
/**
* The code to exit an action
*/
var ExitCode;
(function (ExitCode) {
/**
* A code indicating that the action was successful
*/
ExitCode[(ExitCode['Success'] = 0)] = 'Success';
/**
* A code indicating that the action was a failure
*/
ExitCode[(ExitCode['Failure'] = 1)] = 'Failure';
})((ExitCode = exports.ExitCode || (exports.ExitCode = {})));
//-----------------------------------------------------------------------
// Variables
//-----------------------------------------------------------------------
/**
* Sets env variable for this action and future actions in the job
* @param name the name of the variable to set
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function exportVariable(name, val) {
const convertedVal = utils_1.toCommandValue(val);
process.env[name] = convertedVal;
const filePath = process.env['GITHUB_ENV'] || '';
if (filePath) {
const delimiter = '_GitHubActionsFileCommandDelimeter_';
const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
file_command_1.issueCommand('ENV', commandValue);
} else {
command_1.issueCommand('set-env', { name }, convertedVal);
}
}
exports.exportVariable = exportVariable;
/**
* Registers a secret which will get masked from logs
* @param secret value of the secret
*/
function setSecret(secret) {
command_1.issueCommand('add-mask', {}, secret);
}
exports.setSecret = setSecret;
/**
* Prepends inputPath to the PATH (for this action and future actions)
* @param inputPath
*/
function addPath(inputPath) {
const filePath = process.env['GITHUB_PATH'] || '';
if (filePath) {
file_command_1.issueCommand('PATH', inputPath);
} else {
command_1.issueCommand('add-path', {}, inputPath);
}
process.env[
'PATH'
] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
}
exports.addPath = addPath;
/**
* Gets the value of an input. The value is also trimmed.
*
* @param name name of the input to get
* @param options optional. See InputOptions.
* @returns string
*/
function getInput(name, options) {
const val =
process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
if (options && options.required && !val) {
throw new Error(`Input required and not supplied: ${name}`);
}
return val.trim();
}
exports.getInput = getInput;
/**
* Sets the value of an output.
*
* @param name name of the output to set
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function setOutput(name, value) {
command_1.issueCommand('set-output', { name }, value);
}
exports.setOutput = setOutput;
/**
* Enables or disables the echoing of commands into stdout for the rest of the step.
* Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
*
*/
function setCommandEcho(enabled) {
command_1.issue('echo', enabled ? 'on' : 'off');
}
exports.setCommandEcho = setCommandEcho;
//-----------------------------------------------------------------------
// Results
//-----------------------------------------------------------------------
/**
* Sets the action status to failed.
* When the action exits it will be with an exit code of 1
* @param message add error issue message
*/
function setFailed(message) {
process.exitCode = ExitCode.Failure;
error(message);
}
exports.setFailed = setFailed;
//-----------------------------------------------------------------------
// Logging Commands
//-----------------------------------------------------------------------
/**
* Gets whether Actions Step Debug is on or not
*/
function isDebug() {
return process.env['RUNNER_DEBUG'] === '1';
}
exports.isDebug = isDebug;
/**
* Writes debug message to user log
* @param message debug message
*/
function debug(message) {
command_1.issueCommand('debug', {}, message);
}
exports.debug = debug;
/**
* Adds an error issue
* @param message error issue message. Errors will be converted to string via toString()
*/
function error(message) {
command_1.issue(
'error',
message instanceof Error ? message.toString() : message
);
}
exports.error = error;
/**
* Adds an warning issue
* @param message warning issue message. Errors will be converted to string via toString()
*/
function warning(message) {
command_1.issue(
'warning',
message instanceof Error ? message.toString() : message
);
}
exports.warning = warning;
/**
* Writes info to log with console.log.
* @param message info message
*/
function info(message) {
process.stdout.write(message + os.EOL);
}
exports.info = info;
/**
* Begin an output group.
*
* Output until the next `groupEnd` will be foldable in this group
*
* @param name The name of the output group
*/
function startGroup(name) {
command_1.issue('group', name);
}
exports.startGroup = startGroup;
/**
* End an output group.
*/
function endGroup() {
command_1.issue('endgroup');
}
exports.endGroup = endGroup;
/**
* Wrap an asynchronous function call in a group.
*
* Returns the same type as the function itself.
*
* @param name The name of the group
* @param fn The function to wrap in the group
*/
function group(name, fn) {
return __awaiter(this, void 0, void 0, function* () {
startGroup(name);
let result;
try {
result = yield fn();
} finally {
endGroup();
}
return result;
});
}
exports.group = group;
//-----------------------------------------------------------------------
// Wrapper action state
//-----------------------------------------------------------------------
/**
* Saves state for current action, the state can only be retrieved by this action's post job execution.
*
* @param name name of the state to store
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function saveState(name, value) {
command_1.issueCommand('save-state', { name }, value);
}
exports.saveState = saveState;
/**
* Gets the value of an state set by this action's main execution.
*
* @param name name of the state to get
* @returns string
*/
function getState(name) {
return process.env[`STATE_${name}`] || '';
}
exports.getState = getState;
//# sourceMappingURL=core.js.map
/***/
},
/***/ 717: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
// For internal use, subject to change.
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result['default'] = mod;
return result;
};
Object.defineProperty(exports, '__esModule', { value: true });
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
const fs = __importStar(__nccwpck_require__(7147));
const os = __importStar(__nccwpck_require__(2037));
const utils_1 = __nccwpck_require__(5278);
function issueCommand(command, message) {
const filePath = process.env[`GITHUB_${command}`];
if (!filePath) {
throw new Error(
`Unable to find environment variable for file command ${command}`
);
}
if (!fs.existsSync(filePath)) {
throw new Error(`Missing file at path: ${filePath}`);
}
fs.appendFileSync(
filePath,
`${utils_1.toCommandValue(message)}${os.EOL}`,
{
encoding: 'utf8',
}
);
}
exports.issueCommand = issueCommand;
//# sourceMappingURL=file-command.js.map
/***/
},
/***/ 5278: /***/ (__unused_webpack_module, exports) => {
'use strict';
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
Object.defineProperty(exports, '__esModule', { value: true });
/**
* Sanitizes an input into a string so it can be passed into issueCommand safely
* @param input input to sanitize into a string
*/
function toCommandValue(input) {
if (input === null || input === undefined) {
return '';
} else if (typeof input === 'string' || input instanceof String) {
return input;
}
return JSON.stringify(input);
}
exports.toCommandValue = toCommandValue;
//# sourceMappingURL=utils.js.map
/***/
},
/***/ 1514: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, {
enumerable: true,
get: function () {
return m[k];
},
});
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {
enumerable: true,
value: v,
});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== 'default' && Object.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
Object.defineProperty(exports, '__esModule', { value: true });
exports.getExecOutput = exports.exec = void 0;
const string_decoder_1 = __nccwpck_require__(1576);
const tr = __importStar(__nccwpck_require__(8159));
/**
* Exec a command.
* Output will be streamed to the live console.
* Returns promise with return code
*
* @param commandLine command to execute (can include additional args). Must be correctly escaped.
* @param args optional arguments for tool. Escaping is handled by the lib.
* @param options optional exec options. See ExecOptions
* @returns Promise<number> exit code
*/
function exec(commandLine, args, options) {
return __awaiter(this, void 0, void 0, function* () {
const commandArgs = tr.argStringToArray(commandLine);
if (commandArgs.length === 0) {
throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
}
// Path to tool to execute should be first arg
const toolPath = commandArgs[0];
args = commandArgs.slice(1).concat(args || []);
const runner = new tr.ToolRunner(toolPath, args, options);
return runner.exec();
});
}
exports.exec = exec;
/**
* Exec a command and get the output.
* Output will be streamed to the live console.
* Returns promise with the exit code and collected stdout and stderr
*
* @param commandLine command to execute (can include additional args). Must be correctly escaped.
* @param args optional arguments for tool. Escaping is handled by the lib.
* @param options optional exec options. See ExecOptions
* @returns Promise<ExecOutput> exit code, stdout, and stderr
*/
function getExecOutput(commandLine, args, options) {
var _a, _b;
return __awaiter(this, void 0, void 0, function* () {
let stdout = '';
let stderr = '';
//Using string decoder covers the case where a mult-byte character is split
const stdoutDecoder = new string_decoder_1.StringDecoder('utf8');
const stderrDecoder = new string_decoder_1.StringDecoder('utf8');
const originalStdoutListener =
(_a =
options === null || options === void 0
? void 0
: options.listeners) === null || _a === void 0
? void 0
: _a.stdout;
const originalStdErrListener =
(_b =
options === null || options === void 0
? void 0
: options.listeners) === null || _b === void 0
? void 0
: _b.stderr;
const stdErrListener = (data) => {
stderr += stderrDecoder.write(data);
if (originalStdErrListener) {
originalStdErrListener(data);
}
};
const stdOutListener = (data) => {
stdout += stdoutDecoder.write(data);
if (originalStdoutListener) {
originalStdoutListener(data);
}
};
const listeners = Object.assign(
Object.assign(
{},
options === null || options === void 0
? void 0
: options.listeners
),
{ stdout: stdOutListener, stderr: stdErrListener }
);
const exitCode = yield exec(
commandLine,
args,
Object.assign(Object.assign({}, options), { listeners })
);
//flush any remaining characters
stdout += stdoutDecoder.end();
stderr += stderrDecoder.end();
return {
exitCode,
stdout,
stderr,
};
});
}
exports.getExecOutput = getExecOutput;
//# sourceMappingURL=exec.js.map
/***/
},
/***/ 8159: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, {
enumerable: true,
get: function () {
return m[k];
},
});
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {
enumerable: true,
value: v,
});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== 'default' && Object.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
Object.defineProperty(exports, '__esModule', { value: true });
exports.argStringToArray = exports.ToolRunner = void 0;
const os = __importStar(__nccwpck_require__(2037));
const events = __importStar(__nccwpck_require__(2361));
const child = __importStar(__nccwpck_require__(8493));
const path = __importStar(__nccwpck_require__(1017));
const io = __importStar(__nccwpck_require__(7436));
const ioUtil = __importStar(__nccwpck_require__(1962));
const timers_1 = __nccwpck_require__(9512);
/* eslint-disable @typescript-eslint/unbound-method */
const IS_WINDOWS = process.platform === 'win32';
/*
* Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
*/
class ToolRunner extends events.EventEmitter {
constructor(toolPath, args, options) {
super();
if (!toolPath) {
throw new Error("Parameter 'toolPath' cannot be null or empty.");
}
this.toolPath = toolPath;
this.args = args || [];
this.options = options || {};
}
_debug(message) {
if (this.options.listeners && this.options.listeners.debug) {
this.options.listeners.debug(message);
}
}
_getCommandString(options, noPrefix) {
const toolPath = this._getSpawnFileName();
const args = this._getSpawnArgs(options);
let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
if (IS_WINDOWS) {
// Windows + cmd file
if (this._isCmdFile()) {
cmd += toolPath;
for (const a of args) {
cmd += ` ${a}`;
}
}
// Windows + verbatim
else if (options.windowsVerbatimArguments) {
cmd += `"${toolPath}"`;
for (const a of args) {
cmd += ` ${a}`;
}
}
// Windows (regular)
else {
cmd += this._windowsQuoteCmdArg(toolPath);
for (const a of args) {
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
}
}
} else {
// OSX/Linux - this can likely be improved with some form of quoting.
// creating processes on Unix is fundamentally different than Windows.
// on Unix, execvp() takes an arg array.
cmd += toolPath;
for (const a of args) {
cmd += ` ${a}`;
}
}
return cmd;
}
_processLineBuffer(data, strBuffer, onLine) {
try {
let s = strBuffer + data.toString();
let n = s.indexOf(os.EOL);
while (n > -1) {
const line = s.substring(0, n);
onLine(line);
// the rest of the string ...
s = s.substring(n + os.EOL.length);
n = s.indexOf(os.EOL);
}
return s;
} catch (err) {
// streaming lines to console is best effort. Don't fail a build.
this._debug(`error processing line. Failed with error ${err}`);
return '';
}
}
_getSpawnFileName() {
if (IS_WINDOWS) {
if (this._isCmdFile()) {
return process.env['COMSPEC'] || 'cmd.exe';
}
}
return this.toolPath;
}
_getSpawnArgs(options) {
if (IS_WINDOWS) {
if (this._isCmdFile()) {
let argline = `/D /S /C "${this._windowsQuoteCmdArg(
this.toolPath
)}`;
for (const a of this.args) {
argline += ' ';
argline += options.windowsVerbatimArguments
? a
: this._windowsQuoteCmdArg(a);
}
argline += '"';
return [argline];
}
}
return this.args;
}
_endsWith(str, end) {
return str.endsWith(end);
}
_isCmdFile() {
const upperToolPath = this.toolPath.toUpperCase();
return (
this._endsWith(upperToolPath, '.CMD') ||
this._endsWith(upperToolPath, '.BAT')
);
}
_windowsQuoteCmdArg(arg) {
// for .exe, apply the normal quoting rules that libuv applies
if (!this._isCmdFile()) {
return this._uvQuoteCmdArg(arg);
}
// otherwise apply quoting rules specific to the cmd.exe command line parser.
// the libuv rules are generic and are not designed specifically for cmd.exe
// command line parser.
//
// for a detailed description of the cmd.exe command line parser, refer to
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
// need quotes for empty arg
if (!arg) {
return '""';
}
// determine whether the arg needs to be quoted
const cmdSpecialChars = [
' ',
'\t',
'&',
'(',
')',
'[',
']',
'{',
'}',
'^',
'=',
';',
'!',
"'",
'+',
',',
'`',
'~',
'|',
'<',
'>',
'"',
];
let needsQuotes = false;
for (const char of arg) {
if (cmdSpecialChars.some((x) => x === char)) {
needsQuotes = true;
break;
}
}
// short-circuit if quotes not needed
if (!needsQuotes) {
return arg;
}
// the following quoting rules are very similar to the rules that by libuv applies.
//
// 1) wrap the string in quotes
//
// 2) double-up quotes - i.e. " => ""
//
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
// doesn't work well with a cmd.exe command line.
//
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
// for example, the command line:
// foo.exe "myarg:""my val"""
// is parsed by a .NET console app into an arg array:
// [ "myarg:\"my val\"" ]
// which is the same end result when applying libuv quoting rules. although the actual
// command line from libuv quoting rules would look like:
// foo.exe "myarg:\"my val\""
//
// 3) double-up slashes that precede a quote,
// e.g. hello \world => "hello \world"
// hello\"world => "hello\\""world"
// hello\\"world => "hello\\\\""world"
// hello world\ => "hello world\\"
//
// technically this is not required for a cmd.exe command line, or the batch argument parser.
// the reasons for including this as a .cmd quoting rule are:
//
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
//
// b) it's what we've been doing previously (by deferring to node default behavior) and we
// haven't heard any complaints about that aspect.
//
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
// by using %%.
//
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
//
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
// to an external program.
//
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
// % can be escaped within a .cmd file.
let reverse = '"';
let quoteHit = true;
for (let i = arg.length; i > 0; i--) {
// walk the string in reverse
reverse += arg[i - 1];
if (quoteHit && arg[i - 1] === '\\') {
reverse += '\\'; // double the slash
} else if (arg[i - 1] === '"') {
quoteHit = true;
reverse += '"'; // double the quote
} else {
quoteHit = false;
}
}
reverse += '"';
return reverse.split('').reverse().join('');
}
_uvQuoteCmdArg(arg) {
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
// is used.
//
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
// pasting copyright notice from Node within this function:
//
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
if (!arg) {
// Need double quotation for empty argument
return '""';
}
if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
// No quotation needed
return arg;
}
if (!arg.includes('"') && !arg.includes('\\')) {
// No embedded double quotes or backslashes, so I can just wrap
// quote marks around the whole thing.
return `"${arg}"`;
}
// Expected input/output:
// input : hello"world
// output: "hello\"world"
// input : hello""world
// output: "hello\"\"world"
// input : hello\world
// output: hello\world
// input : hello\\world
// output: hello\\world
// input : hello\"world
// output: "hello\\\"world"
// input : hello\\"world
// output: "hello\\\\\"world"
// input : hello world\
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
// but it appears the comment is wrong, it should be "hello world\\"
let reverse = '"';
let quoteHit = true;
for (let i = arg.length; i > 0; i--) {
// walk the string in reverse
reverse += arg[i - 1];
if (quoteHit && arg[i - 1] === '\\') {
reverse += '\\';
} else if (arg[i - 1] === '"') {
quoteHit = true;
reverse += '\\';
} else {
quoteHit = false;
}
}
reverse += '"';
return reverse.split('').reverse().join('');
}
_cloneExecOptions(options) {
options = options || {};
const result = {
cwd: options.cwd || process.cwd(),
env: options.env || process.env,
silent: options.silent || false,
windowsVerbatimArguments: options.windowsVerbatimArguments || false,
failOnStdErr: options.failOnStdErr || false,
ignoreReturnCode: options.ignoreReturnCode || false,
delay: options.delay || 10000,
};
result.outStream = options.outStream || process.stdout;
result.errStream = options.errStream || process.stderr;
return result;
}
_getSpawnOptions(options, toolPath) {
options = options || {};
const result = {};
result.cwd = options.cwd;
result.env = options.env;
result['windowsVerbatimArguments'] =
options.windowsVerbatimArguments || this._isCmdFile();
if (options.windowsVerbatimArguments) {
result.argv0 = `"${toolPath}"`;
}
return result;
}
/**
* Exec a tool.
* Output will be streamed to the live console.
* Returns promise with return code
*
* @param tool path to tool to exec
* @param options optional exec options. See ExecOptions
* @returns number
*/
exec() {
return __awaiter(this, void 0, void 0, function* () {
// root the tool path if it is unrooted and contains relative pathing
if (
!ioUtil.isRooted(this.toolPath) &&
(this.toolPath.includes('/') ||
(IS_WINDOWS && this.toolPath.includes('\\')))
) {
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
this.toolPath = path.resolve(
process.cwd(),
this.options.cwd || process.cwd(),
this.toolPath
);
}
// if the tool is only a file name, then resolve it from the PATH
// otherwise verify it exists (add extension on Windows if necessary)
this.toolPath = yield io.which(this.toolPath, true);
return new Promise((resolve, reject) =>
__awaiter(this, void 0, void 0, function* () {
this._debug(`exec tool: ${this.toolPath}`);
this._debug('arguments:');
for (const arg of this.args) {
this._debug(` ${arg}`);
}
const optionsNonNull = this._cloneExecOptions(this.options);
if (!optionsNonNull.silent && optionsNonNull.outStream) {
optionsNonNull.outStream.write(
this._getCommandString(optionsNonNull) + os.EOL
);
}
const state = new ExecState(optionsNonNull, this.toolPath);
state.on('debug', (message) => {
this._debug(message);
});
if (
this.options.cwd &&
!(yield ioUtil.exists(this.options.cwd))
) {
return reject(
new Error(`The cwd: ${this.options.cwd} does not exist!`)
);
}
const fileName = this._getSpawnFileName();
const cp = child.spawn(
fileName,
this._getSpawnArgs(optionsNonNull),
this._getSpawnOptions(this.options, fileName)
);
let stdbuffer = '';
if (cp.stdout) {
cp.stdout.on('data', (data) => {
if (
this.options.listeners &&
this.options.listeners.stdout
) {
this.options.listeners.stdout(data);
}
if (!optionsNonNull.silent && optionsNonNull.outStream) {
optionsNonNull.outStream.write(data);
}
stdbuffer = this._processLineBuffer(
data,
stdbuffer,
(line) => {
if (
this.options.listeners &&
this.options.listeners.stdline
) {
this.options.listeners.stdline(line);
}
}
);
});
}
let errbuffer = '';
if (cp.stderr) {
cp.stderr.on('data', (data) => {
state.processStderr = true;
if (
this.options.listeners &&
this.options.listeners.stderr
) {
this.options.listeners.stderr(data);
}
if (
!optionsNonNull.silent &&
optionsNonNull.errStream &&
optionsNonNull.outStream
) {
const s = optionsNonNull.failOnStdErr
? optionsNonNull.errStream
: optionsNonNull.outStream;
s.write(data);
}
errbuffer = this._processLineBuffer(
data,
errbuffer,
(line) => {
if (
this.options.listeners &&
this.options.listeners.errline
) {
this.options.listeners.errline(line);
}
}
);
});
}
cp.on('error', (err) => {
state.processError = err.message;
state.processExited = true;
state.processClosed = true;
state.CheckComplete();
});
cp.on('exit', (code) => {
state.processExitCode = code;
state.processExited = true;
this._debug(
`Exit code ${code} received from tool '${this.toolPath}'`
);
state.CheckComplete();
});
cp.on('close', (code) => {
state.processExitCode = code;
state.processExited = true;
state.processClosed = true;
this._debug(
`STDIO streams have closed for tool '${this.toolPath}'`
);
state.CheckComplete();
});
state.on('done', (error, exitCode) => {
if (stdbuffer.length > 0) {
this.emit('stdline', stdbuffer);
}
if (errbuffer.length > 0) {
this.emit('errline', errbuffer);
}
cp.removeAllListeners();
if (error) {
reject(error);
} else {
resolve(exitCode);
}
});
if (this.options.input) {
if (!cp.stdin) {
throw new Error('child process missing stdin');
}
cp.stdin.end(this.options.input);
}
})
);
});
}
}
exports.ToolRunner = ToolRunner;
/**
* Convert an arg string to an array of args. Handles escaping
*
* @param argString string of arguments
* @returns string[] array of arguments
*/
function argStringToArray(argString) {
const args = [];
let inQuotes = false;
let escaped = false;
let arg = '';
function append(c) {
// we only escape double quotes.
if (escaped && c !== '"') {
arg += '\\';
}
arg += c;
escaped = false;
}
for (let i = 0; i < argString.length; i++) {
const c = argString.charAt(i);
if (c === '"') {
if (!escaped) {
inQuotes = !inQuotes;
} else {
append(c);
}
continue;
}
if (c === '\\' && escaped) {
append(c);
continue;
}
if (c === '\\' && inQuotes) {
escaped = true;
continue;
}
if (c === ' ' && !inQuotes) {
if (arg.length > 0) {
args.push(arg);
arg = '';
}
continue;
}
append(c);
}
if (arg.length > 0) {
args.push(arg.trim());
}
return args;
}
exports.argStringToArray = argStringToArray;
class ExecState extends events.EventEmitter {
constructor(options, toolPath) {
super();
this.processClosed = false; // tracks whether the process has exited and stdio is closed
this.processError = '';
this.processExitCode = 0;
this.processExited = false; // tracks whether the process has exited
this.processStderr = false; // tracks whether stderr was written to
this.delay = 10000; // 10 seconds
this.done = false;
this.timeout = null;
if (!toolPath) {
throw new Error('toolPath must not be empty');
}
this.options = options;
this.toolPath = toolPath;
if (options.delay) {
this.delay = options.delay;
}
}
CheckComplete() {
if (this.done) {
return;
}
if (this.processClosed) {
this._setResult();
} else if (this.processExited) {
this.timeout = timers_1.setTimeout(
ExecState.HandleTimeout,
this.delay,
this
);
}
}
_debug(message) {
this.emit('debug', message);
}
_setResult() {
// determine whether there is an error
let error;
if (this.processExited) {
if (this.processError) {
error = new Error(
`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`
);
} else if (
this.processExitCode !== 0 &&
!this.options.ignoreReturnCode
) {
error = new Error(
`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`
);
} else if (this.processStderr && this.options.failOnStdErr) {
error = new Error(
`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`
);
}
}
// clear the timeout
if (this.timeout) {
clearTimeout(this.timeout);
this.timeout = null;
}
this.done = true;
this.emit('done', error, this.processExitCode);
}
static HandleTimeout(state) {
if (state.done) {
return;
}
if (!state.processClosed && state.processExited) {
const message = `The STDIO streams did not close within ${
state.delay / 1000
} seconds of the exit event from process '${
state.toolPath
}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
state._debug(message);
}
state._setResult();
}
}
//# sourceMappingURL=toolrunner.js.map
/***/
},
/***/ 1962: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
var _a;
Object.defineProperty(exports, '__esModule', { value: true });
const assert_1 = __nccwpck_require__(9491);
const fs = __nccwpck_require__(7147);
const path = __nccwpck_require__(1017);
(_a = fs.promises),
(exports.chmod = _a.chmod),
(exports.copyFile = _a.copyFile),
(exports.lstat = _a.lstat),
(exports.mkdir = _a.mkdir),
(exports.readdir = _a.readdir),
(exports.readlink = _a.readlink),
(exports.rename = _a.rename),
(exports.rmdir = _a.rmdir),
(exports.stat = _a.stat),
(exports.symlink = _a.symlink),
(exports.unlink = _a.unlink);
exports.IS_WINDOWS = process.platform === 'win32';
function exists(fsPath) {
return __awaiter(this, void 0, void 0, function* () {
try {
yield exports.stat(fsPath);
} catch (err) {
if (err.code === 'ENOENT') {
return false;
}
throw err;
}
return true;
});
}
exports.exists = exists;
function isDirectory(fsPath, useStat = false) {
return __awaiter(this, void 0, void 0, function* () {
const stats = useStat
? yield exports.stat(fsPath)
: yield exports.lstat(fsPath);
return stats.isDirectory();
});
}
exports.isDirectory = isDirectory;
/**
* On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
* \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
*/
function isRooted(p) {
p = normalizeSeparators(p);
if (!p) {
throw new Error('isRooted() parameter "p" cannot be empty');
}
if (exports.IS_WINDOWS) {
return (
p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
); // e.g. C: or C:\hello
}
return p.startsWith('/');
}
exports.isRooted = isRooted;
/**
* Recursively create a directory at `fsPath`.
*
* This implementation is optimistic, meaning it attempts to create the full
* path first, and backs up the path stack from there.
*
* @param fsPath The path to create
* @param maxDepth The maximum recursion depth
* @param depth The current recursion depth
*/
function mkdirP(fsPath, maxDepth = 1000, depth = 1) {
return __awaiter(this, void 0, void 0, function* () {
assert_1.ok(fsPath, 'a path argument must be provided');
fsPath = path.resolve(fsPath);
if (depth >= maxDepth) return exports.mkdir(fsPath);
try {
yield exports.mkdir(fsPath);
return;
} catch (err) {
switch (err.code) {
case 'ENOENT': {
yield mkdirP(path.dirname(fsPath), maxDepth, depth + 1);
yield exports.mkdir(fsPath);
return;
}
default: {
let stats;
try {
stats = yield exports.stat(fsPath);
} catch (err2) {
throw err;
}
if (!stats.isDirectory()) throw err;
}
}
}
});
}
exports.mkdirP = mkdirP;
/**
* Best effort attempt to determine whether a file exists and is executable.
* @param filePath file path to check
* @param extensions additional file extensions to try
* @return if file exists and is executable, returns the file path. otherwise empty string.
*/
function tryGetExecutablePath(filePath, extensions) {
return __awaiter(this, void 0, void 0, function* () {
let stats = undefined;
try {
// test file exists
stats = yield exports.stat(filePath);
} catch (err) {
if (err.code !== 'ENOENT') {
// eslint-disable-next-line no-console
console.log(
`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`
);
}
}
if (stats && stats.isFile()) {
if (exports.IS_WINDOWS) {
// on Windows, test for valid extension
const upperExt = path.extname(filePath).toUpperCase();
if (
extensions.some(
(validExt) => validExt.toUpperCase() === upperExt
)
) {
return filePath;
}
} else {
if (isUnixExecutable(stats)) {
return filePath;
}
}
}
// try each extension
const originalFilePath = filePath;
for (const extension of extensions) {
filePath = originalFilePath + extension;
stats = undefined;
try {
stats = yield exports.stat(filePath);
} catch (err) {
if (err.code !== 'ENOENT') {
// eslint-disable-next-line no-console
console.log(
`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`
);
}
}
if (stats && stats.isFile()) {
if (exports.IS_WINDOWS) {
// preserve the case of the actual file (since an extension was appended)
try {
const directory = path.dirname(filePath);
const upperName = path.basename(filePath).toUpperCase();
for (const actualName of yield exports.readdir(directory)) {
if (upperName === actualName.toUpperCase()) {
filePath = path.join(directory, actualName);
break;
}
}
} catch (err) {
// eslint-disable-next-line no-console
console.log(
`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`
);
}
return filePath;
} else {
if (isUnixExecutable(stats)) {
return filePath;
}
}
}
}
return '';
});
}
exports.tryGetExecutablePath = tryGetExecutablePath;
function normalizeSeparators(p) {
p = p || '';
if (exports.IS_WINDOWS) {
// convert slashes on Windows
p = p.replace(/\//g, '\\');
// remove redundant slashes
return p.replace(/\\\\+/g, '\\');
}
// remove redundant slashes
return p.replace(/\/\/+/g, '/');
}
// on Mac/Linux, test the execute bit
// R W X R W X R W X
// 256 128 64 32 16 8 4 2 1
function isUnixExecutable(stats) {
return (
(stats.mode & 1) > 0 ||
((stats.mode & 8) > 0 && stats.gid === process.getgid()) ||
((stats.mode & 64) > 0 && stats.uid === process.getuid())
);
}
//# sourceMappingURL=io-util.js.map
/***/
},
/***/ 7436: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
Object.defineProperty(exports, '__esModule', { value: true });
const childProcess = __nccwpck_require__(8493);
const path = __nccwpck_require__(1017);
const util_1 = __nccwpck_require__(3837);
const ioUtil = __nccwpck_require__(1962);
const exec = util_1.promisify(childProcess.exec);
/**
* Copies a file or folder.
* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
*
* @param source source path
* @param dest destination path
* @param options optional. See CopyOptions.
*/
function cp(source, dest, options = {}) {
return __awaiter(this, void 0, void 0, function* () {
const { force, recursive } = readCopyOptions(options);
const destStat = (yield ioUtil.exists(dest))
? yield ioUtil.stat(dest)
: null;
// Dest is an existing file, but not forcing
if (destStat && destStat.isFile() && !force) {
return;
}
// If dest is an existing directory, should copy inside.
const newDest =
destStat && destStat.isDirectory()
? path.join(dest, path.basename(source))
: dest;
if (!(yield ioUtil.exists(source))) {
throw new Error(`no such file or directory: ${source}`);
}
const sourceStat = yield ioUtil.stat(source);
if (sourceStat.isDirectory()) {
if (!recursive) {
throw new Error(
`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`
);
} else {
yield cpDirRecursive(source, newDest, 0, force);
}
} else {
if (path.relative(source, newDest) === '') {
// a file cannot be copied to itself
throw new Error(`'${newDest}' and '${source}' are the same file`);
}
yield copyFile(source, newDest, force);
}
});
}
exports.cp = cp;
/**
* Moves a path.
*
* @param source source path
* @param dest destination path
* @param options optional. See MoveOptions.
*/
function mv(source, dest, options = {}) {
return __awaiter(this, void 0, void 0, function* () {
if (yield ioUtil.exists(dest)) {
let destExists = true;
if (yield ioUtil.isDirectory(dest)) {
// If dest is directory copy src into dest
dest = path.join(dest, path.basename(source));
destExists = yield ioUtil.exists(dest);
}
if (destExists) {
if (options.force == null || options.force) {
yield rmRF(dest);
} else {
throw new Error('Destination already exists');
}
}
}
yield mkdirP(path.dirname(dest));
yield ioUtil.rename(source, dest);
});
}
exports.mv = mv;
/**
* Remove a path recursively with force
*
* @param inputPath path to remove
*/
function rmRF(inputPath) {
return __awaiter(this, void 0, void 0, function* () {
if (ioUtil.IS_WINDOWS) {
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
try {
if (yield ioUtil.isDirectory(inputPath, true)) {
yield exec(`rd /s /q "${inputPath}"`);
} else {
yield exec(`del /f /a "${inputPath}"`);
}
} catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT') throw err;
}
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
try {
yield ioUtil.unlink(inputPath);
} catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT') throw err;
}
} else {
let isDir = false;
try {
isDir = yield ioUtil.isDirectory(inputPath);
} catch (err) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if (err.code !== 'ENOENT') throw err;
return;
}
if (isDir) {
yield exec(`rm -rf "${inputPath}"`);
} else {
yield ioUtil.unlink(inputPath);
}
}
});
}
exports.rmRF = rmRF;
/**
* Make a directory. Creates the full path with folders in between
* Will throw if it fails
*
* @param fsPath path to create
* @returns Promise<void>
*/
function mkdirP(fsPath) {
return __awaiter(this, void 0, void 0, function* () {
yield ioUtil.mkdirP(fsPath);
});
}
exports.mkdirP = mkdirP;
/**
* Returns path of a tool had the tool actually been invoked. Resolves via paths.
* If you check and the tool does not exist, it will throw.
*
* @param tool name of the tool
* @param check whether to check if tool exists
* @returns Promise<string> path to tool
*/
function which(tool, check) {
return __awaiter(this, void 0, void 0, function* () {
if (!tool) {
throw new Error("parameter 'tool' is required");
}
// recursive when check=true
if (check) {
const result = yield which(tool, false);
if (!result) {
if (ioUtil.IS_WINDOWS) {
throw new Error(
`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`
);
} else {
throw new Error(
`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`
);
}
}
}
try {
// build the list of extensions to try
const extensions = [];
if (ioUtil.IS_WINDOWS && process.env.PATHEXT) {
for (const extension of process.env.PATHEXT.split(
path.delimiter
)) {
if (extension) {
extensions.push(extension);
}
}
}
// if it's rooted, return it if exists. otherwise return empty.
if (ioUtil.isRooted(tool)) {
const filePath = yield ioUtil.tryGetExecutablePath(
tool,
extensions
);
if (filePath) {
return filePath;
}
return '';
}
// if any path separators, return empty
if (
tool.includes('/') ||
(ioUtil.IS_WINDOWS && tool.includes('\\'))
) {
return '';
}
// build the list of directories
//
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
// it feels like we should not do this. Checking the current directory seems like more of a use
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
// across platforms.
const directories = [];
if (process.env.PATH) {
for (const p of process.env.PATH.split(path.delimiter)) {
if (p) {
directories.push(p);
}
}
}
// return the first match
for (const directory of directories) {
const filePath = yield ioUtil.tryGetExecutablePath(
directory + path.sep + tool,
extensions
);
if (filePath) {
return filePath;
}
}
return '';
} catch (err) {
throw new Error(`which failed with message ${err.message}`);
}
});
}
exports.which = which;
function readCopyOptions(options) {
const force = options.force == null ? true : options.force;
const recursive = Boolean(options.recursive);
return { force, recursive };
}
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
return __awaiter(this, void 0, void 0, function* () {
// Ensure there is not a run away recursive copy
if (currentDepth >= 255) return;
currentDepth++;
yield mkdirP(destDir);
const files = yield ioUtil.readdir(sourceDir);
for (const fileName of files) {
const srcFile = `${sourceDir}/${fileName}`;
const destFile = `${destDir}/${fileName}`;
const srcFileStat = yield ioUtil.lstat(srcFile);
if (srcFileStat.isDirectory()) {
// Recurse
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
} else {
yield copyFile(srcFile, destFile, force);
}
}
// Change the mode for the newly created directory
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
});
}
// Buffered file copy
function copyFile(srcFile, destFile, force) {
return __awaiter(this, void 0, void 0, function* () {
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
// unlink/re-link it
try {
yield ioUtil.lstat(destFile);
yield ioUtil.unlink(destFile);
} catch (e) {
// Try to override file permission
if (e.code === 'EPERM') {
yield ioUtil.chmod(destFile, '0666');
yield ioUtil.unlink(destFile);
}
// other errors = it doesn't exist, no work to do
}
// Copy over symlink
const symlinkFull = yield ioUtil.readlink(srcFile);
yield ioUtil.symlink(
symlinkFull,
destFile,
ioUtil.IS_WINDOWS ? 'junction' : null
);
} else if (!(yield ioUtil.exists(destFile)) || force) {
yield ioUtil.copyFile(srcFile, destFile);
}
});
}
//# sourceMappingURL=io.js.map
/***/
},
/***/ 7240: /***/ (module) => {
'use strict';
module.exports = bail;
function bail(err) {
if (err) {
throw err;
}
}
/***/
},
/***/ 8431: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
/*
* EJS Embedded JavaScript templates
* Copyright 2112 Matthew Eernisse (mde@fleegix.org)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
* @file Embedded JavaScript templating engine. {@link http://ejs.co}
* @author Matthew Eernisse <mde@fleegix.org>
* @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
* @project EJS
* @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
*/
/**
* EJS internal functions.
*
* Technically this "module" lies in the same file as {@link module:ejs}, for
* the sake of organization all the private functions re grouped into this
* module.
*
* @module ejs-internal
* @private
*/
/**
* Embedded JavaScript templating engine.
*
* @module ejs
* @public
*/
var fs = __nccwpck_require__(7147);
var path = __nccwpck_require__(1017);
var utils = __nccwpck_require__(356);
var scopeOptionWarned = false;
/** @type {string} */
var _VERSION_STRING = __nccwpck_require__(3558) /* .version */.i8;
var _DEFAULT_OPEN_DELIMITER = '<';
var _DEFAULT_CLOSE_DELIMITER = '>';
var _DEFAULT_DELIMITER = '%';
var _DEFAULT_LOCALS_NAME = 'locals';
var _NAME = 'ejs';
var _REGEX_STRING = '(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)';
var _OPTS_PASSABLE_WITH_DATA = [
'delimiter',
'scope',
'context',
'debug',
'compileDebug',
'client',
'_with',
'rmWhitespace',
'strict',
'filename',
'async',
];
// We don't allow 'cache' option to be passed in the data obj for
// the normal `render` call, but this is where Express 2 & 3 put it
// so we make an exception for `renderFile`
var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat(
'cache'
);
var _BOM = /^\uFEFF/;
/**
* EJS template function cache. This can be a LRU object from lru-cache NPM
* module. By default, it is {@link module:utils.cache}, a simple in-process
* cache that grows continuously.
*
* @type {Cache}
*/
exports.cache = utils.cache;
/**
* Custom file loader. Useful for template preprocessing or restricting access
* to a certain part of the filesystem.
*
* @type {fileLoader}
*/
exports.fileLoader = fs.readFileSync;
/**
* Name of the object containing the locals.
*
* This variable is overridden by {@link Options}`.localsName` if it is not
* `undefined`.
*
* @type {String}
* @public
*/
exports.localsName = _DEFAULT_LOCALS_NAME;
/**
* Promise implementation -- defaults to the native implementation if available
* This is mostly just for testability
*
* @type {PromiseConstructorLike}
* @public
*/
exports.promiseImpl = new Function('return this;')().Promise;
/**
* Get the path to the included file from the parent file path and the
* specified path.
*
* @param {String} name specified path
* @param {String} filename parent file path
* @param {Boolean} [isDir=false] whether the parent file path is a directory
* @return {String}
*/
exports.resolveInclude = function (name, filename, isDir) {
var dirname = path.dirname;
var extname = path.extname;
var resolve = path.resolve;
var includePath = resolve(isDir ? filename : dirname(filename), name);
var ext = extname(name);
if (!ext) {
includePath += '.ejs';
}
return includePath;
};
/**
* Try to resolve file path on multiple directories
*
* @param {String} name specified path
* @param {Array<String>} paths list of possible parent directory paths
* @return {String}
*/
function resolvePaths(name, paths) {
var filePath;
if (
paths.some(function (v) {
filePath = exports.resolveInclude(name, v, true);
return fs.existsSync(filePath);
})
) {
return filePath;
}
}
/**
* Get the path to the included file by Options
*
* @param {String} path specified path
* @param {Options} options compilation options
* @return {String}
*/
function getIncludePath(path, options) {
var includePath;
var filePath;
var views = options.views;
var match = /^[A-Za-z]+:\\|^\//.exec(path);
// Abs path
if (match && match.length) {
path = path.replace(/^\/*/, '');
if (Array.isArray(options.root)) {
includePath = resolvePaths(path, options.root);
} else {
includePath = exports.resolveInclude(
path,
options.root || '/',
true
);
}
}
// Relative paths
else {
// Look relative to a passed filename first
if (options.filename) {
filePath = exports.resolveInclude(path, options.filename);
if (fs.existsSync(filePath)) {
includePath = filePath;
}
}
// Then look in any views directories
if (!includePath && Array.isArray(views)) {
includePath = resolvePaths(path, views);
}
if (!includePath && typeof options.includer !== 'function') {
throw new Error(
'Could not find the include file "' +
options.escapeFunction(path) +
'"'
);
}
}
return includePath;
}
/**
* Get the template from a string or a file, either compiled on-the-fly or
* read from cache (if enabled), and cache the template if needed.
*
* If `template` is not set, the file specified in `options.filename` will be
* read.
*
* If `options.cache` is true, this function reads the file from
* `options.filename` so it must be set prior to calling this function.
*
* @memberof module:ejs-internal
* @param {Options} options compilation options
* @param {String} [template] template source
* @return {(TemplateFunction|ClientFunction)}
* Depending on the value of `options.client`, either type might be returned.
* @static
*/
function handleCache(options, template) {
var func;
var filename = options.filename;
var hasTemplate = arguments.length > 1;
if (options.cache) {
if (!filename) {
throw new Error('cache option requires a filename');
}
func = exports.cache.get(filename);
if (func) {
return func;
}
if (!hasTemplate) {
template = fileLoader(filename).toString().replace(_BOM, '');
}
} else if (!hasTemplate) {
// istanbul ignore if: should not happen at all
if (!filename) {
throw new Error(
'Internal EJS error: no file name or template ' + 'provided'
);
}
template = fileLoader(filename).toString().replace(_BOM, '');
}
func = exports.compile(template, options);
if (options.cache) {
exports.cache.set(filename, func);
}
return func;
}
/**
* Try calling handleCache with the given options and data and call the
* callback with the result. If an error occurs, call the callback with
* the error. Used by renderFile().
*
* @memberof module:ejs-internal
* @param {Options} options compilation options
* @param {Object} data template data
* @param {RenderFileCallback} cb callback
* @static
*/
function tryHandleCache(options, data, cb) {
var result;
if (!cb) {
if (typeof exports.promiseImpl == 'function') {
return new exports.promiseImpl(function (resolve, reject) {
try {
result = handleCache(options)(data);
resolve(result);
} catch (err) {
reject(err);
}
});
} else {
throw new Error('Please provide a callback function');
}
} else {
try {
result = handleCache(options)(data);
} catch (err) {
return cb(err);
}
cb(null, result);
}
}
/**
* fileLoader is independent
*
* @param {String} filePath ejs file path.
* @return {String} The contents of the specified file.
* @static
*/
function fileLoader(filePath) {
return exports.fileLoader(filePath);
}
/**
* Get the template function.
*
* If `options.cache` is `true`, then the template is cached.
*
* @memberof module:ejs-internal
* @param {String} path path for the specified file
* @param {Options} options compilation options
* @return {(TemplateFunction|ClientFunction)}
* Depending on the value of `options.client`, either type might be returned
* @static
*/
function includeFile(path, options) {
var opts = utils.shallowCopy({}, options);
opts.filename = getIncludePath(path, opts);
if (typeof options.includer === 'function') {
var includerResult = options.includer(path, opts.filename);
if (includerResult) {
if (includerResult.filename) {
opts.filename = includerResult.filename;
}
if (includerResult.template) {
return handleCache(opts, includerResult.template);
}
}
}
return handleCache(opts);
}
/**
* Re-throw the given `err` in context to the `str` of ejs, `filename`, and
* `lineno`.
*
* @implements {RethrowCallback}
* @memberof module:ejs-internal
* @param {Error} err Error object
* @param {String} str EJS source
* @param {String} flnm file name of the EJS file
* @param {Number} lineno line number of the error
* @param {EscapeCallback} esc
* @static
*/
function rethrow(err, str, flnm, lineno, esc) {
var lines = str.split('\n');
var start = Math.max(lineno - 3, 0);
var end = Math.min(lines.length, lineno + 3);
var filename = esc(flnm);
// Error context
var context = lines
.slice(start, end)
.map(function (line, i) {
var curr = i + start + 1;
return (curr == lineno ? ' >> ' : ' ') + curr + '| ' + line;
})
.join('\n');
// Alter exception message
err.path = filename;
err.message =
(filename || 'ejs') +
':' +
lineno +
'\n' +
context +
'\n\n' +
err.message;
throw err;
}
function stripSemi(str) {
return str.replace(/;(\s*$)/, '$1');
}
/**
* Compile the given `str` of ejs into a template function.
*
* @param {String} template EJS template
*
* @param {Options} [opts] compilation options
*
* @return {(TemplateFunction|ClientFunction)}
* Depending on the value of `opts.client`, either type might be returned.
* Note that the return type of the function also depends on the value of `opts.async`.
* @public
*/
exports.compile = function compile(template, opts) {
var templ;
// v1 compat
// 'scope' is 'context'
// FIXME: Remove this in a future version
if (opts && opts.scope) {
if (!scopeOptionWarned) {
console.warn(
'`scope` option is deprecated and will be removed in EJS 3'
);
scopeOptionWarned = true;
}
if (!opts.context) {
opts.context = opts.scope;
}
delete opts.scope;
}
templ = new Template(template, opts);
return templ.compile();
};
/**
* Render the given `template` of ejs.
*
* If you would like to include options but not data, you need to explicitly
* call this function with `data` being an empty object or `null`.
*
* @param {String} template EJS template
* @param {Object} [data={}] template data
* @param {Options} [opts={}] compilation and rendering options
* @return {(String|Promise<String>)}
* Return value type depends on `opts.async`.
* @public
*/
exports.render = function (template, d, o) {
var data = d || {};
var opts = o || {};
// No options object -- if there are optiony names
// in the data, copy them to options
if (arguments.length == 2) {
utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
}
return handleCache(opts, template)(data);
};
/**
* Render an EJS file at the given `path` and callback `cb(err, str)`.
*
* If you would like to include options but not data, you need to explicitly
* call this function with `data` being an empty object or `null`.
*
* @param {String} path path to the EJS file
* @param {Object} [data={}] template data
* @param {Options} [opts={}] compilation and rendering options
* @param {RenderFileCallback} cb callback
* @public
*/
exports.renderFile = function () {
var args = Array.prototype.slice.call(arguments);
var filename = args.shift();
var cb;
var opts = { filename: filename };
var data;
var viewOpts;
// Do we have a callback?
if (typeof arguments[arguments.length - 1] == 'function') {
cb = args.pop();
}
// Do we have data/opts?
if (args.length) {
// Should always have data obj
data = args.shift();
// Normal passed opts (data obj + opts obj)
if (args.length) {
// Use shallowCopy so we don't pollute passed in opts obj with new vals
utils.shallowCopy(opts, args.pop());
}
// Special casing for Express (settings + opts-in-data)
else {
// Express 3 and 4
if (data.settings) {
// Pull a few things from known locations
if (data.settings.views) {
opts.views = data.settings.views;
}
if (data.settings['view cache']) {
opts.cache = true;
}
// Undocumented after Express 2, but still usable, esp. for
// items that are unsafe to be passed along with data, like `root`
viewOpts = data.settings['view options'];
if (viewOpts) {
utils.shallowCopy(opts, viewOpts);
}
}
// Express 2 and lower, values set in app.locals, or people who just
// want to pass options in their data. NOTE: These values will override
// anything previously set in settings or settings['view options']
utils.shallowCopyFromList(
opts,
data,
_OPTS_PASSABLE_WITH_DATA_EXPRESS
);
}
opts.filename = filename;
} else {
data = {};
}
return tryHandleCache(opts, data, cb);
};
/**
* Clear intermediate JavaScript cache. Calls {@link Cache#reset}.
* @public
*/
/**
* EJS template class
* @public
*/
exports.Template = Template;
exports.clearCache = function () {
exports.cache.reset();
};
function Template(text, opts) {
opts = opts || {};
var options = {};
this.templateText = text;
/** @type {string | null} */
this.mode = null;
this.truncate = false;
this.currentLine = 1;
this.source = '';
options.client = opts.client || false;
options.escapeFunction =
opts.escape || opts.escapeFunction || utils.escapeXML;
options.compileDebug = opts.compileDebug !== false;
options.debug = !!opts.debug;
options.filename = opts.filename;
options.openDelimiter =
opts.openDelimiter ||
exports.openDelimiter ||
_DEFAULT_OPEN_DELIMITER;
options.closeDelimiter =
opts.closeDelimiter ||
exports.closeDelimiter ||
_DEFAULT_CLOSE_DELIMITER;
options.delimiter =
opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
options.strict = opts.strict || false;
options.context = opts.context;
options.cache = opts.cache || false;
options.rmWhitespace = opts.rmWhitespace;
options.root = opts.root;
options.includer = opts.includer;
options.outputFunctionName = opts.outputFunctionName;
options.localsName =
opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
options.views = opts.views;
options.async = opts.async;
options.destructuredLocals = opts.destructuredLocals;
options.legacyInclude =
typeof opts.legacyInclude != 'undefined'
? !!opts.legacyInclude
: true;
if (options.strict) {
options._with = false;
} else {
options._with = typeof opts._with != 'undefined' ? opts._with : true;
}
this.opts = options;
this.regex = this.createRegex();
}
Template.modes = {
EVAL: 'eval',
ESCAPED: 'escaped',
RAW: 'raw',
COMMENT: 'comment',
LITERAL: 'literal',
};
Template.prototype = {
createRegex: function () {
var str = _REGEX_STRING;
var delim = utils.escapeRegExpChars(this.opts.delimiter);
var open = utils.escapeRegExpChars(this.opts.openDelimiter);
var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
str = str
.replace(/%/g, delim)
.replace(/</g, open)
.replace(/>/g, close);
return new RegExp(str);
},
compile: function () {
/** @type {string} */
var src;
/** @type {ClientFunction} */
var fn;
var opts = this.opts;
var prepended = '';
var appended = '';
/** @type {EscapeCallback} */
var escapeFn = opts.escapeFunction;
/** @type {FunctionConstructor} */
var ctor;
/** @type {string} */
var sanitizedFilename = opts.filename
? JSON.stringify(opts.filename)
: 'undefined';
if (!this.source) {
this.generateSource();
prepended +=
' var __output = "";\n' +
' function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
if (opts.outputFunctionName) {
prepended +=
' var ' + opts.outputFunctionName + ' = __append;' + '\n';
}
if (opts.destructuredLocals && opts.destructuredLocals.length) {
var destructuring =
' var __locals = (' + opts.localsName + ' || {}),\n';
for (var i = 0; i < opts.destructuredLocals.length; i++) {
var name = opts.destructuredLocals[i];
if (i > 0) {
destructuring += ',\n ';
}
destructuring += name + ' = __locals.' + name;
}
prepended += destructuring + ';\n';
}
if (opts._with !== false) {
prepended += ' with (' + opts.localsName + ' || {}) {' + '\n';
appended += ' }' + '\n';
}
appended += ' return __output;' + '\n';
this.source = prepended + this.source + appended;
}
if (opts.compileDebug) {
src =
'var __line = 1' +
'\n' +
' , __lines = ' +
JSON.stringify(this.templateText) +
'\n' +
' , __filename = ' +
sanitizedFilename +
';' +
'\n' +
'try {' +
'\n' +
this.source +
'} catch (e) {' +
'\n' +
' rethrow(e, __lines, __filename, __line, escapeFn);' +
'\n' +
'}' +
'\n';
} else {
src = this.source;
}
if (opts.client) {
src =
'escapeFn = escapeFn || ' +
escapeFn.toString() +
';' +
'\n' +
src;
if (opts.compileDebug) {
src =
'rethrow = rethrow || ' + rethrow.toString() + ';' + '\n' + src;
}
}
if (opts.strict) {
src = '"use strict";\n' + src;
}
if (opts.debug) {
console.log(src);
}
if (opts.compileDebug && opts.filename) {
src = src + '\n' + '//# sourceURL=' + sanitizedFilename + '\n';
}
try {
if (opts.async) {
// Have to use generated function for this, since in envs without support,
// it breaks in parsing
try {
ctor = new Function(
'return (async function(){}).constructor;'
)();
} catch (e) {
if (e instanceof SyntaxError) {
throw new Error(
'This environment does not support async/await'
);
} else {
throw e;
}
}
} else {
ctor = Function;
}
fn = new ctor(
opts.localsName + ', escapeFn, include, rethrow',
src
);
} catch (e) {
// istanbul ignore else
if (e instanceof SyntaxError) {
if (opts.filename) {
e.message += ' in ' + opts.filename;
}
e.message += ' while compiling ejs\n\n';
e.message +=
'If the above error is not helpful, you may want to try EJS-Lint:\n';
e.message += 'https://github.com/RyanZim/EJS-Lint';
if (!opts.async) {
e.message += '\n';
e.message +=
'Or, if you meant to create an async function, pass `async: true` as an option.';
}
}
throw e;
}
// Return a callable function which will execute the function
// created by the source-code, with the passed data as locals
// Adds a local `include` function which allows full recursive include
var returnedFn = opts.client
? fn
: function anonymous(data) {
var include = function (path, includeData) {
var d = utils.shallowCopy({}, data);
if (includeData) {
d = utils.shallowCopy(d, includeData);
}
return includeFile(path, opts)(d);
};
return fn.apply(opts.context, [
data || {},
escapeFn,
include,
rethrow,
]);
};
if (opts.filename && typeof Object.defineProperty === 'function') {
var filename = opts.filename;
var basename = path.basename(filename, path.extname(filename));
try {
Object.defineProperty(returnedFn, 'name', {
value: basename,
writable: false,
enumerable: false,
configurable: true,
});
} catch (e) {
/* ignore */
}
}
return returnedFn;
},
generateSource: function () {
var opts = this.opts;
if (opts.rmWhitespace) {
// Have to use two separate replace here as `^` and `$` operators don't
// work well with `\r` and empty lines don't work well with the `m` flag.
this.templateText = this.templateText
.replace(/[\r\n]+/g, '\n')
.replace(/^\s+|\s+$/gm, '');
}
// Slurp spaces and tabs before <%_ and after _%>
this.templateText = this.templateText
.replace(/[ \t]*<%_/gm, '<%_')
.replace(/_%>[ \t]*/gm, '_%>');
var self = this;
var matches = this.parseTemplateText();
var d = this.opts.delimiter;
var o = this.opts.openDelimiter;
var c = this.opts.closeDelimiter;
if (matches && matches.length) {
matches.forEach(function (line, index) {
var closing;
// If this is an opening tag, check for closing tags
// FIXME: May end up with some false positives here
// Better to store modes as k/v with openDelimiter + delimiter as key
// Then this can simply check against the map
if (
line.indexOf(o + d) === 0 && // If it is a tag
line.indexOf(o + d + d) !== 0
) {
// and is not escaped
closing = matches[index + 2];
if (
!(
closing == d + c ||
closing == '-' + d + c ||
closing == '_' + d + c
)
) {
throw new Error(
'Could not find matching close tag for "' + line + '".'
);
}
}
self.scanLine(line);
});
}
},
parseTemplateText: function () {
var str = this.templateText;
var pat = this.regex;
var result = pat.exec(str);
var arr = [];
var firstPos;
while (result) {
firstPos = result.index;
if (firstPos !== 0) {
arr.push(str.substring(0, firstPos));
str = str.slice(firstPos);
}
arr.push(result[0]);
str = str.slice(result[0].length);
result = pat.exec(str);
}
if (str) {
arr.push(str);
}
return arr;
},
_addOutput: function (line) {
if (this.truncate) {
// Only replace single leading linebreak in the line after
// -%> tag -- this is the single, trailing linebreak
// after the tag that the truncation mode replaces
// Handle Win / Unix / old Mac linebreaks -- do the \r\n
// combo first in the regex-or
line = line.replace(/^(?:\r\n|\r|\n)/, '');
this.truncate = false;
}
if (!line) {
return line;
}
// Preserve literal slashes
line = line.replace(/\\/g, '\\\\');
// Convert linebreaks
line = line.replace(/\n/g, '\\n');
line = line.replace(/\r/g, '\\r');
// Escape double-quotes
// - this will be the delimiter during execution
line = line.replace(/"/g, '\\"');
this.source += ' ; __append("' + line + '")' + '\n';
},
scanLine: function (line) {
var self = this;
var d = this.opts.delimiter;
var o = this.opts.openDelimiter;
var c = this.opts.closeDelimiter;
var newLineCount = 0;
newLineCount = line.split('\n').length - 1;
switch (line) {
case o + d:
case o + d + '_':
this.mode = Template.modes.EVAL;
break;
case o + d + '=':
this.mode = Template.modes.ESCAPED;
break;
case o + d + '-':
this.mode = Template.modes.RAW;
break;
case o + d + '#':
this.mode = Template.modes.COMMENT;
break;
case o + d + d:
this.mode = Template.modes.LITERAL;
this.source +=
' ; __append("' +
line.replace(o + d + d, o + d) +
'")' +
'\n';
break;
case d + d + c:
this.mode = Template.modes.LITERAL;
this.source +=
' ; __append("' +
line.replace(d + d + c, d + c) +
'")' +
'\n';
break;
case d + c:
case '-' + d + c:
case '_' + d + c:
if (this.mode == Template.modes.LITERAL) {
this._addOutput(line);
}
this.mode = null;
this.truncate =
line.indexOf('-') === 0 || line.indexOf('_') === 0;
break;
default:
// In script mode, depends on type of tag
if (this.mode) {
// If '//' is found without a line break, add a line break.
switch (this.mode) {
case Template.modes.EVAL:
case Template.modes.ESCAPED:
case Template.modes.RAW:
if (line.lastIndexOf('//') > line.lastIndexOf('\n')) {
line += '\n';
}
}
switch (this.mode) {
// Just executing code
case Template.modes.EVAL:
this.source += ' ; ' + line + '\n';
break;
// Exec, esc, and output
case Template.modes.ESCAPED:
this.source +=
' ; __append(escapeFn(' +
stripSemi(line) +
'))' +
'\n';
break;
// Exec and output
case Template.modes.RAW:
this.source +=
' ; __append(' + stripSemi(line) + ')' + '\n';
break;
case Template.modes.COMMENT:
// Do nothing
break;
// Literal <%% mode, append as raw output
case Template.modes.LITERAL:
this._addOutput(line);
break;
}
}
// In string mode, just add the output
else {
this._addOutput(line);
}
}
if (self.opts.compileDebug && newLineCount) {
this.currentLine += newLineCount;
this.source += ' ; __line = ' + this.currentLine + '\n';
}
},
};
/**
* Escape characters reserved in XML.
*
* This is simply an export of {@link module:utils.escapeXML}.
*
* If `markup` is `undefined` or `null`, the empty string is returned.
*
* @param {String} markup Input string
* @return {String} Escaped string
* @public
* @func
* */
exports.escapeXML = utils.escapeXML;
/**
* Express.js support.
*
* This is an alias for {@link module:ejs.renderFile}, in order to support
* Express.js out-of-the-box.
*
* @func
*/
exports.__express = exports.renderFile;
/**
* Version of EJS.
*
* @readonly
* @type {String}
* @public
*/
exports.VERSION = _VERSION_STRING;
/**
* Name for detection of EJS.
*
* @readonly
* @type {String}
* @public
*/
exports.name = _NAME;
/* istanbul ignore if */
if (typeof window != 'undefined') {
window.ejs = exports;
}
/***/
},
/***/ 356: /***/ (__unused_webpack_module, exports) => {
'use strict';
/*
* EJS Embedded JavaScript templates
* Copyright 2112 Matthew Eernisse (mde@fleegix.org)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
* Private utility functions
* @module utils
* @private
*/
var regExpChars = /[|\\{}()[\]^$+*?.]/g;
/**
* Escape characters reserved in regular expressions.
*
* If `string` is `undefined` or `null`, the empty string is returned.
*
* @param {String} string Input string
* @return {String} Escaped string
* @static
* @private
*/
exports.escapeRegExpChars = function (string) {
// istanbul ignore if
if (!string) {
return '';
}
return String(string).replace(regExpChars, '\\$&');
};
var _ENCODE_HTML_RULES = {
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&#34;',
"'": '&#39;',
};
var _MATCH_HTML = /[&<>'"]/g;
function encode_char(c) {
return _ENCODE_HTML_RULES[c] || c;
}
/**
* Stringified version of constants used by {@link module:utils.escapeXML}.
*
* It is used in the process of generating {@link ClientFunction}s.
*
* @readonly
* @type {String}
*/
var escapeFuncStr =
'var _ENCODE_HTML_RULES = {\n' +
' "&": "&amp;"\n' +
' , "<": "&lt;"\n' +
' , ">": "&gt;"\n' +
' , \'"\': "&#34;"\n' +
' , "\'": "&#39;"\n' +
' }\n' +
' , _MATCH_HTML = /[&<>\'"]/g;\n' +
'function encode_char(c) {\n' +
' return _ENCODE_HTML_RULES[c] || c;\n' +
'};\n';
/**
* Escape characters reserved in XML.
*
* If `markup` is `undefined` or `null`, the empty string is returned.
*
* @implements {EscapeCallback}
* @param {String} markup Input string
* @return {String} Escaped string
* @static
* @private
*/
exports.escapeXML = function (markup) {
return markup == undefined
? ''
: String(markup).replace(_MATCH_HTML, encode_char);
};
exports.escapeXML.toString = function () {
return Function.prototype.toString.call(this) + ';\n' + escapeFuncStr;
};
/**
* Naive copy of properties from one object to another.
* Does not recurse into non-scalar properties
* Does not check to see if the property has a value before copying
*
* @param {Object} to Destination object
* @param {Object} from Source object
* @return {Object} Destination object
* @static
* @private
*/
exports.shallowCopy = function (to, from) {
from = from || {};
for (var p in from) {
to[p] = from[p];
}
return to;
};
/**
* Naive copy of a list of key names, from one object to another.
* Only copies property if it is actually defined
* Does not recurse into non-scalar properties
*
* @param {Object} to Destination object
* @param {Object} from Source object
* @param {Array} list List of properties to copy
* @return {Object} Destination object
* @static
* @private
*/
exports.shallowCopyFromList = function (to, from, list) {
for (var i = 0; i < list.length; i++) {
var p = list[i];
if (typeof from[p] != 'undefined') {
to[p] = from[p];
}
}
return to;
};
/**
* Simple in-process cache implementation. Does not implement limits of any
* sort.
*
* @implements {Cache}
* @static
* @private
*/
exports.cache = {
_data: {},
set: function (key, val) {
this._data[key] = val;
},
get: function (key) {
return this._data[key];
},
remove: function (key) {
delete this._data[key];
},
reset: function () {
this._data = {};
},
};
/**
* Transforms hyphen case variable into camel case.
*
* @param {String} string Hyphen case string
* @return {String} Camel case string
* @static
* @private
*/
exports.hyphenToCamel = function (str) {
return str.replace(/-[a-z]/g, function (match) {
return match[1].toUpperCase();
});
};
/***/
},
/***/ 8171: /***/ (module) => {
'use strict';
var hasOwn = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var defineProperty = Object.defineProperty;
var gOPD = Object.getOwnPropertyDescriptor;
var isArray = function isArray(arr) {
if (typeof Array.isArray === 'function') {
return Array.isArray(arr);
}
return toStr.call(arr) === '[object Array]';
};
var isPlainObject = function isPlainObject(obj) {
if (!obj || toStr.call(obj) !== '[object Object]') {
return false;
}
var hasOwnConstructor = hasOwn.call(obj, 'constructor');
var hasIsPrototypeOf =
obj.constructor &&
obj.constructor.prototype &&
hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
// Not own constructor property must be Object
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for (key in obj) {
/**/
}
return typeof key === 'undefined' || hasOwn.call(obj, key);
};
// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
var setProperty = function setProperty(target, options) {
if (defineProperty && options.name === '__proto__') {
defineProperty(target, options.name, {
enumerable: true,
configurable: true,
value: options.newValue,
writable: true,
});
} else {
target[options.name] = options.newValue;
}
};
// Return undefined instead of __proto__ if '__proto__' is not an own property
var getProperty = function getProperty(obj, name) {
if (name === '__proto__') {
if (!hasOwn.call(obj, name)) {
return void 0;
} else if (gOPD) {
// In early versions of node, obj['__proto__'] is buggy when obj has
// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
return gOPD(obj, name).value;
}
}
return obj[name];
};
module.exports = function extend() {
var options, name, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
var length = arguments.length;
var deep = false;
// Handle a deep copy situation
if (typeof target === 'boolean') {
deep = target;
target = arguments[1] || {};
// skip the boolean and the target
i = 2;
}
if (
target == null ||
(typeof target !== 'object' && typeof target !== 'function')
) {
target = {};
}
for (; i < length; ++i) {
options = arguments[i];
// Only deal with non-null/undefined values
if (options != null) {
// Extend the base object
for (name in options) {
src = getProperty(target, name);
copy = getProperty(options, name);
// Prevent never-ending loop
if (target !== copy) {
// Recurse if we're merging plain objects or arrays
if (
deep &&
copy &&
(isPlainObject(copy) || (copyIsArray = isArray(copy)))
) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
setProperty(target, {
name: name,
newValue: extend(deep, clone, copy),
});
// Don't bring in undefined values
} else if (typeof copy !== 'undefined') {
setProperty(target, { name: name, newValue: copy });
}
}
}
}
}
// Return the modified object
return target;
};
/***/
},
/***/ 237: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
var emoji = __nccwpck_require__(5464);
module.exports = BananaSlug;
var own = Object.hasOwnProperty;
var whitespace = /\s/g;
var specials = /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~’]/g;
function BananaSlug() {
var self = this;
if (!(self instanceof BananaSlug)) return new BananaSlug();
self.reset();
}
/**
* Generate a unique slug.
* @param {string} value String of text to slugify
* @param {boolean} [false] Keep the current case, otherwise make all lowercase
* @return {string} A unique slug string
*/
BananaSlug.prototype.slug = function (value, maintainCase) {
var self = this;
var slug = slugger(value, maintainCase === true);
var originalSlug = slug;
while (own.call(self.occurrences, slug)) {
self.occurrences[originalSlug]++;
slug = originalSlug + '-' + self.occurrences[originalSlug];
}
self.occurrences[slug] = 0;
return slug;
};
/**
* Reset - Forget all previous slugs
* @return void
*/
BananaSlug.prototype.reset = function () {
this.occurrences = Object.create(null);
};
function slugger(string, maintainCase) {
if (typeof string !== 'string') return '';
if (!maintainCase) string = string.toLowerCase();
return string
.trim()
.replace(specials, '')
.replace(emoji(), '')
.replace(whitespace, '-');
}
BananaSlug.slug = slugger;
/***/
},
/***/ 5464: /***/ (module) => {
module.exports = function () {
return /[\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\u2648-\u2653\u2660\u2663\u2665\u2666\u2668\u267B\u267F\u2692-\u2694\u2696\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\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-\uDD79\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED0\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3]|\uD83E[\uDD10-\uDD18\uDD80-\uDD84\uDDC0]|\uD83C\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uD83C\uDDFE\uD83C[\uDDEA\uDDF9]|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDFC\uD83C[\uDDEB\uDDF8]|\uD83C\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uD83C\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\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\uDDF6\uD83C\uDDE6|\uD83C\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uD83C\uDDF4\uD83C\uDDF2|\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]\u20E3/g;
};
/***/
},
/***/ 4232: /***/ (module) => {
'use strict';
module.exports = longestStreak;
// Get the count of the longest repeating streak of `character` in `value`.
function longestStreak(value, character) {
var count = 0;
var maximum = 0;
var expected;
var index;
if (typeof character !== 'string' || character.length !== 1) {
throw new Error('Expected character');
}
value = String(value);
index = value.indexOf(character);
expected = index;
while (index !== -1) {
count++;
if (index === expected) {
if (count > maximum) {
maximum = count;
}
} else {
count = 1;
}
expected = index + 1;
index = value.indexOf(character, expected);
}
return maximum;
}
/***/
},
/***/ 6869: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = fromMarkdown;
// These three are compiled away in the `dist/`
var toString = __nccwpck_require__(5789);
var assign = __nccwpck_require__(3512);
var own = __nccwpck_require__(3500);
var normalizeIdentifier = __nccwpck_require__(712);
var safeFromInt = __nccwpck_require__(6214);
var parser = __nccwpck_require__(488);
var preprocessor = __nccwpck_require__(5603);
var postprocess = __nccwpck_require__(6948);
var decode = __nccwpck_require__(3485);
var stringifyPosition = __nccwpck_require__(1957);
function fromMarkdown(value, encoding, options) {
if (typeof encoding !== 'string') {
options = encoding;
encoding = undefined;
}
return compiler(options)(
postprocess(
parser(options)
.document()
.write(preprocessor()(value, encoding, true))
)
);
}
// Note this compiler only understand complete buffering, not streaming.
function compiler(options) {
var settings = options || {};
var config = configure(
{
canContainEols: [
'emphasis',
'fragment',
'heading',
'paragraph',
'strong',
],
enter: {
autolink: opener(link),
autolinkProtocol: onenterdata,
autolinkEmail: onenterdata,
atxHeading: opener(heading),
blockQuote: opener(blockQuote),
characterEscape: onenterdata,
characterReference: onenterdata,
codeFenced: opener(codeFlow),
codeFencedFenceInfo: buffer,
codeFencedFenceMeta: buffer,
codeIndented: opener(codeFlow, buffer),
codeText: opener(codeText, buffer),
codeTextData: onenterdata,
data: onenterdata,
codeFlowValue: onenterdata,
definition: opener(definition),
definitionDestinationString: buffer,
definitionLabelString: buffer,
definitionTitleString: buffer,
emphasis: opener(emphasis),
hardBreakEscape: opener(hardBreak),
hardBreakTrailing: opener(hardBreak),
htmlFlow: opener(html, buffer),
htmlFlowData: onenterdata,
htmlText: opener(html, buffer),
htmlTextData: onenterdata,
image: opener(image),
label: buffer,
link: opener(link),
listItem: opener(listItem),
listItemValue: onenterlistitemvalue,
listOrdered: opener(list, onenterlistordered),
listUnordered: opener(list),
paragraph: opener(paragraph),
reference: onenterreference,
referenceString: buffer,
resourceDestinationString: buffer,
resourceTitleString: buffer,
setextHeading: opener(heading),
strong: opener(strong),
thematicBreak: opener(thematicBreak),
},
exit: {
atxHeading: closer(),
atxHeadingSequence: onexitatxheadingsequence,
autolink: closer(),
autolinkEmail: onexitautolinkemail,
autolinkProtocol: onexitautolinkprotocol,
blockQuote: closer(),
characterEscapeValue: onexitdata,
characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
characterReferenceValue: onexitcharacterreferencevalue,
codeFenced: closer(onexitcodefenced),
codeFencedFence: onexitcodefencedfence,
codeFencedFenceInfo: onexitcodefencedfenceinfo,
codeFencedFenceMeta: onexitcodefencedfencemeta,
codeFlowValue: onexitdata,
codeIndented: closer(onexitcodeindented),
codeText: closer(onexitcodetext),
codeTextData: onexitdata,
data: onexitdata,
definition: closer(),
definitionDestinationString: onexitdefinitiondestinationstring,
definitionLabelString: onexitdefinitionlabelstring,
definitionTitleString: onexitdefinitiontitlestring,
emphasis: closer(),
hardBreakEscape: closer(onexithardbreak),
hardBreakTrailing: closer(onexithardbreak),
htmlFlow: closer(onexithtmlflow),
htmlFlowData: onexitdata,
htmlText: closer(onexithtmltext),
htmlTextData: onexitdata,
image: closer(onexitimage),
label: onexitlabel,
labelText: onexitlabeltext,
lineEnding: onexitlineending,
link: closer(onexitlink),
listItem: closer(),
listOrdered: closer(),
listUnordered: closer(),
paragraph: closer(),
referenceString: onexitreferencestring,
resourceDestinationString: onexitresourcedestinationstring,
resourceTitleString: onexitresourcetitlestring,
resource: onexitresource,
setextHeading: closer(onexitsetextheading),
setextHeadingLineSequence: onexitsetextheadinglinesequence,
setextHeadingText: onexitsetextheadingtext,
strong: closer(),
thematicBreak: closer(),
},
},
settings.mdastExtensions || []
);
var data = {};
return compile;
function compile(events) {
var stack = [{ type: 'root', children: [] }];
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,
};
while (++index < events.length) {
// We preprocess lists to add `listItem` tokens, and to infer whether
// items the list itself are spread out.
if (
events[index][1].type === 'listOrdered' ||
events[index][1].type === 'listUnordered'
) {
if (events[index][0] === 'enter') {
listStack.push(index);
} else {
listStart = listStack.pop(index);
index = prepareList(events, listStart, index);
}
}
}
index = -1;
while (++index < events.length) {
handler = config[events[index][0]];
if (own.call(handler, events[index][1].type)) {
handler[events[index][1].type].call(
assign(
{ sliceSerialize: events[index][2].sliceSerialize },
context
),
events[index][1]
);
}
}
if (tokenStack.length) {
throw new Error(
'Cannot close document, a token (`' +
tokenStack[tokenStack.length - 1].type +
'`, ' +
stringifyPosition({
start: tokenStack[tokenStack.length - 1].start,
end: tokenStack[tokenStack.length - 1].end,
}) +
') is still open'
);
}
// Figure out `root` position.
stack[0].position = {
start: point(
events.length
? events[0][1].start
: { line: 1, column: 1, offset: 0 }
),
end: point(
events.length
? events[events.length - 2][1].end
: { line: 1, column: 1, offset: 0 }
),
};
return stack[0];
}
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;
while (++index <= length) {
event = events[index];
if (
event[1].type === 'listUnordered' ||
event[1].type === 'listOrdered' ||
event[1].type === 'blockQuote'
) {
if (event[0] === 'enter') {
containerBalance++;
} else {
containerBalance--;
}
atMarker = undefined;
} else if (event[1].type === 'lineEndingBlank') {
if (event[0] === 'enter') {
if (
listItem &&
!atMarker &&
!containerBalance &&
!firstBlankLineIndex
) {
firstBlankLineIndex = index;
}
atMarker = undefined;
}
} else if (
event[1].type === 'linePrefix' ||
event[1].type === 'listItemValue' ||
event[1].type === 'listItemMarker' ||
event[1].type === 'listItemPrefix' ||
event[1].type === 'listItemPrefixWhitespace'
) {
// Empty.
} else {
atMarker = undefined;
}
if (
(!containerBalance &&
event[0] === 'enter' &&
event[1].type === 'listItemPrefix') ||
(containerBalance === -1 &&
event[0] === 'exit' &&
(event[1].type === 'listUnordered' ||
event[1].type === 'listOrdered'))
) {
if (listItem) {
tailIndex = index;
lineIndex = undefined;
while (tailIndex--) {
tailEvent = events[tailIndex];
if (
tailEvent[1].type === 'lineEnding' ||
tailEvent[1].type === 'lineEndingBlank'
) {
if (tailEvent[0] === 'exit') continue;
if (lineIndex) {
events[lineIndex][1].type = 'lineEndingBlank';
listSpread = true;
}
tailEvent[1].type = 'lineEnding';
lineIndex = tailIndex;
} else if (
tailEvent[1].type === 'linePrefix' ||
tailEvent[1].type === 'blockQuotePrefix' ||
tailEvent[1].type === 'blockQuotePrefixWhitespace' ||
tailEvent[1].type === 'blockQuoteMarker' ||
tailEvent[1].type === 'listItemIndent'
) {
// Empty
} else {
break;
}
}
if (
firstBlankLineIndex &&
(!lineIndex || firstBlankLineIndex < lineIndex)
) {
listItem._spread = true;
}
// Fix position.
listItem.end = point(
lineIndex ? events[lineIndex][1].start : event[1].end
);
events.splice(lineIndex || index, 0, [
'exit',
listItem,
event[2],
]);
index++;
length++;
}
// Create a new list item.
if (event[1].type === 'listItemPrefix') {
listItem = {
type: 'listItem',
_spread: false,
start: point(event[1].start),
};
events.splice(index, 0, ['enter', listItem, event[2]]);
index++;
length++;
firstBlankLineIndex = undefined;
atMarker = true;
}
}
}
events[start][1]._spread = listSpread;
return length;
}
function setData(key, value) {
data[key] = value;
}
function getData(key) {
return data[key];
}
function point(d) {
return { line: d.line, column: d.column, offset: d.offset };
}
function opener(create, and) {
return open;
function open(token) {
enter.call(this, create(token), token);
if (and) and.call(this, token);
}
}
function buffer() {
this.stack.push({ type: 'fragment', children: [] });
}
function enter(node, token) {
this.stack[this.stack.length - 1].children.push(node);
this.stack.push(node);
this.tokenStack.push(token);
node.position = { start: point(token.start) };
return node;
}
function closer(and) {
return close;
function close(token) {
if (and) and.call(this, token);
exit.call(this, token);
}
}
function exit(token) {
var node = this.stack.pop();
var open = this.tokenStack.pop();
if (!open) {
throw new Error(
'Cannot close `' +
token.type +
'` (' +
stringifyPosition({ start: token.start, end: token.end }) +
'): it’s not open'
);
} else if (open.type !== token.type) {
throw new Error(
'Cannot close `' +
token.type +
'` (' +
stringifyPosition({ start: token.start, end: token.end }) +
'): a different token (`' +
open.type +
'`, ' +
stringifyPosition({ start: open.start, end: open.end }) +
') is open'
);
}
node.position.end = point(token.end);
return node;
}
function resume() {
return toString(this.stack.pop());
}
//
// Handlers.
//
function onenterlistordered() {
setData('expectingFirstListItemValue', true);
}
function onenterlistitemvalue(token) {
if (getData('expectingFirstListItemValue')) {
this.stack[this.stack.length - 2].start = parseInt(
this.sliceSerialize(token),
10
);
setData('expectingFirstListItemValue');
}
}
function onexitcodefencedfenceinfo() {
var data = this.resume();
this.stack[this.stack.length - 1].lang = data;
}
function onexitcodefencedfencemeta() {
var data = this.resume();
this.stack[this.stack.length - 1].meta = data;
}
function onexitcodefencedfence() {
// Exit if this is the closing fence.
if (getData('flowCodeInside')) return;
this.buffer();
setData('flowCodeInside', true);
}
function onexitcodefenced() {
var data = this.resume();
this.stack[this.stack.length - 1].value = data.replace(
/^(\r?\n|\r)|(\r?\n|\r)$/g,
''
);
setData('flowCodeInside');
}
function onexitcodeindented() {
var data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
function onexitdefinitionlabelstring(token) {
// Discard label, use the source content instead.
var label = this.resume();
this.stack[this.stack.length - 1].label = label;
this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
}
function onexitdefinitiontitlestring() {
var data = this.resume();
this.stack[this.stack.length - 1].title = data;
}
function onexitdefinitiondestinationstring() {
var data = this.resume();
this.stack[this.stack.length - 1].url = data;
}
function onexitatxheadingsequence(token) {
if (!this.stack[this.stack.length - 1].depth) {
this.stack[this.stack.length - 1].depth = this.sliceSerialize(
token
).length;
}
}
function onexitsetextheadingtext() {
setData('setextHeadingSlurpLineEnding', true);
}
function onexitsetextheadinglinesequence(token) {
this.stack[this.stack.length - 1].depth =
this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;
}
function onexitsetextheading() {
setData('setextHeadingSlurpLineEnding');
}
function onenterdata(token) {
var siblings = this.stack[this.stack.length - 1].children;
var tail = siblings[siblings.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);
}
this.stack.push(tail);
}
function onexitdata(token) {
var tail = this.stack.pop();
tail.value += this.sliceSerialize(token);
tail.position.end = point(token.end);
}
function onexitlineending(token) {
var 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
);
setData('atHardBreak');
return;
}
if (
!getData('setextHeadingSlurpLineEnding') &&
config.canContainEols.indexOf(context.type) > -1
) {
onenterdata.call(this, token);
onexitdata.call(this, token);
}
}
function onexithardbreak() {
setData('atHardBreak', true);
}
function onexithtmlflow() {
var data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
function onexithtmltext() {
var data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
function onexitcodetext() {
var data = this.resume();
this.stack[this.stack.length - 1].value = data;
}
function onexitlink() {
var context = this.stack[this.stack.length - 1];
// To do: clean.
if (getData('inReference')) {
context.type += 'Reference';
context.referenceType = getData('referenceType') || 'shortcut';
delete context.url;
delete context.title;
} else {
delete context.identifier;
delete context.label;
delete context.referenceType;
}
setData('referenceType');
}
function onexitimage() {
var context = this.stack[this.stack.length - 1];
// To do: clean.
if (getData('inReference')) {
context.type += 'Reference';
context.referenceType = getData('referenceType') || 'shortcut';
delete context.url;
delete context.title;
} else {
delete context.identifier;
delete context.label;
delete context.referenceType;
}
setData('referenceType');
}
function onexitlabeltext(token) {
this.stack[this.stack.length - 2].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
}
function onexitlabel() {
var fragment = this.stack[this.stack.length - 1];
var value = this.resume();
this.stack[this.stack.length - 1].label = value;
// Assume a reference.
setData('inReference', true);
if (this.stack[this.stack.length - 1].type === 'link') {
this.stack[this.stack.length - 1].children = fragment.children;
} else {
this.stack[this.stack.length - 1].alt = value;
}
}
function onexitresourcedestinationstring() {
var data = this.resume();
this.stack[this.stack.length - 1].url = data;
}
function onexitresourcetitlestring() {
var data = this.resume();
this.stack[this.stack.length - 1].title = data;
}
function onexitresource() {
setData('inReference');
}
function onenterreference() {
setData('referenceType', 'collapsed');
}
function onexitreferencestring(token) {
var label = this.resume();
this.stack[this.stack.length - 1].label = label;
this.stack[this.stack.length - 1].identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
setData('referenceType', 'full');
}
function onexitcharacterreferencemarker(token) {
setData('characterReferenceType', token.type);
}
function onexitcharacterreferencevalue(token) {
var data = this.sliceSerialize(token);
var type = getData('characterReferenceType');
var value;
var tail;
if (type) {
value = safeFromInt(
data,
type === 'characterReferenceMarkerNumeric' ? 10 : 16
);
setData('characterReferenceType');
} else {
value = decode(data);
}
tail = this.stack.pop();
tail.value += value;
tail.position.end = point(token.end);
}
function onexitautolinkprotocol(token) {
onexitdata.call(this, token);
this.stack[this.stack.length - 1].url = this.sliceSerialize(token);
}
function onexitautolinkemail(token) {
onexitdata.call(this, token);
this.stack[this.stack.length - 1].url =
'mailto:' + this.sliceSerialize(token);
}
//
// Creaters.
//
function blockQuote() {
return { type: 'blockquote', children: [] };
}
function codeFlow() {
return { type: 'code', lang: null, meta: null, value: '' };
}
function codeText() {
return { type: 'inlineCode', value: '' };
}
function definition() {
return {
type: 'definition',
identifier: '',
label: null,
title: null,
url: '',
};
}
function emphasis() {
return { type: 'emphasis', children: [] };
}
function heading() {
return { type: 'heading', depth: undefined, children: [] };
}
function hardBreak() {
return { type: 'break' };
}
function html() {
return { type: 'html', value: '' };
}
function image() {
return { type: 'image', title: null, url: '', alt: null };
}
function link() {
return { type: 'link', title: null, url: '', children: [] };
}
function list(token) {
return {
type: 'list',
ordered: token.type === 'listOrdered',
start: null,
spread: token._spread,
children: [],
};
}
function listItem(token) {
return {
type: 'listItem',
spread: token._spread,
checked: null,
children: [],
};
}
function paragraph() {
return { type: 'paragraph', children: [] };
}
function strong() {
return { type: 'strong', children: [] };
}
function text() {
return { type: 'text', value: '' };
}
function thematicBreak() {
return { type: 'thematicBreak' };
}
}
function configure(config, extensions) {
var index = -1;
while (++index < extensions.length) {
extension(config, extensions[index]);
}
return config;
}
function extension(config, extension) {
var key;
var left;
for (key in extension) {
left = own.call(config, key) ? config[key] : (config[key] = {});
if (key === 'canContainEols') {
config[key] = [].concat(left, extension[key]);
} else {
Object.assign(left, extension[key]);
}
}
}
/***/
},
/***/ 3068: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = __nccwpck_require__(6869);
/***/
},
/***/ 219: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = __nccwpck_require__(3683);
/***/
},
/***/ 9363: /***/ (module) => {
module.exports = configure;
function configure(base, extension) {
var index = -1;
var key;
// First do subextensions.
if (extension.extensions) {
while (++index < extension.extensions.length) {
configure(base, extension.extensions[index]);
}
}
for (key in extension) {
if (key === 'extensions') {
// Empty.
} else if (key === 'unsafe' || key === 'join') {
base[key] = base[key].concat(extension[key] || []);
} else if (key === 'handlers') {
base[key] = Object.assign(base[key], extension[key] || {});
} else {
base.options[key] = extension[key];
}
}
return base;
}
/***/
},
/***/ 3920: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = blockquote;
var flow = __nccwpck_require__(7530);
var indentLines = __nccwpck_require__(6887);
function blockquote(node, _, context) {
var exit = context.enter('blockquote');
var value = indentLines(flow(node, context), map);
exit();
return value;
}
function map(line, index, blank) {
return '>' + (blank ? '' : ' ') + line;
}
/***/
},
/***/ 229: /***/ (module) => {
module.exports = hardBreak;
function hardBreak() {
return '\\\n';
}
/***/
},
/***/ 5268: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = code;
var repeat = __nccwpck_require__(6976);
var streak = __nccwpck_require__(4232);
var formatCodeAsIndented = __nccwpck_require__(8446);
var checkFence = __nccwpck_require__(158);
var indentLines = __nccwpck_require__(6887);
var safe = __nccwpck_require__(3906);
function code(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(node, context)) {
exit = context.enter('codeIndented');
value = indentLines(raw, map);
} else {
sequence = repeat(marker, Math.max(streak(raw, marker) + 1, 3));
exit = context.enter('codeFenced');
value = sequence;
if (node.lang) {
subexit = context.enter('codeFencedLang' + suffix);
value += safe(context, node.lang, {
before: '`',
after: ' ',
encode: ['`'],
});
subexit();
}
if (node.lang && node.meta) {
subexit = context.enter('codeFencedMeta' + suffix);
value +=
' ' +
safe(context, node.meta, {
before: ' ',
after: '\n',
encode: ['`'],
});
subexit();
}
value += '\n';
if (raw) {
value += raw + '\n';
}
value += sequence;
}
exit();
return value;
}
function map(line, _, blank) {
return (blank ? '' : ' ') + line;
}
/***/
},
/***/ 7385: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = definition;
var association = __nccwpck_require__(9211);
var checkQuote = __nccwpck_require__(3366);
var safe = __nccwpck_require__(3906);
function definition(node, _, context) {
var marker = checkQuote(context);
var suffix = marker === '"' ? 'Quote' : 'Apostrophe';
var exit = context.enter('definition');
var subexit = context.enter('label');
var value =
'[' +
safe(context, association(node), { before: '[', after: ']' }) +
']: ';
subexit();
if (
// If there’s no url, or…
!node.url ||
// If there’s whitespace, enclosed is prettier.
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
value +=
'<' + safe(context, node.url, { before: '<', after: '>' }) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
value += safe(context, node.url, { before: ' ', after: ' ' });
}
subexit();
if (node.title) {
subexit = context.enter('title' + suffix);
value +=
' ' +
marker +
safe(context, node.title, { before: marker, after: marker }) +
marker;
subexit();
}
exit();
return value;
}
/***/
},
/***/ 8909: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = emphasis;
emphasis.peek = emphasisPeek;
var checkEmphasis = __nccwpck_require__(6452);
var phrasing = __nccwpck_require__(7489);
// 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?
function emphasis(node, _, context) {
var marker = checkEmphasis(context);
var exit = context.enter('emphasis');
var value = phrasing(node, context, { before: marker, after: marker });
exit();
return marker + value + marker;
}
function emphasisPeek(node, _, context) {
return context.options.emphasis || '*';
}
/***/
},
/***/ 2568: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = heading;
var repeat = __nccwpck_require__(6976);
var formatHeadingAsSetext = __nccwpck_require__(4954);
var phrasing = __nccwpck_require__(7489);
function heading(node, _, context) {
var rank = Math.max(Math.min(6, node.depth || 1), 1);
var exit;
var subexit;
var value;
var sequence;
if (formatHeadingAsSetext(node, context)) {
exit = context.enter('headingSetext');
subexit = context.enter('phrasing');
value = phrasing(node, context, { before: '\n', after: '\n' });
subexit();
exit();
return (
value +
'\n' +
repeat(
rank === 1 ? '=' : '-',
// The whole size…
value.length -
// Minus the position of the character after the last EOL (or
// 0 if there is none)…
(Math.max(value.lastIndexOf('\r'), value.lastIndexOf('\n')) + 1)
)
);
}
sequence = repeat('#', rank);
exit = context.enter('headingAtx');
subexit = context.enter('phrasing');
value = phrasing(node, context, { before: '# ', after: '\n' });
value = value ? sequence + ' ' + value : sequence;
if (context.options.closeAtx) {
value += ' ' + sequence;
}
subexit();
exit();
return value;
}
/***/
},
/***/ 5538: /***/ (module) => {
module.exports = html;
function html(node) {
return node.value || '';
}
/***/
},
/***/ 3885: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = imageReference;
imageReference.peek = imageReferencePeek;
var association = __nccwpck_require__(9211);
var safe = __nccwpck_require__(3906);
function imageReference(node, _, context) {
var type = node.referenceType;
var exit = context.enter('imageReference');
var subexit = context.enter('label');
var alt = safe(context, node.alt, { before: '[', after: ']' });
var value = '![' + alt + ']';
var reference;
var stack;
subexit();
// Hide the fact that we’re in phrasing, because escapes don’t work.
stack = context.stack;
context.stack = [];
subexit = context.enter('reference');
reference = safe(context, association(node), {
before: '[',
after: ']',
});
subexit();
context.stack = stack;
exit();
if (type === 'full' || !alt || alt !== reference) {
value += '[' + reference + ']';
} else if (type !== 'shortcut') {
value += '[]';
}
return value;
}
function imageReferencePeek() {
return '!';
}
/***/
},
/***/ 1591: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = image;
image.peek = imagePeek;
var checkQuote = __nccwpck_require__(3366);
var safe = __nccwpck_require__(3906);
function image(node, _, context) {
var quote = checkQuote(context);
var suffix = quote === '"' ? 'Quote' : 'Apostrophe';
var exit = context.enter('image');
var subexit = context.enter('label');
var value =
'![' + safe(context, node.alt, { before: '[', after: ']' }) + '](';
subexit();
if (
// If there’s no url but there is a title…
(!node.url && node.title) ||
// Or if there’s markdown whitespace or an eol, enclose.
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
value +=
'<' + safe(context, node.url, { before: '<', after: '>' }) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
value += safe(context, node.url, {
before: '(',
after: node.title ? ' ' : ')',
});
}
subexit();
if (node.title) {
subexit = context.enter('title' + suffix);
value +=
' ' +
quote +
safe(context, node.title, { before: quote, after: quote }) +
quote;
subexit();
}
value += ')';
exit();
return value;
}
function imagePeek() {
return '!';
}
/***/
},
/***/ 3769: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
exports.blockquote = __nccwpck_require__(3920);
exports['break'] = __nccwpck_require__(229);
exports.code = __nccwpck_require__(5268);
exports.definition = __nccwpck_require__(7385);
exports.emphasis = __nccwpck_require__(8909);
exports.hardBreak = __nccwpck_require__(229);
exports.heading = __nccwpck_require__(2568);
exports.html = __nccwpck_require__(5538);
exports.image = __nccwpck_require__(1591);
exports.imageReference = __nccwpck_require__(3885);
exports.inlineCode = __nccwpck_require__(5645);
exports.link = __nccwpck_require__(7938);
exports.linkReference = __nccwpck_require__(9556);
exports.list = __nccwpck_require__(9323);
exports.listItem = __nccwpck_require__(7016);
exports.paragraph = __nccwpck_require__(5197);
exports.root = __nccwpck_require__(54);
exports.strong = __nccwpck_require__(2150);
exports.text = __nccwpck_require__(2124);
exports.thematicBreak = __nccwpck_require__(3960);
/***/
},
/***/ 5645: /***/ (module) => {
module.exports = inlineCode;
inlineCode.peek = inlineCodePeek;
function inlineCode(node) {
var value = node.value || '';
var sequence = '`';
var pad = '';
// 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.charAt(0)) ||
/[ \r\n`]/.test(value.charAt(value.length - 1)))
) {
pad = ' ';
}
return sequence + pad + value + pad + sequence;
}
function inlineCodePeek() {
return '`';
}
/***/
},
/***/ 9556: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = linkReference;
linkReference.peek = linkReferencePeek;
var association = __nccwpck_require__(9211);
var phrasing = __nccwpck_require__(7489);
var safe = __nccwpck_require__(3906);
function linkReference(node, _, context) {
var type = node.referenceType;
var exit = context.enter('linkReference');
var subexit = context.enter('label');
var text = phrasing(node, context, { before: '[', after: ']' });
var value = '[' + text + ']';
var reference;
var stack;
subexit();
// Hide the fact that we’re in phrasing, because escapes don’t work.
stack = context.stack;
context.stack = [];
subexit = context.enter('reference');
reference = safe(context, association(node), {
before: '[',
after: ']',
});
subexit();
context.stack = stack;
exit();
if (type === 'full' || !text || text !== reference) {
value += '[' + reference + ']';
} else if (type !== 'shortcut') {
value += '[]';
}
return value;
}
function linkReferencePeek() {
return '[';
}
/***/
},
/***/ 7938: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = link;
link.peek = linkPeek;
var checkQuote = __nccwpck_require__(3366);
var formatLinkAsAutolink = __nccwpck_require__(5358);
var phrasing = __nccwpck_require__(7489);
var safe = __nccwpck_require__(3906);
function link(node, _, context) {
var quote = checkQuote(context);
var suffix = quote === '"' ? 'Quote' : 'Apostrophe';
var exit;
var subexit;
var value;
var stack;
if (formatLinkAsAutolink(node, context)) {
// Hide the fact that we’re in phrasing, because escapes don’t work.
stack = context.stack;
context.stack = [];
exit = context.enter('autolink');
value =
'<' + phrasing(node, context, { before: '<', after: '>' }) + '>';
exit();
context.stack = stack;
return value;
}
exit = context.enter('link');
subexit = context.enter('label');
value =
'[' + phrasing(node, context, { before: '[', after: ']' }) + '](';
subexit();
if (
// If there’s no url but there is a title…
(!node.url && node.title) ||
// Or if there’s markdown whitespace or an eol, enclose.
/[ \t\r\n]/.test(node.url)
) {
subexit = context.enter('destinationLiteral');
value +=
'<' + safe(context, node.url, { before: '<', after: '>' }) + '>';
} else {
// No whitespace, raw is prettier.
subexit = context.enter('destinationRaw');
value += safe(context, node.url, {
before: '(',
after: node.title ? ' ' : ')',
});
}
subexit();
if (node.title) {
subexit = context.enter('title' + suffix);
value +=
' ' +
quote +
safe(context, node.title, { before: quote, after: quote }) +
quote;
subexit();
}
value += ')';
exit();
return value;
}
function linkPeek(node, _, context) {
return formatLinkAsAutolink(node, context) ? '<' : '[';
}
/***/
},
/***/ 7016: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = listItem;
var repeat = __nccwpck_require__(6976);
var checkBullet = __nccwpck_require__(8599);
var checkListItemIndent = __nccwpck_require__(9009);
var flow = __nccwpck_require__(7530);
var indentLines = __nccwpck_require__(6887);
function listItem(node, parent, context) {
var bullet = checkBullet(context);
var listItemIndent = checkListItemIndent(context);
var size;
var value;
var exit;
if (parent && parent.ordered) {
bullet =
(parent.start > -1 ? parent.start : 1) +
(context.options.incrementListMarker === false
? 0
: parent.children.indexOf(node)) +
'.';
}
size = bullet.length + 1;
if (
listItemIndent === 'tab' ||
(listItemIndent === 'mixed' &&
((parent && parent.spread) || node.spread))
) {
size = Math.ceil(size / 4) * 4;
}
exit = context.enter('listItem');
value = indentLines(flow(node, context), map);
exit();
return value;
function map(line, index, blank) {
if (index) {
return (blank ? '' : repeat(' ', size)) + line;
}
return (
(blank ? bullet : bullet + repeat(' ', size - bullet.length)) + line
);
}
}
/***/
},
/***/ 9323: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = list;
var flow = __nccwpck_require__(7530);
function list(node, _, context) {
var exit = context.enter('list');
var value = flow(node, context);
exit();
return value;
}
/***/
},
/***/ 5197: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = paragraph;
var phrasing = __nccwpck_require__(7489);
function paragraph(node, _, context) {
var exit = context.enter('paragraph');
var subexit = context.enter('phrasing');
var value = phrasing(node, context, { before: '\n', after: '\n' });
subexit();
exit();
return value;
}
/***/
},
/***/ 54: /***/ (module, __unused_webpack_exports, __nccwpck_require__) => {
module.exports = root;
var flow = __nccwpck_require__(7530);
function root(node, _, context) {
return flow(node, context);
}
/***/
},
/***/ 2150: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = strong;
strong.peek = strongPeek;
var checkStrong = __nccwpck_require__(3534);
var phrasing = __nccwpck_require__(7489);
// 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?
function strong(node, _, context) {
var marker = checkStrong(context);
var exit = context.enter('strong');
var value = phrasing(node, context, { before: marker, after: marker });
exit();
return marker + marker + value + marker + marker;
}
function strongPeek(node, _, context) {
return context.options.strong || '*';
}
/***/
},
/***/ 2124: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = text;
var safe = __nccwpck_require__(3906);
function text(node, parent, context, safeOptions) {
return safe(context, node.value, safeOptions);
}
/***/
},
/***/ 3960: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = thematicBreak;
var repeat = __nccwpck_require__(6976);
var checkRepeat = __nccwpck_require__(3680);
var checkRule = __nccwpck_require__(7253);
function thematicBreak(node, parent, context) {
var value = repeat(
checkRule(context) + (context.options.ruleSpaces ? ' ' : ''),
checkRepeat(context)
);
return context.options.ruleSpaces ? value.slice(0, -1) : value;
}
/***/
},
/***/ 3683: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = toMarkdown;
var zwitch = __nccwpck_require__(1067);
var configure = __nccwpck_require__(9363);
var defaultHandlers = __nccwpck_require__(3769);
var defaultJoin = __nccwpck_require__(3701);
var defaultUnsafe = __nccwpck_require__(6566);
function toMarkdown(tree, options) {
var settings = options || {};
var context = {
enter: enter,
stack: [],
unsafe: [],
join: [],
handlers: {},
options: {},
};
var result;
configure(context, {
unsafe: defaultUnsafe,
join: defaultJoin,
handlers: defaultHandlers,
});
configure(context, settings);
if (context.options.tightDefinitions) {
context.join = [joinDefinition].concat(context.join);
}
context.handle = zwitch('type', {
invalid: invalid,
unknown: unknown,
handlers: context.handlers,
});
result = context.handle(tree, null, context, {
before: '\n',
after: '\n',
});
if (
result &&
result.charCodeAt(result.length - 1) !== 10 &&
result.charCodeAt(result.length - 1) !== 13
) {
result += '\n';
}
return result;
function enter(name) {
context.stack.push(name);
return exit;
function exit() {
context.stack.pop();
}
}
}
function invalid(value) {
throw new Error('Cannot handle value `' + value + '`, expected node');
}
function unknown(node) {
throw new Error('Cannot handle unknown node `' + node.type + '`');
}
function joinDefinition(left, right) {
// No blank line between adjacent definitions.
if (left.type === 'definition' && left.type === right.type) {
return 0;
}
}
/***/
},
/***/ 3701: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = [joinDefaults];
var formatCodeAsIndented = __nccwpck_require__(8446);
var formatHeadingAsSetext = __nccwpck_require__(4954);
function joinDefaults(left, right, parent, context) {
if (
// Two lists with the same marker.
(right.type === 'list' &&
right.type === left.type &&
Boolean(left.ordered) === Boolean(right.ordered)) ||
// Indented code after list or another indented code.
(right.type === 'code' &&
formatCodeAsIndented(right, context) &&
(left.type === 'list' ||
(left.type === right.type &&
formatCodeAsIndented(left, context))))
) {
return false;
}
// Join children of a list or an item.
// In which case, `parent` has a `spread` field.
if (typeof parent.spread === 'boolean') {
if (
left.type === 'paragraph' &&
// Two paragraphs.
(left.type === right.type ||
right.type === 'definition' ||
// Paragraph followed by a setext heading.
(right.type === 'heading' &&
formatHeadingAsSetext(right, context)))
) {
return;
}
return parent.spread ? 1 : 0;
}
}
/***/
},
/***/ 6566: /***/ (module) => {
module.exports = [
{
character: '\t',
inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde'],
},
{
character: '\r',
inConstruct: [
'codeFencedLangGraveAccent',
'codeFencedLangTilde',
'codeFencedMetaGraveAccent',
'codeFencedMetaTilde',
'destinationLiteral',
'headingAtx',
],
},
{
character: '\n',
inConstruct: [
'codeFencedLangGraveAccent',
'codeFencedLangTilde',
'codeFencedMetaGraveAccent',
'codeFencedMetaTilde',
'destinationLiteral',
'headingAtx',
],
},
{
character: ' ',
inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde'],
},
// An exclamation mark can start an image, if it is followed by a link or
// a link reference.
{ character: '!', after: '\\[', inConstruct: 'phrasing' },
// A quote can break out of a title.
{ character: '"', inConstruct: 'titleQuote' },
// A number sign could start an ATX heading if it starts a line.
{ atBreak: true, character: '#' },
// Dollar sign and percentage are not used in markdown.
// An ampersand could start a character reference.
{ character: '&', after: '[#A-Za-z]', inConstruct: 'phrasing' },
// An apostrophe can break out of a title.
{ character: "'", inConstruct: 'titleApostrophe' },
// A left paren could break out of a destination raw.
{ character: '(', inConstruct: 'destinationRaw' },
{ before: '\\]', character: '(', inConstruct: 'phrasing' },
// A right paren could start a list item or break out of a destination
// raw.
{ atBreak: true, before: '\\d+', character: ')' },
{ character: ')', inConstruct: 'destinationRaw' },
// An asterisk can start thematic breaks, list items, emphasis, strong.
{ atBreak: true, character: '*' },
{ character: '*', inConstruct: 'phrasing' },
// A plus sign could start a list item.
{ atBreak: true, character: '+' },
// A dash can start thematic breaks, list items, and setext heading
// underlines.
{ atBreak: true, character: '-' },
// A dot could start a list item.
{
atBreak: true,
before: '\\d+',
character: '.',
after: '(?:[ \t\r\n]|$)',
},
// Slash, colon, and semicolon are not used in markdown for constructs.
// A less than can start html (flow or text) or an autolink.
// HTML could start with an exclamation mark (declaration, cdata, comment),
// slash (closing tag), question mark (instruction), or a letter (tag).
// An autolink also starts with a letter.
// Finally, it could break out of a destination literal.
{ atBreak: true, character: '<', after: '[!/?A-Za-z]' },
{ character: '<', after: '[!/?A-Za-z]', inConstruct: 'phrasing' },
{ character: '<', inConstruct: 'destinationLiteral' },
// An equals to can start setext heading underlines.
{ atBreak: true, character: '=' },
// A greater than can start block quotes and it can break out of a
// destination literal.
{ atBreak: true, character: '>' },
{ character: '>', inConstruct: 'destinationLiteral' },
// Question mark and at sign are not used in markdown for constructs.
// A left bracket can start definitions, references, labels,
{ atBreak: true, character: '[' },
{
character: '[',
inConstruct: ['phrasing', 'label', 'reference'],
},
// A backslash can start an escape (when followed by punctuation) or a
// hard break (when followed by an eol).
{ character: '\\', after: '[!-/:-@[-`{-~]' },
{ character: '\\', after: '[\\r\\n]', inConstruct: 'phrasing' },
// A right bracket can exit labels.
{
character: ']',
inConstruct: ['label', 'reference'],
},
// Caret is not used in markdown for constructs.
// An underscore can start emphasis, strong, or a thematic break.
{ atBreak: true, character: '_' },
{ before: '[^A-Za-z]', character: '_', inConstruct: 'phrasing' },
{ character: '_', after: '[^A-Za-z]', inConstruct: 'phrasing' },
// A grave accent can start code (fenced or text), or it can break out of
// a grave accent code fence.
{ atBreak: true, character: '`' },
{
character: '`',
inConstruct: [
'codeFencedLangGraveAccent',
'codeFencedMetaGraveAccent',
'phrasing',
],
},
// Left brace, vertical bar, right brace are not used in markdown for
// constructs.
// A tilde can start code (fenced).
{ atBreak: true, character: '~' },
];
/***/
},
/***/ 9211: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = association;
var decode = __nccwpck_require__(3485);
var characterEscape = /\\([!-/:-@[-`{-~])/g;
var 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(node) {
if (node.label || !node.identifier) {
return node.label || '';
}
return node.identifier
.replace(characterEscape, '$1')
.replace(characterReference, decodeIfPossible);
}
function decodeIfPossible($0, $1) {
return decode($1) || $0;
}
/***/
},
/***/ 8599: /***/ (module) => {
module.exports = checkBullet;
function checkBullet(context) {
var marker = context.options.bullet || '*';
if (marker !== '*' && marker !== '+' && marker !== '-') {
throw new Error(
'Cannot serialize items with `' +
marker +
'` for `options.bullet`, expected `*`, `+`, or `-`'
);
}
return marker;
}
/***/
},
/***/ 6452: /***/ (module) => {
module.exports = checkEmphasis;
function checkEmphasis(context) {
var marker = context.options.emphasis || '*';
if (marker !== '*' && marker !== '_') {
throw new Error(
'Cannot serialize emphasis with `' +
marker +
'` for `options.emphasis`, expected `*`, or `_`'
);
}
return marker;
}
/***/
},
/***/ 158: /***/ (module) => {
module.exports = checkFence;
function checkFence(context) {
var marker = context.options.fence || '`';
if (marker !== '`' && marker !== '~') {
throw new Error(
'Cannot serialize code with `' +
marker +
'` for `options.fence`, expected `` ` `` or `~`'
);
}
return marker;
}
/***/
},
/***/ 9009: /***/ (module) => {
module.exports = checkListItemIndent;
function checkListItemIndent(context) {
var style = context.options.listItemIndent || 'tab';
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;
}
/***/
},
/***/ 3366: /***/ (module) => {
module.exports = checkQuote;
function checkQuote(context) {
var marker = context.options.quote || '"';
if (marker !== '"' && marker !== "'") {
throw new Error(
'Cannot serialize title with `' +
marker +
'` for `options.quote`, expected `"`, or `\'`'
);
}
return marker;
}
/***/
},
/***/ 3680: /***/ (module) => {
module.exports = checkRule;
function checkRule(context) {
var repetition = context.options.ruleRepetition || 3;
if (repetition < 3) {
throw new Error(
'Cannot serialize rules with repetition `' +
repetition +
'` for `options.ruleRepetition`, expected `3` or more'
);
}
return repetition;
}
/***/
},
/***/ 7253: /***/ (module) => {
module.exports = checkRule;
function checkRule(context) {
var marker = context.options.rule || '*';
if (marker !== '*' && marker !== '-' && marker !== '_') {
throw new Error(
'Cannot serialize rules with `' +
marker +
'` for `options.rule`, expected `*`, `-`, or `_`'
);
}
return marker;
}
/***/
},
/***/ 3534: /***/ (module) => {
module.exports = checkStrong;
function checkStrong(context) {
var marker = context.options.strong || '*';
if (marker !== '*' && marker !== '_') {
throw new Error(
'Cannot serialize strong with `' +
marker +
'` for `options.strong`, expected `*`, or `_`'
);
}
return marker;
}
/***/
},
/***/ 7530: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = flow;
var repeat = __nccwpck_require__(6976);
function flow(parent, context) {
var children = parent.children || [];
var results = [];
var index = -1;
var child;
while (++index < children.length) {
child = children[index];
results.push(
context.handle(child, parent, context, {
before: '\n',
after: '\n',
})
);
if (index + 1 < children.length) {
results.push(between(child, children[index + 1]));
}
}
return results.join('');
function between(left, right) {
var index = -1;
var result;
while (++index < context.join.length) {
result = context.join[index](left, right, parent, context);
if (result === true || result === 1) {
break;
}
if (typeof result === 'number') {
return repeat('\n', 1 + Number(result));
}
if (result === false) {
return '\n\n<!---->\n\n';
}
}
return '\n\n';
}
}
/***/
},
/***/ 7489: /***/ (module) => {
module.exports = phrasing;
function phrasing(parent, context, safeOptions) {
var children = parent.children || [];
var results = [];
var index = -1;
var before = safeOptions.before;
var after;
var handle;
var child;
while (++index < children.length) {
child = children[index];
if (index + 1 < children.length) {
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;
}
results.push(
context.handle(child, parent, context, {
before: before,
after: after,
})
);
before = results[results.length - 1].slice(-1);
}
return results.join('');
}
/***/
},
/***/ 8446: /***/ (module) => {
module.exports = formatCodeAsIndented;
function formatCodeAsIndented(node, context) {
return (
!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)
);
}
/***/
},
/***/ 4954: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = formatHeadingAsSetext;
var toString = __nccwpck_require__(5789);
function formatHeadingAsSetext(node, context) {
return (
context.options.setext &&
(!node.depth || node.depth < 3) &&
toString(node)
);
}
/***/
},
/***/ 5358: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
module.exports = formatLinkAsAutolink;
var toString = __nccwpck_require__(5789);
function formatLinkAsAutolink(node, context) {
var raw = toString(node);
return (
!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)
);
}
/***/
},
/***/ 6887: /***/ (module) => {
module.exports = indentLines;
var eol = /\r?\n|\r/g;
function indentLines(value, map) {
var result = [];
var start = 0;
var line = 0;
var 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('');
function one(value) {
result.push(map(value, line, !value));
}
}
/***/
},
/***/ 3906: /***/ (module) => {
module.exports = safe;
function safe(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;
while (++index < context.unsafe.length) {
pattern = context.unsafe[index];
if (
!inScope(context.stack, pattern.inConstruct, true) ||
inScope(context.stack, pattern.notInConstruct)
) {
continue;
}
expression =
pattern._compiled || (pattern._compiled = toExpression(pattern));
while ((match = expression.exec(value))) {
before = 'before' in pattern || pattern.atBreak;
after = 'after' in pattern;
position = match.index + (before ? match[1].length : 0);
if (positions.indexOf(position) === -1) {
positions.push(position);
infos[position] = { before: before, after: after };
} else {
if (infos[position].before && !before) {
infos[position].before = false;
}
if (infos[position].after && !after) {
infos[position].after = false;
}
}
}
}
positions.sort(numerical);
start = config.before ? config.before.length : 0;
end = value.length - (config.after ? config.after.length : 0);
index = -1;
while (++index < positions.length) {
position = positions[index];
if (
// Character before or after matched:
position < start ||
position >= end
) {
continue;
}
// If this character is supposed to be escaped because it has a condition on
// the next character, and the next character is definitly being escaped,
// then skip this escape.
if (
position + 1 < end &&
positions[index + 1] === position + 1 &&
infos[position].after &&
!infos[position + 1].before &&
!infos[position + 1].after
) {
continue;
}
if (start !== position) {
result.push(value.slice(start, position));
}
start = position;
if (
/[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
(!config.encode ||
config.encode.indexOf(value.charAt(position)) === -1)
) {
// Character escape.
result.push('\\');
} else {
// Character reference.
result.push(
'&#x' +
value.charCodeAt(position).toString(16).toUpperCase() +
';'
);
start++;
}
}
result.push(value.slice(start, end));
return result.join('');
}
function inScope(stack, list, none) {
var index;
if (!list) {
return none;
}
if (typeof list === 'string') {
list = [list];
}
index = -1;
while (++index < list.length) {
if (stack.indexOf(list[index]) !== -1) {
return true;
}
}
return false;
}
function toExpression(pattern) {
var before = pattern.before ? '(?:' + pattern.before + ')' : '';
var after = pattern.after ? '(?:' + pattern.after + ')' : '';
if (pattern.atBreak) {
before = '[\\r\\n][\\t ]*' + before;
}
return new RegExp(
(before ? '(' + before + ')' : '') +
(/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
pattern.character +
(after || ''),
'g'
);
}
function numerical(a, b) {
return a - b;
}
/***/
},
/***/ 5789: /***/ (module) => {
'use strict';
module.exports = toString;
// 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(node) {
return (
(node &&
(node.value ||
node.alt ||
node.title ||
('children' in node && all(node.children)) ||
('length' in node && all(node)))) ||
''
);
}
function all(values) {
var result = [];
var index = -1;
while (++index < values.length) {
result[index] = toString(values[index]);
}
return result.join('');
}
/***/
},
/***/ 6184: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = __nccwpck_require__(3616);
/***/
},
/***/ 1254: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var extend = __nccwpck_require__(8171);
module.exports = contents;
// Transform a list of heading objects to a markdown list.
function contents(map, tight, prefix, ordered) {
var table = {
type: 'list',
ordered: ordered,
spread: false,
children: [],
};
var minDepth = Infinity;
var index = -1;
// Find minimum depth.
while (++index < map.length) {
if (map[index].depth < minDepth) {
minDepth = map[index].depth;
}
}
// Normalize depth.
index = -1;
while (++index < map.length) {
map[index].depth -= minDepth - 1;
}
// Add TOC to list.
index = -1;
while (++index < map.length) {
insert(map[index], table, tight, prefix, ordered);
}
return table;
}
// Insert an entry into `parent`.
function insert(entry, parent, tight, prefix, ordered) {
var siblings = parent.children;
var tail = siblings[siblings.length - 1];
var index = -1;
var item;
if (entry.depth === 1) {
siblings.push({
type: 'listItem',
spread: false,
children: [
{
type: 'paragraph',
children: [
{
type: 'link',
title: null,
url: '#' + (prefix || '') + entry.id,
children: all(entry.children),
},
],
},
],
});
} else if (tail && tail.type === 'listItem') {
insert(entry, siblings[siblings.length - 1], tight, prefix, ordered);
} else if (tail && tail.type === 'list') {
entry.depth--;
insert(entry, tail, tight, prefix, ordered);
} else if (parent.type === 'list') {
item = { type: 'listItem', spread: false, children: [] };
siblings.push(item);
insert(entry, item, tight, prefix, ordered);
} else {
item = {
type: 'list',
ordered: ordered,
spread: false,
children: [],
};
siblings.push(item);
entry.depth--;
insert(entry, item, tight, prefix, ordered);
}
if (parent.type === 'list' && !tight) {
parent.spread = false;
while (++index < siblings.length) {
if (siblings[index].children.length > 1) {
parent.spread = true;
break;
}
}
} else {
parent.spread = !tight;
}
}
function all(children) {
var result = [];
var index = -1;
if (children) {
while (++index < children.length) {
result = result.concat(one(children[index]));
}
}
return result;
}
function one(node) {
var copy;
if (
node.type === 'link' ||
node.type === 'linkReference' ||
node.type === 'footnote' ||
node.type === 'footnoteReference'
) {
return all(node.children);
}
copy = extend({}, node);
delete copy.children;
delete copy.position;
copy = extend(true, {}, copy);
if (node.children) {
copy.children = all(node.children);
}
return copy;
}
/***/
},
/***/ 3616: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = toc;
var search = __nccwpck_require__(6138);
var contents = __nccwpck_require__(1254);
var toExpression = __nccwpck_require__(2874);
// Get a TOC representation of `node`.
function toc(node, options) {
var settings = options || {};
var heading = settings.heading ? toExpression(settings.heading) : null;
var result = search(node, heading, settings);
result.map = result.map.length
? contents(
result.map,
settings.tight,
settings.prefix,
settings.ordered || false
)
: null;
// No given heading.
if (!heading) {
result.endIndex = result.index = null;
}
return result;
}
/***/
},
/***/ 6138: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = search;
var toString = __nccwpck_require__(5789);
var visit = __nccwpck_require__(199);
var convert = __nccwpck_require__(4070);
var slugs = __nccwpck_require__(237)();
var toExpression = __nccwpck_require__(2874);
// Search a node for a location.
function search(root, expression, settings) {
var skip = settings.skip && toExpression(settings.skip);
var parents = convert(settings.parents || root);
var map = [];
var index;
var endIndex;
var opening;
slugs.reset();
// Visit all headings in `root`. We `slug` all headings (to account for
// duplicates), but only create a TOC from top-level headings.
visit(root, 'heading', onheading);
return {
index: index || -1,
endIndex: index ? endIndex || root.children.length : -1,
map: map,
};
function onheading(node, position, parent) {
var value = toString(node);
/* istanbul ignore next - to do: remove this when `remark-attr` is up to
* date w/ micromark. */
var id =
node.data && node.data.hProperties && node.data.hProperties.id;
var slug = slugs.slug(id || value);
if (!parents(parent)) {
return;
}
// Our opening heading.
if (expression && !index && expression.test(value)) {
index = position + 1;
opening = node;
return;
}
// Our closing heading.
if (opening && !endIndex && node.depth <= opening.depth) {
endIndex = position;
}
// A non-empty heading after the closing (if we were looking for one).
if (
value &&
(endIndex || !expression) &&
(!settings.maxDepth || node.depth <= settings.maxDepth) &&
(!skip || !skip.test(value))
) {
map.push({ depth: node.depth, children: node.children, id: slug });
}
}
}
/***/
},
/***/ 2874: /***/ (module) => {
'use strict';
module.exports = toExpression;
// Transform a string into an applicable expression.
function toExpression(value) {
return new RegExp('^(' + value + ')$', 'i');
}
/***/
},
/***/ 3847: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiAlpha = regexCheck(/[A-Za-z]/);
module.exports = asciiAlpha;
/***/
},
/***/ 598: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
module.exports = asciiAlphanumeric;
/***/
},
/***/ 245: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
module.exports = asciiAtext;
/***/
},
/***/ 1336: /***/ (module) => {
'use strict';
// Note: EOF is seen as ASCII control here, because `null < 32 == true`.
function asciiControl(code) {
return (
// Special whitespace codes (which have negative values), C0 and Control
// character DEL
code < 32 || code === 127
);
}
module.exports = asciiControl;
/***/
},
/***/ 6996: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiDigit = regexCheck(/\d/);
module.exports = asciiDigit;
/***/
},
/***/ 6526: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
module.exports = asciiHexDigit;
/***/
},
/***/ 7909: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
module.exports = asciiPunctuation;
/***/
},
/***/ 9180: /***/ (module) => {
'use strict';
function markdownLineEndingOrSpace(code) {
return code < 0 || code === 32;
}
module.exports = markdownLineEndingOrSpace;
/***/
},
/***/ 7506: /***/ (module) => {
'use strict';
function markdownLineEnding(code) {
return code < -2;
}
module.exports = markdownLineEnding;
/***/
},
/***/ 5989: /***/ (module) => {
'use strict';
function markdownSpace(code) {
return code === -2 || code === -1 || code === 32;
}
module.exports = markdownSpace;
/***/
},
/***/ 9372: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var unicodePunctuationRegex = __nccwpck_require__(9994);
// In fact adds to the bundle size.
var unicodePunctuation = regexCheck(unicodePunctuationRegex);
module.exports = unicodePunctuation;
/***/
},
/***/ 9968: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var regexCheck = __nccwpck_require__(1028);
var unicodeWhitespace = regexCheck(/\s/);
module.exports = unicodeWhitespace;
/***/
},
/***/ 3512: /***/ (module) => {
'use strict';
var assign = Object.assign;
module.exports = assign;
/***/
},
/***/ 3531: /***/ (module) => {
'use strict';
var fromCharCode = String.fromCharCode;
module.exports = fromCharCode;
/***/
},
/***/ 3500: /***/ (module) => {
'use strict';
var own = {}.hasOwnProperty;
module.exports = own;
/***/
},
/***/ 5159: /***/ (module) => {
'use strict';
// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.
var basics = [
'address',
'article',
'aside',
'base',
'basefont',
'blockquote',
'body',
'caption',
'center',
'col',
'colgroup',
'dd',
'details',
'dialog',
'dir',
'div',
'dl',
'dt',
'fieldset',
'figcaption',
'figure',
'footer',
'form',
'frame',
'frameset',
'h1',
'h2',
'h3',
'h4',
'h5',
'h6',
'head',
'header',
'hr',
'html',
'iframe',
'legend',
'li',
'link',
'main',
'menu',
'menuitem',
'nav',
'noframes',
'ol',
'optgroup',
'option',
'p',
'param',
'section',
'source',
'summary',
'table',
'tbody',
'td',
'tfoot',
'th',
'thead',
'title',
'tr',
'track',
'ul',
];
module.exports = basics;
/***/
},
/***/ 4677: /***/ (module) => {
'use strict';
// This module is copied from <https://spec.commonmark.org/0.29/#html-blocks>.
var raws = ['pre', 'script', 'style', 'textarea'];
module.exports = raws;
/***/
},
/***/ 2366: /***/ (module) => {
'use strict';
var splice = [].splice;
module.exports = splice;
/***/
},
/***/ 9994: /***/ (module) => {
'use strict';
// 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 = /[!-\/:-@\[-`\{-~\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]/;
module.exports = unicodePunctuation;
/***/
},
/***/ 289: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var text$1 = __nccwpck_require__(7492);
var attention = __nccwpck_require__(2116);
var autolink = __nccwpck_require__(6681);
var blockQuote = __nccwpck_require__(9025);
var characterEscape = __nccwpck_require__(7128);
var characterReference = __nccwpck_require__(9500);
var codeFenced = __nccwpck_require__(3268);
var codeIndented = __nccwpck_require__(907);
var codeText = __nccwpck_require__(7033);
var definition = __nccwpck_require__(1193);
var hardBreakEscape = __nccwpck_require__(7608);
var headingAtx = __nccwpck_require__(4558);
var htmlFlow = __nccwpck_require__(6791);
var htmlText = __nccwpck_require__(7743);
var labelEnd = __nccwpck_require__(9797);
var labelStartImage = __nccwpck_require__(7860);
var labelStartLink = __nccwpck_require__(5908);
var lineEnding = __nccwpck_require__(5183);
var thematicBreak = __nccwpck_require__(5590);
var list = __nccwpck_require__(3107);
var setextUnderline = __nccwpck_require__(1196);
var document = {
42: list,
// Asterisk
43: list,
// Plus sign
45: list,
// Dash
48: list,
// 0
49: list,
// 1
50: list,
// 2
51: list,
// 3
52: list,
// 4
53: list,
// 5
54: list,
// 6
55: list,
// 7
56: list,
// 8
57: list,
// 9
62: blockQuote, // Greater than
};
var contentInitial = {
91: definition, // Left square bracket
};
var flowInitial = {
'-2': codeIndented,
// Horizontal tab
'-1': codeIndented,
// Virtual space
32: codeIndented, // Space
};
var flow = {
35: headingAtx,
// Number sign
42: thematicBreak,
// Asterisk
45: [setextUnderline, thematicBreak],
// Dash
60: htmlFlow,
// Less than
61: setextUnderline,
// Equals to
95: thematicBreak,
// Underscore
96: codeFenced,
// Grave accent
126: codeFenced, // Tilde
};
var string = {
38: characterReference,
// Ampersand
92: characterEscape, // Backslash
};
var text = {
'-5': lineEnding,
// Carriage return
'-4': lineEnding,
// Line feed
'-3': lineEnding,
// Carriage return + line feed
33: labelStartImage,
// Exclamation mark
38: characterReference,
// Ampersand
42: attention,
// Asterisk
60: [autolink, htmlText],
// Less than
91: labelStartLink,
// Left square bracket
92: [hardBreakEscape, characterEscape],
// Backslash
93: labelEnd,
// Right square bracket
95: attention,
// Underscore
96: codeText, // Grave accent
};
var insideSpan = {
null: [attention, text$1.resolver],
};
var disable = {
null: [],
};
exports.contentInitial = contentInitial;
exports.disable = disable;
exports.document = document;
exports.flow = flow;
exports.flowInitial = flowInitial;
exports.insideSpan = insideSpan;
exports.string = string;
exports.text = text;
/***/
},
/***/ 5834: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var tokenize = initializeContent;
function initializeContent(effects) {
var contentStart = effects.attempt(
this.parser.constructs.contentInitial,
afterContentStartConstruct,
paragraphInitial
);
var previous;
return contentStart;
function afterContentStartConstruct(code) {
if (code === null) {
effects.consume(code);
return;
}
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return factorySpace(effects, contentStart, 'linePrefix');
}
function paragraphInitial(code) {
effects.enter('paragraph');
return lineStart(code);
}
function lineStart(code) {
var token = effects.enter('chunkText', {
contentType: 'text',
previous: previous,
});
if (previous) {
previous.next = token;
}
previous = token;
return data(code);
}
function data(code) {
if (code === null) {
effects.exit('chunkText');
effects.exit('paragraph');
effects.consume(code);
return;
}
if (markdownLineEnding(code)) {
effects.consume(code);
effects.exit('chunkText');
return lineStart;
} // Data.
effects.consume(code);
return data;
}
}
exports.tokenize = tokenize;
/***/
},
/***/ 9517: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var partialBlankLine = __nccwpck_require__(2244);
var tokenize = initializeDocument;
var containerConstruct = {
tokenize: tokenizeContainer,
};
var lazyFlowConstruct = {
tokenize: tokenizeLazyFlow,
};
function initializeDocument(effects) {
var self = this;
var stack = [];
var continued = 0;
var inspectConstruct = {
tokenize: tokenizeInspect,
partial: true,
};
var inspectResult;
var childFlow;
var childToken;
return start;
function start(code) {
if (continued < stack.length) {
self.containerState = stack[continued][1];
return effects.attempt(
stack[continued][0].continuation,
documentContinue,
documentContinued
)(code);
}
return documentContinued(code);
}
function documentContinue(code) {
continued++;
return start(code);
}
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);
}
self.interrupt =
childFlow &&
childFlow.currentConstruct &&
childFlow.currentConstruct.interruptible;
self.containerState = {};
return effects.attempt(
containerConstruct,
containerContinue,
flowStart
)(code);
}
function containerContinue(code) {
stack.push([self.currentConstruct, self.containerState]);
self.containerState = undefined;
return documentContinued(code);
}
function flowStart(code) {
if (code === null) {
exitContainers(0, true);
effects.consume(code);
return;
}
childFlow = childFlow || self.parser.flow(self.now());
effects.enter('chunkFlow', {
contentType: 'flow',
previous: childToken,
_tokenizer: childFlow,
});
return flowContinue(code);
}
function flowContinue(code) {
if (code === null) {
continueFlow(effects.exit('chunkFlow'));
return flowStart(code);
}
if (markdownLineEnding(code)) {
effects.consume(code);
continueFlow(effects.exit('chunkFlow'));
return effects.check(inspectConstruct, documentAfterPeek);
}
effects.consume(code);
return flowContinue;
}
function documentAfterPeek(code) {
exitContainers(
inspectResult.continued,
inspectResult && inspectResult.flowEnd
);
continued = 0;
return start(code);
}
function continueFlow(token) {
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, 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(
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(
effects,
effects.lazy(this.parser.constructs.flow, ok, nok),
'linePrefix',
this.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4
);
}
exports.tokenize = tokenize;
/***/
},
/***/ 9670: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var factorySpace = __nccwpck_require__(8200);
var partialBlankLine = __nccwpck_require__(2244);
var content = __nccwpck_require__(1259);
var tokenize = initializeFlow;
function initializeFlow(effects) {
var self = this;
var initial = effects.attempt(
// Try to parse a blank line.
partialBlankLine,
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;
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;
}
}
exports.tokenize = tokenize;
/***/
},
/***/ 7492: /***/ (
__unused_webpack_module,
exports,
__nccwpck_require__
) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var assign = __nccwpck_require__(3512);
var shallow = __nccwpck_require__(1479);
var text = initializeFactory('text');
var string = 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;
}
}
}
}
}
}
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++;
}
} 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;
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) {
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(data.end),
};
data.end = shallow(token.start);
if (data.start.offset === data.end.offset) {
assign(data, token);
} else {
events.splice(
eventIndex,
0,
['enter', token, context],
['exit', token, context]
);
eventIndex += 2;
}
}
eventIndex++;
}
}
return events;
}
exports.resolver = resolver;
exports.string = string;
exports.text = text;
/***/
},
/***/ 488: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var miniflat = __nccwpck_require__(9042);
var content = __nccwpck_require__(5834);
var document = __nccwpck_require__(9517);
var flow = __nccwpck_require__(9670);
var text = __nccwpck_require__(7492);
var combineExtensions = __nccwpck_require__(8602);
var createTokenizer = __nccwpck_require__(4845);
var constructs = __nccwpck_require__(289);
function parse(options) {
var settings = options || {};
var parser = {
defined: [],
constructs: combineExtensions(
[constructs].concat(miniflat(settings.extensions))
),
content: create(content),
document: create(document),
flow: create(flow),
string: create(text.string),
text: create(text.text),
};
return parser;
function create(initializer) {
return creator;
function creator(from) {
return createTokenizer(parser, initializer, from);
}
}
}
module.exports = parse;
/***/
},
/***/ 6948: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var subtokenize = __nccwpck_require__(14);
function postprocess(events) {
while (!subtokenize(events)) {
// Empty
}
return events;
}
module.exports = postprocess;
/***/
},
/***/ 5603: /***/ (module) => {
'use strict';
var search = /[\0\t\n\r]/g;
function preprocess() {
var start = true;
var column = 1;
var buffer = '';
var atCarriageReturn;
return preprocessor;
function preprocessor(value, encoding, end) {
var chunks = [];
var match;
var next;
var startPosition;
var endPosition;
var code;
value = buffer + value.toString(encoding);
startPosition = 0;
buffer = '';
if (start) {
if (value.charCodeAt(0) === 65279) {
startPosition++;
}
start = undefined;
}
while (startPosition < value.length) {
search.lastIndex = startPosition;
match = search.exec(value);
endPosition = match ? match.index : value.length;
code = value.charCodeAt(endPosition);
if (!match) {
buffer = value.slice(startPosition);
break;
}
if (
code === 10 &&
startPosition === endPosition &&
atCarriageReturn
) {
chunks.push(-3);
atCarriageReturn = undefined;
} else {
if (atCarriageReturn) {
chunks.push(-5);
atCarriageReturn = undefined;
}
if (startPosition < endPosition) {
chunks.push(value.slice(startPosition, endPosition));
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;
}
}
startPosition = endPosition + 1;
}
if (end) {
if (atCarriageReturn) chunks.push(-5);
if (buffer) chunks.push(buffer);
chunks.push(null);
}
return chunks;
}
}
module.exports = preprocess;
/***/
},
/***/ 2116: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var chunkedSplice = __nccwpck_require__(778);
var chunkedPush = __nccwpck_require__(4455);
var shallow = __nccwpck_require__(1479);
var resolveAll = __nccwpck_require__(2004);
var classifyCharacter = __nccwpck_require__(1324);
var movePoint = __nccwpck_require__(6985);
var attention = {
name: 'attention',
tokenize: tokenizeAttention,
resolveAll: resolveAllAttention,
};
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.
//
// Note: performance of this is fine on an mb of normal markdown, but it’s
// a bottleneck for malicious stuff.
while (++index < events.length) {
// Find a token that can close.
if (
events[index][0] === 'enter' &&
events[index][1].type === 'attentionSequence' &&
events[index][1]._close
) {
open = index; // Now walk back to find an opener.
while (open--) {
// Find a token that can open the closer.
if (
events[open][0] === 'exit' &&
events[open][1].type === 'attentionSequence' &&
events[open][1]._open && // If the markers are the same:
context.sliceSerialize(events[open][1]).charCodeAt(0) ===
context.sliceSerialize(events[index][1]).charCodeAt(0)
) {
// If the opening can close or the closing can open,
// and the close size *is not* a multiple of three,
// but the sum of the opening and closing size *is* multiple of three,
// then don’t match.
if (
(events[open][1]._close || events[index][1]._open) &&
(events[index][1].end.offset -
events[index][1].start.offset) %
3 &&
!(
(events[open][1].end.offset -
events[open][1].start.offset +
events[index][1].end.offset -
events[index][1].start.offset) %
3
)
) {
continue;
} // Number of markers to use from the sequence.
use =
events[open][1].end.offset - events[open][1].start.offset >
1 &&
events[index][1].end.offset - events[index][1].start.offset >
1
? 2
: 1;
openingSequence = {
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
start: movePoint(shallow(events[open][1].end), -use),
end: shallow(events[open][1].end),
};
closingSequence = {
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
start: shallow(events[index][1].start),
end: movePoint(shallow(events[index][1].start), use),
};
text = {
type: use > 1 ? 'strongText' : 'emphasisText',
start: shallow(events[open][1].end),
end: shallow(events[index][1].start),
};
group = {
type: use > 1 ? 'strong' : 'emphasis',
start: shallow(openingSequence.start),
end: shallow(closingSequence.end),
};
events[open][1].end = shallow(openingSequence.start);
events[index][1].start = shallow(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(nextEvents, [
['enter', events[open][1], context],
['exit', events[open][1], context],
]);
} // Opening.
nextEvents = chunkedPush(nextEvents, [
['enter', group, context],
['enter', openingSequence, context],
['exit', openingSequence, context],
['enter', text, context],
]); // Between.
nextEvents = chunkedPush(
nextEvents,
resolveAll(
context.parser.constructs.insideSpan.null,
events.slice(open + 1, index),
context
)
); // Closing.
nextEvents = chunkedPush(nextEvents, [
['exit', text, context],
['enter', closingSequence, context],
['exit', closingSequence, context],
['exit', group, context],
]); // If there are more markers in the closing, add them after.
if (
events[index][1].end.offset - events[index][1].start.offset
) {
offset = 2;
nextEvents = chunkedPush(nextEvents, [
['enter', events[index][1], context],
['exit', events[index][1], context],
]);
} else {
offset = 0;
}
chunkedSplice(events, open - 1, index - open + 3, nextEvents);
index = open + nextEvents.length - offset - 2;
break;
}
}
}
} // Remove remaining sequences.
index = -1;
while (++index < events.length) {
if (events[index][1].type === 'attentionSequence') {
events[index][1].type = 'data';
}
}
return events;
}
function tokenizeAttention(effects, ok) {
var before = classifyCharacter(this.previous);
var marker;
return start;
function start(code) {
effects.enter('attentionSequence');
marker = code;
return sequence(code);
}
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(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);
return ok(code);
}
}
module.exports = attention;
/***/
},
/***/ 6681: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var asciiAlphanumeric = __nccwpck_require__(598);
var asciiAlpha = __nccwpck_require__(3847);
var asciiAtext = __nccwpck_require__(245);
var asciiControl = __nccwpck_require__(1336);
var autolink = {
name: 'autolink',
tokenize: tokenizeAutolink,
};
function tokenizeAutolink(effects, ok, nok) {
var size = 1;
return start;
function start(code) {
effects.enter('autolink');
effects.enter('autolinkMarker');
effects.consume(code);
effects.exit('autolinkMarker');
effects.enter('autolinkProtocol');
return open;
}
function open(code) {
if (asciiAlpha(code)) {
effects.consume(code);
return schemeOrEmailAtext;
}
return asciiAtext(code) ? emailAtext(code) : nok(code);
}
function schemeOrEmailAtext(code) {
return code === 43 ||
code === 45 ||
code === 46 ||
asciiAlphanumeric(code)
? schemeInsideOrEmailAtext(code)
: emailAtext(code);
}
function schemeInsideOrEmailAtext(code) {
if (code === 58) {
effects.consume(code);
return urlInside;
}
if (
(code === 43 ||
code === 45 ||
code === 46 ||
asciiAlphanumeric(code)) &&
size++ < 32
) {
effects.consume(code);
return schemeInsideOrEmailAtext;
}
return emailAtext(code);
}
function urlInside(code) {
if (code === 62) {
effects.exit('autolinkProtocol');
return end(code);
}
if (code === 32 || code === 60 || asciiControl(code)) {
return nok(code);
}
effects.consume(code);
return urlInside;
}
function emailAtext(code) {
if (code === 64) {
effects.consume(code);
size = 0;
return emailAtSignOrDot;
}
if (asciiAtext(code)) {
effects.consume(code);
return emailAtext;
}
return nok(code);
}
function emailAtSignOrDot(code) {
return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);
}
function emailLabel(code) {
if (code === 46) {
effects.consume(code);
size = 0;
return emailAtSignOrDot;
}
if (code === 62) {
// Exit, then change the type.
effects.exit('autolinkProtocol').type = 'autolinkEmail';
return end(code);
}
return emailValue(code);
}
function emailValue(code) {
if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
effects.consume(code);
return code === 45 ? emailValue : emailLabel;
}
return nok(code);
}
function end(code) {
effects.enter('autolinkMarker');
effects.consume(code);
effects.exit('autolinkMarker');
effects.exit('autolink');
return ok;
}
}
module.exports = autolink;
/***/
},
/***/ 9025: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
var blockQuote = {
name: 'blockQuote',
tokenize: tokenizeBlockQuoteStart,
continuation: {
tokenize: tokenizeBlockQuoteContinuation,
},
exit: exit,
};
function tokenizeBlockQuoteStart(effects, ok, nok) {
var self = this;
return start;
function start(code) {
if (code === 62) {
if (!self.containerState.open) {
effects.enter('blockQuote', {
_container: true,
});
self.containerState.open = true;
}
effects.enter('blockQuotePrefix');
effects.enter('blockQuoteMarker');
effects.consume(code);
effects.exit('blockQuoteMarker');
return after;
}
return nok(code);
}
function after(code) {
if (markdownSpace(code)) {
effects.enter('blockQuotePrefixWhitespace');
effects.consume(code);
effects.exit('blockQuotePrefixWhitespace');
effects.exit('blockQuotePrefix');
return ok;
}
effects.exit('blockQuotePrefix');
return ok(code);
}
}
function tokenizeBlockQuoteContinuation(effects, ok, nok) {
return factorySpace(
effects,
effects.attempt(blockQuote, ok, nok),
'linePrefix',
this.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4
);
}
function exit(effects) {
effects.exit('blockQuote');
}
module.exports = blockQuote;
/***/
},
/***/ 7128: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var asciiPunctuation = __nccwpck_require__(7909);
var characterEscape = {
name: 'characterEscape',
tokenize: tokenizeCharacterEscape,
};
function tokenizeCharacterEscape(effects, ok, nok) {
return start;
function start(code) {
effects.enter('characterEscape');
effects.enter('escapeMarker');
effects.consume(code);
effects.exit('escapeMarker');
return open;
}
function open(code) {
if (asciiPunctuation(code)) {
effects.enter('characterEscapeValue');
effects.consume(code);
effects.exit('characterEscapeValue');
effects.exit('characterEscape');
return ok;
}
return nok(code);
}
}
module.exports = characterEscape;
/***/
},
/***/ 9500: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var decodeEntity = __nccwpck_require__(3485);
var asciiAlphanumeric = __nccwpck_require__(598);
var asciiDigit = __nccwpck_require__(6996);
var asciiHexDigit = __nccwpck_require__(6526);
function _interopDefaultLegacy(e) {
return e && typeof e === 'object' && 'default' in e
? e
: { default: e };
}
var decodeEntity__default = /*#__PURE__*/ _interopDefaultLegacy(
decodeEntity
);
var characterReference = {
name: 'characterReference',
tokenize: tokenizeCharacterReference,
};
function tokenizeCharacterReference(effects, ok, nok) {
var self = this;
var size = 0;
var max;
var test;
return start;
function start(code) {
effects.enter('characterReference');
effects.enter('characterReferenceMarker');
effects.consume(code);
effects.exit('characterReferenceMarker');
return open;
}
function open(code) {
if (code === 35) {
effects.enter('characterReferenceMarkerNumeric');
effects.consume(code);
effects.exit('characterReferenceMarkerNumeric');
return numeric;
}
effects.enter('characterReferenceValue');
max = 31;
test = asciiAlphanumeric;
return value(code);
}
function numeric(code) {
if (code === 88 || code === 120) {
effects.enter('characterReferenceMarkerHexadecimal');
effects.consume(code);
effects.exit('characterReferenceMarkerHexadecimal');
effects.enter('characterReferenceValue');
max = 6;
test = asciiHexDigit;
return value;
}
effects.enter('characterReferenceValue');
max = 7;
test = asciiDigit;
return value(code);
}
function value(code) {
var token;
if (code === 59 && size) {
token = effects.exit('characterReferenceValue');
if (
test === asciiAlphanumeric &&
!decodeEntity__default['default'](self.sliceSerialize(token))
) {
return nok(code);
}
effects.enter('characterReferenceMarker');
effects.consume(code);
effects.exit('characterReferenceMarker');
effects.exit('characterReference');
return ok;
}
if (test(code) && size++ < max) {
effects.consume(code);
return value;
}
return nok(code);
}
}
module.exports = characterReference;
/***/
},
/***/ 3268: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var prefixSize = __nccwpck_require__(3722);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var codeFenced = {
name: 'codeFenced',
tokenize: tokenizeCodeFenced,
concrete: true,
};
function tokenizeCodeFenced(effects, ok, nok) {
var self = this;
var closingFenceConstruct = {
tokenize: tokenizeClosingFence,
partial: true,
};
var initialPrefix = prefixSize(this.events, 'linePrefix');
var sizeOpen = 0;
var marker;
return start;
function start(code) {
effects.enter('codeFenced');
effects.enter('codeFencedFence');
effects.enter('codeFencedFenceSequence');
marker = code;
return sequenceOpen(code);
}
function sequenceOpen(code) {
if (code === marker) {
effects.consume(code);
sizeOpen++;
return sequenceOpen;
}
effects.exit('codeFencedFenceSequence');
return sizeOpen < 3
? nok(code)
: factorySpace(effects, infoOpen, 'whitespace')(code);
}
function infoOpen(code) {
if (code === null || markdownLineEnding(code)) {
return openAfter(code);
}
effects.enter('codeFencedFenceInfo');
effects.enter('chunkString', {
contentType: 'string',
});
return info(code);
}
function info(code) {
if (code === null || markdownLineEndingOrSpace(code)) {
effects.exit('chunkString');
effects.exit('codeFencedFenceInfo');
return factorySpace(effects, infoAfter, 'whitespace')(code);
}
if (code === 96 && code === marker) return nok(code);
effects.consume(code);
return info;
}
function infoAfter(code) {
if (code === null || markdownLineEnding(code)) {
return openAfter(code);
}
effects.enter('codeFencedFenceMeta');
effects.enter('chunkString', {
contentType: 'string',
});
return meta(code);
}
function meta(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('chunkString');
effects.exit('codeFencedFenceMeta');
return openAfter(code);
}
if (code === 96 && code === marker) return nok(code);
effects.consume(code);
return meta;
}
function openAfter(code) {
effects.exit('codeFencedFence');
return self.interrupt ? ok(code) : content(code);
}
function content(code) {
if (code === null) {
return after(code);
}
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return effects.attempt(
closingFenceConstruct,
after,
initialPrefix
? factorySpace(
effects,
content,
'linePrefix',
initialPrefix + 1
)
: content
);
}
effects.enter('codeFlowValue');
return contentContinue(code);
}
function contentContinue(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('codeFlowValue');
return content(code);
}
effects.consume(code);
return contentContinue;
}
function after(code) {
effects.exit('codeFenced');
return ok(code);
}
function tokenizeClosingFence(effects, ok, nok) {
var size = 0;
return factorySpace(
effects,
closingSequenceStart,
'linePrefix',
this.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4
);
function closingSequenceStart(code) {
effects.enter('codeFencedFence');
effects.enter('codeFencedFenceSequence');
return closingSequence(code);
}
function closingSequence(code) {
if (code === marker) {
effects.consume(code);
size++;
return closingSequence;
}
if (size < sizeOpen) return nok(code);
effects.exit('codeFencedFenceSequence');
return factorySpace(
effects,
closingSequenceEnd,
'whitespace'
)(code);
}
function closingSequenceEnd(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('codeFencedFence');
return ok(code);
}
return nok(code);
}
}
}
module.exports = codeFenced;
/***/
},
/***/ 907: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var chunkedSplice = __nccwpck_require__(778);
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var prefixSize = __nccwpck_require__(3722);
var codeIndented = {
name: 'codeIndented',
tokenize: tokenizeCodeIndented,
resolve: resolveCodeIndented,
};
var indentedContentConstruct = {
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(events, 0, 0, [['enter', code, context]]);
chunkedSplice(events, events.length, 0, [['exit', code, context]]);
return events;
}
function tokenizeCodeIndented(effects, ok, nok) {
return effects.attempt(indentedContentConstruct, afterPrefix, nok);
function afterPrefix(code) {
if (code === null) {
return ok(code);
}
if (markdownLineEnding(code)) {
return effects.attempt(
indentedContentConstruct,
afterPrefix,
ok
)(code);
}
effects.enter('codeFlowValue');
return content(code);
}
function content(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('codeFlowValue');
return afterPrefix(code);
}
effects.consume(code);
return content;
}
}
function tokenizeIndentedContent(effects, ok, nok) {
var self = this;
return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);
function afterPrefix(code) {
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1);
}
return prefixSize(self.events, 'linePrefix') < 4
? nok(code)
: ok(code);
}
}
module.exports = codeIndented;
/***/
},
/***/ 7033: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var codeText = {
name: 'codeText',
tokenize: tokenizeCodeText,
resolve: resolveCodeText,
previous: previous,
};
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.
if (
(events[headEnterIndex][1].type === 'lineEnding' ||
events[headEnterIndex][1].type === 'space') &&
(events[tailExitIndex][1].type === 'lineEnding' ||
events[tailExitIndex][1].type === 'space')
) {
index = headEnterIndex; // And we have data.
while (++index < tailExitIndex) {
if (events[index][1].type === 'codeTextData') {
// Then we have padding.
events[tailExitIndex][1].type = events[headEnterIndex][1].type =
'codeTextPadding';
headEnterIndex += 2;
tailExitIndex -= 2;
break;
}
}
} // Merge adjacent spaces and data.
index = headEnterIndex - 1;
tailExitIndex++;
while (++index <= tailExitIndex) {
if (enter === undefined) {
if (
index !== tailExitIndex &&
events[index][1].type !== 'lineEnding'
) {
enter = index;
}
} else if (
index === tailExitIndex ||
events[index][1].type === 'lineEnding'
) {
events[enter][1].type = 'codeTextData';
if (index !== enter + 2) {
events[enter][1].end = events[index - 1][1].end;
events.splice(enter + 2, index - enter - 2);
tailExitIndex -= index - enter - 2;
index = enter + 2;
}
enter = undefined;
}
}
return events;
}
function previous(code) {
// If there is a previous code, there will always be a tail.
return (
code !== 96 ||
this.events[this.events.length - 1][1].type === 'characterEscape'
);
}
function tokenizeCodeText(effects, ok, nok) {
var sizeOpen = 0;
var size;
var token;
return start;
function start(code) {
effects.enter('codeText');
effects.enter('codeTextSequence');
return openingSequence(code);
}
function openingSequence(code) {
if (code === 96) {
effects.consume(code);
sizeOpen++;
return openingSequence;
}
effects.exit('codeTextSequence');
return gap(code);
}
function gap(code) {
// EOF.
if (code === null) {
return nok(code);
} // Closing fence?
// Could also be data.
if (code === 96) {
token = effects.enter('codeTextSequence');
size = 0;
return closingSequence(code);
} // Tabs don’t work, and virtual spaces don’t make sense.
if (code === 32) {
effects.enter('space');
effects.consume(code);
effects.exit('space');
return gap;
}
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return gap;
} // Data.
effects.enter('codeTextData');
return data(code);
} // In code.
function data(code) {
if (
code === null ||
code === 32 ||
code === 96 ||
markdownLineEnding(code)
) {
effects.exit('codeTextData');
return gap(code);
}
effects.consume(code);
return data;
} // Closing fence.
function closingSequence(code) {
// More.
if (code === 96) {
effects.consume(code);
size++;
return closingSequence;
} // Done!
if (size === sizeOpen) {
effects.exit('codeTextSequence');
effects.exit('codeText');
return ok(code);
} // More or less accents: mark as data.
token.type = 'codeTextData';
return data(code);
}
}
module.exports = codeText;
/***/
},
/***/ 1259: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var prefixSize = __nccwpck_require__(3722);
var subtokenize = __nccwpck_require__(14);
// No name because it must not be turned off.
var content = {
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(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(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(effects, prefixed, 'linePrefix');
}
function prefixed(code) {
if (code === null || markdownLineEnding(code)) {
return nok(code);
}
if (
self.parser.constructs.disable.null.indexOf('codeIndented') > -1 ||
prefixSize(self.events, 'linePrefix') < 4
) {
return effects.interrupt(
self.parser.constructs.flow,
nok,
ok
)(code);
}
return ok(code);
}
}
module.exports = content;
/***/
},
/***/ 1193: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var normalizeIdentifier = __nccwpck_require__(712);
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var factoryDestination = __nccwpck_require__(9851);
var factoryLabel = __nccwpck_require__(349);
var factoryWhitespace = __nccwpck_require__(3168);
var factoryTitle = __nccwpck_require__(9469);
var definition = {
name: 'definition',
tokenize: tokenizeDefinition,
};
var titleConstruct = {
tokenize: tokenizeTitle,
partial: true,
};
function tokenizeDefinition(effects, ok, nok) {
var self = this;
var identifier;
return start;
function start(code) {
effects.enter('definition');
return factoryLabel.call(
self,
effects,
labelAfter,
nok,
'definitionLabel',
'definitionLabelMarker',
'definitionLabelString'
)(code);
}
function labelAfter(code) {
identifier = normalizeIdentifier(
self
.sliceSerialize(self.events[self.events.length - 1][1])
.slice(1, -1)
);
if (code === 58) {
effects.enter('definitionMarker');
effects.consume(code);
effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.
return factoryWhitespace(
effects,
factoryDestination(
effects,
effects.attempt(
titleConstruct,
factorySpace(effects, after, 'whitespace'),
factorySpace(effects, after, 'whitespace')
),
nok,
'definitionDestination',
'definitionDestinationLiteral',
'definitionDestinationLiteralMarker',
'definitionDestinationRaw',
'definitionDestinationString'
)
);
}
return nok(code);
}
function after(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('definition');
if (self.parser.defined.indexOf(identifier) < 0) {
self.parser.defined.push(identifier);
}
return ok(code);
}
return nok(code);
}
}
function tokenizeTitle(effects, ok, nok) {
return start;
function start(code) {
return markdownLineEndingOrSpace(code)
? factoryWhitespace(effects, before)(code)
: nok(code);
}
function before(code) {
if (code === 34 || code === 39 || code === 40) {
return factoryTitle(
effects,
factorySpace(effects, after, 'whitespace'),
nok,
'definitionTitle',
'definitionTitleMarker',
'definitionTitleString'
)(code);
}
return nok(code);
}
function after(code) {
return code === null || markdownLineEnding(code)
? ok(code)
: nok(code);
}
}
module.exports = definition;
/***/
},
/***/ 9851: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var asciiControl = __nccwpck_require__(1336);
// eslint-disable-next-line max-params
function destinationFactory(
effects,
ok,
nok,
type,
literalType,
literalMarkerType,
rawType,
stringType,
max
) {
var limit = max || Infinity;
var balance = 0;
return start;
function start(code) {
if (code === 60) {
effects.enter(type);
effects.enter(literalType);
effects.enter(literalMarkerType);
effects.consume(code);
effects.exit(literalMarkerType);
return destinationEnclosedBefore;
}
if (asciiControl(code)) {
return nok(code);
}
effects.enter(type);
effects.enter(rawType);
effects.enter(stringType);
effects.enter('chunkString', {
contentType: 'string',
});
return destinationRaw(code);
}
function destinationEnclosedBefore(code) {
if (code === 62) {
effects.enter(literalMarkerType);
effects.consume(code);
effects.exit(literalMarkerType);
effects.exit(literalType);
effects.exit(type);
return ok;
}
effects.enter(stringType);
effects.enter('chunkString', {
contentType: 'string',
});
return destinationEnclosed(code);
}
function destinationEnclosed(code) {
if (code === 62) {
effects.exit('chunkString');
effects.exit(stringType);
return destinationEnclosedBefore(code);
}
if (code === null || code === 60 || markdownLineEnding(code)) {
return nok(code);
}
effects.consume(code);
return code === 92 ? destinationEnclosedEscape : destinationEnclosed;
}
function destinationEnclosedEscape(code) {
if (code === 60 || code === 62 || code === 92) {
effects.consume(code);
return destinationEnclosed;
}
return destinationEnclosed(code);
}
function destinationRaw(code) {
if (code === 40) {
if (++balance > limit) return nok(code);
effects.consume(code);
return destinationRaw;
}
if (code === 41) {
if (!balance--) {
effects.exit('chunkString');
effects.exit(stringType);
effects.exit(rawType);
effects.exit(type);
return ok(code);
}
effects.consume(code);
return destinationRaw;
}
if (code === null || markdownLineEndingOrSpace(code)) {
if (balance) return nok(code);
effects.exit('chunkString');
effects.exit(stringType);
effects.exit(rawType);
effects.exit(type);
return ok(code);
}
if (asciiControl(code)) return nok(code);
effects.consume(code);
return code === 92 ? destinationRawEscape : destinationRaw;
}
function destinationRawEscape(code) {
if (code === 40 || code === 41 || code === 92) {
effects.consume(code);
return destinationRaw;
}
return destinationRaw(code);
}
}
module.exports = destinationFactory;
/***/
},
/***/ 349: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
// eslint-disable-next-line max-params
function labelFactory(effects, ok, nok, type, markerType, stringType) {
var self = this;
var size = 0;
var data;
return start;
function start(code) {
effects.enter(type);
effects.enter(markerType);
effects.consume(code);
effects.exit(markerType);
effects.enter(stringType);
return atBreak;
}
function atBreak(code) {
if (
code === null ||
code === 91 ||
(code === 93 && !data) ||
/* c8 ignore next */
(code === 94 &&
/* c8 ignore next */
!size &&
/* c8 ignore next */
'_hiddenFootnoteSupport' in self.parser.constructs) ||
size > 999
) {
return nok(code);
}
if (code === 93) {
effects.exit(stringType);
effects.enter(markerType);
effects.consume(code);
effects.exit(markerType);
effects.exit(type);
return ok;
}
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return atBreak;
}
effects.enter('chunkString', {
contentType: 'string',
});
return label(code);
}
function label(code) {
if (
code === null ||
code === 91 ||
code === 93 ||
markdownLineEnding(code) ||
size++ > 999
) {
effects.exit('chunkString');
return atBreak(code);
}
effects.consume(code);
data = data || !markdownSpace(code);
return code === 92 ? labelEscape : label;
}
function labelEscape(code) {
if (code === 91 || code === 92 || code === 93) {
effects.consume(code);
size++;
return label;
}
return label(code);
}
}
module.exports = labelFactory;
/***/
},
/***/ 8200: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownSpace = __nccwpck_require__(5989);
function spaceFactory(effects, ok, type, max) {
var limit = max ? max - 1 : Infinity;
var size = 0;
return start;
function start(code) {
if (markdownSpace(code)) {
effects.enter(type);
return prefix(code);
}
return ok(code);
}
function prefix(code) {
if (markdownSpace(code) && size++ < limit) {
effects.consume(code);
return prefix;
}
effects.exit(type);
return ok(code);
}
}
module.exports = spaceFactory;
/***/
},
/***/ 9469: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
function titleFactory(effects, ok, nok, type, markerType, stringType) {
var marker;
return start;
function start(code) {
effects.enter(type);
effects.enter(markerType);
effects.consume(code);
effects.exit(markerType);
marker = code === 40 ? 41 : code;
return atFirstTitleBreak;
}
function atFirstTitleBreak(code) {
if (code === marker) {
effects.enter(markerType);
effects.consume(code);
effects.exit(markerType);
effects.exit(type);
return ok;
}
effects.enter(stringType);
return atTitleBreak(code);
}
function atTitleBreak(code) {
if (code === marker) {
effects.exit(stringType);
return atFirstTitleBreak(marker);
}
if (code === null) {
return nok(code);
} // Note: blank lines can’t exist in content.
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return factorySpace(effects, atTitleBreak, 'linePrefix');
}
effects.enter('chunkString', {
contentType: 'string',
});
return title(code);
}
function title(code) {
if (code === marker || code === null || markdownLineEnding(code)) {
effects.exit('chunkString');
return atTitleBreak(code);
}
effects.consume(code);
return code === 92 ? titleEscape : title;
}
function titleEscape(code) {
if (code === marker || code === 92) {
effects.consume(code);
return title;
}
return title(code);
}
}
module.exports = titleFactory;
/***/
},
/***/ 3168: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
function whitespaceFactory(effects, ok) {
var seen;
return start;
function start(code) {
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
seen = true;
return start;
}
if (markdownSpace(code)) {
return factorySpace(
effects,
start,
seen ? 'linePrefix' : 'lineSuffix'
)(code);
}
return ok(code);
}
}
module.exports = whitespaceFactory;
/***/
},
/***/ 7608: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var hardBreakEscape = {
name: 'hardBreakEscape',
tokenize: tokenizeHardBreakEscape,
};
function tokenizeHardBreakEscape(effects, ok, nok) {
return start;
function start(code) {
effects.enter('hardBreakEscape');
effects.enter('escapeMarker');
effects.consume(code);
return open;
}
function open(code) {
if (markdownLineEnding(code)) {
effects.exit('escapeMarker');
effects.exit('hardBreakEscape');
return ok(code);
}
return nok(code);
}
}
module.exports = hardBreakEscape;
/***/
},
/***/ 4558: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var chunkedSplice = __nccwpck_require__(778);
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var headingAtx = {
name: 'headingAtx',
tokenize: tokenizeHeadingAtx,
resolve: resolveHeadingAtx,
};
function resolveHeadingAtx(events, context) {
var contentEnd = events.length - 2;
var contentStart = 3;
var content;
var text; // Prefix whitespace, part of the opening.
if (events[contentStart][1].type === 'whitespace') {
contentStart += 2;
} // Suffix whitespace, part of the closing.
if (
contentEnd - 2 > contentStart &&
events[contentEnd][1].type === 'whitespace'
) {
contentEnd -= 2;
}
if (
events[contentEnd][1].type === 'atxHeadingSequence' &&
(contentStart === contentEnd - 1 ||
(contentEnd - 4 > contentStart &&
events[contentEnd - 2][1].type === 'whitespace'))
) {
contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
}
if (contentEnd > contentStart) {
content = {
type: 'atxHeadingText',
start: events[contentStart][1].start,
end: events[contentEnd][1].end,
};
text = {
type: 'chunkText',
start: events[contentStart][1].start,
end: events[contentEnd][1].end,
contentType: 'text',
};
chunkedSplice(events, contentStart, contentEnd - contentStart + 1, [
['enter', content, context],
['enter', text, context],
['exit', text, context],
['exit', content, context],
]);
}
return events;
}
function tokenizeHeadingAtx(effects, ok, nok) {
var self = this;
var size = 0;
return start;
function start(code) {
effects.enter('atxHeading');
effects.enter('atxHeadingSequence');
return fenceOpenInside(code);
}
function fenceOpenInside(code) {
if (code === 35 && size++ < 6) {
effects.consume(code);
return fenceOpenInside;
}
if (code === null || markdownLineEndingOrSpace(code)) {
effects.exit('atxHeadingSequence');
return self.interrupt ? ok(code) : headingBreak(code);
}
return nok(code);
}
function headingBreak(code) {
if (code === 35) {
effects.enter('atxHeadingSequence');
return sequence(code);
}
if (code === null || markdownLineEnding(code)) {
effects.exit('atxHeading');
return ok(code);
}
if (markdownSpace(code)) {
return factorySpace(effects, headingBreak, 'whitespace')(code);
}
effects.enter('atxHeadingText');
return data(code);
}
function sequence(code) {
if (code === 35) {
effects.consume(code);
return sequence;
}
effects.exit('atxHeadingSequence');
return headingBreak(code);
}
function data(code) {
if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
effects.exit('atxHeadingText');
return headingBreak(code);
}
effects.consume(code);
return data;
}
}
module.exports = headingAtx;
/***/
},
/***/ 6791: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var fromCharCode = __nccwpck_require__(3531);
var asciiAlphanumeric = __nccwpck_require__(598);
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
var partialBlankLine = __nccwpck_require__(2244);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var asciiAlpha = __nccwpck_require__(3847);
var htmlBlockNames = __nccwpck_require__(5159);
var htmlRawNames = __nccwpck_require__(4677);
var htmlFlow = {
name: 'htmlFlow',
tokenize: tokenizeHtmlFlow,
resolveTo: resolveToHtmlFlow,
concrete: true,
};
var nextBlankConstruct = {
tokenize: tokenizeNextBlank,
partial: true,
};
function resolveToHtmlFlow(events) {
var index = events.length;
while (index--) {
if (
events[index][0] === 'enter' &&
events[index][1].type === 'htmlFlow'
) {
break;
}
}
if (index > 1 && events[index - 2][1].type === 'linePrefix') {
// Add the prefix start to the HTML token.
events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.
events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.
events.splice(index - 2, 2);
}
return events;
}
function tokenizeHtmlFlow(effects, ok, nok) {
var self = this;
var kind;
var startTag;
var buffer;
var index;
var marker;
return start;
function start(code) {
effects.enter('htmlFlow');
effects.enter('htmlFlowData');
effects.consume(code);
return open;
}
function open(code) {
if (code === 33) {
effects.consume(code);
return declarationStart;
}
if (code === 47) {
effects.consume(code);
return tagCloseStart;
}
if (code === 63) {
effects.consume(code);
kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`
// right now, so we do need to search for `>`, similar to declarations.
return self.interrupt ? ok : continuationDeclarationInside;
}
if (asciiAlpha(code)) {
effects.consume(code);
buffer = fromCharCode(code);
startTag = true;
return tagName;
}
return nok(code);
}
function declarationStart(code) {
if (code === 45) {
effects.consume(code);
kind = 2;
return commentOpenInside;
}
if (code === 91) {
effects.consume(code);
kind = 5;
buffer = 'CDATA[';
index = 0;
return cdataOpenInside;
}
if (asciiAlpha(code)) {
effects.consume(code);
kind = 4;
return self.interrupt ? ok : continuationDeclarationInside;
}
return nok(code);
}
function commentOpenInside(code) {
if (code === 45) {
effects.consume(code);
return self.interrupt ? ok : continuationDeclarationInside;
}
return nok(code);
}
function cdataOpenInside(code) {
if (code === buffer.charCodeAt(index++)) {
effects.consume(code);
return index === buffer.length
? self.interrupt
? ok
: continuation
: cdataOpenInside;
}
return nok(code);
}
function tagCloseStart(code) {
if (asciiAlpha(code)) {
effects.consume(code);
buffer = fromCharCode(code);
return tagName;
}
return nok(code);
}
function tagName(code) {
if (
code === null ||
code === 47 ||
code === 62 ||
markdownLineEndingOrSpace(code)
) {
if (
code !== 47 &&
startTag &&
htmlRawNames.indexOf(buffer.toLowerCase()) > -1
) {
kind = 1;
return self.interrupt ? ok(code) : continuation(code);
}
if (htmlBlockNames.indexOf(buffer.toLowerCase()) > -1) {
kind = 6;
if (code === 47) {
effects.consume(code);
return basicSelfClosing;
}
return self.interrupt ? ok(code) : continuation(code);
}
kind = 7; // Do not support complete HTML when interrupting.
return self.interrupt
? nok(code)
: startTag
? completeAttributeNameBefore(code)
: completeClosingTagAfter(code);
}
if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
buffer += fromCharCode(code);
return tagName;
}
return nok(code);
}
function basicSelfClosing(code) {
if (code === 62) {
effects.consume(code);
return self.interrupt ? ok : continuation;
}
return nok(code);
}
function completeClosingTagAfter(code) {
if (markdownSpace(code)) {
effects.consume(code);
return completeClosingTagAfter;
}
return completeEnd(code);
}
function completeAttributeNameBefore(code) {
if (code === 47) {
effects.consume(code);
return completeEnd;
}
if (code === 58 || code === 95 || asciiAlpha(code)) {
effects.consume(code);
return completeAttributeName;
}
if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeNameBefore;
}
return completeEnd(code);
}
function completeAttributeName(code) {
if (
code === 45 ||
code === 46 ||
code === 58 ||
code === 95 ||
asciiAlphanumeric(code)
) {
effects.consume(code);
return completeAttributeName;
}
return completeAttributeNameAfter(code);
}
function completeAttributeNameAfter(code) {
if (code === 61) {
effects.consume(code);
return completeAttributeValueBefore;
}
if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeNameAfter;
}
return completeAttributeNameBefore(code);
}
function completeAttributeValueBefore(code) {
if (
code === null ||
code === 60 ||
code === 61 ||
code === 62 ||
code === 96
) {
return nok(code);
}
if (code === 34 || code === 39) {
effects.consume(code);
marker = code;
return completeAttributeValueQuoted;
}
if (markdownSpace(code)) {
effects.consume(code);
return completeAttributeValueBefore;
}
marker = undefined;
return completeAttributeValueUnquoted(code);
}
function completeAttributeValueQuoted(code) {
if (code === marker) {
effects.consume(code);
return completeAttributeValueQuotedAfter;
}
if (code === null || markdownLineEnding(code)) {
return nok(code);
}
effects.consume(code);
return completeAttributeValueQuoted;
}
function completeAttributeValueUnquoted(code) {
if (
code === null ||
code === 34 ||
code === 39 ||
code === 60 ||
code === 61 ||
code === 62 ||
code === 96 ||
markdownLineEndingOrSpace(code)
) {
return completeAttributeNameAfter(code);
}
effects.consume(code);
return completeAttributeValueUnquoted;
}
function completeAttributeValueQuotedAfter(code) {
if (code === 47 || code === 62 || markdownSpace(code)) {
return completeAttributeNameBefore(code);
}
return nok(code);
}
function completeEnd(code) {
if (code === 62) {
effects.consume(code);
return completeAfter;
}
return nok(code);
}
function completeAfter(code) {
if (markdownSpace(code)) {
effects.consume(code);
return completeAfter;
}
return code === null || markdownLineEnding(code)
? continuation(code)
: nok(code);
}
function continuation(code) {
if (code === 45 && kind === 2) {
effects.consume(code);
return continuationCommentInside;
}
if (code === 60 && kind === 1) {
effects.consume(code);
return continuationRawTagOpen;
}
if (code === 62 && kind === 4) {
effects.consume(code);
return continuationClose;
}
if (code === 63 && kind === 3) {
effects.consume(code);
return continuationDeclarationInside;
}
if (code === 93 && kind === 5) {
effects.consume(code);
return continuationCharacterDataInside;
}
if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {
return effects.check(
nextBlankConstruct,
continuationClose,
continuationAtLineEnding
)(code);
}
if (code === null || markdownLineEnding(code)) {
return continuationAtLineEnding(code);
}
effects.consume(code);
return continuation;
}
function continuationAtLineEnding(code) {
effects.exit('htmlFlowData');
return htmlContinueStart(code);
}
function htmlContinueStart(code) {
if (code === null) {
return done(code);
}
if (markdownLineEnding(code)) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return htmlContinueStart;
}
effects.enter('htmlFlowData');
return continuation(code);
}
function continuationCommentInside(code) {
if (code === 45) {
effects.consume(code);
return continuationDeclarationInside;
}
return continuation(code);
}
function continuationRawTagOpen(code) {
if (code === 47) {
effects.consume(code);
buffer = '';
return continuationRawEndTag;
}
return continuation(code);
}
function continuationRawEndTag(code) {
if (code === 62 && htmlRawNames.indexOf(buffer.toLowerCase()) > -1) {
effects.consume(code);
return continuationClose;
}
if (asciiAlpha(code) && buffer.length < 8) {
effects.consume(code);
buffer += fromCharCode(code);
return continuationRawEndTag;
}
return continuation(code);
}
function continuationCharacterDataInside(code) {
if (code === 93) {
effects.consume(code);
return continuationDeclarationInside;
}
return continuation(code);
}
function continuationDeclarationInside(code) {
if (code === 62) {
effects.consume(code);
return continuationClose;
}
return continuation(code);
}
function continuationClose(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('htmlFlowData');
return done(code);
}
effects.consume(code);
return continuationClose;
}
function done(code) {
effects.exit('htmlFlow');
return ok(code);
}
}
function tokenizeNextBlank(effects, ok, nok) {
return start;
function start(code) {
effects.exit('htmlFlowData');
effects.enter('lineEndingBlank');
effects.consume(code);
effects.exit('lineEndingBlank');
return effects.attempt(partialBlankLine, ok, nok);
}
}
module.exports = htmlFlow;
/***/
},
/***/ 7743: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var asciiAlphanumeric = __nccwpck_require__(598);
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var asciiAlpha = __nccwpck_require__(3847);
var htmlText = {
name: 'htmlText',
tokenize: tokenizeHtmlText,
};
function tokenizeHtmlText(effects, ok, nok) {
var self = this;
var marker;
var buffer;
var index;
var returnState;
return start;
function start(code) {
effects.enter('htmlText');
effects.enter('htmlTextData');
effects.consume(code);
return open;
}
function open(code) {
if (code === 33) {
effects.consume(code);
return declarationOpen;
}
if (code === 47) {
effects.consume(code);
return tagCloseStart;
}
if (code === 63) {
effects.consume(code);
return instruction;
}
if (asciiAlpha(code)) {
effects.consume(code);
return tagOpen;
}
return nok(code);
}
function declarationOpen(code) {
if (code === 45) {
effects.consume(code);
return commentOpen;
}
if (code === 91) {
effects.consume(code);
buffer = 'CDATA[';
index = 0;
return cdataOpen;
}
if (asciiAlpha(code)) {
effects.consume(code);
return declaration;
}
return nok(code);
}
function commentOpen(code) {
if (code === 45) {
effects.consume(code);
return commentStart;
}
return nok(code);
}
function commentStart(code) {
if (code === null || code === 62) {
return nok(code);
}
if (code === 45) {
effects.consume(code);
return commentStartDash;
}
return comment(code);
}
function commentStartDash(code) {
if (code === null || code === 62) {
return nok(code);
}
return comment(code);
}
function comment(code) {
if (code === null) {
return nok(code);
}
if (code === 45) {
effects.consume(code);
return commentClose;
}
if (markdownLineEnding(code)) {
returnState = comment;
return atLineEnding(code);
}
effects.consume(code);
return comment;
}
function commentClose(code) {
if (code === 45) {
effects.consume(code);
return end;
}
return comment(code);
}
function cdataOpen(code) {
if (code === buffer.charCodeAt(index++)) {
effects.consume(code);
return index === buffer.length ? cdata : cdataOpen;
}
return nok(code);
}
function cdata(code) {
if (code === null) {
return nok(code);
}
if (code === 93) {
effects.consume(code);
return cdataClose;
}
if (markdownLineEnding(code)) {
returnState = cdata;
return atLineEnding(code);
}
effects.consume(code);
return cdata;
}
function cdataClose(code) {
if (code === 93) {
effects.consume(code);
return cdataEnd;
}
return cdata(code);
}
function cdataEnd(code) {
if (code === 62) {
return end(code);
}
if (code === 93) {
effects.consume(code);
return cdataEnd;
}
return cdata(code);
}
function declaration(code) {
if (code === null || code === 62) {
return end(code);
}
if (markdownLineEnding(code)) {
returnState = declaration;
return atLineEnding(code);
}
effects.consume(code);
return declaration;
}
function instruction(code) {
if (code === null) {
return nok(code);
}
if (code === 63) {
effects.consume(code);
return instructionClose;
}
if (markdownLineEnding(code)) {
returnState = instruction;
return atLineEnding(code);
}
effects.consume(code);
return instruction;
}
function instructionClose(code) {
return code === 62 ? end(code) : instruction(code);
}
function tagCloseStart(code) {
if (asciiAlpha(code)) {
effects.consume(code);
return tagClose;
}
return nok(code);
}
function tagClose(code) {
if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
return tagClose;
}
return tagCloseBetween(code);
}
function tagCloseBetween(code) {
if (markdownLineEnding(code)) {
returnState = tagCloseBetween;
return atLineEnding(code);
}
if (markdownSpace(code)) {
effects.consume(code);
return tagCloseBetween;
}
return end(code);
}
function tagOpen(code) {
if (code === 45 || asciiAlphanumeric(code)) {
effects.consume(code);
return tagOpen;
}
if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code);
}
return nok(code);
}
function tagOpenBetween(code) {
if (code === 47) {
effects.consume(code);
return end;
}
if (code === 58 || code === 95 || asciiAlpha(code)) {
effects.consume(code);
return tagOpenAttributeName;
}
if (markdownLineEnding(code)) {
returnState = tagOpenBetween;
return atLineEnding(code);
}
if (markdownSpace(code)) {
effects.consume(code);
return tagOpenBetween;
}
return end(code);
}
function tagOpenAttributeName(code) {
if (
code === 45 ||
code === 46 ||
code === 58 ||
code === 95 ||
asciiAlphanumeric(code)
) {
effects.consume(code);
return tagOpenAttributeName;
}
return tagOpenAttributeNameAfter(code);
}
function tagOpenAttributeNameAfter(code) {
if (code === 61) {
effects.consume(code);
return tagOpenAttributeValueBefore;
}
if (markdownLineEnding(code)) {
returnState = tagOpenAttributeNameAfter;
return atLineEnding(code);
}
if (markdownSpace(code)) {
effects.consume(code);
return tagOpenAttributeNameAfter;
}
return tagOpenBetween(code);
}
function tagOpenAttributeValueBefore(code) {
if (
code === null ||
code === 60 ||
code === 61 ||
code === 62 ||
code === 96
) {
return nok(code);
}
if (code === 34 || code === 39) {
effects.consume(code);
marker = code;
return tagOpenAttributeValueQuoted;
}
if (markdownLineEnding(code)) {
returnState = tagOpenAttributeValueBefore;
return atLineEnding(code);
}
if (markdownSpace(code)) {
effects.consume(code);
return tagOpenAttributeValueBefore;
}
effects.consume(code);
marker = undefined;
return tagOpenAttributeValueUnquoted;
}
function tagOpenAttributeValueQuoted(code) {
if (code === marker) {
effects.consume(code);
return tagOpenAttributeValueQuotedAfter;
}
if (code === null) {
return nok(code);
}
if (markdownLineEnding(code)) {
returnState = tagOpenAttributeValueQuoted;
return atLineEnding(code);
}
effects.consume(code);
return tagOpenAttributeValueQuoted;
}
function tagOpenAttributeValueQuotedAfter(code) {
if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code);
}
return nok(code);
}
function tagOpenAttributeValueUnquoted(code) {
if (
code === null ||
code === 34 ||
code === 39 ||
code === 60 ||
code === 61 ||
code === 96
) {
return nok(code);
}
if (code === 62 || markdownLineEndingOrSpace(code)) {
return tagOpenBetween(code);
}
effects.consume(code);
return tagOpenAttributeValueUnquoted;
} // We can’t have blank lines in content, so no need to worry about empty
// tokens.
function atLineEnding(code) {
effects.exit('htmlTextData');
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return factorySpace(
effects,
afterPrefix,
'linePrefix',
self.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4
);
}
function afterPrefix(code) {
effects.enter('htmlTextData');
return returnState(code);
}
function end(code) {
if (code === 62) {
effects.consume(code);
effects.exit('htmlTextData');
effects.exit('htmlText');
return ok;
}
return nok(code);
}
}
module.exports = htmlText;
/***/
},
/***/ 9797: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var chunkedSplice = __nccwpck_require__(778);
var chunkedPush = __nccwpck_require__(4455);
var normalizeIdentifier = __nccwpck_require__(712);
var shallow = __nccwpck_require__(1479);
var resolveAll = __nccwpck_require__(2004);
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var factoryDestination = __nccwpck_require__(9851);
var factoryLabel = __nccwpck_require__(349);
var factoryWhitespace = __nccwpck_require__(3168);
var factoryTitle = __nccwpck_require__(9469);
var labelEnd = {
name: 'labelEnd',
tokenize: tokenizeLabelEnd,
resolveTo: resolveToLabelEnd,
resolveAll: resolveAllLabelEnd,
};
var resourceConstruct = {
tokenize: tokenizeResource,
};
var fullReferenceConstruct = {
tokenize: tokenizeFullReference,
};
var collapsedReferenceConstruct = {
tokenize: tokenizeCollapsedReference,
};
function resolveAllLabelEnd(events) {
var index = -1;
var token;
while (++index < events.length) {
token = events[index][1];
if (
!token._used &&
(token.type === 'labelImage' ||
token.type === 'labelLink' ||
token.type === 'labelEnd')
) {
// Remove the marker.
events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);
token.type = 'data';
index++;
}
}
return events;
}
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.
while (index--) {
token = events[index][1];
if (open) {
// If we see another link, or inactive link label, we’ve been here before.
if (
token.type === 'link' ||
(token.type === 'labelLink' && token._inactive)
) {
break;
} // Mark other link openings as inactive, as we can’t have links in
// links.
if (events[index][0] === 'enter' && token.type === 'labelLink') {
token._inactive = true;
}
} else if (close) {
if (
events[index][0] === 'enter' &&
(token.type === 'labelImage' || token.type === 'labelLink') &&
!token._balanced
) {
open = index;
if (token.type !== 'labelLink') {
offset = 2;
break;
}
}
} else if (token.type === 'labelEnd') {
close = index;
}
}
group = {
type: events[open][1].type === 'labelLink' ? 'link' : 'image',
start: shallow(events[open][1].start),
end: shallow(events[events.length - 1][1].end),
};
label = {
type: 'label',
start: shallow(events[open][1].start),
end: shallow(events[close][1].end),
};
text = {
type: 'labelText',
start: shallow(events[open + offset + 2][1].end),
end: shallow(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 = chunkedPush(media, [['enter', text, context]]); // Between.
media = chunkedPush(
media,
resolveAll(
context.parser.constructs.insideSpan.null,
events.slice(open + offset + 4, close - 3),
context
)
); // Text close, marker close, label close.
media = chunkedPush(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 = chunkedPush(media, [['exit', group, context]]);
chunkedSplice(events, open, events.length, media);
return events;
}
function tokenizeLabelEnd(effects, ok, nok) {
var self = this;
var index = self.events.length;
var labelStart;
var defined; // Find an opening.
while (index--) {
if (
(self.events[index][1].type === 'labelImage' ||
self.events[index][1].type === 'labelLink') &&
!self.events[index][1]._balanced
) {
labelStart = self.events[index][1];
break;
}
}
return start;
function start(code) {
if (!labelStart) {
return nok(code);
} // It’s a balanced bracket, but contains a link.
if (labelStart._inactive) return balanced(code);
defined =
self.parser.defined.indexOf(
normalizeIdentifier(
self.sliceSerialize({
start: labelStart.end,
end: self.now(),
})
)
) > -1;
effects.enter('labelEnd');
effects.enter('labelMarker');
effects.consume(code);
effects.exit('labelMarker');
effects.exit('labelEnd');
return afterLabelEnd;
}
function afterLabelEnd(code) {
// Resource: `[asd](fgh)`.
if (code === 40) {
return effects.attempt(
resourceConstruct,
ok,
defined ? ok : balanced
)(code);
} // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?
if (code === 91) {
return effects.attempt(
fullReferenceConstruct,
ok,
defined
? effects.attempt(collapsedReferenceConstruct, ok, balanced)
: balanced
)(code);
} // Shortcut reference: `[asd]`?
return defined ? ok(code) : balanced(code);
}
function balanced(code) {
labelStart._balanced = true;
return nok(code);
}
}
function tokenizeResource(effects, ok, nok) {
return start;
function start(code) {
effects.enter('resource');
effects.enter('resourceMarker');
effects.consume(code);
effects.exit('resourceMarker');
return factoryWhitespace(effects, open);
}
function open(code) {
if (code === 41) {
return end(code);
}
return factoryDestination(
effects,
destinationAfter,
nok,
'resourceDestination',
'resourceDestinationLiteral',
'resourceDestinationLiteralMarker',
'resourceDestinationRaw',
'resourceDestinationString',
3
)(code);
}
function destinationAfter(code) {
return markdownLineEndingOrSpace(code)
? factoryWhitespace(effects, between)(code)
: end(code);
}
function between(code) {
if (code === 34 || code === 39 || code === 40) {
return factoryTitle(
effects,
factoryWhitespace(effects, end),
nok,
'resourceTitle',
'resourceTitleMarker',
'resourceTitleString'
)(code);
}
return end(code);
}
function end(code) {
if (code === 41) {
effects.enter('resourceMarker');
effects.consume(code);
effects.exit('resourceMarker');
effects.exit('resource');
return ok;
}
return nok(code);
}
}
function tokenizeFullReference(effects, ok, nok) {
var self = this;
return start;
function start(code) {
return factoryLabel.call(
self,
effects,
afterLabel,
nok,
'reference',
'referenceMarker',
'referenceString'
)(code);
}
function afterLabel(code) {
return self.parser.defined.indexOf(
normalizeIdentifier(
self
.sliceSerialize(self.events[self.events.length - 1][1])
.slice(1, -1)
)
) < 0
? nok(code)
: ok(code);
}
}
function tokenizeCollapsedReference(effects, ok, nok) {
return start;
function start(code) {
effects.enter('reference');
effects.enter('referenceMarker');
effects.consume(code);
effects.exit('referenceMarker');
return open;
}
function open(code) {
if (code === 93) {
effects.enter('referenceMarker');
effects.consume(code);
effects.exit('referenceMarker');
effects.exit('reference');
return ok;
}
return nok(code);
}
}
module.exports = labelEnd;
/***/
},
/***/ 7860: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var labelEnd = __nccwpck_require__(9797);
var labelStartImage = {
name: 'labelStartImage',
tokenize: tokenizeLabelStartImage,
resolveAll: labelEnd.resolveAll,
};
function tokenizeLabelStartImage(effects, ok, nok) {
var self = this;
return start;
function start(code) {
effects.enter('labelImage');
effects.enter('labelImageMarker');
effects.consume(code);
effects.exit('labelImageMarker');
return open;
}
function open(code) {
if (code === 91) {
effects.enter('labelMarker');
effects.consume(code);
effects.exit('labelMarker');
effects.exit('labelImage');
return after;
}
return nok(code);
}
function after(code) {
/* c8 ignore next */
return code === 94 &&
/* c8 ignore next */
'_hiddenFootnoteSupport' in self.parser.constructs
? /* c8 ignore next */
nok(code)
: ok(code);
}
}
module.exports = labelStartImage;
/***/
},
/***/ 5908: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var labelEnd = __nccwpck_require__(9797);
var labelStartLink = {
name: 'labelStartLink',
tokenize: tokenizeLabelStartLink,
resolveAll: labelEnd.resolveAll,
};
function tokenizeLabelStartLink(effects, ok, nok) {
var self = this;
return start;
function start(code) {
effects.enter('labelLink');
effects.enter('labelMarker');
effects.consume(code);
effects.exit('labelMarker');
effects.exit('labelLink');
return after;
}
function after(code) {
/* c8 ignore next */
return code === 94 &&
/* c8 ignore next */
'_hiddenFootnoteSupport' in self.parser.constructs
? /* c8 ignore next */
nok(code)
: ok(code);
}
}
module.exports = labelStartLink;
/***/
},
/***/ 5183: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var factorySpace = __nccwpck_require__(8200);
var lineEnding = {
name: 'lineEnding',
tokenize: tokenizeLineEnding,
};
function tokenizeLineEnding(effects, ok) {
return start;
function start(code) {
effects.enter('lineEnding');
effects.consume(code);
effects.exit('lineEnding');
return factorySpace(effects, ok, 'linePrefix');
}
}
module.exports = lineEnding;
/***/
},
/***/ 3107: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
var partialBlankLine = __nccwpck_require__(2244);
var sizeChunks = __nccwpck_require__(5041);
var prefixSize = __nccwpck_require__(3722);
var asciiDigit = __nccwpck_require__(6996);
var thematicBreak = __nccwpck_require__(5590);
var list = {
name: 'list',
tokenize: tokenizeListStart,
continuation: {
tokenize: tokenizeListContinuation,
},
exit: tokenizeListEnd,
};
var listItemPrefixWhitespaceConstruct = {
tokenize: tokenizeListItemPrefixWhitespace,
partial: true,
};
var indentConstruct = {
tokenize: tokenizeIndent,
partial: true,
};
function tokenizeListStart(effects, ok, nok) {
var self = this;
var initialSize = prefixSize(self.events, 'linePrefix');
var size = 0;
return start;
function start(code) {
var kind =
self.containerState.type ||
(code === 42 || code === 43 || code === 45
? 'listUnordered'
: 'listOrdered');
if (
kind === 'listUnordered'
? !self.containerState.marker ||
code === self.containerState.marker
: asciiDigit(code)
) {
if (!self.containerState.type) {
self.containerState.type = kind;
effects.enter(kind, {
_container: true,
});
}
if (kind === 'listUnordered') {
effects.enter('listItemPrefix');
return code === 42 || code === 45
? effects.check(thematicBreak, nok, atMarker)(code)
: atMarker(code);
}
if (!self.interrupt || code === 49) {
effects.enter('listItemPrefix');
effects.enter('listItemValue');
return inside(code);
}
}
return nok(code);
}
function inside(code) {
if (asciiDigit(code) && ++size < 10) {
effects.consume(code);
return inside;
}
if (
(!self.interrupt || size < 2) &&
(self.containerState.marker
? code === self.containerState.marker
: code === 41 || code === 46)
) {
effects.exit('listItemValue');
return atMarker(code);
}
return nok(code);
}
function atMarker(code) {
effects.enter('listItemMarker');
effects.consume(code);
effects.exit('listItemMarker');
self.containerState.marker = self.containerState.marker || code;
return effects.check(
partialBlankLine, // Can’t be empty when interrupting.
self.interrupt ? nok : onBlank,
effects.attempt(
listItemPrefixWhitespaceConstruct,
endOfPrefix,
otherPrefix
)
);
}
function onBlank(code) {
self.containerState.initialBlankLine = true;
initialSize++;
return endOfPrefix(code);
}
function otherPrefix(code) {
if (markdownSpace(code)) {
effects.enter('listItemPrefixWhitespace');
effects.consume(code);
effects.exit('listItemPrefixWhitespace');
return endOfPrefix;
}
return nok(code);
}
function endOfPrefix(code) {
self.containerState.size =
initialSize +
sizeChunks(self.sliceStream(effects.exit('listItemPrefix')));
return ok(code);
}
}
function tokenizeListContinuation(effects, ok, nok) {
var self = this;
self.containerState._closeFlow = undefined;
return effects.check(partialBlankLine, onBlank, notBlank);
function onBlank(code) {
self.containerState.furtherBlankLines =
self.containerState.furtherBlankLines ||
self.containerState.initialBlankLine;
return ok(code);
}
function notBlank(code) {
if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;
return notInCurrentItem(code);
}
self.containerState.furtherBlankLines = self.containerState.initialBlankLine = undefined;
return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);
}
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(
effects,
effects.attempt(list, ok, nok),
'linePrefix',
self.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4
)(code);
}
}
function tokenizeIndent(effects, ok, nok) {
var self = this;
return factorySpace(
effects,
afterPrefix,
'listItemIndent',
self.containerState.size + 1
);
function afterPrefix(code) {
return prefixSize(self.events, 'listItemIndent') ===
self.containerState.size
? ok(code)
: nok(code);
}
}
function tokenizeListEnd(effects) {
effects.exit(this.containerState.type);
}
function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
var self = this;
return factorySpace(
effects,
afterPrefix,
'listItemPrefixWhitespace',
self.parser.constructs.disable.null.indexOf('codeIndented') > -1
? undefined
: 4 + 1
);
function afterPrefix(code) {
return markdownSpace(code) ||
!prefixSize(self.events, 'listItemPrefixWhitespace')
? nok(code)
: ok(code);
}
}
module.exports = list;
/***/
},
/***/ 2244: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var partialBlankLine = {
tokenize: tokenizePartialBlankLine,
partial: true,
};
function tokenizePartialBlankLine(effects, ok, nok) {
return factorySpace(effects, afterWhitespace, 'linePrefix');
function afterWhitespace(code) {
return code === null || markdownLineEnding(code)
? ok(code)
: nok(code);
}
}
module.exports = partialBlankLine;
/***/
},
/***/ 1196: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var factorySpace = __nccwpck_require__(8200);
var shallow = __nccwpck_require__(1479);
var setextUnderline = {
name: 'setextUnderline',
tokenize: tokenizeSetextUnderline,
resolveTo: resolveToSetextUnderline,
};
function resolveToSetextUnderline(events, context) {
var index = events.length;
var content;
var text;
var definition;
var heading; // Find the opening of the content.
// It’ll always exist: we don’t tokenize if it isn’t there.
while (index--) {
if (events[index][0] === 'enter') {
if (events[index][1].type === 'content') {
content = index;
break;
}
if (events[index][1].type === 'paragraph') {
text = index;
}
} // Exit
else {
if (events[index][1].type === 'content') {
// Remove the content end (if needed we’ll add it later)
events.splice(index, 1);
}
if (!definition && events[index][1].type === 'definition') {
definition = index;
}
}
}
heading = {
type: 'setextHeading',
start: shallow(events[text][1].start),
end: shallow(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,
// but we need move it.
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);
} else {
events[content][1] = heading;
} // Add the heading exit at the end.
events.push(['exit', heading, context]);
return events;
}
function tokenizeSetextUnderline(effects, ok, nok) {
var self = this;
var index = self.events.length;
var marker;
var paragraph; // Find an opening.
while (index--) {
// Skip enter/exit of line ending, line prefix, and content.
// We can now either have a definition or a paragraph.
if (
self.events[index][1].type !== 'lineEnding' &&
self.events[index][1].type !== 'linePrefix' &&
self.events[index][1].type !== 'content'
) {
paragraph = self.events[index][1].type === 'paragraph';
break;
}
}
return start;
function start(code) {
if (!self.lazy && (self.interrupt || paragraph)) {
effects.enter('setextHeadingLine');
effects.enter('setextHeadingLineSequence');
marker = code;
return closingSequence(code);
}
return nok(code);
}
function closingSequence(code) {
if (code === marker) {
effects.consume(code);
return closingSequence;
}
effects.exit('setextHeadingLineSequence');
return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);
}
function closingSequenceEnd(code) {
if (code === null || markdownLineEnding(code)) {
effects.exit('setextHeadingLine');
return ok(code);
}
return nok(code);
}
}
module.exports = setextUnderline;
/***/
},
/***/ 5590: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEnding = __nccwpck_require__(7506);
var markdownSpace = __nccwpck_require__(5989);
var factorySpace = __nccwpck_require__(8200);
var thematicBreak = {
name: 'thematicBreak',
tokenize: tokenizeThematicBreak,
};
function tokenizeThematicBreak(effects, ok, nok) {
var size = 0;
var marker;
return start;
function start(code) {
effects.enter('thematicBreak');
marker = code;
return atBreak(code);
}
function atBreak(code) {
if (code === marker) {
effects.enter('thematicBreakSequence');
return sequence(code);
}
if (markdownSpace(code)) {
return factorySpace(effects, atBreak, 'whitespace')(code);
}
if (size < 3 || (code !== null && !markdownLineEnding(code))) {
return nok(code);
}
effects.exit('thematicBreak');
return ok(code);
}
function sequence(code) {
if (code === marker) {
effects.consume(code);
size++;
return sequence;
}
effects.exit('thematicBreakSequence');
return atBreak(code);
}
}
module.exports = thematicBreak;
/***/
},
/***/ 4455: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var chunkedSplice = __nccwpck_require__(778);
function chunkedPush(list, items) {
if (list.length) {
chunkedSplice(list, list.length, 0, items);
return list;
}
return items;
}
module.exports = chunkedPush;
/***/
},
/***/ 778: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var splice = __nccwpck_require__(2366);
// causes a stack overflow in V8 when trying to insert 100k items for instance.
function chunkedSplice(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.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);
splice.apply(list, parameters);
chunkStart += 10000;
start += 10000;
}
}
}
module.exports = chunkedSplice;
/***/
},
/***/ 1324: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var markdownLineEndingOrSpace = __nccwpck_require__(9180);
var unicodePunctuation = __nccwpck_require__(9372);
var unicodeWhitespace = __nccwpck_require__(9968);
// 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(code) {
if (
code === null ||
markdownLineEndingOrSpace(code) ||
unicodeWhitespace(code)
) {
return 1;
}
if (unicodePunctuation(code)) {
return 2;
}
}
module.exports = classifyCharacter;
/***/
},
/***/ 8602: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var hasOwnProperty = __nccwpck_require__(3500);
var chunkedSplice = __nccwpck_require__(778);
var miniflat = __nccwpck_require__(9042);
function combineExtensions(extensions) {
var all = {};
var index = -1;
while (++index < extensions.length) {
extension(all, extensions[index]);
}
return all;
}
function extension(all, extension) {
var hook;
var left;
var right;
var code;
for (hook in extension) {
left = hasOwnProperty.call(all, hook) ? all[hook] : (all[hook] = {});
right = extension[hook];
for (code in right) {
left[code] = constructs(
miniflat(right[code]),
hasOwnProperty.call(left, code) ? left[code] : []
);
}
}
}
function constructs(list, existing) {
var index = -1;
var before = [];
while (++index < list.length) {
(list[index].add === 'after' ? existing : before).push(list[index]);
}
chunkedSplice(existing, 0, 0, before);
return existing;
}
module.exports = combineExtensions;
/***/
},
/***/ 4845: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var assign = __nccwpck_require__(3512);
var chunkedSplice = __nccwpck_require__(778);
var chunkedPush = __nccwpck_require__(4455);
var miniflat = __nccwpck_require__(9042);
var markdownLineEnding = __nccwpck_require__(7506);
var shallow = __nccwpck_require__(1479);
var resolveAll = __nccwpck_require__(2004);
var serializeChunks = __nccwpck_require__(4363);
var sliceChunks = __nccwpck_require__(7271);
// 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(parser, initialize, from) {
var point = from
? shallow(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(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.
//
function sliceSerialize(token) {
return serializeChunks(sliceStream(token));
}
function sliceStream(token) {
return sliceChunks(chunks, token);
}
function now() {
return shallow(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(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(constructs))
: handleMapOfConstructs;
function handleMapOfConstructs(code) {
if (code in constructs || null in constructs) {
return handleListOfConstructs(
constructs.null
? /* c8 ignore next */
miniflat(constructs[code]).concat(
miniflat(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({}, 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(
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;
}
}
}
module.exports = createTokenizer;
/***/
},
/***/ 9042: /***/ (module) => {
'use strict';
function miniflat(value) {
return value === null || value === undefined
? []
: 'length' in value
? value
: [value];
}
module.exports = miniflat;
/***/
},
/***/ 6985: /***/ (module) => {
'use strict';
// chunks (replacement characters, tabs, or line endings).
function movePoint(point, offset) {
point.column += offset;
point.offset += offset;
point._bufferIndex += offset;
return point;
}
module.exports = movePoint;
/***/
},
/***/ 712: /***/ (module) => {
'use strict';
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 object method is uppercase.
.toLowerCase()
.toUpperCase()
);
}
module.exports = normalizeIdentifier;
/***/
},
/***/ 3722: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var sizeChunks = __nccwpck_require__(5041);
function prefixSize(events, type) {
var tail = events[events.length - 1];
if (!tail || tail[1].type !== type) return 0;
return sizeChunks(tail[2].sliceStream(tail[1]));
}
module.exports = prefixSize;
/***/
},
/***/ 1028: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var fromCharCode = __nccwpck_require__(3531);
function regexCheck(regex) {
return check;
function check(code) {
return regex.test(fromCharCode(code));
}
}
module.exports = regexCheck;
/***/
},
/***/ 2004: /***/ (module) => {
'use strict';
function resolveAll(constructs, events, context) {
var called = [];
var index = -1;
var resolve;
while (++index < constructs.length) {
resolve = constructs[index].resolveAll;
if (resolve && called.indexOf(resolve) < 0) {
events = resolve(events, context);
called.push(resolve);
}
}
return events;
}
module.exports = resolveAll;
/***/
},
/***/ 6214: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var fromCharCode = __nccwpck_require__(3531);
function safeFromInt(value, base) {
var code = parseInt(value, base);
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';
}
return fromCharCode(code);
}
module.exports = safeFromInt;
/***/
},
/***/ 4363: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var fromCharCode = __nccwpck_require__(3531);
function serializeChunks(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(chunk);
}
atTab = chunk === -2;
result.push(value);
}
return result.join('');
}
module.exports = serializeChunks;
/***/
},
/***/ 1479: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var assign = __nccwpck_require__(3512);
function shallow(object) {
return assign({}, object);
}
module.exports = shallow;
/***/
},
/***/ 5041: /***/ (module) => {
'use strict';
// Counts tabs based on their expanded size, and CR+LF as one character.
function sizeChunks(chunks) {
var index = -1;
var size = 0;
while (++index < chunks.length) {
size += typeof chunks[index] === 'string' ? chunks[index].length : 1;
}
return size;
}
module.exports = sizeChunks;
/***/
},
/***/ 7271: /***/ (module) => {
'use strict';
function sliceChunks(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;
}
module.exports = sliceChunks;
/***/
},
/***/ 14: /***/ (module, __unused_webpack_exports, __nccwpck_require__) => {
'use strict';
var assign = __nccwpck_require__(3512);
var chunkedSplice = __nccwpck_require__(778);
var shallow = __nccwpck_require__(1479);
function subtokenize(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(jumps, subcontent(events, index));
index = jumps[index];
more = true;
}
} // Exit.
else if (event[1]._container || event[1]._movePreviousLineEndings) {
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 = shallow(events[lineIndex][1].start); // Switch container exit w/ line endings.
parameters = events.slice(lineIndex, index);
parameters.unshift(event);
chunkedSplice(
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);
if (!token._tokenizer) {
stream = context.sliceStream(token);
if (!token.next) {
stream.push(null);
}
if (previous) {
tokenizer.defineSkip(token.start);
}
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(events, start, 2, slice);
}
}
module.exports = subtokenize;
/***/
},
/***/ 3485: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var characterEntities = __nccwpck_require__(2661);
module.exports = decodeEntity;
var own = {}.hasOwnProperty;
function decodeEntity(characters) {
return own.call(characterEntities, characters)
? characterEntities[characters]
: false;
}
/***/
},
/***/ 4859: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = parse;
var fromMarkdown = __nccwpck_require__(3068);
function parse(options) {
var self = this;
this.Parser = parse;
function parse(doc) {
return fromMarkdown(
doc,
Object.assign({}, self.data('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') || [],
})
);
}
}
/***/
},
/***/ 7114: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = stringify;
var toMarkdown = __nccwpck_require__(219);
function stringify(options) {
var self = this;
this.Compiler = compile;
function compile(tree) {
return toMarkdown(
tree,
Object.assign({}, self.data('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') || [],
})
);
}
}
/***/
},
/***/ 5096: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var util = __nccwpck_require__(6184);
module.exports = toc;
var defaultHeading = 'toc|table[ -]of[ -]contents?';
function toc(options) {
var settings = options || {};
var heading = settings.heading || defaultHeading;
var depth = settings.maxDepth || 6;
var tight = settings.tight;
var skip = settings.skip;
return transformer;
function transformer(node) {
var result = util(node, {
heading: heading,
maxDepth: depth,
tight: tight,
skip: skip,
});
if (result.index === null || result.index === -1 || !result.map) {
return;
}
node.children = [].concat(
node.children.slice(0, result.index),
result.map,
node.children.slice(result.endIndex)
);
}
}
/***/
},
/***/ 2081: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var unified = __nccwpck_require__(5075);
var parse = __nccwpck_require__(4859);
var stringify = __nccwpck_require__(7114);
module.exports = unified().use(parse).use(stringify).freeze();
/***/
},
/***/ 6976: /***/ (module) => {
'use strict';
/*!
* repeat-string <https://github.com/jonschlinkert/repeat-string>
*
* Copyright (c) 2014-2015, Jon Schlinkert.
* Licensed under the MIT License.
*/
/**
* Results cache
*/
var res = '';
var cache;
/**
* Expose `repeat`
*/
module.exports = repeat;
/**
* Repeat the given `string` the specified `number`
* of times.
*
* **Example:**
*
* ```js
* var repeat = require('repeat-string');
* repeat('A', 5);
* //=> AAAAA
* ```
*
* @param {String} `string` The string to repeat
* @param {Number} `number` The number of times to repeat the string
* @return {String} Repeated string
* @api public
*/
function repeat(str, num) {
if (typeof str !== 'string') {
throw new TypeError('expected a string');
}
// cover common, quick use cases
if (num === 1) return str;
if (num === 2) return str + str;
var max = str.length * num;
if (cache !== str || typeof cache === 'undefined') {
cache = str;
res = '';
} else if (res.length >= max) {
return res.substr(0, max);
}
while (max > res.length && num > 1) {
if (num & 1) {
res += str;
}
num >>= 1;
str += str;
}
res += str;
res = res.substr(0, max);
return res;
}
/***/
},
/***/ 3604: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var wrap = __nccwpck_require__(3458);
module.exports = trough;
trough.wrap = wrap;
var slice = [].slice;
// Create new middleware.
function trough() {
var fns = [];
var middleware = {};
middleware.run = run;
middleware.use = use;
return middleware;
// Run `fns`. Last argument must be a completion handler.
function run() {
var index = -1;
var input = slice.call(arguments, 0, -1);
var done = arguments[arguments.length - 1];
if (typeof done !== 'function') {
throw new Error('Expected function as last argument, not ' + done);
}
next.apply(null, [null].concat(input));
// Run the next `fn`, if any.
function next(err) {
var fn = fns[++index];
var params = slice.call(arguments, 0);
var values = params.slice(1);
var length = input.length;
var pos = -1;
if (err) {
done(err);
return;
}
// Copy non-nully input into values.
while (++pos < length) {
if (values[pos] === null || values[pos] === undefined) {
values[pos] = input[pos];
}
}
input = values;
// Next or done.
if (fn) {
wrap(fn, next).apply(null, input);
} else {
done.apply(null, [null].concat(input));
}
}
}
// Add `fn` to the list.
function use(fn) {
if (typeof fn !== 'function') {
throw new Error('Expected `fn` to be a function, not ' + fn);
}
fns.push(fn);
return middleware;
}
}
/***/
},
/***/ 3458: /***/ (module) => {
'use strict';
var slice = [].slice;
module.exports = wrap;
// Wrap `fn`.
// Can be sync or async; return a promise, receive a completion handler, return
// new values and errors.
function wrap(fn, callback) {
var invoked;
return wrapped;
function wrapped() {
var params = slice.call(arguments, 0);
var callback = fn.length > params.length;
var result;
if (callback) {
params.push(done);
}
try {
result = fn.apply(null, params);
} catch (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;
}
return done(error);
}
if (!callback) {
if (result && typeof result.then === 'function') {
result.then(then, done);
} else if (result instanceof Error) {
done(result);
} else {
then(result);
}
}
}
// Invoke `next`, only once.
function done() {
if (!invoked) {
invoked = true;
callback.apply(null, arguments);
}
}
// Invoke `done` with one value.
// Tracks if an error is passed, too.
function then(value) {
done(null, value);
}
}
/***/
},
/***/ 5075: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var bail = __nccwpck_require__(7240);
var buffer = __nccwpck_require__(8810);
var extend = __nccwpck_require__(8171);
var plain = __nccwpck_require__(4118);
var trough = __nccwpck_require__(3604);
var vfile = __nccwpck_require__(4860);
// Expose a frozen processor.
module.exports = unified().freeze();
var slice = [].slice;
var own = {}.hasOwnProperty;
// Process pipeline.
var pipeline = trough()
.use(pipelineParse)
.use(pipelineRun)
.use(pipelineStringify);
function pipelineParse(p, ctx) {
ctx.tree = p.parse(ctx.file);
}
function pipelineRun(p, ctx, next) {
p.run(ctx.tree, ctx.file, done);
function done(err, tree, file) {
if (err) {
next(err);
} else {
ctx.tree = tree;
ctx.file = file;
next();
}
}
}
function pipelineStringify(p, ctx) {
var result = p.stringify(ctx.tree, ctx.file);
var file = ctx.file;
if (result === undefined || result === null) {
// Empty.
} else if (typeof result === 'string' || buffer(result)) {
file.contents = result;
} else {
file.result = result;
}
}
// Function to create the first processor.
function unified() {
var attachers = [];
var transformers = trough();
var namespace = {};
var frozen = false;
var freezeIndex = -1;
// Data management.
processor.data = data;
// Lock.
processor.freeze = freeze;
// Plugins.
processor.attachers = attachers;
processor.use = use;
// API.
processor.parse = parse;
processor.stringify = stringify;
processor.run = run;
processor.runSync = runSync;
processor.process = process;
processor.processSync = processSync;
// Expose.
return processor;
// Create a new processor based on the processor in the current scope.
function processor() {
var destination = unified();
var length = attachers.length;
var index = -1;
while (++index < length) {
destination.use.apply(null, attachers[index]);
}
destination.data(extend(true, {}, namespace));
return destination;
}
// Freeze: used to signal a processor that has finished configuration.
//
// For example, take unified itself: it’s frozen.
// Plugins should not be added to it.
// Rather, it should be extended, by invoking it, before modifying it.
//
// In essence, always invoke this when exporting a processor.
function freeze() {
var values;
var plugin;
var options;
var transformer;
if (frozen) {
return processor;
}
while (++freezeIndex < attachers.length) {
values = attachers[freezeIndex];
plugin = values[0];
options = values[1];
transformer = null;
if (options === false) {
continue;
}
if (options === true) {
values[1] = undefined;
}
transformer = plugin.apply(processor, values.slice(1));
if (typeof transformer === 'function') {
transformers.use(transformer);
}
}
frozen = true;
freezeIndex = Infinity;
return processor;
}
// Data management.
// Getter / setter for processor-specific informtion.
function data(key, value) {
if (typeof key === 'string') {
// Set `key`.
if (arguments.length === 2) {
assertUnfrozen('data', frozen);
namespace[key] = value;
return processor;
}
// Get `key`.
return (own.call(namespace, key) && namespace[key]) || null;
}
// Set space.
if (key) {
assertUnfrozen('data', frozen);
namespace = key;
return processor;
}
// Get space.
return namespace;
}
// Plugin management.
//
// Pass it:
// * an attacher and options,
// * a preset,
// * a list of presets, attachers, and arguments (list of attachers and
// options).
function use(value) {
var settings;
assertUnfrozen('use', frozen);
if (value === null || value === undefined) {
// Empty.
} else if (typeof value === 'function') {
addPlugin.apply(null, arguments);
} else if (typeof value === 'object') {
if ('length' in value) {
addList(value);
} else {
addPreset(value);
}
} else {
throw new Error('Expected usable value, not `' + value + '`');
}
if (settings) {
namespace.settings = extend(namespace.settings || {}, settings);
}
return processor;
function addPreset(result) {
addList(result.plugins);
if (result.settings) {
settings = extend(settings || {}, result.settings);
}
}
function add(value) {
if (typeof value === 'function') {
addPlugin(value);
} else if (typeof value === 'object') {
if ('length' in value) {
addPlugin.apply(null, value);
} else {
addPreset(value);
}
} else {
throw new Error('Expected usable value, not `' + value + '`');
}
}
function addList(plugins) {
var length;
var index;
if (plugins === null || plugins === undefined) {
// Empty.
} else if (typeof plugins === 'object' && 'length' in plugins) {
length = plugins.length;
index = -1;
while (++index < length) {
add(plugins[index]);
}
} else {
throw new Error(
'Expected a list of plugins, not `' + plugins + '`'
);
}
}
function addPlugin(plugin, value) {
var entry = find(plugin);
if (entry) {
if (plain(entry[1]) && plain(value)) {
value = extend(entry[1], value);
}
entry[1] = value;
} else {
attachers.push(slice.call(arguments));
}
}
}
function find(plugin) {
var length = attachers.length;
var index = -1;
var entry;
while (++index < length) {
entry = attachers[index];
if (entry[0] === plugin) {
return entry;
}
}
}
// Parse a file (in string or vfile representation) into a unist node using
// the `Parser` on the processor.
function parse(doc) {
var file = vfile(doc);
var Parser;
freeze();
Parser = processor.Parser;
assertParser('parse', Parser);
if (newable(Parser, 'parse')) {
return new Parser(String(file), file).parse();
}
return Parser(String(file), file); // eslint-disable-line new-cap
}
// Run transforms on a unist node representation of a file (in string or
// vfile representation), async.
function run(node, file, cb) {
assertNode(node);
freeze();
if (!cb && typeof file === 'function') {
cb = file;
file = null;
}
if (!cb) {
return new Promise(executor);
}
executor(null, cb);
function executor(resolve, reject) {
transformers.run(node, vfile(file), done);
function done(err, tree, file) {
tree = tree || node;
if (err) {
reject(err);
} else if (resolve) {
resolve(tree);
} else {
cb(null, tree, file);
}
}
}
}
// Run transforms on a unist node representation of a file (in string or
// vfile representation), sync.
function runSync(node, file) {
var complete = false;
var result;
run(node, file, done);
assertDone('runSync', 'run', complete);
return result;
function done(err, tree) {
complete = true;
bail(err);
result = tree;
}
}
// Stringify a unist node representation of a file (in string or vfile
// representation) into a string using the `Compiler` on the processor.
function stringify(node, doc) {
var file = vfile(doc);
var Compiler;
freeze();
Compiler = processor.Compiler;
assertCompiler('stringify', Compiler);
assertNode(node);
if (newable(Compiler, '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();
assertParser('process', processor.Parser);
assertCompiler('process', processor.Compiler);
if (!cb) {
return new Promise(executor);
}
executor(null, cb);
function executor(resolve, reject) {
var file = vfile(doc);
pipeline.run(processor, { file: file }, done);
function done(err) {
if (err) {
reject(err);
} else if (resolve) {
resolve(file);
} else {
cb(null, file);
}
}
}
}
// Process the given document (in string or vfile representation), sync.
function processSync(doc) {
var complete = false;
var file;
freeze();
assertParser('processSync', processor.Parser);
assertCompiler('processSync', processor.Compiler);
file = vfile(doc);
process(file, done);
assertDone('processSync', 'process', complete);
return file;
function done(err) {
complete = true;
bail(err);
}
}
}
// Check if `value` is a constructor.
function newable(value, name) {
return (
typeof value === 'function' &&
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.
(keys(value.prototype) || name in value.prototype)
);
}
// Check if `value` is an object with keys.
function keys(value) {
var key;
for (key in value) {
return true;
}
return false;
}
// Assert a parser is available.
function assertParser(name, Parser) {
if (typeof Parser !== 'function') {
throw new Error('Cannot `' + name + '` without `Parser`');
}
}
// Assert a compiler is available.
function assertCompiler(name, Compiler) {
if (typeof Compiler !== 'function') {
throw new Error('Cannot `' + name + '` without `Compiler`');
}
}
// Assert the processor is not frozen.
function assertUnfrozen(name, frozen) {
if (frozen) {
throw new Error(
'Cannot invoke `' +
name +
'` on a frozen processor.\nCreate a new processor first, by invoking it: use `processor()` instead of `processor`.'
);
}
}
// Assert `node` is a unist node.
function assertNode(node) {
if (!node || typeof node.type !== 'string') {
throw new Error('Expected node, got `' + node + '`');
}
}
// Assert that `complete` is `true`.
function assertDone(name, asyncName, complete) {
if (!complete) {
throw new Error(
'`' + name + '` finished async. Use `' + asyncName + '` instead'
);
}
}
/***/
},
/***/ 8810: /***/ (module) => {
/*!
* Determine if an object is a Buffer
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
module.exports = function isBuffer(obj) {
return (
obj != null &&
obj.constructor != null &&
typeof obj.constructor.isBuffer === 'function' &&
obj.constructor.isBuffer(obj)
);
};
/***/
},
/***/ 4118: /***/ (module) => {
'use strict';
module.exports = (value) => {
if (Object.prototype.toString.call(value) !== '[object Object]') {
return false;
}
const prototype = Object.getPrototypeOf(value);
return prototype === null || prototype === Object.prototype;
};
/***/
},
/***/ 4070: /***/ (module) => {
'use strict';
module.exports = convert;
function convert(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(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;
}
/***/
},
/***/ 1957: /***/ (module) => {
'use strict';
var own = {}.hasOwnProperty;
module.exports = stringify;
function stringify(value) {
// Nothing.
if (!value || typeof value !== 'object') {
return '';
}
// Node.
if (own.call(value, 'position') || own.call(value, 'type')) {
return position(value.position);
}
// Position.
if (own.call(value, 'start') || own.call(value, 'end')) {
return position(value);
}
// Point.
if (own.call(value, 'line') || own.call(value, 'column')) {
return point(value);
}
// ?
return '';
}
function point(point) {
if (!point || typeof point !== 'object') {
point = {};
}
return index(point.line) + ':' + index(point.column);
}
function position(pos) {
if (!pos || typeof pos !== 'object') {
pos = {};
}
return point(pos.start) + '-' + point(pos.end);
}
function index(value) {
return value && typeof value === 'number' ? value : 1;
}
/***/
},
/***/ 9906: /***/ (module) => {
module.exports = color;
function color(d) {
return '\u001B[33m' + d + '\u001B[39m';
}
/***/
},
/***/ 3246: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = visitParents;
var convert = __nccwpck_require__(4070);
var color = __nccwpck_require__(9906);
var CONTINUE = true;
var SKIP = 'skip';
var EXIT = false;
visitParents.CONTINUE = CONTINUE;
visitParents.SKIP = SKIP;
visitParents.EXIT = EXIT;
function visitParents(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) {
return result;
}
}
if (node.children && result[0] !== SKIP) {
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) {
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, value];
}
return [value];
}
/***/
},
/***/ 199: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = visit;
var visitParents = __nccwpck_require__(3246);
var CONTINUE = visitParents.CONTINUE;
var SKIP = visitParents.SKIP;
var EXIT = visitParents.EXIT;
visit.CONTINUE = CONTINUE;
visit.SKIP = SKIP;
visit.EXIT = EXIT;
function visit(tree, test, visitor, reverse) {
if (typeof test === 'function' && typeof visitor !== 'function') {
reverse = visitor;
visitor = test;
test = null;
}
visitParents(tree, test, overload, reverse);
function overload(node, parents) {
var parent = parents[parents.length - 1];
var index = parent ? parent.children.indexOf(node) : null;
return visitor(node, index, parent);
}
}
/***/
},
/***/ 4108: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var stringify = __nccwpck_require__(1957);
module.exports = VMessage;
// Inherit from `Error#`.
function VMessagePrototype() {}
VMessagePrototype.prototype = Error.prototype;
VMessage.prototype = new VMessagePrototype();
// Message properties.
var proto = VMessage.prototype;
proto.file = '';
proto.name = '';
proto.reason = '';
proto.message = '';
proto.stack = '';
proto.fatal = null;
proto.column = null;
proto.line = null;
// Construct a new VMessage.
//
// Note: We cannot invoke `Error` on the created context, as that adds readonly
// `line` and `column` attributes on Safari 9, thus throwing and failing the
// data.
function VMessage(reason, position, origin) {
var parts;
var range;
var location;
if (typeof position === 'string') {
origin = position;
position = null;
}
parts = parseOrigin(origin);
range = stringify(position) || '1:1';
location = {
start: { line: null, column: null },
end: { line: null, column: null },
};
// Node.
if (position && position.position) {
position = position.position;
}
if (position) {
// Position.
if (position.start) {
location = position;
position = position.start;
} else {
// Point.
location.start = position;
}
}
if (reason.stack) {
this.stack = reason.stack;
reason = reason.message;
}
this.message = reason;
this.name = range;
this.reason = reason;
this.line = position ? position.line : null;
this.column = position ? position.column : null;
this.location = location;
this.source = parts[0];
this.ruleId = parts[1];
}
function parseOrigin(origin) {
var result = [null, null];
var index;
if (typeof origin === 'string') {
index = origin.indexOf(':');
if (index === -1) {
result[1] = origin;
} else {
result[0] = origin.slice(0, index);
result[1] = origin.slice(index + 1);
}
}
return result;
}
/***/
},
/***/ 4860: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = __nccwpck_require__(77);
/***/
},
/***/ 9523: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
var p = __nccwpck_require__(9239);
var proc = __nccwpck_require__(6070);
var buffer = __nccwpck_require__(2157);
module.exports = VFile;
var own = {}.hasOwnProperty;
// Order of setting (least specific to most), we need this because otherwise
// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
// stem can be set.
var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
VFile.prototype.toString = toString;
// Access full path (`~/index.min.js`).
Object.defineProperty(VFile.prototype, 'path', {
get: getPath,
set: setPath,
});
// Access parent path (`~`).
Object.defineProperty(VFile.prototype, 'dirname', {
get: getDirname,
set: setDirname,
});
// Access basename (`index.min.js`).
Object.defineProperty(VFile.prototype, 'basename', {
get: getBasename,
set: setBasename,
});
// Access extname (`.js`).
Object.defineProperty(VFile.prototype, 'extname', {
get: getExtname,
set: setExtname,
});
// Access stem (`index.min`).
Object.defineProperty(VFile.prototype, 'stem', {
get: getStem,
set: setStem,
});
// Construct a new file.
function VFile(options) {
var prop;
var index;
if (!options) {
options = {};
} else if (typeof options === 'string' || buffer(options)) {
options = { contents: options };
} else if ('message' in options && 'messages' in options) {
return options;
}
if (!(this instanceof VFile)) {
return new VFile(options);
}
this.data = {};
this.messages = [];
this.history = [];
this.cwd = proc.cwd();
// Set path related properties in the correct order.
index = -1;
while (++index < order.length) {
prop = order[index];
if (own.call(options, prop)) {
this[prop] = options[prop];
}
}
// Set non-path related properties.
for (prop in options) {
if (order.indexOf(prop) < 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(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'
);
}
}
/***/
},
/***/ 77: /***/ (module, __unused_webpack_exports, __nccwpck_require__) => {
'use strict';
var VMessage = __nccwpck_require__(4108);
var VFile = __nccwpck_require__(9523);
module.exports = 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;
}
/***/
},
/***/ 9239: /***/ (
module,
__unused_webpack_exports,
__nccwpck_require__
) => {
'use strict';
module.exports = __nccwpck_require__(1017);
/***/
},
/***/ 6070: /***/ (module) => {
'use strict';
module.exports = process;
/***/
},
/***/ 2157: /***/ (module) => {
/*!
* Determine if an object is a Buffer
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
module.exports = function isBuffer(obj) {
return (
obj != null &&
obj.constructor != null &&
typeof obj.constructor.isBuffer === 'function' &&
obj.constructor.isBuffer(obj)
);
};
/***/
},
/***/ 1067: /***/ (module) => {
'use strict';
module.exports = factory;
var noop = Function.prototype;
var own = {}.hasOwnProperty;
// Handle values based on a property.
function factory(key, options) {
var settings = options || {};
function one(value) {
var fn = one.invalid;
var handlers = one.handlers;
if (value && own.call(value, key)) {
fn = own.call(handlers, value[key])
? handlers[value[key]]
: one.unknown;
}
return (fn || noop).apply(this, arguments);
}
one.handlers = settings.handlers || {};
one.invalid = settings.invalid;
one.unknown = settings.unknown;
return one;
}
/***/
},
/***/ 6350: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
// original content by: https://github.com/TriPSs/conventional-changelog-action/blob/master/src/helpers/git.js
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (
!desc ||
('get' in desc
? !m.__esModule
: desc.writable || desc.configurable)
) {
desc = {
enumerable: true,
get: function () {
return m[k];
},
};
}
Object.defineProperty(o, k2, desc);
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {
enumerable: true,
value: v,
});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (
k !== 'default' &&
Object.prototype.hasOwnProperty.call(mod, k)
)
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
Object.defineProperty(exports, '__esModule', { value: true });
const core = __importStar(__nccwpck_require__(2186));
const exec = __importStar(__nccwpck_require__(1514));
const { GITHUB_REPOSITORY, GITHUB_REF } = process.env;
const branch =
GITHUB_REF === null || GITHUB_REF === void 0
? void 0
: GITHUB_REF.replace('refs/heads/', '');
class Git {
constructor() {
this.isShallow = () =>
__awaiter(this, void 0, void 0, function* () {
const isShallow = yield this.exec(
'rev-parse --is-shallow-repository'
);
return isShallow.trim().replace('\n', '') === 'true';
});
this.config = (prop, value) => this.exec(`config ${prop} "${value}"`);
this.add = (file) => {
let str = '';
if (Array.isArray(file)) {
file.map((f) => (str += ` ${f}`));
} else {
str = file;
}
return this.exec(`add ${str}`);
};
this.commit = (message) => this.exec(`commit -m "${message}"`);
this.pull = () =>
__awaiter(this, void 0, void 0, function* () {
const args = ['pull'];
// Check if the repo is unshallow
if (yield this.isShallow()) {
args.push('--unshallow');
}
args.push('--tags');
args.push(core.getInput('git-pull-method'));
return this.exec(args.join(' '));
});
this.push = () => this.exec(`push origin ${branch} --follow-tags`);
this.updateOrigin = (repo) =>
this.exec(`remote set-url origin ${repo}`);
this.createTag = (tag) => this.exec(`tag -a ${tag} -m "${tag}"`);
const githubToken = core.getInput('github-token', { required: true });
core.setSecret(githubToken);
const githubName = core.getInput('github-name') || 'GitHub Actions';
const githubEmail =
core.getInput('github-email') || 'actions@users.noreply.github.com';
// Set config
this.config('user.name', githubName);
this.config('user.email', githubEmail);
this.config('pull.rebase', 'false');
// Update the origin
this.updateOrigin(
`https://x-access-token:${githubToken}@github.com/${GITHUB_REPOSITORY}.git`
);
}
exec(command) {
return __awaiter(this, void 0, void 0, function* () {
let execOutput = '';
const options = {
listeners: {
stdout: (data) => {
execOutput += data.toString();
},
},
};
const exitCode = yield exec.exec(
`git ${command}`,
undefined,
options
);
if (exitCode === 0) {
return execOutput;
} else {
core.error(
`Command "git ${command}" exited with code ${exitCode}.`
);
throw new Error(
`Command "git ${command}" exited with code ${exitCode}.`
);
}
});
}
}
exports['default'] = new Git();
/***/
},
/***/ 3015: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (
!desc ||
('get' in desc
? !m.__esModule
: desc.writable || desc.configurable)
) {
desc = {
enumerable: true,
get: function () {
return m[k];
},
};
}
Object.defineProperty(o, k2, desc);
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {
enumerable: true,
value: v,
});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (
k !== 'default' &&
Object.prototype.hasOwnProperty.call(mod, k)
)
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
var __importDefault =
(this && this.__importDefault) ||
function (mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
var _a;
Object.defineProperty(exports, '__esModule', { value: true });
exports.pushNewFiles = exports.MARKDOWN_FILENAME = exports.generateMd = exports.renderer = exports.API_STARRED_URL = exports.REPO_USERNAME = void 0;
const fs_1 = __importDefault(__nccwpck_require__(7147));
const ejs_1 = __importDefault(__nccwpck_require__(8431));
const core = __importStar(__nccwpck_require__(2186));
const remark_1 = __importDefault(__nccwpck_require__(2081));
const remark_toc_1 = __importDefault(__nccwpck_require__(5096));
const git_1 = __importDefault(__nccwpck_require__(6350));
exports.REPO_USERNAME =
(_a = process.env.GITHUB_REPOSITORY) === null || _a === void 0
? void 0
: _a.split('/')[0];
exports.API_STARRED_URL = `${process.env.GITHUB_API_URL}/users/${exports.REPO_USERNAME}/starred`;
const fsp = fs_1.default.promises;
function renderer(data, templateString) {
return __awaiter(this, void 0, void 0, function* () {
try {
return ejs_1.default.render(templateString, data);
} catch (error) {
core.setFailed(`#renderer: ${error}`);
return '';
}
});
}
exports.renderer = renderer;
function generateMd(data) {
return new Promise((resolve) => {
(0, remark_1.default)()
.use(remark_toc_1.default)
.process(data, function (error, file) {
if (error) {
core.error('#generateMd');
core.error(error);
return resolve('');
}
return resolve(String(file));
});
});
}
exports.generateMd = generateMd;
exports.MARKDOWN_FILENAME = core.getInput('output-filename');
function pushNewFiles(files = []) {
return __awaiter(this, void 0, void 0, function* () {
if (!files.length) return;
yield git_1.default.pull();
yield Promise.all(
files.map(({ filename, data }) => fsp.writeFile(filename, data))
);
yield git_1.default.add(files.map(({ filename }) => filename));
yield git_1.default.commit(
`chore(updates): updated entries in files`
);
yield git_1.default.push();
});
}
exports.pushNewFiles = pushNewFiles;
/***/
},
/***/ 6144: /***/ function (
__unused_webpack_module,
exports,
__nccwpck_require__
) {
'use strict';
var __createBinding =
(this && this.__createBinding) ||
(Object.create
? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (
!desc ||
('get' in desc
? !m.__esModule
: desc.writable || desc.configurable)
) {
desc = {
enumerable: true,
get: function () {
return m[k];
},
};
}
Object.defineProperty(o, k2, desc);
}
: function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault =
(this && this.__setModuleDefault) ||
(Object.create
? function (o, v) {
Object.defineProperty(o, 'default', {
enumerable: true,
value: v,
});
}
: function (o, v) {
o['default'] = v;
});
var __importStar =
(this && this.__importStar) ||
function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (
k !== 'default' &&
Object.prototype.hasOwnProperty.call(mod, k)
)
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter =
(this && this.__awaiter) ||
function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P
? value
: new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator['throw'](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done
? resolve(result.value)
: adopt(result.value).then(fulfilled, rejected);
}
step(
(generator = generator.apply(thisArg, _arguments || [])).next()
);
});
};
var __importDefault =
(this && this.__importDefault) ||
function (mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
Object.defineProperty(exports, '__esModule', { value: true });
exports.run = exports.main = void 0;
const core = __importStar(__nccwpck_require__(2186));
const promises_1 = __nccwpck_require__(3292);
const gh_star_fetch_1 = __importDefault(__nccwpck_require__(1696));
const helpers_1 = __nccwpck_require__(3015);
const template_1 = __importDefault(__nccwpck_require__(3932));
function main() {
return __awaiter(this, void 0, void 0, function* () {
// set default template
let template = template_1.default;
// get template if found in the repo
const customTemplatePath = core.getInput('template-path');
console.log(
`check if customTemplatePath: ${customTemplatePath} exists`
);
try {
const dir = yield (0, promises_1.readdir)('./');
template = yield (0, promises_1.readFile)(
customTemplatePath,
'utf8'
);
} catch (_a) {
console.log("Couldn't find template file, using default");
}
const sortedByLanguages = yield (0, gh_star_fetch_1.default)({
accessToken: core.getInput('api-token', { required: true }),
compactByLanguage: true,
});
const rendered = yield (0, helpers_1.renderer)(
{
username: helpers_1.REPO_USERNAME,
stars: Object.entries(sortedByLanguages),
updatedAt: Date.now(),
},
template
);
const markdown = yield (0, helpers_1.generateMd)(rendered);
yield (0, helpers_1.pushNewFiles)([
{
filename: helpers_1.MARKDOWN_FILENAME,
data: markdown,
},
{
filename: 'data.json',
data: JSON.stringify(sortedByLanguages, null, 2),
},
]);
});
}
exports.main = main;
function run() {
return __awaiter(this, void 0, void 0, function* () {
try {
yield main();
} catch (error) {
core.setFailed(`#run: ${error}`);
}
});
}
exports.run = run;
const catchAll = (info) => {
core.setFailed(`#catchAll: ${info}`);
core.error(info);
};
process.on('unhandledRejection', catchAll);
process.on('uncaughtException', catchAll);
run().catch(core.error);
/***/
},
/***/ 3932: /***/ (__unused_webpack_module, exports) => {
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
exports[
'default'
] = `# <%= username %> Awesome List [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)
> :star: generated with [simonecorsi/mawesome](https://github.com/simonecorsi/mawesome)
## Table of Contents
<% for(let [language, repositories] of stars) { %>
## <%= language %>
<% for(let repo of repositories) { %>- [<%= repo.full_name %>](<%= repo.html_url %>) - <%= repo.description %>
<% } %>
<% } %>
`;
/***/
},
/***/ 1696: /***/ (module) => {
module.exports = eval('require')('gh-star-fetch');
/***/
},
/***/ 9491: /***/ (module) => {
'use strict';
module.exports = require('assert');
/***/
},
/***/ 8493: /***/ (module) => {
'use strict';
module.exports = require('child_process');
/***/
},
/***/ 2361: /***/ (module) => {
'use strict';
module.exports = require('events');
/***/
},
/***/ 7147: /***/ (module) => {
'use strict';
module.exports = require('fs');
/***/
},
/***/ 3292: /***/ (module) => {
'use strict';
module.exports = require('fs/promises');
/***/
},
/***/ 2037: /***/ (module) => {
'use strict';
module.exports = require('os');
/***/
},
/***/ 1017: /***/ (module) => {
'use strict';
module.exports = require('path');
/***/
},
/***/ 1576: /***/ (module) => {
'use strict';
module.exports = require('string_decoder');
/***/
},
/***/ 9512: /***/ (module) => {
'use strict';
module.exports = require('timers');
/***/
},
/***/ 3837: /***/ (module) => {
'use strict';
module.exports = require('util');
/***/
},
/***/ 2661: /***/ (module) => {
'use strict';
module.exports = JSON.parse(
'{"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":"‌"}'
);
/***/
},
/***/ 3558: /***/ (module) => {
'use strict';
module.exports = { i8: '3.1.6' };
/***/
},
/******/
}; // The module cache
/************************************************************************/
/******/ /******/ var __webpack_module_cache__ = {}; // The require function
/******/
/******/ /******/ function __nccwpck_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/
} // Create a new module (and put it into the cache)
/******/ /******/ var module = (__webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {},
/******/
}); // Execute the module function
/******/
/******/ /******/ var threw = true;
/******/ try {
/******/ __webpack_modules__[moduleId].call(
module.exports,
module,
module.exports,
__nccwpck_require__
);
/******/ threw = false;
/******/
} finally {
/******/ if (threw) delete __webpack_module_cache__[moduleId];
/******/
} // Return the exports of the module
/******/
/******/ /******/ return module.exports;
/******/
} /* webpack/runtime/compat */
/******/
/************************************************************************/
/******/ /******/
/******/ if (typeof __nccwpck_require__ !== 'undefined')
__nccwpck_require__.ab = __dirname + '/'; // startup // Load entry module and return exports // This entry module is referenced by other modules so it can't be inlined
/******/
/************************************************************************/
/******/
/******/ /******/ /******/ /******/ var __webpack_exports__ = __nccwpck_require__(
6144
);
/******/ module.exports = __webpack_exports__;
/******/
/******/
})();
Reference in New Issue View Git Blame Copy Permalink