@readme/markdown
Version:
ReadMe's React-based Markdown parser
1,482 lines (1,447 loc) • 982 kB
JavaScript
"use strict";
exports.id = 10;
exports.ids = [10];
exports.modules = {
/***/ 671:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
z: () => (/* reexport */ BaseRegExpVisitor),
H: () => (/* reexport */ RegExpParser)
});
;// ./node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js
function cc(char) {
return char.charCodeAt(0);
}
function insertToSet(item, set) {
if (Array.isArray(item)) {
item.forEach(function (subItem) {
set.push(subItem);
});
}
else {
set.push(item);
}
}
function addFlag(flagObj, flagKey) {
if (flagObj[flagKey] === true) {
throw "duplicate flag " + flagKey;
}
const x = flagObj[flagKey];
flagObj[flagKey] = true;
}
function ASSERT_EXISTS(obj) {
// istanbul ignore next
if (obj === undefined) {
throw Error("Internal Error - Should never get here!");
}
return true;
}
// istanbul ignore next
function ASSERT_NEVER_REACH_HERE() {
throw Error("Internal Error - Should never get here!");
}
function isCharacter(obj) {
return obj["type"] === "Character";
}
//# sourceMappingURL=utils.js.map
;// ./node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js
const digitsCharCodes = [];
for (let i = cc("0"); i <= cc("9"); i++) {
digitsCharCodes.push(i);
}
const wordCharCodes = [cc("_")].concat(digitsCharCodes);
for (let i = cc("a"); i <= cc("z"); i++) {
wordCharCodes.push(i);
}
for (let i = cc("A"); i <= cc("Z"); i++) {
wordCharCodes.push(i);
}
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#character-classes
const whitespaceCodes = [
cc(" "),
cc("\f"),
cc("\n"),
cc("\r"),
cc("\t"),
cc("\v"),
cc("\t"),
cc("\u00a0"),
cc("\u1680"),
cc("\u2000"),
cc("\u2001"),
cc("\u2002"),
cc("\u2003"),
cc("\u2004"),
cc("\u2005"),
cc("\u2006"),
cc("\u2007"),
cc("\u2008"),
cc("\u2009"),
cc("\u200a"),
cc("\u2028"),
cc("\u2029"),
cc("\u202f"),
cc("\u205f"),
cc("\u3000"),
cc("\ufeff"),
];
//# sourceMappingURL=character-classes.js.map
;// ./node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
// consts and utilities
const hexDigitPattern = /[0-9a-fA-F]/;
const decimalPattern = /[0-9]/;
const decimalPatternNoZero = /[1-9]/;
// https://hackernoon.com/the-madness-of-parsing-real-world-javascript-regexps-d9ee336df983
// https://www.ecma-international.org/ecma-262/8.0/index.html#prod-Pattern
class RegExpParser {
constructor() {
this.idx = 0;
this.input = "";
this.groupIdx = 0;
}
saveState() {
return {
idx: this.idx,
input: this.input,
groupIdx: this.groupIdx,
};
}
restoreState(newState) {
this.idx = newState.idx;
this.input = newState.input;
this.groupIdx = newState.groupIdx;
}
pattern(input) {
// parser state
this.idx = 0;
this.input = input;
this.groupIdx = 0;
this.consumeChar("/");
const value = this.disjunction();
this.consumeChar("/");
const flags = {
type: "Flags",
loc: { begin: this.idx, end: input.length },
global: false,
ignoreCase: false,
multiLine: false,
unicode: false,
sticky: false,
};
while (this.isRegExpFlag()) {
switch (this.popChar()) {
case "g":
addFlag(flags, "global");
break;
case "i":
addFlag(flags, "ignoreCase");
break;
case "m":
addFlag(flags, "multiLine");
break;
case "u":
addFlag(flags, "unicode");
break;
case "y":
addFlag(flags, "sticky");
break;
}
}
if (this.idx !== this.input.length) {
throw Error("Redundant input: " + this.input.substring(this.idx));
}
return {
type: "Pattern",
flags: flags,
value: value,
loc: this.loc(0),
};
}
disjunction() {
const alts = [];
const begin = this.idx;
alts.push(this.alternative());
while (this.peekChar() === "|") {
this.consumeChar("|");
alts.push(this.alternative());
}
return { type: "Disjunction", value: alts, loc: this.loc(begin) };
}
alternative() {
const terms = [];
const begin = this.idx;
while (this.isTerm()) {
terms.push(this.term());
}
return { type: "Alternative", value: terms, loc: this.loc(begin) };
}
term() {
if (this.isAssertion()) {
return this.assertion();
}
else {
return this.atom();
}
}
assertion() {
const begin = this.idx;
switch (this.popChar()) {
case "^":
return {
type: "StartAnchor",
loc: this.loc(begin),
};
case "$":
return { type: "EndAnchor", loc: this.loc(begin) };
// '\b' or '\B'
case "\\":
switch (this.popChar()) {
case "b":
return {
type: "WordBoundary",
loc: this.loc(begin),
};
case "B":
return {
type: "NonWordBoundary",
loc: this.loc(begin),
};
}
// istanbul ignore next
throw Error("Invalid Assertion Escape");
// '(?=' or '(?!'
case "(":
this.consumeChar("?");
let type;
switch (this.popChar()) {
case "=":
type = "Lookahead";
break;
case "!":
type = "NegativeLookahead";
break;
}
ASSERT_EXISTS(type);
const disjunction = this.disjunction();
this.consumeChar(")");
return {
type: type,
value: disjunction,
loc: this.loc(begin),
};
}
// istanbul ignore next
return ASSERT_NEVER_REACH_HERE();
}
quantifier(isBacktracking = false) {
let range = undefined;
const begin = this.idx;
switch (this.popChar()) {
case "*":
range = {
atLeast: 0,
atMost: Infinity,
};
break;
case "+":
range = {
atLeast: 1,
atMost: Infinity,
};
break;
case "?":
range = {
atLeast: 0,
atMost: 1,
};
break;
case "{":
const atLeast = this.integerIncludingZero();
switch (this.popChar()) {
case "}":
range = {
atLeast: atLeast,
atMost: atLeast,
};
break;
case ",":
let atMost;
if (this.isDigit()) {
atMost = this.integerIncludingZero();
range = {
atLeast: atLeast,
atMost: atMost,
};
}
else {
range = {
atLeast: atLeast,
atMost: Infinity,
};
}
this.consumeChar("}");
break;
}
// throwing exceptions from "ASSERT_EXISTS" during backtracking
// causes severe performance degradations
if (isBacktracking === true && range === undefined) {
return undefined;
}
ASSERT_EXISTS(range);
break;
}
// throwing exceptions from "ASSERT_EXISTS" during backtracking
// causes severe performance degradations
if (isBacktracking === true && range === undefined) {
return undefined;
}
// istanbul ignore else
if (ASSERT_EXISTS(range)) {
if (this.peekChar(0) === "?") {
this.consumeChar("?");
range.greedy = false;
}
else {
range.greedy = true;
}
range.type = "Quantifier";
range.loc = this.loc(begin);
return range;
}
}
atom() {
let atom;
const begin = this.idx;
switch (this.peekChar()) {
case ".":
atom = this.dotAll();
break;
case "\\":
atom = this.atomEscape();
break;
case "[":
atom = this.characterClass();
break;
case "(":
atom = this.group();
break;
}
if (atom === undefined && this.isPatternCharacter()) {
atom = this.patternCharacter();
}
// istanbul ignore else
if (ASSERT_EXISTS(atom)) {
atom.loc = this.loc(begin);
if (this.isQuantifier()) {
atom.quantifier = this.quantifier();
}
return atom;
}
// istanbul ignore next
return ASSERT_NEVER_REACH_HERE();
}
dotAll() {
this.consumeChar(".");
return {
type: "Set",
complement: true,
value: [cc("\n"), cc("\r"), cc("\u2028"), cc("\u2029")],
};
}
atomEscape() {
this.consumeChar("\\");
switch (this.peekChar()) {
case "1":
case "2":
case "3":
case "4":
case "5":
case "6":
case "7":
case "8":
case "9":
return this.decimalEscapeAtom();
case "d":
case "D":
case "s":
case "S":
case "w":
case "W":
return this.characterClassEscape();
case "f":
case "n":
case "r":
case "t":
case "v":
return this.controlEscapeAtom();
case "c":
return this.controlLetterEscapeAtom();
case "0":
return this.nulCharacterAtom();
case "x":
return this.hexEscapeSequenceAtom();
case "u":
return this.regExpUnicodeEscapeSequenceAtom();
default:
return this.identityEscapeAtom();
}
}
decimalEscapeAtom() {
const value = this.positiveInteger();
return { type: "GroupBackReference", value: value };
}
characterClassEscape() {
let set;
let complement = false;
switch (this.popChar()) {
case "d":
set = digitsCharCodes;
break;
case "D":
set = digitsCharCodes;
complement = true;
break;
case "s":
set = whitespaceCodes;
break;
case "S":
set = whitespaceCodes;
complement = true;
break;
case "w":
set = wordCharCodes;
break;
case "W":
set = wordCharCodes;
complement = true;
break;
}
// istanbul ignore else
if (ASSERT_EXISTS(set)) {
return { type: "Set", value: set, complement: complement };
}
// istanbul ignore next
return ASSERT_NEVER_REACH_HERE();
}
controlEscapeAtom() {
let escapeCode;
switch (this.popChar()) {
case "f":
escapeCode = cc("\f");
break;
case "n":
escapeCode = cc("\n");
break;
case "r":
escapeCode = cc("\r");
break;
case "t":
escapeCode = cc("\t");
break;
case "v":
escapeCode = cc("\v");
break;
}
// istanbul ignore else
if (ASSERT_EXISTS(escapeCode)) {
return { type: "Character", value: escapeCode };
}
// istanbul ignore next
return ASSERT_NEVER_REACH_HERE();
}
controlLetterEscapeAtom() {
this.consumeChar("c");
const letter = this.popChar();
if (/[a-zA-Z]/.test(letter) === false) {
throw Error("Invalid ");
}
const letterCode = letter.toUpperCase().charCodeAt(0) - 64;
return { type: "Character", value: letterCode };
}
nulCharacterAtom() {
// TODO implement '[lookahead ∉ DecimalDigit]'
// TODO: for the deprecated octal escape sequence
this.consumeChar("0");
return { type: "Character", value: cc("\0") };
}
hexEscapeSequenceAtom() {
this.consumeChar("x");
return this.parseHexDigits(2);
}
regExpUnicodeEscapeSequenceAtom() {
this.consumeChar("u");
return this.parseHexDigits(4);
}
identityEscapeAtom() {
// TODO: implement "SourceCharacter but not UnicodeIDContinue"
// // http://unicode.org/reports/tr31/#Specific_Character_Adjustments
const escapedChar = this.popChar();
return { type: "Character", value: cc(escapedChar) };
}
classPatternCharacterAtom() {
switch (this.peekChar()) {
// istanbul ignore next
case "\n":
// istanbul ignore next
case "\r":
// istanbul ignore next
case "\u2028":
// istanbul ignore next
case "\u2029":
// istanbul ignore next
case "\\":
// istanbul ignore next
case "]":
throw Error("TBD");
default:
const nextChar = this.popChar();
return { type: "Character", value: cc(nextChar) };
}
}
characterClass() {
const set = [];
let complement = false;
this.consumeChar("[");
if (this.peekChar(0) === "^") {
this.consumeChar("^");
complement = true;
}
while (this.isClassAtom()) {
const from = this.classAtom();
const isFromSingleChar = from.type === "Character";
if (isCharacter(from) && this.isRangeDash()) {
this.consumeChar("-");
const to = this.classAtom();
const isToSingleChar = to.type === "Character";
// a range can only be used when both sides are single characters
if (isCharacter(to)) {
if (to.value < from.value) {
throw Error("Range out of order in character class");
}
set.push({ from: from.value, to: to.value });
}
else {
// literal dash
insertToSet(from.value, set);
set.push(cc("-"));
insertToSet(to.value, set);
}
}
else {
insertToSet(from.value, set);
}
}
this.consumeChar("]");
return { type: "Set", complement: complement, value: set };
}
classAtom() {
switch (this.peekChar()) {
// istanbul ignore next
case "]":
// istanbul ignore next
case "\n":
// istanbul ignore next
case "\r":
// istanbul ignore next
case "\u2028":
// istanbul ignore next
case "\u2029":
throw Error("TBD");
case "\\":
return this.classEscape();
default:
return this.classPatternCharacterAtom();
}
}
classEscape() {
this.consumeChar("\\");
switch (this.peekChar()) {
// Matches a backspace.
// (Not to be confused with \b word boundary outside characterClass)
case "b":
this.consumeChar("b");
return { type: "Character", value: cc("\u0008") };
case "d":
case "D":
case "s":
case "S":
case "w":
case "W":
return this.characterClassEscape();
case "f":
case "n":
case "r":
case "t":
case "v":
return this.controlEscapeAtom();
case "c":
return this.controlLetterEscapeAtom();
case "0":
return this.nulCharacterAtom();
case "x":
return this.hexEscapeSequenceAtom();
case "u":
return this.regExpUnicodeEscapeSequenceAtom();
default:
return this.identityEscapeAtom();
}
}
group() {
let capturing = true;
this.consumeChar("(");
switch (this.peekChar(0)) {
case "?":
this.consumeChar("?");
this.consumeChar(":");
capturing = false;
break;
default:
this.groupIdx++;
break;
}
const value = this.disjunction();
this.consumeChar(")");
const groupAst = {
type: "Group",
capturing: capturing,
value: value,
};
if (capturing) {
groupAst["idx"] = this.groupIdx;
}
return groupAst;
}
positiveInteger() {
let number = this.popChar();
// istanbul ignore next - can't ever get here due to previous lookahead checks
// still implementing this error checking in case this ever changes.
if (decimalPatternNoZero.test(number) === false) {
throw Error("Expecting a positive integer");
}
while (decimalPattern.test(this.peekChar(0))) {
number += this.popChar();
}
return parseInt(number, 10);
}
integerIncludingZero() {
let number = this.popChar();
if (decimalPattern.test(number) === false) {
throw Error("Expecting an integer");
}
while (decimalPattern.test(this.peekChar(0))) {
number += this.popChar();
}
return parseInt(number, 10);
}
patternCharacter() {
const nextChar = this.popChar();
switch (nextChar) {
// istanbul ignore next
case "\n":
// istanbul ignore next
case "\r":
// istanbul ignore next
case "\u2028":
// istanbul ignore next
case "\u2029":
// istanbul ignore next
case "^":
// istanbul ignore next
case "$":
// istanbul ignore next
case "\\":
// istanbul ignore next
case ".":
// istanbul ignore next
case "*":
// istanbul ignore next
case "+":
// istanbul ignore next
case "?":
// istanbul ignore next
case "(":
// istanbul ignore next
case ")":
// istanbul ignore next
case "[":
// istanbul ignore next
case "|":
// istanbul ignore next
throw Error("TBD");
default:
return { type: "Character", value: cc(nextChar) };
}
}
isRegExpFlag() {
switch (this.peekChar(0)) {
case "g":
case "i":
case "m":
case "u":
case "y":
return true;
default:
return false;
}
}
isRangeDash() {
return this.peekChar() === "-" && this.isClassAtom(1);
}
isDigit() {
return decimalPattern.test(this.peekChar(0));
}
isClassAtom(howMuch = 0) {
switch (this.peekChar(howMuch)) {
case "]":
case "\n":
case "\r":
case "\u2028":
case "\u2029":
return false;
default:
return true;
}
}
isTerm() {
return this.isAtom() || this.isAssertion();
}
isAtom() {
if (this.isPatternCharacter()) {
return true;
}
switch (this.peekChar(0)) {
case ".":
case "\\": // atomEscape
case "[": // characterClass
// TODO: isAtom must be called before isAssertion - disambiguate
case "(": // group
return true;
default:
return false;
}
}
isAssertion() {
switch (this.peekChar(0)) {
case "^":
case "$":
return true;
// '\b' or '\B'
case "\\":
switch (this.peekChar(1)) {
case "b":
case "B":
return true;
default:
return false;
}
// '(?=' or '(?!'
case "(":
return (this.peekChar(1) === "?" &&
(this.peekChar(2) === "=" || this.peekChar(2) === "!"));
default:
return false;
}
}
isQuantifier() {
const prevState = this.saveState();
try {
return this.quantifier(true) !== undefined;
}
catch (e) {
return false;
}
finally {
this.restoreState(prevState);
}
}
isPatternCharacter() {
switch (this.peekChar()) {
case "^":
case "$":
case "\\":
case ".":
case "*":
case "+":
case "?":
case "(":
case ")":
case "[":
case "|":
case "/":
case "\n":
case "\r":
case "\u2028":
case "\u2029":
return false;
default:
return true;
}
}
parseHexDigits(howMany) {
let hexString = "";
for (let i = 0; i < howMany; i++) {
const hexChar = this.popChar();
if (hexDigitPattern.test(hexChar) === false) {
throw Error("Expecting a HexDecimal digits");
}
hexString += hexChar;
}
const charCode = parseInt(hexString, 16);
return { type: "Character", value: charCode };
}
peekChar(howMuch = 0) {
return this.input[this.idx + howMuch];
}
popChar() {
const nextChar = this.peekChar(0);
this.consumeChar(undefined);
return nextChar;
}
consumeChar(char) {
if (char !== undefined && this.input[this.idx] !== char) {
throw Error("Expected: '" +
char +
"' but found: '" +
this.input[this.idx] +
"' at offset: " +
this.idx);
}
if (this.idx >= this.input.length) {
throw Error("Unexpected end of input");
}
this.idx++;
}
loc(begin) {
return { begin: begin, end: this.idx };
}
}
//# sourceMappingURL=regexp-parser.js.map
;// ./node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js
class BaseRegExpVisitor {
visitChildren(node) {
for (const key in node) {
const child = node[key];
/* istanbul ignore else */
if (node.hasOwnProperty(key)) {
if (child.type !== undefined) {
this.visit(child);
}
else if (Array.isArray(child)) {
child.forEach((subChild) => {
this.visit(subChild);
}, this);
}
}
}
}
visit(node) {
switch (node.type) {
case "Pattern":
this.visitPattern(node);
break;
case "Flags":
this.visitFlags(node);
break;
case "Disjunction":
this.visitDisjunction(node);
break;
case "Alternative":
this.visitAlternative(node);
break;
case "StartAnchor":
this.visitStartAnchor(node);
break;
case "EndAnchor":
this.visitEndAnchor(node);
break;
case "WordBoundary":
this.visitWordBoundary(node);
break;
case "NonWordBoundary":
this.visitNonWordBoundary(node);
break;
case "Lookahead":
this.visitLookahead(node);
break;
case "NegativeLookahead":
this.visitNegativeLookahead(node);
break;
case "Character":
this.visitCharacter(node);
break;
case "Set":
this.visitSet(node);
break;
case "Group":
this.visitGroup(node);
break;
case "GroupBackReference":
this.visitGroupBackReference(node);
break;
case "Quantifier":
this.visitQuantifier(node);
break;
}
this.visitChildren(node);
}
visitPattern(node) { }
visitFlags(node) { }
visitDisjunction(node) { }
visitAlternative(node) { }
// Assertion
visitStartAnchor(node) { }
visitEndAnchor(node) { }
visitWordBoundary(node) { }
visitNonWordBoundary(node) { }
visitLookahead(node) { }
visitNegativeLookahead(node) { }
// atoms
visitCharacter(node) { }
visitSet(node) { }
visitGroup(node) { }
visitGroupBackReference(node) { }
visitQuantifier(node) { }
}
//# sourceMappingURL=base-regexp-visitor.js.map
;// ./node_modules/@chevrotain/regexp-to-ast/lib/src/api.js
//# sourceMappingURL=api.js.map
/***/ }),
/***/ 1163:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ $: () => (/* binding */ createPacketServices)
/* harmony export */ });
/* unused harmony export PacketModule */
/* harmony import */ var _chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5608);
/* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6052);
/* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1281);
/* harmony import */ var langium__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1901);
// src/language/packet/module.ts
// src/language/packet/tokenBuilder.ts
var PacketTokenBuilder = class extends _chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .AbstractMermaidTokenBuilder */ .mR {
static {
(0,_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .K2)(this, "PacketTokenBuilder");
}
constructor() {
super(["packet"]);
}
};
// src/language/packet/module.ts
var PacketModule = {
parser: {
TokenBuilder: /* @__PURE__ */ (0,_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .K2)(() => new PacketTokenBuilder(), "TokenBuilder"),
ValueConverter: /* @__PURE__ */ (0,_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .K2)(() => new _chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .CommonValueConverter */ .Tm(), "ValueConverter")
}
};
function createPacketServices(context = langium__WEBPACK_IMPORTED_MODULE_1__/* .EmptyFileSystem */ .D) {
const shared = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .WQ)(
(0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultSharedCoreModule */ .u)(context),
_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .MermaidGeneratedSharedModule */ .sr
);
const Packet = (0,langium__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .WQ)(
(0,langium__WEBPACK_IMPORTED_MODULE_3__/* .createDefaultCoreModule */ .t)({ shared }),
_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .PacketGeneratedModule */ .AM,
PacketModule
);
shared.ServiceRegistry.register(Packet);
return { shared, Packet };
}
(0,_chunk_FPAJGGOC_mjs__WEBPACK_IMPORTED_MODULE_0__/* .__name */ .K2)(createPacketServices, "createPacketServices");
/***/ }),
/***/ 5608:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
mR: () => (/* binding */ AbstractMermaidTokenBuilder),
dg: () => (/* binding */ AbstractMermaidValueConverter),
jE: () => (/* binding */ ArchitectureGeneratedModule),
Tm: () => (/* binding */ CommonValueConverter),
eZ: () => (/* binding */ GitGraphGeneratedModule),
e5: () => (/* binding */ InfoGeneratedModule),
sr: () => (/* binding */ MermaidGeneratedSharedModule),
AM: () => (/* binding */ PacketGeneratedModule),
KX: () => (/* binding */ PieGeneratedModule),
YP: () => (/* binding */ RadarGeneratedModule),
eV: () => (/* binding */ TreemapGeneratedModule),
K2: () => (/* binding */ __name)
});
// UNUSED EXPORTS: Architecture, Branch, Commit, CommonTokenBuilder, GitGraph, Info, Merge, Packet, PacketBlock, Pie, PieSection, Radar, Statement, Treemap, isArchitecture, isBranch, isCommit, isGitGraph, isInfo, isMerge, isPacket, isPacketBlock, isPie, isPieSection, isTreemap
// EXTERNAL MODULE: ./node_modules/langium/lib/syntax-tree.js
var syntax_tree = __webpack_require__(4032);
// EXTERNAL MODULE: ./node_modules/langium/lib/default-module.js + 42 modules
var default_module = __webpack_require__(1901);
// EXTERNAL MODULE: ./node_modules/langium/lib/dependency-injection.js
var dependency_injection = __webpack_require__(1281);
// EXTERNAL MODULE: ./node_modules/langium/lib/languages/generated/ast.js
var ast = __webpack_require__(5684);
// EXTERNAL MODULE: ./node_modules/langium/lib/workspace/file-system-provider.js
var file_system_provider = __webpack_require__(6052);
// EXTERNAL MODULE: ./node_modules/vscode-uri/lib/esm/index.mjs
var esm = __webpack_require__(4247);
;// ./node_modules/langium/lib/utils/grammar-loader.js
/******************************************************************************
* Copyright 2023 TypeFox GmbH
* This program and the accompanying materials are made available under the
* terms of the MIT License, which is available in the project root.
******************************************************************************/
const minimalGrammarModule = {
Grammar: () => undefined,
LanguageMetaData: () => ({
caseInsensitive: false,
fileExtensions: ['.langium'],
languageId: 'langium'
})
};
const minimalSharedGrammarModule = {
AstReflection: () => new ast/* LangiumGrammarAstReflection */.QX()
};
function createMinimalGrammarServices() {
const shared = (0,dependency_injection/* inject */.WQ)((0,default_module/* createDefaultSharedCoreModule */.u)(file_system_provider/* EmptyFileSystem */.D), minimalSharedGrammarModule);
const grammar = (0,dependency_injection/* inject */.WQ)((0,default_module/* createDefaultCoreModule */.t)({ shared }), minimalGrammarModule);
shared.ServiceRegistry.register(grammar);
return grammar;
}
/**
* Load a Langium grammar for your language from a JSON string. This is used by several services,
* most notably the parser builder which interprets the grammar to create a parser.
*/
function loadGrammarFromJson(json) {
var _a;
const services = createMinimalGrammarServices();
const astNode = services.serializer.JsonSerializer.deserialize(json);
services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, esm/* URI */.r.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : 'grammar'}.langium`));
return astNode;
}
//# sourceMappingURL=grammar-loader.js.map
// EXTERNAL MODULE: ./node_modules/langium/lib/parser/value-converter.js
var value_converter = __webpack_require__(4480);
// EXTERNAL MODULE: ./node_modules/langium/lib/parser/token-builder.js
var token_builder = __webpack_require__(5355);
;// ./node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-FPAJGGOC.mjs
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
// src/language/generated/ast.ts
var Statement = "Statement";
var Architecture = "Architecture";
function isArchitecture(item) {
return reflection.isInstance(item, Architecture);
}
__name(isArchitecture, "isArchitecture");
var Axis = "Axis";
var Branch = "Branch";
function isBranch(item) {
return reflection.isInstance(item, Branch);
}
__name(isBranch, "isBranch");
var Checkout = "Checkout";
var CherryPicking = "CherryPicking";
var ClassDefStatement = "ClassDefStatement";
var Commit = "Commit";
function isCommit(item) {
return reflection.isInstance(item, Commit);
}
__name(isCommit, "isCommit");
var Curve = "Curve";
var Edge = "Edge";
var Entry = "Entry";
var GitGraph = "GitGraph";
function isGitGraph(item) {
return reflection.isInstance(item, GitGraph);
}
__name(isGitGraph, "isGitGraph");
var Group = "Group";
var Info = "Info";
function isInfo(item) {
return reflection.isInstance(item, Info);
}
__name(isInfo, "isInfo");
var Item = "Item";
var Junction = "Junction";
var Merge = "Merge";
function isMerge(item) {
return reflection.isInstance(item, Merge);
}
__name(isMerge, "isMerge");
var Option = "Option";
var Packet = "Packet";
function isPacket(item) {
return reflection.isInstance(item, Packet);
}
__name(isPacket, "isPacket");
var PacketBlock = "PacketBlock";
function isPacketBlock(item) {
return reflection.isInstance(item, PacketBlock);
}
__name(isPacketBlock, "isPacketBlock");
var Pie = "Pie";
function isPie(item) {
return reflection.isInstance(item, Pie);
}
__name(isPie, "isPie");
var PieSection = "PieSection";
function isPieSection(item) {
return reflection.isInstance(item, PieSection);
}
__name(isPieSection, "isPieSection");
var Radar = "Radar";
var Service = "Service";
var Treemap = "Treemap";
function isTreemap(item) {
return reflection.isInstance(item, Treemap);
}
__name(isTreemap, "isTreemap");
var TreemapRow = "TreemapRow";
var Direction = "Direction";
var Leaf = "Leaf";
var Section = "Section";
var MermaidAstReflection = class extends syntax_tree/* AbstractAstReflection */.kD {
static {
__name(this, "MermaidAstReflection");
}
getAllTypes() {
return [Architecture, Axis, Branch, Checkout, CherryPicking, ClassDefStatement, Commit, Curve, Direction, Edge, Entry, GitGraph, Group, Info, Item, Junction, Leaf, Merge, Option, Packet, PacketBlock, Pie, PieSection, Radar, Section, Service, Statement, Treemap, TreemapRow];
}
computeIsSubtype(subtype, supertype) {
switch (subtype) {
case Branch:
case Checkout:
case CherryPicking:
case Commit:
case Merge: {
return this.isSubtype(Statement, supertype);
}
case Direction: {
return this.isSubtype(GitGraph, supertype);
}
case Leaf:
case Section: {
return this.isSubtype(Item, supertype);
}
default: {
return false;
}
}
}
getReferenceType(refInfo) {
const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
switch (referenceId) {
case "Entry:axis": {
return Axis;
}
default: {
throw new Error(`${referenceId} is not a valid reference id.`);
}
}
}
getTypeMetaData(type) {
switch (type) {
case Architecture: {
return {
name: Architecture,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "edges", defaultValue: [] },
{ name: "groups", defaultValue: [] },
{ name: "junctions", defaultValue: [] },
{ name: "services", defaultValue: [] },
{ name: "title" }
]
};
}
case Axis: {
return {
name: Axis,
properties: [
{ name: "label" },
{ name: "name" }
]
};
}
case Branch: {
return {
name: Branch,
properties: [
{ name: "name" },
{ name: "order" }
]
};
}
case Checkout: {
return {
name: Checkout,
properties: [
{ name: "branch" }
]
};
}
case CherryPicking: {
return {
name: CherryPicking,
properties: [
{ name: "id" },
{ name: "parent" },
{ name: "tags", defaultValue: [] }
]
};
}
case ClassDefStatement: {
return {
name: ClassDefStatement,
properties: [
{ name: "className" },
{ name: "styleText" }
]
};
}
case Commit: {
return {
name: Commit,
properties: [
{ name: "id" },
{ name: "message" },
{ name: "tags", defaultValue: [] },
{ name: "type" }
]
};
}
case Curve: {
return {
name: Curve,
properties: [
{ name: "entries", defaultValue: [] },
{ name: "label" },
{ name: "name" }
]
};
}
case Edge: {
return {
name: Edge,
properties: [
{ name: "lhsDir" },
{ name: "lhsGroup", defaultValue: false },
{ name: "lhsId" },
{ name: "lhsInto", defaultValue: false },
{ name: "rhsDir" },
{ name: "rhsGroup", defaultValue: false },
{ name: "rhsId" },
{ name: "rhsInto", defaultValue: false },
{ name: "title" }
]
};
}
case Entry: {
return {
name: Entry,
properties: [
{ name: "axis" },
{ name: "value" }
]
};
}
case GitGraph: {
return {
name: GitGraph,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "statements", defaultValue: [] },
{ name: "title" }
]
};
}
case Group: {
return {
name: Group,
properties: [
{ name: "icon" },
{ name: "id" },
{ name: "in" },
{ name: "title" }
]
};
}
case Info: {
return {
name: Info,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "title" }
]
};
}
case Item: {
return {
name: Item,
properties: [
{ name: "classSelector" },
{ name: "name" }
]
};
}
case Junction: {
return {
name: Junction,
properties: [
{ name: "id" },
{ name: "in" }
]
};
}
case Merge: {
return {
name: Merge,
properties: [
{ name: "branch" },
{ name: "id" },
{ name: "tags", defaultValue: [] },
{ name: "type" }
]
};
}
case Option: {
return {
name: Option,
properties: [
{ name: "name" },
{ name: "value", defaultValue: false }
]
};
}
case Packet: {
return {
name: Packet,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "blocks", defaultValue: [] },
{ name: "title" }
]
};
}
case PacketBlock: {
return {
name: PacketBlock,
properties: [
{ name: "bits" },
{ name: "end" },
{ name: "label" },
{ name: "start" }
]
};
}
case Pie: {
return {
name: Pie,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "sections", defaultValue: [] },
{ name: "showData", defaultValue: false },
{ name: "title" }
]
};
}
case PieSection: {
return {
name: PieSection,
properties: [
{ name: "label" },
{ name: "value" }
]
};
}
case Radar: {
return {
name: Radar,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "axes", defaultValue: [] },
{ name: "curves", defaultValue: [] },
{ name: "options", defaultValue: [] },
{ name: "title" }
]
};
}
case Service: {
return {
name: Service,
properties: [
{ name: "icon" },
{ name: "iconText" },
{ name: "id" },
{ name: "in" },
{ name: "title" }
]
};
}
case Treemap: {
return {
name: Treemap,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "title" },
{ name: "TreemapRows", defaultValue: [] }
]
};
}
case TreemapRow: {
return {
name: TreemapRow,
properties: [
{ name: "indent" },
{ name: "item" }
]
};
}
case Direction: {
return {
name: Direction,
properties: [
{ name: "accDescr" },
{ name: "accTitle" },
{ name: "dir" },
{ name: "statements", defaultValue: [] },
{ name: "title" }
]
};
}
case Leaf: {
return {
name: Leaf,
properties: [
{ name: "classSelector" },
{ name: "name" },
{ name: "value" }
]
};
}
case Section: {
return {
name: Section,
properties: [
{ name: "classSelector" },
{ name: "name" }
]
};
}
default: {
return {
name: type,
properties: []
};
}
}
}
};
var reflection = new MermaidAstReflection();
// src/language/generated/grammar.ts
var loadedInfoGrammar;
var InfoGrammar = /* @__PURE__ */ __name(() => loadedInfoGrammar ?? (loadedInfoGrammar = loadGrammarFromJson(`{"$type":"Grammar","isDeclared":true,"name":"Info","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Info","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Keyword","value":"info"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"},{"$type":"Group","elements":[{"$type":"Keyword","value":"showInfo"},{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"*"}],"cardinality":"?"},{"$type":"RuleCall","rule":{"$ref":"#/rules@2"},"arguments":[],"cardinality":"?"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"EOL","dataType":"string","definition":{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@12"},"arguments":[],"cardinality":"+"},{"$type":"EndOfFile"}]},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","fragment":true,"name":"TitleAndAccessibilities","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Assignment","feature":"accDescr","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@4"},"arguments":[]}},{"$type":"Assignment","feature":"accTitle","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@5"},"arguments":[]}},{"$type":"Assignment","feature":"title","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@6"},"arguments":[]}}]},{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}],"cardinality":"+"},"definesHiddenTokens":false,"entry":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"TerminalRule","name":"BOOLEAN","type":{"$type":"ReturnType","name":"boolean"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"CharacterRange","left":{"$type":"Keyword","value":"true"}},{"$type":"CharacterRange","left":{"$type":"Keyword","value":"false"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_DESCR","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accDescr(?:[\\\\t ]*:([^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)|\\\\s*{([^}]*)})/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ACC_TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*accTitle[\\\\t ]*:(?:[^\\\\n\\\\r]*?(?=%%)|[^\\\\n\\\\r]*)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"TITLE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*title(?:[\\\\t ][^\\\\n\\\\r]*?(?=%%)|[\\\\t ][^\\\\n\\\\r]*|)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"FLOAT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/[0-9]+\\\\.[0-9]+(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"INT","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"RegexToken","regex":"/0|[1-9][0-9]*(?!\\\\.)/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NUMBER","type":{"$type":"ReturnType","name":"number"},"definition":{"$type":"TerminalAlternatives","elements":[{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@7"}},{"$type":"TerminalRuleCall","rule":{"$ref":"#/rules@8"}}]},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"STRING","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/\\"([^\\"\\\\\\\\]|\\\\\\\\.)*\\"|'([^'\\\\\\\\]|\\\\\\\\.)*'/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"ID","type":{"$type":"ReturnType","name":"string"},"definition":{"$type":"RegexToken","regex":"/[\\\\w]([-\\\\w]*\\\\w)?/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","name":"NEWLINE","definition":{"$type":"RegexToken","regex":"/\\\\r?\\\\n/"},"fragment":false,"hidden":false},{"$type":"TerminalRule","hidden":true,"name":"WHITESPACE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]+/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"YAML","definition":{"$type":"RegexToken","regex":"/---[\\\\t ]*\\\\r?\\\\n(?:[\\\\S\\\\s]*?\\\\r?\\\\n)?---(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"DIRECTIVE","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%{[\\\\S\\\\s]*?}%%(?:\\\\r?\\\\n|(?!\\\\S))/"},"fragment":false},{"$type":"TerminalRule","hidden":true,"name":"SINGLE_LINE_COMMENT","definition":{"$type":"RegexToken","regex":"/[\\\\t ]*%%[^\\\\n\\\\r]*/"},"fragment":false}],"definesHiddenTokens":false,"hiddenTokens":[],"interfaces":[],"types":[],"usedGrammars":[]}`)), "InfoGrammar");
var loadedPacketGrammar;
var PacketGrammar = /* @__PURE__ */ __name(() => loadedPacketGrammar ?? (loadedPacketGrammar = loadGrammarFromJson(`{"$type":"Grammar","isDeclared":true,"name":"Packet","imports":[],"rules":[{"$type":"ParserRule","entry":true,"name":"Packet","definition":{"$type":"Group","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[],"cardinality":"*"},{"$type":"Alternatives","elements":[{"$type":"Keyword","value":"packet"},{"$type":"Keyword","value":"packet-beta"}]},{"$type":"Alternatives","elements":[{"$type":"RuleCall","rule":{"$ref":"#/rules@3"},"arguments":[]},{"$type":"Assignment","feature":"blocks","operator":"+=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@1"},"arguments":[]}},{"$type":"RuleCall","rule":{"$ref":"#/rules@13"},"arguments":[]}],"cardinality":"*"}]},"definesHiddenTokens":false,"fragment":false,"hiddenTokens":[],"parameters":[],"wildcard":false},{"$type":"ParserRule","name":"PacketBlock","definition":{"$type":"Group","elements":[{"$type":"Alternatives","elements":[{"$type":"Group","elements":[{"$type":"Assignment","feature":"start","operator":"=","terminal":{"$type":"RuleCall","rule":{"$ref":"#/rules@9"},"arguments":[]}},{"$type":"Group