vibebusiness 1.2.73 → 1.2.75

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv/dist/vocabularies/validation/required.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const code_1 = require("../code");
+const codegen_1 = require("../../compile/codegen");
+const util_1 = require("../../compile/util");
+const error = {
+    message: ({ params: { missingProperty } }) => (0, codegen_1.str) `must have required property '${missingProperty}'`,
+    params: ({ params: { missingProperty } }) => (0, codegen_1._) `{missingProperty: ${missingProperty}}`,
+};
+const def = {
+    keyword: "required",
+    type: "object",
+    schemaType: "array",
+    $data: true,
+    error,
+    code(cxt) {
+        const { gen, schema, schemaCode, data, $data, it } = cxt;
+        const { opts } = it;
+        if (!$data && schema.length === 0)
+            return;
+        const useLoop = schema.length >= opts.loopRequired;
+        if (it.allErrors)
+            allErrorsMode();
+        else
+            exitOnErrorMode();
+        if (opts.strictRequired) {
+            const props = cxt.parentSchema.properties;
+            const { definedProperties } = cxt.it;
+            for (const requiredKey of schema) {
+                if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === undefined && !definedProperties.has(requiredKey)) {
+                    const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
+                    const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
+                    (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
+                }
+            }
+        }
+        function allErrorsMode() {
+            if (useLoop || $data) {
+                cxt.block$data(codegen_1.nil, loopAllRequired);
+            }
+            else {
+                for (const prop of schema) {
+                    (0, code_1.checkReportMissingProp)(cxt, prop);
+                }
+            }
+        }
+        function exitOnErrorMode() {
+            const missing = gen.let("missing");
+            if (useLoop || $data) {
+                const valid = gen.let("valid", true);
+                cxt.block$data(valid, () => loopUntilMissing(missing, valid));
+                cxt.ok(valid);
+            }
+            else {
+                gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
+                (0, code_1.reportMissingProp)(cxt, missing);
+                gen.else();
+            }
+        }
+        function loopAllRequired() {
+            gen.forOf("prop", schemaCode, (prop) => {
+                cxt.setParams({ missingProperty: prop });
+                gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
+            });
+        }
+        function loopUntilMissing(missing, valid) {
+            cxt.setParams({ missingProperty: missing });
+            gen.forOf(missing, schemaCode, () => {
+                gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
+                gen.if((0, codegen_1.not)(valid), () => {
+                    cxt.error();
+                    gen.break();
+                });
+            }, codegen_1.nil);
+        }
+    },
+};
+exports.default = def;
+//# sourceMappingURL=required.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataType_1 = require("../../compile/validate/dataType");
+const codegen_1 = require("../../compile/codegen");
+const util_1 = require("../../compile/util");
+const equal_1 = require("../../runtime/equal");
+const error = {
+    message: ({ params: { i, j } }) => (0, codegen_1.str) `must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
+    params: ({ params: { i, j } }) => (0, codegen_1._) `{i: ${i}, j: ${j}}`,
+};
+const def = {
+    keyword: "uniqueItems",
+    type: "array",
+    schemaType: "boolean",
+    $data: true,
+    error,
+    code(cxt) {
+        const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
+        if (!$data && !schema)
+            return;
+        const valid = gen.let("valid");
+        const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
+        cxt.block$data(valid, validateUniqueItems, (0, codegen_1._) `${schemaCode} === false`);
+        cxt.ok(valid);
+        function validateUniqueItems() {
+            const i = gen.let("i", (0, codegen_1._) `${data}.length`);
+            const j = gen.let("j");
+            cxt.setParams({ i, j });
+            gen.assign(valid, true);
+            gen.if((0, codegen_1._) `${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
+        }
+        function canOptimize() {
+            return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
+        }
+        function loopN(i, j) {
+            const item = gen.name("item");
+            const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
+            const indices = gen.const("indices", (0, codegen_1._) `{}`);
+            gen.for((0, codegen_1._) `;${i}--;`, () => {
+                gen.let(item, (0, codegen_1._) `${data}[${i}]`);
+                gen.if(wrongType, (0, codegen_1._) `continue`);
+                if (itemTypes.length > 1)
+                    gen.if((0, codegen_1._) `typeof ${item} == "string"`, (0, codegen_1._) `${item} += "_"`);
+                gen
+                    .if((0, codegen_1._) `typeof ${indices}[${item}] == "number"`, () => {
+                    gen.assign(j, (0, codegen_1._) `${indices}[${item}]`);
+                    cxt.error();
+                    gen.assign(valid, false).break();
+                })
+                    .code((0, codegen_1._) `${indices}[${item}] = ${i}`);
+            });
+        }
+        function loopN2(i, j) {
+            const eql = (0, util_1.useFunc)(gen, equal_1.default);
+            const outer = gen.name("outer");
+            gen.label(outer).for((0, codegen_1._) `;${i}--;`, () => gen.for((0, codegen_1._) `${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._) `${eql}(${data}[${i}], ${data}[${j}])`, () => {
+                cxt.error();
+                gen.assign(valid, false).break(outer);
+            })));
+        }
+    },
+};
+exports.default = def;
+//# sourceMappingURL=uniqueItems.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "ajv",
+  "version": "8.18.0",
+  "description": "Another JSON Schema Validator",
+  "main": "dist/ajv.js",
+  "types": "dist/ajv.d.ts",
+  "files": [
+    "lib/",
+    "dist/",
+    ".runkit_example.js"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "eslint": "eslint \"lib/**/*.ts\" \"spec/**/*.*s\" --ignore-pattern spec/JSON-Schema-Test-Suite",
+    "prettier:write": "prettier --write \"./**/*.{json,yaml,js,ts}\"",
+    "prettier:check": "prettier --list-different \"./**/*.{json,yaml,js,ts}\"",
+    "test-spec": "cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register \"spec/**/*.spec.{ts,js}\" -R dot",
+    "test-codegen": "nyc cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register 'spec/codegen.spec.ts' -R spec",
+    "test-debug": "npm run test-spec -- --inspect-brk",
+    "test-cov": "nyc npm run test-spec",
+    "rollup": "rm -rf bundle && rollup -c",
+    "bundle": "rm -rf bundle && node ./scripts/bundle.js ajv ajv7 ajv7 && node ./scripts/bundle.js 2019 ajv2019 ajv2019 && node ./scripts/bundle.js 2020 ajv2020 ajv2020 && node ./scripts/bundle.js jtd ajvJTD ajvJTD",
+    "build": "rm -rf dist && tsc && cp -r lib/refs dist && rm dist/refs/json-schema-2019-09/index.ts && rm dist/refs/json-schema-2020-12/index.ts && rm dist/refs/jtd-schema.ts",
+    "json-tests": "rm -rf spec/_json/*.js && node scripts/jsontests",
+    "test-karma": "karma start",
+    "test-browser": "rm -rf .browser && npm run bundle && scripts/prepare-tests && karma start",
+    "test-all": "npm run test-cov && if-node-version 12 npm run test-browser",
+    "test": "npm run json-tests && npm run prettier:check && npm run eslint && npm link && npm link --legacy-peer-deps ajv && npm run test-cov",
+    "test-ci": "AJV_FULL_TEST=true npm test",
+    "prepublish": "npm run build",
+    "benchmark": "npm i && npm run build && npm link && cd ./benchmark && npm link --legacy-peer-deps ajv && npm i && node ./jtd",
+    "docs:dev": "./scripts/prepare-site && vuepress dev docs",
+    "docs:build": "./scripts/prepare-site && vuepress build docs"
+  },
+  "nyc": {
+    "exclude": [
+      "**/spec/**",
+      "node_modules"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "repository": "ajv-validator/ajv",
+  "keywords": [
+    "JSON",
+    "schema",
+    "validator",
+    "validation",
+    "jsonschema",
+    "json-schema",
+    "json-schema-validator",
+    "json-schema-validation"
+  ],
+  "author": "Evgeny Poberezkin",
+  "license": "MIT",
+  "bugs": "https://github.com/ajv-validator/ajv/issues",
+  "homepage": "https://ajv.js.org",
+  "runkitExampleFilename": ".runkit_example.js",
+  "dependencies": {
+    "fast-deep-equal": "^3.1.3",
+    "fast-uri": "^3.0.1",
+    "json-schema-traverse": "^1.0.0",
+    "require-from-string": "^2.0.2"
+  },
+  "devDependencies": {
+    "@ajv-validator/config": "^0.5.0",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/chai": "^4.3.11",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.11.30",
+    "@types/require-from-string": "^1.2.3",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
+    "ajv-formats": "^3.0.1",
+    "browserify": "^17.0.0",
+    "chai": "^4.4.1",
+    "cross-env": "^7.0.3",
+    "dayjs": "^1.11.10",
+    "dayjs-plugin-utc": "^0.1.2",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "glob": "^10.3.10",
+    "husky": "^9.0.11",
+    "if-node-version": "^1.1.1",
+    "jimp": "^0.22.10",
+    "js-beautify": "^1.15.1",
+    "json-schema-test": "^2.0.0",
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-mocha": "^2.0.1",
+    "lint-staged": "^15.2.2",
+    "mocha": "^10.3.0",
+    "module-from-string": "^3.3.0",
+    "node-fetch": "^3.3.2",
+    "nyc": "^15.1.0",
+    "prettier": "3.0.3",
+    "re2": "^1.20.9",
+    "rollup": "^2.79.1",
+    "rollup-plugin-terser": "^7.0.2",
+    "ts-node": "^10.9.2",
+    "tsify": "^5.0.4",
+    "typescript": "5.3.3",
+    "uri-js": "^4.4.1"
+  },
+  "collective": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/ajv"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/epoberezkin"
+  },
+  "prettier": "@ajv-validator/config/prettierrc.json",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged && npm test"
+    }
+  },
+  "lint-staged": {
+    "*.{json,yaml,js,ts}": "prettier --write"
+  }
+}

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_range.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRangeDef(keyword) {
+    return () => ({
+        keyword,
+        type: "number",
+        schemaType: "array",
+        macro: function ([min, max]) {
+            validateRangeSchema(min, max);
+            return keyword === "range"
+                ? { minimum: min, maximum: max }
+                : { exclusiveMinimum: min, exclusiveMaximum: max };
+        },
+        metaSchema: {
+            type: "array",
+            minItems: 2,
+            maxItems: 2,
+            items: { type: "number" },
+        },
+    });
+    function validateRangeSchema(min, max) {
+        if (min > max || (keyword === "exclusiveRange" && min === max)) {
+            throw new Error("There are no numbers in range");
+        }
+    }
+}
+exports.default = getRangeDef;
+//# sourceMappingURL=_range.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_required.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRequiredDef(keyword) {
+    return () => ({
+        keyword,
+        type: "object",
+        schemaType: "array",
+        macro(schema) {
+            if (schema.length === 0)
+                return true;
+            if (schema.length === 1)
+                return { required: schema };
+            const comb = keyword === "anyRequired" ? "anyOf" : "oneOf";
+            return { [comb]: schema.map((p) => ({ required: [p] })) };
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string" },
+        },
+    });
+}
+exports.default = getRequiredDef;
+//# sourceMappingURL=_required.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePattern = exports.metaSchemaRef = void 0;
+const codegen_1 = require("ajv/dist/compile/codegen");
+const META_SCHEMA_ID = "http://json-schema.org/schema";
+function metaSchemaRef({ defaultMeta } = {}) {
+    return defaultMeta === false ? {} : { $ref: defaultMeta || META_SCHEMA_ID };
+}
+exports.metaSchemaRef = metaSchemaRef;
+function usePattern({ gen, it: { opts } }, pattern, flags = opts.unicodeRegExp ? "u" : "") {
+    const rx = new RegExp(pattern, flags);
+    return gen.scopeValue("pattern", {
+        key: rx.toString(),
+        ref: rx,
+        code: (0, codegen_1._) `new RegExp(${pattern}, ${flags})`,
+    });
+}
+exports.usePattern = usePattern;
+//# sourceMappingURL=_util.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/allRequired.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDef() {
+    return {
+        keyword: "allRequired",
+        type: "object",
+        schemaType: "boolean",
+        macro(schema, parentSchema) {
+            if (!schema)
+                return true;
+            const required = Object.keys(parentSchema.properties);
+            if (required.length === 0)
+                return true;
+            return { required };
+        },
+        dependencies: ["properties"],
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=allRequired.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/anyRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _required_1 = __importDefault(require("./_required"));
+const getDef = (0, _required_1.default)("anyRequired");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=anyRequired.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/deepProperties.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _util_1 = require("./_util");
+function getDef(opts) {
+    return {
+        keyword: "deepProperties",
+        type: "object",
+        schemaType: "object",
+        macro: function (schema) {
+            const allOf = [];
+            for (const pointer in schema)
+                allOf.push(getSchema(pointer, schema[pointer]));
+            return { allOf };
+        },
+        metaSchema: {
+            type: "object",
+            propertyNames: { type: "string", format: "json-pointer" },
+            additionalProperties: (0, _util_1.metaSchemaRef)(opts),
+        },
+    };
+}
+exports.default = getDef;
+function getSchema(jsonPointer, schema) {
+    const segments = jsonPointer.split("/");
+    const rootSchema = {};
+    let pointerSchema = rootSchema;
+    for (let i = 1; i < segments.length; i++) {
+        let segment = segments[i];
+        const isLast = i === segments.length - 1;
+        segment = unescapeJsonPointer(segment);
+        const properties = (pointerSchema.properties = {});
+        let items;
+        if (/[0-9]+/.test(segment)) {
+            let count = +segment;
+            items = pointerSchema.items = [];
+            pointerSchema.type = ["object", "array"];
+            while (count--)
+                items.push({});
+        }
+        else {
+            pointerSchema.type = "object";
+        }
+        pointerSchema = isLast ? schema : {};
+        properties[segment] = pointerSchema;
+        if (items)
+            items.push(pointerSchema);
+    }
+    return rootSchema;
+}
+function unescapeJsonPointer(str) {
+    return str.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+module.exports = getDef;
+//# sourceMappingURL=deepProperties.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/deepRequired.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+function getDef() {
+    return {
+        keyword: "deepRequired",
+        type: "object",
+        schemaType: "array",
+        code(ctx) {
+            const { schema, data } = ctx;
+            const props = schema.map((jp) => (0, codegen_1._) `(${getData(jp)}) === undefined`);
+            ctx.fail((0, codegen_1.or)(...props));
+            function getData(jsonPointer) {
+                if (jsonPointer === "")
+                    throw new Error("empty JSON pointer not allowed");
+                const segments = jsonPointer.split("/");
+                let x = data;
+                const xs = segments.map((s, i) => i ? (x = (0, codegen_1._) `${x}${(0, codegen_1.getProperty)(unescapeJPSegment(s))}`) : x);
+                return (0, codegen_1.and)(...xs);
+            }
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string", format: "json-pointer" },
+        },
+    };
+}
+exports.default = getDef;
+function unescapeJPSegment(s) {
+    return s.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+module.exports = getDef;
+//# sourceMappingURL=deepRequired.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/dynamicDefaults.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequences = {};
+const DEFAULTS = {
+    timestamp: () => () => Date.now(),
+    datetime: () => () => new Date().toISOString(),
+    date: () => () => new Date().toISOString().slice(0, 10),
+    time: () => () => new Date().toISOString().slice(11),
+    random: () => () => Math.random(),
+    randomint: (args) => {
+        var _a;
+        const max = (_a = args === null || args === void 0 ? void 0 : args.max) !== null && _a !== void 0 ? _a : 2;
+        return () => Math.floor(Math.random() * max);
+    },
+    seq: (args) => {
+        var _a;
+        const name = (_a = args === null || args === void 0 ? void 0 : args.name) !== null && _a !== void 0 ? _a : "";
+        sequences[name] || (sequences[name] = 0);
+        return () => sequences[name]++;
+    },
+};
+const getDef = Object.assign(_getDef, { DEFAULTS });
+function _getDef() {
+    return {
+        keyword: "dynamicDefaults",
+        type: "object",
+        schemaType: ["string", "object"],
+        modifying: true,
+        valid: true,
+        compile(schema, _parentSchema, it) {
+            if (!it.opts.useDefaults || it.compositeRule)
+                return () => true;
+            const fs = {};
+            for (const key in schema)
+                fs[key] = getDefault(schema[key]);
+            const empty = it.opts.useDefaults === "empty";
+            return (data) => {
+                for (const prop in schema) {
+                    if (data[prop] === undefined || (empty && (data[prop] === null || data[prop] === ""))) {
+                        data[prop] = fs[prop]();
+                    }
+                }
+                return true;
+            };
+        },
+        metaSchema: {
+            type: "object",
+            additionalProperties: {
+                anyOf: [
+                    { type: "string" },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["func", "args"],
+                        properties: {
+                            func: { type: "string" },
+                            args: { type: "object" },
+                        },
+                    },
+                ],
+            },
+        },
+    };
+}
+function getDefault(d) {
+    return typeof d == "object" ? getObjDefault(d) : getStrDefault(d);
+}
+function getObjDefault({ func, args }) {
+    const def = DEFAULTS[func];
+    assertDefined(func, def);
+    return def(args);
+}
+function getStrDefault(d = "") {
+    const def = DEFAULTS[d];
+    assertDefined(d, def);
+    return def();
+}
+function assertDefined(name, def) {
+    if (!def)
+        throw new Error(`invalid "dynamicDefaults" keyword property value: ${name}`);
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=dynamicDefaults.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/exclusiveRange.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _range_1 = __importDefault(require("./_range"));
+const getDef = (0, _range_1.default)("exclusiveRange");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=exclusiveRange.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/instanceof.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CONSTRUCTORS = {
+    Object,
+    Array,
+    Function,
+    Number,
+    String,
+    Date,
+    RegExp,
+};
+/* istanbul ignore else */
+if (typeof Buffer != "undefined")
+    CONSTRUCTORS.Buffer = Buffer;
+/* istanbul ignore else */
+if (typeof Promise != "undefined")
+    CONSTRUCTORS.Promise = Promise;
+const getDef = Object.assign(_getDef, { CONSTRUCTORS });
+function _getDef() {
+    return {
+        keyword: "instanceof",
+        schemaType: ["string", "array"],
+        compile(schema) {
+            if (typeof schema == "string") {
+                const C = getConstructor(schema);
+                return (data) => data instanceof C;
+            }
+            if (Array.isArray(schema)) {
+                const constructors = schema.map(getConstructor);
+                return (data) => {
+                    for (const C of constructors) {
+                        if (data instanceof C)
+                            return true;
+                    }
+                    return false;
+                };
+            }
+            /* istanbul ignore next */
+            throw new Error("ajv implementation error");
+        },
+        metaSchema: {
+            anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+        },
+    };
+}
+function getConstructor(c) {
+    const C = CONSTRUCTORS[c];
+    if (C)
+        return C;
+    throw new Error(`invalid "instanceof" keyword value ${c}`);
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=instanceof.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/oneRequired.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _required_1 = __importDefault(require("./_required"));
+const getDef = (0, _required_1.default)("oneRequired");
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=oneRequired.js.map

package/.next/standalone/node_modules/terser-webpack-plugin/node_modules/ajv-keywords/dist/definitions/patternRequired.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codegen_1 = require("ajv/dist/compile/codegen");
+const _util_1 = require("./_util");
+const error = {
+    message: ({ params: { missingPattern } }) => (0, codegen_1.str) `should have property matching pattern '${missingPattern}'`,
+    params: ({ params: { missingPattern } }) => (0, codegen_1._) `{missingPattern: ${missingPattern}}`,
+};
+function getDef() {
+    return {
+        keyword: "patternRequired",
+        type: "object",
+        schemaType: "array",
+        error,
+        code(cxt) {
+            const { gen, schema, data } = cxt;
+            if (schema.length === 0)
+                return;
+            const valid = gen.let("valid", true);
+            for (const pat of schema)
+                validateProperties(pat);
+            function validateProperties(pattern) {
+                const matched = gen.let("matched", false);
+                gen.forIn("key", data, (key) => {
+                    gen.assign(matched, (0, codegen_1._) `${(0, _util_1.usePattern)(cxt, pattern)}.test(${key})`);
+                    gen.if(matched, () => gen.break());
+                });
+                cxt.setParams({ missingPattern: pattern });
+                gen.assign(valid, (0, codegen_1.and)(valid, matched));
+                cxt.pass(valid);
+            }
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string", format: "regex" },
+            uniqueItems: true,
+        },
+    };
+}
+exports.default = getDef;
+module.exports = getDef;
+//# sourceMappingURL=patternRequired.js.map