vibebusiness 1.2.73 → 1.2.75

package/.next/standalone/node_modules/webpack/lib/webpack.js

@@ -0,0 +1,225 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+const webpackOptionsSchemaCheck = require("../schemas/WebpackOptions.check");
+const webpackOptionsSchema = require("../schemas/WebpackOptions.json");
+const Compiler = require("./Compiler");
+const MultiCompiler = require("./MultiCompiler");
+const WebpackOptionsApply = require("./WebpackOptionsApply");
+const {
+	applyWebpackOptionsBaseDefaults,
+	applyWebpackOptionsDefaults
+} = require("./config/defaults");
+const {
+	applyWebpackOptionsInterception,
+	getNormalizedWebpackOptions
+} = require("./config/normalization");
+const NodeEnvironmentPlugin = require("./node/NodeEnvironmentPlugin");
+const memoize = require("./util/memoize");
+
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptionsNormalizedWithDefaults */
+/** @typedef {import("./config/normalization").WebpackOptionsInterception} WebpackOptionsInterception */
+/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
+/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
+/** @typedef {import("./MultiCompiler").MultiWebpackOptions} MultiWebpackOptions */
+/** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./Stats")} Stats */
+
+const getValidateSchema = memoize(() => require("./validateSchema"));
+
+/**
+ * @template T
+ * @template [R=void]
+ * @callback Callback
+ * @param {Error | null} err
+ * @param {T=} result
+ * @returns {R}
+ */
+
+/** @typedef {Callback<void>} ErrorCallback */
+
+/**
+ * @param {ReadonlyArray<WebpackOptions>} childOptions options array
+ * @param {MultiCompilerOptions} options options
+ * @returns {MultiCompiler} a multi-compiler
+ */
+const createMultiCompiler = (childOptions, options) => {
+	const compilers = childOptions.map((options, index) =>
+		createCompiler(options, index)
+	);
+	const compiler = new MultiCompiler(compilers, options);
+	for (const childCompiler of compilers) {
+		if (childCompiler.options.dependencies) {
+			compiler.setDependencies(
+				childCompiler,
+				childCompiler.options.dependencies
+			);
+		}
+	}
+	return compiler;
+};
+
+/**
+ * @param {WebpackOptions} rawOptions options object
+ * @param {number=} compilerIndex index of compiler
+ * @returns {Compiler} a compiler
+ */
+const createCompiler = (rawOptions, compilerIndex) => {
+	let options = getNormalizedWebpackOptions(rawOptions);
+	applyWebpackOptionsBaseDefaults(options);
+
+	/** @type {WebpackOptionsInterception=} */
+	let interception;
+	({ options, interception } = applyWebpackOptionsInterception(options));
+
+	const compiler = new Compiler(
+		/** @type {string} */ (options.context),
+		options
+	);
+	new NodeEnvironmentPlugin({
+		infrastructureLogging: options.infrastructureLogging
+	}).apply(compiler);
+	if (Array.isArray(options.plugins)) {
+		for (const plugin of options.plugins) {
+			if (typeof plugin === "function") {
+				/** @type {WebpackPluginFunction} */
+				(plugin).call(compiler, compiler);
+			} else if (plugin) {
+				plugin.apply(compiler);
+			}
+		}
+	}
+	const resolvedDefaultOptions = applyWebpackOptionsDefaults(
+		options,
+		compilerIndex
+	);
+	if (resolvedDefaultOptions.platform) {
+		compiler.platform = resolvedDefaultOptions.platform;
+	}
+	compiler.hooks.environment.call();
+	compiler.hooks.afterEnvironment.call();
+	new WebpackOptionsApply().process(
+		/** @type {WebpackOptionsNormalizedWithDefaults} */
+		(options),
+		compiler,
+		interception
+	);
+	compiler.hooks.initialize.call();
+	return compiler;
+};
+
+/**
+ * @template T
+ * @param {T[] | T} options options
+ * @returns {T[]} array of options
+ */
+const asArray = (options) =>
+	Array.isArray(options) ? [...options] : [options];
+
+/**
+ * @overload
+ * @param {WebpackOptions} options options object
+ * @param {Callback<Stats>} callback callback
+ * @returns {Compiler | null} the compiler object
+ */
+/**
+ * @overload
+ * @param {WebpackOptions} options options object
+ * @returns {Compiler} the compiler object
+ */
+/**
+ * @overload
+ * @param {MultiWebpackOptions} options options objects
+ * @param {Callback<MultiStats>} callback callback
+ * @returns {MultiCompiler | null} the multi compiler object
+ */
+/**
+ * @overload
+ * @param {MultiWebpackOptions} options options objects
+ * @returns {MultiCompiler} the multi compiler object
+ */
+/**
+ * @param {WebpackOptions | MultiWebpackOptions} options options
+ * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
+ * @returns {Compiler | MultiCompiler | null} Compiler or MultiCompiler
+ */
+const webpack = (options, callback) => {
+	const create = () => {
+		if (
+			!asArray(/** @type {WebpackOptions} */ (options)).every(
+				webpackOptionsSchemaCheck
+			)
+		) {
+			getValidateSchema()(webpackOptionsSchema, options);
+			util.deprecate(
+				() => {},
+				"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+				"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+			)();
+		}
+		/** @type {MultiCompiler | Compiler} */
+		let compiler;
+		/** @type {boolean | undefined} */
+		let watch = false;
+		/** @type {WatchOptions | WatchOptions[]} */
+		let watchOptions;
+		if (Array.isArray(options)) {
+			/** @type {MultiCompiler} */
+			compiler = createMultiCompiler(
+				options,
+				/** @type {MultiCompilerOptions} */
+				(options)
+			);
+			watch = options.some((options) => options.watch);
+			watchOptions = options.map((options) => options.watchOptions || {});
+		} else {
+			const webpackOptions = /** @type {WebpackOptions} */ (options);
+			/** @type {Compiler} */
+			compiler = createCompiler(webpackOptions);
+			watch = webpackOptions.watch;
+			watchOptions = webpackOptions.watchOptions || {};
+		}
+		return { compiler, watch, watchOptions };
+	};
+	if (callback) {
+		try {
+			const { compiler, watch, watchOptions } = create();
+			if (watch) {
+				compiler.watch(watchOptions, callback);
+			} else {
+				compiler.run((err, stats) => {
+					compiler.close((err2) => {
+						callback(
+							err || err2,
+							/** @type {options extends WebpackOptions ? Stats : MultiStats} */
+							(stats)
+						);
+					});
+				});
+			}
+			return compiler;
+		} catch (err) {
+			process.nextTick(() => callback(/** @type {Error} */ (err)));
+			return null;
+		}
+	} else {
+		const { compiler, watch } = create();
+		if (watch) {
+			util.deprecate(
+				() => {},
+				"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+				"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
+			)();
+		}
+		return compiler;
+	}
+};
+
+module.exports = webpack;

package/.next/standalone/node_modules/webpack/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -0,0 +1,110 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
+const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+
+const PLUGIN_NAME = "ImportScriptsChunkLoadingPlugin";
+
+class ImportScriptsChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new StartupChunkDependenciesPlugin({
+			chunkLoading: "import-scripts",
+			asyncChunkLoading: true
+		}).apply(compiler);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {boolean} true, if wasm loading is enabled for the chunk
+			 */
+			const isEnabledForChunk = (chunk) => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === "import-scripts";
+			};
+			/** @type {WeakSet<Chunk>} */
+			const onceForChunkSet = new WeakSet();
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const handler = (chunk, set) => {
+				if (onceForChunkSet.has(chunk)) return;
+				onceForChunkSet.add(chunk);
+				if (!isEnabledForChunk(chunk)) return;
+				const withCreateScriptUrl = Boolean(
+					compilation.outputOptions.trustedTypes
+				);
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+				if (withCreateScriptUrl) {
+					set.add(RuntimeGlobals.createScriptUrl);
+				}
+				compilation.addRuntimeModule(
+					chunk,
+					new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
+				);
+			};
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadManifest)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.baseURI)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap(PLUGIN_NAME, handler);
+
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkScriptFilename);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+					set.add(RuntimeGlobals.moduleCache);
+					set.add(RuntimeGlobals.hmrModuleData);
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hmrDownloadManifest)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getUpdateManifestFilename);
+				});
+		});
+	}
+}
+
+module.exports = ImportScriptsChunkLoadingPlugin;

package/.next/standalone/node_modules/webpack/lib/webworker/ImportScriptsChunkLoadingRuntimeModule.js

@@ -0,0 +1,229 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const {
+	generateJavascriptHMR
+} = require("../hmr/JavascriptHotModuleReplacementHelper");
+const {
+	chunkHasJs,
+	getChunkFilenameTemplate
+} = require("../javascript/JavascriptModulesPlugin");
+const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const { getUndoPath } = require("../util/identifier");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+
+class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 * @param {boolean} withCreateScriptUrl with createScriptUrl support
+	 */
+	constructor(runtimeRequirements, withCreateScriptUrl) {
+		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
+		this._withCreateScriptUrl = withCreateScriptUrl;
+	}
+
+	/**
+	 * @private
+	 * @param {Chunk} chunk chunk
+	 * @returns {string} generated code
+	 */
+	_generateBaseUri(chunk) {
+		const options = chunk.getEntryOptions();
+		if (options && options.baseUri) {
+			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
+		}
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			compilation.outputOptions.path,
+			false
+		);
+		return `${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
+			rootOutputDir ? `/../${rootOutputDir}` : ""
+		)};`;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withCallback = this.runtimeRequirements.has(
+			RuntimeGlobals.chunkCallback
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const globalObject = compilation.runtimeTemplate.globalObject;
+		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+			compilation.outputOptions.chunkLoadingGlobal
+		)}]`;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const hasJsMatcher = compileBooleanMatcher(
+			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
+		);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
+			: undefined;
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const { _withCreateScriptUrl: withCreateScriptUrl } = this;
+
+		return Template.asString([
+			withBaseURI ? this._generateBaseUri(chunk) : "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "1" means "already loaded"',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 1`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withCallback || withLoading
+				? Template.asString([
+						"// importScripts chunk loading",
+						`var installChunk = ${runtimeTemplate.basicFunction("data", [
+							runtimeTemplate.destructureArray(
+								["chunkIds", "moreModules", "runtime"],
+								"data"
+							),
+							"for(var moduleId in moreModules) {",
+							Template.indent([
+								`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+								Template.indent(
+									`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+								),
+								"}"
+							]),
+							"}",
+							`if(runtime) runtime(${RuntimeGlobals.require});`,
+							"while(chunkIds.length)",
+							Template.indent("installedChunks[chunkIds.pop()] = 1;"),
+							"parentChunkLoadingFunction(data);"
+						])};`
+					])
+				: "// no chunk install function needed",
+			withCallback || withLoading
+				? Template.asString([
+						withLoading
+							? `${fn}.i = ${runtimeTemplate.basicFunction(
+									"chunkId, promises",
+									hasJsMatcher !== false
+										? [
+												'// "1" is the signal for "already loaded"',
+												"if(!installedChunks[chunkId]) {",
+												Template.indent([
+													hasJsMatcher === true
+														? "if(true) { // all chunks have JS"
+														: `if(${hasJsMatcher("chunkId")}) {`,
+													Template.indent(
+														`importScripts(${
+															withCreateScriptUrl
+																? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
+																: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
+														});`
+													),
+													"}"
+												]),
+												"}"
+											]
+										: "installedChunks[chunkId] = 1;"
+								)};`
+							: "",
+						"",
+						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
+						"chunkLoadingGlobal.push = installChunk;"
+					])
+				: "// no chunk loading",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							"var success = false;",
+							`${globalObject}[${JSON.stringify(
+								compilation.outputOptions.hotUpdateGlobal
+							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
+								"for(var moduleId in moreModules) {",
+								Template.indent([
+									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+									Template.indent([
+										"currentUpdate[moduleId] = moreModules[moduleId];",
+										"if(updatedModulesList) updatedModulesList.push(moduleId);"
+									]),
+									"}"
+								]),
+								"}",
+								"if(runtime) currentUpdateRuntime.push(runtime);",
+								"success = true;"
+							])};`,
+							"// start update chunk loading",
+							`importScripts(${
+								withCreateScriptUrl
+									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
+									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
+							});`,
+							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
+						]),
+						"}",
+						"",
+						generateJavascriptHMR("importScripts")
+					])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${
+							RuntimeGlobals.hmrDownloadManifest
+						} = ${runtimeTemplate.basicFunction("", [
+							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+							`return fetch(${RuntimeGlobals.publicPath} + ${
+								RuntimeGlobals.getUpdateManifestFilename
+							}()).then(${runtimeTemplate.basicFunction("response", [
+								"if(response.status === 404) return; // no update available",
+								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+								"return response.json();"
+							])});`
+						])};`
+					])
+				: "// no HMR manifest"
+		]);
+	}
+}
+
+module.exports = ImportScriptsChunkLoadingRuntimeModule;

package/.next/standalone/node_modules/webpack/lib/webworker/WebWorkerTemplatePlugin.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ArrayPushCallbackChunkFormatPlugin = require("../javascript/ArrayPushCallbackChunkFormatPlugin");
+const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class WebWorkerTemplatePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.options.output.chunkLoading = "import-scripts";
+		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin("import-scripts").apply(compiler);
+	}
+}
+
+module.exports = WebWorkerTemplatePlugin;

package/.next/standalone/node_modules/webpack/node_modules/ajv/dist/ajv.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
+const core_1 = require("./core");
+const draft7_1 = require("./vocabularies/draft7");
+const discriminator_1 = require("./vocabularies/discriminator");
+const draft7MetaSchema = require("./refs/json-schema-draft-07.json");
+const META_SUPPORT_DATA = ["/properties"];
+const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
+class Ajv extends core_1.default {
+    _addVocabularies() {
+        super._addVocabularies();
+        draft7_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+            this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        if (!this.opts.meta)
+            return;
+        const metaSchema = this.opts.$data
+            ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)
+            : draft7MetaSchema;
+        this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+        return (this.opts.defaultMeta =
+            super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined));
+    }
+}
+exports.Ajv = Ajv;
+module.exports = exports = Ajv;
+module.exports.Ajv = Ajv;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Ajv;
+var validate_1 = require("./compile/validate");
+Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function () { return validate_1.KeywordCxt; } });
+var codegen_1 = require("./compile/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; } });
+var validation_error_1 = require("./runtime/validation_error");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validation_error_1.default; } });
+var ref_error_1 = require("./compile/ref_error");
+Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function () { return ref_error_1.default; } });
+//# sourceMappingURL=ajv.js.map