@amplitude/ai 0.1.0

package/dist/node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js

@@ -0,0 +1,76 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/rolldown_runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_util } from "../util.js";
+
+//#region node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js
+var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
+		if (keyword !== void 0 && schema !== void 0) throw new Error("both \"keyword\" and \"schema\" passed, only one allowed");
+		if (keyword !== void 0) {
+			const sch = it.schema[keyword];
+			return schemaProp === void 0 ? {
+				schema: sch,
+				schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
+				errSchemaPath: `${it.errSchemaPath}/${keyword}`
+			} : {
+				schema: sch[schemaProp],
+				schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
+				errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
+			};
+		}
+		if (schema !== void 0) {
+			if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) throw new Error("\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"");
+			return {
+				schema,
+				schemaPath,
+				topSchemaRef,
+				errSchemaPath
+			};
+		}
+		throw new Error("either \"keyword\" or \"schema\" must be passed");
+	}
+	exports.getSubschema = getSubschema;
+	function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
+		if (data !== void 0 && dataProp !== void 0) throw new Error("both \"data\" and \"dataProp\" passed, only one allowed");
+		const { gen } = it;
+		if (dataProp !== void 0) {
+			const { errorPath, dataPathArr, opts } = it;
+			dataContextProps(gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true));
+			subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+			subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
+			subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
+		}
+		if (data !== void 0) {
+			dataContextProps(data instanceof codegen_1.Name ? data : gen.let("data", data, true));
+			if (propertyName !== void 0) subschema.propertyName = propertyName;
+		}
+		if (dataTypes) subschema.dataTypes = dataTypes;
+		function dataContextProps(_nextData) {
+			subschema.data = _nextData;
+			subschema.dataLevel = it.dataLevel + 1;
+			subschema.dataTypes = [];
+			it.definedProperties = /* @__PURE__ */ new Set();
+			subschema.parentData = it.data;
+			subschema.dataNames = [...it.dataNames, _nextData];
+		}
+	}
+	exports.extendSubschemaData = extendSubschemaData;
+	function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
+		if (compositeRule !== void 0) subschema.compositeRule = compositeRule;
+		if (createErrors !== void 0) subschema.createErrors = createErrors;
+		if (allErrors !== void 0) subschema.allErrors = allErrors;
+		subschema.jtdDiscriminator = jtdDiscriminator;
+		subschema.jtdMetadata = jtdMetadata;
+	}
+	exports.extendSubschemaMode = extendSubschemaMode;
+}));
+
+//#endregion
+export default require_subschema();
+
+export { require_subschema };
+//# sourceMappingURL=subschema.js.map

package/dist/node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subschema.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/compile/validate/subschema.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;\nconst codegen_1 = require(\"../codegen\");\nconst util_1 = require(\"../util\");\nfunction getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {\n    if (keyword !== undefined && schema !== undefined) {\n        throw new Error('both \"keyword\" and \"schema\" passed, only one allowed');\n    }\n    if (keyword !== undefined) {\n        const sch = it.schema[keyword];\n        return schemaProp === undefined\n            ? {\n                schema: sch,\n                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,\n                errSchemaPath: `${it.errSchemaPath}/${keyword}`,\n            }\n            : {\n                schema: sch[schemaProp],\n                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,\n                errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,\n            };\n    }\n    if (schema !== undefined) {\n        if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {\n            throw new Error('\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"');\n        }\n        return {\n            schema,\n            schemaPath,\n            topSchemaRef,\n            errSchemaPath,\n        };\n    }\n    throw new Error('either \"keyword\" or \"schema\" must be passed');\n}\nexports.getSubschema = getSubschema;\nfunction extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {\n    if (data !== undefined && dataProp !== undefined) {\n        throw new Error('both \"data\" and \"dataProp\" passed, only one allowed');\n    }\n    const { gen } = it;\n    if (dataProp !== undefined) {\n        const { errorPath, dataPathArr, opts } = it;\n        const nextData = gen.let(\"data\", (0, codegen_1._) `${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);\n        dataContextProps(nextData);\n        subschema.errorPath = (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;\n        subschema.parentDataProperty = (0, codegen_1._) `${dataProp}`;\n        subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];\n    }\n    if (data !== undefined) {\n        const nextData = data instanceof codegen_1.Name ? data : gen.let(\"data\", data, true); // replaceable if used once?\n        dataContextProps(nextData);\n        if (propertyName !== undefined)\n            subschema.propertyName = propertyName;\n        // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr\n    }\n    if (dataTypes)\n        subschema.dataTypes = dataTypes;\n    function dataContextProps(_nextData) {\n        subschema.data = _nextData;\n        subschema.dataLevel = it.dataLevel + 1;\n        subschema.dataTypes = [];\n        it.definedProperties = new Set();\n        subschema.parentData = it.data;\n        subschema.dataNames = [...it.dataNames, _nextData];\n    }\n}\nexports.extendSubschemaData = extendSubschemaData;\nfunction extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {\n    if (compositeRule !== undefined)\n        subschema.compositeRule = compositeRule;\n    if (createErrors !== undefined)\n        subschema.createErrors = createErrors;\n    if (allErrors !== undefined)\n        subschema.allErrors = allErrors;\n    subschema.jtdDiscriminator = jtdDiscriminator; // not inherited\n    subschema.jtdMetadata = jtdMetadata; // not inherited\n}\nexports.extendSubschemaMode = extendSubschemaMode;\n//# sourceMappingURL=subschema.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;AACA,QAAO,eAAe,SAAS,cAAc,EAAE,OAAO,MAAM,CAAC;AAC7D,SAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ,eAAe,KAAK;CACxF,MAAM;CACN,MAAM;CACN,SAAS,aAAa,IAAI,EAAE,SAAS,YAAY,QAAQ,YAAY,eAAe,gBAAgB;AAChG,MAAI,YAAY,UAAa,WAAW,OACpC,OAAM,IAAI,MAAM,2DAAuD;AAE3E,MAAI,YAAY,QAAW;GACvB,MAAM,MAAM,GAAG,OAAO;AACtB,UAAO,eAAe,SAChB;IACE,QAAQ;IACR,YAAY,CAAC,GAAG,UAAU,EAAG,GAAG,GAAG,cAAc,GAAG,UAAU,aAAa,QAAQ;IACnF,eAAe,GAAG,GAAG,cAAc,GAAG;IACzC,GACC;IACE,QAAQ,IAAI;IACZ,YAAY,CAAC,GAAG,UAAU,EAAG,GAAG,GAAG,cAAc,GAAG,UAAU,aAAa,QAAQ,IAAI,GAAG,UAAU,aAAa,WAAW;IAC5H,eAAe,GAAG,GAAG,cAAc,GAAG,QAAQ,IAAI,GAAG,OAAO,gBAAgB,WAAW;IAC1F;;AAET,MAAI,WAAW,QAAW;AACtB,OAAI,eAAe,UAAa,kBAAkB,UAAa,iBAAiB,OAC5E,OAAM,IAAI,MAAM,sFAA8E;AAElG,UAAO;IACH;IACA;IACA;IACA;IACH;;AAEL,QAAM,IAAI,MAAM,kDAA8C;;AAElE,SAAQ,eAAe;CACvB,SAAS,oBAAoB,WAAW,IAAI,EAAE,UAAU,cAAc,QAAQ,MAAM,WAAW,gBAAgB;AAC3G,MAAI,SAAS,UAAa,aAAa,OACnC,OAAM,IAAI,MAAM,0DAAsD;EAE1E,MAAM,EAAE,QAAQ;AAChB,MAAI,aAAa,QAAW;GACxB,MAAM,EAAE,WAAW,aAAa,SAAS;AAEzC,oBADiB,IAAI,IAAI,QAAQ,CAAC,GAAG,UAAU,EAAG,GAAG,GAAG,QAAQ,GAAG,UAAU,aAAa,SAAS,IAAI,KAAK,CAClF;AAC1B,aAAU,YAAY,CAAC,GAAG,UAAU,IAAK,GAAG,aAAa,GAAG,OAAO,cAAc,UAAU,QAAQ,KAAK,iBAAiB;AACzH,aAAU,qBAAqB,CAAC,GAAG,UAAU,EAAG,GAAG;AACnD,aAAU,cAAc,CAAC,GAAG,aAAa,UAAU,mBAAmB;;AAE1E,MAAI,SAAS,QAAW;AAEpB,oBADiB,gBAAgB,UAAU,OAAO,OAAO,IAAI,IAAI,QAAQ,MAAM,KAAK,CAC1D;AAC1B,OAAI,iBAAiB,OACjB,WAAU,eAAe;;AAGjC,MAAI,UACA,WAAU,YAAY;EAC1B,SAAS,iBAAiB,WAAW;AACjC,aAAU,OAAO;AACjB,aAAU,YAAY,GAAG,YAAY;AACrC,aAAU,YAAY,EAAE;AACxB,MAAG,oCAAoB,IAAI,KAAK;AAChC,aAAU,aAAa,GAAG;AAC1B,aAAU,YAAY,CAAC,GAAG,GAAG,WAAW,UAAU;;;AAG1D,SAAQ,sBAAsB;CAC9B,SAAS,oBAAoB,WAAW,EAAE,kBAAkB,aAAa,eAAe,cAAc,aAAa;AAC/G,MAAI,kBAAkB,OAClB,WAAU,gBAAgB;AAC9B,MAAI,iBAAiB,OACjB,WAAU,eAAe;AAC7B,MAAI,cAAc,OACd,WAAU,YAAY;AAC1B,YAAU,mBAAmB;AAC7B,YAAU,cAAc;;AAE5B,SAAQ,sBAAsB"}

package/dist/node_modules/.pnpm/ajv@8.18.0/node_modules/ajv/dist/core.js

@@ -0,0 +1,587 @@
+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.18.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 = 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 = {};
+			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=core.js.map