diff --git a/.cspell.json b/.cspell.json index 0af9e2f3ec3..e305b5b9e84 100644 --- a/.cspell.json +++ b/.cspell.json @@ -788,6 +788,7 @@ "apps/web/src/studio/components/workflows/step-editor/editor/files.ts", "apps/web/src/pages/playground/web-container-configuration/sandbox-vite/*.ts", "apps/api/src/app/analytics/usecases/hubspot-identify-form/hubspot-identify-form.usecase.ts", - "apps/dashboard/eslint.config.js" + "apps/dashboard/eslint.config.js", + "packages/framework/src/jsonSchemaFaker.js" ] } diff --git a/packages/framework/express/package.json b/packages/framework/express/package.json index 0266fbdf181..abcf5932461 100644 --- a/packages/framework/express/package.json +++ b/packages/framework/express/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/express.cjs", - "module": "../dist/esm/servers/express.js", - "types": "../dist/esm/servers/express.d.ts" + "main": "../dist/cjs/servers/express.cjs" } diff --git a/packages/framework/h3/package.json b/packages/framework/h3/package.json index b4f10e503ca..59e9dbba6fd 100644 --- a/packages/framework/h3/package.json +++ b/packages/framework/h3/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/h3.cjs", - "module": "../dist/esm/servers/h3.js", - "types": "../dist/esm/servers/h3.d.ts" + "main": "../dist/cjs/servers/h3.cjs" } diff --git a/packages/framework/internal/package.json b/packages/framework/internal/package.json index a00e1cd0e9d..95494b06671 100644 --- a/packages/framework/internal/package.json +++ b/packages/framework/internal/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/internal/index.cjs", - "module": "../dist/esm/internal/index.js", - "types": "../dist/esm/internal/index.d.ts" + "main": "../dist/cjs/internal/index.cjs" } diff --git a/packages/framework/lambda/package.json b/packages/framework/lambda/package.json index b890eec9146..a42edd23af6 100644 --- a/packages/framework/lambda/package.json +++ b/packages/framework/lambda/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/lambda.cjs", - "module": "../dist/esm/servers/lambda.js", - "types": "../dist/esm/servers/lambda.d.ts" + "main": "../dist/cjs/servers/lambda.cjs" } diff --git a/packages/framework/nest/package.json b/packages/framework/nest/package.json index 03a7d5810d4..6428fb2c90a 100644 --- a/packages/framework/nest/package.json +++ b/packages/framework/nest/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/nest.cjs", - "module": "../dist/esm/servers/nest.js", - "types": "../dist/esm/servers/nest.d.ts" + "main": "../dist/cjs/servers/nest.cjs" } diff --git a/packages/framework/next/package.json b/packages/framework/next/package.json index 80a90c0bb52..02f8c817b02 100644 --- a/packages/framework/next/package.json +++ b/packages/framework/next/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/next.cjs", - "module": "../dist/esm/servers/next.js", - "types": "../dist/esm/servers/next.d.ts" + "main": "../dist/cjs/servers/next.cjs" } diff --git a/packages/framework/nuxt/package.json b/packages/framework/nuxt/package.json index 9adfbdaa15e..54126aad2e8 100644 --- a/packages/framework/nuxt/package.json +++ b/packages/framework/nuxt/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/nuxt.cjs", - "module": "../dist/esm/servers/nuxt.js", - "types": "../dist/esm/servers/nuxt.d.ts" + "main": "../dist/cjs/servers/nuxt.cjs" } diff --git a/packages/framework/package.cjs.json b/packages/framework/package.cjs.json deleted file mode 100644 index 5bbefffbabe..00000000000 --- a/packages/framework/package.cjs.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "type": "commonjs" -} diff --git a/packages/framework/package.esm.json b/packages/framework/package.esm.json deleted file mode 100644 index 3dbc1ca591c..00000000000 --- a/packages/framework/package.esm.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "type": "module" -} diff --git a/packages/framework/package.json b/packages/framework/package.json index 67983cd2266..7cbb9cca9ae 100644 --- a/packages/framework/package.json +++ b/packages/framework/package.json @@ -37,7 +37,7 @@ "format:fix": "prettier --write --ignore-path .gitignore .", "build": "NODE_ENV=production tsup", "build:watch": "tsup --watch", - "postbuild": "./scripts/copy-package-json.sh && pnpm run check:exports && pnpm check:circulars", + "postbuild": "pnpm run check:exports && pnpm check:circulars", "check:exports": "attw --pack .", "check:circulars": "madge --circular --extensions ts --exclude ../../shared ./src", "$comment:bump:prerelease": "This is a workaround to support `npm version prerelease` with lerna", @@ -239,7 +239,6 @@ "better-ajv-errors": "^1.2.0", "chalk": "^4.1.2", "cross-fetch": "^4.0.0", - "json-schema-faker": "^0.5.6", "json-schema-to-ts": "^3.0.0", "liquidjs": "^10.13.1", "ora": "^5.4.1", diff --git a/packages/framework/remix/package.json b/packages/framework/remix/package.json index 4b33dad838c..cf3a10fea1f 100644 --- a/packages/framework/remix/package.json +++ b/packages/framework/remix/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/remix.cjs", - "module": "../dist/esm/servers/remix.js", - "types": "../dist/esm/servers/remix.d.ts" + "main": "../dist/cjs/servers/remix.cjs" } diff --git a/packages/framework/scripts/copy-package-json.sh b/packages/framework/scripts/copy-package-json.sh deleted file mode 100755 index 18cc160c6fd..00000000000 --- a/packages/framework/scripts/copy-package-json.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/sh - -cp ./package.cjs.json ./dist/cjs/package.json -cp ./package.esm.json ./dist/esm/package.json diff --git a/packages/framework/src/client.test.ts b/packages/framework/src/client.test.ts index d28283542b3..bfffdfd46b5 100644 --- a/packages/framework/src/client.test.ts +++ b/packages/framework/src/client.test.ts @@ -11,7 +11,7 @@ import { } from './errors'; import { workflow } from './resources'; import { Event, Step } from './types'; -import { FRAMEWORK_VERSION, SDK_VERSION, PostActionEnum } from './constants'; +import { PostActionEnum } from './constants'; describe('Novu Client', () => { let client: Client; diff --git a/packages/framework/src/client.ts b/packages/framework/src/client.ts index b01af80bb63..3b053b1064a 100644 --- a/packages/framework/src/client.ts +++ b/packages/framework/src/client.ts @@ -1,7 +1,7 @@ import { Liquid } from 'liquidjs'; import ora from 'ora'; -import { ChannelStepEnum, FRAMEWORK_VERSION, PostActionEnum, SDK_VERSION } from './constants'; +import { ChannelStepEnum, PostActionEnum } from './constants'; import { ExecutionEventControlsInvalidError, ExecutionEventPayloadInvalidError, @@ -37,25 +37,9 @@ import type { } from './types'; import { WithPassthrough } from './types/provider.types'; import { EMOJI, log, sanitizeHtmlInObject, stringifyDataStructureWithSingleQuotes } from './utils'; -import { transformSchema, validateData } from './validators'; - -/* - * JSONSchemaFaker needs to be imported as CJS to avoid HMR and Webpack issues when importing @novu/framework - * in Next.js. See https://github.com/json-schema-faker/json-schema-faker/issues/796#issuecomment-2433335751 - */ -const { JSONSchemaFaker } = require('json-schema-faker'); - -/** - * We want to respond with a consistent string value for preview - */ -JSONSchemaFaker.random.shuffle = function shuffle() { - return ['[placeholder]']; -}; - -JSONSchemaFaker.option({ - useDefaultValue: true, - alwaysFakeOptionals: true, -}); +import { validateData } from './validators'; + +import { mockSchema } from './jsonSchemaFaker'; function isRuntimeInDevelopment() { return ['development', undefined].includes(process.env.NODE_ENV); @@ -169,8 +153,7 @@ export class Client { * @returns mocked data */ private mock(schema: Schema): Record { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - return JSONSchemaFaker.generate(transformSchema(schema) as any) as Record; + return mockSchema(schema) as Record; } private async validate>( diff --git a/packages/framework/src/constants/index.ts b/packages/framework/src/constants/index.ts index 6c072ddbea4..32b666d86ed 100644 --- a/packages/framework/src/constants/index.ts +++ b/packages/framework/src/constants/index.ts @@ -8,5 +8,4 @@ export * from './http-query.constants'; export * from './http-status.constants'; export * from './resource.constants'; export * from './step.constants'; -export * from './version.constants'; export * from './workflow.constants'; diff --git a/packages/framework/src/constants/version.constants.ts b/packages/framework/src/constants/version.constants.ts deleted file mode 100644 index 37def4e2a84..00000000000 --- a/packages/framework/src/constants/version.constants.ts +++ /dev/null @@ -1,2 +0,0 @@ -export { version as SDK_VERSION } from '../../package.json'; -export const FRAMEWORK_VERSION = '2024-06-26'; diff --git a/packages/framework/src/constants/version.test.ts b/packages/framework/src/constants/version.test.ts deleted file mode 100644 index 78341f6aed5..00000000000 --- a/packages/framework/src/constants/version.test.ts +++ /dev/null @@ -1,11 +0,0 @@ -import { expect, test, describe } from 'vitest'; -import { SDK_VERSION } from './version.constants'; - -describe('version', () => { - test('should export the current version', () => { - const importVersion = SDK_VERSION; - // eslint-disable-next-line global-require - const packageJsonVersion = require('../../package.json').version; - expect(importVersion).toEqual(packageJsonVersion); - }); -}); diff --git a/packages/framework/src/globals.d.ts b/packages/framework/src/globals.d.ts new file mode 100644 index 00000000000..93d34f40670 --- /dev/null +++ b/packages/framework/src/globals.d.ts @@ -0,0 +1,6 @@ +export {}; + +declare global { + const SDK_VERSION: string; + const FRAMEWORK_VERSION: string; +} diff --git a/packages/framework/src/handler.ts b/packages/framework/src/handler.ts index 26167d46582..9ad8953cc7b 100644 --- a/packages/framework/src/handler.ts +++ b/packages/framework/src/handler.ts @@ -2,14 +2,12 @@ import { createHmac } from 'node:crypto'; import { Client } from './client'; import { - FRAMEWORK_VERSION, GetActionEnum, HttpHeaderKeysEnum, HttpMethodEnum, HttpQueryKeysEnum, HttpStatusEnum, PostActionEnum, - SDK_VERSION, SIGNATURE_TIMESTAMP_TOLERANCE, } from './constants'; import { diff --git a/packages/framework/src/jsonSchemaFaker.js b/packages/framework/src/jsonSchemaFaker.js new file mode 100644 index 00000000000..2052d154641 --- /dev/null +++ b/packages/framework/src/jsonSchemaFaker.js @@ -0,0 +1,6069 @@ +/* eslint-disable */ + +/* + * Json-schema-faker is causing big HMR and Webpack headaches when @novu/framework is used in Next.js. + * To address the issue, we decided to go old-school and hardcode the IIFE version of the source code in our package. + * + * The code was copied for https://unpkg.com/browse/json-schema-faker@0.5.6/dist/main.iife.js. + * + * PLEASE NOTE THE CODE WAS SLIGHTLY MODIFIED TO MAKE IT WORK IN @novu/framework. See the end of this file. + * + * See https://github.com/json-schema-faker/json-schema-faker/issues/796#issuecomment-2433335751. + */ +const JSONSchemaFaker = (() => { + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __esm = (fn, res) => + function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])((fn = 0))), res; + }; + var __commonJS = (cb, mod) => + function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __export = (target, all) => { + for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if ((from && typeof from === 'object') || typeof from === 'function') { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { + get: () => from[key], + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable, + }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps(__defProp({}, '__esModule', { value: true }), mod); + + // src/shared.js + var shared_exports = {}; + __export(shared_exports, { + JSONSchemaFaker: () => JSONSchemaFaker, + default: () => lib_default, + setDependencies: () => setDependencies, + }); + function optionAPI(nameOrOptionMap, optionalValue) { + if (typeof nameOrOptionMap === 'string') { + if (typeof optionalValue !== 'undefined') { + return registry.register(nameOrOptionMap, optionalValue); + } + return registry.get(nameOrOptionMap); + } + return registry.registerMany(nameOrOptionMap); + } + function getRandomInteger(min, max) { + min = typeof min === 'undefined' ? constants_default.MIN_INTEGER : min; + max = typeof max === 'undefined' ? constants_default.MAX_INTEGER : max; + return Math.floor(option_default('random')() * (max - min + 1)) + min; + } + function _randexp(value) { + import_randexp.default.prototype.max = option_default('defaultRandExpMax'); + import_randexp.default.prototype.randInt = (a, b) => a + Math.floor(option_default('random')() * (1 + (b - a))); + const re = new import_randexp.default(value); + return re.gen(); + } + function pick(collection) { + return collection[Math.floor(option_default('random')() * collection.length)]; + } + function shuffle(collection) { + let tmp; + let key; + let length = collection.length; + const copy = collection.slice(); + for (; length > 0; ) { + key = Math.floor(option_default('random')() * length); + length -= 1; + tmp = copy[length]; + copy[length] = copy[key]; + copy[key] = tmp; + } + return copy; + } + function getRandom(min, max) { + return option_default('random')() * (max - min) + min; + } + function number(min, max, defMin, defMax, hasPrecision = false) { + defMin = typeof defMin === 'undefined' ? constants_default.MIN_NUMBER : defMin; + defMax = typeof defMax === 'undefined' ? constants_default.MAX_NUMBER : defMax; + min = typeof min === 'undefined' ? defMin : min; + max = typeof max === 'undefined' ? defMax : max; + if (max < min) { + max += min; + } + if (hasPrecision) { + return getRandom(min, max); + } + return getRandomInteger(min, max); + } + function by(type) { + switch (type) { + case 'seconds': + return number(0, 60) * 60; + case 'minutes': + return number(15, 50) * 612; + case 'hours': + return number(12, 72) * 36123; + case 'days': + return number(7, 30) * 86412345; + case 'weeks': + return number(4, 52) * 604812345; + case 'months': + return number(2, 13) * 2592012345; + case 'years': + return number(1, 20) * 31104012345; + default: + break; + } + } + function date(step) { + if (step) { + return by(step); + } + let earliest = option_default('minDateTime'); + let latest = option_default('maxDateTime'); + if (typeof earliest === 'string') { + earliest = new Date(earliest); + } + if (typeof latest === 'string') { + latest = new Date(latest); + } + const now = /* @__PURE__ */ new Date().getTime(); + if (typeof earliest === 'number') { + earliest = new Date(now + earliest); + } + if (typeof latest === 'number') { + latest = new Date(now + latest); + } + return new Date(getRandom(earliest.getTime(), latest.getTime())); + } + function getLocalRef(obj, path, refs) { + path = decodeURIComponent(path); + if (refs && refs[path]) return clone(refs[path]); + const keyElements = path.replace('#/', '/').split('/'); + let schema = (obj.$ref && refs && refs[obj.$ref]) || obj; + if (!schema && !keyElements[0]) { + keyElements[0] = obj.$ref.split('#/')[0]; + } + if (refs && path.includes('#/') && refs[keyElements[0]]) { + schema = refs[keyElements.shift()]; + } + if (!keyElements[0]) keyElements.shift(); + while (schema && keyElements.length > 0) { + const prop = keyElements.shift(); + if (!schema[prop]) { + throw new Error(`Prop not found: ${prop} (${path})`); + } + schema = schema[prop]; + } + return schema; + } + function isNumeric(value) { + return typeof value === 'string' && RE_NUMERIC.test(value); + } + function isScalar(value) { + return ['number', 'boolean'].includes(typeof value); + } + function hasProperties(obj, ...properties) { + return ( + properties.filter((key) => { + return typeof obj[key] !== 'undefined'; + }).length > 0 + ); + } + function clampDate(value) { + if (value.includes(' ')) { + return new Date(value).toISOString().substr(0, 10); + } + let [year, month, day] = value.split('T')[0].split('-'); + month = `0${Math.max(1, Math.min(12, month))}`.slice(-2); + day = `0${Math.max(1, Math.min(31, day))}`.slice(-2); + return `${year}-${month}-${day}`; + } + function clampDateTime(value) { + if (value.includes(' ')) { + return new Date(value).toISOString().substr(0, 10); + } + const [datePart, timePart] = value.split('T'); + let [year, month, day] = datePart.split('-'); + let [hour, minute, second] = timePart.substr(0, 8).split(':'); + month = `0${Math.max(1, Math.min(12, month))}`.slice(-2); + day = `0${Math.max(1, Math.min(31, day))}`.slice(-2); + hour = `0${Math.max(1, Math.min(23, hour))}`.slice(-2); + minute = `0${Math.max(1, Math.min(59, minute))}`.slice(-2); + second = `0${Math.max(1, Math.min(59, second))}`.slice(-2); + return `${year}-${month}-${day}T${hour}:${minute}:${second}.000Z`; + } + function typecast(type, schema, callback) { + const params = {}; + switch (type || schema.type) { + case 'integer': + case 'number': + if (typeof schema.minimum !== 'undefined') { + params.minimum = schema.minimum; + } + if (typeof schema.maximum !== 'undefined') { + params.maximum = schema.maximum; + } + if (schema.enum) { + let min = Math.max(params.minimum || 0, 0); + let max = Math.min(params.maximum || Infinity, Infinity); + if (schema.exclusiveMinimum && min === schema.minimum) { + min += schema.multipleOf || 1; + } + if (schema.exclusiveMaximum && max === schema.maximum) { + max -= schema.multipleOf || 1; + } + if (min || max !== Infinity) { + schema.enum = schema.enum.filter((x) => { + if (x >= min && x <= max) { + return true; + } + return false; + }); + } + } + break; + case 'string': { + params.minLength = option_default('minLength') || 0; + params.maxLength = option_default('maxLength') || Number.MAX_SAFE_INTEGER; + if (typeof schema.minLength !== 'undefined') { + params.minLength = Math.max(params.minLength, schema.minLength); + } + if (typeof schema.maxLength !== 'undefined') { + params.maxLength = Math.min(params.maxLength, schema.maxLength); + } + break; + } + default: + break; + } + let value = callback(params); + if (value === null || value === void 0) { + return null; + } + switch (type || schema.type) { + case 'number': + value = isNumeric(value) ? parseFloat(value) : value; + break; + case 'integer': + value = isNumeric(value) ? parseInt(value, 10) : value; + break; + case 'boolean': + value = !!value; + break; + case 'string': { + if (isScalar(value)) { + return value; + } + value = String(value); + const min = Math.max(params.minLength || 0, 0); + const max = Math.min(params.maxLength || Infinity, Infinity); + let prev; + let noChangeCount = 0; + while (value.length < min) { + prev = value; + if (!schema.pattern) { + value += `${random_default.pick([' ', '/', '_', '-', '+', '=', '@', '^'])}${value}`; + } else { + value += random_default.randexp(schema.pattern); + } + if (value === prev) { + noChangeCount += 1; + if (noChangeCount === 3) { + break; + } + } else { + noChangeCount = 0; + } + } + if (value.length > max) { + value = value.substr(0, max); + } + switch (schema.format) { + case 'date-time': + case 'datetime': + value = new Date(clampDateTime(value)).toISOString().replace(/([0-9])0+Z$/, '$1Z'); + break; + case 'full-date': + case 'date': + value = new Date(clampDate(value)).toISOString().substr(0, 10); + break; + case 'time': + value = /* @__PURE__ */ new Date(`1969-01-01 ${value}`).toISOString().substr(11); + break; + default: + break; + } + break; + } + default: + break; + } + return value; + } + function merge(a, b) { + Object.keys(b).forEach((key) => { + if (typeof b[key] !== 'object' || b[key] === null) { + a[key] = b[key]; + } else if (Array.isArray(b[key])) { + a[key] = a[key] || []; + b[key].forEach((value, i) => { + if (a.type === 'array' && b.type === 'array') { + a[key][i] = merge(a[key][i] || {}, value, true); + } else if (Array.isArray(a[key]) && a[key].indexOf(value) === -1) { + a[key].push(value); + } + }); + } else if (typeof a[key] !== 'object' || a[key] === null || Array.isArray(a[key])) { + a[key] = merge({}, b[key]); + } else { + a[key] = merge(a[key], b[key]); + } + }); + return a; + } + function clone(obj, cache = /* @__PURE__ */ new Map()) { + if (!obj || typeof obj !== 'object') { + return obj; + } + if (cache.has(obj)) { + return cache.get(obj); + } + if (Array.isArray(obj)) { + const arr = []; + cache.set(obj, arr); + arr.push(...obj.map((x) => clone(x, cache))); + return arr; + } + const clonedObj = {}; + cache.set(obj, clonedObj); + return Object.keys(obj).reduce((prev, cur) => { + prev[cur] = clone(obj[cur], cache); + return prev; + }, clonedObj); + } + function short(schema) { + const s = JSON.stringify(schema); + const l = JSON.stringify(schema, null, 2); + return s.length > 400 ? `${l.substr(0, 400)}...` : l; + } + function anyValue() { + return random_default.pick([ + false, + true, + null, + -1, + NaN, + Math.PI, + Infinity, + void 0, + [], + {}, + // FIXME: use built-in random? + Math.random(), + Math.random().toString(36).substr(2), + ]); + } + function hasValue(schema, value) { + if (schema.enum) return schema.enum.includes(value); + if (schema.const) return schema.const === value; + } + function notValue(schema, parent) { + const copy = merge({}, parent); + if (typeof schema.minimum !== 'undefined') { + copy.maximum = schema.minimum; + copy.exclusiveMaximum = true; + } + if (typeof schema.maximum !== 'undefined') { + copy.minimum = schema.maximum > copy.maximum ? 0 : schema.maximum; + copy.exclusiveMinimum = true; + } + if (typeof schema.minLength !== 'undefined') { + copy.maxLength = schema.minLength; + } + if (typeof schema.maxLength !== 'undefined') { + copy.minLength = schema.maxLength > copy.maxLength ? 0 : schema.maxLength; + } + if (schema.type) { + copy.type = random_default.pick( + constants_default.SCALAR_TYPES.filter((x) => { + const types2 = Array.isArray(schema.type) ? schema.type : [schema.type]; + return types2.every((type) => { + if (x === 'number' || x === 'integer') { + return type !== 'number' && type !== 'integer'; + } + return x !== type; + }); + }) + ); + } else if (schema.enum) { + let value; + do { + value = anyValue(); + } while (schema.enum.indexOf(value) !== -1); + copy.enum = [value]; + } + if (schema.required && copy.properties) { + schema.required.forEach((prop) => { + delete copy.properties[prop]; + }); + } + return copy; + } + function validateValueForSchema(value, schema) { + const schemaHasMin = schema.minimum !== void 0; + const schemaHasMax = schema.maximum !== void 0; + return ( + (schemaHasMin || schemaHasMax) && + (!schemaHasMin || value >= schema.minimum) && + (!schemaHasMax || value <= schema.maximum) + ); + } + function validate(value, schemas) { + return !schemas.every((schema) => validateValueForSchema(value, schema)); + } + function validateValueForOneOf(value, oneOf) { + const validCount = oneOf.reduce((count, schema) => count + (validateValueForSchema(value, schema) ? 1 : 0), 0); + return validCount === 1; + } + function isKey(prop) { + return ['enum', 'const', 'default', 'examples', 'required', 'definitions', 'items', 'properties'].includes(prop); + } + function omitProps(obj, props) { + return Object.keys(obj) + .filter((key) => !props.includes(key)) + .reduce((copy, k) => { + if (Array.isArray(obj[k])) { + copy[k] = obj[k].slice(); + } else { + copy[k] = obj[k] instanceof Object ? merge({}, obj[k]) : obj[k]; + } + return copy; + }, {}); + } + function template(value, schema) { + if (Array.isArray(value)) { + return value.map((x) => template(x, schema)); + } + if (typeof value === 'string') { + value = value.replace(/#\{([\w.-]+)\}/g, (_, $1) => schema[$1]); + } + return value; + } + function isEmpty(value) { + return Object.prototype.toString.call(value) === '[object Object]' && !Object.keys(value).length; + } + function shouldClean(key, schema) { + schema = schema.items || schema; + const alwaysFakeOptionals = option_default('alwaysFakeOptionals'); + const isRequired = (Array.isArray(schema.required) && schema.required.includes(key)) || alwaysFakeOptionals; + const wasCleaned = + typeof schema.thunk === 'function' || + (schema.additionalProperties && typeof schema.additionalProperties.thunk === 'function'); + return !isRequired && !wasCleaned; + } + function clean(obj, schema, isArray = false) { + if (!obj || typeof obj !== 'object') { + return obj; + } + if (Array.isArray(obj)) { + return obj.map((value) => clean(value, schema, true)).filter((value) => typeof value !== 'undefined'); + } + Object.keys(obj).forEach((k) => { + if (isEmpty(obj[k])) { + if (shouldClean(k, schema)) { + delete obj[k]; + } + } else { + let subSchema = schema; + if (schema && schema.properties && schema.properties[k]) { + subSchema = schema.properties[k]; + } + const value = clean(obj[k], subSchema); + if (!isEmpty(value)) { + obj[k] = value; + } + } + if (typeof obj[k] === 'undefined') { + delete obj[k]; + } + }); + if (!Object.keys(obj).length && isArray) { + return void 0; + } + return obj; + } + function proxy(gen) { + return (value, schema, property, rootSchema) => { + let fn = value; + let args = []; + if (typeof value === 'object') { + fn = Object.keys(value)[0]; + if (Array.isArray(value[fn])) { + args = value[fn]; + } else { + args.push(value[fn]); + } + } + const props = fn.split('.'); + let ctx = gen(); + while (props.length > 1) { + ctx = ctx[props.shift()]; + } + value = typeof ctx === 'object' ? ctx[props[0]] : ctx; + if (typeof value === 'function') { + value = value.apply( + ctx, + args.map((x) => utils_default.template(x, rootSchema)) + ); + } + if (Object.prototype.toString.call(value) === '[object Object]') { + Object.keys(value).forEach((key) => { + if (typeof value[key] === 'function') { + throw new Error(`Cannot resolve value for '${property}: ${fn}', given: ${value}`); + } + }); + } + return value; + }; + } + function formatAPI(nameOrFormatMap, callback) { + if (typeof nameOrFormatMap === 'undefined') { + return registry2.list(); + } + if (typeof nameOrFormatMap === 'string') { + if (typeof callback === 'function') { + registry2.register(nameOrFormatMap, callback); + } else if (callback === null || callback === false) { + registry2.unregister(nameOrFormatMap); + } else { + return registry2.get(nameOrFormatMap); + } + } else { + registry2.registerMany(nameOrFormatMap); + } + } + function matchesType(obj, lastElementInPath, inferredTypeProperties) { + return ( + Object.keys(obj).filter((prop) => { + const isSubschema = subschemaProperties.indexOf(lastElementInPath) > -1; + const inferredPropertyFound = inferredTypeProperties.indexOf(prop) > -1; + if (inferredPropertyFound && !isSubschema) { + return true; + } + return false; + }).length > 0 + ); + } + function inferType(obj, schemaPath) { + const keys = Object.keys(inferredProperties); + for (let i = 0; i < keys.length; i += 1) { + const typeName = keys[i]; + const lastElementInPath = schemaPath[schemaPath.length - 1]; + if (matchesType(obj, lastElementInPath, inferredProperties[typeName])) { + return typeName; + } + } + } + function booleanGenerator() { + return option_default('random')() > 0.5; + } + function nullGenerator() { + return null; + } + function unique(path, items, value, sample, resolve2, traverseCallback) { + const tmp = []; + const seen = []; + function walk(obj) { + const json = JSON.stringify(obj.value); + if (seen.indexOf(json) === -1) { + seen.push(json); + tmp.push(obj); + return true; + } + return false; + } + items.forEach(walk); + let limit = 100; + while (tmp.length !== items.length) { + if (!walk(traverseCallback(value.items || sample, path, resolve2))) { + limit -= 1; + } + if (!limit) { + break; + } + } + return tmp; + } + function arrayType(value, path, resolve2, traverseCallback) { + const items = []; + if (!(value.items || value.additionalItems)) { + if (utils_default.hasProperties(value, 'minItems', 'maxItems', 'uniqueItems')) { + if (value.minItems !== 0 || value.maxItems !== 0) { + throw new error_default(`missing items for ${utils_default.short(value)}`, path); + } + } + return items; + } + if (Array.isArray(value.items)) { + return value.items.map((item, key) => { + const itemSubpath = path.concat(['items', key]); + return traverseCallback(item, itemSubpath, resolve2); + }); + } + let minItems = value.minItems; + let maxItems = value.maxItems; + const defaultMinItems = option_default('minItems'); + const defaultMaxItems = option_default('maxItems'); + if (defaultMinItems) { + minItems = typeof minItems === 'undefined' ? defaultMinItems : Math.min(defaultMinItems, minItems); + } + if (defaultMaxItems) { + maxItems = typeof maxItems === 'undefined' ? defaultMaxItems : Math.min(defaultMaxItems, maxItems); + if (maxItems && maxItems > defaultMaxItems) { + maxItems = defaultMaxItems; + } + if (minItems && minItems > defaultMaxItems) { + minItems = maxItems; + } + } + const optionalsProbability = + option_default('alwaysFakeOptionals') === true ? 1 : option_default('optionalsProbability'); + const fixedProbabilities = option_default('alwaysFakeOptionals') || option_default('fixedProbabilities') || false; + let length = random_default.number(minItems, maxItems, 1, 5); + if (optionalsProbability !== null) { + length = Math.max( + fixedProbabilities + ? Math.round((maxItems || length) * optionalsProbability) + : Math.abs(random_default.number(minItems, maxItems) * optionalsProbability), + minItems || 0 + ); + } + const sample = typeof value.additionalItems === 'object' ? value.additionalItems : {}; + for (let current = items.length; current < length; current += 1) { + const itemSubpath = path.concat(['items', current]); + const element = traverseCallback(value.items || sample, itemSubpath, resolve2); + items.push(element); + } + if (value.contains && length > 0) { + const idx = random_default.number(0, length - 1); + items[idx] = traverseCallback(value.contains, path.concat(['items', idx]), resolve2); + } + if (value.uniqueItems) { + return unique(path.concat(['items']), items, value, sample, resolve2, traverseCallback); + } + return items; + } + function numberType(value) { + let min = + typeof value.minimum === 'undefined' || value.minimum === -Number.MAX_VALUE + ? constants_default.MIN_INTEGER + : value.minimum; + let max = + typeof value.maximum === 'undefined' || value.maximum === Number.MAX_VALUE + ? constants_default.MAX_INTEGER + : value.maximum; + const multipleOf = value.multipleOf; + const decimals = multipleOf && String(multipleOf).match(/e-(\d)|\.(\d+)$/); + if (decimals) { + const number2 = (Math.random() * random_default.number(0, 10) + 1) * multipleOf; + const truncate = decimals[1] || decimals[2].length; + const result = parseFloat(number2.toFixed(truncate)); + const base = random_default.number(min, max - 1); + if (!String(result).includes('.')) { + return (base + result).toExponential(); + } + return base + result; + } + if (multipleOf) { + max = Math.floor(max / multipleOf) * multipleOf; + min = Math.ceil(min / multipleOf) * multipleOf; + } + if (value.exclusiveMinimum && min === value.minimum) { + min += multipleOf || 1; + } + if (value.exclusiveMaximum && max === value.maximum) { + max -= multipleOf || 1; + } + if (min > max) { + return NaN; + } + if (multipleOf) { + let base = random_default.number(Math.floor(min / multipleOf), Math.floor(max / multipleOf)) * multipleOf; + while (base < min) { + base += multipleOf; + } + return base; + } + return random_default.number(min, max, void 0, void 0, value.type !== 'integer'); + } + function integerType(value) { + return Math.floor(number_default({ ...value })); + } + function wordsGenerator(length) { + const words = random_default.shuffle(LIPSUM_WORDS); + return words.slice(0, length); + } + function objectType(value, path, resolve2, traverseCallback) { + const props = {}; + const properties = value.properties || {}; + const patternProperties = value.patternProperties || {}; + const requiredProperties = typeof value.required === 'boolean' ? [] : (value.required || []).slice(); + const allowsAdditional = value.additionalProperties !== false; + const propertyKeys = Object.keys(properties); + const patternPropertyKeys = Object.keys(patternProperties); + const optionalProperties = propertyKeys.concat(patternPropertyKeys).reduce((_response, _key) => { + if (requiredProperties.indexOf(_key) === -1) _response.push(_key); + return _response; + }, []); + const allProperties = requiredProperties.concat(optionalProperties); + const additionalProperties = allowsAdditional + ? value.additionalProperties === true + ? anyType + : value.additionalProperties + : value.additionalProperties; + if ( + !allowsAdditional && + propertyKeys.length === 0 && + patternPropertyKeys.length === 0 && + utils_default.hasProperties(value, 'minProperties', 'maxProperties', 'dependencies', 'required') + ) { + return null; + } + if (option_default('requiredOnly') === true) { + requiredProperties.forEach((key) => { + if (properties[key]) { + props[key] = properties[key]; + } + }); + return traverseCallback(props, path.concat(['properties']), resolve2, value); + } + const optionalsProbability = + option_default('alwaysFakeOptionals') === true ? 1 : option_default('optionalsProbability'); + const fixedProbabilities = option_default('alwaysFakeOptionals') || option_default('fixedProbabilities') || false; + const ignoreProperties = option_default('ignoreProperties') || []; + const reuseProps = option_default('reuseProperties'); + const fillProps = option_default('fillProperties'); + const max = value.maxProperties || allProperties.length + (allowsAdditional ? random_default.number(1, 5) : 0); + let min = Math.max(value.minProperties || 0, requiredProperties.length); + let neededExtras = Math.max(0, allProperties.length - min); + if (allProperties.length === 1 && !requiredProperties.length) { + min = Math.max(random_default.number(fillProps ? 1 : 0, max), min); + } + if (optionalsProbability !== null) { + if (fixedProbabilities === true) { + neededExtras = Math.round( + min - requiredProperties.length + optionalsProbability * (allProperties.length - min) + ); + } else { + neededExtras = random_default.number( + min - requiredProperties.length, + optionalsProbability * (allProperties.length - min) + ); + } + } + const extraPropertiesRandomOrder = random_default.shuffle(optionalProperties).slice(0, neededExtras); + const extraProperties = optionalProperties.filter((_item) => { + return extraPropertiesRandomOrder.indexOf(_item) !== -1; + }); + const _limit = + optionalsProbability !== null || requiredProperties.length === max ? max : random_default.number(0, max); + const _props = requiredProperties.concat(random_default.shuffle(extraProperties).slice(0, _limit)).slice(0, max); + const _defns = []; + const _deps = []; + if (value.dependencies) { + Object.keys(value.dependencies).forEach((prop) => { + const _required = value.dependencies[prop]; + if (_props.indexOf(prop) !== -1) { + if (Array.isArray(_required)) { + _required.forEach((sub) => { + if (_props.indexOf(sub) === -1) { + _props.push(sub); + } + }); + } else if (Array.isArray(_required.oneOf || _required.anyOf)) { + const values = _required.oneOf || _required.anyOf; + _deps.push({ prop, values }); + } else { + _defns.push(_required); + } + } + }); + if (_defns.length) { + delete value.dependencies; + return traverseCallback( + { + allOf: _defns.concat(value), + }, + path.concat(['properties']), + resolve2, + value + ); + } + } + const skipped = []; + const missing = []; + _props.forEach((key) => { + if (properties[key] && ['{}', 'true'].includes(JSON.stringify(properties[key].not))) { + return; + } + for (let i = 0; i < ignoreProperties.length; i += 1) { + if ( + (ignoreProperties[i] instanceof RegExp && ignoreProperties[i].test(key)) || + (typeof ignoreProperties[i] === 'string' && ignoreProperties[i] === key) || + (typeof ignoreProperties[i] === 'function' && ignoreProperties[i](properties[key], key)) + ) { + skipped.push(key); + return; + } + } + if (additionalProperties === false) { + if (requiredProperties.indexOf(key) !== -1) { + props[key] = properties[key]; + } + } + if (properties[key]) { + props[key] = properties[key]; + } + let found; + patternPropertyKeys.forEach((_key) => { + if (key.match(new RegExp(_key))) { + found = true; + if (props[key]) { + utils_default.merge(props[key], patternProperties[_key]); + } else { + props[random_default.randexp(key)] = patternProperties[_key]; + } + } + }); + if (!found) { + const subschema = patternProperties[key] || additionalProperties; + if (subschema && additionalProperties !== false) { + props[patternProperties[key] ? random_default.randexp(key) : key] = properties[key] || subschema; + } else { + missing.push(key); + } + } + }); + let current = Object.keys(props).length + (fillProps ? 0 : skipped.length); + const hash = (suffix) => random_default.randexp(`_?[_a-f\\d]{1,3}${suffix ? '\\$?' : ''}`); + function get(from) { + let one; + do { + if (!from.length) break; + one = from.shift(); + } while (props[one]); + return one; + } + let minProps = min; + if (allowsAdditional && !requiredProperties.length) { + minProps = Math.max( + optionalsProbability === null || additionalProperties ? random_default.number(fillProps ? 1 : 0, max) : 0, + min + ); + } + if (!extraProperties.length && !neededExtras && allowsAdditional && fixedProbabilities === true && fillProps) { + const limit = random_default.number(0, max); + for (let i = 0; i < limit; i += 1) { + props[words_default(1) + hash(limit[i])] = additionalProperties || anyType; + } + } + while (fillProps) { + if (!(patternPropertyKeys.length || allowsAdditional)) { + break; + } + if (current >= minProps) { + break; + } + if (allowsAdditional) { + if (reuseProps && propertyKeys.length - current > minProps) { + let count = 0; + let key; + do { + count += 1; + if (count > 1e3) { + break; + } + key = get(requiredProperties) || random_default.pick(propertyKeys); + } while (typeof props[key] !== 'undefined'); + if (typeof props[key] === 'undefined') { + props[key] = properties[key]; + current += 1; + } + } else if (patternPropertyKeys.length && !additionalProperties) { + const prop = random_default.pick(patternPropertyKeys); + const word = random_default.randexp(prop); + if (!props[word]) { + props[word] = patternProperties[prop]; + current += 1; + } + } else { + const word = get(requiredProperties) || words_default(1) + hash(); + if (!props[word]) { + props[word] = additionalProperties || anyType; + current += 1; + } + } + } + for (let i = 0; current < min && i < patternPropertyKeys.length; i += 1) { + const _key = patternPropertyKeys[i]; + const word = random_default.randexp(_key); + if (!props[word]) { + props[word] = patternProperties[_key]; + current += 1; + } + } + } + if (requiredProperties.length === 0 && (!allowsAdditional || optionalsProbability === false)) { + const maximum = random_default.number(min, max); + for (; current < maximum; ) { + const word = get(propertyKeys); + if (word) { + props[word] = properties[word]; + } + current += 1; + } + } + let sortedObj = props; + if (option_default('sortProperties') !== null) { + const originalKeys = Object.keys(properties); + const sortedKeys = Object.keys(props).sort((a, b) => { + return option_default('sortProperties') + ? a.localeCompare(b) + : originalKeys.indexOf(a) - originalKeys.indexOf(b); + }); + sortedObj = sortedKeys.reduce((memo, key) => { + memo[key] = props[key]; + return memo; + }, {}); + } + const result = traverseCallback(sortedObj, path.concat(['properties']), resolve2, value); + _deps.forEach((dep) => { + for (const sub of dep.values) { + if (utils_default.hasValue(sub.properties[dep.prop], result.value[dep.prop])) { + Object.keys(sub.properties).forEach((next) => { + if (next !== dep.prop) { + utils_default.merge( + result.value, + traverseCallback(sub.properties, path.concat(['properties']), resolve2, value).value + ); + } + }); + break; + } + } + }); + return result; + } + function produce() { + const length = random_default.number(1, 5); + return words_default(length).join(' '); + } + function thunkGenerator(min = 0, max = 140) { + const _min = Math.max(0, min); + const _max = random_default.number(_min, max); + let result = produce(); + while (result.length < _min) { + result += produce(); + } + if (result.length > _max) { + result = result.substr(0, _max); + } + return result; + } + function ipv4Generator() { + return [0, 0, 0, 0] + .map(() => { + return random_default.number(0, 255); + }) + .join('.'); + } + function dateTimeGenerator() { + return random_default.date().toISOString(); + } + function dateGenerator() { + return dateTime_default().slice(0, 10); + } + function timeGenerator() { + return dateTime_default().slice(11); + } + function coreFormatGenerator(coreFormat) { + return random_default.randexp(regexps[coreFormat]).replace(ALLOWED_FORMATS, (match, key) => { + return random_default.randexp(regexps[key]); + }); + } + function generateFormat(value, invalid) { + const callback = format_default(value.format); + if (typeof callback === 'function') { + return callback(value); + } + switch (value.format) { + case 'date-time': + case 'datetime': + return dateTime_default(); + case 'date': + return date_default(); + case 'time': + return time_default(); + case 'ipv4': + return ipv4_default(); + case 'regex': + return '.+?'; + case 'email': + case 'hostname': + case 'ipv6': + case 'uri': + case 'uri-reference': + case 'iri': + case 'iri-reference': + case 'idn-email': + case 'idn-hostname': + case 'json-pointer': + case 'slug': + case 'uri-template': + case 'uuid': + case 'duration': + return coreFormat_default(value.format); + default: + if (typeof callback === 'undefined') { + if (option_default('failOnInvalidFormat')) { + throw new Error(`unknown registry key ${utils_default.short(value.format)}`); + } else { + return invalid(); + } + } + throw new Error(`unsupported format '${value.format}'`); + } + } + function stringType(value) { + const output = utils_default.typecast('string', value, (opts) => { + if (value.format) { + return generateFormat(value, () => thunk_default(opts.minLength, opts.maxLength)); + } + if (value.pattern) { + return random_default.randexp(value.pattern); + } + return thunk_default(opts.minLength, opts.maxLength); + }); + return output; + } + function getMeta({ $comment: comment, title, description }) { + return Object.entries({ comment, title, description }) + .filter(([, value]) => value) + .reduce((memo, [k, v]) => { + memo[k] = v; + return memo; + }, {}); + } + function traverse(schema, path, resolve2, rootSchema) { + schema = resolve2(schema, null, path); + if (schema && (schema.oneOf || schema.anyOf || schema.allOf)) { + schema = resolve2(schema, null, path); + } + if (!schema) { + throw new Error(`Cannot traverse at '${path.join('.')}', given '${JSON.stringify(rootSchema)}'`); + } + const context = { + ...getMeta(schema), + schemaPath: path, + }; + if (path[path.length - 1] !== 'properties') { + if (option_default('useExamplesValue') && Array.isArray(schema.examples)) { + const fixedExamples = schema.examples.concat('default' in schema ? [schema.default] : []); + return { value: utils_default.typecast(null, schema, () => random_default.pick(fixedExamples)), context }; + } + if (option_default('useExamplesValue') && typeof schema.example !== 'undefined') { + return { value: utils_default.typecast(null, schema, () => schema.example), context }; + } + if (option_default('useDefaultValue') && 'default' in schema) { + if (schema.default !== '' || !option_default('replaceEmptyByRandomValue')) { + return { value: schema.default, context }; + } + } + if ('template' in schema) { + return { value: utils_default.template(schema.template, rootSchema), context }; + } + if ('const' in schema) { + return { value: schema.const, context }; + } + } + if (schema.not && typeof schema.not === 'object') { + schema = utils_default.notValue(schema.not, utils_default.omitProps(schema, ['not'])); + if (schema.type && schema.type === 'object') { + const { value, context: innerContext } = traverse(schema, path.concat(['not']), resolve2, rootSchema); + return { value: utils_default.clean(value, schema, false), context: { ...context, items: innerContext } }; + } + } + if (typeof schema.thunk === 'function') { + const { value, context: innerContext } = traverse(schema.thunk(rootSchema), path, resolve2); + return { value, context: { ...context, items: innerContext } }; + } + if (schema.jsonPath) { + return { value: schema, context }; + } + let type = schema.type; + if (Array.isArray(type)) { + type = random_default.pick(type); + } else if (typeof type === 'undefined') { + type = infer_default(schema, path) || type; + if (type) { + schema.type = type; + } + } + if (typeof schema.generate === 'function') { + const retVal = utils_default.typecast(null, schema, () => schema.generate(rootSchema, path)); + const retType = retVal === null ? 'null' : typeof retVal; + if ( + retType === type || + (retType === 'number' && type === 'integer') || + (Array.isArray(retVal) && type === 'array') + ) { + return { value: retVal, context }; + } + } + if (typeof schema.pattern === 'string') { + return { value: utils_default.typecast('string', schema, () => random_default.randexp(schema.pattern)), context }; + } + if (Array.isArray(schema.enum)) { + return { value: utils_default.typecast(null, schema, () => random_default.pick(schema.enum)), context }; + } + if (typeof type === 'string') { + if (!types_default[type]) { + if (option_default('failOnInvalidTypes')) { + throw new error_default(`unknown primitive ${utils_default.short(type)}`, path.concat(['type'])); + } else { + const value = option_default('defaultInvalidTypeProduct'); + if (typeof value === 'string' && types_default[value]) { + return { value: types_default[value](schema, path, resolve2, traverse), context }; + } + return { value, context }; + } + } else { + try { + const innerResult = types_default[type](schema, path, resolve2, traverse); + if (type === 'array') { + return { + value: innerResult.map(({ value }) => value), + context: { + ...context, + items: innerResult.map( + Array.isArray(schema.items) + ? ({ context: c }) => c + : ({ context: c }) => ({ + ...c, + // we have to remove the index from the path to get the real schema path + schemaPath: c.schemaPath.slice(0, -1), + }) + ), + }, + }; + } + if (type === 'object') { + return innerResult !== null + ? { value: innerResult.value, context: { ...context, items: innerResult.context } } + : { value: {}, context }; + } + return { value: innerResult, context }; + } catch (e) { + if (typeof e.path === 'undefined') { + throw new error_default(e.stack, path); + } + throw e; + } + } + } + let valueCopy = {}; + let contextCopy = { ...context }; + if (Array.isArray(schema)) { + valueCopy = []; + } + const pruneProperties = option_default('pruneProperties') || []; + Object.keys(schema).forEach((prop) => { + if (pruneProperties.includes(prop)) return; + if (schema[prop] === null) return; + if (typeof schema[prop] === 'object' && prop !== 'definitions') { + const { value, context: innerContext } = traverse(schema[prop], path.concat([prop]), resolve2, valueCopy); + valueCopy[prop] = utils_default.clean(value, schema[prop], false); + contextCopy[prop] = innerContext; + if (valueCopy[prop] === null && option_default('omitNulls')) { + delete valueCopy[prop]; + delete contextCopy[prop]; + } + } else { + valueCopy[prop] = schema[prop]; + } + }); + return { value: valueCopy, context: contextCopy }; + } + function pick2(data) { + return Array.isArray(data) ? random_default.pick(data) : data; + } + function cycle(data, reverse) { + if (!Array.isArray(data)) { + return data; + } + const value = reverse ? data.pop() : data.shift(); + if (reverse) { + data.unshift(value); + } else { + data.push(value); + } + return value; + } + function resolve(obj, data, values, property) { + if (!obj || typeof obj !== 'object') { + return obj; + } + if (!values) { + values = {}; + } + if (!data) { + data = obj; + } + if (Array.isArray(obj)) { + return obj.map((x) => resolve(x, data, values, property)); + } + if (obj.jsonPath) { + const { JSONPath: JSONPath2 } = getDependencies(); + const params = typeof obj.jsonPath !== 'object' ? { path: obj.jsonPath } : obj.jsonPath; + params.group = obj.group || params.group || property; + params.cycle = obj.cycle || params.cycle || false; + params.reverse = obj.reverse || params.reverse || false; + params.count = obj.count || params.count || 1; + const key = `${params.group}__${params.path}`; + if (!values[key]) { + if (params.count > 1) { + values[key] = JSONPath2(params.path, data).slice(0, params.count); + } else { + values[key] = JSONPath2(params.path, data); + } + } + if (params.cycle || params.reverse) { + return cycle(values[key], params.reverse); + } + return pick2(values[key]); + } + Object.keys(obj).forEach((k) => { + obj[k] = resolve(obj[k], data, values, k); + }); + return obj; + } + function run(refs, schema, container2, synchronous) { + if (Object.prototype.toString.call(schema) !== '[object Object]') { + throw new Error(`Invalid input, expecting object but given ${typeof schema}`); + } + const refDepthMin = option_default('refDepthMin') || 0; + const refDepthMax = option_default('refDepthMax') || 3; + try { + const { resolveSchema } = buildResolveSchema_default({ + refs, + schema, + container: container2, + synchronous, + refDepthMin, + refDepthMax, + }); + const result = traverse_default(utils_default.clone(schema), [], resolveSchema); + if (option_default('resolveJsonPath')) { + return { + value: resolve(result.value), + context: result.context, + }; + } + return result; + } catch (e) { + if (e.path) { + throw new Error(`${e.message} in /${e.path.join('/')}`); + } else { + throw e; + } + } + } + function renderJS(res) { + return res.value; + } + function getIn(obj, path) { + return path.reduce((v, k) => (k in v ? v[k] : {}), obj); + } + function addComments(context, path, commentNode, iterNode = commentNode) { + const { title, description, comment } = getIn(context, path); + const lines = []; + if (option_default('renderTitle') && title) { + lines.push(` ${title}`, ''); + } + if (option_default('renderDescription') && description) { + lines.push(` ${description}`); + } + if (option_default('renderComment') && comment) { + lines.push(` ${comment}`); + } + commentNode.commentBefore = lines.join('\n'); + if (iterNode instanceof YAMLMap) { + iterNode.items.forEach((n) => { + addComments(context, [...path, 'items', n.key.value], n.key, n.value); + }); + } else if (iterNode instanceof YAMLSeq) { + iterNode.items.forEach((n, i) => { + addComments(context, [...path, 'items', i], n); + }); + } + } + function renderYAML({ value, context }) { + const nodes = yaml_default.createNode(value); + addComments(context, [], nodes); + const doc = new yaml_default.Document(); + doc.contents = nodes; + return doc.toString(); + } + function setupKeywords() { + container.define('autoIncrement', function autoIncrement(value, schema) { + if (!this.offset) { + const min = schema.minimum || 1; + const max = min + constants_default.MAX_NUMBER; + const offset = value.initialOffset || schema.initialOffset; + this.offset = offset || random_default.number(min, max); + } + if (value) { + return this.offset++; + } + return schema; + }); + container.define('sequentialDate', function sequentialDate(value, schema) { + if (!this.now) { + this.now = random_default.date(); + } + if (value) { + schema = this.now.toISOString(); + value = value === true ? 'days' : value; + if (['seconds', 'minutes', 'hours', 'days', 'weeks', 'months', 'years'].indexOf(value) === -1) { + throw new Error(`Unsupported increment by ${utils_default.short(value)}`); + } + this.now.setTime(this.now.getTime() + random_default.date(value)); + } + return schema; + }); + } + function getRefs(refs, schema) { + let $refs = {}; + if (Array.isArray(refs)) { + refs.forEach((_schema) => { + $refs[_schema.$id || _schema.id] = _schema; + }); + } else { + $refs = refs || {}; + } + function walk(obj) { + if (!obj || typeof obj !== 'object') return; + if (Array.isArray(obj)) return obj.forEach(walk); + const _id = obj.$id || obj.id; + if (typeof _id === 'string' && !$refs[_id]) { + $refs[_id] = obj; + } + Object.keys(obj).forEach((key) => { + walk(obj[key]); + }); + } + walk(refs); + walk(schema); + return $refs; + } + var __create, + __defProp2, + __getOwnPropDesc2, + __getOwnPropNames2, + __getProtoOf, + __hasOwnProp2, + __commonJS2, + __copyProps2, + __toESM, + require_types, + require_sets, + require_util, + require_positions, + require_lib, + require_lib2, + require_randexp, + require_PlainValue_ec8e588e, + require_resolveSeq_d03cb037, + require_warnings_1000a372, + require_Schema_88e323a7, + require_types2, + DEPENDENCIES, + getDependencies, + setDependencies, + Registry, + Registry_default, + defaults, + defaults_default, + OptionRegistry, + OptionRegistry_default, + registry, + option_default, + ALLOWED_TYPES, + SCALAR_TYPES, + ALL_TYPES, + MOST_NEAR_DATETIME, + MIN_INTEGER, + MAX_INTEGER, + MIN_NUMBER, + MAX_NUMBER, + constants_default, + import_randexp, + random_default, + RE_NUMERIC, + utils_default, + Container, + Container_default, + registry2, + format_default, + ParseError, + error_default, + inferredProperties, + subschemaProperties, + infer_default, + boolean_default, + booleanType, + boolean_default2, + null_default, + nullType, + null_default2, + array_default, + number_default, + integer_default, + LIPSUM_WORDS, + words_default, + anyType, + object_default, + thunk_default, + ipv4_default, + dateTime_default, + date_default, + time_default, + FRAGMENT, + URI_PATTERN, + PARAM_PATTERN, + regexps, + ALLOWED_FORMATS, + coreFormat_default, + string_default, + typeMap, + types_default, + traverse_default, + buildResolveSchema, + buildResolveSchema_default, + run_default, + js_default, + import_types2, + binaryOptions, + boolOptions, + intOptions, + nullOptions, + strOptions, + Schema, + Alias, + Collection, + Merge, + Node, + Pair, + Scalar, + YAMLMap, + YAMLSeq, + yaml_default, + container, + jsf, + JSONSchemaFaker, + lib_default; + var init_shared = __esm({ + 'src/shared.js'() { + __create = Object.create; + __defProp2 = Object.defineProperty; + __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + __getOwnPropNames2 = Object.getOwnPropertyNames; + __getProtoOf = Object.getPrototypeOf; + __hasOwnProp2 = Object.prototype.hasOwnProperty; + __commonJS2 = (cb, mod) => + function __require() { + return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + __copyProps2 = (to, from, except, desc) => { + if ((from && typeof from === 'object') || typeof from === 'function') { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { + get: () => from[key], + enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable, + }); + } + return to; + }; + __toESM = (mod, isNodeMode, target) => ( + (target = mod != null ? __create(__getProtoOf(mod)) : {}), + __copyProps2( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule + ? __defProp2(target, 'default', { value: mod, enumerable: true }) + : target, + mod + ) + ); + require_types = __commonJS2({ + 'node_modules/ret/lib/types.js'(exports, module) { + module.exports = { + ROOT: 0, + GROUP: 1, + POSITION: 2, + SET: 3, + RANGE: 4, + REPETITION: 5, + REFERENCE: 6, + CHAR: 7, + }; + }, + }); + require_sets = __commonJS2({ + 'node_modules/ret/lib/sets.js'(exports) { + var types2 = require_types(); + var INTS = () => [{ type: types2.RANGE, from: 48, to: 57 }]; + var WORDS = () => { + return [ + { type: types2.CHAR, value: 95 }, + { type: types2.RANGE, from: 97, to: 122 }, + { type: types2.RANGE, from: 65, to: 90 }, + ].concat(INTS()); + }; + var WHITESPACE = () => { + return [ + { type: types2.CHAR, value: 9 }, + { type: types2.CHAR, value: 10 }, + { type: types2.CHAR, value: 11 }, + { type: types2.CHAR, value: 12 }, + { type: types2.CHAR, value: 13 }, + { type: types2.CHAR, value: 32 }, + { type: types2.CHAR, value: 160 }, + { type: types2.CHAR, value: 5760 }, + { type: types2.RANGE, from: 8192, to: 8202 }, + { type: types2.CHAR, value: 8232 }, + { type: types2.CHAR, value: 8233 }, + { type: types2.CHAR, value: 8239 }, + { type: types2.CHAR, value: 8287 }, + { type: types2.CHAR, value: 12288 }, + { type: types2.CHAR, value: 65279 }, + ]; + }; + var NOTANYCHAR = () => { + return [ + { type: types2.CHAR, value: 10 }, + { type: types2.CHAR, value: 13 }, + { type: types2.CHAR, value: 8232 }, + { type: types2.CHAR, value: 8233 }, + ]; + }; + exports.words = () => ({ type: types2.SET, set: WORDS(), not: false }); + exports.notWords = () => ({ type: types2.SET, set: WORDS(), not: true }); + exports.ints = () => ({ type: types2.SET, set: INTS(), not: false }); + exports.notInts = () => ({ type: types2.SET, set: INTS(), not: true }); + exports.whitespace = () => ({ type: types2.SET, set: WHITESPACE(), not: false }); + exports.notWhitespace = () => ({ type: types2.SET, set: WHITESPACE(), not: true }); + exports.anyChar = () => ({ type: types2.SET, set: NOTANYCHAR(), not: true }); + }, + }); + require_util = __commonJS2({ + 'node_modules/ret/lib/util.js'(exports) { + var types2 = require_types(); + var sets = require_sets(); + var CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?'; + var SLSH = { 0: 0, t: 9, n: 10, v: 11, f: 12, r: 13 }; + exports.strToChars = function (str) { + var chars_regex = + /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g; + str = str.replace(chars_regex, function (s, b, lbs, a16, b16, c8, dctrl, eslsh) { + if (lbs) { + return s; + } + var code = b + ? 8 + : a16 + ? parseInt(a16, 16) + : b16 + ? parseInt(b16, 16) + : c8 + ? parseInt(c8, 8) + : dctrl + ? CTRL.indexOf(dctrl) + : SLSH[eslsh]; + var c = String.fromCharCode(code); + if (/[[\]{}^$.|?*+()]/.test(c)) { + c = '\\' + c; + } + return c; + }); + return str; + }; + exports.tokenizeClass = (str, regexpStr) => { + var tokens = []; + var regexp = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?([^])/g; + var rs, c; + while ((rs = regexp.exec(str)) != null) { + if (rs[1]) { + tokens.push(sets.words()); + } else if (rs[2]) { + tokens.push(sets.ints()); + } else if (rs[3]) { + tokens.push(sets.whitespace()); + } else if (rs[4]) { + tokens.push(sets.notWords()); + } else if (rs[5]) { + tokens.push(sets.notInts()); + } else if (rs[6]) { + tokens.push(sets.notWhitespace()); + } else if (rs[7]) { + tokens.push({ + type: types2.RANGE, + from: (rs[8] || rs[9]).charCodeAt(0), + to: rs[10].charCodeAt(0), + }); + } else if ((c = rs[12])) { + tokens.push({ + type: types2.CHAR, + value: c.charCodeAt(0), + }); + } else { + return [tokens, regexp.lastIndex]; + } + } + exports.error(regexpStr, 'Unterminated character class'); + }; + exports.error = (regexp, msg) => { + throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg); + }; + }, + }); + require_positions = __commonJS2({ + 'node_modules/ret/lib/positions.js'(exports) { + var types2 = require_types(); + exports.wordBoundary = () => ({ type: types2.POSITION, value: 'b' }); + exports.nonWordBoundary = () => ({ type: types2.POSITION, value: 'B' }); + exports.begin = () => ({ type: types2.POSITION, value: '^' }); + exports.end = () => ({ type: types2.POSITION, value: '$' }); + }, + }); + require_lib = __commonJS2({ + 'node_modules/ret/lib/index.js'(exports, module) { + var util = require_util(); + var types2 = require_types(); + var sets = require_sets(); + var positions = require_positions(); + module.exports = (regexpStr) => { + var i = 0, + l, + c, + start = { type: types2.ROOT, stack: [] }, + lastGroup = start, + last = start.stack, + groupStack = []; + var repeatErr = (i2) => { + util.error(regexpStr, `Nothing to repeat at column ${i2 - 1}`); + }; + var str = util.strToChars(regexpStr); + l = str.length; + while (i < l) { + c = str[i++]; + switch (c) { + case '\\': + c = str[i++]; + switch (c) { + case 'b': + last.push(positions.wordBoundary()); + break; + case 'B': + last.push(positions.nonWordBoundary()); + break; + case 'w': + last.push(sets.words()); + break; + case 'W': + last.push(sets.notWords()); + break; + case 'd': + last.push(sets.ints()); + break; + case 'D': + last.push(sets.notInts()); + break; + case 's': + last.push(sets.whitespace()); + break; + case 'S': + last.push(sets.notWhitespace()); + break; + default: + if (/\d/.test(c)) { + last.push({ type: types2.REFERENCE, value: parseInt(c, 10) }); + } else { + last.push({ type: types2.CHAR, value: c.charCodeAt(0) }); + } + } + break; + case '^': + last.push(positions.begin()); + break; + case '$': + last.push(positions.end()); + break; + case '[': + var not; + if (str[i] === '^') { + not = true; + i++; + } else { + not = false; + } + var classTokens = util.tokenizeClass(str.slice(i), regexpStr); + i += classTokens[1]; + last.push({ + type: types2.SET, + set: classTokens[0], + not, + }); + break; + case '.': + last.push(sets.anyChar()); + break; + case '(': + var group = { + type: types2.GROUP, + stack: [], + remember: true, + }; + c = str[i]; + if (c === '?') { + c = str[i + 1]; + i += 2; + if (c === '=') { + group.followedBy = true; + } else if (c === '!') { + group.notFollowedBy = true; + } else if (c !== ':') { + util.error(regexpStr, `Invalid group, character '${c}' after '?' at column ${i - 1}`); + } + group.remember = false; + } + last.push(group); + groupStack.push(lastGroup); + lastGroup = group; + last = group.stack; + break; + case ')': + if (groupStack.length === 0) { + util.error(regexpStr, `Unmatched ) at column ${i - 1}`); + } + lastGroup = groupStack.pop(); + last = lastGroup.options ? lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack; + break; + case '|': + if (!lastGroup.options) { + lastGroup.options = [lastGroup.stack]; + delete lastGroup.stack; + } + var stack = []; + lastGroup.options.push(stack); + last = stack; + break; + case '{': + var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), + min, + max; + if (rs !== null) { + if (last.length === 0) { + repeatErr(i); + } + min = parseInt(rs[1], 10); + max = rs[2] ? (rs[3] ? parseInt(rs[3], 10) : Infinity) : min; + i += rs[0].length; + last.push({ + type: types2.REPETITION, + min, + max, + value: last.pop(), + }); + } else { + last.push({ + type: types2.CHAR, + value: 123, + }); + } + break; + case '?': + if (last.length === 0) { + repeatErr(i); + } + last.push({ + type: types2.REPETITION, + min: 0, + max: 1, + value: last.pop(), + }); + break; + case '+': + if (last.length === 0) { + repeatErr(i); + } + last.push({ + type: types2.REPETITION, + min: 1, + max: Infinity, + value: last.pop(), + }); + break; + case '*': + if (last.length === 0) { + repeatErr(i); + } + last.push({ + type: types2.REPETITION, + min: 0, + max: Infinity, + value: last.pop(), + }); + break; + default: + last.push({ + type: types2.CHAR, + value: c.charCodeAt(0), + }); + } + } + if (groupStack.length !== 0) { + util.error(regexpStr, 'Unterminated group'); + } + return start; + }; + module.exports.types = types2; + }, + }); + require_lib2 = __commonJS2({ + 'node_modules/drange/lib/index.js'(exports, module) { + 'use strict'; + var SubRange = class _SubRange { + constructor(low, high) { + this.low = low; + this.high = high; + this.length = 1 + high - low; + } + overlaps(range) { + return !(this.high < range.low || this.low > range.high); + } + touches(range) { + return !(this.high + 1 < range.low || this.low - 1 > range.high); + } + // Returns inclusive combination of SubRanges as a SubRange. + add(range) { + return new _SubRange(Math.min(this.low, range.low), Math.max(this.high, range.high)); + } + // Returns subtraction of SubRanges as an array of SubRanges. + // (There's a case where subtraction divides it in 2) + subtract(range) { + if (range.low <= this.low && range.high >= this.high) { + return []; + } else if (range.low > this.low && range.high < this.high) { + return [new _SubRange(this.low, range.low - 1), new _SubRange(range.high + 1, this.high)]; + } else if (range.low <= this.low) { + return [new _SubRange(range.high + 1, this.high)]; + } else { + return [new _SubRange(this.low, range.low - 1)]; + } + } + toString() { + return this.low == this.high ? this.low.toString() : this.low + '-' + this.high; + } + }; + var DRange = class _DRange { + constructor(a, b) { + this.ranges = []; + this.length = 0; + if (a != null) this.add(a, b); + } + _update_length() { + this.length = this.ranges.reduce((previous, range) => { + return previous + range.length; + }, 0); + } + add(a, b) { + var _add = (subrange) => { + var i = 0; + while (i < this.ranges.length && !subrange.touches(this.ranges[i])) { + i++; + } + var newRanges = this.ranges.slice(0, i); + while (i < this.ranges.length && subrange.touches(this.ranges[i])) { + subrange = subrange.add(this.ranges[i]); + i++; + } + newRanges.push(subrange); + this.ranges = newRanges.concat(this.ranges.slice(i)); + this._update_length(); + }; + if (a instanceof _DRange) { + a.ranges.forEach(_add); + } else { + if (b == null) b = a; + _add(new SubRange(a, b)); + } + return this; + } + subtract(a, b) { + var _subtract = (subrange) => { + var i = 0; + while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) { + i++; + } + var newRanges = this.ranges.slice(0, i); + while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) { + newRanges = newRanges.concat(this.ranges[i].subtract(subrange)); + i++; + } + this.ranges = newRanges.concat(this.ranges.slice(i)); + this._update_length(); + }; + if (a instanceof _DRange) { + a.ranges.forEach(_subtract); + } else { + if (b == null) b = a; + _subtract(new SubRange(a, b)); + } + return this; + } + intersect(a, b) { + var newRanges = []; + var _intersect = (subrange) => { + var i = 0; + while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) { + i++; + } + while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) { + var low = Math.max(this.ranges[i].low, subrange.low); + var high = Math.min(this.ranges[i].high, subrange.high); + newRanges.push(new SubRange(low, high)); + i++; + } + }; + if (a instanceof _DRange) { + a.ranges.forEach(_intersect); + } else { + if (b == null) b = a; + _intersect(new SubRange(a, b)); + } + this.ranges = newRanges; + this._update_length(); + return this; + } + index(index) { + var i = 0; + while (i < this.ranges.length && this.ranges[i].length <= index) { + index -= this.ranges[i].length; + i++; + } + return this.ranges[i].low + index; + } + toString() { + return '[ ' + this.ranges.join(', ') + ' ]'; + } + clone() { + return new _DRange(this); + } + numbers() { + return this.ranges.reduce((result, subrange) => { + var i = subrange.low; + while (i <= subrange.high) { + result.push(i); + i++; + } + return result; + }, []); + } + subranges() { + return this.ranges.map((subrange) => ({ + low: subrange.low, + high: subrange.high, + length: 1 + subrange.high - subrange.low, + })); + } + }; + module.exports = DRange; + }, + }); + require_randexp = __commonJS2({ + 'node_modules/randexp/lib/randexp.js'(exports, module) { + var ret = require_lib(); + var DRange = require_lib2(); + var types2 = ret.types; + module.exports = class RandExp2 { + /** + * @constructor + * @param {RegExp|String} regexp + * @param {String} m + */ + constructor(regexp, m) { + this._setDefaults(regexp); + if (regexp instanceof RegExp) { + this.ignoreCase = regexp.ignoreCase; + this.multiline = regexp.multiline; + regexp = regexp.source; + } else if (typeof regexp === 'string') { + this.ignoreCase = m && m.indexOf('i') !== -1; + this.multiline = m && m.indexOf('m') !== -1; + } else { + throw new Error('Expected a regexp or string'); + } + this.tokens = ret(regexp); + } + /** + * Checks if some custom properties have been set for this regexp. + * + * @param {RandExp} randexp + * @param {RegExp} regexp + */ + _setDefaults(regexp) { + this.max = + regexp.max != null ? regexp.max : RandExp2.prototype.max != null ? RandExp2.prototype.max : 100; + this.defaultRange = regexp.defaultRange ? regexp.defaultRange : this.defaultRange.clone(); + if (regexp.randInt) { + this.randInt = regexp.randInt; + } + } + /** + * Generates the random string. + * + * @return {String} + */ + gen() { + return this._gen(this.tokens, []); + } + /** + * Generate random string modeled after given tokens. + * + * @param {Object} token + * @param {Array.} groups + * @return {String} + */ + _gen(token, groups) { + var stack, str, n, i, l; + switch (token.type) { + case types2.ROOT: + case types2.GROUP: + if (token.followedBy || token.notFollowedBy) { + return ''; + } + if (token.remember && token.groupNumber === void 0) { + token.groupNumber = groups.push(null) - 1; + } + stack = token.options ? this._randSelect(token.options) : token.stack; + str = ''; + for (i = 0, l = stack.length; i < l; i++) { + str += this._gen(stack[i], groups); + } + if (token.remember) { + groups[token.groupNumber] = str; + } + return str; + case types2.POSITION: + return ''; + case types2.SET: + var expandedSet = this._expand(token); + if (!expandedSet.length) { + return ''; + } + return String.fromCharCode(this._randSelect(expandedSet)); + case types2.REPETITION: + n = this.randInt(token.min, token.max === Infinity ? token.min + this.max : token.max); + str = ''; + for (i = 0; i < n; i++) { + str += this._gen(token.value, groups); + } + return str; + case types2.REFERENCE: + return groups[token.value - 1] || ''; + case types2.CHAR: + var code = this.ignoreCase && this._randBool() ? this._toOtherCase(token.value) : token.value; + return String.fromCharCode(code); + } + } + /** + * If code is alphabetic, converts to other case. + * If not alphabetic, returns back code. + * + * @param {Number} code + * @return {Number} + */ + _toOtherCase(code) { + return code + (97 <= code && code <= 122 ? -32 : 65 <= code && code <= 90 ? 32 : 0); + } + /** + * Randomly returns a true or false value. + * + * @return {Boolean} + */ + _randBool() { + return !this.randInt(0, 1); + } + /** + * Randomly selects and returns a value from the array. + * + * @param {Array.} arr + * @return {Object} + */ + _randSelect(arr) { + if (arr instanceof DRange) { + return arr.index(this.randInt(0, arr.length - 1)); + } + return arr[this.randInt(0, arr.length - 1)]; + } + /** + * expands a token to a DiscontinuousRange of characters which has a + * length and an index function (for random selecting) + * + * @param {Object} token + * @return {DiscontinuousRange} + */ + _expand(token) { + if (token.type === ret.types.CHAR) { + return new DRange(token.value); + } else if (token.type === ret.types.RANGE) { + return new DRange(token.from, token.to); + } else { + let drange = new DRange(); + for (let i = 0; i < token.set.length; i++) { + let subrange = this._expand(token.set[i]); + drange.add(subrange); + if (this.ignoreCase) { + for (let j = 0; j < subrange.length; j++) { + let code = subrange.index(j); + let otherCaseCode = this._toOtherCase(code); + if (code !== otherCaseCode) { + drange.add(otherCaseCode); + } + } + } + } + if (token.not) { + return this.defaultRange.clone().subtract(drange); + } else { + return this.defaultRange.clone().intersect(drange); + } + } + } + /** + * Randomly generates and returns a number between a and b (inclusive). + * + * @param {Number} a + * @param {Number} b + * @return {Number} + */ + randInt(a, b) { + return a + Math.floor(Math.random() * (1 + b - a)); + } + /** + * Default range of characters to generate from. + */ + get defaultRange() { + return (this._range = this._range || new DRange(32, 126)); + } + set defaultRange(range) { + this._range = range; + } + /** + * + * Enables use of randexp with a shorter call. + * + * @param {RegExp|String| regexp} + * @param {String} m + * @return {String} + */ + static randexp(regexp, m) { + var randexp; + if (typeof regexp === 'string') { + regexp = new RegExp(regexp, m); + } + if (regexp._randexp === void 0) { + randexp = new RandExp2(regexp, m); + regexp._randexp = randexp; + } else { + randexp = regexp._randexp; + randexp._setDefaults(regexp); + } + return randexp.gen(); + } + /** + * Enables sugary /regexp/.gen syntax. + */ + static sugar() { + RegExp.prototype.gen = function () { + return RandExp2.randexp(this); + }; + } + }; + }, + }); + require_PlainValue_ec8e588e = __commonJS2({ + 'node_modules/yaml/dist/PlainValue-ec8e588e.js'(exports) { + 'use strict'; + var Char = { + ANCHOR: '&', + COMMENT: '#', + TAG: '!', + DIRECTIVES_END: '-', + DOCUMENT_END: '.', + }; + var Type = { + ALIAS: 'ALIAS', + BLANK_LINE: 'BLANK_LINE', + BLOCK_FOLDED: 'BLOCK_FOLDED', + BLOCK_LITERAL: 'BLOCK_LITERAL', + COMMENT: 'COMMENT', + DIRECTIVE: 'DIRECTIVE', + DOCUMENT: 'DOCUMENT', + FLOW_MAP: 'FLOW_MAP', + FLOW_SEQ: 'FLOW_SEQ', + MAP: 'MAP', + MAP_KEY: 'MAP_KEY', + MAP_VALUE: 'MAP_VALUE', + PLAIN: 'PLAIN', + QUOTE_DOUBLE: 'QUOTE_DOUBLE', + QUOTE_SINGLE: 'QUOTE_SINGLE', + SEQ: 'SEQ', + SEQ_ITEM: 'SEQ_ITEM', + }; + var defaultTagPrefix = 'tag:yaml.org,2002:'; + var defaultTags = { + MAP: 'tag:yaml.org,2002:map', + SEQ: 'tag:yaml.org,2002:seq', + STR: 'tag:yaml.org,2002:str', + }; + function findLineStarts(src) { + const ls = [0]; + let offset = src.indexOf('\n'); + while (offset !== -1) { + offset += 1; + ls.push(offset); + offset = src.indexOf('\n', offset); + } + return ls; + } + function getSrcInfo(cst) { + let lineStarts, src; + if (typeof cst === 'string') { + lineStarts = findLineStarts(cst); + src = cst; + } else { + if (Array.isArray(cst)) cst = cst[0]; + if (cst && cst.context) { + if (!cst.lineStarts) cst.lineStarts = findLineStarts(cst.context.src); + lineStarts = cst.lineStarts; + src = cst.context.src; + } + } + return { + lineStarts, + src, + }; + } + function getLinePos(offset, cst) { + if (typeof offset !== 'number' || offset < 0) return null; + const { lineStarts, src } = getSrcInfo(cst); + if (!lineStarts || !src || offset > src.length) return null; + for (let i = 0; i < lineStarts.length; ++i) { + const start = lineStarts[i]; + if (offset < start) { + return { + line: i, + col: offset - lineStarts[i - 1] + 1, + }; + } + if (offset === start) + return { + line: i + 1, + col: 1, + }; + } + const line = lineStarts.length; + return { + line, + col: offset - lineStarts[line - 1] + 1, + }; + } + function getLine(line, cst) { + const { lineStarts, src } = getSrcInfo(cst); + if (!lineStarts || !(line >= 1) || line > lineStarts.length) return null; + const start = lineStarts[line - 1]; + let end = lineStarts[line]; + while (end && end > start && src[end - 1] === '\n') --end; + return src.slice(start, end); + } + function getPrettyContext({ start, end }, cst, maxWidth = 80) { + let src = getLine(start.line, cst); + if (!src) return null; + let { col } = start; + if (src.length > maxWidth) { + if (col <= maxWidth - 10) { + src = src.substr(0, maxWidth - 1) + '\u2026'; + } else { + const halfWidth = Math.round(maxWidth / 2); + if (src.length > col + halfWidth) src = src.substr(0, col + halfWidth - 1) + '\u2026'; + col -= src.length - maxWidth; + src = '\u2026' + src.substr(1 - maxWidth); + } + } + let errLen = 1; + let errEnd = ''; + if (end) { + if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) { + errLen = end.col - start.col; + } else { + errLen = Math.min(src.length + 1, maxWidth) - col; + errEnd = '\u2026'; + } + } + const offset = col > 1 ? ' '.repeat(col - 1) : ''; + const err = '^'.repeat(errLen); + return `${src} +${offset}${err}${errEnd}`; + } + var Range = class _Range { + static copy(orig) { + return new _Range(orig.start, orig.end); + } + constructor(start, end) { + this.start = start; + this.end = end || start; + } + isEmpty() { + return typeof this.start !== 'number' || !this.end || this.end <= this.start; + } + /** + * Set `origStart` and `origEnd` to point to the original source range for + * this node, which may differ due to dropped CR characters. + * + * @param {number[]} cr - Positions of dropped CR characters + * @param {number} offset - Starting index of `cr` from the last call + * @returns {number} - The next offset, matching the one found for `origStart` + */ + setOrigRange(cr, offset) { + const { start, end } = this; + if (cr.length === 0 || end <= cr[0]) { + this.origStart = start; + this.origEnd = end; + return offset; + } + let i = offset; + while (i < cr.length) { + if (cr[i] > start) break; + else ++i; + } + this.origStart = start + i; + const nextOffset = i; + while (i < cr.length) { + if (cr[i] >= end) break; + else ++i; + } + this.origEnd = end + i; + return nextOffset; + } + }; + var Node2 = class _Node { + static addStringTerminator(src, offset, str) { + if (str[str.length - 1] === '\n') return str; + const next = _Node.endOfWhiteSpace(src, offset); + return next >= src.length || src[next] === '\n' ? str + '\n' : str; + } + // ^(---|...) + static atDocumentBoundary(src, offset, sep) { + const ch0 = src[offset]; + if (!ch0) return true; + const prev = src[offset - 1]; + if (prev && prev !== '\n') return false; + if (sep) { + if (ch0 !== sep) return false; + } else { + if (ch0 !== Char.DIRECTIVES_END && ch0 !== Char.DOCUMENT_END) return false; + } + const ch1 = src[offset + 1]; + const ch2 = src[offset + 2]; + if (ch1 !== ch0 || ch2 !== ch0) return false; + const ch3 = src[offset + 3]; + return !ch3 || ch3 === '\n' || ch3 === ' ' || ch3 === ' '; + } + static endOfIdentifier(src, offset) { + let ch = src[offset]; + const isVerbatim = ch === '<'; + const notOk = isVerbatim ? ['\n', ' ', ' ', '>'] : ['\n', ' ', ' ', '[', ']', '{', '}', ',']; + while (ch && notOk.indexOf(ch) === -1) ch = src[(offset += 1)]; + if (isVerbatim && ch === '>') offset += 1; + return offset; + } + static endOfIndent(src, offset) { + let ch = src[offset]; + while (ch === ' ') ch = src[(offset += 1)]; + return offset; + } + static endOfLine(src, offset) { + let ch = src[offset]; + while (ch && ch !== '\n') ch = src[(offset += 1)]; + return offset; + } + static endOfWhiteSpace(src, offset) { + let ch = src[offset]; + while (ch === ' ' || ch === ' ') ch = src[(offset += 1)]; + return offset; + } + static startOfLine(src, offset) { + let ch = src[offset - 1]; + if (ch === '\n') return offset; + while (ch && ch !== '\n') ch = src[(offset -= 1)]; + return offset + 1; + } + /** + * End of indentation, or null if the line's indent level is not more + * than `indent` + * + * @param {string} src + * @param {number} indent + * @param {number} lineStart + * @returns {?number} + */ + static endOfBlockIndent(src, indent, lineStart) { + const inEnd = _Node.endOfIndent(src, lineStart); + if (inEnd > lineStart + indent) { + return inEnd; + } else { + const wsEnd = _Node.endOfWhiteSpace(src, inEnd); + const ch = src[wsEnd]; + if (!ch || ch === '\n') return wsEnd; + } + return null; + } + static atBlank(src, offset, endAsBlank) { + const ch = src[offset]; + return ch === '\n' || ch === ' ' || ch === ' ' || (endAsBlank && !ch); + } + static nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) { + if (!ch || indentDiff < 0) return false; + if (indentDiff > 0) return true; + return indicatorAsIndent && ch === '-'; + } + // should be at line or string end, or at next non-whitespace char + static normalizeOffset(src, offset) { + const ch = src[offset]; + return !ch + ? offset + : ch !== '\n' && src[offset - 1] === '\n' + ? offset - 1 + : _Node.endOfWhiteSpace(src, offset); + } + // fold single newline into space, multiple newlines to N - 1 newlines + // presumes src[offset] === '\n' + static foldNewline(src, offset, indent) { + let inCount = 0; + let error = false; + let fold = ''; + let ch = src[offset + 1]; + while (ch === ' ' || ch === ' ' || ch === '\n') { + switch (ch) { + case '\n': + inCount = 0; + offset += 1; + fold += '\n'; + break; + case ' ': + if (inCount <= indent) error = true; + offset = _Node.endOfWhiteSpace(src, offset + 2) - 1; + break; + case ' ': + inCount += 1; + offset += 1; + break; + } + ch = src[offset + 1]; + } + if (!fold) fold = ' '; + if (ch && inCount <= indent) error = true; + return { + fold, + offset, + error, + }; + } + constructor(type, props, context) { + Object.defineProperty(this, 'context', { + value: context || null, + writable: true, + }); + this.error = null; + this.range = null; + this.valueRange = null; + this.props = props || []; + this.type = type; + this.value = null; + } + getPropValue(idx, key, skipKey) { + if (!this.context) return null; + const { src } = this.context; + const prop = this.props[idx]; + return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null; + } + get anchor() { + for (let i = 0; i < this.props.length; ++i) { + const anchor = this.getPropValue(i, Char.ANCHOR, true); + if (anchor != null) return anchor; + } + return null; + } + get comment() { + const comments = []; + for (let i = 0; i < this.props.length; ++i) { + const comment = this.getPropValue(i, Char.COMMENT, true); + if (comment != null) comments.push(comment); + } + return comments.length > 0 ? comments.join('\n') : null; + } + commentHasRequiredWhitespace(start) { + const { src } = this.context; + if (this.header && start === this.header.end) return false; + if (!this.valueRange) return false; + const { end } = this.valueRange; + return start !== end || _Node.atBlank(src, end - 1); + } + get hasComment() { + if (this.context) { + const { src } = this.context; + for (let i = 0; i < this.props.length; ++i) { + if (src[this.props[i].start] === Char.COMMENT) return true; + } + } + return false; + } + get hasProps() { + if (this.context) { + const { src } = this.context; + for (let i = 0; i < this.props.length; ++i) { + if (src[this.props[i].start] !== Char.COMMENT) return true; + } + } + return false; + } + get includesTrailingLines() { + return false; + } + get jsonLike() { + const jsonLikeTypes = [Type.FLOW_MAP, Type.FLOW_SEQ, Type.QUOTE_DOUBLE, Type.QUOTE_SINGLE]; + return jsonLikeTypes.indexOf(this.type) !== -1; + } + get rangeAsLinePos() { + if (!this.range || !this.context) return void 0; + const start = getLinePos(this.range.start, this.context.root); + if (!start) return void 0; + const end = getLinePos(this.range.end, this.context.root); + return { + start, + end, + }; + } + get rawValue() { + if (!this.valueRange || !this.context) return null; + const { start, end } = this.valueRange; + return this.context.src.slice(start, end); + } + get tag() { + for (let i = 0; i < this.props.length; ++i) { + const tag = this.getPropValue(i, Char.TAG, false); + if (tag != null) { + if (tag[1] === '<') { + return { + verbatim: tag.slice(2, -1), + }; + } else { + const [_, handle, suffix] = tag.match(/^(.*!)([^!]*)$/); + return { + handle, + suffix, + }; + } + } + } + return null; + } + get valueRangeContainsNewline() { + if (!this.valueRange || !this.context) return false; + const { start, end } = this.valueRange; + const { src } = this.context; + for (let i = start; i < end; ++i) { + if (src[i] === '\n') return true; + } + return false; + } + parseComment(start) { + const { src } = this.context; + if (src[start] === Char.COMMENT) { + const end = _Node.endOfLine(src, start + 1); + const commentRange = new Range(start, end); + this.props.push(commentRange); + return end; + } + return start; + } + /** + * Populates the `origStart` and `origEnd` values of all ranges for this + * node. Extended by child classes to handle descendant nodes. + * + * @param {number[]} cr - Positions of dropped CR characters + * @param {number} offset - Starting index of `cr` from the last call + * @returns {number} - The next offset, matching the one found for `origStart` + */ + setOrigRanges(cr, offset) { + if (this.range) offset = this.range.setOrigRange(cr, offset); + if (this.valueRange) this.valueRange.setOrigRange(cr, offset); + this.props.forEach((prop) => prop.setOrigRange(cr, offset)); + return offset; + } + toString() { + const { + context: { src }, + range, + value, + } = this; + if (value != null) return value; + const str = src.slice(range.start, range.end); + return _Node.addStringTerminator(src, range.end, str); + } + }; + var YAMLError = class extends Error { + constructor(name, source, message) { + if (!message || !(source instanceof Node2)) throw new Error(`Invalid arguments for new ${name}`); + super(); + this.name = name; + this.message = message; + this.source = source; + } + makePretty() { + if (!this.source) return; + this.nodeType = this.source.type; + const cst = this.source.context && this.source.context.root; + if (typeof this.offset === 'number') { + this.range = new Range(this.offset, this.offset + 1); + const start = cst && getLinePos(this.offset, cst); + if (start) { + const end = { + line: start.line, + col: start.col + 1, + }; + this.linePos = { + start, + end, + }; + } + delete this.offset; + } else { + this.range = this.source.range; + this.linePos = this.source.rangeAsLinePos; + } + if (this.linePos) { + const { line, col } = this.linePos.start; + this.message += ` at line ${line}, column ${col}`; + const ctx = cst && getPrettyContext(this.linePos, cst); + if (ctx) + this.message += `: + +${ctx} +`; + } + delete this.source; + } + }; + var YAMLReferenceError = class extends YAMLError { + constructor(source, message) { + super('YAMLReferenceError', source, message); + } + }; + var YAMLSemanticError = class extends YAMLError { + constructor(source, message) { + super('YAMLSemanticError', source, message); + } + }; + var YAMLSyntaxError = class extends YAMLError { + constructor(source, message) { + super('YAMLSyntaxError', source, message); + } + }; + var YAMLWarning = class extends YAMLError { + constructor(source, message) { + super('YAMLWarning', source, message); + } + }; + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; + } + var PlainValue = class _PlainValue extends Node2 { + static endOfLine(src, start, inFlow) { + let ch = src[start]; + let offset = start; + while (ch && ch !== '\n') { + if (inFlow && (ch === '[' || ch === ']' || ch === '{' || ch === '}' || ch === ',')) break; + const next = src[offset + 1]; + if (ch === ':' && (!next || next === '\n' || next === ' ' || next === ' ' || (inFlow && next === ','))) + break; + if ((ch === ' ' || ch === ' ') && next === '#') break; + offset += 1; + ch = next; + } + return offset; + } + get strValue() { + if (!this.valueRange || !this.context) return null; + let { start, end } = this.valueRange; + const { src } = this.context; + let ch = src[end - 1]; + while (start < end && (ch === '\n' || ch === ' ' || ch === ' ')) ch = src[--end - 1]; + let str = ''; + for (let i = start; i < end; ++i) { + const ch2 = src[i]; + if (ch2 === '\n') { + const { fold, offset } = Node2.foldNewline(src, i, -1); + str += fold; + i = offset; + } else if (ch2 === ' ' || ch2 === ' ') { + const wsStart = i; + let next = src[i + 1]; + while (i < end && (next === ' ' || next === ' ')) { + i += 1; + next = src[i + 1]; + } + if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch2; + } else { + str += ch2; + } + } + const ch0 = src[start]; + switch (ch0) { + case ' ': { + const msg = 'Plain value cannot start with a tab character'; + const errors = [new YAMLSemanticError(this, msg)]; + return { + errors, + str, + }; + } + case '@': + case '`': { + const msg = `Plain value cannot start with reserved character ${ch0}`; + const errors = [new YAMLSemanticError(this, msg)]; + return { + errors, + str, + }; + } + default: + return str; + } + } + parseBlockValue(start) { + const { indent, inFlow, src } = this.context; + let offset = start; + let valueEnd = start; + for (let ch = src[offset]; ch === '\n'; ch = src[offset]) { + if (Node2.atDocumentBoundary(src, offset + 1)) break; + const end = Node2.endOfBlockIndent(src, indent, offset + 1); + if (end === null || src[end] === '#') break; + if (src[end] === '\n') { + offset = end; + } else { + valueEnd = _PlainValue.endOfLine(src, end, inFlow); + offset = valueEnd; + } + } + if (this.valueRange.isEmpty()) this.valueRange.start = start; + this.valueRange.end = valueEnd; + return valueEnd; + } + /** + * Parses a plain value from the source + * + * Accepted forms are: + * ``` + * #comment + * + * first line + * + * first line #comment + * + * first line + * block + * lines + * + * #comment + * block + * lines + * ``` + * where block lines are empty or have an indent level greater than `indent`. + * + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this scalar, may be `\n` + */ + parse(context, start) { + this.context = context; + const { inFlow, src } = context; + let offset = start; + const ch = src[offset]; + if (ch && ch !== '#' && ch !== '\n') { + offset = _PlainValue.endOfLine(src, start, inFlow); + } + this.valueRange = new Range(start, offset); + offset = Node2.endOfWhiteSpace(src, offset); + offset = this.parseComment(offset); + if (!this.hasComment || this.valueRange.isEmpty()) { + offset = this.parseBlockValue(offset); + } + return offset; + } + }; + exports.Char = Char; + exports.Node = Node2; + exports.PlainValue = PlainValue; + exports.Range = Range; + exports.Type = Type; + exports.YAMLError = YAMLError; + exports.YAMLReferenceError = YAMLReferenceError; + exports.YAMLSemanticError = YAMLSemanticError; + exports.YAMLSyntaxError = YAMLSyntaxError; + exports.YAMLWarning = YAMLWarning; + exports._defineProperty = _defineProperty; + exports.defaultTagPrefix = defaultTagPrefix; + exports.defaultTags = defaultTags; + }, + }); + require_resolveSeq_d03cb037 = __commonJS2({ + 'node_modules/yaml/dist/resolveSeq-d03cb037.js'(exports) { + 'use strict'; + var PlainValue = require_PlainValue_ec8e588e(); + function addCommentBefore(str, indent, comment) { + if (!comment) return str; + const cc = comment.replace(/[\s\S]^/gm, `$&${indent}#`); + return `#${cc} +${indent}${str}`; + } + function addComment(str, indent, comment) { + return !comment + ? str + : comment.indexOf('\n') === -1 + ? `${str} #${comment}` + : `${str} +` + comment.replace(/^/gm, `${indent || ''}#`); + } + var Node2 = class {}; + function toJSON(value, arg, ctx) { + if (Array.isArray(value)) return value.map((v, i) => toJSON(v, String(i), ctx)); + if (value && typeof value.toJSON === 'function') { + const anchor = ctx && ctx.anchors && ctx.anchors.get(value); + if (anchor) + ctx.onCreate = (res2) => { + anchor.res = res2; + delete ctx.onCreate; + }; + const res = value.toJSON(arg, ctx); + if (anchor && ctx.onCreate) ctx.onCreate(res); + return res; + } + if ((!ctx || !ctx.keep) && typeof value === 'bigint') return Number(value); + return value; + } + var Scalar2 = class extends Node2 { + constructor(value) { + super(); + this.value = value; + } + toJSON(arg, ctx) { + return ctx && ctx.keep ? this.value : toJSON(this.value, arg, ctx); + } + toString() { + return String(this.value); + } + }; + function collectionFromPath(schema, path, value) { + let v = value; + for (let i = path.length - 1; i >= 0; --i) { + const k = path[i]; + if (Number.isInteger(k) && k >= 0) { + const a = []; + a[k] = v; + v = a; + } else { + const o = {}; + Object.defineProperty(o, k, { + value: v, + writable: true, + enumerable: true, + configurable: true, + }); + v = o; + } + } + return schema.createNode(v, false); + } + var isEmptyPath = (path) => path == null || (typeof path === 'object' && path[Symbol.iterator]().next().done); + var Collection2 = class _Collection extends Node2 { + constructor(schema) { + super(); + PlainValue._defineProperty(this, 'items', []); + this.schema = schema; + } + addIn(path, value) { + if (isEmptyPath(path)) this.add(value); + else { + const [key, ...rest] = path; + const node = this.get(key, true); + if (node instanceof _Collection) node.addIn(rest, value); + else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value)); + else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } + deleteIn([key, ...rest]) { + if (rest.length === 0) return this.delete(key); + const node = this.get(key, true); + if (node instanceof _Collection) return node.deleteIn(rest); + else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + getIn([key, ...rest], keepScalar) { + const node = this.get(key, true); + if (rest.length === 0) return !keepScalar && node instanceof Scalar2 ? node.value : node; + else return node instanceof _Collection ? node.getIn(rest, keepScalar) : void 0; + } + hasAllNullValues() { + return this.items.every((node) => { + if (!node || node.type !== 'PAIR') return false; + const n = node.value; + return ( + n == null || (n instanceof Scalar2 && n.value == null && !n.commentBefore && !n.comment && !n.tag) + ); + }); + } + hasIn([key, ...rest]) { + if (rest.length === 0) return this.has(key); + const node = this.get(key, true); + return node instanceof _Collection ? node.hasIn(rest) : false; + } + setIn([key, ...rest], value) { + if (rest.length === 0) { + this.set(key, value); + } else { + const node = this.get(key, true); + if (node instanceof _Collection) node.setIn(rest, value); + else if (node === void 0 && this.schema) this.set(key, collectionFromPath(this.schema, rest, value)); + else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } + // overridden in implementations + /* istanbul ignore next */ + toJSON() { + return null; + } + toString(ctx, { blockItem, flowChars, isMap, itemIndent }, onComment, onChompKeep) { + const { indent, indentStep, stringify } = ctx; + const inFlow = + this.type === PlainValue.Type.FLOW_MAP || this.type === PlainValue.Type.FLOW_SEQ || ctx.inFlow; + if (inFlow) itemIndent += indentStep; + const allNullValues = isMap && this.hasAllNullValues(); + ctx = Object.assign({}, ctx, { + allNullValues, + indent: itemIndent, + inFlow, + type: null, + }); + let chompKeep = false; + let hasItemWithNewLine = false; + const nodes = this.items.reduce((nodes2, item, i) => { + let comment; + if (item) { + if (!chompKeep && item.spaceBefore) + nodes2.push({ + type: 'comment', + str: '', + }); + if (item.commentBefore) + item.commentBefore.match(/^.*$/gm).forEach((line) => { + nodes2.push({ + type: 'comment', + str: `#${line}`, + }); + }); + if (item.comment) comment = item.comment; + if ( + inFlow && + ((!chompKeep && item.spaceBefore) || + item.commentBefore || + item.comment || + (item.key && (item.key.commentBefore || item.key.comment)) || + (item.value && (item.value.commentBefore || item.value.comment))) + ) + hasItemWithNewLine = true; + } + chompKeep = false; + let str2 = stringify( + item, + ctx, + () => (comment = null), + () => (chompKeep = true) + ); + if (inFlow && !hasItemWithNewLine && str2.includes('\n')) hasItemWithNewLine = true; + if (inFlow && i < this.items.length - 1) str2 += ','; + str2 = addComment(str2, itemIndent, comment); + if (chompKeep && (comment || inFlow)) chompKeep = false; + nodes2.push({ + type: 'item', + str: str2, + }); + return nodes2; + }, []); + let str; + if (nodes.length === 0) { + str = flowChars.start + flowChars.end; + } else if (inFlow) { + const { start, end } = flowChars; + const strings = nodes.map((n) => n.str); + if ( + hasItemWithNewLine || + strings.reduce((sum, str2) => sum + str2.length + 2, 2) > _Collection.maxFlowStringSingleLineLength + ) { + str = start; + for (const s of strings) { + str += s + ? ` +${indentStep}${indent}${s}` + : '\n'; + } + str += ` +${indent}${end}`; + } else { + str = `${start} ${strings.join(' ')} ${end}`; + } + } else { + const strings = nodes.map(blockItem); + str = strings.shift(); + for (const s of strings) + str += s + ? ` +${indent}${s}` + : '\n'; + } + if (this.comment) { + str += '\n' + this.comment.replace(/^/gm, `${indent}#`); + if (onComment) onComment(); + } else if (chompKeep && onChompKeep) onChompKeep(); + return str; + } + }; + PlainValue._defineProperty(Collection2, 'maxFlowStringSingleLineLength', 60); + function asItemIndex(key) { + let idx = key instanceof Scalar2 ? key.value : key; + if (idx && typeof idx === 'string') idx = Number(idx); + return Number.isInteger(idx) && idx >= 0 ? idx : null; + } + var YAMLSeq2 = class extends Collection2 { + add(value) { + this.items.push(value); + } + delete(key) { + const idx = asItemIndex(key); + if (typeof idx !== 'number') return false; + const del = this.items.splice(idx, 1); + return del.length > 0; + } + get(key, keepScalar) { + const idx = asItemIndex(key); + if (typeof idx !== 'number') return void 0; + const it = this.items[idx]; + return !keepScalar && it instanceof Scalar2 ? it.value : it; + } + has(key) { + const idx = asItemIndex(key); + return typeof idx === 'number' && idx < this.items.length; + } + set(key, value) { + const idx = asItemIndex(key); + if (typeof idx !== 'number') throw new Error(`Expected a valid index, not ${key}.`); + this.items[idx] = value; + } + toJSON(_, ctx) { + const seq = []; + if (ctx && ctx.onCreate) ctx.onCreate(seq); + let i = 0; + for (const item of this.items) seq.push(toJSON(item, String(i++), ctx)); + return seq; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) return JSON.stringify(this); + return super.toString( + ctx, + { + blockItem: (n) => (n.type === 'comment' ? n.str : `- ${n.str}`), + flowChars: { + start: '[', + end: ']', + }, + isMap: false, + itemIndent: (ctx.indent || '') + ' ', + }, + onComment, + onChompKeep + ); + } + }; + var stringifyKey = (key, jsKey, ctx) => { + if (jsKey === null) return ''; + if (typeof jsKey !== 'object') return String(jsKey); + if (key instanceof Node2 && ctx && ctx.doc) + return key.toString({ + anchors: /* @__PURE__ */ Object.create(null), + doc: ctx.doc, + indent: '', + indentStep: ctx.indentStep, + inFlow: true, + inStringifyKey: true, + stringify: ctx.stringify, + }); + return JSON.stringify(jsKey); + }; + var Pair2 = class _Pair extends Node2 { + constructor(key, value = null) { + super(); + this.key = key; + this.value = value; + this.type = _Pair.Type.PAIR; + } + get commentBefore() { + return this.key instanceof Node2 ? this.key.commentBefore : void 0; + } + set commentBefore(cb) { + if (this.key == null) this.key = new Scalar2(null); + if (this.key instanceof Node2) this.key.commentBefore = cb; + else { + const msg = + 'Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.'; + throw new Error(msg); + } + } + addToJSMap(ctx, map) { + const key = toJSON(this.key, '', ctx); + if (map instanceof Map) { + const value = toJSON(this.value, key, ctx); + map.set(key, value); + } else if (map instanceof Set) { + map.add(key); + } else { + const stringKey = stringifyKey(this.key, key, ctx); + const value = toJSON(this.value, stringKey, ctx); + if (stringKey in map) + Object.defineProperty(map, stringKey, { + value, + writable: true, + enumerable: true, + configurable: true, + }); + else map[stringKey] = value; + } + return map; + } + toJSON(_, ctx) { + const pair = ctx && ctx.mapAsMap ? /* @__PURE__ */ new Map() : {}; + return this.addToJSMap(ctx, pair); + } + toString(ctx, onComment, onChompKeep) { + if (!ctx || !ctx.doc) return JSON.stringify(this); + const { indent: indentSize, indentSeq, simpleKeys } = ctx.doc.options; + let { key, value } = this; + let keyComment = key instanceof Node2 && key.comment; + if (simpleKeys) { + if (keyComment) { + throw new Error('With simple keys, key nodes cannot have comments'); + } + if (key instanceof Collection2) { + const msg = 'With simple keys, collection cannot be used as a key value'; + throw new Error(msg); + } + } + let explicitKey = + !simpleKeys && + (!key || + keyComment || + (key instanceof Node2 + ? key instanceof Collection2 || + key.type === PlainValue.Type.BLOCK_FOLDED || + key.type === PlainValue.Type.BLOCK_LITERAL + : typeof key === 'object')); + const { doc, indent, indentStep, stringify } = ctx; + ctx = Object.assign({}, ctx, { + implicitKey: !explicitKey, + indent: indent + indentStep, + }); + let chompKeep = false; + let str = stringify( + key, + ctx, + () => (keyComment = null), + () => (chompKeep = true) + ); + str = addComment(str, ctx.indent, keyComment); + if (!explicitKey && str.length > 1024) { + if (simpleKeys) + throw new Error('With simple keys, single line scalar must not span more than 1024 characters'); + explicitKey = true; + } + if (ctx.allNullValues && !simpleKeys) { + if (this.comment) { + str = addComment(str, ctx.indent, this.comment); + if (onComment) onComment(); + } else if (chompKeep && !keyComment && onChompKeep) onChompKeep(); + return ctx.inFlow && !explicitKey ? str : `? ${str}`; + } + str = explicitKey + ? `? ${str} +${indent}:` + : `${str}:`; + if (this.comment) { + str = addComment(str, ctx.indent, this.comment); + if (onComment) onComment(); + } + let vcb = ''; + let valueComment = null; + if (value instanceof Node2) { + if (value.spaceBefore) vcb = '\n'; + if (value.commentBefore) { + const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`); + vcb += ` +${cs}`; + } + valueComment = value.comment; + } else if (value && typeof value === 'object') { + value = doc.schema.createNode(value, true); + } + ctx.implicitKey = false; + if (!explicitKey && !this.comment && value instanceof Scalar2) ctx.indentAtStart = str.length + 1; + chompKeep = false; + if ( + !indentSeq && + indentSize >= 2 && + !ctx.inFlow && + !explicitKey && + value instanceof YAMLSeq2 && + value.type !== PlainValue.Type.FLOW_SEQ && + !value.tag && + !doc.anchors.getName(value) + ) { + ctx.indent = ctx.indent.substr(2); + } + const valueStr = stringify( + value, + ctx, + () => (valueComment = null), + () => (chompKeep = true) + ); + let ws = ' '; + if (vcb || this.comment) { + ws = `${vcb} +${ctx.indent}`; + } else if (!explicitKey && value instanceof Collection2) { + const flow = valueStr[0] === '[' || valueStr[0] === '{'; + if (!flow || valueStr.includes('\n')) + ws = ` +${ctx.indent}`; + } else if (valueStr[0] === '\n') ws = ''; + if (chompKeep && !valueComment && onChompKeep) onChompKeep(); + return addComment(str + ws + valueStr, ctx.indent, valueComment); + } + }; + PlainValue._defineProperty(Pair2, 'Type', { + PAIR: 'PAIR', + MERGE_PAIR: 'MERGE_PAIR', + }); + var getAliasCount = (node, anchors) => { + if (node instanceof Alias2) { + const anchor = anchors.get(node.source); + return anchor.count * anchor.aliasCount; + } else if (node instanceof Collection2) { + let count = 0; + for (const item of node.items) { + const c = getAliasCount(item, anchors); + if (c > count) count = c; + } + return count; + } else if (node instanceof Pair2) { + const kc = getAliasCount(node.key, anchors); + const vc = getAliasCount(node.value, anchors); + return Math.max(kc, vc); + } + return 1; + }; + var Alias2 = class _Alias extends Node2 { + static stringify({ range, source }, { anchors, doc, implicitKey, inStringifyKey }) { + let anchor = Object.keys(anchors).find((a) => anchors[a] === source); + if (!anchor && inStringifyKey) anchor = doc.anchors.getName(source) || doc.anchors.newName(); + if (anchor) return `*${anchor}${implicitKey ? ' ' : ''}`; + const msg = doc.anchors.getName(source) + ? 'Alias node must be after source node' + : 'Source node not found for alias node'; + throw new Error(`${msg} [${range}]`); + } + constructor(source) { + super(); + this.source = source; + this.type = PlainValue.Type.ALIAS; + } + set tag(t) { + throw new Error('Alias nodes cannot have tags'); + } + toJSON(arg, ctx) { + if (!ctx) return toJSON(this.source, arg, ctx); + const { anchors, maxAliasCount } = ctx; + const anchor = anchors.get(this.source); + if (!anchor || anchor.res === void 0) { + const msg = 'This should not happen: Alias anchor was not resolved?'; + if (this.cstNode) throw new PlainValue.YAMLReferenceError(this.cstNode, msg); + else throw new ReferenceError(msg); + } + if (maxAliasCount >= 0) { + anchor.count += 1; + if (anchor.aliasCount === 0) anchor.aliasCount = getAliasCount(this.source, anchors); + if (anchor.count * anchor.aliasCount > maxAliasCount) { + const msg = 'Excessive alias count indicates a resource exhaustion attack'; + if (this.cstNode) throw new PlainValue.YAMLReferenceError(this.cstNode, msg); + else throw new ReferenceError(msg); + } + } + return anchor.res; + } + // Only called when stringifying an alias mapping key while constructing + // Object output. + toString(ctx) { + return _Alias.stringify(this, ctx); + } + }; + PlainValue._defineProperty(Alias2, 'default', true); + function findPair(items, key) { + const k = key instanceof Scalar2 ? key.value : key; + for (const it of items) { + if (it instanceof Pair2) { + if (it.key === key || it.key === k) return it; + if (it.key && it.key.value === k) return it; + } + } + return void 0; + } + var YAMLMap2 = class extends Collection2 { + add(pair, overwrite) { + if (!pair) pair = new Pair2(pair); + else if (!(pair instanceof Pair2)) pair = new Pair2(pair.key || pair, pair.value); + const prev = findPair(this.items, pair.key); + const sortEntries = this.schema && this.schema.sortMapEntries; + if (prev) { + if (overwrite) prev.value = pair.value; + else throw new Error(`Key ${pair.key} already set`); + } else if (sortEntries) { + const i = this.items.findIndex((item) => sortEntries(pair, item) < 0); + if (i === -1) this.items.push(pair); + else this.items.splice(i, 0, pair); + } else { + this.items.push(pair); + } + } + delete(key) { + const it = findPair(this.items, key); + if (!it) return false; + const del = this.items.splice(this.items.indexOf(it), 1); + return del.length > 0; + } + get(key, keepScalar) { + const it = findPair(this.items, key); + const node = it && it.value; + return !keepScalar && node instanceof Scalar2 ? node.value : node; + } + has(key) { + return !!findPair(this.items, key); + } + set(key, value) { + this.add(new Pair2(key, value), true); + } + /** + * @param {*} arg ignored + * @param {*} ctx Conversion context, originally set in Document#toJSON() + * @param {Class} Type If set, forces the returned collection type + * @returns {*} Instance of Type, Map, or Object + */ + toJSON(_, ctx, Type) { + const map = Type ? new Type() : ctx && ctx.mapAsMap ? /* @__PURE__ */ new Map() : {}; + if (ctx && ctx.onCreate) ctx.onCreate(map); + for (const item of this.items) item.addToJSMap(ctx, map); + return map; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) return JSON.stringify(this); + for (const item of this.items) { + if (!(item instanceof Pair2)) + throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`); + } + return super.toString( + ctx, + { + blockItem: (n) => n.str, + flowChars: { + start: '{', + end: '}', + }, + isMap: true, + itemIndent: ctx.indent || '', + }, + onComment, + onChompKeep + ); + } + }; + var MERGE_KEY = '<<'; + var Merge2 = class extends Pair2 { + constructor(pair) { + if (pair instanceof Pair2) { + let seq = pair.value; + if (!(seq instanceof YAMLSeq2)) { + seq = new YAMLSeq2(); + seq.items.push(pair.value); + seq.range = pair.value.range; + } + super(pair.key, seq); + this.range = pair.range; + } else { + super(new Scalar2(MERGE_KEY), new YAMLSeq2()); + } + this.type = Pair2.Type.MERGE_PAIR; + } + // If the value associated with a merge key is a single mapping node, each of + // its key/value pairs is inserted into the current mapping, unless the key + // already exists in it. If the value associated with the merge key is a + // sequence, then this sequence is expected to contain mapping nodes and each + // of these nodes is merged in turn according to its order in the sequence. + // Keys in mapping nodes earlier in the sequence override keys specified in + // later mapping nodes. -- http://yaml.org/type/merge.html + addToJSMap(ctx, map) { + for (const { source } of this.value.items) { + if (!(source instanceof YAMLMap2)) throw new Error('Merge sources must be maps'); + const srcMap = source.toJSON(null, ctx, Map); + for (const [key, value] of srcMap) { + if (map instanceof Map) { + if (!map.has(key)) map.set(key, value); + } else if (map instanceof Set) { + map.add(key); + } else if (!Object.prototype.hasOwnProperty.call(map, key)) { + Object.defineProperty(map, key, { + value, + writable: true, + enumerable: true, + configurable: true, + }); + } + } + } + return map; + } + toString(ctx, onComment) { + const seq = this.value; + if (seq.items.length > 1) return super.toString(ctx, onComment); + this.value = seq.items[0]; + const str = super.toString(ctx, onComment); + this.value = seq; + return str; + } + }; + var binaryOptions2 = { + defaultType: PlainValue.Type.BLOCK_LITERAL, + lineWidth: 76, + }; + var boolOptions2 = { + trueStr: 'true', + falseStr: 'false', + }; + var intOptions2 = { + asBigInt: false, + }; + var nullOptions2 = { + nullStr: 'null', + }; + var strOptions2 = { + defaultType: PlainValue.Type.PLAIN, + doubleQuoted: { + jsonEncoding: false, + minMultiLineLength: 40, + }, + fold: { + lineWidth: 80, + minContentWidth: 20, + }, + }; + function resolveScalar(str, tags, scalarFallback) { + for (const { format, test, resolve: resolve2 } of tags) { + if (test) { + const match = str.match(test); + if (match) { + let res = resolve2.apply(null, match); + if (!(res instanceof Scalar2)) res = new Scalar2(res); + if (format) res.format = format; + return res; + } + } + } + if (scalarFallback) str = scalarFallback(str); + return new Scalar2(str); + } + var FOLD_FLOW = 'flow'; + var FOLD_BLOCK = 'block'; + var FOLD_QUOTED = 'quoted'; + var consumeMoreIndentedLines = (text, i) => { + let ch = text[i + 1]; + while (ch === ' ' || ch === ' ') { + do { + ch = text[(i += 1)]; + } while (ch && ch !== '\n'); + ch = text[i + 1]; + } + return i; + }; + function foldFlowLines( + text, + indent, + mode, + { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } + ) { + if (!lineWidth || lineWidth < 0) return text; + const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length); + if (text.length <= endStep) return text; + const folds = []; + const escapedFolds = {}; + let end = lineWidth - indent.length; + if (typeof indentAtStart === 'number') { + if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0); + else end = lineWidth - indentAtStart; + } + let split = void 0; + let prev = void 0; + let overflow = false; + let i = -1; + let escStart = -1; + let escEnd = -1; + if (mode === FOLD_BLOCK) { + i = consumeMoreIndentedLines(text, i); + if (i !== -1) end = i + endStep; + } + for (let ch; (ch = text[(i += 1)]); ) { + if (mode === FOLD_QUOTED && ch === '\\') { + escStart = i; + switch (text[i + 1]) { + case 'x': + i += 3; + break; + case 'u': + i += 5; + break; + case 'U': + i += 9; + break; + default: + i += 1; + } + escEnd = i; + } + if (ch === '\n') { + if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i); + end = i + endStep; + split = void 0; + } else { + if (ch === ' ' && prev && prev !== ' ' && prev !== '\n' && prev !== ' ') { + const next = text[i + 1]; + if (next && next !== ' ' && next !== '\n' && next !== ' ') split = i; + } + if (i >= end) { + if (split) { + folds.push(split); + end = split + endStep; + split = void 0; + } else if (mode === FOLD_QUOTED) { + while (prev === ' ' || prev === ' ') { + prev = ch; + ch = text[(i += 1)]; + overflow = true; + } + const j = i > escEnd + 1 ? i - 2 : escStart - 1; + if (escapedFolds[j]) return text; + folds.push(j); + escapedFolds[j] = true; + end = j + endStep; + split = void 0; + } else { + overflow = true; + } + } + } + prev = ch; + } + if (overflow && onOverflow) onOverflow(); + if (folds.length === 0) return text; + if (onFold) onFold(); + let res = text.slice(0, folds[0]); + for (let i2 = 0; i2 < folds.length; ++i2) { + const fold = folds[i2]; + const end2 = folds[i2 + 1] || text.length; + if (fold === 0) + res = ` +${indent}${text.slice(0, end2)}`; + else { + if (mode === FOLD_QUOTED && escapedFolds[fold]) res += `${text[fold]}\\`; + res += ` +${indent}${text.slice(fold + 1, end2)}`; + } + } + return res; + } + var getFoldOptions = ({ indentAtStart }) => + indentAtStart + ? Object.assign( + { + indentAtStart, + }, + strOptions2.fold + ) + : strOptions2.fold; + var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str); + function lineLengthOverLimit(str, lineWidth, indentLength) { + if (!lineWidth || lineWidth < 0) return false; + const limit = lineWidth - indentLength; + const strLen = str.length; + if (strLen <= limit) return false; + for (let i = 0, start = 0; i < strLen; ++i) { + if (str[i] === '\n') { + if (i - start > limit) return true; + start = i + 1; + if (strLen - start <= limit) return false; + } + } + return true; + } + function doubleQuotedString(value, ctx) { + const { implicitKey } = ctx; + const { jsonEncoding, minMultiLineLength } = strOptions2.doubleQuoted; + const json = JSON.stringify(value); + if (jsonEncoding) return json; + const indent = ctx.indent || (containsDocumentMarker(value) ? ' ' : ''); + let str = ''; + let start = 0; + for (let i = 0, ch = json[i]; ch; ch = json[++i]) { + if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') { + str += json.slice(start, i) + '\\ '; + i += 1; + start = i; + ch = '\\'; + } + if (ch === '\\') + switch (json[i + 1]) { + case 'u': + { + str += json.slice(start, i); + const code = json.substr(i + 2, 4); + switch (code) { + case '0000': + str += '\\0'; + break; + case '0007': + str += '\\a'; + break; + case '000b': + str += '\\v'; + break; + case '001b': + str += '\\e'; + break; + case '0085': + str += '\\N'; + break; + case '00a0': + str += '\\_'; + break; + case '2028': + str += '\\L'; + break; + case '2029': + str += '\\P'; + break; + default: + if (code.substr(0, 2) === '00') str += '\\x' + code.substr(2); + else str += json.substr(i, 6); + } + i += 5; + start = i + 1; + } + break; + case 'n': + if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) { + i += 1; + } else { + str += json.slice(start, i) + '\n\n'; + while (json[i + 2] === '\\' && json[i + 3] === 'n' && json[i + 4] !== '"') { + str += '\n'; + i += 2; + } + str += indent; + if (json[i + 2] === ' ') str += '\\'; + i += 1; + start = i + 1; + } + break; + default: + i += 1; + } + } + str = start ? str + json.slice(start) : json; + return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx)); + } + function singleQuotedString(value, ctx) { + if (ctx.implicitKey) { + if (/\n/.test(value)) return doubleQuotedString(value, ctx); + } else { + if (/[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx); + } + const indent = ctx.indent || (containsDocumentMarker(value) ? ' ' : ''); + const res = + "'" + + value.replace(/'/g, "''").replace( + /\n+/g, + `$& +${indent}` + ) + + "'"; + return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx)); + } + function blockString({ comment, type, value }, ctx, onComment, onChompKeep) { + if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) { + return doubleQuotedString(value, ctx); + } + const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? ' ' : ''); + const indentSize = indent ? '2' : '1'; + const literal = + type === PlainValue.Type.BLOCK_FOLDED + ? false + : type === PlainValue.Type.BLOCK_LITERAL + ? true + : !lineLengthOverLimit(value, strOptions2.fold.lineWidth, indent.length); + let header = literal ? '|' : '>'; + if (!value) return header + '\n'; + let wsStart = ''; + let wsEnd = ''; + value = value + .replace(/[\n\t ]*$/, (ws) => { + const n = ws.indexOf('\n'); + if (n === -1) { + header += '-'; + } else if (value === ws || n !== ws.length - 1) { + header += '+'; + if (onChompKeep) onChompKeep(); + } + wsEnd = ws.replace(/\n$/, ''); + return ''; + }) + .replace(/^[\n ]*/, (ws) => { + if (ws.indexOf(' ') !== -1) header += indentSize; + const m = ws.match(/ +$/); + if (m) { + wsStart = ws.slice(0, -m[0].length); + return m[0]; + } else { + wsStart = ws; + return ''; + } + }); + if (wsEnd) wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`); + if (wsStart) wsStart = wsStart.replace(/\n+/g, `$&${indent}`); + if (comment) { + header += ' #' + comment.replace(/ ?[\r\n]+/g, ' '); + if (onComment) onComment(); + } + if (!value) + return `${header}${indentSize} +${indent}${wsEnd}`; + if (literal) { + value = value.replace(/\n+/g, `$&${indent}`); + return `${header} +${indent}${wsStart}${value}${wsEnd}`; + } + value = value + .replace(/\n+/g, '\n$&') + .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') + .replace(/\n+/g, `$&${indent}`); + const body = foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, FOLD_BLOCK, strOptions2.fold); + return `${header} +${indent}${body}`; + } + function plainString(item, ctx, onComment, onChompKeep) { + const { comment, type, value } = item; + const { actualString, implicitKey, indent, inFlow } = ctx; + if ((implicitKey && /[\n[\]{},]/.test(value)) || (inFlow && /[[\]{},]/.test(value))) { + return doubleQuotedString(value, ctx); + } + if ( + !value || + /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value) + ) { + return implicitKey || inFlow || value.indexOf('\n') === -1 + ? value.indexOf('"') !== -1 && value.indexOf("'") === -1 + ? singleQuotedString(value, ctx) + : doubleQuotedString(value, ctx) + : blockString(item, ctx, onComment, onChompKeep); + } + if (!implicitKey && !inFlow && type !== PlainValue.Type.PLAIN && value.indexOf('\n') !== -1) { + return blockString(item, ctx, onComment, onChompKeep); + } + if (indent === '' && containsDocumentMarker(value)) { + ctx.forceBlockIndent = true; + return blockString(item, ctx, onComment, onChompKeep); + } + const str = value.replace( + /\n+/g, + `$& +${indent}` + ); + if (actualString) { + const { tags } = ctx.doc.schema; + const resolved = resolveScalar(str, tags, tags.scalarFallback).value; + if (typeof resolved !== 'string') return doubleQuotedString(value, ctx); + } + const body = implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx)); + if (comment && !inFlow && (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) { + if (onComment) onComment(); + return addCommentBefore(body, indent, comment); + } + return body; + } + function stringifyString(item, ctx, onComment, onChompKeep) { + const { defaultType } = strOptions2; + const { implicitKey, inFlow } = ctx; + let { type, value } = item; + if (typeof value !== 'string') { + value = String(value); + item = Object.assign({}, item, { + value, + }); + } + const _stringify = (_type) => { + switch (_type) { + case PlainValue.Type.BLOCK_FOLDED: + case PlainValue.Type.BLOCK_LITERAL: + return blockString(item, ctx, onComment, onChompKeep); + case PlainValue.Type.QUOTE_DOUBLE: + return doubleQuotedString(value, ctx); + case PlainValue.Type.QUOTE_SINGLE: + return singleQuotedString(value, ctx); + case PlainValue.Type.PLAIN: + return plainString(item, ctx, onComment, onChompKeep); + default: + return null; + } + }; + if (type !== PlainValue.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) { + type = PlainValue.Type.QUOTE_DOUBLE; + } else if ( + (implicitKey || inFlow) && + (type === PlainValue.Type.BLOCK_FOLDED || type === PlainValue.Type.BLOCK_LITERAL) + ) { + type = PlainValue.Type.QUOTE_DOUBLE; + } + let res = _stringify(type); + if (res === null) { + res = _stringify(defaultType); + if (res === null) throw new Error(`Unsupported default string type ${defaultType}`); + } + return res; + } + function stringifyNumber({ format, minFractionDigits, tag, value }) { + if (typeof value === 'bigint') return String(value); + if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf'; + let n = JSON.stringify(value); + if (!format && minFractionDigits && (!tag || tag === 'tag:yaml.org,2002:float') && /^\d/.test(n)) { + let i = n.indexOf('.'); + if (i < 0) { + i = n.length; + n += '.'; + } + let d = minFractionDigits - (n.length - i - 1); + while (d-- > 0) n += '0'; + } + return n; + } + function checkFlowCollectionEnd(errors, cst) { + let char, name; + switch (cst.type) { + case PlainValue.Type.FLOW_MAP: + char = '}'; + name = 'flow map'; + break; + case PlainValue.Type.FLOW_SEQ: + char = ']'; + name = 'flow sequence'; + break; + default: + errors.push(new PlainValue.YAMLSemanticError(cst, 'Not a flow collection!?')); + return; + } + let lastItem; + for (let i = cst.items.length - 1; i >= 0; --i) { + const item = cst.items[i]; + if (!item || item.type !== PlainValue.Type.COMMENT) { + lastItem = item; + break; + } + } + if (lastItem && lastItem.char !== char) { + const msg = `Expected ${name} to end with ${char}`; + let err; + if (typeof lastItem.offset === 'number') { + err = new PlainValue.YAMLSemanticError(cst, msg); + err.offset = lastItem.offset + 1; + } else { + err = new PlainValue.YAMLSemanticError(lastItem, msg); + if (lastItem.range && lastItem.range.end) err.offset = lastItem.range.end - lastItem.range.start; + } + errors.push(err); + } + } + function checkFlowCommentSpace(errors, comment) { + const prev = comment.context.src[comment.range.start - 1]; + if (prev !== '\n' && prev !== ' ' && prev !== ' ') { + const msg = 'Comments must be separated from other tokens by white space characters'; + errors.push(new PlainValue.YAMLSemanticError(comment, msg)); + } + } + function getLongKeyError(source, key) { + const sk = String(key); + const k = sk.substr(0, 8) + '...' + sk.substr(-8); + return new PlainValue.YAMLSemanticError(source, `The "${k}" key is too long`); + } + function resolveComments(collection, comments) { + for (const { afterKey, before, comment } of comments) { + let item = collection.items[before]; + if (!item) { + if (comment !== void 0) { + if (collection.comment) collection.comment += '\n' + comment; + else collection.comment = comment; + } + } else { + if (afterKey && item.value) item = item.value; + if (comment === void 0) { + if (afterKey || !item.commentBefore) item.spaceBefore = true; + } else { + if (item.commentBefore) item.commentBefore += '\n' + comment; + else item.commentBefore = comment; + } + } + } + } + function resolveString(doc, node) { + const res = node.strValue; + if (!res) return ''; + if (typeof res === 'string') return res; + res.errors.forEach((error) => { + if (!error.source) error.source = node; + doc.errors.push(error); + }); + return res.str; + } + function resolveTagHandle(doc, node) { + const { handle, suffix } = node.tag; + let prefix = doc.tagPrefixes.find((p) => p.handle === handle); + if (!prefix) { + const dtp = doc.getDefaults().tagPrefixes; + if (dtp) prefix = dtp.find((p) => p.handle === handle); + if (!prefix) + throw new PlainValue.YAMLSemanticError( + node, + `The ${handle} tag handle is non-default and was not declared.` + ); + } + if (!suffix) throw new PlainValue.YAMLSemanticError(node, `The ${handle} tag has no suffix.`); + if (handle === '!' && (doc.version || doc.options.version) === '1.0') { + if (suffix[0] === '^') { + doc.warnings.push(new PlainValue.YAMLWarning(node, 'YAML 1.0 ^ tag expansion is not supported')); + return suffix; + } + if (/[:/]/.test(suffix)) { + const vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i); + return vocab ? `tag:${vocab[1]}.yaml.org,2002:${vocab[2]}` : `tag:${suffix}`; + } + } + return prefix.prefix + decodeURIComponent(suffix); + } + function resolveTagName(doc, node) { + const { tag, type } = node; + let nonSpecific = false; + if (tag) { + const { handle, suffix, verbatim } = tag; + if (verbatim) { + if (verbatim !== '!' && verbatim !== '!!') return verbatim; + const msg = `Verbatim tags aren't resolved, so ${verbatim} is invalid.`; + doc.errors.push(new PlainValue.YAMLSemanticError(node, msg)); + } else if (handle === '!' && !suffix) { + nonSpecific = true; + } else { + try { + return resolveTagHandle(doc, node); + } catch (error) { + doc.errors.push(error); + } + } + } + switch (type) { + case PlainValue.Type.BLOCK_FOLDED: + case PlainValue.Type.BLOCK_LITERAL: + case PlainValue.Type.QUOTE_DOUBLE: + case PlainValue.Type.QUOTE_SINGLE: + return PlainValue.defaultTags.STR; + case PlainValue.Type.FLOW_MAP: + case PlainValue.Type.MAP: + return PlainValue.defaultTags.MAP; + case PlainValue.Type.FLOW_SEQ: + case PlainValue.Type.SEQ: + return PlainValue.defaultTags.SEQ; + case PlainValue.Type.PLAIN: + return nonSpecific ? PlainValue.defaultTags.STR : null; + default: + return null; + } + } + function resolveByTagName(doc, node, tagName) { + const { tags } = doc.schema; + const matchWithTest = []; + for (const tag of tags) { + if (tag.tag === tagName) { + if (tag.test) matchWithTest.push(tag); + else { + const res = tag.resolve(doc, node); + return res instanceof Collection2 ? res : new Scalar2(res); + } + } + } + const str = resolveString(doc, node); + if (typeof str === 'string' && matchWithTest.length > 0) + return resolveScalar(str, matchWithTest, tags.scalarFallback); + return null; + } + function getFallbackTagName({ type }) { + switch (type) { + case PlainValue.Type.FLOW_MAP: + case PlainValue.Type.MAP: + return PlainValue.defaultTags.MAP; + case PlainValue.Type.FLOW_SEQ: + case PlainValue.Type.SEQ: + return PlainValue.defaultTags.SEQ; + default: + return PlainValue.defaultTags.STR; + } + } + function resolveTag(doc, node, tagName) { + try { + const res = resolveByTagName(doc, node, tagName); + if (res) { + if (tagName && node.tag) res.tag = tagName; + return res; + } + } catch (error) { + if (!error.source) error.source = node; + doc.errors.push(error); + return null; + } + try { + const fallback = getFallbackTagName(node); + if (!fallback) throw new Error(`The tag ${tagName} is unavailable`); + const msg = `The tag ${tagName} is unavailable, falling back to ${fallback}`; + doc.warnings.push(new PlainValue.YAMLWarning(node, msg)); + const res = resolveByTagName(doc, node, fallback); + res.tag = tagName; + return res; + } catch (error) { + const refError = new PlainValue.YAMLReferenceError(node, error.message); + refError.stack = error.stack; + doc.errors.push(refError); + return null; + } + } + var isCollectionItem = (node) => { + if (!node) return false; + const { type } = node; + return ( + type === PlainValue.Type.MAP_KEY || + type === PlainValue.Type.MAP_VALUE || + type === PlainValue.Type.SEQ_ITEM + ); + }; + function resolveNodeProps(errors, node) { + const comments = { + before: [], + after: [], + }; + let hasAnchor = false; + let hasTag = false; + const props = isCollectionItem(node.context.parent) + ? node.context.parent.props.concat(node.props) + : node.props; + for (const { start, end } of props) { + switch (node.context.src[start]) { + case PlainValue.Char.COMMENT: { + if (!node.commentHasRequiredWhitespace(start)) { + const msg = 'Comments must be separated from other tokens by white space characters'; + errors.push(new PlainValue.YAMLSemanticError(node, msg)); + } + const { header, valueRange } = node; + const cc = + valueRange && (start > valueRange.start || (header && start > header.start)) + ? comments.after + : comments.before; + cc.push(node.context.src.slice(start + 1, end)); + break; + } + case PlainValue.Char.ANCHOR: + if (hasAnchor) { + const msg = 'A node can have at most one anchor'; + errors.push(new PlainValue.YAMLSemanticError(node, msg)); + } + hasAnchor = true; + break; + case PlainValue.Char.TAG: + if (hasTag) { + const msg = 'A node can have at most one tag'; + errors.push(new PlainValue.YAMLSemanticError(node, msg)); + } + hasTag = true; + break; + } + } + return { + comments, + hasAnchor, + hasTag, + }; + } + function resolveNodeValue(doc, node) { + const { anchors, errors, schema } = doc; + if (node.type === PlainValue.Type.ALIAS) { + const name = node.rawValue; + const src = anchors.getNode(name); + if (!src) { + const msg = `Aliased anchor not found: ${name}`; + errors.push(new PlainValue.YAMLReferenceError(node, msg)); + return null; + } + const res = new Alias2(src); + anchors._cstAliases.push(res); + return res; + } + const tagName = resolveTagName(doc, node); + if (tagName) return resolveTag(doc, node, tagName); + if (node.type !== PlainValue.Type.PLAIN) { + const msg = `Failed to resolve ${node.type} node here`; + errors.push(new PlainValue.YAMLSyntaxError(node, msg)); + return null; + } + try { + const str = resolveString(doc, node); + return resolveScalar(str, schema.tags, schema.tags.scalarFallback); + } catch (error) { + if (!error.source) error.source = node; + errors.push(error); + return null; + } + } + function resolveNode(doc, node) { + if (!node) return null; + if (node.error) doc.errors.push(node.error); + const { comments, hasAnchor, hasTag } = resolveNodeProps(doc.errors, node); + if (hasAnchor) { + const { anchors } = doc; + const name = node.anchor; + const prev = anchors.getNode(name); + if (prev) anchors.map[anchors.newName(name)] = prev; + anchors.map[name] = node; + } + if (node.type === PlainValue.Type.ALIAS && (hasAnchor || hasTag)) { + const msg = 'An alias node must not specify any properties'; + doc.errors.push(new PlainValue.YAMLSemanticError(node, msg)); + } + const res = resolveNodeValue(doc, node); + if (res) { + res.range = [node.range.start, node.range.end]; + if (doc.options.keepCstNodes) res.cstNode = node; + if (doc.options.keepNodeTypes) res.type = node.type; + const cb = comments.before.join('\n'); + if (cb) { + res.commentBefore = res.commentBefore + ? `${res.commentBefore} +${cb}` + : cb; + } + const ca = comments.after.join('\n'); + if (ca) + res.comment = res.comment + ? `${res.comment} +${ca}` + : ca; + } + return (node.resolved = res); + } + function resolveMap(doc, cst) { + if (cst.type !== PlainValue.Type.MAP && cst.type !== PlainValue.Type.FLOW_MAP) { + const msg = `A ${cst.type} node cannot be resolved as a mapping`; + doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg)); + return null; + } + const { comments, items } = + cst.type === PlainValue.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst); + const map = new YAMLMap2(); + map.items = items; + resolveComments(map, comments); + let hasCollectionKey = false; + for (let i = 0; i < items.length; ++i) { + const { key: iKey } = items[i]; + if (iKey instanceof Collection2) hasCollectionKey = true; + if (doc.schema.merge && iKey && iKey.value === MERGE_KEY) { + items[i] = new Merge2(items[i]); + const sources = items[i].value.items; + let error = null; + sources.some((node) => { + if (node instanceof Alias2) { + const { type } = node.source; + if (type === PlainValue.Type.MAP || type === PlainValue.Type.FLOW_MAP) return false; + return (error = 'Merge nodes aliases can only point to maps'); + } + return (error = 'Merge nodes can only have Alias nodes as values'); + }); + if (error) doc.errors.push(new PlainValue.YAMLSemanticError(cst, error)); + } else { + for (let j = i + 1; j < items.length; ++j) { + const { key: jKey } = items[j]; + if ( + iKey === jKey || + (iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, 'value') && iKey.value === jKey.value) + ) { + const msg = `Map keys must be unique; "${iKey}" is repeated`; + doc.errors.push(new PlainValue.YAMLSemanticError(cst, msg)); + break; + } + } + } + } + if (hasCollectionKey && !doc.options.mapAsMap) { + const warn = + 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.'; + doc.warnings.push(new PlainValue.YAMLWarning(cst, warn)); + } + cst.resolved = map; + return map; + } + var valueHasPairComment = ({ context: { lineStart, node, src }, props }) => { + if (props.length === 0) return false; + const { start } = props[0]; + if (node && start > node.valueRange.start) return false; + if (src[start] !== PlainValue.Char.COMMENT) return false; + for (let i = lineStart; i < start; ++i) if (src[i] === '\n') return false; + return true; + }; + function resolvePairComment(item, pair) { + if (!valueHasPairComment(item)) return; + const comment = item.getPropValue(0, PlainValue.Char.COMMENT, true); + let found = false; + const cb = pair.value.commentBefore; + if (cb && cb.startsWith(comment)) { + pair.value.commentBefore = cb.substr(comment.length + 1); + found = true; + } else { + const cc = pair.value.comment; + if (!item.node && cc && cc.startsWith(comment)) { + pair.value.comment = cc.substr(comment.length + 1); + found = true; + } + } + if (found) pair.comment = comment; + } + function resolveBlockMapItems(doc, cst) { + const comments = []; + const items = []; + let key = void 0; + let keyStart = null; + for (let i = 0; i < cst.items.length; ++i) { + const item = cst.items[i]; + switch (item.type) { + case PlainValue.Type.BLANK_LINE: + comments.push({ + afterKey: !!key, + before: items.length, + }); + break; + case PlainValue.Type.COMMENT: + comments.push({ + afterKey: !!key, + before: items.length, + comment: item.comment, + }); + break; + case PlainValue.Type.MAP_KEY: + if (key !== void 0) items.push(new Pair2(key)); + if (item.error) doc.errors.push(item.error); + key = resolveNode(doc, item.node); + keyStart = null; + break; + case PlainValue.Type.MAP_VALUE: + { + if (key === void 0) key = null; + if (item.error) doc.errors.push(item.error); + if ( + !item.context.atLineStart && + item.node && + item.node.type === PlainValue.Type.MAP && + !item.node.context.atLineStart + ) { + const msg = 'Nested mappings are not allowed in compact mappings'; + doc.errors.push(new PlainValue.YAMLSemanticError(item.node, msg)); + } + let valueNode = item.node; + if (!valueNode && item.props.length > 0) { + valueNode = new PlainValue.PlainValue(PlainValue.Type.PLAIN, []); + valueNode.context = { + parent: item, + src: item.context.src, + }; + const pos = item.range.start + 1; + valueNode.range = { + start: pos, + end: pos, + }; + valueNode.valueRange = { + start: pos, + end: pos, + }; + if (typeof item.range.origStart === 'number') { + const origPos = item.range.origStart + 1; + valueNode.range.origStart = valueNode.range.origEnd = origPos; + valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos; + } + } + const pair = new Pair2(key, resolveNode(doc, valueNode)); + resolvePairComment(item, pair); + items.push(pair); + if (key && typeof keyStart === 'number') { + if (item.range.start > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key)); + } + key = void 0; + keyStart = null; + } + break; + default: + if (key !== void 0) items.push(new Pair2(key)); + key = resolveNode(doc, item); + keyStart = item.range.start; + if (item.error) doc.errors.push(item.error); + next: for (let j = i + 1; ; ++j) { + const nextItem = cst.items[j]; + switch (nextItem && nextItem.type) { + case PlainValue.Type.BLANK_LINE: + case PlainValue.Type.COMMENT: + continue next; + case PlainValue.Type.MAP_VALUE: + break next; + default: { + const msg = 'Implicit map keys need to be followed by map values'; + doc.errors.push(new PlainValue.YAMLSemanticError(item, msg)); + break next; + } + } + } + if (item.valueRangeContainsNewline) { + const msg = 'Implicit map keys need to be on a single line'; + doc.errors.push(new PlainValue.YAMLSemanticError(item, msg)); + } + } + } + if (key !== void 0) items.push(new Pair2(key)); + return { + comments, + items, + }; + } + function resolveFlowMapItems(doc, cst) { + const comments = []; + const items = []; + let key = void 0; + let explicitKey = false; + let next = '{'; + for (let i = 0; i < cst.items.length; ++i) { + const item = cst.items[i]; + if (typeof item.char === 'string') { + const { char, offset } = item; + if (char === '?' && key === void 0 && !explicitKey) { + explicitKey = true; + next = ':'; + continue; + } + if (char === ':') { + if (key === void 0) key = null; + if (next === ':') { + next = ','; + continue; + } + } else { + if (explicitKey) { + if (key === void 0 && char !== ',') key = null; + explicitKey = false; + } + if (key !== void 0) { + items.push(new Pair2(key)); + key = void 0; + if (char === ',') { + next = ':'; + continue; + } + } + } + if (char === '}') { + if (i === cst.items.length - 1) continue; + } else if (char === next) { + next = ':'; + continue; + } + const msg = `Flow map contains an unexpected ${char}`; + const err = new PlainValue.YAMLSyntaxError(cst, msg); + err.offset = offset; + doc.errors.push(err); + } else if (item.type === PlainValue.Type.BLANK_LINE) { + comments.push({ + afterKey: !!key, + before: items.length, + }); + } else if (item.type === PlainValue.Type.COMMENT) { + checkFlowCommentSpace(doc.errors, item); + comments.push({ + afterKey: !!key, + before: items.length, + comment: item.comment, + }); + } else if (key === void 0) { + if (next === ',') + doc.errors.push(new PlainValue.YAMLSemanticError(item, 'Separator , missing in flow map')); + key = resolveNode(doc, item); + } else { + if (next !== ',') + doc.errors.push(new PlainValue.YAMLSemanticError(item, 'Indicator : missing in flow map entry')); + items.push(new Pair2(key, resolveNode(doc, item))); + key = void 0; + explicitKey = false; + } + } + checkFlowCollectionEnd(doc.errors, cst); + if (key !== void 0) items.push(new Pair2(key)); + return { + comments, + items, + }; + } + function resolveSeq(doc, cst) { + if (cst.type !== PlainValue.Type.SEQ && cst.type !== PlainValue.Type.FLOW_SEQ) { + const msg = `A ${cst.type} node cannot be resolved as a sequence`; + doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg)); + return null; + } + const { comments, items } = + cst.type === PlainValue.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst); + const seq = new YAMLSeq2(); + seq.items = items; + resolveComments(seq, comments); + if (!doc.options.mapAsMap && items.some((it) => it instanceof Pair2 && it.key instanceof Collection2)) { + const warn = + 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.'; + doc.warnings.push(new PlainValue.YAMLWarning(cst, warn)); + } + cst.resolved = seq; + return seq; + } + function resolveBlockSeqItems(doc, cst) { + const comments = []; + const items = []; + for (let i = 0; i < cst.items.length; ++i) { + const item = cst.items[i]; + switch (item.type) { + case PlainValue.Type.BLANK_LINE: + comments.push({ + before: items.length, + }); + break; + case PlainValue.Type.COMMENT: + comments.push({ + comment: item.comment, + before: items.length, + }); + break; + case PlainValue.Type.SEQ_ITEM: + if (item.error) doc.errors.push(item.error); + items.push(resolveNode(doc, item.node)); + if (item.hasProps) { + const msg = 'Sequence items cannot have tags or anchors before the - indicator'; + doc.errors.push(new PlainValue.YAMLSemanticError(item, msg)); + } + break; + default: + if (item.error) doc.errors.push(item.error); + doc.errors.push(new PlainValue.YAMLSyntaxError(item, `Unexpected ${item.type} node in sequence`)); + } + } + return { + comments, + items, + }; + } + function resolveFlowSeqItems(doc, cst) { + const comments = []; + const items = []; + let explicitKey = false; + let key = void 0; + let keyStart = null; + let next = '['; + let prevItem = null; + for (let i = 0; i < cst.items.length; ++i) { + const item = cst.items[i]; + if (typeof item.char === 'string') { + const { char, offset } = item; + if (char !== ':' && (explicitKey || key !== void 0)) { + if (explicitKey && key === void 0) key = next ? items.pop() : null; + items.push(new Pair2(key)); + explicitKey = false; + key = void 0; + keyStart = null; + } + if (char === next) { + next = null; + } else if (!next && char === '?') { + explicitKey = true; + } else if (next !== '[' && char === ':' && key === void 0) { + if (next === ',') { + key = items.pop(); + if (key instanceof Pair2) { + const msg = 'Chaining flow sequence pairs is invalid'; + const err = new PlainValue.YAMLSemanticError(cst, msg); + err.offset = offset; + doc.errors.push(err); + } + if (!explicitKey && typeof keyStart === 'number') { + const keyEnd = item.range ? item.range.start : item.offset; + if (keyEnd > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key)); + const { src } = prevItem.context; + for (let i2 = keyStart; i2 < keyEnd; ++i2) + if (src[i2] === '\n') { + const msg = 'Implicit keys of flow sequence pairs need to be on a single line'; + doc.errors.push(new PlainValue.YAMLSemanticError(prevItem, msg)); + break; + } + } + } else { + key = null; + } + keyStart = null; + explicitKey = false; + next = null; + } else if (next === '[' || char !== ']' || i < cst.items.length - 1) { + const msg = `Flow sequence contains an unexpected ${char}`; + const err = new PlainValue.YAMLSyntaxError(cst, msg); + err.offset = offset; + doc.errors.push(err); + } + } else if (item.type === PlainValue.Type.BLANK_LINE) { + comments.push({ + before: items.length, + }); + } else if (item.type === PlainValue.Type.COMMENT) { + checkFlowCommentSpace(doc.errors, item); + comments.push({ + comment: item.comment, + before: items.length, + }); + } else { + if (next) { + const msg = `Expected a ${next} in flow sequence`; + doc.errors.push(new PlainValue.YAMLSemanticError(item, msg)); + } + const value = resolveNode(doc, item); + if (key === void 0) { + items.push(value); + prevItem = item; + } else { + items.push(new Pair2(key, value)); + key = void 0; + } + keyStart = item.range.start; + next = ','; + } + } + checkFlowCollectionEnd(doc.errors, cst); + if (key !== void 0) items.push(new Pair2(key)); + return { + comments, + items, + }; + } + exports.Alias = Alias2; + exports.Collection = Collection2; + exports.Merge = Merge2; + exports.Node = Node2; + exports.Pair = Pair2; + exports.Scalar = Scalar2; + exports.YAMLMap = YAMLMap2; + exports.YAMLSeq = YAMLSeq2; + exports.addComment = addComment; + exports.binaryOptions = binaryOptions2; + exports.boolOptions = boolOptions2; + exports.findPair = findPair; + exports.intOptions = intOptions2; + exports.isEmptyPath = isEmptyPath; + exports.nullOptions = nullOptions2; + exports.resolveMap = resolveMap; + exports.resolveNode = resolveNode; + exports.resolveSeq = resolveSeq; + exports.resolveString = resolveString; + exports.strOptions = strOptions2; + exports.stringifyNumber = stringifyNumber; + exports.stringifyString = stringifyString; + exports.toJSON = toJSON; + }, + }); + require_warnings_1000a372 = __commonJS2({ + 'node_modules/yaml/dist/warnings-1000a372.js'(exports) { + 'use strict'; + var PlainValue = require_PlainValue_ec8e588e(); + var resolveSeq = require_resolveSeq_d03cb037(); + var binary = { + identify: (value) => value instanceof Uint8Array, + // Buffer inherits from Uint8Array + default: false, + tag: 'tag:yaml.org,2002:binary', + /** + * Returns a Buffer in node and an Uint8Array in browsers + * + * To use the resulting buffer as an image, you'll want to do something like: + * + * const blob = new Blob([buffer], { type: 'image/jpeg' }) + * document.querySelector('#photo').src = URL.createObjectURL(blob) + */ + resolve: (doc, node) => { + const src = resolveSeq.resolveString(doc, node); + if (typeof Buffer === 'function') { + return Buffer.from(src, 'base64'); + } else if (typeof atob === 'function') { + const str = atob(src.replace(/[\n\r]/g, '')); + const buffer = new Uint8Array(str.length); + for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i); + return buffer; + } else { + const msg = 'This environment does not support reading binary tags; either Buffer or atob is required'; + doc.errors.push(new PlainValue.YAMLReferenceError(node, msg)); + return null; + } + }, + options: resolveSeq.binaryOptions, + stringify: ({ comment, type, value }, ctx, onComment, onChompKeep) => { + let src; + if (typeof Buffer === 'function') { + src = value instanceof Buffer ? value.toString('base64') : Buffer.from(value.buffer).toString('base64'); + } else if (typeof btoa === 'function') { + let s = ''; + for (let i = 0; i < value.length; ++i) s += String.fromCharCode(value[i]); + src = btoa(s); + } else { + throw new Error( + 'This environment does not support writing binary tags; either Buffer or btoa is required' + ); + } + if (!type) type = resolveSeq.binaryOptions.defaultType; + if (type === PlainValue.Type.QUOTE_DOUBLE) { + value = src; + } else { + const { lineWidth } = resolveSeq.binaryOptions; + const n = Math.ceil(src.length / lineWidth); + const lines = new Array(n); + for (let i = 0, o = 0; i < n; ++i, o += lineWidth) { + lines[i] = src.substr(o, lineWidth); + } + value = lines.join(type === PlainValue.Type.BLOCK_LITERAL ? '\n' : ' '); + } + return resolveSeq.stringifyString( + { + comment, + type, + value, + }, + ctx, + onComment, + onChompKeep + ); + }, + }; + function parsePairs(doc, cst) { + const seq = resolveSeq.resolveSeq(doc, cst); + for (let i = 0; i < seq.items.length; ++i) { + let item = seq.items[i]; + if (item instanceof resolveSeq.Pair) continue; + else if (item instanceof resolveSeq.YAMLMap) { + if (item.items.length > 1) { + const msg = 'Each pair must have its own sequence indicator'; + throw new PlainValue.YAMLSemanticError(cst, msg); + } + const pair = item.items[0] || new resolveSeq.Pair(); + if (item.commentBefore) + pair.commentBefore = pair.commentBefore + ? `${item.commentBefore} +${pair.commentBefore}` + : item.commentBefore; + if (item.comment) + pair.comment = pair.comment + ? `${item.comment} +${pair.comment}` + : item.comment; + item = pair; + } + seq.items[i] = item instanceof resolveSeq.Pair ? item : new resolveSeq.Pair(item); + } + return seq; + } + function createPairs(schema, iterable, ctx) { + const pairs2 = new resolveSeq.YAMLSeq(schema); + pairs2.tag = 'tag:yaml.org,2002:pairs'; + for (const it of iterable) { + let key, value; + if (Array.isArray(it)) { + if (it.length === 2) { + key = it[0]; + value = it[1]; + } else throw new TypeError(`Expected [key, value] tuple: ${it}`); + } else if (it && it instanceof Object) { + const keys = Object.keys(it); + if (keys.length === 1) { + key = keys[0]; + value = it[key]; + } else throw new TypeError(`Expected { key: value } tuple: ${it}`); + } else { + key = it; + } + const pair = schema.createPair(key, value, ctx); + pairs2.items.push(pair); + } + return pairs2; + } + var pairs = { + default: false, + tag: 'tag:yaml.org,2002:pairs', + resolve: parsePairs, + createNode: createPairs, + }; + var YAMLOMap = class _YAMLOMap extends resolveSeq.YAMLSeq { + constructor() { + super(); + PlainValue._defineProperty(this, 'add', resolveSeq.YAMLMap.prototype.add.bind(this)); + PlainValue._defineProperty(this, 'delete', resolveSeq.YAMLMap.prototype.delete.bind(this)); + PlainValue._defineProperty(this, 'get', resolveSeq.YAMLMap.prototype.get.bind(this)); + PlainValue._defineProperty(this, 'has', resolveSeq.YAMLMap.prototype.has.bind(this)); + PlainValue._defineProperty(this, 'set', resolveSeq.YAMLMap.prototype.set.bind(this)); + this.tag = _YAMLOMap.tag; + } + toJSON(_, ctx) { + const map = /* @__PURE__ */ new Map(); + if (ctx && ctx.onCreate) ctx.onCreate(map); + for (const pair of this.items) { + let key, value; + if (pair instanceof resolveSeq.Pair) { + key = resolveSeq.toJSON(pair.key, '', ctx); + value = resolveSeq.toJSON(pair.value, key, ctx); + } else { + key = resolveSeq.toJSON(pair, '', ctx); + } + if (map.has(key)) throw new Error('Ordered maps must not include duplicate keys'); + map.set(key, value); + } + return map; + } + }; + PlainValue._defineProperty(YAMLOMap, 'tag', 'tag:yaml.org,2002:omap'); + function parseOMap(doc, cst) { + const pairs2 = parsePairs(doc, cst); + const seenKeys = []; + for (const { key } of pairs2.items) { + if (key instanceof resolveSeq.Scalar) { + if (seenKeys.includes(key.value)) { + const msg = 'Ordered maps must not include duplicate keys'; + throw new PlainValue.YAMLSemanticError(cst, msg); + } else { + seenKeys.push(key.value); + } + } + } + return Object.assign(new YAMLOMap(), pairs2); + } + function createOMap(schema, iterable, ctx) { + const pairs2 = createPairs(schema, iterable, ctx); + const omap2 = new YAMLOMap(); + omap2.items = pairs2.items; + return omap2; + } + var omap = { + identify: (value) => value instanceof Map, + nodeClass: YAMLOMap, + default: false, + tag: 'tag:yaml.org,2002:omap', + resolve: parseOMap, + createNode: createOMap, + }; + var YAMLSet = class _YAMLSet extends resolveSeq.YAMLMap { + constructor() { + super(); + this.tag = _YAMLSet.tag; + } + add(key) { + const pair = key instanceof resolveSeq.Pair ? key : new resolveSeq.Pair(key); + const prev = resolveSeq.findPair(this.items, pair.key); + if (!prev) this.items.push(pair); + } + get(key, keepPair) { + const pair = resolveSeq.findPair(this.items, key); + return !keepPair && pair instanceof resolveSeq.Pair + ? pair.key instanceof resolveSeq.Scalar + ? pair.key.value + : pair.key + : pair; + } + set(key, value) { + if (typeof value !== 'boolean') + throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`); + const prev = resolveSeq.findPair(this.items, key); + if (prev && !value) { + this.items.splice(this.items.indexOf(prev), 1); + } else if (!prev && value) { + this.items.push(new resolveSeq.Pair(key)); + } + } + toJSON(_, ctx) { + return super.toJSON(_, ctx, Set); + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) return JSON.stringify(this); + if (this.hasAllNullValues()) return super.toString(ctx, onComment, onChompKeep); + else throw new Error('Set items must all have null values'); + } + }; + PlainValue._defineProperty(YAMLSet, 'tag', 'tag:yaml.org,2002:set'); + function parseSet(doc, cst) { + const map = resolveSeq.resolveMap(doc, cst); + if (!map.hasAllNullValues()) + throw new PlainValue.YAMLSemanticError(cst, 'Set items must all have null values'); + return Object.assign(new YAMLSet(), map); + } + function createSet(schema, iterable, ctx) { + const set2 = new YAMLSet(); + for (const value of iterable) set2.items.push(schema.createPair(value, null, ctx)); + return set2; + } + var set = { + identify: (value) => value instanceof Set, + nodeClass: YAMLSet, + default: false, + tag: 'tag:yaml.org,2002:set', + resolve: parseSet, + createNode: createSet, + }; + var parseSexagesimal = (sign, parts) => { + const n = parts.split(':').reduce((n2, p) => n2 * 60 + Number(p), 0); + return sign === '-' ? -n : n; + }; + var stringifySexagesimal = ({ value }) => { + if (isNaN(value) || !isFinite(value)) return resolveSeq.stringifyNumber(value); + let sign = ''; + if (value < 0) { + sign = '-'; + value = Math.abs(value); + } + const parts = [value % 60]; + if (value < 60) { + parts.unshift(0); + } else { + value = Math.round((value - parts[0]) / 60); + parts.unshift(value % 60); + if (value >= 60) { + value = Math.round((value - parts[0]) / 60); + parts.unshift(value); + } + } + return ( + sign + + parts + .map((n) => (n < 10 ? '0' + String(n) : String(n))) + .join(':') + .replace(/000000\d*$/, '') + ); + }; + var intTime = { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'TIME', + test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/, + resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, '')), + stringify: stringifySexagesimal, + }; + var floatTime = { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'TIME', + test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/, + resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, '')), + stringify: stringifySexagesimal, + }; + var timestamp = { + identify: (value) => value instanceof Date, + default: true, + tag: 'tag:yaml.org,2002:timestamp', + // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part + // may be omitted altogether, resulting in a date format. In such a case, the time part is + // assumed to be 00:00:00Z (start of day, UTC). + test: RegExp( + '^(?:([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?)$' + ), + resolve: (str, year, month, day, hour, minute, second, millisec, tz) => { + if (millisec) millisec = (millisec + '00').substr(1, 3); + let date2 = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec || 0); + if (tz && tz !== 'Z') { + let d = parseSexagesimal(tz[0], tz.slice(1)); + if (Math.abs(d) < 30) d *= 60; + date2 -= 6e4 * d; + } + return new Date(date2); + }, + stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, ''), + }; + function shouldWarn(deprecation) { + const env = (typeof process !== 'undefined' && process.env) || {}; + if (deprecation) { + if (typeof YAML_SILENCE_DEPRECATION_WARNINGS !== 'undefined') return !YAML_SILENCE_DEPRECATION_WARNINGS; + return !env.YAML_SILENCE_DEPRECATION_WARNINGS; + } + if (typeof YAML_SILENCE_WARNINGS !== 'undefined') return !YAML_SILENCE_WARNINGS; + return !env.YAML_SILENCE_WARNINGS; + } + function warn(warning, type) { + if (shouldWarn(false)) { + const emit = typeof process !== 'undefined' && process.emitWarning; + if (emit) emit(warning, type); + else { + console.warn(type ? `${type}: ${warning}` : warning); + } + } + } + function warnFileDeprecation(filename) { + if (shouldWarn(true)) { + const path = filename + .replace(/.*yaml[/\\]/i, '') + .replace(/\.js$/, '') + .replace(/\\/g, '/'); + warn(`The endpoint 'yaml/${path}' will be removed in a future release.`, 'DeprecationWarning'); + } + } + var warned = {}; + function warnOptionDeprecation(name, alternative) { + if (!warned[name] && shouldWarn(true)) { + warned[name] = true; + let msg = `The option '${name}' will be removed in a future release`; + msg += alternative ? `, use '${alternative}' instead.` : '.'; + warn(msg, 'DeprecationWarning'); + } + } + exports.binary = binary; + exports.floatTime = floatTime; + exports.intTime = intTime; + exports.omap = omap; + exports.pairs = pairs; + exports.set = set; + exports.timestamp = timestamp; + exports.warn = warn; + exports.warnFileDeprecation = warnFileDeprecation; + exports.warnOptionDeprecation = warnOptionDeprecation; + }, + }); + require_Schema_88e323a7 = __commonJS2({ + 'node_modules/yaml/dist/Schema-88e323a7.js'(exports) { + 'use strict'; + var PlainValue = require_PlainValue_ec8e588e(); + var resolveSeq = require_resolveSeq_d03cb037(); + var warnings = require_warnings_1000a372(); + function createMap(schema, obj, ctx) { + const map2 = new resolveSeq.YAMLMap(schema); + if (obj instanceof Map) { + for (const [key, value] of obj) map2.items.push(schema.createPair(key, value, ctx)); + } else if (obj && typeof obj === 'object') { + for (const key of Object.keys(obj)) map2.items.push(schema.createPair(key, obj[key], ctx)); + } + if (typeof schema.sortMapEntries === 'function') { + map2.items.sort(schema.sortMapEntries); + } + return map2; + } + var map = { + createNode: createMap, + default: true, + nodeClass: resolveSeq.YAMLMap, + tag: 'tag:yaml.org,2002:map', + resolve: resolveSeq.resolveMap, + }; + function createSeq(schema, obj, ctx) { + const seq2 = new resolveSeq.YAMLSeq(schema); + if (obj && obj[Symbol.iterator]) { + for (const it of obj) { + const v = schema.createNode(it, ctx.wrapScalars, null, ctx); + seq2.items.push(v); + } + } + return seq2; + } + var seq = { + createNode: createSeq, + default: true, + nodeClass: resolveSeq.YAMLSeq, + tag: 'tag:yaml.org,2002:seq', + resolve: resolveSeq.resolveSeq, + }; + var string = { + identify: (value) => typeof value === 'string', + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: resolveSeq.resolveString, + stringify(item, ctx, onComment, onChompKeep) { + ctx = Object.assign( + { + actualString: true, + }, + ctx + ); + return resolveSeq.stringifyString(item, ctx, onComment, onChompKeep); + }, + options: resolveSeq.strOptions, + }; + var failsafe = [map, seq, string]; + var intIdentify$2 = (value) => typeof value === 'bigint' || Number.isInteger(value); + var intResolve$1 = (src, part, radix) => + resolveSeq.intOptions.asBigInt ? BigInt(src) : parseInt(part, radix); + function intStringify$1(node, radix, prefix) { + const { value } = node; + if (intIdentify$2(value) && value >= 0) return prefix + value.toString(radix); + return resolveSeq.stringifyNumber(node); + } + var nullObj = { + identify: (value) => value == null, + createNode: (schema, value, ctx) => (ctx.wrapScalars ? new resolveSeq.Scalar(null) : null), + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: () => null, + options: resolveSeq.nullOptions, + stringify: () => resolveSeq.nullOptions.nullStr, + }; + var boolObj = { + identify: (value) => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, + resolve: (str) => str[0] === 't' || str[0] === 'T', + options: resolveSeq.boolOptions, + stringify: ({ value }) => (value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr), + }; + var octObj = { + identify: (value) => intIdentify$2(value) && value >= 0, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^0o([0-7]+)$/, + resolve: (str, oct) => intResolve$1(str, oct, 8), + options: resolveSeq.intOptions, + stringify: (node) => intStringify$1(node, 8, '0o'), + }; + var intObj = { + identify: intIdentify$2, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9]+$/, + resolve: (str) => intResolve$1(str, str, 10), + options: resolveSeq.intOptions, + stringify: resolveSeq.stringifyNumber, + }; + var hexObj = { + identify: (value) => intIdentify$2(value) && value >= 0, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^0x([0-9a-fA-F]+)$/, + resolve: (str, hex) => intResolve$1(str, hex, 16), + options: resolveSeq.intOptions, + stringify: (node) => intStringify$1(node, 16, '0x'), + }; + var nanObj = { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: (str, nan) => (nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY), + stringify: resolveSeq.stringifyNumber, + }; + var expObj = { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str), + stringify: ({ value }) => Number(value).toExponential(), + }; + var floatObj = { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/, + resolve(str, frac1, frac2) { + const frac = frac1 || frac2; + const node = new resolveSeq.Scalar(parseFloat(str)); + if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length; + return node; + }, + stringify: resolveSeq.stringifyNumber, + }; + var core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]); + var intIdentify$1 = (value) => typeof value === 'bigint' || Number.isInteger(value); + var stringifyJSON = ({ value }) => JSON.stringify(value); + var json = [ + map, + seq, + { + identify: (value) => typeof value === 'string', + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: resolveSeq.resolveString, + stringify: stringifyJSON, + }, + { + identify: (value) => value == null, + createNode: (schema, value, ctx) => (ctx.wrapScalars ? new resolveSeq.Scalar(null) : null), + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^null$/, + resolve: () => null, + stringify: stringifyJSON, + }, + { + identify: (value) => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^true|false$/, + resolve: (str) => str === 'true', + stringify: stringifyJSON, + }, + { + identify: intIdentify$1, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: (str) => (resolveSeq.intOptions.asBigInt ? BigInt(str) : parseInt(str, 10)), + stringify: ({ value }) => (intIdentify$1(value) ? value.toString() : JSON.stringify(value)), + }, + { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: (str) => parseFloat(str), + stringify: stringifyJSON, + }, + ]; + json.scalarFallback = (str) => { + throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(str)}`); + }; + var boolStringify = ({ value }) => (value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr); + var intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value); + function intResolve(sign, src, radix) { + let str = src.replace(/_/g, ''); + if (resolveSeq.intOptions.asBigInt) { + switch (radix) { + case 2: + str = `0b${str}`; + break; + case 8: + str = `0o${str}`; + break; + case 16: + str = `0x${str}`; + break; + } + const n2 = BigInt(str); + return sign === '-' ? BigInt(-1) * n2 : n2; + } + const n = parseInt(str, radix); + return sign === '-' ? -1 * n : n; + } + function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value)) { + const str = value.toString(radix); + return value < 0 ? '-' + prefix + str.substr(1) : prefix + str; + } + return resolveSeq.stringifyNumber(node); + } + var yaml11 = failsafe.concat( + [ + { + identify: (value) => value == null, + createNode: (schema, value, ctx) => (ctx.wrapScalars ? new resolveSeq.Scalar(null) : null), + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: () => null, + options: resolveSeq.nullOptions, + stringify: () => resolveSeq.nullOptions.nullStr, + }, + { + identify: (value) => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, + resolve: () => true, + options: resolveSeq.boolOptions, + stringify: boolStringify, + }, + { + identify: (value) => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i, + resolve: () => false, + options: resolveSeq.boolOptions, + stringify: boolStringify, + }, + { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'BIN', + test: /^([-+]?)0b([0-1_]+)$/, + resolve: (str, sign, bin) => intResolve(sign, bin, 2), + stringify: (node) => intStringify(node, 2, '0b'), + }, + { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^([-+]?)0([0-7_]+)$/, + resolve: (str, sign, oct) => intResolve(sign, oct, 8), + stringify: (node) => intStringify(node, 8, '0'), + }, + { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^([-+]?)([0-9][0-9_]*)$/, + resolve: (str, sign, abs) => intResolve(sign, abs, 10), + stringify: resolveSeq.stringifyNumber, + }, + { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^([-+]?)0x([0-9a-fA-F_]+)$/, + resolve: (str, sign, hex) => intResolve(sign, hex, 16), + stringify: (node) => intStringify(node, 16, '0x'), + }, + { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: (str, nan) => + nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, + stringify: resolveSeq.stringifyNumber, + }, + { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str.replace(/_/g, '')), + stringify: ({ value }) => Number(value).toExponential(), + }, + { + identify: (value) => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/, + resolve(str, frac) { + const node = new resolveSeq.Scalar(parseFloat(str.replace(/_/g, ''))); + if (frac) { + const f = frac.replace(/_/g, ''); + if (f[f.length - 1] === '0') node.minFractionDigits = f.length; + } + return node; + }, + stringify: resolveSeq.stringifyNumber, + }, + ], + warnings.binary, + warnings.omap, + warnings.pairs, + warnings.set, + warnings.intTime, + warnings.floatTime, + warnings.timestamp + ); + var schemas = { + core, + failsafe, + json, + yaml11, + }; + var tags = { + binary: warnings.binary, + bool: boolObj, + float: floatObj, + floatExp: expObj, + floatNaN: nanObj, + floatTime: warnings.floatTime, + int: intObj, + intHex: hexObj, + intOct: octObj, + intTime: warnings.intTime, + map, + null: nullObj, + omap: warnings.omap, + pairs: warnings.pairs, + seq, + set: warnings.set, + timestamp: warnings.timestamp, + }; + function findTagObject(value, tagName, tags2) { + if (tagName) { + const match = tags2.filter((t) => t.tag === tagName); + const tagObj = match.find((t) => !t.format) || match[0]; + if (!tagObj) throw new Error(`Tag ${tagName} not found`); + return tagObj; + } + return tags2.find( + (t) => ((t.identify && t.identify(value)) || (t.class && value instanceof t.class)) && !t.format + ); + } + function createNode(value, tagName, ctx) { + if (value instanceof resolveSeq.Node) return value; + const { defaultPrefix, onTagObj, prevObjects, schema, wrapScalars } = ctx; + if (tagName && tagName.startsWith('!!')) tagName = defaultPrefix + tagName.slice(2); + let tagObj = findTagObject(value, tagName, schema.tags); + if (!tagObj) { + if (typeof value.toJSON === 'function') value = value.toJSON(); + if (!value || typeof value !== 'object') return wrapScalars ? new resolveSeq.Scalar(value) : value; + tagObj = value instanceof Map ? map : value[Symbol.iterator] ? seq : map; + } + if (onTagObj) { + onTagObj(tagObj); + delete ctx.onTagObj; + } + const obj = { + value: void 0, + node: void 0, + }; + if (value && typeof value === 'object' && prevObjects) { + const prev = prevObjects.get(value); + if (prev) { + const alias = new resolveSeq.Alias(prev); + ctx.aliasNodes.push(alias); + return alias; + } + obj.value = value; + prevObjects.set(value, obj); + } + obj.node = tagObj.createNode + ? tagObj.createNode(ctx.schema, value, ctx) + : wrapScalars + ? new resolveSeq.Scalar(value) + : value; + if (tagName && obj.node instanceof resolveSeq.Node) obj.node.tag = tagName; + return obj.node; + } + function getSchemaTags(schemas2, knownTags, customTags, schemaId) { + let tags2 = schemas2[schemaId.replace(/\W/g, '')]; + if (!tags2) { + const keys = Object.keys(schemas2) + .map((key) => JSON.stringify(key)) + .join(', '); + throw new Error(`Unknown schema "${schemaId}"; use one of ${keys}`); + } + if (Array.isArray(customTags)) { + for (const tag of customTags) tags2 = tags2.concat(tag); + } else if (typeof customTags === 'function') { + tags2 = customTags(tags2.slice()); + } + for (let i = 0; i < tags2.length; ++i) { + const tag = tags2[i]; + if (typeof tag === 'string') { + const tagObj = knownTags[tag]; + if (!tagObj) { + const keys = Object.keys(knownTags) + .map((key) => JSON.stringify(key)) + .join(', '); + throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`); + } + tags2[i] = tagObj; + } + } + return tags2; + } + var sortMapEntriesByKey = (a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0); + var Schema2 = class _Schema { + // TODO: remove in v2 + // TODO: remove in v2 + constructor({ customTags, merge: merge2, schema, sortMapEntries, tags: deprecatedCustomTags }) { + this.merge = !!merge2; + this.name = schema; + this.sortMapEntries = sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null; + if (!customTags && deprecatedCustomTags) warnings.warnOptionDeprecation('tags', 'customTags'); + this.tags = getSchemaTags(schemas, tags, customTags || deprecatedCustomTags, schema); + } + createNode(value, wrapScalars, tagName, ctx) { + const baseCtx = { + defaultPrefix: _Schema.defaultPrefix, + schema: this, + wrapScalars, + }; + const createCtx = ctx ? Object.assign(ctx, baseCtx) : baseCtx; + return createNode(value, tagName, createCtx); + } + createPair(key, value, ctx) { + if (!ctx) + ctx = { + wrapScalars: true, + }; + const k = this.createNode(key, ctx.wrapScalars, null, ctx); + const v = this.createNode(value, ctx.wrapScalars, null, ctx); + return new resolveSeq.Pair(k, v); + } + }; + PlainValue._defineProperty(Schema2, 'defaultPrefix', PlainValue.defaultTagPrefix); + PlainValue._defineProperty(Schema2, 'defaultTags', PlainValue.defaultTags); + exports.Schema = Schema2; + }, + }); + require_types2 = __commonJS2({ + 'node_modules/yaml/dist/types.js'(exports) { + 'use strict'; + var resolveSeq = require_resolveSeq_d03cb037(); + var Schema2 = require_Schema_88e323a7(); + require_PlainValue_ec8e588e(); + require_warnings_1000a372(); + exports.Alias = resolveSeq.Alias; + exports.Collection = resolveSeq.Collection; + exports.Merge = resolveSeq.Merge; + exports.Node = resolveSeq.Node; + exports.Pair = resolveSeq.Pair; + exports.Scalar = resolveSeq.Scalar; + exports.YAMLMap = resolveSeq.YAMLMap; + exports.YAMLSeq = resolveSeq.YAMLSeq; + exports.binaryOptions = resolveSeq.binaryOptions; + exports.boolOptions = resolveSeq.boolOptions; + exports.intOptions = resolveSeq.intOptions; + exports.nullOptions = resolveSeq.nullOptions; + exports.strOptions = resolveSeq.strOptions; + exports.Schema = Schema2.Schema; + }, + }); + DEPENDENCIES = {}; + getDependencies = () => { + return DEPENDENCIES; + }; + setDependencies = (value) => { + Object.assign(DEPENDENCIES, value); + }; + Registry = class { + constructor() { + this.data = {}; + } + /** + * Unregisters custom format(s) + * @param name + */ + unregister(name) { + if (!name) { + this.data = {}; + } else { + delete this.data[name]; + } + } + /** + * Registers custom format + */ + register(name, callback) { + this.data[name] = callback; + } + /** + * Register many formats at one shot + */ + registerMany(formats) { + Object.keys(formats).forEach((name) => { + this.data[name] = formats[name]; + }); + } + /** + * Returns element by registry key + */ + get(name) { + const format = this.data[name]; + return format; + } + /** + * Returns the whole registry content + */ + list() { + return this.data; + } + }; + Registry_default = Registry; + defaults = {}; + defaults_default = defaults; + defaults.defaultInvalidTypeProduct = void 0; + defaults.defaultRandExpMax = 10; + defaults.pruneProperties = []; + defaults.ignoreProperties = []; + defaults.ignoreMissingRefs = false; + defaults.failOnInvalidTypes = true; + defaults.failOnInvalidFormat = true; + defaults.alwaysFakeOptionals = false; + defaults.optionalsProbability = null; + defaults.fixedProbabilities = false; + defaults.useExamplesValue = false; + defaults.useDefaultValue = false; + defaults.requiredOnly = false; + defaults.omitNulls = false; + defaults.minItems = 0; + defaults.maxItems = null; + defaults.minLength = 0; + defaults.maxLength = null; + defaults.resolveJsonPath = false; + defaults.reuseProperties = false; + defaults.fillProperties = true; + defaults.sortProperties = false; + defaults.replaceEmptyByRandomValue = false; + defaults.random = Math.random; + defaults.minDateTime = /* @__PURE__ */ new Date('1889-12-31T00:00:00.000Z'); + defaults.maxDateTime = /* @__PURE__ */ new Date('1970-01-01T00:00:01.000Z'); + defaults.renderTitle = true; + defaults.renderDescription = true; + defaults.renderComment = false; + OptionRegistry = class extends Registry_default { + constructor() { + super(); + this.data = { ...defaults_default }; + this._defaults = defaults_default; + } + get defaults() { + return { ...this._defaults }; + } + }; + OptionRegistry_default = OptionRegistry; + registry = new OptionRegistry_default(); + optionAPI.getDefaults = () => registry.defaults; + option_default = optionAPI; + ALLOWED_TYPES = ['integer', 'number', 'string', 'boolean']; + SCALAR_TYPES = ALLOWED_TYPES.concat(['null']); + ALL_TYPES = ['array', 'object'].concat(SCALAR_TYPES); + MOST_NEAR_DATETIME = 2524608e6; + MIN_INTEGER = -1e8; + MAX_INTEGER = 1e8; + MIN_NUMBER = -100; + MAX_NUMBER = 100; + constants_default = { + ALLOWED_TYPES, + SCALAR_TYPES, + ALL_TYPES, + MIN_NUMBER, + MAX_NUMBER, + MIN_INTEGER, + MAX_INTEGER, + MOST_NEAR_DATETIME, + }; + import_randexp = __toESM(require_randexp(), 1); + random_default = { + pick, + date, + shuffle, + number, + randexp: _randexp, + }; + RE_NUMERIC = /^(0|[1-9][0-9]*)$/; + utils_default = { + hasProperties, + getLocalRef, + omitProps, + typecast, + merge, + clone, + short, + hasValue, + notValue, + anyValue, + validate, + validateValueForSchema, + validateValueForOneOf, + isKey, + template, + shouldClean, + clean, + isEmpty, + clampDate, + }; + Container = class { + constructor() { + this.registry = {}; + this.support = {}; + } + /** + * Unregister extensions + * @param name + */ + reset(name) { + if (!name) { + this.registry = {}; + this.support = {}; + } else { + delete this.registry[name]; + delete this.support[name]; + } + } + /** + * Override dependency given by name + * @param name + * @param callback + */ + extend(name, callback) { + this.registry[name] = callback(this.registry[name]); + if (!this.support[name]) { + this.support[name] = proxy(() => this.registry[name]); + } + } + /** + * Set keyword support by name + * @param name + * @param callback + */ + define(name, callback) { + this.support[name] = callback; + } + /** + * Returns dependency given by name + * @param name + * @returns {Dependency} + */ + get(name) { + if (typeof this.registry[name] === 'undefined') { + throw new ReferenceError(`'${name}' dependency doesn't exist.`); + } + return this.registry[name]; + } + /** + * Apply a custom keyword + * @param schema + */ + wrap(schema) { + if (!('generate' in schema)) { + const keys = Object.keys(schema); + const context = {}; + let length = keys.length; + while (length--) { + const fn = keys[length].replace(/^x-/, ''); + const gen = this.support[fn]; + if (typeof gen === 'function') { + Object.defineProperty(schema, 'generate', { + configurable: false, + enumerable: false, + writable: false, + value: (rootSchema, key) => + gen.call(context, schema[keys[length]], schema, keys[length], rootSchema, key.slice()), + }); + break; + } + } + } + return schema; + } + }; + Container_default = Container; + registry2 = new Registry_default(); + format_default = formatAPI; + ParseError = class extends Error { + constructor(message, path) { + super(); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = 'ParseError'; + this.message = message; + this.path = path; + } + }; + error_default = ParseError; + inferredProperties = { + array: ['additionalItems', 'items', 'maxItems', 'minItems', 'uniqueItems'], + integer: ['exclusiveMaximum', 'exclusiveMinimum', 'maximum', 'minimum', 'multipleOf'], + object: [ + 'additionalProperties', + 'dependencies', + 'maxProperties', + 'minProperties', + 'patternProperties', + 'properties', + 'required', + ], + string: ['maxLength', 'minLength', 'pattern', 'format'], + }; + inferredProperties.number = inferredProperties.integer; + subschemaProperties = [ + 'additionalItems', + 'items', + 'additionalProperties', + 'dependencies', + 'patternProperties', + 'properties', + ]; + infer_default = inferType; + boolean_default = booleanGenerator; + booleanType = boolean_default; + boolean_default2 = booleanType; + null_default = nullGenerator; + nullType = null_default; + null_default2 = nullType; + array_default = arrayType; + number_default = numberType; + integer_default = integerType; + LIPSUM_WORDS = `Lorem ipsum dolor sit amet consectetur adipisicing elit sed do eiusmod tempor incididunt ut labore +et dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea +commodo consequat Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla +pariatur Excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est +laborum`.split(/\W/); + words_default = wordsGenerator; + anyType = { type: constants_default.ALLOWED_TYPES }; + object_default = objectType; + thunk_default = thunkGenerator; + ipv4_default = ipv4Generator; + dateTime_default = dateTimeGenerator; + date_default = dateGenerator; + time_default = timeGenerator; + FRAGMENT = '[a-zA-Z][a-zA-Z0-9+-.]*'; + URI_PATTERN = `https?://{hostname}(?:${FRAGMENT})+`; + PARAM_PATTERN = '(?:\\?([a-z]{1,7}(=\\w{1,5})?&){0,3})?'; + regexps = { + email: '[a-zA-Z\\d][a-zA-Z\\d-]{1,13}[a-zA-Z\\d]@{hostname}', + hostname: '[a-zA-Z]{1,33}\\.[a-z]{2,4}', + ipv6: '[a-f\\d]{4}(:[a-f\\d]{4}){7}', + uri: URI_PATTERN, + slug: '[a-zA-Z\\d_-]+', + // types from draft-0[67] (?) + 'uri-reference': `${URI_PATTERN}${PARAM_PATTERN}`, + 'uri-template': URI_PATTERN.replace('(?:', '(?:/\\{[a-z][:a-zA-Z0-9-]*\\}|'), + 'json-pointer': `(/(?:${FRAGMENT.replace(']*', '/]*')}|~[01]))+`, + // some types from https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#data-types (?) + uuid: '^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$', + duration: '^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$', + }; + regexps.iri = regexps['uri-reference']; + regexps['iri-reference'] = regexps['uri-reference']; + regexps['idn-email'] = regexps.email; + regexps['idn-hostname'] = regexps.hostname; + ALLOWED_FORMATS = new RegExp(`\\{(${Object.keys(regexps).join('|')})\\}`); + coreFormat_default = coreFormatGenerator; + string_default = stringType; + typeMap = { + boolean: boolean_default2, + null: null_default2, + array: array_default, + integer: integer_default, + number: number_default, + object: object_default, + string: string_default, + }; + types_default = typeMap; + traverse_default = traverse; + buildResolveSchema = ({ refs, schema, container: container2, synchronous, refDepthMax, refDepthMin }) => { + const recursiveUtil = {}; + const seenRefs = {}; + let depth = 0; + let lastRef; + let lastPath; + recursiveUtil.resolveSchema = (sub, index, rootPath) => { + if (sub === null || sub === void 0) { + return null; + } + if (typeof sub.generate === 'function') { + return sub; + } + const _id = sub.$id || sub.id; + if (typeof _id === 'string') { + delete sub.id; + delete sub.$id; + delete sub.$schema; + } + if (typeof sub.$ref === 'string') { + const maxDepth = Math.max(refDepthMin, refDepthMax) - 1; + if (sub.$ref === '#' || seenRefs[sub.$ref] < 0 || (lastRef === sub.$ref && ++depth > maxDepth)) { + if (sub.$ref !== '#' && lastPath && lastPath.length === rootPath.length) { + return utils_default.getLocalRef(schema, sub.$ref, synchronous && refs); + } + delete sub.$ref; + return sub; + } + if (typeof seenRefs[sub.$ref] === 'undefined') { + seenRefs[sub.$ref] = random_default.number(refDepthMin, refDepthMax) - 1; + } + lastPath = rootPath; + lastRef = sub.$ref; + let ref; + if (sub.$ref.indexOf('#/') === -1) { + ref = refs[sub.$ref] || null; + } else { + ref = utils_default.getLocalRef(schema, sub.$ref, synchronous && refs) || null; + } + let fixed; + if (typeof ref !== 'undefined') { + if (!ref && option_default('ignoreMissingRefs') !== true) { + throw new Error(`Reference not found: ${sub.$ref}`); + } + seenRefs[sub.$ref] -= 1; + utils_default.merge(sub, ref || {}); + fixed = synchronous && ref && ref.$ref; + } + if (!fixed) delete sub.$ref; + return sub; + } + if (Array.isArray(sub.allOf)) { + const schemas = sub.allOf; + delete sub.allOf; + schemas.forEach((subSchema) => { + const _sub = recursiveUtil.resolveSchema(subSchema, null, rootPath); + utils_default.merge(sub, typeof _sub.thunk === 'function' ? _sub.thunk(sub) : _sub); + if (Array.isArray(sub.allOf)) { + recursiveUtil.resolveSchema(sub, index, rootPath); + } + }); + } + if (Array.isArray(sub.oneOf || sub.anyOf) && rootPath[rootPath.length - 2] !== 'dependencies') { + const mix = sub.oneOf || sub.anyOf; + if (sub.enum && sub.oneOf) { + sub.enum = sub.enum.filter((x) => utils_default.validate(x, mix)); + } + return { + thunk(rootSchema) { + const copy = utils_default.omitProps(sub, ['anyOf', 'oneOf']); + const fixed = random_default.pick(mix); + utils_default.merge(copy, fixed); + mix.forEach((omit) => { + if (omit.required && omit !== fixed) { + omit.required.forEach((key) => { + if (fixed.required && fixed.required.includes(key)) { + return; + } + const includesKey = copy.required && copy.required.includes(key); + if (copy.properties && !includesKey) { + delete copy.properties[key]; + } + if (rootSchema && rootSchema.properties) { + delete rootSchema.properties[key]; + } + }); + } + }); + return copy; + }, + }; + } + Object.keys(sub).forEach((prop) => { + if ((Array.isArray(sub[prop]) || typeof sub[prop] === 'object') && !utils_default.isKey(prop)) { + sub[prop] = recursiveUtil.resolveSchema(sub[prop], prop, rootPath.concat(prop)); + } + }); + if (rootPath) { + const lastProp = rootPath[rootPath.length - 1]; + if (lastProp === 'properties' || lastProp === 'items') { + return sub; + } + } + return container2.wrap(sub); + }; + return recursiveUtil; + }; + buildResolveSchema_default = buildResolveSchema; + run_default = run; + js_default = renderJS; + import_types2 = __toESM(require_types2(), 1); + binaryOptions = import_types2.default.binaryOptions; + boolOptions = import_types2.default.boolOptions; + intOptions = import_types2.default.intOptions; + nullOptions = import_types2.default.nullOptions; + strOptions = import_types2.default.strOptions; + Schema = import_types2.default.Schema; + Alias = import_types2.default.Alias; + Collection = import_types2.default.Collection; + Merge = import_types2.default.Merge; + Node = import_types2.default.Node; + Pair = import_types2.default.Pair; + Scalar = import_types2.default.Scalar; + YAMLMap = import_types2.default.YAMLMap; + YAMLSeq = import_types2.default.YAMLSeq; + yaml_default = renderYAML; + container = new Container_default(); + jsf = (schema, refs, cwd) => { + console.debug( + '[json-schema-faker] calling JSONSchemaFaker() is deprecated, call either .generate() or .resolve()' + ); + if (cwd) { + console.debug('[json-schema-faker] local references are only supported by calling .resolve()'); + } + return jsf.generate(schema, refs); + }; + jsf.generateWithContext = (schema, refs) => { + const $refs = getRefs(refs, schema); + return run_default($refs, schema, container, true); + }; + jsf.generate = (schema, refs) => js_default(jsf.generateWithContext(schema, refs)); + jsf.generateYAML = (schema, refs) => yaml_default(jsf.generateWithContext(schema, refs)); + jsf.resolveWithContext = (schema, refs, cwd) => { + if (typeof refs === 'string') { + cwd = refs; + refs = {}; + } + cwd = cwd || (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : ''); + cwd = `${cwd.replace(/\/+$/, '')}/`; + const $refs = getRefs(refs, schema); + const fixedRefs = { + order: 1, + canRead(file) { + const key = file.url.replace('/:', ':'); + return $refs[key] || $refs[key.split('/').pop()]; + }, + read(file, callback) { + try { + callback(null, this.canRead(file)); + } catch (e) { + callback(e); + } + }, + }; + const { $RefParser: $RefParser2 } = getDependencies(); + return $RefParser2 + .bundle(cwd, schema, { + resolve: { + file: { order: 100 }, + http: { order: 200 }, + fixedRefs, + }, + dereference: { + circular: 'ignore', + }, + }) + .then((sub) => run_default($refs, sub, container)) + .catch((e) => { + throw new Error(`Error while resolving schema (${e.message})`); + }); + }; + jsf.resolve = (schema, refs, cwd) => jsf.resolveWithContext(schema, refs, cwd).then(js_default); + jsf.resolveYAML = (schema, refs, cwd) => jsf.resolveWithContext(schema, refs, cwd).then(yaml_default); + setupKeywords(); + jsf.format = format_default; + jsf.option = option_default; + jsf.random = random_default; + jsf.extend = (name, cb) => { + container.extend(name, cb); + return jsf; + }; + jsf.define = (name, cb) => { + container.define(name, cb); + return jsf; + }; + jsf.reset = (name) => { + container.reset(name); + setupKeywords(); + return jsf; + }; + jsf.locate = (name) => { + return container.get(name); + }; + jsf.VERSION = '0.5.5'; + JSONSchemaFaker = { ...jsf }; + lib_default = jsf; + }, + }); + + // src/src/main.iife.js + var require_main_iife = __commonJS({ + 'src/src/main.iife.js'(exports, module) { + var jsf2 = (init_shared(), __toCommonJS(shared_exports)); + if (typeof $RefParser !== 'undefined' && typeof JSONPath !== 'undefined') { + jsf2.setDependencies({ ...JSONPath, $RefParser }); + } + if (typeof window !== 'undefined') { + window.JSONSchemaFaker = jsf2.default; + } + module.exports = jsf2.default; + module.exports.JSONSchemaFaker = jsf2.JSONSchemaFaker; + }, + }); + return require_main_iife(); +})(); +(function (root, factory) { + root.JSONSchemaFaker = factory(); +})(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : globalThis, () => JSONSchemaFaker); + +/* + * ******************************************************************* + * | The following code are Novu required additions to the IIFE code | + * ******************************************************************* + */ +JSONSchemaFaker.random.shuffle = function shuffle() { + return ['[placeholder]']; +}; + +JSONSchemaFaker.option({ + useDefaultValue: true, + alwaysFakeOptionals: true, +}); + +export function mockSchema(schema) { + return JSONSchemaFaker.generate(schema); +} diff --git a/packages/framework/sveltekit/package.json b/packages/framework/sveltekit/package.json index 83ba603461a..953441417f4 100644 --- a/packages/framework/sveltekit/package.json +++ b/packages/framework/sveltekit/package.json @@ -1,5 +1,3 @@ { - "main": "../dist/cjs/servers/sveltekit.cjs", - "module": "../dist/esm/servers/sveltekit.js", - "types": "../dist/esm/servers/sveltekit.d.ts" + "main": "../dist/cjs/servers/sveltekit.cjs" } diff --git a/packages/framework/tsconfig.json b/packages/framework/tsconfig.json index 6380c8cd408..759741b4e9f 100644 --- a/packages/framework/tsconfig.json +++ b/packages/framework/tsconfig.json @@ -14,6 +14,7 @@ "rootDir": ".", "outDir": "./dist", "experimentalDecorators": true, + "allowJs": true, "strict": true }, "include": ["./src/**/*", "scripts/devtool.ts"], diff --git a/packages/framework/tsup.config.ts b/packages/framework/tsup.config.ts index 908905a886e..572627ba8d4 100644 --- a/packages/framework/tsup.config.ts +++ b/packages/framework/tsup.config.ts @@ -1,5 +1,6 @@ -import { defineConfig } from 'tsup'; -import { type SupportedFrameworkName } from './src'; +import { type Options, defineConfig } from 'tsup'; +import { version } from './package.json'; +import { type SupportedFrameworkName } from './src/internal'; const frameworks: SupportedFrameworkName[] = ['h3', 'express', 'next', 'nuxt', 'sveltekit', 'remix', 'lambda', 'nest']; @@ -7,12 +8,15 @@ const baseConfig: Options = { entry: ['src/index.ts', 'src/internal/index.ts', ...frameworks.map((framework) => `src/servers/${framework}.ts`)], sourcemap: false, clean: true, - treeshake: true, dts: true, minify: true, minifyWhitespace: true, minifyIdentifiers: true, minifySyntax: true, + define: { + SDK_VERSION: `"${version}"`, + FRAMEWORK_VERSION: `"2024-06-26"`, + }, }; export default defineConfig([ diff --git a/packages/framework/vitest.config.ts b/packages/framework/vitest.config.ts new file mode 100644 index 00000000000..3547570866a --- /dev/null +++ b/packages/framework/vitest.config.ts @@ -0,0 +1,13 @@ +/// + +import { defineConfig } from 'vitest/config'; +import { version } from './package.json'; + +export default defineConfig({ + esbuild: { + define: { + SDK_VERSION: `"${version}"`, + FRAMEWORK_VERSION: `"2024-06-26"`, + }, + }, +}); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 990c855363c..79ee5640597 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -338,7 +338,7 @@ importers: version: 7.1.0 ts-jest: specifier: 27.1.5 - version: 27.1.5(@babel/core@7.25.2)(@types/jest@29.5.13)(babel-jest@27.5.1(@babel/core@7.25.2))(jest@29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) + version: 27.1.5(@babel/core@7.24.3)(@types/jest@29.5.13)(babel-jest@27.5.1(@babel/core@7.24.3))(jest@29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) ts-node: specifier: ~10.9.1 version: 10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2) @@ -990,13 +990,13 @@ importers: dependencies: '@babel/plugin-proposal-optional-chaining': specifier: ^7.20.7 - version: 7.21.0(@babel/core@7.21.4) + version: 7.21.0(@babel/core@7.22.11) '@babel/plugin-transform-react-display-name': specifier: ^7.18.6 - version: 7.18.6(@babel/core@7.21.4) + version: 7.18.6(@babel/core@7.22.11) '@babel/plugin-transform-runtime': specifier: ^7.23.2 - version: 7.23.2(@babel/core@7.21.4) + version: 7.23.2(@babel/core@7.22.11) '@clerk/clerk-js': specifier: ^5.10.0 version: 5.10.1(@types/react@18.3.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) @@ -1185,7 +1185,7 @@ importers: version: 11.9.0 html-webpack-plugin: specifier: 5.5.3 - version: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + version: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) js-cookie: specifier: ^3.0.5 version: 3.0.5 @@ -1221,7 +1221,7 @@ importers: version: 4.3.2 mdx-bundler: specifier: 10.0.2 - version: 10.0.2(esbuild@0.23.1) + version: 10.0.2(esbuild@0.18.20) mixpanel-browser: specifier: ^2.52.0 version: 2.53.0 @@ -1327,13 +1327,13 @@ importers: version: 7.12.1 '@babel/preset-env': specifier: ^7.23.2 - version: 7.23.2(@babel/core@7.21.4) + version: 7.23.2(@babel/core@7.22.11) '@babel/preset-react': specifier: ^7.13.13 - version: 7.18.6(@babel/core@7.21.4) + version: 7.18.6(@babel/core@7.22.11) '@babel/preset-typescript': specifier: ^7.13.0 - version: 7.21.4(@babel/core@7.21.4) + version: 7.21.4(@babel/core@7.22.11) '@babel/runtime': specifier: ^7.20.13 version: 7.21.0 @@ -1378,13 +1378,13 @@ importers: version: 7.4.2 '@storybook/preset-create-react-app': specifier: ^7.4.2 - version: 7.4.2(f7avyblvzm233o6g7idqcb345u) + version: 7.4.2(ucmnrhmq4kewpo24xrp57f5r6y) '@storybook/react': specifier: ^7.4.2 version: 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@storybook/react-webpack5': specifier: ^7.4.2 - version: 7.4.2(@babel/core@7.21.4)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1) + version: 7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1) '@testing-library/jest-dom': specifier: ^4.2.4 version: 4.2.4 @@ -1411,16 +1411,16 @@ importers: version: 0.13.0 less-loader: specifier: 4.1.0 - version: 4.1.0(less@4.1.3)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + version: 4.1.0(less@4.1.3)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) react-app-rewired: specifier: ^2.2.1 - version: 2.2.1(react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1)) + version: 2.2.1(react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1)) react-error-overlay: specifier: 6.0.11 version: 6.0.11 react-scripts: specifier: ^5.0.1 - version: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) + version: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) sinon: specifier: 9.2.4 version: 9.2.4 @@ -1432,13 +1432,13 @@ importers: version: 5.6.2 webpack: specifier: 5.78.0 - version: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + version: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) webpack-bundle-analyzer: specifier: ^4.9.0 version: 4.9.0 webpack-dev-server: specifier: 4.11.1 - version: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + version: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) apps/webhook: dependencies: @@ -2759,7 +2759,7 @@ importers: version: 20.16.5 jest: specifier: ^29.4.1 - version: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + version: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-environment-jsdom: specifier: ^29.4.1 version: 29.5.0 @@ -2771,7 +2771,7 @@ importers: version: 16.10.0(@swc-node/register@1.8.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/types@0.1.12)(typescript@5.6.2))(@swc/core@1.3.107(@swc/helpers@0.5.12)) ts-jest: specifier: ^29.1.0 - version: 29.1.2(@babel/core@7.24.4)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.24.4))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) + version: 29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) typescript: specifier: 5.6.2 version: 5.6.2 @@ -2929,13 +2929,13 @@ importers: version: 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@storybook/react-webpack5': specifier: ^7.4.2 - version: 7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1) + version: 7.4.2(@babel/core@7.23.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-hot-middleware@2.26.1) '@storybook/theming': specifier: ^7.4.2 version: 7.4.2(react-dom@18.3.1(react@18.3.1))(react@18.3.1) '@testing-library/jest-dom': specifier: ^6.4.1 - version: 6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@24.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6)) + version: 6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@24.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6)) '@testing-library/react': specifier: ^12.1.5 version: 12.1.5(react-dom@18.3.1(react@18.3.1))(react@18.3.1) @@ -2980,13 +2980,13 @@ importers: version: 7.4.2(encoding@0.1.13) ts-loader: specifier: ~9.4.0 - version: 9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + version: 9.4.4(typescript@5.6.2)(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))) typescript: specifier: 5.6.2 version: 5.6.2 url-loader: specifier: ^4.1.1 - version: 4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + version: 4.1.1(file-loader@6.2.0(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))))(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))) vite: specifier: ^4.5.2 version: 4.5.2(@types/node@20.16.5)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6) @@ -3177,7 +3177,7 @@ importers: version: 8.1.1 '@testing-library/jest-dom': specifier: ^6.4.1 - version: 6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@25.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.38))(terser@5.31.6)) + version: 6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@25.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.38))(terser@5.31.6)) '@testing-library/react': specifier: ^12.1.5 version: 12.1.5(react-dom@18.3.1(react@18.3.1))(react@18.3.1) @@ -3396,9 +3396,6 @@ importers: cross-fetch: specifier: ^4.0.0 version: 4.0.0(encoding@0.1.13) - json-schema-faker: - specifier: ^0.5.6 - version: 0.5.6 json-schema-to-ts: specifier: ^3.0.0 version: 3.1.0 @@ -3453,7 +3450,7 @@ importers: version: 8.0.0(typescript@5.6.2) next: specifier: ^13.5.4 - version: 13.5.6(@babel/core@7.25.2)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) + version: 13.5.6(@babel/core@7.24.3)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) prettier: specifier: ^3.2.5 version: 3.3.2 @@ -3514,7 +3511,7 @@ importers: version: 29.5.0 ts-jest: specifier: ^29.0.3 - version: 29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(esbuild@0.18.20)(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) + version: 29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) typedoc: specifier: ^0.24.0 version: 0.24.6(typescript@5.6.2) @@ -3714,7 +3711,7 @@ importers: version: link:../react next: specifier: '>=13' - version: 13.5.6(@babel/core@7.25.2)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) + version: 13.5.6(@babel/core@7.24.3)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) react: specifier: '>=17' version: 18.3.1 @@ -3785,7 +3782,7 @@ importers: version: 3.8.3(encoding@0.1.13) jest: specifier: ^29.7.0 - version: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + version: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) nock: specifier: ^13.1.3 version: 13.3.0 @@ -3803,7 +3800,7 @@ importers: version: 0.0.0 ts-jest: specifier: ^29.1.2 - version: 29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) + version: 29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(esbuild@0.23.1)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) typedoc: specifier: ^0.24.0 version: 0.24.6(typescript@5.6.2) @@ -3894,7 +3891,7 @@ importers: version: 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@storybook/react-webpack5': specifier: ^7.4.2 - version: 7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1) + version: 7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack-hot-middleware@2.26.1) '@testing-library/dom': specifier: ^9.3.0 version: 9.3.0 @@ -3927,10 +3924,10 @@ importers: version: 8.8.2 babel-loader: specifier: ^8.2.4 - version: 8.3.0(@babel/core@7.25.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + version: 8.3.0(@babel/core@7.25.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) compression-webpack-plugin: specifier: ^10.0.0 - version: 10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + version: 10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) jest: specifier: ^29.3.1 version: 29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) @@ -3954,28 +3951,28 @@ importers: version: 7.4.2(encoding@0.1.13) terser-webpack-plugin: specifier: ^5.3.9 - version: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + version: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) ts-jest: specifier: ^29.0.3 - version: 29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(esbuild@0.18.20)(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) + version: 29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2) ts-loader: specifier: ~9.4.0 - version: 9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + version: 9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) typescript: specifier: 5.6.2 version: 5.6.2 url-loader: specifier: ^4.1.1 - version: 4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + version: 4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) webpack: specifier: ^5.74.0 - version: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + version: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) webpack-bundle-analyzer: specifier: ^4.9.0 version: 4.9.0 webpack-cli: specifier: ^5.1.4 - version: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) + version: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) packages/novu: dependencies: @@ -4528,7 +4525,7 @@ importers: version: 0.439.0(react@18.3.1) next: specifier: 14.2.4 - version: 14.2.4(@babel/core@7.25.2)(@opentelemetry/api@1.9.0)(@playwright/test@1.46.1)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) + version: 14.2.4(@babel/core@7.24.3)(@opentelemetry/api@1.9.0)(@playwright/test@1.46.1)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8) react: specifier: ^18 version: 18.3.1 @@ -22621,9 +22618,6 @@ packages: resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} engines: {node: '>= 6'} - format-util@1.0.5: - resolution: {integrity: sha512-varLbTj0e0yVyRpqQhuWV+8hlePAgaoFRhNFj50BNjEIrw1/DphHSObtqwskVCPWNgzwPoQrZAbfa/SBiicNeg==} - format@0.2.2: resolution: {integrity: sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==} engines: {node: '>=0.4.x'} @@ -24998,18 +24992,10 @@ packages: json-schema-compare@0.2.2: resolution: {integrity: sha512-c4WYmDKyJXhs7WWvAWm3uIYnfyWFoIp+JEoX34rctVvEkMYCPGhXtvmFFXiffBbxfZsvQ0RNnV5H7GvDF5HCqQ==} - json-schema-faker@0.5.6: - resolution: {integrity: sha512-u/cFC26/GDxh2vPiAC8B8xVvpXAW+QYtG2mijEbKrimCk8IHtiwQBjCE8TwvowdhALWq9IcdIWZ+/8ocXvdL3Q==} - hasBin: true - json-schema-merge-allof@0.8.1: resolution: {integrity: sha512-CTUKmIlPJbsWfzRRnOXz+0MjIqvnleIXwFTzz+t9T86HnYX/Rozria6ZVGLktAU9e+NygNljveP+yxqtQp/Q4w==} engines: {node: '>=12.0.0'} - json-schema-ref-parser@6.1.0: - resolution: {integrity: sha512-pXe9H1m6IgIpXmE5JSb8epilNTGsmTb2iPohAXpOdhqGFbQjNeHHsZxU+C8w6T81GZxSPFLeUoqDJmzxx5IGuw==} - deprecated: Please switch to @apidevtools/json-schema-ref-parser - json-schema-to-ts@1.6.4: resolution: {integrity: sha512-pR4yQ9DHz6itqswtHCm26mw45FSNfQ9rEQjosaZErhn5J3J2sIViQiz8rDaezjKAhFGpmsoczYVBgGHzFw/stA==} @@ -25081,10 +25067,6 @@ packages: resolution: {integrity: sha512-gTaNRsPWO/K2KY6MrqaUFClF9kmuM6MFH5Dhg1VYDODgFbByw1yb7xu3hrViE/sz+dGOeMWgCzwUwQtAnCTE9g==} engines: {node: '>=12.0.0'} - jsonpath-plus@7.2.0: - resolution: {integrity: sha512-zBfiUPM5nD0YZSBT/o/fbCUlCcepMIdP0CJZxM1+KgA4f2T206f6VAg9e7mX35+KlMaIc5qXW34f3BnwJ3w+RA==} - engines: {node: '>=12.0.0'} - jsonpointer@5.0.1: resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} engines: {node: '>=0.10.0'} @@ -27473,9 +27455,6 @@ packages: resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==} engines: {node: '>=12'} - ono@4.0.11: - resolution: {integrity: sha512-jQ31cORBFE6td25deYeD80wxKBMj+zBmHTrVxnc6CKhx8gho6ipmWM5zj/oeoqioZ99yqBls9Z/9Nss7J26G2g==} - open-cli@6.0.1: resolution: {integrity: sha512-A5h8MF3GrT1efn9TiO9LPajDnLtuEiGQT5G8TxWObBlgt1cZJF1YbQo/kNtsD1bJb7HxnT6SaSjzeLq0Rfhygw==} engines: {node: '>=10'} @@ -34994,8 +34973,8 @@ snapshots: dependencies: '@aws-crypto/sha256-browser': 3.0.0 '@aws-crypto/sha256-js': 3.0.0 - '@aws-sdk/client-sso-oidc': 3.575.0(@aws-sdk/client-sts@3.575.0) - '@aws-sdk/client-sts': 3.575.0 + '@aws-sdk/client-sso-oidc': 3.575.0 + '@aws-sdk/client-sts': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) '@aws-sdk/core': 3.575.0 '@aws-sdk/credential-provider-node': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0)(@aws-sdk/client-sts@3.575.0) '@aws-sdk/middleware-host-header': 3.575.0 @@ -35196,8 +35175,8 @@ snapshots: '@aws-crypto/sha1-browser': 3.0.0 '@aws-crypto/sha256-browser': 3.0.0 '@aws-crypto/sha256-js': 3.0.0 - '@aws-sdk/client-sso-oidc': 3.575.0(@aws-sdk/client-sts@3.575.0) - '@aws-sdk/client-sts': 3.575.0 + '@aws-sdk/client-sso-oidc': 3.575.0 + '@aws-sdk/client-sts': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) '@aws-sdk/core': 3.575.0 '@aws-sdk/credential-provider-node': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0)(@aws-sdk/client-sts@3.575.0) '@aws-sdk/middleware-bucket-endpoint': 3.575.0 @@ -35423,11 +35402,11 @@ snapshots: - aws-crt optional: true - '@aws-sdk/client-sso-oidc@3.575.0(@aws-sdk/client-sts@3.575.0)': + '@aws-sdk/client-sso-oidc@3.575.0': dependencies: '@aws-crypto/sha256-browser': 3.0.0 '@aws-crypto/sha256-js': 3.0.0 - '@aws-sdk/client-sts': 3.575.0 + '@aws-sdk/client-sts': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) '@aws-sdk/core': 3.575.0 '@aws-sdk/credential-provider-node': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0)(@aws-sdk/client-sts@3.575.0) '@aws-sdk/middleware-host-header': 3.575.0 @@ -35466,7 +35445,6 @@ snapshots: '@smithy/util-utf8': 3.0.0 tslib: 2.7.0 transitivePeerDependencies: - - '@aws-sdk/client-sts' - aws-crt '@aws-sdk/client-sso-oidc@3.637.0(@aws-sdk/client-sts@3.637.0)': @@ -35851,11 +35829,11 @@ snapshots: - aws-crt optional: true - '@aws-sdk/client-sts@3.575.0': + '@aws-sdk/client-sts@3.575.0(@aws-sdk/client-sso-oidc@3.575.0)': dependencies: '@aws-crypto/sha256-browser': 3.0.0 '@aws-crypto/sha256-js': 3.0.0 - '@aws-sdk/client-sso-oidc': 3.575.0(@aws-sdk/client-sts@3.575.0) + '@aws-sdk/client-sso-oidc': 3.575.0 '@aws-sdk/core': 3.575.0 '@aws-sdk/credential-provider-node': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0)(@aws-sdk/client-sts@3.575.0) '@aws-sdk/middleware-host-header': 3.575.0 @@ -35894,6 +35872,7 @@ snapshots: '@smithy/util-utf8': 3.0.0 tslib: 2.7.0 transitivePeerDependencies: + - '@aws-sdk/client-sso-oidc' - aws-crt '@aws-sdk/client-sts@3.637.0': @@ -36123,7 +36102,7 @@ snapshots: '@aws-sdk/credential-provider-ini@3.575.0(@aws-sdk/client-sso-oidc@3.575.0)(@aws-sdk/client-sts@3.575.0)': dependencies: - '@aws-sdk/client-sts': 3.575.0 + '@aws-sdk/client-sts': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) '@aws-sdk/credential-provider-env': 3.575.0 '@aws-sdk/credential-provider-process': 3.575.0 '@aws-sdk/credential-provider-sso': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) @@ -36434,7 +36413,7 @@ snapshots: '@aws-sdk/credential-provider-web-identity@3.575.0(@aws-sdk/client-sts@3.575.0)': dependencies: - '@aws-sdk/client-sts': 3.575.0 + '@aws-sdk/client-sts': 3.575.0(@aws-sdk/client-sso-oidc@3.575.0) '@aws-sdk/types': 3.575.0 '@smithy/property-provider': 3.1.3 '@smithy/types': 3.3.0 @@ -36955,7 +36934,7 @@ snapshots: '@aws-sdk/token-providers@3.575.0(@aws-sdk/client-sso-oidc@3.575.0)': dependencies: - '@aws-sdk/client-sso-oidc': 3.575.0(@aws-sdk/client-sts@3.575.0) + '@aws-sdk/client-sso-oidc': 3.575.0 '@aws-sdk/types': 3.575.0 '@smithy/property-provider': 3.1.3 '@smithy/shared-ini-file-loader': 3.1.4 @@ -36964,7 +36943,7 @@ snapshots: '@aws-sdk/token-providers@3.614.0(@aws-sdk/client-sso-oidc@3.575.0)': dependencies: - '@aws-sdk/client-sso-oidc': 3.575.0(@aws-sdk/client-sts@3.575.0) + '@aws-sdk/client-sso-oidc': 3.575.0 '@aws-sdk/types': 3.609.0 '@smithy/property-provider': 3.1.3 '@smithy/shared-ini-file-loader': 3.1.4 @@ -37834,6 +37813,17 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/helper-module-transforms@7.22.20(@babel/core@7.22.11)': + dependencies: + '@babel/core': 7.22.11 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-module-imports': 7.24.7 + '@babel/helper-simple-access': 7.24.7 + '@babel/helper-split-export-declaration': 7.22.6 + '@babel/helper-validator-identifier': 7.24.7 + transitivePeerDependencies: + - supports-color + '@babel/helper-module-transforms@7.22.20(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -38359,6 +38349,13 @@ snapshots: '@babel/helper-skip-transparent-expression-wrappers': 7.22.5 '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.21.4) + '@babel/plugin-proposal-optional-chaining@7.21.0(@babel/core@7.22.11)': + dependencies: + '@babel/core': 7.22.11 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/helper-skip-transparent-expression-wrappers': 7.22.5 + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.22.11) + '@babel/plugin-proposal-optional-chaining@7.21.0(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -38434,6 +38431,12 @@ snapshots: '@babel/core': 7.21.4 '@babel/helper-plugin-utils': 7.24.8 + '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.24.3)': + dependencies: + '@babel/core': 7.24.3 + '@babel/helper-plugin-utils': 7.24.8 + optional: true + '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.24.4)': dependencies: '@babel/core': 7.24.4 @@ -38569,14 +38572,14 @@ snapshots: '@babel/core': 7.21.4 '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4)': + '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11)': + '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.23.2)': dependencies: - '@babel/core': 7.22.11 + '@babel/core': 7.23.2 '@babel/helper-plugin-utils': 7.24.8 '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.24.3)': @@ -38709,6 +38712,11 @@ snapshots: '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-syntax-jsx@7.22.5(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-syntax-jsx@7.22.5(@babel/core@7.24.4)': dependencies: '@babel/core': 7.24.4 @@ -38719,9 +38727,9 @@ snapshots: '@babel/core': 7.25.2 '@babel/helper-plugin-utils': 7.22.5 - '@babel/plugin-syntax-jsx@7.24.7(@babel/core@7.21.4)': + '@babel/plugin-syntax-jsx@7.24.7(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.24.8 '@babel/plugin-syntax-jsx@7.24.7(@babel/core@7.24.3)': @@ -38944,9 +38952,9 @@ snapshots: '@babel/core': 7.25.2 '@babel/helper-plugin-utils': 7.22.5 - '@babel/plugin-syntax-typescript@7.21.4(@babel/core@7.21.4)': + '@babel/plugin-syntax-typescript@7.21.4(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.24.8 '@babel/plugin-syntax-typescript@7.21.4(@babel/core@7.25.2)': @@ -39615,18 +39623,18 @@ snapshots: '@babel/helper-plugin-utils': 7.24.8 '@babel/plugin-syntax-flow': 7.22.5(@babel/core@7.21.4) - '@babel/plugin-transform-flow-strip-types@7.25.2(@babel/core@7.21.4)': - dependencies: - '@babel/core': 7.21.4 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.21.4) - '@babel/plugin-transform-flow-strip-types@7.25.2(@babel/core@7.22.11)': dependencies: '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.24.8 '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.22.11) + '@babel/plugin-transform-flow-strip-types@7.25.2(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-plugin-utils': 7.24.8 + '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.23.2) + '@babel/plugin-transform-flow-strip-types@7.25.2(@babel/core@7.24.3)': dependencies: '@babel/core': 7.24.3 @@ -39901,10 +39909,10 @@ snapshots: transitivePeerDependencies: - supports-color - '@babel/plugin-transform-modules-commonjs@7.22.15(@babel/core@7.21.4)': + '@babel/plugin-transform-modules-commonjs@7.22.15(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 - '@babel/helper-module-transforms': 7.22.20(@babel/core@7.21.4) + '@babel/core': 7.22.11 + '@babel/helper-module-transforms': 7.22.20(@babel/core@7.22.11) '@babel/helper-plugin-utils': 7.22.5 '@babel/helper-simple-access': 7.22.5 transitivePeerDependencies: @@ -40555,6 +40563,11 @@ snapshots: '@babel/core': 7.21.4 '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-transform-react-display-name@7.18.6(@babel/core@7.22.11)': + dependencies: + '@babel/core': 7.22.11 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/plugin-transform-react-display-name@7.22.5(@babel/core@7.21.4)': dependencies: '@babel/core': 7.21.4 @@ -40565,6 +40578,11 @@ snapshots: '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-transform-react-display-name@7.22.5(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-transform-react-display-name@7.22.5(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -40580,16 +40598,21 @@ snapshots: '@babel/core': 7.21.4 '@babel/plugin-transform-react-jsx': 7.21.0(@babel/core@7.21.4) - '@babel/plugin-transform-react-jsx-development@7.22.5(@babel/core@7.21.4)': + '@babel/plugin-transform-react-jsx-development@7.18.6(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 - '@babel/plugin-transform-react-jsx': 7.22.15(@babel/core@7.21.4) + '@babel/core': 7.22.11 + '@babel/plugin-transform-react-jsx': 7.21.0(@babel/core@7.22.11) '@babel/plugin-transform-react-jsx-development@7.22.5(@babel/core@7.22.11)': dependencies: '@babel/core': 7.22.11 '@babel/plugin-transform-react-jsx': 7.22.15(@babel/core@7.22.11) + '@babel/plugin-transform-react-jsx-development@7.22.5(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/plugin-transform-react-jsx': 7.22.15(@babel/core@7.23.2) + '@babel/plugin-transform-react-jsx-development@7.22.5(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -40641,14 +40664,14 @@ snapshots: '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.21.4) '@babel/types': 7.22.19 - '@babel/plugin-transform-react-jsx@7.22.15(@babel/core@7.21.4)': + '@babel/plugin-transform-react-jsx@7.21.0(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 - '@babel/helper-annotate-as-pure': 7.22.5 + '@babel/core': 7.22.11 + '@babel/helper-annotate-as-pure': 7.18.6 '@babel/helper-module-imports': 7.22.15 '@babel/helper-plugin-utils': 7.22.5 - '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.21.4) - '@babel/types': 7.24.0 + '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.22.11) + '@babel/types': 7.22.19 '@babel/plugin-transform-react-jsx@7.22.15(@babel/core@7.22.11)': dependencies: @@ -40659,6 +40682,15 @@ snapshots: '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.22.11) '@babel/types': 7.24.0 + '@babel/plugin-transform-react-jsx@7.22.15(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-annotate-as-pure': 7.22.5 + '@babel/helper-module-imports': 7.22.15 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.23.2) + '@babel/types': 7.24.0 + '@babel/plugin-transform-react-jsx@7.22.15(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -40679,13 +40711,13 @@ snapshots: transitivePeerDependencies: - supports-color - '@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4)': + '@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-annotate-as-pure': 7.24.7 '@babel/helper-module-imports': 7.24.7 '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.21.4) + '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.22.11) '@babel/types': 7.25.6 transitivePeerDependencies: - supports-color @@ -40718,10 +40750,10 @@ snapshots: '@babel/helper-annotate-as-pure': 7.18.6 '@babel/helper-plugin-utils': 7.22.5 - '@babel/plugin-transform-react-pure-annotations@7.22.5(@babel/core@7.21.4)': + '@babel/plugin-transform-react-pure-annotations@7.18.6(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 - '@babel/helper-annotate-as-pure': 7.22.5 + '@babel/core': 7.22.11 + '@babel/helper-annotate-as-pure': 7.18.6 '@babel/helper-plugin-utils': 7.22.5 '@babel/plugin-transform-react-pure-annotations@7.22.5(@babel/core@7.22.11)': @@ -40730,6 +40762,12 @@ snapshots: '@babel/helper-annotate-as-pure': 7.22.5 '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-transform-react-pure-annotations@7.22.5(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-annotate-as-pure': 7.22.5 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/plugin-transform-react-pure-annotations@7.22.5(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -40820,6 +40858,18 @@ snapshots: transitivePeerDependencies: - supports-color + '@babel/plugin-transform-runtime@7.23.2(@babel/core@7.22.11)': + dependencies: + '@babel/core': 7.22.11 + '@babel/helper-module-imports': 7.22.15 + '@babel/helper-plugin-utils': 7.22.5 + babel-plugin-polyfill-corejs2: 0.4.6(@babel/core@7.22.11) + babel-plugin-polyfill-corejs3: 0.8.5(@babel/core@7.22.11) + babel-plugin-polyfill-regenerator: 0.5.3(@babel/core@7.22.11) + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + '@babel/plugin-transform-runtime@7.23.2(@babel/core@7.24.4)': dependencies: '@babel/core': 7.24.4 @@ -41004,13 +41054,13 @@ snapshots: '@babel/core': 7.25.2 '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-transform-typescript@7.21.3(@babel/core@7.21.4)': + '@babel/plugin-transform-typescript@7.21.3(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-annotate-as-pure': 7.22.5 - '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.21.4) + '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.22.11) '@babel/helper-plugin-utils': 7.22.5 - '@babel/plugin-syntax-typescript': 7.21.4(@babel/core@7.21.4) + '@babel/plugin-syntax-typescript': 7.21.4(@babel/core@7.22.11) '@babel/plugin-transform-typescript@7.21.3(@babel/core@7.25.2)': dependencies: @@ -41706,19 +41756,19 @@ snapshots: transitivePeerDependencies: - supports-color - '@babel/preset-flow@7.22.15(@babel/core@7.21.4)': + '@babel/preset-flow@7.22.15(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.24.8 '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.21.4) + '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.22.11) - '@babel/preset-flow@7.22.15(@babel/core@7.22.11)': + '@babel/preset-flow@7.22.15(@babel/core@7.23.2)': dependencies: - '@babel/core': 7.22.11 + '@babel/core': 7.23.2 '@babel/helper-plugin-utils': 7.24.8 '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.22.11) + '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.23.2) '@babel/preset-flow@7.22.15(@babel/core@7.25.2)': dependencies: @@ -41786,15 +41836,15 @@ snapshots: '@babel/plugin-transform-react-jsx-development': 7.18.6(@babel/core@7.21.4) '@babel/plugin-transform-react-pure-annotations': 7.18.6(@babel/core@7.21.4) - '@babel/preset-react@7.22.15(@babel/core@7.21.4)': + '@babel/preset-react@7.18.6(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 - '@babel/helper-plugin-utils': 7.22.5 - '@babel/helper-validator-option': 7.22.15 - '@babel/plugin-transform-react-display-name': 7.22.5(@babel/core@7.21.4) - '@babel/plugin-transform-react-jsx': 7.22.15(@babel/core@7.21.4) - '@babel/plugin-transform-react-jsx-development': 7.22.5(@babel/core@7.21.4) - '@babel/plugin-transform-react-pure-annotations': 7.22.5(@babel/core@7.21.4) + '@babel/core': 7.22.11 + '@babel/helper-plugin-utils': 7.20.2 + '@babel/helper-validator-option': 7.21.0 + '@babel/plugin-transform-react-display-name': 7.18.6(@babel/core@7.22.11) + '@babel/plugin-transform-react-jsx': 7.21.0(@babel/core@7.22.11) + '@babel/plugin-transform-react-jsx-development': 7.18.6(@babel/core@7.22.11) + '@babel/plugin-transform-react-pure-annotations': 7.18.6(@babel/core@7.22.11) '@babel/preset-react@7.22.15(@babel/core@7.22.11)': dependencies: @@ -41806,6 +41856,16 @@ snapshots: '@babel/plugin-transform-react-jsx-development': 7.22.5(@babel/core@7.22.11) '@babel/plugin-transform-react-pure-annotations': 7.22.5(@babel/core@7.22.11) + '@babel/preset-react@7.22.15(@babel/core@7.23.2)': + dependencies: + '@babel/core': 7.23.2 + '@babel/helper-plugin-utils': 7.22.5 + '@babel/helper-validator-option': 7.22.15 + '@babel/plugin-transform-react-display-name': 7.22.5(@babel/core@7.23.2) + '@babel/plugin-transform-react-jsx': 7.22.15(@babel/core@7.23.2) + '@babel/plugin-transform-react-jsx-development': 7.22.5(@babel/core@7.23.2) + '@babel/plugin-transform-react-pure-annotations': 7.22.5(@babel/core@7.23.2) + '@babel/preset-react@7.22.15(@babel/core@7.25.2)': dependencies: '@babel/core': 7.25.2 @@ -41828,14 +41888,14 @@ snapshots: transitivePeerDependencies: - supports-color - '@babel/preset-typescript@7.21.4(@babel/core@7.21.4)': + '@babel/preset-typescript@7.21.4(@babel/core@7.22.11)': dependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 '@babel/helper-plugin-utils': 7.22.5 '@babel/helper-validator-option': 7.22.15 - '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.21.4) - '@babel/plugin-transform-modules-commonjs': 7.22.15(@babel/core@7.21.4) - '@babel/plugin-transform-typescript': 7.21.3(@babel/core@7.21.4) + '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.22.11) + '@babel/plugin-transform-modules-commonjs': 7.22.15(@babel/core@7.22.11) + '@babel/plugin-transform-typescript': 7.21.3(@babel/core@7.22.11) transitivePeerDependencies: - supports-color @@ -43149,11 +43209,11 @@ snapshots: to-pascal-case: 1.0.0 unescape-js: 1.1.4 - '@esbuild-plugins/node-resolve@0.2.2(esbuild@0.23.1)': + '@esbuild-plugins/node-resolve@0.2.2(esbuild@0.18.20)': dependencies: '@types/resolve': 1.20.2 debug: 4.3.6(supports-color@8.1.1) - esbuild: 0.23.1 + esbuild: 0.18.20 escape-string-regexp: 4.0.0 resolve: 1.22.8 transitivePeerDependencies: @@ -44260,6 +44320,41 @@ snapshots: - supports-color - ts-node + '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2))': + dependencies: + '@jest/console': 29.7.0 + '@jest/reporters': 29.7.0 + '@jest/test-result': 29.7.0 + '@jest/transform': 29.7.0 + '@jest/types': 29.6.3 + '@types/node': 20.16.5 + ansi-escapes: 4.3.2 + chalk: 4.1.2 + ci-info: 3.9.0 + exit: 0.1.2 + graceful-fs: 4.2.11 + jest-changed-files: 29.7.0 + jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + jest-haste-map: 29.7.0 + jest-message-util: 29.7.0 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-resolve-dependencies: 29.7.0 + jest-runner: 29.7.0 + jest-runtime: 29.7.0 + jest-snapshot: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + jest-watcher: 29.7.0 + micromatch: 4.0.8 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-ansi: 6.0.1 + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + - ts-node + '@jest/core@29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2))': dependencies: '@jest/console': 29.7.0 @@ -45371,11 +45466,11 @@ snapshots: - encoding - supports-color - '@mdx-js/esbuild@3.0.1(esbuild@0.23.1)': + '@mdx-js/esbuild@3.0.1(esbuild@0.18.20)': dependencies: '@mdx-js/mdx': 3.0.1 '@types/unist': 3.0.2 - esbuild: 0.23.1 + esbuild: 0.18.20 vfile: 6.0.1 vfile-message: 4.0.2 transitivePeerDependencies: @@ -48771,26 +48866,7 @@ snapshots: webpack-dev-server: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) webpack-hot-middleware: 2.26.1 - '@pmmmwh/react-refresh-webpack-plugin@0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))': - dependencies: - ansi-html-community: 0.0.8 - common-path-prefix: 3.0.0 - core-js-pure: 3.30.0 - error-stack-parser: 2.1.4 - find-up: 5.0.0 - html-entities: 2.3.3 - loader-utils: 2.0.4 - react-refresh: 0.11.0 - schema-utils: 3.3.0 - source-map: 0.7.4 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - optionalDependencies: - '@types/webpack': 5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - type-fest: 2.19.0 - webpack-dev-server: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - webpack-hot-middleware: 2.26.1 - - '@pmmmwh/react-refresh-webpack-plugin@0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4))': + '@pmmmwh/react-refresh-webpack-plugin@0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4))': dependencies: ansi-html-community: 0.0.8 common-path-prefix: 3.0.0 @@ -48802,11 +48878,10 @@ snapshots: react-refresh: 0.11.0 schema-utils: 3.3.0 source-map: 0.7.4 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) optionalDependencies: - '@types/webpack': 5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)) + '@types/webpack': 5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)) type-fest: 2.19.0 - webpack-dev-server: 4.11.1(webpack-cli@5.1.4)(webpack@5.78.0) webpack-hot-middleware: 2.26.1 '@pmmmwh/react-refresh-webpack-plugin@0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)))': @@ -53734,7 +53809,7 @@ snapshots: - uglify-js - webpack-cli - '@storybook/builder-webpack5@7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))': + '@storybook/builder-webpack5@7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)': dependencies: '@babel/core': 7.23.2 '@storybook/addons': 7.4.2(react-dom@18.3.1(react@18.3.1))(react@18.3.1) @@ -53756,30 +53831,30 @@ snapshots: '@swc/core': 1.3.107(@swc/helpers@0.5.12) '@types/node': 16.11.7 '@types/semver': 7.3.13 - babel-loader: 9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + babel-loader: 9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) babel-plugin-named-exports-order: 0.0.2 browser-assert: 1.2.1 case-sensitive-paths-webpack-plugin: 2.4.0 constants-browserify: 1.0.0 - css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) express: 4.21.0 - fork-ts-checker-webpack-plugin: 8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + fork-ts-checker-webpack-plugin: 8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) fs-extra: 11.2.0 - html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) path-browserify: 1.0.1 process: 0.11.10 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) semver: 7.6.3 - style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) - swc-loader: 0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) - terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) + swc-loader: 0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) + terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) ts-dedent: 2.2.0 url: 0.11.4 util: 0.12.5 util-deprecate: 1.0.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)) - webpack-dev-middleware: 6.1.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) + webpack-dev-middleware: 6.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) webpack-hot-middleware: 2.25.3 webpack-virtual-modules: 0.5.0 optionalDependencies: @@ -53794,7 +53869,7 @@ snapshots: - uglify-js - webpack-cli - '@storybook/builder-webpack5@7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)': + '@storybook/builder-webpack5@7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))': dependencies: '@babel/core': 7.23.2 '@storybook/addons': 7.4.2(react-dom@18.3.1(react@18.3.1))(react@18.3.1) @@ -53816,30 +53891,30 @@ snapshots: '@swc/core': 1.3.107(@swc/helpers@0.5.12) '@types/node': 16.11.7 '@types/semver': 7.3.13 - babel-loader: 9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + babel-loader: 9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) babel-plugin-named-exports-order: 0.0.2 browser-assert: 1.2.1 case-sensitive-paths-webpack-plugin: 2.4.0 constants-browserify: 1.0.0 - css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) express: 4.21.0 - fork-ts-checker-webpack-plugin: 8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + fork-ts-checker-webpack-plugin: 8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) fs-extra: 11.2.0 - html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) path-browserify: 1.0.1 process: 0.11.10 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) semver: 7.6.3 - style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - swc-loader: 0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) + swc-loader: 0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) + terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) ts-dedent: 2.2.0 url: 0.11.4 util: 0.12.5 util-deprecate: 1.0.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - webpack-dev-middleware: 6.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)) + webpack-dev-middleware: 6.1.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) webpack-hot-middleware: 2.25.3 webpack-virtual-modules: 0.5.0 optionalDependencies: @@ -54490,16 +54565,16 @@ snapshots: '@storybook/postinstall@7.4.2': {} - '@storybook/preset-create-react-app@7.4.2(f7avyblvzm233o6g7idqcb345u)': + '@storybook/preset-create-react-app@7.4.2(ucmnrhmq4kewpo24xrp57f5r6y)': dependencies: - '@babel/core': 7.21.4 - '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + '@babel/core': 7.22.11 + '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) '@storybook/types': 7.4.2 '@types/babel__core': 7.20.0 babel-plugin-react-docgen: 4.2.1 pnp-webpack-plugin: 1.7.0(typescript@5.6.2) - react-scripts: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) + react-scripts: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) semver: 7.5.4 transitivePeerDependencies: - '@types/webpack' @@ -54513,16 +54588,16 @@ snapshots: - webpack-hot-middleware - webpack-plugin-serve - '@storybook/preset-react-webpack@7.4.2(@babel/core@7.21.4)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)': + '@storybook/preset-react-webpack@7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)': dependencies: - '@babel/preset-flow': 7.22.15(@babel/core@7.21.4) - '@babel/preset-react': 7.22.15(@babel/core@7.21.4) - '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + '@babel/preset-flow': 7.22.15(@babel/core@7.22.11) + '@babel/preset-react': 7.22.15(@babel/core@7.22.11) + '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) '@storybook/core-webpack': 7.4.2(encoding@0.1.13) '@storybook/docs-tools': 7.4.2(encoding@0.1.13) '@storybook/node-logger': 7.4.2 '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) - '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) '@types/node': 16.11.7 '@types/semver': 7.5.8 babel-plugin-add-react-displayname: 0.0.5 @@ -54532,9 +54607,9 @@ snapshots: react-dom: 18.3.1(react@18.3.1) react-refresh: 0.11.0 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 typescript: 5.6.2 transitivePeerDependencies: - '@swc/core' @@ -54550,16 +54625,16 @@ snapshots: - webpack-hot-middleware - webpack-plugin-serve - '@storybook/preset-react-webpack@7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)': + '@storybook/preset-react-webpack@7.4.2(@babel/core@7.23.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-hot-middleware@2.26.1)': dependencies: - '@babel/preset-flow': 7.22.15(@babel/core@7.22.11) - '@babel/preset-react': 7.22.15(@babel/core@7.22.11) - '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + '@babel/preset-flow': 7.22.15(@babel/core@7.23.2) + '@babel/preset-react': 7.22.15(@babel/core@7.23.2) + '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))) '@storybook/core-webpack': 7.4.2(encoding@0.1.13) '@storybook/docs-tools': 7.4.2(encoding@0.1.13) '@storybook/node-logger': 7.4.2 '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) - '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))) '@types/node': 16.11.7 '@types/semver': 7.5.8 babel-plugin-add-react-displayname: 0.0.5 @@ -54569,9 +54644,9 @@ snapshots: react-dom: 18.3.1(react@18.3.1) react-refresh: 0.11.0 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) optionalDependencies: - '@babel/core': 7.22.11 + '@babel/core': 7.23.2 typescript: 5.6.2 transitivePeerDependencies: - '@swc/core' @@ -54587,16 +54662,16 @@ snapshots: - webpack-hot-middleware - webpack-plugin-serve - '@storybook/preset-react-webpack@7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)': + '@storybook/preset-react-webpack@7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)': dependencies: '@babel/preset-flow': 7.22.15(@babel/core@7.25.2) '@babel/preset-react': 7.22.15(@babel/core@7.25.2) - '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) '@storybook/core-webpack': 7.4.2(encoding@0.1.13) '@storybook/docs-tools': 7.4.2(encoding@0.1.13) '@storybook/node-logger': 7.4.2 '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) - '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + '@storybook/react-docgen-typescript-plugin': 1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) '@types/node': 16.11.7 '@types/semver': 7.5.8 babel-plugin-add-react-displayname: 0.0.5 @@ -54606,7 +54681,7 @@ snapshots: react-dom: 18.3.1(react@18.3.1) react-refresh: 0.11.0 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) optionalDependencies: '@babel/core': 7.25.2 typescript: 5.6.2 @@ -54710,7 +54785,7 @@ snapshots: transitivePeerDependencies: - supports-color - '@storybook/react-docgen-typescript-plugin@1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))': + '@storybook/react-docgen-typescript-plugin@1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4))': dependencies: debug: 4.3.6(supports-color@8.1.1) endent: 2.1.0 @@ -54720,11 +54795,11 @@ snapshots: react-docgen-typescript: 2.2.2(typescript@5.6.2) tslib: 2.7.0 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) transitivePeerDependencies: - supports-color - '@storybook/react-docgen-typescript-plugin@1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4))': + '@storybook/react-docgen-typescript-plugin@1.0.6--canary.9.0c3f3b7.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)))': dependencies: debug: 4.3.6(supports-color@8.1.1) endent: 2.1.0 @@ -54734,7 +54809,7 @@ snapshots: react-docgen-typescript: 2.2.2(typescript@5.6.2) tslib: 2.7.0 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) transitivePeerDependencies: - supports-color @@ -54774,16 +54849,16 @@ snapshots: - vite-plugin-glimmerx - webpack-sources - '@storybook/react-webpack5@7.4.2(@babel/core@7.21.4)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)': + '@storybook/react-webpack5@7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)': dependencies: - '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) - '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.21.4)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(encoding@0.1.13)(esbuild@0.23.1)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1) + '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) + '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1) '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@types/node': 16.11.7 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) optionalDependencies: - '@babel/core': 7.21.4 + '@babel/core': 7.22.11 typescript: 5.6.2 transitivePeerDependencies: - '@swc/core' @@ -54802,16 +54877,16 @@ snapshots: - webpack-hot-middleware - webpack-plugin-serve - '@storybook/react-webpack5@7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)': + '@storybook/react-webpack5@7.4.2(@babel/core@7.23.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-hot-middleware@2.26.1)': dependencies: - '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) - '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.22.11)(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1) + '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) + '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.23.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-hot-middleware@2.26.1) '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@types/node': 16.11.7 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) optionalDependencies: - '@babel/core': 7.22.11 + '@babel/core': 7.23.2 typescript: 5.6.2 transitivePeerDependencies: - '@swc/core' @@ -54830,10 +54905,10 @@ snapshots: - webpack-hot-middleware - webpack-plugin-serve - '@storybook/react-webpack5@7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)': + '@storybook/react-webpack5@7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack-hot-middleware@2.26.1)': dependencies: - '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)) - '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)))(encoding@0.1.13)(esbuild@0.18.20)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack-hot-middleware@2.26.1) + '@storybook/builder-webpack5': 7.4.2(@swc/helpers@0.5.12)(@types/react-dom@18.3.0)(@types/react@18.3.3)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)) + '@storybook/preset-react-webpack': 7.4.2(@babel/core@7.25.2)(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)))(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(type-fest@2.19.0)(typescript@5.6.2)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack-hot-middleware@2.26.1) '@storybook/react': 7.4.2(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(typescript@5.6.2) '@types/node': 16.11.7 react: 18.3.1 @@ -55469,7 +55544,7 @@ snapshots: pretty-format: 24.9.0 redent: 3.0.0 - '@testing-library/jest-dom@6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@24.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6))': + '@testing-library/jest-dom@6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@24.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6))': dependencies: '@adobe/css-tools': 4.3.3 '@babel/runtime': 7.23.2 @@ -55482,10 +55557,10 @@ snapshots: optionalDependencies: '@jest/globals': 29.7.0 '@types/jest': 29.5.13 - jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) vitest: 1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@24.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.47))(terser@5.31.6) - '@testing-library/jest-dom@6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@25.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.38))(terser@5.31.6))': + '@testing-library/jest-dom@6.4.2(@jest/globals@29.7.0)(@types/jest@29.5.13)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(vitest@1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@25.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.38))(terser@5.31.6))': dependencies: '@adobe/css-tools': 4.3.3 '@babel/runtime': 7.23.2 @@ -55498,7 +55573,7 @@ snapshots: optionalDependencies: '@jest/globals': 29.7.0 '@types/jest': 29.5.13 - jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) vitest: 1.2.1(@edge-runtime/vm@4.0.2)(@types/node@20.16.5)(jsdom@25.0.0)(less@4.2.0)(lightningcss@1.26.0)(sass@1.77.8)(sugarss@4.0.1(postcss@8.4.38))(terser@5.31.6) '@testing-library/react-hooks@8.0.1(@types/react@18.3.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)': @@ -56659,18 +56734,6 @@ snapshots: - webpack-cli optional: true - '@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)': - dependencies: - '@types/node': 20.16.5 - tapable: 2.2.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - transitivePeerDependencies: - - '@swc/core' - - esbuild - - uglify-js - - webpack-cli - optional: true - '@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))': dependencies: '@types/node': 20.16.5 @@ -56683,11 +56746,11 @@ snapshots: - webpack-cli optional: true - '@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))': + '@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))': dependencies: '@types/node': 20.16.5 tapable: 2.2.1 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) transitivePeerDependencies: - '@swc/core' - esbuild @@ -58185,32 +58248,30 @@ snapshots: webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) webpack-cli: 5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0) - '@webpack-cli/configtest@2.1.1(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4))': + '@webpack-cli/configtest@2.1.1(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4))': dependencies: - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) '@webpack-cli/info@2.0.2(webpack-cli@5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4))': dependencies: webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) webpack-cli: 5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0) - '@webpack-cli/info@2.0.2(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4))': + '@webpack-cli/info@2.0.2(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4))': dependencies: - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) '@webpack-cli/serve@2.0.5(webpack-cli@5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4))': dependencies: webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) webpack-cli: 5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0) - '@webpack-cli/serve@2.0.5(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4))': + '@webpack-cli/serve@2.0.5(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4))': dependencies: - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) - optionalDependencies: - webpack-dev-server: 4.11.1(webpack-cli@5.1.4)(webpack@5.78.0) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) '@wry/context@0.4.4': dependencies: @@ -59332,42 +59393,43 @@ snapshots: transitivePeerDependencies: - supports-color - babel-jest@27.5.1(@babel/core@7.24.4): + babel-jest@27.5.1(@babel/core@7.24.3): dependencies: - '@babel/core': 7.24.4 + '@babel/core': 7.24.3 '@jest/transform': 27.5.1 '@jest/types': 27.5.1 '@types/babel__core': 7.20.3 babel-plugin-istanbul: 6.1.1 - babel-preset-jest: 27.5.1(@babel/core@7.24.4) + babel-preset-jest: 27.5.1(@babel/core@7.24.3) chalk: 4.1.2 graceful-fs: 4.2.11 slash: 3.0.0 transitivePeerDependencies: - supports-color + optional: true - babel-jest@27.5.1(@babel/core@7.25.2): + babel-jest@27.5.1(@babel/core@7.24.4): dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.24.4 '@jest/transform': 27.5.1 '@jest/types': 27.5.1 '@types/babel__core': 7.20.3 babel-plugin-istanbul: 6.1.1 - babel-preset-jest: 27.5.1(@babel/core@7.25.2) + babel-preset-jest: 27.5.1(@babel/core@7.24.4) chalk: 4.1.2 graceful-fs: 4.2.11 slash: 3.0.0 transitivePeerDependencies: - supports-color - optional: true - babel-jest@29.7.0(@babel/core@7.24.4): + babel-jest@27.5.1(@babel/core@7.25.2): dependencies: - '@babel/core': 7.24.4 - '@jest/transform': 29.7.0 - '@types/babel__core': 7.20.5 + '@babel/core': 7.25.2 + '@jest/transform': 27.5.1 + '@jest/types': 27.5.1 + '@types/babel__core': 7.20.3 babel-plugin-istanbul: 6.1.1 - babel-preset-jest: 29.6.3(@babel/core@7.24.4) + babel-preset-jest: 27.5.1(@babel/core@7.25.2) chalk: 4.1.2 graceful-fs: 4.2.11 slash: 3.0.0 @@ -59388,14 +59450,14 @@ snapshots: transitivePeerDependencies: - supports-color - babel-loader@8.3.0(@babel/core@7.21.4)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + babel-loader@8.3.0(@babel/core@7.21.4)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: '@babel/core': 7.21.4 find-cache-dir: 3.3.2 loader-utils: 2.0.4 make-dir: 3.1.0 schema-utils: 2.7.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) babel-loader@8.3.0(@babel/core@7.21.4)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -59406,14 +59468,14 @@ snapshots: schema-utils: 2.7.1 webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) - babel-loader@8.3.0(@babel/core@7.25.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + babel-loader@8.3.0(@babel/core@7.25.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@babel/core': 7.25.2 find-cache-dir: 3.3.2 loader-utils: 2.0.4 make-dir: 3.1.0 schema-utils: 2.7.1 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) babel-loader@9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: @@ -59422,19 +59484,19 @@ snapshots: schema-utils: 4.0.0 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - babel-loader@9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + babel-loader@9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: '@babel/core': 7.23.2 find-cache-dir: 3.3.2 schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - babel-loader@9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + babel-loader@9.1.2(@babel/core@7.23.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@babel/core': 7.23.2 find-cache-dir: 3.3.2 schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) babel-plugin-add-react-displayname@0.0.5: {} @@ -59704,6 +59766,23 @@ snapshots: '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.21.4) '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.21.4) + babel-preset-current-node-syntax@1.0.1(@babel/core@7.24.3): + dependencies: + '@babel/core': 7.24.3 + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.24.3) + '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.24.3) + '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.24.3) + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.24.3) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.24.3) + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.24.3) + '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.24.3) + optional: true + babel-preset-current-node-syntax@1.0.1(@babel/core@7.24.4): dependencies: '@babel/core': 7.24.4 @@ -59742,6 +59821,13 @@ snapshots: babel-plugin-jest-hoist: 27.5.1 babel-preset-current-node-syntax: 1.0.1(@babel/core@7.21.4) + babel-preset-jest@27.5.1(@babel/core@7.24.3): + dependencies: + '@babel/core': 7.24.3 + babel-plugin-jest-hoist: 27.5.1 + babel-preset-current-node-syntax: 1.0.1(@babel/core@7.24.3) + optional: true + babel-preset-jest@27.5.1(@babel/core@7.24.4): dependencies: '@babel/core': 7.24.4 @@ -59755,13 +59841,6 @@ snapshots: babel-preset-current-node-syntax: 1.0.1(@babel/core@7.25.2) optional: true - babel-preset-jest@29.6.3(@babel/core@7.24.4): - dependencies: - '@babel/core': 7.24.4 - babel-plugin-jest-hoist: 29.6.3 - babel-preset-current-node-syntax: 1.0.1(@babel/core@7.24.4) - optional: true - babel-preset-jest@29.6.3(@babel/core@7.25.2): dependencies: '@babel/core': 7.25.2 @@ -61010,17 +61089,17 @@ snapshots: dependencies: mime-db: 1.52.0 - compression-webpack-plugin@10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + compression-webpack-plugin@10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): dependencies: schema-utils: 4.0.0 serialize-javascript: 6.0.1 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) - compression-webpack-plugin@10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): + compression-webpack-plugin@10.0.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: schema-utils: 4.0.0 serialize-javascript: 6.0.1 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) compression@1.7.4: dependencies: @@ -61338,13 +61417,13 @@ snapshots: - supports-color - ts-node - create-jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)): + create-jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: '@jest/types': 29.6.3 chalk: 4.1.2 exit: 0.1.2 graceful-fs: 4.2.11 - jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 29.7.0 prompts: 2.4.2 transitivePeerDependencies: @@ -61353,13 +61432,13 @@ snapshots: - supports-color - ts-node - create-jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): + create-jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: '@jest/types': 29.6.3 chalk: 4.1.2 exit: 0.1.2 graceful-fs: 4.2.11 - jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 29.7.0 prompts: 2.4.2 transitivePeerDependencies: @@ -61707,7 +61786,7 @@ snapshots: semver: 7.6.3 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - css-loader@6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + css-loader@6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: icss-utils: 5.1.0(postcss@8.4.47) postcss: 8.4.47 @@ -61717,9 +61796,9 @@ snapshots: postcss-modules-values: 4.0.0(postcss@8.4.47) postcss-value-parser: 4.2.0 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - css-loader@6.7.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + css-loader@6.7.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: icss-utils: 5.1.0(postcss@8.4.47) postcss: 8.4.47 @@ -61729,7 +61808,7 @@ snapshots: postcss-modules-values: 4.0.0(postcss@8.4.47) postcss-value-parser: 4.2.0 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) css-loader@6.7.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -61743,7 +61822,7 @@ snapshots: semver: 7.6.3 webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) - css-minimizer-webpack-plugin@3.4.1(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + css-minimizer-webpack-plugin@3.4.1(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: cssnano: 5.1.15(postcss@8.4.47) jest-worker: 27.5.1 @@ -61751,9 +61830,9 @@ snapshots: schema-utils: 4.0.0 serialize-javascript: 6.0.2 source-map: 0.6.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: - esbuild: 0.23.1 + esbuild: 0.18.20 css-minimizer-webpack-plugin@3.4.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -63361,7 +63440,7 @@ snapshots: dependencies: eslint: 8.57.1 - eslint-config-react-app@7.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): + eslint-config-react-app@7.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): dependencies: '@babel/core': 7.21.4 '@babel/eslint-parser': 7.25.1(@babel/core@7.21.4)(eslint@9.9.1(jiti@1.21.6)) @@ -63371,7 +63450,7 @@ snapshots: babel-preset-react-app: 10.0.1 confusing-browser-globals: 1.0.11 eslint: 9.9.1(jiti@1.21.6) - eslint-plugin-flowtype: 8.0.3(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(eslint@9.9.1(jiti@1.21.6)) + eslint-plugin-flowtype: 8.0.3(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(eslint@9.9.1(jiti@1.21.6)) eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.62.0(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6)) eslint-plugin-jest: 25.7.0(@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@5.62.0(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2))(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2))(eslint@9.9.1(jiti@1.21.6))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) eslint-plugin-jsx-a11y: 6.9.0(eslint@9.9.1(jiti@1.21.6)) @@ -63496,10 +63575,10 @@ snapshots: eslint: 8.57.1 ignore: 5.3.2 - eslint-plugin-flowtype@8.0.3(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(eslint@9.9.1(jiti@1.21.6)): + eslint-plugin-flowtype@8.0.3(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(eslint@9.9.1(jiti@1.21.6)): dependencies: - '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.21.4) - '@babel/plugin-transform-react-jsx': 7.25.2(@babel/core@7.21.4) + '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.22.11) + '@babel/plugin-transform-react-jsx': 7.25.2(@babel/core@7.22.11) eslint: 9.9.1(jiti@1.21.6) lodash: 4.17.21 string-natural-compare: 3.0.1 @@ -63936,7 +64015,7 @@ snapshots: eslint-visitor-keys@4.0.0: {} - eslint-webpack-plugin@3.2.0(eslint@9.9.1(jiti@1.21.6))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + eslint-webpack-plugin@3.2.0(eslint@9.9.1(jiti@1.21.6))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: '@types/eslint': 8.56.12 eslint: 9.9.1(jiti@1.21.6) @@ -63944,7 +64023,7 @@ snapshots: micromatch: 4.0.8 normalize-path: 3.0.0 schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) eslint-webpack-plugin@3.2.0(eslint@9.9.1(jiti@1.21.6))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -64683,26 +64762,26 @@ snapshots: loader-utils: 2.0.4 schema-utils: 3.3.0 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - optional: true - file-loader@6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: loader-utils: 2.0.4 schema-utils: 3.3.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) + optional: true - file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: loader-utils: 2.0.4 schema-utils: 3.3.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - optional: true + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) - file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): + file-loader@6.2.0(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: loader-utils: 2.0.4 schema-utils: 3.3.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) + webpack: 5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) + optional: true file-selector@0.6.0: dependencies: @@ -64936,7 +65015,7 @@ snapshots: forever-agent@0.6.1: {} - fork-ts-checker-webpack-plugin@6.5.3(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + fork-ts-checker-webpack-plugin@6.5.3(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: '@babel/code-frame': 7.24.7 '@types/json-schema': 7.0.15 @@ -64952,7 +65031,7 @@ snapshots: semver: 7.6.3 tapable: 1.1.3 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: eslint: 9.9.1(jiti@1.21.6) vue-template-compiler: 2.7.16 @@ -64995,7 +65074,7 @@ snapshots: typescript: 5.6.2 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - fork-ts-checker-webpack-plugin@8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + fork-ts-checker-webpack-plugin@8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: '@babel/code-frame': 7.24.7 chalk: 4.1.2 @@ -65010,9 +65089,9 @@ snapshots: semver: 7.6.3 tapable: 2.2.1 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - fork-ts-checker-webpack-plugin@8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + fork-ts-checker-webpack-plugin@8.0.0(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@babel/code-frame': 7.24.7 chalk: 4.1.2 @@ -65027,7 +65106,7 @@ snapshots: semver: 7.6.3 tapable: 2.2.1 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) fork-ts-checker-webpack-plugin@9.0.2(typescript@5.3.3)(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -65070,8 +65149,6 @@ snapshots: combined-stream: 1.0.8 mime-types: 2.1.35 - format-util@1.0.5: {} - format@0.2.2: {} formdata-polyfill@4.0.10: @@ -66249,23 +66326,23 @@ snapshots: tapable: 2.2.1 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - html-webpack-plugin@5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + html-webpack-plugin@5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: '@types/html-minifier-terser': 6.1.0 html-minifier-terser: 6.1.0 lodash: 4.17.21 pretty-error: 4.0.0 tapable: 2.2.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - html-webpack-plugin@5.5.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + html-webpack-plugin@5.5.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@types/html-minifier-terser': 6.1.0 html-minifier-terser: 6.1.0 lodash: 4.17.21 pretty-error: 4.0.0 tapable: 2.2.1 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) html-webpack-plugin@5.5.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -67513,16 +67590,16 @@ snapshots: - supports-color - ts-node - jest-cli@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)): + jest-cli@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: - '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) '@jest/test-result': 29.7.0 '@jest/types': 29.6.3 chalk: 4.1.2 - create-jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + create-jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) exit: 0.1.2 import-local: 3.1.0 - jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 29.7.0 jest-validate: 29.7.0 yargs: 17.7.2 @@ -67532,16 +67609,16 @@ snapshots: - supports-color - ts-node - jest-cli@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): + jest-cli@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: - '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) '@jest/test-result': 29.7.0 '@jest/types': 29.6.3 chalk: 4.1.2 - create-jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + create-jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) exit: 0.1.2 import-local: 3.1.0 - jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + jest-config: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 29.7.0 jest-validate: 29.7.0 yargs: 17.7.2 @@ -67833,6 +67910,37 @@ snapshots: - babel-plugin-macros - supports-color + jest-config@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): + dependencies: + '@babel/core': 7.25.2 + '@jest/test-sequencer': 29.7.0 + '@jest/types': 29.6.3 + babel-jest: 29.7.0(@babel/core@7.25.2) + chalk: 4.1.2 + ci-info: 3.9.0 + deepmerge: 4.3.1 + glob: 7.2.3 + graceful-fs: 4.2.11 + jest-circus: 29.7.0(babel-plugin-macros@3.1.0) + jest-environment-node: 29.7.0 + jest-get-type: 29.6.3 + jest-regex-util: 29.6.3 + jest-resolve: 29.7.0 + jest-runner: 29.7.0 + jest-util: 29.7.0 + jest-validate: 29.7.0 + micromatch: 4.0.8 + parse-json: 5.2.0 + pretty-format: 29.7.0 + slash: 3.0.0 + strip-json-comments: 3.1.1 + optionalDependencies: + '@types/node': 20.16.5 + ts-node: 10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2) + transitivePeerDependencies: + - babel-plugin-macros + - supports-color + jest-config@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: '@babel/core': 7.25.2 @@ -68567,24 +68675,24 @@ snapshots: - supports-color - ts-node - jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)): + jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: - '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) '@jest/types': 29.6.3 import-local: 3.1.0 - jest-cli: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest-cli: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) transitivePeerDependencies: - '@types/node' - babel-plugin-macros - supports-color - ts-node - jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): + jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)): dependencies: - '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + '@jest/core': 29.7.0(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) '@jest/types': 29.6.3 import-local: 3.1.0 - jest-cli: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + jest-cli: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) transitivePeerDependencies: - '@types/node' - babel-plugin-macros @@ -68896,23 +69004,12 @@ snapshots: dependencies: lodash: 4.17.21 - json-schema-faker@0.5.6: - dependencies: - json-schema-ref-parser: 6.1.0 - jsonpath-plus: 7.2.0 - json-schema-merge-allof@0.8.1: dependencies: compute-lcm: 1.1.2 json-schema-compare: 0.2.2 lodash: 4.17.21 - json-schema-ref-parser@6.1.0: - dependencies: - call-me-maybe: 1.0.2 - js-yaml: 3.14.1 - ono: 4.0.11 - json-schema-to-ts@1.6.4: dependencies: '@types/json-schema': 7.0.15 @@ -68977,8 +69074,6 @@ snapshots: jsonpath-plus@7.1.0: {} - jsonpath-plus@7.2.0: {} - jsonpointer@5.0.1: {} jsonwebtoken@9.0.0: @@ -69219,13 +69314,13 @@ snapshots: - encoding - supports-color - less-loader@4.1.0(less@4.1.3)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + less-loader@4.1.0(less@4.1.3)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: clone: 2.1.2 less: 4.1.3 loader-utils: 1.4.2 pify: 3.0.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) less-loader@4.1.0(less@4.1.3)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -70361,13 +70456,13 @@ snapshots: mdurl@2.0.0: {} - mdx-bundler@10.0.2(esbuild@0.23.1): + mdx-bundler@10.0.2(esbuild@0.18.20): dependencies: '@babel/runtime': 7.24.7 - '@esbuild-plugins/node-resolve': 0.2.2(esbuild@0.23.1) + '@esbuild-plugins/node-resolve': 0.2.2(esbuild@0.18.20) '@fal-works/esbuild-plugin-global-externals': 2.1.2 - '@mdx-js/esbuild': 3.0.1(esbuild@0.23.1) - esbuild: 0.23.1 + '@mdx-js/esbuild': 3.0.1(esbuild@0.18.20) + esbuild: 0.18.20 gray-matter: 4.0.3 remark-frontmatter: 5.0.0 remark-mdx-frontmatter: 4.0.0 @@ -71027,10 +71122,10 @@ snapshots: min-indent@1.0.1: {} - mini-css-extract-plugin@2.7.5(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + mini-css-extract-plugin@2.7.5(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) mini-css-extract-plugin@2.7.5(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -71641,7 +71736,7 @@ snapshots: react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - next@13.5.6(@babel/core@7.25.2)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8): + next@13.5.6(@babel/core@7.24.3)(@opentelemetry/api@1.9.0)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8): dependencies: '@next/env': 13.5.6 '@swc/helpers': 0.5.2 @@ -71650,7 +71745,7 @@ snapshots: postcss: 8.4.31 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - styled-jsx: 5.1.1(@babel/core@7.25.2)(babel-plugin-macros@3.1.0)(react@18.3.1) + styled-jsx: 5.1.1(@babel/core@7.24.3)(babel-plugin-macros@3.1.0)(react@18.3.1) watchpack: 2.4.0 optionalDependencies: '@next/swc-darwin-arm64': 13.5.6 @@ -71668,7 +71763,7 @@ snapshots: - '@babel/core' - babel-plugin-macros - next@14.2.4(@babel/core@7.25.2)(@opentelemetry/api@1.9.0)(@playwright/test@1.46.1)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8): + next@14.2.4(@babel/core@7.24.3)(@opentelemetry/api@1.9.0)(@playwright/test@1.46.1)(babel-plugin-macros@3.1.0)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.77.8): dependencies: '@next/env': 14.2.4 '@swc/helpers': 0.5.5 @@ -71678,7 +71773,7 @@ snapshots: postcss: 8.4.31 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - styled-jsx: 5.1.1(@babel/core@7.25.2)(babel-plugin-macros@3.1.0)(react@18.3.1) + styled-jsx: 5.1.1(@babel/core@7.24.3)(babel-plugin-macros@3.1.0)(react@18.3.1) optionalDependencies: '@next/swc-darwin-arm64': 14.2.4 '@next/swc-darwin-x64': 14.2.4 @@ -72433,10 +72528,6 @@ snapshots: dependencies: mimic-fn: 4.0.0 - ono@4.0.11: - dependencies: - format-util: 1.0.5 - open-cli@6.0.1: dependencies: file-type: 16.5.4 @@ -73648,13 +73739,13 @@ snapshots: tsx: 4.19.0 yaml: 2.5.0 - postcss-loader@6.2.1(postcss@8.4.47)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + postcss-loader@6.2.1(postcss@8.4.47)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: cosmiconfig: 7.1.0 klona: 2.0.6 postcss: 8.4.47 semver: 7.6.3 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) postcss-loader@6.2.1(postcss@8.4.47)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -75245,9 +75336,9 @@ snapshots: regenerator-runtime: 0.13.11 whatwg-fetch: 3.6.2 - react-app-rewired@2.2.1(react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1)): + react-app-rewired@2.2.1(react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1)): dependencies: - react-scripts: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) + react-scripts: 5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1) semver: 5.7.2 react-app-rewired@2.2.1(react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.25.2))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.25.2))(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.7.26(@swc/helpers@0.5.12)))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1)): @@ -75288,7 +75379,7 @@ snapshots: react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - react-dev-utils@12.0.1(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + react-dev-utils@12.0.1(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: '@babel/code-frame': 7.24.2 address: 1.2.2 @@ -75299,7 +75390,7 @@ snapshots: escape-string-regexp: 4.0.0 filesize: 8.0.7 find-up: 5.0.0 - fork-ts-checker-webpack-plugin: 6.5.3(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + fork-ts-checker-webpack-plugin: 6.5.3(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) global-modules: 2.0.0 globby: 11.1.0 gzip-size: 6.0.0 @@ -75314,7 +75405,7 @@ snapshots: shell-quote: 1.8.1 strip-ansi: 6.0.1 text-table: 0.2.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: typescript: 5.6.2 transitivePeerDependencies: @@ -75646,56 +75737,56 @@ snapshots: transitivePeerDependencies: - supports-color - react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(esbuild@0.23.1)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1): + react-scripts@5.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/babel__core@7.20.5)(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(esbuild@0.18.20)(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(react@18.3.1)(sass@1.77.8)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))(type-fest@2.19.0)(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack-hot-middleware@2.26.1): dependencies: '@babel/core': 7.21.4 - '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + '@pmmmwh/react-refresh-webpack-plugin': 0.5.10(@types/webpack@5.28.5(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20))(react-refresh@0.11.0)(type-fest@2.19.0)(webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack-hot-middleware@2.26.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) '@svgr/webpack': 5.5.0 babel-jest: 27.5.1(@babel/core@7.21.4) - babel-loader: 8.3.0(@babel/core@7.21.4)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + babel-loader: 8.3.0(@babel/core@7.21.4)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) babel-plugin-named-asset-import: 0.3.8(@babel/core@7.21.4) babel-preset-react-app: 10.0.1 bfj: 7.0.2 browserslist: 4.21.5 camelcase: 6.3.0 case-sensitive-paths-webpack-plugin: 2.4.0 - css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - css-minimizer-webpack-plugin: 3.4.1(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + css-loader: 6.7.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + css-minimizer-webpack-plugin: 3.4.1(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) dotenv: 10.0.0 dotenv-expand: 5.1.0 eslint: 9.9.1(jiti@1.21.6) - eslint-config-react-app: 7.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.21.4))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.21.4))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) - eslint-webpack-plugin: 3.2.0(eslint@9.9.1(jiti@1.21.6))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - file-loader: 6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + eslint-config-react-app: 7.0.1(@babel/plugin-syntax-flow@7.24.7(@babel/core@7.22.11))(@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.22.11))(eslint-import-resolver-webpack@0.13.8(eslint-plugin-import@2.29.1)(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))))(eslint@9.9.1(jiti@1.21.6))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2) + eslint-webpack-plugin: 3.2.0(eslint@9.9.1(jiti@1.21.6))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + file-loader: 6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) fs-extra: 10.1.0 - html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + html-webpack-plugin: 5.5.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) identity-obj-proxy: 3.0.0 jest: 27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) jest-resolve: 27.5.1 jest-watch-typeahead: 1.1.0(jest@27.5.1(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2))) - mini-css-extract-plugin: 2.7.5(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + mini-css-extract-plugin: 2.7.5(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) postcss: 8.4.47 postcss-flexbugs-fixes: 5.0.2(postcss@8.4.47) - postcss-loader: 6.2.1(postcss@8.4.47)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + postcss-loader: 6.2.1(postcss@8.4.47)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) postcss-normalize: 10.0.1(browserslist@4.21.5)(postcss@8.4.47) postcss-preset-env: 7.8.3(postcss@8.4.47) prompts: 2.4.2 react: 18.3.1 react-app-polyfill: 3.0.0 - react-dev-utils: 12.0.1(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + react-dev-utils: 12.0.1(eslint@9.9.1(jiti@1.21.6))(typescript@5.6.2)(vue-template-compiler@2.7.16)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) react-refresh: 0.11.0 resolve: 1.22.2 resolve-url-loader: 4.0.0 - sass-loader: 12.6.0(sass@1.77.8)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + sass-loader: 12.6.0(sass@1.77.8)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) semver: 7.5.4 - source-map-loader: 3.0.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + source-map-loader: 3.0.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + style-loader: 3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) tailwindcss: 3.4.13(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) - terser-webpack-plugin: 5.3.7(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - webpack-dev-server: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - webpack-manifest-plugin: 4.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - workbox-webpack-plugin: 6.5.4(@types/babel__core@7.20.5)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + terser-webpack-plugin: 5.3.7(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) + webpack-dev-server: 4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + webpack-manifest-plugin: 4.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + workbox-webpack-plugin: 6.5.4(@types/babel__core@7.20.5)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) optionalDependencies: fsevents: 2.3.3 typescript: 5.6.2 @@ -76795,11 +76886,11 @@ snapshots: sanitize.css@13.0.0: {} - sass-loader@12.6.0(sass@1.77.8)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + sass-loader@12.6.0(sass@1.77.8)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: klona: 2.0.6 neo-async: 2.6.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: sass: 1.77.8 @@ -77448,12 +77539,12 @@ snapshots: source-map-js@1.2.1: {} - source-map-loader@3.0.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + source-map-loader@3.0.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: abab: 2.0.6 iconv-lite: 0.6.3 source-map-js: 1.2.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) source-map-loader@3.0.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -77997,13 +78088,13 @@ snapshots: dependencies: webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - style-loader@3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + style-loader@3.3.2(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - style-loader@3.3.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + style-loader@3.3.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) style-loader@3.3.2(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -78017,12 +78108,12 @@ snapshots: dependencies: inline-style-parser: 0.2.3 - styled-jsx@5.1.1(@babel/core@7.25.2)(babel-plugin-macros@3.1.0)(react@18.3.1): + styled-jsx@5.1.1(@babel/core@7.24.3)(babel-plugin-macros@3.1.0)(react@18.3.1): dependencies: client-only: 0.0.1 react: 18.3.1 optionalDependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.24.3 babel-plugin-macros: 3.1.0 stylehacks@5.1.1(postcss@8.4.47): @@ -78292,15 +78383,15 @@ snapshots: '@swc/core': 1.3.107(@swc/helpers@0.5.12) webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - swc-loader@0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + swc-loader@0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - swc-loader@0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + swc-loader@0.2.3(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) swr@2.2.5(react@18.3.1): dependencies: @@ -78614,29 +78705,27 @@ snapshots: '@swc/core': 1.3.107(@swc/helpers@0.5.12) esbuild: 0.18.20 - terser-webpack-plugin@5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + terser-webpack-plugin@5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: '@jridgewell/trace-mapping': 0.3.25 jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.2 terser: 5.31.6 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) optionalDependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - esbuild: 0.18.20 - terser-webpack-plugin@5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + terser-webpack-plugin@5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@jridgewell/trace-mapping': 0.3.25 jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.2 terser: 5.31.6 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) optionalDependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - esbuild: 0.23.1 terser-webpack-plugin@5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.94.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: @@ -78649,29 +78738,28 @@ snapshots: optionalDependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - terser-webpack-plugin@5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + terser-webpack-plugin@5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): dependencies: '@jridgewell/trace-mapping': 0.3.25 jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.2 terser: 5.31.6 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) optionalDependencies: '@swc/core': 1.7.26(@swc/helpers@0.5.12) - esbuild: 0.18.20 + esbuild: 0.23.1 - terser-webpack-plugin@5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): + terser-webpack-plugin@5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: '@jridgewell/trace-mapping': 0.3.25 jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.2 terser: 5.31.6 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) optionalDependencies: '@swc/core': 1.7.26(@swc/helpers@0.5.12) - esbuild: 0.23.1 terser-webpack-plugin@5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -78695,17 +78783,17 @@ snapshots: optionalDependencies: '@swc/core': 1.7.26(@swc/helpers@0.5.12) - terser-webpack-plugin@5.3.7(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + terser-webpack-plugin@5.3.7(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: '@jridgewell/trace-mapping': 0.3.25 jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.2 terser: 5.31.6 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) optionalDependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) - esbuild: 0.23.1 + esbuild: 0.18.20 terser-webpack-plugin@5.3.7(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -79056,11 +79144,11 @@ snapshots: dependencies: tslib: 1.14.1 - ts-jest@27.1.5(@babel/core@7.24.4)(@types/jest@29.5.2)(babel-jest@27.5.1(@babel/core@7.24.4))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): + ts-jest@27.1.5(@babel/core@7.24.3)(@types/jest@29.5.13)(babel-jest@27.5.1(@babel/core@7.24.3))(jest@29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 - jest: 27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) + jest: 29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) jest-util: 27.5.1 json5: 2.2.3 lodash.memoize: 4.1.2 @@ -79069,11 +79157,11 @@ snapshots: typescript: 5.6.2 yargs-parser: 20.2.9 optionalDependencies: - '@babel/core': 7.24.4 - '@types/jest': 29.5.2 - babel-jest: 27.5.1(@babel/core@7.24.4) + '@babel/core': 7.24.3 + '@types/jest': 29.5.13 + babel-jest: 27.5.1(@babel/core@7.24.3) - ts-jest@27.1.5(@babel/core@7.25.2)(@types/jest@29.5.1)(babel-jest@27.5.1(@babel/core@7.25.2))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): + ts-jest@27.1.5(@babel/core@7.24.4)(@types/jest@29.5.2)(babel-jest@27.5.1(@babel/core@7.24.4))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 @@ -79086,15 +79174,15 @@ snapshots: typescript: 5.6.2 yargs-parser: 20.2.9 optionalDependencies: - '@babel/core': 7.25.2 - '@types/jest': 29.5.1 - babel-jest: 27.5.1(@babel/core@7.25.2) + '@babel/core': 7.24.4 + '@types/jest': 29.5.2 + babel-jest: 27.5.1(@babel/core@7.24.4) - ts-jest@27.1.5(@babel/core@7.25.2)(@types/jest@29.5.13)(babel-jest@27.5.1(@babel/core@7.25.2))(jest@29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): + ts-jest@27.1.5(@babel/core@7.25.2)(@types/jest@29.5.1)(babel-jest@27.5.1(@babel/core@7.25.2))(jest@27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 - jest: 29.7.0(@types/node@18.16.9)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest: 27.5.1(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 27.5.1 json5: 2.2.3 lodash.memoize: 4.1.2 @@ -79104,7 +79192,7 @@ snapshots: yargs-parser: 20.2.9 optionalDependencies: '@babel/core': 7.25.2 - '@types/jest': 29.5.13 + '@types/jest': 29.5.1 babel-jest: 27.5.1(@babel/core@7.25.2) ts-jest@27.1.5(@babel/core@7.25.2)(@types/jest@29.5.13)(babel-jest@27.5.1(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): @@ -79175,7 +79263,7 @@ snapshots: '@types/jest': 29.5.2 babel-jest: 27.5.1(@babel/core@7.25.2) - ts-jest@29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(esbuild@0.18.20)(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): + ts-jest@29.1.0(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.5.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 @@ -79191,24 +79279,6 @@ snapshots: '@babel/core': 7.25.2 '@jest/types': 29.6.3 babel-jest: 29.7.0(@babel/core@7.25.2) - esbuild: 0.18.20 - - ts-jest@29.1.2(@babel/core@7.24.4)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.24.4))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): - dependencies: - bs-logger: 0.2.6 - fast-json-stable-stringify: 2.1.0 - jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) - jest-util: 29.7.0 - json5: 2.2.3 - lodash.memoize: 4.1.2 - make-error: 1.3.6 - semver: 7.6.3 - typescript: 5.6.2 - yargs-parser: 21.1.1 - optionalDependencies: - '@babel/core': 7.24.4 - '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.24.4) ts-jest@29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(esbuild@0.23.1)(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): dependencies: @@ -79228,11 +79298,11 @@ snapshots: babel-jest: 29.7.0(@babel/core@7.25.2) esbuild: 0.23.1 - ts-jest@29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)))(typescript@5.6.2): + ts-jest@29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)))(typescript@5.6.2): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 - jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.1(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@18.16.9)(typescript@5.6.2)) + jest: 29.7.0(@types/node@20.16.5)(babel-plugin-macros@3.1.0)(ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2)) jest-util: 29.7.0 json5: 2.2.3 lodash.memoize: 4.1.2 @@ -79254,32 +79324,23 @@ snapshots: typescript: 5.6.2 webpack: 5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) - ts-loader@9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): - dependencies: - chalk: 4.1.2 - enhanced-resolve: 5.17.1 - micromatch: 4.0.8 - semver: 7.6.3 - typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - - ts-loader@9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + ts-loader@9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): dependencies: chalk: 4.1.2 enhanced-resolve: 5.17.1 micromatch: 4.0.8 semver: 7.6.3 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) - ts-loader@9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)): + ts-loader@9.4.4(typescript@5.6.2)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: chalk: 4.1.2 enhanced-resolve: 5.17.1 micromatch: 4.0.8 semver: 7.6.3 typescript: 5.6.2 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) ts-loader@9.4.4(typescript@5.6.2)(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -79440,6 +79501,27 @@ snapshots: optionalDependencies: '@swc/core': 1.3.107(@swc/helpers@0.5.12) + ts-node@10.9.2(@swc/core@1.3.107(@swc/helpers@0.5.12))(@types/node@20.16.5)(typescript@5.6.2): + dependencies: + '@cspotcode/source-map-support': 0.8.1 + '@tsconfig/node10': 1.0.9 + '@tsconfig/node12': 1.0.11 + '@tsconfig/node14': 1.0.3 + '@tsconfig/node16': 1.0.3 + '@types/node': 20.16.5 + acorn: 8.12.1 + acorn-walk: 8.3.2 + arg: 4.1.3 + create-require: 1.1.1 + diff: 4.0.2 + make-error: 1.3.6 + typescript: 5.6.2 + v8-compile-cache-lib: 3.0.1 + yn: 3.1.1 + optionalDependencies: + '@swc/core': 1.3.107(@swc/helpers@0.5.12) + optional: true + ts-node@10.9.2(@swc/core@1.7.26(@swc/helpers@0.5.12))(@types/node@20.14.10)(typescript@5.6.2): dependencies: '@cspotcode/source-map-support': 0.8.1 @@ -80238,23 +80320,23 @@ snapshots: url-join@5.0.0: {} - url-loader@4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): + url-loader@4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: loader-utils: 2.0.4 mime-types: 2.1.35 schema-utils: 3.3.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) optionalDependencies: - file-loader: 6.2.0(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + file-loader: 6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) - url-loader@4.1.1(file-loader@6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + url-loader@4.1.1(file-loader@6.2.0(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))))(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: loader-utils: 2.0.4 mime-types: 2.1.35 schema-utils: 3.3.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12)) optionalDependencies: - file-loader: 6.2.0(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + file-loader: 6.2.0(webpack@5.94.0(@swc/core@1.7.26(@swc/helpers@0.5.12))) url-parse@1.5.10: dependencies: @@ -81295,12 +81377,12 @@ snapshots: optionalDependencies: webpack-bundle-analyzer: 4.10.1 - webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0): + webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0): dependencies: '@discoveryjs/json-ext': 0.5.7 - '@webpack-cli/configtest': 2.1.1(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) - '@webpack-cli/info': 2.0.2(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) - '@webpack-cli/serve': 2.0.5(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0))(webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + '@webpack-cli/configtest': 2.1.1(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) + '@webpack-cli/info': 2.0.2(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) + '@webpack-cli/serve': 2.0.5(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) colorette: 2.0.20 commander: 10.0.1 cross-spawn: 7.0.3 @@ -81309,11 +81391,10 @@ snapshots: import-local: 3.1.0 interpret: 3.1.1 rechoir: 0.8.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) webpack-merge: 5.9.0 optionalDependencies: webpack-bundle-analyzer: 4.9.0 - webpack-dev-server: 4.11.1(webpack-cli@5.1.4)(webpack@5.78.0) webpack-dev-middleware@5.3.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: @@ -81323,26 +81404,6 @@ snapshots: range-parser: 1.2.1 schema-utils: 4.0.0 webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - optional: true - - webpack-dev-middleware@5.3.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): - dependencies: - colorette: 2.0.19 - memfs: 3.5.0 - mime-types: 2.1.35 - range-parser: 1.2.1 - schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - - webpack-dev-middleware@5.3.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): - dependencies: - colorette: 2.0.19 - memfs: 3.5.0 - mime-types: 2.1.35 - range-parser: 1.2.1 - schema-utils: 4.0.0 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - optional: true webpack-dev-middleware@5.3.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -81363,7 +81424,7 @@ snapshots: optionalDependencies: webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) - webpack-dev-middleware@6.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + webpack-dev-middleware@6.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))): dependencies: colorette: 2.0.19 memfs: 3.5.0 @@ -81371,9 +81432,9 @@ snapshots: range-parser: 1.2.1 schema-utils: 4.0.0 optionalDependencies: - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)) - webpack-dev-middleware@6.1.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)): + webpack-dev-middleware@6.1.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)): dependencies: colorette: 2.0.19 memfs: 3.5.0 @@ -81381,48 +81442,7 @@ snapshots: range-parser: 1.2.1 schema-utils: 4.0.0 optionalDependencies: - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - - webpack-dev-server@4.11.1(webpack-cli@5.1.4)(webpack@5.78.0): - dependencies: - '@types/bonjour': 3.5.10 - '@types/connect-history-api-fallback': 1.3.5 - '@types/express': 4.17.17 - '@types/serve-index': 1.9.1 - '@types/serve-static': 1.15.1 - '@types/sockjs': 0.3.33 - '@types/ws': 8.5.4 - ansi-html-community: 0.0.8 - bonjour-service: 1.1.1 - chokidar: 3.5.3 - colorette: 2.0.19 - compression: 1.7.4 - connect-history-api-fallback: 2.0.0 - default-gateway: 6.0.3 - express: 4.21.0 - graceful-fs: 4.2.11 - html-entities: 2.3.3 - http-proxy-middleware: 2.0.6(@types/express@4.17.17) - ipaddr.js: 2.0.1 - open: 8.4.2 - p-retry: 4.6.2 - rimraf: 3.0.2 - schema-utils: 4.0.0 - selfsigned: 2.1.1 - serve-index: 1.9.1 - sockjs: 0.3.24 - spdy: 4.0.2 - webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4) - webpack-dev-middleware: 5.3.3(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) - ws: 8.13.0 - optionalDependencies: - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) - transitivePeerDependencies: - - bufferutil - - debug - - supports-color - - utf-8-validate - optional: true + webpack: 5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4) webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: @@ -81461,45 +81481,6 @@ snapshots: - debug - supports-color - utf-8-validate - optional: true - - webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): - dependencies: - '@types/bonjour': 3.5.10 - '@types/connect-history-api-fallback': 1.3.5 - '@types/express': 4.17.17 - '@types/serve-index': 1.9.1 - '@types/serve-static': 1.15.1 - '@types/sockjs': 0.3.33 - '@types/ws': 8.5.4 - ansi-html-community: 0.0.8 - bonjour-service: 1.1.1 - chokidar: 3.5.3 - colorette: 2.0.19 - compression: 1.7.4 - connect-history-api-fallback: 2.0.0 - default-gateway: 6.0.3 - express: 4.21.0 - graceful-fs: 4.2.11 - html-entities: 2.3.3 - http-proxy-middleware: 2.0.6(@types/express@4.17.17) - ipaddr.js: 2.0.1 - open: 8.4.2 - p-retry: 4.6.2 - rimraf: 3.0.2 - schema-utils: 4.0.0 - selfsigned: 2.1.1 - serve-index: 1.9.1 - sockjs: 0.3.24 - spdy: 4.0.2 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) - webpack-dev-middleware: 5.3.3(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) - ws: 8.13.0 - transitivePeerDependencies: - - bufferutil - - debug - - supports-color - - utf-8-validate webpack-dev-server@4.11.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): dependencies: @@ -81552,10 +81533,10 @@ snapshots: strip-ansi: 6.0.1 optional: true - webpack-manifest-plugin@4.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + webpack-manifest-plugin@4.1.1(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: tapable: 2.2.1 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) webpack-sources: 2.3.1 webpack-manifest-plugin@4.1.1(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))): @@ -81587,7 +81568,7 @@ snapshots: webpack-virtual-modules@0.6.2: {} - webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20): + webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12)): dependencies: '@types/eslint-scope': 3.7.4 '@types/estree': 0.0.51 @@ -81610,7 +81591,7 @@ snapshots: neo-async: 2.6.2 schema-utils: 3.3.0 tapable: 2.2.1 - terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) + terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))) watchpack: 2.4.2 webpack-sources: 3.2.3 transitivePeerDependencies: @@ -81618,7 +81599,7 @@ snapshots: - esbuild - uglify-js - webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0)): + webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20): dependencies: '@types/eslint-scope': 3.7.4 '@types/estree': 0.0.51 @@ -81641,17 +81622,15 @@ snapshots: neo-async: 2.6.2 schema-utils: 3.3.0 tapable: 2.2.1 - terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)) watchpack: 2.4.2 webpack-sources: 3.2.3 - optionalDependencies: - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) transitivePeerDependencies: - '@swc/core' - esbuild - uglify-js - webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1): + webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack-cli@5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0)): dependencies: '@types/eslint-scope': 3.7.4 '@types/estree': 0.0.51 @@ -81674,9 +81653,11 @@ snapshots: neo-async: 2.6.2 schema-utils: 3.3.0 tapable: 2.2.1 - terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)) + terser-webpack-plugin: 5.3.10(@swc/core@1.3.107(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) watchpack: 2.4.2 webpack-sources: 3.2.3 + optionalDependencies: + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) transitivePeerDependencies: - '@swc/core' - esbuild @@ -81713,7 +81694,7 @@ snapshots: - esbuild - uglify-js - webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4): + webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4): dependencies: '@types/eslint-scope': 3.7.4 '@types/estree': 0.0.51 @@ -81736,17 +81717,17 @@ snapshots: neo-async: 2.6.2 schema-utils: 3.3.0 tapable: 2.2.1 - terser-webpack-plugin: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.18.20)(webpack-cli@5.1.4)) + terser-webpack-plugin: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)) watchpack: 2.4.2 webpack-sources: 3.2.3 optionalDependencies: - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack-dev-server@4.11.1)(webpack@5.78.0) + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0) transitivePeerDependencies: - '@swc/core' - esbuild - uglify-js - webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4): + webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4): dependencies: '@types/eslint-scope': 3.7.4 '@types/estree': 0.0.51 @@ -81769,11 +81750,11 @@ snapshots: neo-async: 2.6.2 schema-utils: 3.3.0 tapable: 2.2.1 - terser-webpack-plugin: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(esbuild@0.23.1)(webpack-cli@5.1.4)) + terser-webpack-plugin: 5.3.10(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack@5.78.0(@swc/core@1.7.26(@swc/helpers@0.5.12))(webpack-cli@5.1.4)) watchpack: 2.4.2 webpack-sources: 3.2.3 optionalDependencies: - webpack-cli: 5.1.4(webpack-bundle-analyzer@4.10.1)(webpack@5.78.0) + webpack-cli: 5.1.4(webpack-bundle-analyzer@4.9.0)(webpack@5.78.0) transitivePeerDependencies: - '@swc/core' - esbuild @@ -82147,12 +82128,12 @@ snapshots: workbox-sw@6.5.4: {} - workbox-webpack-plugin@6.5.4(@types/babel__core@7.20.5)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1)): + workbox-webpack-plugin@6.5.4(@types/babel__core@7.20.5)(webpack@5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20)): dependencies: fast-json-stable-stringify: 2.1.0 pretty-bytes: 5.6.0 upath: 1.2.0 - webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.23.1) + webpack: 5.78.0(@swc/core@1.3.107(@swc/helpers@0.5.12))(esbuild@0.18.20) webpack-sources: 1.4.3 workbox-build: 6.5.4(@types/babel__core@7.20.5) transitivePeerDependencies: