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

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

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

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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,371 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1 @@
+{"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]}