@qraft/asyncapi-plugin 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/_vendor/@asyncapi/specs/schemas/3.1.0.json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"3.1.0.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_vendor/@jsep-plugin/regex/dist/index.js

@@ -1,64 +0,0 @@
-const FSLASH_CODE = 47; // '/'
-const BSLASH_CODE = 92; // '\\'
-
-var index = {
-	name: 'regex',
-
-	init(jsep) {
-		// Regex literal: /abc123/ig
-		jsep.hooks.add('gobble-token', function gobbleRegexLiteral(env) {
-			if (this.code === FSLASH_CODE) {
-				const patternIndex = ++this.index;
-
-				let inCharSet = false;
-				while (this.index < this.expr.length) {
-					if (this.code === FSLASH_CODE && !inCharSet) {
-						const pattern = this.expr.slice(patternIndex, this.index);
-
-						let flags = '';
-						while (++this.index < this.expr.length) {
-							const code = this.code;
-							if ((code >= 97 && code <= 122) // a...z
-								|| (code >= 65 && code <= 90) // A...Z
-								|| (code >= 48 && code <= 57)) { // 0-9
-								flags += this.char;
-							}
-							else {
-								break;
-							}
-						}
-
-						let value;
-						try {
-							value = new RegExp(pattern, flags);
-						}
-						catch (e) {
-							this.throwError(e.message);
-						}
-
-						env.node = {
-							type: jsep.LITERAL,
-							value,
-							raw: this.expr.slice(patternIndex - 1, this.index),
-						};
-
-						// allow . [] and () after regex: /regex/.test(a)
-						env.node = this.gobbleTokenProperty(env.node);
-						return env.node;
-					}
-					if (this.code === jsep.OBRACK_CODE) {
-						inCharSet = true;
-					}
-					else if (inCharSet && this.code === jsep.CBRACK_CODE) {
-						inCharSet = false;
-					}
-					this.index += this.code === BSLASH_CODE ? 2 : 1;
-				}
-				this.throwError('Unclosed Regex');
-			}
-		});
-	},
-};
-
-export { index as default };
-//# sourceMappingURL=index.js.map

package/dist/_vendor/@jsep-plugin/regex/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@jsep-plugin/regex/dist/index.js"],"sourcesContent":["const FSLASH_CODE = 47; // '/'\nconst BSLASH_CODE = 92; // '\\\\'\n\nvar index = {\n\tname: 'regex',\n\n\tinit(jsep) {\n\t\t// Regex literal: /abc123/ig\n\t\tjsep.hooks.add('gobble-token', function gobbleRegexLiteral(env) {\n\t\t\tif (this.code === FSLASH_CODE) {\n\t\t\t\tconst patternIndex = ++this.index;\n\n\t\t\t\tlet inCharSet = false;\n\t\t\t\twhile (this.index < this.expr.length) {\n\t\t\t\t\tif (this.code === FSLASH_CODE && !inCharSet) {\n\t\t\t\t\t\tconst pattern = this.expr.slice(patternIndex, this.index);\n\n\t\t\t\t\t\tlet flags = '';\n\t\t\t\t\t\twhile (++this.index < this.expr.length) {\n\t\t\t\t\t\t\tconst code = this.code;\n\t\t\t\t\t\t\tif ((code >= 97 && code <= 122) // a...z\n\t\t\t\t\t\t\t\t|| (code >= 65 && code <= 90) // A...Z\n\t\t\t\t\t\t\t\t|| (code >= 48 && code <= 57)) { // 0-9\n\t\t\t\t\t\t\t\tflags += this.char;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tlet value;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tvalue = new RegExp(pattern, flags);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcatch (e) {\n\t\t\t\t\t\t\tthis.throwError(e.message);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tenv.node = {\n\t\t\t\t\t\t\ttype: jsep.LITERAL,\n\t\t\t\t\t\t\tvalue,\n\t\t\t\t\t\t\traw: this.expr.slice(patternIndex - 1, this.index),\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// allow . [] and () after regex: /regex/.test(a)\n\t\t\t\t\t\tenv.node = this.gobbleTokenProperty(env.node);\n\t\t\t\t\t\treturn env.node;\n\t\t\t\t\t}\n\t\t\t\t\tif (this.code === jsep.OBRACK_CODE) {\n\t\t\t\t\t\tinCharSet = true;\n\t\t\t\t\t}\n\t\t\t\t\telse if (inCharSet && this.code === jsep.CBRACK_CODE) {\n\t\t\t\t\t\tinCharSet = false;\n\t\t\t\t\t}\n\t\t\t\t\tthis.index += this.code === BSLASH_CODE ? 2 : 1;\n\t\t\t\t}\n\t\t\t\tthis.throwError('Unclosed Regex');\n\t\t\t}\n\t\t});\n\t},\n};\n\nexport { index as default };\n"],"names":[],"mappings":"AAAA,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB,MAAM,WAAW,GAAG,EAAE,CAAC;AACvB;AACG,IAAC,KAAK,GAAG;AACZ,CAAC,IAAI,EAAE,OAAO;AACd;AACA,CAAC,IAAI,CAAC,IAAI,EAAE;AACZ;AACA,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,cAAc,EAAE,SAAS,kBAAkB,CAAC,GAAG,EAAE;AAClE,GAAG,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE;AAClC,IAAI,MAAM,YAAY,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC;AACtC;AACA,IAAI,IAAI,SAAS,GAAG,KAAK,CAAC;AAC1B,IAAI,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AAC1C,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,CAAC,SAAS,EAAE;AAClD,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;AAChE;AACA,MAAM,IAAI,KAAK,GAAG,EAAE,CAAC;AACrB,MAAM,OAAO,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AAC9C,OAAO,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;AAC9B,OAAO,IAAI,CAAC,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,GAAG;AACrC,YAAY,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC;AACrC,YAAY,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,EAAE;AACvC,QAAQ,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;AAC3B,QAAQ;AACR,YAAY;AACZ,QAAQ,MAAM;AACd,QAAQ;AACR,OAAO;AACP;AACA,MAAM,IAAI,KAAK,CAAC;AAChB,MAAM,IAAI;AACV,OAAO,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AAC1C,OAAO;AACP,MAAM,OAAO,CAAC,EAAE;AAChB,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAClC,OAAO;AACP;AACA,MAAM,GAAG,CAAC,IAAI,GAAG;AACjB,OAAO,IAAI,EAAE,IAAI,CAAC,OAAO;AACzB,OAAO,KAAK;AACZ,OAAO,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC;AACzD,OAAO,CAAC;AACR;AACA;AACA,MAAM,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACpD,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC;AACtB,MAAM;AACN,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;AACzC,MAAM,SAAS,GAAG,IAAI,CAAC;AACvB,MAAM;AACN,UAAU,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;AAC3D,MAAM,SAAS,GAAG,KAAK,CAAC;AACxB,MAAM;AACN,KAAK,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC;AACrD,KAAK;AACL,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;AACtC,IAAI;AACJ,GAAG,CAAC,CAAC;AACL,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/dist/_vendor/@jsep-plugin/ternary/dist/index.js

@@ -1,55 +0,0 @@
-const CONDITIONAL_EXP = 'ConditionalExpression';
-
-var index = {
-	name: 'ternary',
-
-	init(jsep) {
-		// Ternary expression: test ? consequent : alternate
-		jsep.hooks.add('after-expression', function gobbleTernary(env) {
-			if (env.node && this.code === jsep.QUMARK_CODE) {
-				this.index++;
-				const test = env.node;
-				const consequent = this.gobbleExpression();
-
-				if (!consequent) {
-					this.throwError('Expected expression');
-				}
-
-				this.gobbleSpaces();
-
-				if (this.code === jsep.COLON_CODE) {
-					this.index++;
-					const alternate = this.gobbleExpression();
-
-					if (!alternate) {
-						this.throwError('Expected expression');
-					}
-					env.node = {
-						type: CONDITIONAL_EXP,
-						test,
-						consequent,
-						alternate,
-					};
-
-					// check for operators of higher priority than ternary (i.e. assignment)
-					// jsep sets || at 1, and assignment at 0.9, and conditional should be between them
-					if (test.operator && jsep.binary_ops[test.operator] <= 0.9) {
-						let newTest = test;
-						while (newTest.right.operator && jsep.binary_ops[newTest.right.operator] <= 0.9) {
-							newTest = newTest.right;
-						}
-						env.node.test = newTest.right;
-						newTest.right = env.node;
-						env.node = test;
-					}
-				}
-				else {
-					this.throwError('Expected :');
-				}
-			}
-		});
-	},
-};
-
-export { index as default };
-//# sourceMappingURL=index.js.map

package/dist/_vendor/@jsep-plugin/ternary/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@jsep-plugin/ternary/dist/index.js"],"sourcesContent":["const CONDITIONAL_EXP = 'ConditionalExpression';\n\nvar index = {\n\tname: 'ternary',\n\n\tinit(jsep) {\n\t\t// Ternary expression: test ? consequent : alternate\n\t\tjsep.hooks.add('after-expression', function gobbleTernary(env) {\n\t\t\tif (env.node && this.code === jsep.QUMARK_CODE) {\n\t\t\t\tthis.index++;\n\t\t\t\tconst test = env.node;\n\t\t\t\tconst consequent = this.gobbleExpression();\n\n\t\t\t\tif (!consequent) {\n\t\t\t\t\tthis.throwError('Expected expression');\n\t\t\t\t}\n\n\t\t\t\tthis.gobbleSpaces();\n\n\t\t\t\tif (this.code === jsep.COLON_CODE) {\n\t\t\t\t\tthis.index++;\n\t\t\t\t\tconst alternate = this.gobbleExpression();\n\n\t\t\t\t\tif (!alternate) {\n\t\t\t\t\t\tthis.throwError('Expected expression');\n\t\t\t\t\t}\n\t\t\t\t\tenv.node = {\n\t\t\t\t\t\ttype: CONDITIONAL_EXP,\n\t\t\t\t\t\ttest,\n\t\t\t\t\t\tconsequent,\n\t\t\t\t\t\talternate,\n\t\t\t\t\t};\n\n\t\t\t\t\t// check for operators of higher priority than ternary (i.e. assignment)\n\t\t\t\t\t// jsep sets || at 1, and assignment at 0.9, and conditional should be between them\n\t\t\t\t\tif (test.operator && jsep.binary_ops[test.operator] <= 0.9) {\n\t\t\t\t\t\tlet newTest = test;\n\t\t\t\t\t\twhile (newTest.right.operator && jsep.binary_ops[newTest.right.operator] <= 0.9) {\n\t\t\t\t\t\t\tnewTest = newTest.right;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tenv.node.test = newTest.right;\n\t\t\t\t\t\tnewTest.right = env.node;\n\t\t\t\t\t\tenv.node = test;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.throwError('Expected :');\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t},\n};\n\nexport { index as default };\n"],"names":[],"mappings":"AAAA,MAAM,eAAe,GAAG,uBAAuB,CAAC;AAChD;AACG,IAAC,KAAK,GAAG;AACZ,CAAC,IAAI,EAAE,SAAS;AAChB;AACA,CAAC,IAAI,CAAC,IAAI,EAAE;AACZ;AACA,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,kBAAkB,EAAE,SAAS,aAAa,CAAC,GAAG,EAAE;AACjE,GAAG,IAAI,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;AACnD,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;AACjB,IAAI,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;AAC1B,IAAI,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAC/C;AACA,IAAI,IAAI,CAAC,UAAU,EAAE;AACrB,KAAK,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;AAC5C,KAAK;AACL;AACA,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;AACxB;AACA,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,UAAU,EAAE;AACvC,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;AAClB,KAAK,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAC/C;AACA,KAAK,IAAI,CAAC,SAAS,EAAE;AACrB,MAAM,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAAC,CAAC;AAC7C,MAAM;AACN,KAAK,GAAG,CAAC,IAAI,GAAG;AAChB,MAAM,IAAI,EAAE,eAAe;AAC3B,MAAM,IAAI;AACV,MAAM,UAAU;AAChB,MAAM,SAAS;AACf,MAAM,CAAC;AACP;AACA;AACA;AACA,KAAK,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,EAAE;AACjE,MAAM,IAAI,OAAO,GAAG,IAAI,CAAC;AACzB,MAAM,OAAO,OAAO,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,GAAG,EAAE;AACvF,OAAO,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;AAC/B,OAAO;AACP,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;AACpC,MAAM,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;AAC/B,MAAM,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;AACtB,MAAM;AACN,KAAK;AACL,SAAS;AACT,KAAK,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AACnC,KAAK;AACL,IAAI;AACJ,GAAG,CAAC,CAAC;AACL,EAAE;AACF;;;;","x_google_ignoreList":[0]}

package/dist/_vendor/@stoplight/better-ajv-errors/dist/index.js

@@ -1,371 +0,0 @@
-import { __require as requireJsonpointer } from '../../../jsonpointer/jsonpointer.js';
-import { __require as requireLeven } from '../../../leven/index.js';
-
-var dist;
-var hasRequiredDist;
-
-function requireDist () {
-	if (hasRequiredDist) return dist;
-	hasRequiredDist = 1;
-
-	var pointer = /*@__PURE__*/ requireJsonpointer();
-	var leven = /*@__PURE__*/ requireLeven();
-
-	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-	var pointer__default = /*#__PURE__*/_interopDefaultLegacy(pointer);
-	var leven__default = /*#__PURE__*/_interopDefaultLegacy(leven);
-
-	// @flow
-
-	/*::
-	import type { Error, Node } from './types';
-	*/
-
-	// Basic
-	const eq = x => y => x === y;
-	const not = fn => x => !fn(x);
-
-	// https://github.com/facebook/flow/issues/2221
-	const getValues = /*::<Obj: Object>*/ (
-	  o /*: Obj*/,
-	) /*: $ReadOnlyArray<$Values<Obj>>*/ => Object.values(o);
-
-	const notUndefined = (x /*: mixed*/) => x !== undefined;
-
-	// Error
-	const isXError = x => (error /*: Error */) => error.keyword === x;
-	const isAnyOfError = isXError('anyOf');
-	const isEnumError = isXError('enum');
-	const getErrors = (node /*: Node*/) => (node && node.errors) || [];
-
-	// Node
-	const getChildren = (node /*: Node*/) /*: $ReadOnlyArray<Node>*/ =>
-	  (node && getValues(node.children)) || [];
-
-	const getSiblings = (parent /*: Node*/) => (
-	  node /*: Node*/,
-	) /*: $ReadOnlyArray<Node>*/ => getChildren(parent).filter(not(eq(node)));
-
-	const concatAll = /*::<T>*/ (xs /*: $ReadOnlyArray<T>*/) => (
-	  ys /*: $ReadOnlyArray<T>*/,
-	) /*: $ReadOnlyArray<T>*/ => ys.reduce((zs, z) => zs.concat(z), xs);
-
-	function getLastSegment(instancePath) {
-	  const index = instancePath.lastIndexOf('/');
-	  if (index !== -1) {
-	    return instancePath.slice(index + 1);
-	  }
-
-	  return null;
-	}
-
-	const QUOTES = /['"]/g;
-	const NOT = /NOT/g;
-	const FIRST_LETTER = /^[a-z]/;
-
-	function cleanAjvMessage(word) {
-	  return word.replace(QUOTES, '"').replace(NOT, 'not');
-	}
-
-	function toUpperCase(word) {
-	  return word.toUpperCase();
-	}
-
-	function capitalize(word) {
-	  return word.replace(FIRST_LETTER, toUpperCase);
-	}
-
-	class BaseValidationError {
-	  constructor(
-	    options = { isIdentifierLocation: false },
-	    { data, schema, propPath },
-	  ) {
-	    this.options = options;
-	    this.data = data;
-	    this.schema = schema;
-	    this.propPath = propPath;
-	  }
-
-	  getError() {
-	    throw new Error(
-	      `Implement the 'getError' method inside ${this.constructor.name}!`,
-	    );
-	  }
-
-	  getPrettyPropertyName(dataPath) {
-	    const propName = this.getPropertyName(dataPath);
-
-	    if (propName === null) {
-	      return capitalize(typeof this.getPropertyValue(dataPath));
-	    }
-
-	    return `"${propName}" property`;
-	  }
-
-	  getPropertyName(path) {
-	    const propName = getLastSegment(path);
-	    if (propName !== null) {
-	      return propName;
-	    }
-
-	    if (this.propPath.length === 0) {
-	      return null;
-	    }
-
-	    return this.propPath[this.propPath.length - 1];
-	  }
-
-	  getPropertyValue(path) {
-	    return path === '' ? this.data : pointer__default["default"].get(this.data, path);
-	  }
-	}
-
-	class RequiredValidationError extends BaseValidationError {
-	  getError() {
-	    const { message, instancePath } = this.options;
-
-	    return {
-	      error: `${this.getPrettyPropertyName(instancePath)} ${cleanAjvMessage(
-	        message,
-	      )}`,
-	      path: instancePath,
-	    };
-	  }
-	}
-
-	class AdditionalPropValidationError extends BaseValidationError {
-	  constructor(...args) {
-	    super(...args);
-	  }
-
-	  getError() {
-	    const { params, instancePath } = this.options;
-
-	    return {
-	      error: `Property "${params.additionalProperty}" is not expected to be here`,
-	      path: instancePath,
-	    };
-	  }
-	}
-
-	class EnumValidationError extends BaseValidationError {
-	  getError() {
-	    const { message, instancePath, params } = this.options;
-	    const bestMatch = this.findBestMatch();
-
-	    const output = {
-	      error: `${this.getPrettyPropertyName(
-	        instancePath,
-	      )} ${message}: ${params.allowedValues
-	        .map(value =>
-	          typeof value === 'string' ? `"${value}"` : JSON.stringify(value),
-	        )
-	        .join(', ')}`,
-	      path: instancePath,
-	    };
-
-	    if (bestMatch !== null) {
-	      output.suggestion = `Did you mean "${bestMatch}"?`;
-	    }
-
-	    return output;
-	  }
-
-	  findBestMatch() {
-	    const {
-	      instancePath,
-	      params: { allowedValues },
-	    } = this.options;
-
-	    const currentValue = this.getPropertyValue(instancePath);
-
-	    if (typeof currentValue !== 'string') {
-	      return null;
-	    }
-
-	    const matches = allowedValues
-	      .filter(value => typeof value === 'string')
-	      .map(value => ({
-	        value,
-	        weight: leven__default["default"](value, currentValue.toString()),
-	      }))
-	      .sort((x, y) => (x.weight > y.weight ? 1 : x.weight < y.weight ? -1 : 0));
-
-	    if (matches.length === 0) {
-	      return null;
-	    }
-
-	    const bestMatch = matches[0];
-
-	    return allowedValues.length === 1 ||
-	      bestMatch.weight < bestMatch.value.length
-	      ? bestMatch.value
-	      : null;
-	  }
-	}
-
-	class DefaultValidationError extends BaseValidationError {
-	  getError() {
-	    const { message, instancePath } = this.options;
-
-	    return {
-	      error: `${this.getPrettyPropertyName(instancePath)} ${cleanAjvMessage(
-	        message,
-	      )}`,
-	      path: instancePath,
-	    };
-	  }
-	}
-
-	class TypeValidationError extends BaseValidationError {
-	  getError() {
-	    const { message, instancePath } = this.options;
-
-	    const propertyName = this.getPropertyName(instancePath);
-
-	    return {
-	      error:
-	        propertyName === null
-	          ? `Value type ${message}`
-	          : `"${propertyName}" property type ${message}`,
-	      path: instancePath,
-	    };
-	  }
-	}
-
-	class ErrorMessageError extends BaseValidationError {
-	  getError() {
-	    const { message, instancePath } = this.options;
-
-	    return {
-	      error: message,
-	      path: instancePath,
-	    };
-	  }
-	}
-
-	const JSON_POINTERS_REGEX = /\/[\w$_-]+(\/\d+)?/g;
-
-	// Make a tree of errors from ajv errors array
-	function makeTree(ajvErrors = []) {
-	  const root = { children: {} };
-	  ajvErrors.forEach(ajvError => {
-	    const { instancePath } = ajvError;
-
-	    // `instancePath === ''` is root
-	    const paths =
-	      instancePath === '' ? [''] : instancePath.match(JSON_POINTERS_REGEX);
-	    paths &&
-	      paths.reduce((obj, path, i) => {
-	        obj.children[path] = obj.children[path] || { children: {}, errors: [] };
-	        if (i === paths.length - 1) {
-	          obj.children[path].errors.push(ajvError);
-	        }
-	        return obj.children[path];
-	      }, root);
-	  });
-	  return root;
-	}
-
-	function filterRedundantErrors(root, parent, key) {
-	  /**
-	   * If there is an `anyOf` error that means we have more meaningful errors
-	   * inside children. So we will just remove all errors from this level.
-	   *
-	   * If there are no children, then we don't delete the errors since we should
-	   * have at least one error to report.
-	   */
-	  if (getErrors(root).some(isAnyOfError)) {
-	    if (Object.keys(root.children).length > 0) {
-	      delete root.errors;
-	    }
-	  }
-
-	  /**
-	   * If all errors are `enum` and siblings have any error then we can safely
-	   * ignore the node.
-	   *
-	   * **CAUTION**
-	   * Need explicit `root.errors` check because `[].every(fn) === true`
-	   * https://en.wikipedia.org/wiki/Vacuous_truth#Vacuous_truths_in_mathematics
-	   */
-	  if (root.errors && root.errors.length && getErrors(root).every(isEnumError)) {
-	    if (
-	      getSiblings(parent)(root)
-	        // Remove any reference which becomes `undefined` later
-	        .filter(notUndefined)
-	        .some(getErrors)
-	    ) {
-	      delete parent.children[key];
-	    }
-	  }
-
-	  Object.entries(root.children).forEach(([key, child]) =>
-	    filterRedundantErrors(child, root, key),
-	  );
-	}
-
-	function createErrorInstances(root, options) {
-	  const errors = getErrors(root);
-	  if (errors.length && errors.every(isEnumError)) {
-	    const uniqueValues = new Set(
-	      concatAll([])(errors.map(e => e.params.allowedValues)),
-	    );
-	    const allowedValues = [...uniqueValues];
-	    const error = errors[0];
-	    return [
-	      new EnumValidationError(
-	        {
-	          ...error,
-	          params: { allowedValues },
-	        },
-	        options,
-	      ),
-	    ];
-	  } else {
-	    return concatAll(
-	      errors.reduce((ret, error) => {
-	        switch (error.keyword) {
-	          case 'additionalProperties':
-	            return ret.concat(
-	              new AdditionalPropValidationError(error, options),
-	            );
-	          case 'required':
-	            return ret.concat(new RequiredValidationError(error, options));
-	          case 'type':
-	            return ret.concat(new TypeValidationError(error, options));
-	          case 'errorMessage':
-	            return ret.concat(new ErrorMessageError(error, options));
-	          default:
-	            return ret.concat(new DefaultValidationError(error, options));
-	        }
-	      }, []),
-	    )(getChildren(root).map(child => createErrorInstances(child, options)));
-	  }
-	}
-
-	var prettify = (ajvErrors, options) => {
-	  const tree = makeTree(ajvErrors || []);
-	  filterRedundantErrors(tree);
-	  return createErrorInstances(tree, options);
-	};
-
-	const customErrorToStructure = error => error.getError();
-
-	var index = (schema, errors, { propertyPath, targetValue }) => {
-	  const customErrors = prettify(errors, {
-	    data: targetValue,
-	    schema,
-	    propPath: propertyPath,
-	  });
-
-	  return customErrors.map(customErrorToStructure);
-	};
-
-	dist = index;
-	return dist;
-}
-
-export { requireDist as __require };
-//# sourceMappingURL=index.js.map

package/dist/_vendor/@stoplight/better-ajv-errors/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/@stoplight/better-ajv-errors/dist/index.js"],"sourcesContent":["'use strict';\n\nvar pointer = require('jsonpointer');\nvar leven = require('leven');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nvar pointer__default = /*#__PURE__*/_interopDefaultLegacy(pointer);\nvar leven__default = /*#__PURE__*/_interopDefaultLegacy(leven);\n\n// @flow\n\n/*::\nimport type { Error, Node } from './types';\n*/\n\n// Basic\nconst eq = x => y => x === y;\nconst not = fn => x => !fn(x);\n\n// https://github.com/facebook/flow/issues/2221\nconst getValues = /*::<Obj: Object>*/ (\n  o /*: Obj*/,\n) /*: $ReadOnlyArray<$Values<Obj>>*/ => Object.values(o);\n\nconst notUndefined = (x /*: mixed*/) => x !== undefined;\n\n// Error\nconst isXError = x => (error /*: Error */) => error.keyword === x;\nconst isAnyOfError = isXError('anyOf');\nconst isEnumError = isXError('enum');\nconst getErrors = (node /*: Node*/) => (node && node.errors) || [];\n\n// Node\nconst getChildren = (node /*: Node*/) /*: $ReadOnlyArray<Node>*/ =>\n  (node && getValues(node.children)) || [];\n\nconst getSiblings = (parent /*: Node*/) => (\n  node /*: Node*/,\n) /*: $ReadOnlyArray<Node>*/ => getChildren(parent).filter(not(eq(node)));\n\nconst concatAll = /*::<T>*/ (xs /*: $ReadOnlyArray<T>*/) => (\n  ys /*: $ReadOnlyArray<T>*/,\n) /*: $ReadOnlyArray<T>*/ => ys.reduce((zs, z) => zs.concat(z), xs);\n\nfunction getLastSegment(instancePath) {\n  const index = instancePath.lastIndexOf('/');\n  if (index !== -1) {\n    return instancePath.slice(index + 1);\n  }\n\n  return null;\n}\n\nconst QUOTES = /['\"]/g;\nconst NOT = /NOT/g;\nconst FIRST_LETTER = /^[a-z]/;\n\nfunction cleanAjvMessage(word) {\n  return word.replace(QUOTES, '\"').replace(NOT, 'not');\n}\n\nfunction toUpperCase(word) {\n  return word.toUpperCase();\n}\n\nfunction capitalize(word) {\n  return word.replace(FIRST_LETTER, toUpperCase);\n}\n\nclass BaseValidationError {\n  constructor(\n    options = { isIdentifierLocation: false },\n    { data, schema, propPath },\n  ) {\n    this.options = options;\n    this.data = data;\n    this.schema = schema;\n    this.propPath = propPath;\n  }\n\n  getError() {\n    throw new Error(\n      `Implement the 'getError' method inside ${this.constructor.name}!`,\n    );\n  }\n\n  getPrettyPropertyName(dataPath) {\n    const propName = this.getPropertyName(dataPath);\n\n    if (propName === null) {\n      return capitalize(typeof this.getPropertyValue(dataPath));\n    }\n\n    return `\"${propName}\" property`;\n  }\n\n  getPropertyName(path) {\n    const propName = getLastSegment(path);\n    if (propName !== null) {\n      return propName;\n    }\n\n    if (this.propPath.length === 0) {\n      return null;\n    }\n\n    return this.propPath[this.propPath.length - 1];\n  }\n\n  getPropertyValue(path) {\n    return path === '' ? this.data : pointer__default[\"default\"].get(this.data, path);\n  }\n}\n\nclass RequiredValidationError extends BaseValidationError {\n  getError() {\n    const { message, instancePath } = this.options;\n\n    return {\n      error: `${this.getPrettyPropertyName(instancePath)} ${cleanAjvMessage(\n        message,\n      )}`,\n      path: instancePath,\n    };\n  }\n}\n\nclass AdditionalPropValidationError extends BaseValidationError {\n  constructor(...args) {\n    super(...args);\n  }\n\n  getError() {\n    const { params, instancePath } = this.options;\n\n    return {\n      error: `Property \"${params.additionalProperty}\" is not expected to be here`,\n      path: instancePath,\n    };\n  }\n}\n\nclass EnumValidationError extends BaseValidationError {\n  getError() {\n    const { message, instancePath, params } = this.options;\n    const bestMatch = this.findBestMatch();\n\n    const output = {\n      error: `${this.getPrettyPropertyName(\n        instancePath,\n      )} ${message}: ${params.allowedValues\n        .map(value =>\n          typeof value === 'string' ? `\"${value}\"` : JSON.stringify(value),\n        )\n        .join(', ')}`,\n      path: instancePath,\n    };\n\n    if (bestMatch !== null) {\n      output.suggestion = `Did you mean \"${bestMatch}\"?`;\n    }\n\n    return output;\n  }\n\n  findBestMatch() {\n    const {\n      instancePath,\n      params: { allowedValues },\n    } = this.options;\n\n    const currentValue = this.getPropertyValue(instancePath);\n\n    if (typeof currentValue !== 'string') {\n      return null;\n    }\n\n    const matches = allowedValues\n      .filter(value => typeof value === 'string')\n      .map(value => ({\n        value,\n        weight: leven__default[\"default\"](value, currentValue.toString()),\n      }))\n      .sort((x, y) => (x.weight > y.weight ? 1 : x.weight < y.weight ? -1 : 0));\n\n    if (matches.length === 0) {\n      return null;\n    }\n\n    const bestMatch = matches[0];\n\n    return allowedValues.length === 1 ||\n      bestMatch.weight < bestMatch.value.length\n      ? bestMatch.value\n      : null;\n  }\n}\n\nclass DefaultValidationError extends BaseValidationError {\n  getError() {\n    const { message, instancePath } = this.options;\n\n    return {\n      error: `${this.getPrettyPropertyName(instancePath)} ${cleanAjvMessage(\n        message,\n      )}`,\n      path: instancePath,\n    };\n  }\n}\n\nclass TypeValidationError extends BaseValidationError {\n  getError() {\n    const { message, instancePath } = this.options;\n\n    const propertyName = this.getPropertyName(instancePath);\n\n    return {\n      error:\n        propertyName === null\n          ? `Value type ${message}`\n          : `\"${propertyName}\" property type ${message}`,\n      path: instancePath,\n    };\n  }\n}\n\nclass ErrorMessageError extends BaseValidationError {\n  getError() {\n    const { message, instancePath } = this.options;\n\n    return {\n      error: message,\n      path: instancePath,\n    };\n  }\n}\n\nconst JSON_POINTERS_REGEX = /\\/[\\w$_-]+(\\/\\d+)?/g;\n\n// Make a tree of errors from ajv errors array\nfunction makeTree(ajvErrors = []) {\n  const root = { children: {} };\n  ajvErrors.forEach(ajvError => {\n    const { instancePath } = ajvError;\n\n    // `instancePath === ''` is root\n    const paths =\n      instancePath === '' ? [''] : instancePath.match(JSON_POINTERS_REGEX);\n    paths &&\n      paths.reduce((obj, path, i) => {\n        obj.children[path] = obj.children[path] || { children: {}, errors: [] };\n        if (i === paths.length - 1) {\n          obj.children[path].errors.push(ajvError);\n        }\n        return obj.children[path];\n      }, root);\n  });\n  return root;\n}\n\nfunction filterRedundantErrors(root, parent, key) {\n  /**\n   * If there is an `anyOf` error that means we have more meaningful errors\n   * inside children. So we will just remove all errors from this level.\n   *\n   * If there are no children, then we don't delete the errors since we should\n   * have at least one error to report.\n   */\n  if (getErrors(root).some(isAnyOfError)) {\n    if (Object.keys(root.children).length > 0) {\n      delete root.errors;\n    }\n  }\n\n  /**\n   * If all errors are `enum` and siblings have any error then we can safely\n   * ignore the node.\n   *\n   * **CAUTION**\n   * Need explicit `root.errors` check because `[].every(fn) === true`\n   * https://en.wikipedia.org/wiki/Vacuous_truth#Vacuous_truths_in_mathematics\n   */\n  if (root.errors && root.errors.length && getErrors(root).every(isEnumError)) {\n    if (\n      getSiblings(parent)(root)\n        // Remove any reference which becomes `undefined` later\n        .filter(notUndefined)\n        .some(getErrors)\n    ) {\n      delete parent.children[key];\n    }\n  }\n\n  Object.entries(root.children).forEach(([key, child]) =>\n    filterRedundantErrors(child, root, key),\n  );\n}\n\nfunction createErrorInstances(root, options) {\n  const errors = getErrors(root);\n  if (errors.length && errors.every(isEnumError)) {\n    const uniqueValues = new Set(\n      concatAll([])(errors.map(e => e.params.allowedValues)),\n    );\n    const allowedValues = [...uniqueValues];\n    const error = errors[0];\n    return [\n      new EnumValidationError(\n        {\n          ...error,\n          params: { allowedValues },\n        },\n        options,\n      ),\n    ];\n  } else {\n    return concatAll(\n      errors.reduce((ret, error) => {\n        switch (error.keyword) {\n          case 'additionalProperties':\n            return ret.concat(\n              new AdditionalPropValidationError(error, options),\n            );\n          case 'required':\n            return ret.concat(new RequiredValidationError(error, options));\n          case 'type':\n            return ret.concat(new TypeValidationError(error, options));\n          case 'errorMessage':\n            return ret.concat(new ErrorMessageError(error, options));\n          default:\n            return ret.concat(new DefaultValidationError(error, options));\n        }\n      }, []),\n    )(getChildren(root).map(child => createErrorInstances(child, options)));\n  }\n}\n\nvar prettify = (ajvErrors, options) => {\n  const tree = makeTree(ajvErrors || []);\n  filterRedundantErrors(tree);\n  return createErrorInstances(tree, options);\n};\n\nconst customErrorToStructure = error => error.getError();\n\nvar index = (schema, errors, { propertyPath, targetValue }) => {\n  const customErrors = prettify(errors, {\n    data: targetValue,\n    schema,\n    propPath: propertyPath,\n  });\n\n  return customErrors.map(customErrorToStructure);\n};\n\nmodule.exports = index;\n"],"names":["require$$0","require$$1"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_vendor/@stoplight/json/_vendor/safe-stable-stringify/index.js

@@ -1,18 +0,0 @@
-import { __require as requireStable } from './stable.js';
-
-var safeStableStringify;
-var hasRequiredSafeStableStringify;
-
-function requireSafeStableStringify () {
-	if (hasRequiredSafeStableStringify) return safeStableStringify;
-	hasRequiredSafeStableStringify = 1;
-
-	const stringify = /*@__PURE__*/ requireStable();
-
-	safeStableStringify = stringify;
-	stringify.default = stringify;
-	return safeStableStringify;
-}
-
-export { requireSafeStableStringify as __require };
-//# sourceMappingURL=index.js.map

package/dist/_vendor/@stoplight/json/_vendor/safe-stable-stringify/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/@stoplight/json/node_modules/safe-stable-stringify/index.js"],"sourcesContent":["'use strict'\n\nconst stringify = require('./stable')\n\nmodule.exports = stringify\nstringify.default = stringify\n"],"names":["require$$0"],"mappings":";;;;;;;;;AAEA,CAAA,MAAM,SAAS,iBAAGA,aAAA,GAAA;;AAElB,CAAA,mBAAc,GAAG,UAAA;CACjB,SAAS,CAAC,OAAO,GAAG,UAAA;;;;;;","x_google_ignoreList":[0]}