@cartanova/qgrid-cli 2.7.0 → 2.7.1

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js

@@ -0,0 +1,585 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./compile/codegen/index.js";
+import { require_util } from "./compile/util.js";
+import { require_rules } from "./compile/rules.js";
+import { require_dataType } from "./compile/validate/dataType.js";
+import { require_resolve } from "./compile/resolve.js";
+import { require_validate } from "./compile/validate/index.js";
+import { require_validation_error } from "./runtime/validation_error.js";
+import { require_ref_error } from "./compile/ref_error.js";
+import { require_compile } from "./compile/index.js";
+import { require_data } from "./refs/data.js";
+import { require_uri } from "./runtime/uri.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js
+var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
+	var validate_1 = require_validate();
+	Object.defineProperty(exports, "KeywordCxt", {
+		enumerable: true,
+		get: function() {
+			return validate_1.KeywordCxt;
+		}
+	});
+	var codegen_1 = require_codegen();
+	Object.defineProperty(exports, "_", {
+		enumerable: true,
+		get: function() {
+			return codegen_1._;
+		}
+	});
+	Object.defineProperty(exports, "str", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.str;
+		}
+	});
+	Object.defineProperty(exports, "stringify", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.stringify;
+		}
+	});
+	Object.defineProperty(exports, "nil", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.nil;
+		}
+	});
+	Object.defineProperty(exports, "Name", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.Name;
+		}
+	});
+	Object.defineProperty(exports, "CodeGen", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.CodeGen;
+		}
+	});
+	const validation_error_1 = require_validation_error();
+	const ref_error_1 = require_ref_error();
+	const rules_1 = require_rules();
+	const compile_1 = require_compile();
+	const codegen_2 = require_codegen();
+	const resolve_1 = require_resolve();
+	const dataType_1 = require_dataType();
+	const util_1 = require_util();
+	const $dataRefSchema = require_data();
+	const uri_1 = require_uri();
+	const defaultRegExp = (str, flags) => new RegExp(str, flags);
+	defaultRegExp.code = "new RegExp";
+	const META_IGNORE_OPTIONS = [
+		"removeAdditional",
+		"useDefaults",
+		"coerceTypes"
+	];
+	const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
+		"validate",
+		"serialize",
+		"parse",
+		"wrapper",
+		"root",
+		"schema",
+		"keyword",
+		"pattern",
+		"formats",
+		"validate$data",
+		"func",
+		"obj",
+		"Error"
+	]);
+	const removedOptions = {
+		errorDataPath: "",
+		format: "`validateFormats: false` can be used instead.",
+		nullable: "\"nullable\" keyword is supported by default.",
+		jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
+		extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
+		missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
+		processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
+		sourceCode: "Use option `code: {source: true}`",
+		strictDefaults: "It is default now, see option `strict`.",
+		strictKeywords: "It is default now, see option `strict`.",
+		uniqueItems: "\"uniqueItems\" keyword is always validated.",
+		unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
+		cache: "Map is used as cache, schema object as key.",
+		serialize: "Map is used as cache, schema object as key.",
+		ajvErrors: "It is default now."
+	};
+	const deprecatedOptions = {
+		ignoreKeywordsWithRef: "",
+		jsPropertySyntax: "",
+		unicode: "\"minLength\"/\"maxLength\" account for unicode characters by default."
+	};
+	const MAX_EXPRESSION = 200;
+	function requiredOptions(o) {
+		var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+		const s = o.strict;
+		const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;
+		const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
+		const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
+		const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
+		return {
+			strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
+			strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
+			strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
+			strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
+			strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
+			code: o.code ? {
+				...o.code,
+				optimize,
+				regExp
+			} : {
+				optimize,
+				regExp
+			},
+			loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
+			loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
+			meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
+			messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
+			inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
+			schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
+			addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
+			validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
+			validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
+			unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
+			int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
+			uriResolver
+		};
+	}
+	var Ajv = class {
+		constructor(opts = {}) {
+			this.schemas = {};
+			this.refs = {};
+			this.formats = Object.create(null);
+			this._compilations = /* @__PURE__ */ new Set();
+			this._loading = {};
+			this._cache = /* @__PURE__ */ new Map();
+			opts = this.opts = {
+				...opts,
+				...requiredOptions(opts)
+			};
+			const { es5, lines } = this.opts.code;
+			this.scope = new codegen_2.ValueScope({
+				scope: {},
+				prefixes: EXT_SCOPE_NAMES,
+				es5,
+				lines
+			});
+			this.logger = getLogger(opts.logger);
+			const formatOpt = opts.validateFormats;
+			opts.validateFormats = false;
+			this.RULES = (0, rules_1.getRules)();
+			checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
+			checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
+			this._metaOpts = getMetaSchemaOptions.call(this);
+			if (opts.formats) addInitialFormats.call(this);
+			this._addVocabularies();
+			this._addDefaultMetaSchema();
+			if (opts.keywords) addInitialKeywords.call(this, opts.keywords);
+			if (typeof opts.meta == "object") this.addMetaSchema(opts.meta);
+			addInitialSchemas.call(this);
+			opts.validateFormats = formatOpt;
+		}
+		_addVocabularies() {
+			this.addKeyword("$async");
+		}
+		_addDefaultMetaSchema() {
+			const { $data, meta, schemaId } = this.opts;
+			let _dataRefSchema = $dataRefSchema;
+			if (schemaId === "id") {
+				_dataRefSchema = { ...$dataRefSchema };
+				_dataRefSchema.id = _dataRefSchema.$id;
+				delete _dataRefSchema.$id;
+			}
+			if (meta && $data) this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
+		}
+		defaultMeta() {
+			const { meta, schemaId } = this.opts;
+			return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0;
+		}
+		validate(schemaKeyRef, data) {
+			let v;
+			if (typeof schemaKeyRef == "string") {
+				v = this.getSchema(schemaKeyRef);
+				if (!v) throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
+			} else v = this.compile(schemaKeyRef);
+			const valid = v(data);
+			if (!("$async" in v)) this.errors = v.errors;
+			return valid;
+		}
+		compile(schema, _meta) {
+			const sch = this._addSchema(schema, _meta);
+			return sch.validate || this._compileSchemaEnv(sch);
+		}
+		compileAsync(schema, meta) {
+			if (typeof this.opts.loadSchema != "function") throw new Error("options.loadSchema should be a function");
+			const { loadSchema } = this.opts;
+			return runCompileAsync.call(this, schema, meta);
+			async function runCompileAsync(_schema, _meta) {
+				await loadMetaSchema.call(this, _schema.$schema);
+				const sch = this._addSchema(_schema, _meta);
+				return sch.validate || _compileAsync.call(this, sch);
+			}
+			async function loadMetaSchema($ref) {
+				if ($ref && !this.getSchema($ref)) await runCompileAsync.call(this, { $ref }, true);
+			}
+			async function _compileAsync(sch) {
+				try {
+					return this._compileSchemaEnv(sch);
+				} catch (e) {
+					if (!(e instanceof ref_error_1.default)) throw e;
+					checkLoaded.call(this, e);
+					await loadMissingSchema.call(this, e.missingSchema);
+					return _compileAsync.call(this, sch);
+				}
+			}
+			function checkLoaded({ missingSchema: ref, missingRef }) {
+				if (this.refs[ref]) throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
+			}
+			async function loadMissingSchema(ref) {
+				const _schema = await _loadSchema.call(this, ref);
+				if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema);
+				if (!this.refs[ref]) this.addSchema(_schema, ref, meta);
+			}
+			async function _loadSchema(ref) {
+				const p = this._loading[ref];
+				if (p) return p;
+				try {
+					return await (this._loading[ref] = loadSchema(ref));
+				} finally {
+					delete this._loading[ref];
+				}
+			}
+		}
+		addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
+			if (Array.isArray(schema)) {
+				for (const sch of schema) this.addSchema(sch, void 0, _meta, _validateSchema);
+				return this;
+			}
+			let id;
+			if (typeof schema === "object") {
+				const { schemaId } = this.opts;
+				id = schema[schemaId];
+				if (id !== void 0 && typeof id != "string") throw new Error(`schema ${schemaId} must be string`);
+			}
+			key = (0, resolve_1.normalizeId)(key || id);
+			this._checkUnique(key);
+			this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
+			return this;
+		}
+		addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
+			this.addSchema(schema, key, true, _validateSchema);
+			return this;
+		}
+		validateSchema(schema, throwOrLogError) {
+			if (typeof schema == "boolean") return true;
+			let $schema;
+			$schema = schema.$schema;
+			if ($schema !== void 0 && typeof $schema != "string") throw new Error("$schema must be a string");
+			$schema = $schema || this.opts.defaultMeta || this.defaultMeta();
+			if (!$schema) {
+				this.logger.warn("meta-schema not available");
+				this.errors = null;
+				return true;
+			}
+			const valid = this.validate($schema, schema);
+			if (!valid && throwOrLogError) {
+				const message = "schema is invalid: " + this.errorsText();
+				if (this.opts.validateSchema === "log") this.logger.error(message);
+				else throw new Error(message);
+			}
+			return valid;
+		}
+		getSchema(keyRef) {
+			let sch;
+			while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") keyRef = sch;
+			if (sch === void 0) {
+				const { schemaId } = this.opts;
+				const root = new compile_1.SchemaEnv({
+					schema: {},
+					schemaId
+				});
+				sch = compile_1.resolveSchema.call(this, root, keyRef);
+				if (!sch) return;
+				this.refs[keyRef] = sch;
+			}
+			return sch.validate || this._compileSchemaEnv(sch);
+		}
+		removeSchema(schemaKeyRef) {
+			if (schemaKeyRef instanceof RegExp) {
+				this._removeAllSchemas(this.schemas, schemaKeyRef);
+				this._removeAllSchemas(this.refs, schemaKeyRef);
+				return this;
+			}
+			switch (typeof schemaKeyRef) {
+				case "undefined":
+					this._removeAllSchemas(this.schemas);
+					this._removeAllSchemas(this.refs);
+					this._cache.clear();
+					return this;
+				case "string": {
+					const sch = getSchEnv.call(this, schemaKeyRef);
+					if (typeof sch == "object") this._cache.delete(sch.schema);
+					delete this.schemas[schemaKeyRef];
+					delete this.refs[schemaKeyRef];
+					return this;
+				}
+				case "object": {
+					const cacheKey = schemaKeyRef;
+					this._cache.delete(cacheKey);
+					let id = schemaKeyRef[this.opts.schemaId];
+					if (id) {
+						id = (0, resolve_1.normalizeId)(id);
+						delete this.schemas[id];
+						delete this.refs[id];
+					}
+					return this;
+				}
+				default: throw new Error("ajv.removeSchema: invalid parameter");
+			}
+		}
+		addVocabulary(definitions) {
+			for (const def of definitions) this.addKeyword(def);
+			return this;
+		}
+		addKeyword(kwdOrDef, def) {
+			let keyword;
+			if (typeof kwdOrDef == "string") {
+				keyword = kwdOrDef;
+				if (typeof def == "object") {
+					this.logger.warn("these parameters are deprecated, see docs for addKeyword");
+					def.keyword = keyword;
+				}
+			} else if (typeof kwdOrDef == "object" && def === void 0) {
+				def = kwdOrDef;
+				keyword = def.keyword;
+				if (Array.isArray(keyword) && !keyword.length) throw new Error("addKeywords: keyword must be string or non-empty array");
+			} else throw new Error("invalid addKeywords parameters");
+			checkKeyword.call(this, keyword, def);
+			if (!def) {
+				(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
+				return this;
+			}
+			keywordMetaschema.call(this, def);
+			const definition = {
+				...def,
+				type: (0, dataType_1.getJSONTypes)(def.type),
+				schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
+			};
+			(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
+			return this;
+		}
+		getKeyword(keyword) {
+			const rule = this.RULES.all[keyword];
+			return typeof rule == "object" ? rule.definition : !!rule;
+		}
+		removeKeyword(keyword) {
+			const { RULES } = this;
+			delete RULES.keywords[keyword];
+			delete RULES.all[keyword];
+			for (const group of RULES.rules) {
+				const i = group.rules.findIndex((rule) => rule.keyword === keyword);
+				if (i >= 0) group.rules.splice(i, 1);
+			}
+			return this;
+		}
+		addFormat(name, format) {
+			if (typeof format == "string") format = new RegExp(format);
+			this.formats[name] = format;
+			return this;
+		}
+		errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
+			if (!errors || errors.length === 0) return "No errors";
+			return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+		}
+		$dataMetaSchema(metaSchema, keywordsJsonPointers) {
+			const rules = this.RULES.all;
+			metaSchema = JSON.parse(JSON.stringify(metaSchema));
+			for (const jsonPointer of keywordsJsonPointers) {
+				const segments = jsonPointer.split("/").slice(1);
+				let keywords = metaSchema;
+				for (const seg of segments) keywords = keywords[seg];
+				for (const key in rules) {
+					const rule = rules[key];
+					if (typeof rule != "object") continue;
+					const { $data } = rule.definition;
+					const schema = keywords[key];
+					if ($data && schema) keywords[key] = schemaOrData(schema);
+				}
+			}
+			return metaSchema;
+		}
+		_removeAllSchemas(schemas, regex) {
+			for (const keyRef in schemas) {
+				const sch = schemas[keyRef];
+				if (!regex || regex.test(keyRef)) {
+					if (typeof sch == "string") delete schemas[keyRef];
+					else if (sch && !sch.meta) {
+						this._cache.delete(sch.schema);
+						delete schemas[keyRef];
+					}
+				}
+			}
+		}
+		_addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+			let id;
+			const { schemaId } = this.opts;
+			if (typeof schema == "object") id = schema[schemaId];
+			else if (this.opts.jtd) throw new Error("schema must be object");
+			else if (typeof schema != "boolean") throw new Error("schema must be object or boolean");
+			let sch = this._cache.get(schema);
+			if (sch !== void 0) return sch;
+			baseId = (0, resolve_1.normalizeId)(id || baseId);
+			const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
+			sch = new compile_1.SchemaEnv({
+				schema,
+				schemaId,
+				meta,
+				baseId,
+				localRefs
+			});
+			this._cache.set(sch.schema, sch);
+			if (addSchema && !baseId.startsWith("#")) {
+				if (baseId) this._checkUnique(baseId);
+				this.refs[baseId] = sch;
+			}
+			if (validateSchema) this.validateSchema(schema, true);
+			return sch;
+		}
+		_checkUnique(id) {
+			if (this.schemas[id] || this.refs[id]) throw new Error(`schema with key or id "${id}" already exists`);
+		}
+		_compileSchemaEnv(sch) {
+			if (sch.meta) this._compileMetaSchema(sch);
+			else compile_1.compileSchema.call(this, sch);
+			/* istanbul ignore if */
+			if (!sch.validate) throw new Error("ajv implementation error");
+			return sch.validate;
+		}
+		_compileMetaSchema(sch) {
+			const currentOpts = this.opts;
+			this.opts = this._metaOpts;
+			try {
+				compile_1.compileSchema.call(this, sch);
+			} finally {
+				this.opts = currentOpts;
+			}
+		}
+	};
+	Ajv.ValidationError = validation_error_1.default;
+	Ajv.MissingRefError = ref_error_1.default;
+	exports.default = Ajv;
+	function checkOptions(checkOpts, options, msg, log = "error") {
+		for (const key in checkOpts) {
+			const opt = key;
+			if (opt in options) this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
+		}
+	}
+	function getSchEnv(keyRef) {
+		keyRef = (0, resolve_1.normalizeId)(keyRef);
+		return this.schemas[keyRef] || this.refs[keyRef];
+	}
+	function addInitialSchemas() {
+		const optsSchemas = this.opts.schemas;
+		if (!optsSchemas) return;
+		if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas);
+		else for (const key in optsSchemas) this.addSchema(optsSchemas[key], key);
+	}
+	function addInitialFormats() {
+		for (const name in this.opts.formats) {
+			const format = this.opts.formats[name];
+			if (format) this.addFormat(name, format);
+		}
+	}
+	function addInitialKeywords(defs) {
+		if (Array.isArray(defs)) {
+			this.addVocabulary(defs);
+			return;
+		}
+		this.logger.warn("keywords option as map is deprecated, pass array");
+		for (const keyword in defs) {
+			const def = defs[keyword];
+			if (!def.keyword) def.keyword = keyword;
+			this.addKeyword(def);
+		}
+	}
+	function getMetaSchemaOptions() {
+		const metaOpts = { ...this.opts };
+		for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt];
+		return metaOpts;
+	}
+	const noLogs = {
+		log() {},
+		warn() {},
+		error() {}
+	};
+	function getLogger(logger) {
+		if (logger === false) return noLogs;
+		if (logger === void 0) return console;
+		if (logger.log && logger.warn && logger.error) return logger;
+		throw new Error("logger must implement log, warn and error methods");
+	}
+	const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
+	function checkKeyword(keyword, def) {
+		const { RULES } = this;
+		(0, util_1.eachItem)(keyword, (kwd) => {
+			if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`);
+			if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`);
+		});
+		if (!def) return;
+		if (def.$data && !("code" in def || "validate" in def)) throw new Error("$data keyword must have \"code\" or \"validate\" function");
+	}
+	function addRule(keyword, definition, dataType) {
+		var _a;
+		const post = definition === null || definition === void 0 ? void 0 : definition.post;
+		if (dataType && post) throw new Error("keyword with \"post\" flag cannot have \"type\"");
+		const { RULES } = this;
+		let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
+		if (!ruleGroup) {
+			ruleGroup = {
+				type: dataType,
+				rules: []
+			};
+			RULES.rules.push(ruleGroup);
+		}
+		RULES.keywords[keyword] = true;
+		if (!definition) return;
+		const rule = {
+			keyword,
+			definition: {
+				...definition,
+				type: (0, dataType_1.getJSONTypes)(definition.type),
+				schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
+			}
+		};
+		if (definition.before) addBeforeRule.call(this, ruleGroup, rule, definition.before);
+		else ruleGroup.rules.push(rule);
+		RULES.all[keyword] = rule;
+		(_a = definition.implements) === null || _a === void 0 || _a.forEach((kwd) => this.addKeyword(kwd));
+	}
+	function addBeforeRule(ruleGroup, rule, before) {
+		const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
+		if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
+		else {
+			ruleGroup.rules.push(rule);
+			this.logger.warn(`rule ${before} is not defined`);
+		}
+	}
+	function keywordMetaschema(def) {
+		let { metaSchema } = def;
+		if (metaSchema === void 0) return;
+		if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema);
+		def.validateSchema = this.compile(metaSchema, true);
+	}
+	const $dataRef = { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" };
+	function schemaOrData(schema) {
+		return { anyOf: [schema, $dataRef] };
+	}
+}));
+//#endregion
+export default require_core();
+export { require_core };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/core.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;\nvar validate_1 = require(\"./compile/validate\");\nObject.defineProperty(exports, \"KeywordCxt\", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });\nvar codegen_1 = require(\"./compile/codegen\");\nObject.defineProperty(exports, \"_\", { enumerable: true, get: function () { return codegen_1._; } });\nObject.defineProperty(exports, \"str\", { enumerable: true, get: function () { return codegen_1.str; } });\nObject.defineProperty(exports, \"stringify\", { enumerable: true, get: function () { return codegen_1.stringify; } });\nObject.defineProperty(exports, \"nil\", { enumerable: true, get: function () { return codegen_1.nil; } });\nObject.defineProperty(exports, \"Name\", { enumerable: true, get: function () { return codegen_1.Name; } });\nObject.defineProperty(exports, \"CodeGen\", { enumerable: true, get: function () { return codegen_1.CodeGen; } });\nconst validation_error_1 = require(\"./runtime/validation_error\");\nconst ref_error_1 = require(\"./compile/ref_error\");\nconst rules_1 = require(\"./compile/rules\");\nconst compile_1 = require(\"./compile\");\nconst codegen_2 = require(\"./compile/codegen\");\nconst resolve_1 = require(\"./compile/resolve\");\nconst dataType_1 = require(\"./compile/validate/dataType\");\nconst util_1 = require(\"./compile/util\");\nconst $dataRefSchema = require(\"./refs/data.json\");\nconst uri_1 = require(\"./runtime/uri\");\nconst defaultRegExp = (str, flags) => new RegExp(str, flags);\ndefaultRegExp.code = \"new RegExp\";\nconst META_IGNORE_OPTIONS = [\"removeAdditional\", \"useDefaults\", \"coerceTypes\"];\nconst EXT_SCOPE_NAMES = new Set([\n    \"validate\",\n    \"serialize\",\n    \"parse\",\n    \"wrapper\",\n    \"root\",\n    \"schema\",\n    \"keyword\",\n    \"pattern\",\n    \"formats\",\n    \"validate$data\",\n    \"func\",\n    \"obj\",\n    \"Error\",\n]);\nconst removedOptions = {\n    errorDataPath: \"\",\n    format: \"`validateFormats: false` can be used instead.\",\n    nullable: '\"nullable\" keyword is supported by default.',\n    jsonPointers: \"Deprecated jsPropertySyntax can be used instead.\",\n    extendRefs: \"Deprecated ignoreKeywordsWithRef can be used instead.\",\n    missingRefs: \"Pass empty schema with $id that should be ignored to ajv.addSchema.\",\n    processCode: \"Use option `code: {process: (code, schemaEnv: object) => string}`\",\n    sourceCode: \"Use option `code: {source: true}`\",\n    strictDefaults: \"It is default now, see option `strict`.\",\n    strictKeywords: \"It is default now, see option `strict`.\",\n    uniqueItems: '\"uniqueItems\" keyword is always validated.',\n    unknownFormats: \"Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).\",\n    cache: \"Map is used as cache, schema object as key.\",\n    serialize: \"Map is used as cache, schema object as key.\",\n    ajvErrors: \"It is default now.\",\n};\nconst deprecatedOptions = {\n    ignoreKeywordsWithRef: \"\",\n    jsPropertySyntax: \"\",\n    unicode: '\"minLength\"/\"maxLength\" account for unicode characters by default.',\n};\nconst MAX_EXPRESSION = 200;\n// eslint-disable-next-line complexity\nfunction requiredOptions(o) {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;\n    const s = o.strict;\n    const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize;\n    const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0;\n    const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;\n    const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;\n    return {\n        strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,\n        strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,\n        strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : \"log\",\n        strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : \"log\",\n        strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,\n        code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp },\n        loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,\n        loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,\n        meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,\n        messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,\n        inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,\n        schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : \"$id\",\n        addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,\n        validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,\n        validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,\n        unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,\n        int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,\n        uriResolver: uriResolver,\n    };\n}\nclass Ajv {\n    constructor(opts = {}) {\n        this.schemas = {};\n        this.refs = {};\n        this.formats = Object.create(null);\n        this._compilations = new Set();\n        this._loading = {};\n        this._cache = new Map();\n        opts = this.opts = { ...opts, ...requiredOptions(opts) };\n        const { es5, lines } = this.opts.code;\n        this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });\n        this.logger = getLogger(opts.logger);\n        const formatOpt = opts.validateFormats;\n        opts.validateFormats = false;\n        this.RULES = (0, rules_1.getRules)();\n        checkOptions.call(this, removedOptions, opts, \"NOT SUPPORTED\");\n        checkOptions.call(this, deprecatedOptions, opts, \"DEPRECATED\", \"warn\");\n        this._metaOpts = getMetaSchemaOptions.call(this);\n        if (opts.formats)\n            addInitialFormats.call(this);\n        this._addVocabularies();\n        this._addDefaultMetaSchema();\n        if (opts.keywords)\n            addInitialKeywords.call(this, opts.keywords);\n        if (typeof opts.meta == \"object\")\n            this.addMetaSchema(opts.meta);\n        addInitialSchemas.call(this);\n        opts.validateFormats = formatOpt;\n    }\n    _addVocabularies() {\n        this.addKeyword(\"$async\");\n    }\n    _addDefaultMetaSchema() {\n        const { $data, meta, schemaId } = this.opts;\n        let _dataRefSchema = $dataRefSchema;\n        if (schemaId === \"id\") {\n            _dataRefSchema = { ...$dataRefSchema };\n            _dataRefSchema.id = _dataRefSchema.$id;\n            delete _dataRefSchema.$id;\n        }\n        if (meta && $data)\n            this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);\n    }\n    defaultMeta() {\n        const { meta, schemaId } = this.opts;\n        return (this.opts.defaultMeta = typeof meta == \"object\" ? meta[schemaId] || meta : undefined);\n    }\n    validate(schemaKeyRef, // key, ref or schema object\n    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n    data // to be validated\n    ) {\n        let v;\n        if (typeof schemaKeyRef == \"string\") {\n            v = this.getSchema(schemaKeyRef);\n            if (!v)\n                throw new Error(`no schema with key or ref \"${schemaKeyRef}\"`);\n        }\n        else {\n            v = this.compile(schemaKeyRef);\n        }\n        const valid = v(data);\n        if (!(\"$async\" in v))\n            this.errors = v.errors;\n        return valid;\n    }\n    compile(schema, _meta) {\n        const sch = this._addSchema(schema, _meta);\n        return (sch.validate || this._compileSchemaEnv(sch));\n    }\n    compileAsync(schema, meta) {\n        if (typeof this.opts.loadSchema != \"function\") {\n            throw new Error(\"options.loadSchema should be a function\");\n        }\n        const { loadSchema } = this.opts;\n        return runCompileAsync.call(this, schema, meta);\n        async function runCompileAsync(_schema, _meta) {\n            await loadMetaSchema.call(this, _schema.$schema);\n            const sch = this._addSchema(_schema, _meta);\n            return sch.validate || _compileAsync.call(this, sch);\n        }\n        async function loadMetaSchema($ref) {\n            if ($ref && !this.getSchema($ref)) {\n                await runCompileAsync.call(this, { $ref }, true);\n            }\n        }\n        async function _compileAsync(sch) {\n            try {\n                return this._compileSchemaEnv(sch);\n            }\n            catch (e) {\n                if (!(e instanceof ref_error_1.default))\n                    throw e;\n                checkLoaded.call(this, e);\n                await loadMissingSchema.call(this, e.missingSchema);\n                return _compileAsync.call(this, sch);\n            }\n        }\n        function checkLoaded({ missingSchema: ref, missingRef }) {\n            if (this.refs[ref]) {\n                throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);\n            }\n        }\n        async function loadMissingSchema(ref) {\n            const _schema = await _loadSchema.call(this, ref);\n            if (!this.refs[ref])\n                await loadMetaSchema.call(this, _schema.$schema);\n            if (!this.refs[ref])\n                this.addSchema(_schema, ref, meta);\n        }\n        async function _loadSchema(ref) {\n            const p = this._loading[ref];\n            if (p)\n                return p;\n            try {\n                return await (this._loading[ref] = loadSchema(ref));\n            }\n            finally {\n                delete this._loading[ref];\n            }\n        }\n    }\n    // Adds schema to the instance\n    addSchema(schema, // If array is passed, `key` will be ignored\n    key, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.\n    _meta, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n    _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead.\n    ) {\n        if (Array.isArray(schema)) {\n            for (const sch of schema)\n                this.addSchema(sch, undefined, _meta, _validateSchema);\n            return this;\n        }\n        let id;\n        if (typeof schema === \"object\") {\n            const { schemaId } = this.opts;\n            id = schema[schemaId];\n            if (id !== undefined && typeof id != \"string\") {\n                throw new Error(`schema ${schemaId} must be string`);\n            }\n        }\n        key = (0, resolve_1.normalizeId)(key || id);\n        this._checkUnique(key);\n        this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);\n        return this;\n    }\n    // Add schema that will be used to validate other schemas\n    // options in META_IGNORE_OPTIONS are alway set to false\n    addMetaSchema(schema, key, // schema key\n    _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema\n    ) {\n        this.addSchema(schema, key, true, _validateSchema);\n        return this;\n    }\n    //  Validate schema against its meta-schema\n    validateSchema(schema, throwOrLogError) {\n        if (typeof schema == \"boolean\")\n            return true;\n        let $schema;\n        $schema = schema.$schema;\n        if ($schema !== undefined && typeof $schema != \"string\") {\n            throw new Error(\"$schema must be a string\");\n        }\n        $schema = $schema || this.opts.defaultMeta || this.defaultMeta();\n        if (!$schema) {\n            this.logger.warn(\"meta-schema not available\");\n            this.errors = null;\n            return true;\n        }\n        const valid = this.validate($schema, schema);\n        if (!valid && throwOrLogError) {\n            const message = \"schema is invalid: \" + this.errorsText();\n            if (this.opts.validateSchema === \"log\")\n                this.logger.error(message);\n            else\n                throw new Error(message);\n        }\n        return valid;\n    }\n    // Get compiled schema by `key` or `ref`.\n    // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)\n    getSchema(keyRef) {\n        let sch;\n        while (typeof (sch = getSchEnv.call(this, keyRef)) == \"string\")\n            keyRef = sch;\n        if (sch === undefined) {\n            const { schemaId } = this.opts;\n            const root = new compile_1.SchemaEnv({ schema: {}, schemaId });\n            sch = compile_1.resolveSchema.call(this, root, keyRef);\n            if (!sch)\n                return;\n            this.refs[keyRef] = sch;\n        }\n        return (sch.validate || this._compileSchemaEnv(sch));\n    }\n    // Remove cached schema(s).\n    // If no parameter is passed all schemas but meta-schemas are removed.\n    // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n    // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n    removeSchema(schemaKeyRef) {\n        if (schemaKeyRef instanceof RegExp) {\n            this._removeAllSchemas(this.schemas, schemaKeyRef);\n            this._removeAllSchemas(this.refs, schemaKeyRef);\n            return this;\n        }\n        switch (typeof schemaKeyRef) {\n            case \"undefined\":\n                this._removeAllSchemas(this.schemas);\n                this._removeAllSchemas(this.refs);\n                this._cache.clear();\n                return this;\n            case \"string\": {\n                const sch = getSchEnv.call(this, schemaKeyRef);\n                if (typeof sch == \"object\")\n                    this._cache.delete(sch.schema);\n                delete this.schemas[schemaKeyRef];\n                delete this.refs[schemaKeyRef];\n                return this;\n            }\n            case \"object\": {\n                const cacheKey = schemaKeyRef;\n                this._cache.delete(cacheKey);\n                let id = schemaKeyRef[this.opts.schemaId];\n                if (id) {\n                    id = (0, resolve_1.normalizeId)(id);\n                    delete this.schemas[id];\n                    delete this.refs[id];\n                }\n                return this;\n            }\n            default:\n                throw new Error(\"ajv.removeSchema: invalid parameter\");\n        }\n    }\n    // add \"vocabulary\" - a collection of keywords\n    addVocabulary(definitions) {\n        for (const def of definitions)\n            this.addKeyword(def);\n        return this;\n    }\n    addKeyword(kwdOrDef, def // deprecated\n    ) {\n        let keyword;\n        if (typeof kwdOrDef == \"string\") {\n            keyword = kwdOrDef;\n            if (typeof def == \"object\") {\n                this.logger.warn(\"these parameters are deprecated, see docs for addKeyword\");\n                def.keyword = keyword;\n            }\n        }\n        else if (typeof kwdOrDef == \"object\" && def === undefined) {\n            def = kwdOrDef;\n            keyword = def.keyword;\n            if (Array.isArray(keyword) && !keyword.length) {\n                throw new Error(\"addKeywords: keyword must be string or non-empty array\");\n            }\n        }\n        else {\n            throw new Error(\"invalid addKeywords parameters\");\n        }\n        checkKeyword.call(this, keyword, def);\n        if (!def) {\n            (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));\n            return this;\n        }\n        keywordMetaschema.call(this, def);\n        const definition = {\n            ...def,\n            type: (0, dataType_1.getJSONTypes)(def.type),\n            schemaType: (0, dataType_1.getJSONTypes)(def.schemaType),\n        };\n        (0, util_1.eachItem)(keyword, definition.type.length === 0\n            ? (k) => addRule.call(this, k, definition)\n            : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));\n        return this;\n    }\n    getKeyword(keyword) {\n        const rule = this.RULES.all[keyword];\n        return typeof rule == \"object\" ? rule.definition : !!rule;\n    }\n    // Remove keyword\n    removeKeyword(keyword) {\n        // TODO return type should be Ajv\n        const { RULES } = this;\n        delete RULES.keywords[keyword];\n        delete RULES.all[keyword];\n        for (const group of RULES.rules) {\n            const i = group.rules.findIndex((rule) => rule.keyword === keyword);\n            if (i >= 0)\n                group.rules.splice(i, 1);\n        }\n        return this;\n    }\n    // Add format\n    addFormat(name, format) {\n        if (typeof format == \"string\")\n            format = new RegExp(format);\n        this.formats[name] = format;\n        return this;\n    }\n    errorsText(errors = this.errors, // optional array of validation errors\n    { separator = \", \", dataVar = \"data\" } = {} // optional options with properties `separator` and `dataVar`\n    ) {\n        if (!errors || errors.length === 0)\n            return \"No errors\";\n        return errors\n            .map((e) => `${dataVar}${e.instancePath} ${e.message}`)\n            .reduce((text, msg) => text + separator + msg);\n    }\n    $dataMetaSchema(metaSchema, keywordsJsonPointers) {\n        const rules = this.RULES.all;\n        metaSchema = JSON.parse(JSON.stringify(metaSchema));\n        for (const jsonPointer of keywordsJsonPointers) {\n            const segments = jsonPointer.split(\"/\").slice(1); // first segment is an empty string\n            let keywords = metaSchema;\n            for (const seg of segments)\n                keywords = keywords[seg];\n            for (const key in rules) {\n                const rule = rules[key];\n                if (typeof rule != \"object\")\n                    continue;\n                const { $data } = rule.definition;\n                const schema = keywords[key];\n                if ($data && schema)\n                    keywords[key] = schemaOrData(schema);\n            }\n        }\n        return metaSchema;\n    }\n    _removeAllSchemas(schemas, regex) {\n        for (const keyRef in schemas) {\n            const sch = schemas[keyRef];\n            if (!regex || regex.test(keyRef)) {\n                if (typeof sch == \"string\") {\n                    delete schemas[keyRef];\n                }\n                else if (sch && !sch.meta) {\n                    this._cache.delete(sch.schema);\n                    delete schemas[keyRef];\n                }\n            }\n        }\n    }\n    _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {\n        let id;\n        const { schemaId } = this.opts;\n        if (typeof schema == \"object\") {\n            id = schema[schemaId];\n        }\n        else {\n            if (this.opts.jtd)\n                throw new Error(\"schema must be object\");\n            else if (typeof schema != \"boolean\")\n                throw new Error(\"schema must be object or boolean\");\n        }\n        let sch = this._cache.get(schema);\n        if (sch !== undefined)\n            return sch;\n        baseId = (0, resolve_1.normalizeId)(id || baseId);\n        const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);\n        sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });\n        this._cache.set(sch.schema, sch);\n        if (addSchema && !baseId.startsWith(\"#\")) {\n            // TODO atm it is allowed to overwrite schemas without id (instead of not adding them)\n            if (baseId)\n                this._checkUnique(baseId);\n            this.refs[baseId] = sch;\n        }\n        if (validateSchema)\n            this.validateSchema(schema, true);\n        return sch;\n    }\n    _checkUnique(id) {\n        if (this.schemas[id] || this.refs[id]) {\n            throw new Error(`schema with key or id \"${id}\" already exists`);\n        }\n    }\n    _compileSchemaEnv(sch) {\n        if (sch.meta)\n            this._compileMetaSchema(sch);\n        else\n            compile_1.compileSchema.call(this, sch);\n        /* istanbul ignore if */\n        if (!sch.validate)\n            throw new Error(\"ajv implementation error\");\n        return sch.validate;\n    }\n    _compileMetaSchema(sch) {\n        const currentOpts = this.opts;\n        this.opts = this._metaOpts;\n        try {\n            compile_1.compileSchema.call(this, sch);\n        }\n        finally {\n            this.opts = currentOpts;\n        }\n    }\n}\nAjv.ValidationError = validation_error_1.default;\nAjv.MissingRefError = ref_error_1.default;\nexports.default = Ajv;\nfunction checkOptions(checkOpts, options, msg, log = \"error\") {\n    for (const key in checkOpts) {\n        const opt = key;\n        if (opt in options)\n            this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);\n    }\n}\nfunction getSchEnv(keyRef) {\n    keyRef = (0, resolve_1.normalizeId)(keyRef); // TODO tests fail without this line\n    return this.schemas[keyRef] || this.refs[keyRef];\n}\nfunction addInitialSchemas() {\n    const optsSchemas = this.opts.schemas;\n    if (!optsSchemas)\n        return;\n    if (Array.isArray(optsSchemas))\n        this.addSchema(optsSchemas);\n    else\n        for (const key in optsSchemas)\n            this.addSchema(optsSchemas[key], key);\n}\nfunction addInitialFormats() {\n    for (const name in this.opts.formats) {\n        const format = this.opts.formats[name];\n        if (format)\n            this.addFormat(name, format);\n    }\n}\nfunction addInitialKeywords(defs) {\n    if (Array.isArray(defs)) {\n        this.addVocabulary(defs);\n        return;\n    }\n    this.logger.warn(\"keywords option as map is deprecated, pass array\");\n    for (const keyword in defs) {\n        const def = defs[keyword];\n        if (!def.keyword)\n            def.keyword = keyword;\n        this.addKeyword(def);\n    }\n}\nfunction getMetaSchemaOptions() {\n    const metaOpts = { ...this.opts };\n    for (const opt of META_IGNORE_OPTIONS)\n        delete metaOpts[opt];\n    return metaOpts;\n}\nconst noLogs = { log() { }, warn() { }, error() { } };\nfunction getLogger(logger) {\n    if (logger === false)\n        return noLogs;\n    if (logger === undefined)\n        return console;\n    if (logger.log && logger.warn && logger.error)\n        return logger;\n    throw new Error(\"logger must implement log, warn and error methods\");\n}\nconst KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;\nfunction checkKeyword(keyword, def) {\n    const { RULES } = this;\n    (0, util_1.eachItem)(keyword, (kwd) => {\n        if (RULES.keywords[kwd])\n            throw new Error(`Keyword ${kwd} is already defined`);\n        if (!KEYWORD_NAME.test(kwd))\n            throw new Error(`Keyword ${kwd} has invalid name`);\n    });\n    if (!def)\n        return;\n    if (def.$data && !(\"code\" in def || \"validate\" in def)) {\n        throw new Error('$data keyword must have \"code\" or \"validate\" function');\n    }\n}\nfunction addRule(keyword, definition, dataType) {\n    var _a;\n    const post = definition === null || definition === void 0 ? void 0 : definition.post;\n    if (dataType && post)\n        throw new Error('keyword with \"post\" flag cannot have \"type\"');\n    const { RULES } = this;\n    let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);\n    if (!ruleGroup) {\n        ruleGroup = { type: dataType, rules: [] };\n        RULES.rules.push(ruleGroup);\n    }\n    RULES.keywords[keyword] = true;\n    if (!definition)\n        return;\n    const rule = {\n        keyword,\n        definition: {\n            ...definition,\n            type: (0, dataType_1.getJSONTypes)(definition.type),\n            schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType),\n        },\n    };\n    if (definition.before)\n        addBeforeRule.call(this, ruleGroup, rule, definition.before);\n    else\n        ruleGroup.rules.push(rule);\n    RULES.all[keyword] = rule;\n    (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));\n}\nfunction addBeforeRule(ruleGroup, rule, before) {\n    const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);\n    if (i >= 0) {\n        ruleGroup.rules.splice(i, 0, rule);\n    }\n    else {\n        ruleGroup.rules.push(rule);\n        this.logger.warn(`rule ${before} is not defined`);\n    }\n}\nfunction keywordMetaschema(def) {\n    let { metaSchema } = def;\n    if (metaSchema === undefined)\n        return;\n    if (def.$data && this.opts.$data)\n        metaSchema = schemaOrData(metaSchema);\n    def.validateSchema = this.compile(metaSchema, true);\n}\nconst $dataRef = {\n    $ref: \"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#\",\n};\nfunction schemaOrData(schema) {\n    return { anyOf: [schema, $dataRef] };\n}\n//# sourceMappingURL=core.js.map"],"x_google_ignoreList":[0],"mappings":"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"}