(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[7995],{ /***/ 57995: /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { "use strict"; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXPORTS __webpack_require__.d(__webpack_exports__, { ADDITIONAL_PROPERTIES_KEY: () => (/* reexport */ ADDITIONAL_PROPERTIES_KEY), ADDITIONAL_PROPERTY_FLAG: () => (/* reexport */ ADDITIONAL_PROPERTY_FLAG), ALL_OF_KEY: () => (/* reexport */ ALL_OF_KEY), ANY_OF_KEY: () => (/* reexport */ ANY_OF_KEY), CONST_KEY: () => (/* reexport */ CONST_KEY), DEFAULT_KEY: () => (/* reexport */ DEFAULT_KEY), DEFINITIONS_KEY: () => (/* reexport */ DEFINITIONS_KEY), DEPENDENCIES_KEY: () => (/* reexport */ DEPENDENCIES_KEY), ENUM_KEY: () => (/* reexport */ ENUM_KEY), ERRORS_KEY: () => (/* reexport */ ERRORS_KEY), ErrorSchemaBuilder: () => (/* reexport */ ErrorSchemaBuilder), ID_KEY: () => (/* reexport */ ID_KEY), IF_KEY: () => (/* reexport */ IF_KEY), ITEMS_KEY: () => (/* reexport */ ITEMS_KEY), JUNK_OPTION_ID: () => (/* reexport */ JUNK_OPTION_ID), NAME_KEY: () => (/* reexport */ NAME_KEY), ONE_OF_KEY: () => (/* reexport */ ONE_OF_KEY), PROPERTIES_KEY: () => (/* reexport */ PROPERTIES_KEY), REF_KEY: () => (/* reexport */ REF_KEY), REQUIRED_KEY: () => (/* reexport */ REQUIRED_KEY), RJSF_ADDITONAL_PROPERTIES_FLAG: () => (/* reexport */ RJSF_ADDITONAL_PROPERTIES_FLAG), ROOT_SCHEMA_PREFIX: () => (/* reexport */ ROOT_SCHEMA_PREFIX), SUBMIT_BTN_OPTIONS_KEY: () => (/* reexport */ SUBMIT_BTN_OPTIONS_KEY), TranslatableString: () => (/* reexport */ TranslatableString), UI_FIELD_KEY: () => (/* reexport */ UI_FIELD_KEY), UI_GLOBAL_OPTIONS_KEY: () => (/* reexport */ UI_GLOBAL_OPTIONS_KEY), UI_OPTIONS_KEY: () => (/* reexport */ UI_OPTIONS_KEY), UI_WIDGET_KEY: () => (/* reexport */ UI_WIDGET_KEY), allowAdditionalItems: () => (/* reexport */ allowAdditionalItems), ariaDescribedByIds: () => (/* reexport */ ariaDescribedByIds), asNumber: () => (/* reexport */ asNumber), canExpand: () => (/* reexport */ canExpand), createErrorHandler: () => (/* reexport */ createErrorHandler), createSchemaUtils: () => (/* reexport */ createSchemaUtils), dataURItoBlob: () => (/* reexport */ dataURItoBlob), deepEquals: () => (/* reexport */ deepEquals), descriptionId: () => (/* reexport */ descriptionId), englishStringTranslator: () => (/* reexport */ englishStringTranslator), enumOptionsDeselectValue: () => (/* reexport */ enumOptionsDeselectValue), enumOptionsIndexForValue: () => (/* reexport */ enumOptionsIndexForValue), enumOptionsIsSelected: () => (/* reexport */ enumOptionsIsSelected), enumOptionsSelectValue: () => (/* reexport */ enumOptionsSelectValue), enumOptionsValueForIndex: () => (/* reexport */ enumOptionsValueForIndex), errorId: () => (/* reexport */ errorId), examplesId: () => (/* reexport */ examplesId), findSchemaDefinition: () => (/* reexport */ findSchemaDefinition), getClosestMatchingOption: () => (/* reexport */ getClosestMatchingOption), getDateElementProps: () => (/* reexport */ getDateElementProps), getDefaultFormState: () => (/* reexport */ getDefaultFormState), getDiscriminatorFieldFromSchema: () => (/* reexport */ getDiscriminatorFieldFromSchema), getDisplayLabel: () => (/* reexport */ getDisplayLabel), getFirstMatchingOption: () => (/* reexport */ getFirstMatchingOption), getInputProps: () => (/* reexport */ getInputProps), getMatchingOption: () => (/* reexport */ getMatchingOption), getOptionMatchingSimpleDiscriminator: () => (/* reexport */ getOptionMatchingSimpleDiscriminator), getSchemaType: () => (/* reexport */ getSchemaType), getSubmitButtonOptions: () => (/* reexport */ getSubmitButtonOptions), getTemplate: () => (/* reexport */ getTemplate), getUiOptions: () => (/* reexport */ getUiOptions), getWidget: () => (/* reexport */ getWidget), guessType: () => (/* reexport */ guessType), hasWidget: () => (/* reexport */ hasWidget), hashForSchema: () => (/* reexport */ hashForSchema), helpId: () => (/* reexport */ helpId), isConstant: () => (/* reexport */ isConstant), isCustomWidget: () => (/* reexport */ isCustomWidget), isFilesArray: () => (/* reexport */ isFilesArray), isFixedItems: () => (/* reexport */ isFixedItems), isMultiSelect: () => (/* reexport */ isMultiSelect), isObject: () => (/* reexport */ isObject), isSelect: () => (/* reexport */ isSelect), labelValue: () => (/* reexport */ labelValue), localToUTC: () => (/* reexport */ localToUTC), mergeDefaultsWithFormData: () => (/* reexport */ mergeDefaultsWithFormData), mergeObjects: () => (/* reexport */ mergeObjects), mergeSchemas: () => (/* reexport */ mergeSchemas), mergeValidationData: () => (/* reexport */ mergeValidationData), optionId: () => (/* reexport */ optionId), optionsList: () => (/* reexport */ optionsList), orderProperties: () => (/* reexport */ orderProperties), pad: () => (/* reexport */ pad), parseDateString: () => (/* reexport */ parseDateString), rangeSpec: () => (/* reexport */ rangeSpec), replaceStringParameters: () => (/* reexport */ replaceStringParameters), retrieveSchema: () => (/* reexport */ retrieveSchema), sanitizeDataForNewSchema: () => (/* reexport */ sanitizeDataForNewSchema), schemaParser: () => (/* reexport */ schemaParser), schemaRequiresTrueValue: () => (/* reexport */ schemaRequiresTrueValue), shouldRender: () => (/* reexport */ shouldRender), titleId: () => (/* reexport */ titleId), toConstant: () => (/* reexport */ toConstant), toDateString: () => (/* reexport */ toDateString), toErrorList: () => (/* reexport */ toErrorList), toErrorSchema: () => (/* reexport */ toErrorSchema), toIdSchema: () => (/* reexport */ toIdSchema), toPathSchema: () => (/* reexport */ toPathSchema), unwrapErrorHandler: () => (/* reexport */ unwrapErrorHandler), utcToLocal: () => (/* reexport */ utcToLocal), validationDataMerge: () => (/* reexport */ validationDataMerge), withIdRefPrefix: () => (/* reexport */ withIdRefPrefix) }); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/isObject.js /** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has * the type `object` but is NOT null, an array or a File. * * @param thing - The thing to check to see whether it is an object * @returns - True if it is a non-null, non-array, non-File object */ function isObject(thing) { if (typeof File !== 'undefined' && thing instanceof File) { return false; } if (typeof Date !== 'undefined' && thing instanceof Date) { return false; } return typeof thing === 'object' && thing !== null && !Array.isArray(thing); } //# sourceMappingURL=isObject.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/allowAdditionalItems.js /** Checks the schema to see if it is allowing additional items, by verifying that `schema.additionalItems` is an * object. The user is warned in the console if `schema.additionalItems` has the value `true`. * * @param schema - The schema object to check * @returns - True if additional items is allowed, otherwise false */ function allowAdditionalItems(schema) { if (schema.additionalItems === true) { console.warn('additionalItems=true is currently not supported'); } return isObject(schema.additionalItems); } //# sourceMappingURL=allowAdditionalItems.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/asNumber.js /** Attempts to convert the string into a number. If an empty string is provided, then `undefined` is returned. If a * `null` is provided, it is returned. If the string ends in a `.` then the string is returned because the user may be * in the middle of typing a float number. If a number ends in a pattern like `.0`, `.20`, `.030`, string is returned * because the user may be typing number that will end in a non-zero digit. Otherwise, the string is wrapped by * `Number()` and if that result is not `NaN`, that number will be returned, otherwise the string `value` will be. * * @param value - The string or null value to convert to a number * @returns - The `value` converted to a number when appropriate, otherwise the `value` */ function asNumber(value) { if (value === '') { return undefined; } if (value === null) { return null; } if (/\.$/.test(value)) { // '3.' can't really be considered a number even if it parses in js. The // user is most likely entering a float. return value; } if (/\.0$/.test(value)) { // we need to return this as a string here, to allow for input like 3.07 return value; } if (/\.\d*0$/.test(value)) { // It's a number, that's cool - but we need it as a string so it doesn't screw // with the user when entering dollar amounts or other values (such as those with // specific precision or number of significant digits) return value; } const n = Number(value); const valid = typeof n === 'number' && !Number.isNaN(n); return valid ? n : value; } //# sourceMappingURL=asNumber.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/constants.js /** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and * `RJSF_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()` * utility. */ const ADDITIONAL_PROPERTY_FLAG = '__additional_property'; const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties'; const ALL_OF_KEY = 'allOf'; const ANY_OF_KEY = 'anyOf'; const CONST_KEY = 'const'; const DEFAULT_KEY = 'default'; const DEFINITIONS_KEY = 'definitions'; const DEPENDENCIES_KEY = 'dependencies'; const ENUM_KEY = 'enum'; const ERRORS_KEY = '__errors'; const ID_KEY = '$id'; const IF_KEY = 'if'; const ITEMS_KEY = 'items'; const JUNK_OPTION_ID = '_$junk_option_schema_id$_'; const NAME_KEY = '$name'; const ONE_OF_KEY = 'oneOf'; const PROPERTIES_KEY = 'properties'; const REQUIRED_KEY = 'required'; const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions'; const REF_KEY = '$ref'; const RJSF_ADDITONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties'; const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema'; const UI_FIELD_KEY = 'ui:field'; const UI_WIDGET_KEY = 'ui:widget'; const UI_OPTIONS_KEY = 'ui:options'; const UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions'; //# sourceMappingURL=constants.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getUiOptions.js /** Get all passed options from ui:options, and ui:, returning them in an object with the `ui:` * stripped off. Any `globalOptions` will always be returned, unless they are overridden by options in the `uiSchema`. * * @param [uiSchema={}] - The UI Schema from which to get any `ui:xxx` options * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options * @returns - An object containing all the `ui:xxx` options with the `ui:` stripped off along with all `globalOptions` */ function getUiOptions(uiSchema = {}, globalOptions = {}) { return Object.keys(uiSchema) .filter((key) => key.indexOf('ui:') === 0) .reduce((options, key) => { const value = uiSchema[key]; if (key === UI_WIDGET_KEY && isObject(value)) { console.error('Setting options via ui:widget object is no longer supported, use ui:options instead'); return options; } if (key === UI_OPTIONS_KEY && isObject(value)) { return { ...options, ...value }; } return { ...options, [key.substring(3)]: value }; }, { ...globalOptions }); } //# sourceMappingURL=getUiOptions.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/canExpand.js /** Checks whether the field described by `schema`, having the `uiSchema` and `formData` supports expanding. The UI for * the field can expand if it has additional properties, is not forced as non-expandable by the `uiSchema` and the * `formData` object doesn't already have `schema.maxProperties` elements. * * @param schema - The schema for the field that is being checked * @param [uiSchema={}] - The uiSchema for the field * @param [formData] - The formData for the field * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit */ function canExpand(schema, uiSchema = {}, formData) { if (!schema.additionalProperties) { return false; } const { expandable = true } = getUiOptions(uiSchema); if (expandable === false) { return expandable; } // if ui:options.expandable was not explicitly set to false, we can add // another property if we have not exceeded maxProperties yet if (schema.maxProperties !== undefined && formData) { return Object.keys(formData).length < schema.maxProperties; } return true; } //# sourceMappingURL=canExpand.js.map // EXTERNAL MODULE: ../node_modules/lodash/isPlainObject.js var isPlainObject = __webpack_require__(40861); var isPlainObject_default = /*#__PURE__*/__webpack_require__.n(isPlainObject); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/createErrorHandler.js /** Given a `formData` object, recursively creates a `FormValidation` error handling structure around it * * @param formData - The form data around which the error handler is created * @returns - A `FormValidation` object based on the `formData` structure */ function createErrorHandler(formData) { const handler = { // We store the list of errors for this node in a property named __errors // to avoid name collision with a possible sub schema field named // 'errors' (see `utils.toErrorSchema`). [ERRORS_KEY]: [], addError(message) { this[ERRORS_KEY].push(message); }, }; if (Array.isArray(formData)) { return formData.reduce((acc, value, key) => { return { ...acc, [key]: createErrorHandler(value) }; }, handler); } if (isPlainObject_default()(formData)) { const formObject = formData; return Object.keys(formObject).reduce((acc, key) => { return { ...acc, [key]: createErrorHandler(formObject[key]) }; }, handler); } return handler; } //# sourceMappingURL=createErrorHandler.js.map // EXTERNAL MODULE: ../node_modules/lodash/isEqualWith.js var isEqualWith = __webpack_require__(65191); var isEqualWith_default = /*#__PURE__*/__webpack_require__.n(isEqualWith); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/deepEquals.js /** Implements a deep equals using the `lodash.isEqualWith` function, that provides a customized comparator that * assumes all functions are equivalent. * * @param a - The first element to compare * @param b - The second element to compare * @returns - True if the `a` and `b` are deeply equal, false otherwise */ function deepEquals(a, b) { return isEqualWith_default()(a, b, (obj, other) => { if (typeof obj === 'function' && typeof other === 'function') { // Assume all functions are equivalent // see https://github.com/rjsf-team/react-jsonschema-form/issues/255 return true; } return undefined; // fallback to default isEquals behavior }); } //# sourceMappingURL=deepEquals.js.map // EXTERNAL MODULE: ../node_modules/lodash/get.js var get = __webpack_require__(99729); var get_default = /*#__PURE__*/__webpack_require__.n(get); // EXTERNAL MODULE: ../node_modules/lodash/isEmpty.js var isEmpty = __webpack_require__(90104); var isEmpty_default = /*#__PURE__*/__webpack_require__.n(isEmpty); // EXTERNAL MODULE: ../node_modules/jsonpointer/jsonpointer.js var jsonpointer = __webpack_require__(88208); // EXTERNAL MODULE: ../node_modules/lodash/omit.js var omit = __webpack_require__(48159); var omit_default = /*#__PURE__*/__webpack_require__.n(omit); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/findSchemaDefinition.js /** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first * location, the `object` minus the `key: value` and in the second location the `value`. * * @param key - The key from the object to extract * @param object - The object from which to extract the element * @returns - An array with the first value being the object minus the `key` element and the second element being the * value from `object[key]` */ function splitKeyElementFromObject(key, object) { const value = object[key]; const remaining = omit_default()(object, [key]); return [remaining, value]; } /** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the * path provided by that reference. If `#` is not the first character of the reference, or the path does not exist in * the schema, then throw an Error. Otherwise return the sub-schema. Also deals with nested `$ref`s in the sub-schema. * * @param $ref - The ref string for which the schema definition is desired * @param [rootSchema={}] - The root schema in which to search for the definition * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists * @throws - Error indicating that no schema for that reference exists */ function findSchemaDefinition($ref, rootSchema = {}) { let ref = $ref || ''; if (ref.startsWith('#')) { // Decode URI fragment representation. ref = decodeURIComponent(ref.substring(1)); } else { throw new Error(`Could not find a definition for ${$ref}.`); } const current = jsonpointer.get(rootSchema, ref); if (current === undefined) { throw new Error(`Could not find a definition for ${$ref}.`); } if (current[REF_KEY]) { const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current); const subSchema = findSchemaDefinition(theRef, rootSchema); if (Object.keys(remaining).length > 0) { return { ...remaining, ...subSchema }; } return subSchema; } return current; } //# sourceMappingURL=findSchemaDefinition.js.map // EXTERNAL MODULE: ../node_modules/lodash/has.js var has = __webpack_require__(73915); var has_default = /*#__PURE__*/__webpack_require__.n(has); // EXTERNAL MODULE: ../node_modules/lodash/isNumber.js var isNumber = __webpack_require__(78581); var isNumber_default = /*#__PURE__*/__webpack_require__.n(isNumber); // EXTERNAL MODULE: ../node_modules/lodash/isObject.js var lodash_isObject = __webpack_require__(11611); var isObject_default = /*#__PURE__*/__webpack_require__.n(lodash_isObject); // EXTERNAL MODULE: ../node_modules/lodash/isString.js var isString = __webpack_require__(47206); var isString_default = /*#__PURE__*/__webpack_require__.n(isString); // EXTERNAL MODULE: ../node_modules/lodash/reduce.js var reduce = __webpack_require__(34172); var reduce_default = /*#__PURE__*/__webpack_require__.n(reduce); // EXTERNAL MODULE: ../node_modules/lodash/times.js var times = __webpack_require__(41571); var times_default = /*#__PURE__*/__webpack_require__.n(times); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getOptionMatchingSimpleDiscriminator.js /** Compares the value of `discriminatorField` within `formData` against the value of `discriminatorField` within schema for each `option`. * Returns index of first `option` whose discriminator matches formData. Returns `undefined` if there is no match. * This function does not work with discriminators of `"type": "object"` and `"type": "array"` * * @param formData - The current formData, if any, used to figure out a match * @param options - The list of options to find a matching options from * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the matched option or undefined if there is no match */ function getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField) { var _a; if (formData && discriminatorField) { const value = get_default()(formData, discriminatorField); if (value === undefined) { return; } for (let i = 0; i < options.length; i++) { const option = options[i]; const discriminator = get_default()(option, [PROPERTIES_KEY, discriminatorField], {}); if (discriminator.type === 'object' || discriminator.type === 'array') { continue; } if (discriminator.const === value) { return i; } if ((_a = discriminator.enum) === null || _a === void 0 ? void 0 : _a.includes(value)) { return i; } } } return; } //# sourceMappingURL=getOptionMatchingSimpleDiscriminator.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/getMatchingOption.js /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data. * Deprecated, use `getFirstMatchingOption()` instead. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param formData - The current formData, if any, used to figure out a match * @param options - The list of options to find a matching options from * @param rootSchema - The root schema, used to primarily to look up `$ref`s * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the matched option or 0 if none is available * @deprecated */ function getMatchingOption(validator, formData, options, rootSchema, discriminatorField) { // For performance, skip validating subschemas if formData is undefined. We just // want to get the first option in that case. if (formData === undefined) { return 0; } const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField); if (isNumber_default()(simpleDiscriminatorMatch)) { return simpleDiscriminatorMatch; } for (let i = 0; i < options.length; i++) { const option = options[i]; // If we have a discriminator field, then we will use this to make the determination if (discriminatorField && has_default()(option, [PROPERTIES_KEY, discriminatorField])) { const value = get_default()(formData, discriminatorField); const discriminator = get_default()(option, [PROPERTIES_KEY, discriminatorField], {}); if (validator.isValid(discriminator, value, rootSchema)) { return i; } } else if (option[PROPERTIES_KEY]) { // If the schema describes an object then we need to add slightly more // strict matching to the schema, because unless the schema uses the // "requires" keyword, an object will match the schema as long as it // doesn't have matching keys with a conflicting type. To do this we use an // "anyOf" with an array of requires. This augmentation expresses that the // schema should match if any of the keys in the schema are present on the // object and pass validation. // // Create an "anyOf" schema that requires at least one of the keys in the // "properties" object const requiresAnyOf = { anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({ required: [key], })), }; let augmentedSchema; // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf" if (option.anyOf) { // Create a shallow clone of the option const { ...shallowClone } = option; if (!shallowClone.allOf) { shallowClone.allOf = []; } else { // If "allOf" already exists, shallow clone the array shallowClone.allOf = shallowClone.allOf.slice(); } shallowClone.allOf.push(requiresAnyOf); augmentedSchema = shallowClone; } else { augmentedSchema = Object.assign({}, option, requiresAnyOf); } // Remove the "required" field as it's likely that not all fields have // been filled in yet, which will mean that the schema is not valid delete augmentedSchema.required; if (validator.isValid(augmentedSchema, formData, rootSchema)) { return i; } } else if (validator.isValid(option, formData, rootSchema)) { return i; } } return 0; } //# sourceMappingURL=getMatchingOption.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/getFirstMatchingOption.js /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data. * Always returns the first option if there is nothing that matches. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param formData - The current formData, if any, used to figure out a match * @param options - The list of options to find a matching options from * @param rootSchema - The root schema, used to primarily to look up `$ref`s * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the first matched option or 0 if none is available */ function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) { return getMatchingOption(validator, formData, options, rootSchema, discriminatorField); } //# sourceMappingURL=getFirstMatchingOption.js.map // EXTERNAL MODULE: ../node_modules/lodash/isEqual.js var isEqual = __webpack_require__(56141); var isEqual_default = /*#__PURE__*/__webpack_require__.n(isEqual); // EXTERNAL MODULE: ../node_modules/lodash/set.js var set = __webpack_require__(47215); var set_default = /*#__PURE__*/__webpack_require__.n(set); // EXTERNAL MODULE: ../node_modules/lodash/transform.js var transform = __webpack_require__(42673); var transform_default = /*#__PURE__*/__webpack_require__.n(transform); // EXTERNAL MODULE: ../node_modules/lodash/merge.js var merge = __webpack_require__(15409); var merge_default = /*#__PURE__*/__webpack_require__.n(merge); // EXTERNAL MODULE: ../node_modules/lodash/flattenDeep.js var flattenDeep = __webpack_require__(84812); var flattenDeep_default = /*#__PURE__*/__webpack_require__.n(flattenDeep); // EXTERNAL MODULE: ../node_modules/lodash/uniq.js var uniq = __webpack_require__(83766); var uniq_default = /*#__PURE__*/__webpack_require__.n(uniq); // EXTERNAL MODULE: ../node_modules/json-schema-merge-allof/src/index.js var src = __webpack_require__(64717); var src_default = /*#__PURE__*/__webpack_require__.n(src); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getDiscriminatorFieldFromSchema.js /** Returns the `discriminator.propertyName` when defined in the `schema` if it is a string. A warning is generated when * it is not a string. Returns `undefined` when a valid discriminator is not present. * * @param schema - The schema from which the discriminator is potentially obtained * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined` */ function getDiscriminatorFieldFromSchema(schema) { let discriminator; const maybeString = get_default()(schema, 'discriminator.propertyName', undefined); if (isString_default()(maybeString)) { discriminator = maybeString; } else if (maybeString !== undefined) { console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`); } return discriminator; } //# sourceMappingURL=getDiscriminatorFieldFromSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/guessType.js /** Given a specific `value` attempts to guess the type of a schema element. In the case where we have to implicitly * create a schema, it is useful to know what type to use based on the data we are defining. * * @param value - The value from which to guess the type * @returns - The best guess for the object type */ function guessType(value) { if (Array.isArray(value)) { return 'array'; } if (typeof value === 'string') { return 'string'; } if (value == null) { return 'null'; } if (typeof value === 'boolean') { return 'boolean'; } if (!isNaN(value)) { return 'number'; } if (typeof value === 'object') { return 'object'; } // Default to string if we can't figure it out return 'string'; } //# sourceMappingURL=guessType.js.map // EXTERNAL MODULE: ../node_modules/lodash/union.js var union = __webpack_require__(68946); var union_default = /*#__PURE__*/__webpack_require__.n(union); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getSchemaType.js /** Gets the type of a given `schema`. If the type is not explicitly defined, then an attempt is made to infer it from * other elements of the schema as follows: * - schema.const: Returns the `guessType()` of that value * - schema.enum: Returns `string` * - schema.properties: Returns `object` * - schema.additionalProperties: Returns `object` * - type is an array with a length of 2 and one type is 'null': Returns the other type * * @param schema - The schema for which to get the type * @returns - The type of the schema */ function getSchemaType(schema) { let { type } = schema; if (!type && schema.const) { return guessType(schema.const); } if (!type && schema.enum) { return 'string'; } if (!type && (schema.properties || schema.additionalProperties)) { return 'object'; } if (Array.isArray(type)) { if (type.length === 2 && type.includes('null')) { type = type.find((type) => type !== 'null'); } else { type = type[0]; } } return type; } //# sourceMappingURL=getSchemaType.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/mergeSchemas.js /** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include * duplicate values. * * @param obj1 - The first schema object to merge * @param obj2 - The second schema object to merge * @returns - The merged schema object */ function mergeSchemas(obj1, obj2) { const acc = Object.assign({}, obj1); // Prevent mutation of source object. return Object.keys(obj2).reduce((acc, key) => { const left = obj1 ? obj1[key] : {}, right = obj2[key]; if (obj1 && key in obj1 && isObject(right)) { acc[key] = mergeSchemas(left, right); } else if (obj1 && obj2 && (getSchemaType(obj1) === 'object' || getSchemaType(obj2) === 'object') && key === REQUIRED_KEY && Array.isArray(left) && Array.isArray(right)) { // Don't include duplicate values when merging 'required' fields. acc[key] = union_default()(left, right); } else { acc[key] = right; } return acc; }, acc); } //# sourceMappingURL=mergeSchemas.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/retrieveSchema.js /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the * potentially recursive resolution. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which retrieving a schema is desired * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs * @param [rawFormData] - The current formData, if any, to assist retrieving a schema * @returns - The schema having its conditions, additional properties, references and dependencies resolved */ function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) { return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0]; } /** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both * conditions will be returned. * * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions * @param schema - The schema for which resolving a condition is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and * dependencies as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData to assist retrieving a schema * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded */ function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData) { const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema; const conditionValue = validator.isValid(expression, formData || {}, rootSchema); let resolvedSchemas = [resolvedSchemaLessConditional]; let schemas = []; if (expandAllBranches) { if (then && typeof then !== 'boolean') { schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches, recurseList)); } if (otherwise && typeof otherwise !== 'boolean') { schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches, recurseList)); } } else { const conditionalSchema = conditionValue ? then : otherwise; if (conditionalSchema && typeof conditionalSchema !== 'boolean') { schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches, recurseList)); } } if (schemas.length) { resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s)); } return resolvedSchemas.flatMap((s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList)); } /** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`. * From those lists, build a matrix for each `xxxOf` where there is more than one schema for a row in the list of lists. * * For example: * - If there are three xxxOf rows (A, B, C) and they have been resolved such that there is only one A, two B and three * C schemas then: * - The permutation for the first row is `[[A]]` * - The permutations for the second row are `[[A,B1], [A,B2]]` * - The permutations for the third row are `[[A,B1,C1], [A,B1,C2], [A,B1,C3], [A,B2,C1], [A,B2,C2], [A,B2,C3]]` * * @param listOfLists - The list of lists of elements that represent the allOf, anyOf or oneOf resolved values in order * @returns - The list of all permutations of schemas for a set of `xxxOf`s */ function getAllPermutationsOfXxxOf(listOfLists) { const allPermutations = listOfLists.reduce((permutations, list) => { // When there are more than one set of schemas for a row, duplicate the set of permutations and add in the values if (list.length > 1) { return list.flatMap((element) => times_default()(permutations.length, (i) => [...permutations[i]].concat(element))); } // Otherwise just push in the single value into the current set of permutations permutations.forEach((permutation) => permutation.push(list[0])); return permutations; }, [[]] // Start with an empty list ); return allPermutations; } /** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag * down to the `retrieveSchemaInternal()`, `resolveReference()` and `resolveDependencies()` helper calls. If * `expandAllBranches` is true, then all possible dependencies and/or allOf branches are returned. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which resolving a schema is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData, if any, to assist retrieving a schema * @returns - The list of schemas having its references, dependencies and allOf schemas resolved */ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData) { const updatedSchemas = resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData); if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) { // return the updatedSchemas array if it has either multiple schemas within it // OR the first schema is not the same as the original schema return updatedSchemas; } if (DEPENDENCIES_KEY in schema) { const resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData); return resolvedSchemas.flatMap((s) => { return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches, recurseList); }); } if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) { const allOfSchemaElements = schema.allOf.map((allOfSubschema) => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches, recurseList)); const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements); return allPermutations.map((permutation) => ({ ...schema, allOf: permutation })); } // No $ref or dependencies or allOf attribute was found, returning the original schema. return [schema]; } /** Resolves all references within a schema and then returns the `retrieveSchemaInternal()` if the resolved schema is * actually different than the original. Passes the `expandAllBranches` flag down to the `retrieveSchemaInternal()` * helper call. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which resolving a reference is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData, if any, to assist retrieving a schema * @returns - The list schemas retrieved after having all references resolved */ function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData) { const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList); if (updatedSchema !== schema) { // Only call this if the schema was actually changed by the `resolveAllReferences()` function return retrieveSchemaInternal(validator, updatedSchema, rootSchema, formData, expandAllBranches, recurseList); } return [schema]; } /** Resolves all references within the schema itself as well as any of its properties and array items. * * @param schema - The schema for which resolving all references is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param recurseList - List of $refs already resolved to prevent recursion * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved */ function resolveAllReferences(schema, rootSchema, recurseList) { if (!isObject(schema)) { return schema; } let resolvedSchema = schema; // resolve top level ref if (REF_KEY in resolvedSchema) { const { $ref, ...localSchema } = resolvedSchema; // Check for a recursive reference and stop the loop if (recurseList.includes($ref)) { return resolvedSchema; } recurseList.push($ref); // Retrieve the referenced schema definition. const refSchema = findSchemaDefinition($ref, rootSchema); resolvedSchema = { ...refSchema, ...localSchema }; } if (PROPERTIES_KEY in resolvedSchema) { const childrenLists = []; const updatedProps = transform_default()(resolvedSchema[PROPERTIES_KEY], (result, value, key) => { const childList = [...recurseList]; result[key] = resolveAllReferences(value, rootSchema, childList); childrenLists.push(childList); }, {}); merge_default()(recurseList, uniq_default()(flattenDeep_default()(childrenLists))); resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps }; } if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== 'boolean') { resolvedSchema = { ...resolvedSchema, items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList), }; } return isEqual_default()(schema, resolvedSchema) ? schema : resolvedSchema; } /** Creates new 'properties' items for each key in the `formData` * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param theSchema - The schema for which the existing additional properties is desired * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator * @param [aFormData] - The current formData, if any, to assist retrieving a schema * @returns - The updated schema with additional properties stubbed */ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) { // Clone the schema so that we don't ruin the consumer's original const schema = { ...theSchema, properties: { ...theSchema.properties }, }; // make sure formData is an object const formData = aFormData && isObject(aFormData) ? aFormData : {}; Object.keys(formData).forEach((key) => { if (key in schema.properties) { // No need to stub, our schema already has the property return; } let additionalProperties = {}; if (typeof schema.additionalProperties !== 'boolean') { if (REF_KEY in schema.additionalProperties) { additionalProperties = retrieveSchema(validator, { $ref: get_default()(schema.additionalProperties, [REF_KEY]) }, rootSchema, formData); } else if ('type' in schema.additionalProperties) { additionalProperties = { ...schema.additionalProperties }; } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) { additionalProperties = { type: 'object', ...schema.additionalProperties, }; } else { additionalProperties = { type: guessType(get_default()(formData, [key])) }; } } else { additionalProperties = { type: guessType(get_default()(formData, [key])) }; } // The type of our new key should match the additionalProperties value; schema.properties[key] = additionalProperties; // Set our additional property flag so we know it was dynamically added set_default()(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true); }); return schema; } /** Internal handler that retrieves an expanded schema that has had all of its conditions, additional properties, * references and dependencies resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` * that is used to do the potentially recursive resolution. If `expandAllBranches` is true, then all possible branches * of the schema and its references, conditions and dependencies are returned. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which retrieving a schema is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param [rawFormData] - The current formData, if any, to assist retrieving a schema * @param [expandAllBranches=false] - Flag, if true, will return all possible branches of conditions, any/oneOf and * dependencies as a list of schemas * @param [recurseList=[]] - The optional, list of recursive references already processed * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies * resolved. Multiple schemas may be returned if `expandAllBranches` is true. */ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = []) { if (!isObject(schema)) { return [{}]; } const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, rawFormData); return resolvedSchemas.flatMap((s) => { let resolvedSchema = s; if (IF_KEY in resolvedSchema) { return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, recurseList, rawFormData); } if (ALL_OF_KEY in resolvedSchema) { // resolve allOf schemas if (expandAllBranches) { const { allOf, ...restOfSchema } = resolvedSchema; return [...allOf, restOfSchema]; } try { resolvedSchema = src_default()(resolvedSchema, { deep: false, }); } catch (e) { console.warn('could not merge subschemas in allOf:\n', e); const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema; return resolvedSchemaWithoutAllOf; } } const hasAdditionalProperties = ADDITIONAL_PROPERTIES_KEY in resolvedSchema && resolvedSchema.additionalProperties !== false; if (hasAdditionalProperties) { return stubExistingAdditionalProperties(validator, resolvedSchema, rootSchema, rawFormData); } return resolvedSchema; }); } /** Resolves an `anyOf` or `oneOf` within a schema (if present) to the list of schemas returned from * `retrieveSchemaInternal()` for the best matching option. If `expandAllBranches` is true, then a list of schemas for ALL * options are retrieved and returned. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which retrieving a schema is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param [rawFormData] - The current formData, if any, to assist retrieving a schema, defaults to an empty object * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true */ function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, rawFormData) { let anyOrOneOf; const { oneOf, anyOf, ...remaining } = schema; if (Array.isArray(oneOf)) { anyOrOneOf = oneOf; } else if (Array.isArray(anyOf)) { anyOrOneOf = anyOf; } if (anyOrOneOf) { // Ensure that during expand all branches we pass an object rather than undefined so that all options are interrogated const formData = rawFormData === undefined && expandAllBranches ? {} : rawFormData; const discriminator = getDiscriminatorFieldFromSchema(schema); anyOrOneOf = anyOrOneOf.map((s) => { // Due to anyOf/oneOf possibly using the same $ref we always pass a fresh recurse list array so that each option // can resolve recursive references independently return resolveAllReferences(s, rootSchema, []); }); // Call this to trigger the set of isValid() calls that the schema parser will need const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator); if (expandAllBranches) { return anyOrOneOf.map((item) => mergeSchemas(remaining, item)); } schema = mergeSchemas(remaining, anyOrOneOf[option]); } return [schema]; } /** Resolves dependencies within a schema and its 'anyOf/oneOf' children. Passes the `expandAllBranches` flag down to * the `resolveAnyOrOneOfSchema()` and `processDependencies()` helper calls. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which resolving a dependency is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData, if any, to assist retrieving a schema * @returns - The list of schemas with their dependencies resolved */ function resolveDependencies(validator, schema, rootSchema, expandAllBranches, recurseList, formData) { // Drop the dependencies from the source schema. const { dependencies, ...remainingSchema } = schema; const resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData); return resolvedSchemas.flatMap((resolvedSchema) => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData)); } /** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param dependencies - The set of dependencies that needs to be processed * @param resolvedSchema - The schema for which processing dependencies is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData, if any, to assist retrieving a schema * @returns - The schema with the `dependencies` resolved into it */ function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, recurseList, formData) { let schemas = [resolvedSchema]; // Process dependencies updating the local schema properties as appropriate. for (const dependencyKey in dependencies) { // Skip this dependency if its trigger property is not present. if (!expandAllBranches && get_default()(formData, [dependencyKey]) === undefined) { continue; } // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.) if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) { continue; } const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(dependencyKey, dependencies); if (Array.isArray(dependencyValue)) { schemas[0] = withDependentProperties(resolvedSchema, dependencyValue); } else if (isObject(dependencyValue)) { schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData); } return schemas.flatMap((schema) => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, recurseList, formData)); } return schemas; } /** Updates a schema with additionally required properties added * * @param schema - The schema for which resolving a dependent properties is desired * @param [additionallyRequired] - An optional array of additionally required names * @returns - The schema with the additional required values merged in */ function withDependentProperties(schema, additionallyRequired) { if (!additionallyRequired) { return schema; } const required = Array.isArray(schema.required) ? Array.from(new Set([...schema.required, ...additionallyRequired])) : additionallyRequired; return { ...schema, required: required }; } /** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag * down to the `retrieveSchemaInternal()`, `resolveReference()` and `withExactlyOneSubschema()` helper calls. * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param schema - The schema for which resolving a dependent schema is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param dependencyKey - The key name of the dependency * @param dependencyValue - The potentially dependent schema * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData]- The current formData to assist retrieving a schema * @returns - The list of schemas with the dependent schema resolved into them */ function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, recurseList, formData) { const dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches, recurseList); return dependentSchemas.flatMap((dependent) => { const { oneOf, ...dependentSchema } = dependent; schema = mergeSchemas(schema, dependentSchema); // Since it does not contain oneOf, we return the original schema. if (oneOf === undefined) { return schema; } // Resolve $refs inside oneOf. const resolvedOneOfs = oneOf.map((subschema) => { if (typeof subschema === 'boolean' || !(REF_KEY in subschema)) { return [subschema]; } return resolveReference(validator, subschema, rootSchema, expandAllBranches, recurseList, formData); }); const allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs); return allPermutations.flatMap((resolvedOneOf) => withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, recurseList, formData)); }); } /** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is * true, then a list of schemas for ALL options are retrieved and returned. Passes the `expandAllBranches` flag down to * the `retrieveSchemaInternal()` helper call. * * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options * @param schema - The schema for which resolving a oneOf subschema is desired * @param rootSchema - The root schema that will be forwarded to all the APIs * @param dependencyKey - The key name of the oneOf dependency * @param oneOf - The list of schemas representing the oneOf options * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies * as a list of schemas * @param recurseList - The list of recursive references already processed * @param [formData] - The current formData to assist retrieving a schema * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true */ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, recurseList, formData) { const validSubschemas = oneOf.filter((subschema) => { if (typeof subschema === 'boolean' || !subschema || !subschema.properties) { return false; } const { [dependencyKey]: conditionPropertySchema } = subschema.properties; if (conditionPropertySchema) { const conditionSchema = { type: 'object', properties: { [dependencyKey]: conditionPropertySchema, }, }; return validator.isValid(conditionSchema, formData, rootSchema) || expandAllBranches; } return false; }); if (!expandAllBranches && validSubschemas.length !== 1) { console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid"); return [schema]; } return validSubschemas.flatMap((s) => { const subschema = s; const [dependentSubschema] = splitKeyElementFromObject(dependencyKey, subschema.properties); const dependentSchema = { ...subschema, properties: dependentSubschema }; const schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches, recurseList); return schemas.map((s) => mergeSchemas(schema, s)); }); } //# sourceMappingURL=retrieveSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/getClosestMatchingOption.js /** A junk option used to determine when the getFirstMatchingOption call really matches an option rather than returning * the first item */ const JUNK_OPTION = { type: 'object', $id: JUNK_OPTION_ID, properties: { __not_really_there__: { type: 'number', }, }, }; /** Recursive function that calculates the score of a `formData` against the given `schema`. The computation is fairly * simple. Initially the total score is 0. When `schema.properties` object exists, then all the `key/value` pairs within * the object are processed as follows after obtaining the formValue from `formData` using the `key`: * - If the `value` contains a `$ref`, `calculateIndexScore()` is called recursively with the formValue and the new * schema that is the result of the ref in the schema being resolved and that sub-schema's resulting score is added to * the total. * - If the `value` contains a `oneOf` and there is a formValue, then score based on the index returned from calling * `getClosestMatchingOption()` of that oneOf. * - If the type of the `value` is 'object', `calculateIndexScore()` is called recursively with the formValue and the * `value` itself as the sub-schema, and the score is added to the total. * - If the type of the `value` matches the guessed-type of the `formValue`, the score is incremented by 1, UNLESS the * value has a `default` or `const`. In those case, if the `default` or `const` and the `formValue` match, the score * is incremented by another 1 otherwise it is decremented by 1. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param rootSchema - The root JSON schema of the entire form * @param schema - The schema for which the score is being calculated * @param formData - The form data associated with the schema, used to calculate the score * @returns - The score a schema against the formData */ function calculateIndexScore(validator, rootSchema, schema, formData = {}) { let totalScore = 0; if (schema) { if (isObject_default()(schema.properties)) { totalScore += reduce_default()(schema.properties, (score, value, key) => { const formValue = get_default()(formData, key); if (typeof value === 'boolean') { return score; } if (has_default()(value, REF_KEY)) { const newSchema = retrieveSchema(validator, value, rootSchema, formValue); return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {}); } if ((has_default()(value, ONE_OF_KEY) || has_default()(value, ANY_OF_KEY)) && formValue) { const key = has_default()(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY; const discriminator = getDiscriminatorFieldFromSchema(value); return (score + getClosestMatchingOption(validator, rootSchema, formValue, get_default()(value, key), -1, discriminator)); } if (value.type === 'object') { return score + calculateIndexScore(validator, rootSchema, value, formValue || {}); } if (value.type === guessType(formValue)) { // If the types match, then we bump the score by one let newScore = score + 1; if (value.default) { // If the schema contains a readonly default value score the value that matches the default higher and // any non-matching value lower newScore += formValue === value.default ? 1 : -1; } else if (value.const) { // If the schema contains a const value score the value that matches the default higher and // any non-matching value lower newScore += formValue === value.const ? 1 : -1; } // TODO eventually, deal with enums/arrays return newScore; } return score; }, 0); } else if (isString_default()(schema.type) && schema.type === guessType(formData)) { totalScore += 1; } } return totalScore; } /** Determines which of the given `options` provided most closely matches the `formData`. Using * `getFirstMatchingOption()` to match two schemas that differ only by the readOnly, default or const value of a field * based on the `formData` and returns 0 when there is no match. Rather than passing in all the `options` at once to * this utility, instead an array of valid option indexes is created by iterating over the list of options, call * `getFirstMatchingOptions` with a list of one junk option and one good option, seeing if the good option is considered * matched. * * Once the list of valid indexes is created, if there is only one valid index, just return it. Otherwise, if there are * no valid indexes, then fill the valid indexes array with the indexes of all the options. Next, the index of the * option with the highest score is determined by iterating over the list of valid options, calling * `calculateIndexScore()` on each, comparing it against the current best score, and returning the index of the one that * eventually has the best score. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param rootSchema - The root JSON schema of the entire form * @param formData - The form data associated with the schema * @param options - The list of options that can be selected from * @param [selectedOption=-1] - The index of the currently selected option, defaulted to -1 if not specified * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match */ function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) { // First resolve any refs in the options const resolvedOptions = options.map((option) => { return resolveAllReferences(option, rootSchema, []); }); const simpleDiscriminatorMatch = getOptionMatchingSimpleDiscriminator(formData, options, discriminatorField); if (isNumber_default()(simpleDiscriminatorMatch)) { return simpleDiscriminatorMatch; } // Reduce the array of options down to a list of the indexes that are considered matching options const allValidIndexes = resolvedOptions.reduce((validList, option, index) => { const testOptions = [JUNK_OPTION, option]; const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField); // The match is the real option, so add its index to list of valid indexes if (match === 1) { validList.push(index); } return validList; }, []); // There is only one valid index, so return it! if (allValidIndexes.length === 1) { return allValidIndexes[0]; } if (!allValidIndexes.length) { // No indexes were valid, so we'll score all the options, add all the indexes times_default()(resolvedOptions.length, (i) => allValidIndexes.push(i)); } const scoreCount = new Set(); // Score all the options in the list of valid indexes and return the index with the best score const { bestIndex } = allValidIndexes.reduce((scoreData, index) => { const { bestScore } = scoreData; const option = resolvedOptions[index]; const score = calculateIndexScore(validator, rootSchema, option, formData); scoreCount.add(score); if (score > bestScore) { return { bestIndex: index, bestScore: score }; } return scoreData; }, { bestIndex: selectedOption, bestScore: 0 }); // if all scores are the same go with selectedOption if (scoreCount.size === 1 && selectedOption >= 0) { return selectedOption; } return bestIndex; } //# sourceMappingURL=getClosestMatchingOption.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/isFixedItems.js /** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array * that only contains objects. * * @param schema - The schema in which to check for fixed items * @returns - True if there are fixed items in the schema, false otherwise */ function isFixedItems(schema) { return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item)); } //# sourceMappingURL=isFixedItems.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/mergeDefaultsWithFormData.js /** Merges the `defaults` object of type `T` into the `formData` of type `T` * * When merging defaults and form data, we want to merge in this specific way: * - objects are deeply merged * - arrays are merged in such a way that: * - when the array is set in form data, only array entries set in form data * are deeply merged; additional entries from the defaults are ignored unless `mergeExtraArrayDefaults` is true, in * which case the extras are appended onto the end of the form data * - when the array is not set in form data, the default is copied over * - scalars are overwritten/set by form data * * @param [defaults] - The defaults to merge * @param [formData] - The form data into which the defaults will be merged * @param [mergeExtraArrayDefaults=false] - If true, any additional default array entries are appended onto the formData * @returns - The resulting merged form data with defaults */ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) { if (Array.isArray(formData)) { const defaultsArray = Array.isArray(defaults) ? defaults : []; const mapped = formData.map((value, idx) => { if (defaultsArray[idx]) { return mergeDefaultsWithFormData(defaultsArray[idx], value, mergeExtraArrayDefaults); } return value; }); // Merge any extra defaults when mergeExtraArrayDefaults is true if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) { mapped.push(...defaultsArray.slice(mapped.length)); } return mapped; } if (isObject(formData)) { const acc = Object.assign({}, defaults); // Prevent mutation of source object. return Object.keys(formData).reduce((acc, key) => { acc[key] = mergeDefaultsWithFormData(defaults ? get_default()(defaults, key) : {}, get_default()(formData, key), mergeExtraArrayDefaults); return acc; }, acc); } return formData; } //# sourceMappingURL=mergeDefaultsWithFormData.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/mergeObjects.js /** Recursively merge deeply nested objects. * * @param obj1 - The first object to merge * @param obj2 - The second object to merge * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated. Use * "preventDuplicates" to merge arrays in a manner that prevents any duplicate entries from being merged. * NOTE: Uses shallow comparison for the duplicate checking. * @returns - A new object that is the merge of the two given objects */ function mergeObjects(obj1, obj2, concatArrays = false) { return Object.keys(obj2).reduce((acc, key) => { const left = obj1 ? obj1[key] : {}, right = obj2[key]; if (obj1 && key in obj1 && isObject(right)) { acc[key] = mergeObjects(left, right, concatArrays); } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) { let toMerge = right; if (concatArrays === 'preventDuplicates') { toMerge = right.reduce((result, value) => { if (!left.includes(value)) { result.push(value); } return result; }, []); } acc[key] = left.concat(toMerge); } else { acc[key] = right; } return acc; }, Object.assign({}, obj1)); // Prevent mutation of source object. } //# sourceMappingURL=mergeObjects.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/isConstant.js /** This function checks if the given `schema` matches a single constant value. This happens when either the schema has * an `enum` array with a single value or there is a `const` defined. * * @param schema - The schema for a field * @returns - True if the `schema` has a single constant value, false otherwise */ function isConstant(schema) { return (Array.isArray(schema.enum) && schema.enum.length === 1) || CONST_KEY in schema; } //# sourceMappingURL=isConstant.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/isSelect.js /** Checks to see if the `schema` combination represents a select * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param theSchema - The schema for which check for a select flag is desired * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @returns - True if schema contains a select, otherwise false */ function isSelect(validator, theSchema, rootSchema = {}) { const schema = retrieveSchema(validator, theSchema, rootSchema, undefined); const altSchemas = schema.oneOf || schema.anyOf; if (Array.isArray(schema.enum)) { return true; } if (Array.isArray(altSchemas)) { return altSchemas.every((altSchemas) => typeof altSchemas !== 'boolean' && isConstant(altSchemas)); } return false; } //# sourceMappingURL=isSelect.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/isMultiSelect.js /** Checks to see if the `schema` combination represents a multi-select * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which check for a multi-select flag is desired * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @returns - True if schema contains a multi-select, otherwise false */ function isMultiSelect(validator, schema, rootSchema) { if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') { return false; } return isSelect(validator, schema.items, rootSchema); } //# sourceMappingURL=isMultiSelect.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/getDefaultFormState.js /** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function. */ var AdditionalItemsHandling; (function (AdditionalItemsHandling) { AdditionalItemsHandling[AdditionalItemsHandling["Ignore"] = 0] = "Ignore"; AdditionalItemsHandling[AdditionalItemsHandling["Invert"] = 1] = "Invert"; AdditionalItemsHandling[AdditionalItemsHandling["Fallback"] = 2] = "Fallback"; })(AdditionalItemsHandling || (AdditionalItemsHandling = {})); /** Given a `schema` will return an inner schema that for an array item. This is computed differently based on the * `additionalItems` enum and the value of `idx`. There are four possible returns: * 1. If `idx` is >= 0, then if `schema.items` is an array the `idx`th element of the array is returned if it is a valid * index and not a boolean, otherwise it falls through to 3. * 2. If `schema.items` is not an array AND truthy and not a boolean, then `schema.items` is returned since it actually * is a schema, otherwise it falls through to 3. * 3. If `additionalItems` is not `AdditionalItemsHandling.Ignore` and `schema.additionalItems` is an object, then * `schema.additionalItems` is returned since it actually is a schema, otherwise it falls through to 4. * 4. {} is returned representing an empty schema * * @param schema - The schema from which to get the particular item * @param [additionalItems=AdditionalItemsHandling.Ignore] - How do we want to handle additional items? * @param [idx=-1] - Index, if non-negative, will be used to return the idx-th element in a `schema.items` array * @returns - The best fit schema object from the `schema` given the `additionalItems` and `idx` modifiers */ function getInnerSchemaForArrayItem(schema, additionalItems = AdditionalItemsHandling.Ignore, idx = -1) { if (idx >= 0) { if (Array.isArray(schema.items) && idx < schema.items.length) { const item = schema.items[idx]; if (typeof item !== 'boolean') { return item; } } } else if (schema.items && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') { return schema.items; } if (additionalItems !== AdditionalItemsHandling.Ignore && isObject(schema.additionalItems)) { return schema.additionalItems; } return {}; } /** Either add `computedDefault` at `key` into `obj` or not add it based on its value, the value of * `includeUndefinedValues`, the value of `emptyObjectFields` and if its parent field is required. Generally undefined * `computedDefault` values are added only when `includeUndefinedValues` is either true/"excludeObjectChildren". If ` * includeUndefinedValues` is false and `emptyObjectFields` is not "skipDefaults", then non-undefined and non-empty-object * values will be added based on certain conditions. * * @param obj - The object into which the computed default may be added * @param key - The key into the object at which the computed default may be added * @param computedDefault - The computed default value that maybe should be added to the obj * @param includeUndefinedValues - Optional flag, if true, cause undefined values to be added as defaults. * If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as * false when computing defaults for any nested object properties. If "allowEmptyObject", prevents undefined * values in this object while allow the object itself to be empty and passing `includeUndefinedValues` as * false when computing defaults for any nested object properties. * @param isParentRequired - The optional boolean that indicates whether the parent field is required * @param requiredFields - The list of fields that are required * @param experimental_defaultFormStateBehavior - Optional configuration object, if provided, allows users to override * default form state behavior */ function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}) { const { emptyObjectFields = 'populateAllDefaults' } = experimental_defaultFormStateBehavior; if (includeUndefinedValues) { obj[key] = computedDefault; } else if (emptyObjectFields !== 'skipDefaults') { if (isObject(computedDefault)) { // If isParentRequired is undefined, then we are at the root level of the schema so defer to the requiredness of // the field key itself in the `requiredField` list const isSelfOrParentRequired = isParentRequired === undefined ? requiredFields.includes(key) : isParentRequired; // Store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions // Condition 1: If computedDefault is not empty or if the key is a required field // Condition 2: If the parent object is required or emptyObjectFields is not 'populateRequiredDefaults' if ((!isEmpty_default()(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== 'populateRequiredDefaults')) { obj[key] = computedDefault; } } else if ( // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions // Condition 1: computedDefault is not undefined // Condition 2: If emptyObjectFields is 'populateAllDefaults' or if the key is a required field computedDefault !== undefined && (emptyObjectFields === 'populateAllDefaults' || requiredFields.includes(key))) { obj[key] = computedDefault; } } } /** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into * each level of the schema, recursively, to fill out every level of defaults provided by the schema. * * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary * @param rawSchema - The schema for which the default state is desired * @param [props] - Optional props for this function * @param [props.parentDefaults] - Any defaults provided by the parent field in the schema * @param [props.rootSchema] - The options root schema, used to primarily to look up `$ref`s * @param [props.rawFormData] - The current formData, if any, onto which to provide any missing defaults * @param [props.includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults. * If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as * false when computing defaults for any nested object properties. * @param [props._recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion * @param [props.experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema. * @returns - The resulting `formData` with all the defaults provided */ function computeDefaults(validator, rawSchema, { parentDefaults, rawFormData, rootSchema = {}, includeUndefinedValues = false, _recurseList = [], experimental_defaultFormStateBehavior = undefined, required, } = {}) { var _a, _b; const formData = (isObject(rawFormData) ? rawFormData : {}); const schema = isObject(rawSchema) ? rawSchema : {}; // Compute the defaults recursively: give highest priority to deepest nodes. let defaults = parentDefaults; // If we get a new schema, then we need to recompute defaults again for the new schema found. let schemaToCompute = null; let updatedRecurseList = _recurseList; if (isObject(defaults) && isObject(schema.default)) { // For object defaults, only override parent defaults that are defined in // schema.default. defaults = mergeObjects(defaults, schema.default); } else if (DEFAULT_KEY in schema) { defaults = schema.default; } else if (REF_KEY in schema) { const refName = schema[REF_KEY]; // Use referenced schema defaults for this node. if (!_recurseList.includes(refName)) { updatedRecurseList = _recurseList.concat(refName); schemaToCompute = findSchemaDefinition(refName, rootSchema); } } else if (DEPENDENCIES_KEY in schema) { const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, [], formData); schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies } else if (isFixedItems(schema)) { defaults = schema.items.map((itemSchema, idx) => computeDefaults(validator, itemSchema, { rootSchema, includeUndefinedValues, _recurseList, experimental_defaultFormStateBehavior, parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined, rawFormData: formData, required, })); } else if (ONE_OF_KEY in schema) { const { oneOf, ...remaining } = schema; if (oneOf.length === 0) { return undefined; } const discriminator = getDiscriminatorFieldFromSchema(schema); schemaToCompute = oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty_default()(formData) ? undefined : formData, oneOf, 0, discriminator)]; schemaToCompute = mergeSchemas(remaining, schemaToCompute); } else if (ANY_OF_KEY in schema) { const { anyOf, ...remaining } = schema; if (anyOf.length === 0) { return undefined; } const discriminator = getDiscriminatorFieldFromSchema(schema); schemaToCompute = anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty_default()(formData) ? undefined : formData, anyOf, 0, discriminator)]; schemaToCompute = mergeSchemas(remaining, schemaToCompute); } if (schemaToCompute) { return computeDefaults(validator, schemaToCompute, { rootSchema, includeUndefinedValues, _recurseList: updatedRecurseList, experimental_defaultFormStateBehavior, parentDefaults: defaults, rawFormData: formData, required, }); } // No defaults defined for this node, fallback to generic typed ones. if (defaults === undefined) { defaults = schema.default; } switch (getSchemaType(schema)) { // We need to recurse for object schema inner default values. case 'object': { // This is a custom addition that fixes this issue: // https://github.com/rjsf-team/react-jsonschema-form/issues/3832 const retrievedSchema = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.allOf) === 'populateDefaults' && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData) : schema; const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce((acc, key) => { var _a; // Compute the defaults for this node, with the parent defaults we might // have from a previous run: defaults[key]. const computedDefault = computeDefaults(validator, get_default()(retrievedSchema, [PROPERTIES_KEY, key]), { rootSchema, _recurseList, experimental_defaultFormStateBehavior, includeUndefinedValues: includeUndefinedValues === true, parentDefaults: get_default()(defaults, [key]), rawFormData: get_default()(formData, [key]), required: (_a = retrievedSchema.required) === null || _a === void 0 ? void 0 : _a.includes(key), }); maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, required, retrievedSchema.required, experimental_defaultFormStateBehavior); return acc; }, {}); if (retrievedSchema.additionalProperties) { // as per spec additionalProperties may be either schema or boolean const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {}; const keys = new Set(); if (isObject(defaults)) { Object.keys(defaults) .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]) .forEach((key) => keys.add(key)); } const formDataRequired = []; Object.keys(formData) .filter((key) => !retrievedSchema.properties || !retrievedSchema.properties[key]) .forEach((key) => { keys.add(key); formDataRequired.push(key); }); keys.forEach((key) => { var _a; const computedDefault = computeDefaults(validator, additionalPropertiesSchema, { rootSchema, _recurseList, experimental_defaultFormStateBehavior, includeUndefinedValues: includeUndefinedValues === true, parentDefaults: get_default()(defaults, [key]), rawFormData: get_default()(formData, [key]), required: (_a = retrievedSchema.required) === null || _a === void 0 ? void 0 : _a.includes(key), }); // Since these are additional properties we don't need to add the `experimental_defaultFormStateBehavior` prop maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues, required, formDataRequired); }); } return objectDefaults; } case 'array': { const neverPopulate = ((_a = experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) === null || _a === void 0 ? void 0 : _a.populate) === 'never'; const ignoreMinItemsFlagSet = ((_b = experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) === null || _b === void 0 ? void 0 : _b.populate) === 'requiredOnly'; // Inject defaults into existing array defaults if (Array.isArray(defaults)) { defaults = defaults.map((item, idx) => { const schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx); return computeDefaults(validator, schemaItem, { rootSchema, _recurseList, experimental_defaultFormStateBehavior, parentDefaults: item, required, }); }); } // Deeply inject defaults into already existing form data if (Array.isArray(rawFormData)) { const schemaItem = getInnerSchemaForArrayItem(schema); if (neverPopulate) { defaults = rawFormData; } else { defaults = rawFormData.map((item, idx) => { return computeDefaults(validator, schemaItem, { rootSchema, _recurseList, experimental_defaultFormStateBehavior, rawFormData: item, parentDefaults: get_default()(defaults, [idx]), required, }); }); } } if (neverPopulate) { return defaults !== null && defaults !== void 0 ? defaults : []; } if (ignoreMinItemsFlagSet && !required) { // If no form data exists or defaults are set leave the field empty/non-existent, otherwise // return form data/defaults return defaults ? defaults : undefined; } const defaultsLength = Array.isArray(defaults) ? defaults.length : 0; if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || schema.minItems <= defaultsLength) { return defaults ? defaults : []; } const defaultEntries = (defaults || []); const fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert); const fillerDefault = fillerSchema.default; // Calculate filler entries for remaining items (minItems - existing raw data/defaults) const fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, { parentDefaults: fillerDefault, rootSchema, _recurseList, experimental_defaultFormStateBehavior, required, })); // then fill up the rest with either the item default or empty, up to minItems return defaultEntries.concat(fillerEntries); } } return defaults; } /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have * computed to have defaults provided in the `schema`. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param theSchema - The schema for which the default state is desired * @param [formData] - The current formData, if any, onto which to provide any missing defaults * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults. * If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as * false when computing defaults for any nested object properties. * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior * @returns - The resulting `formData` with all the defaults provided */ function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) { if (!isObject(theSchema)) { throw new Error('Invalid schema: ' + theSchema); } const schema = retrieveSchema(validator, theSchema, rootSchema, formData); const defaults = computeDefaults(validator, schema, { rootSchema, includeUndefinedValues, experimental_defaultFormStateBehavior, rawFormData: formData, }); if (formData === undefined || formData === null || (typeof formData === 'number' && isNaN(formData))) { // No form data? Use schema defaults. return defaults; } const { mergeExtraDefaults } = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) || {}; if (isObject(formData)) { return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults); } if (Array.isArray(formData)) { return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults); } return formData; } //# sourceMappingURL=getDefaultFormState.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/isCustomWidget.js /** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden` * * @param uiSchema - The UI Schema from which to detect if it is customized * @returns - True if the `uiSchema` describes a custom widget, false otherwise */ function isCustomWidget(uiSchema = {}) { return ( // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays. // https://rjsf-team.github.io/react-jsonschema-form/docs/usage/widgets/#hidden-widgets 'widget' in getUiOptions(uiSchema) && getUiOptions(uiSchema)['widget'] !== 'hidden'); } //# sourceMappingURL=isCustomWidget.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/isFilesArray.js /** Checks to see if the `schema` and `uiSchema` combination represents an array of files * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which check for array of files flag is desired * @param [uiSchema={}] - The UI schema from which to check the widget * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @returns - True if schema/uiSchema contains an array of files, otherwise false */ function isFilesArray(validator, schema, uiSchema = {}, rootSchema) { if (uiSchema[UI_WIDGET_KEY] === 'files') { return true; } if (schema.items) { const itemsSchema = retrieveSchema(validator, schema.items, rootSchema); return itemsSchema.type === 'string' && itemsSchema.format === 'data-url'; } return false; } //# sourceMappingURL=isFilesArray.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/getDisplayLabel.js /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema` * should be displayed in a UI. * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which the display label flag is desired * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options * @returns - True if the label should be displayed or false if it should not */ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions) { const uiOptions = getUiOptions(uiSchema, globalOptions); const { label = true } = uiOptions; let displayLabel = !!label; const schemaType = getSchemaType(schema); if (schemaType === 'array') { displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema); } if (schemaType === 'object') { displayLabel = false; } if (schemaType === 'boolean' && !uiSchema[UI_WIDGET_KEY]) { displayLabel = false; } if (uiSchema[UI_FIELD_KEY]) { displayLabel = false; } return displayLabel; } //# sourceMappingURL=getDisplayLabel.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/mergeValidationData.js /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then * `validationData` is returned. * * @param validator - The validator used to convert an ErrorSchema to a list of errors * @param validationData - The current `ValidationData` into which to merge the additional errors * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema` * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided. * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be * removed in the next major release. */ function mergeValidationData(validator, validationData, additionalErrorSchema) { if (!additionalErrorSchema) { return validationData; } const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData; let errors = validator.toErrorList(additionalErrorSchema); let errorSchema = additionalErrorSchema; if (!isEmpty_default()(oldErrorSchema)) { errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true); errors = [...oldErrors].concat(errors); } return { errorSchema, errors }; } //# sourceMappingURL=mergeValidationData.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/sanitizeDataForNewSchema.js const NO_VALUE = Symbol('no Value'); /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema * that are non-existent in the new schema are set to `undefined`. The data sanitization process has the following flow: * * - If the new schema is an object that contains a `properties` object then: * - Create a `removeOldSchemaData` object, setting each key in the `oldSchema.properties` having `data` to undefined * - Create an empty `nestedData` object for use in the key filtering below: * - Iterate over each key in the `newSchema.properties` as follows: * - Get the `formValue` of the key from the `data` * - Get the `oldKeySchema` and `newKeyedSchema` for the key, defaulting to `{}` when it doesn't exist * - Retrieve the schema for any refs within each `oldKeySchema` and/or `newKeySchema` * - Get the types of the old and new keyed schemas and if the old doesn't exist or the old & new are the same then: * - If `removeOldSchemaData` has an entry for the key, delete it since the new schema has the same property * - If type of the key in the new schema is `object`: * - Store the value from the recursive `sanitizeDataForNewSchema` call in `nestedData[key]` * - Otherwise, check for default or const values: * - Get the old and new `default` values from the schema and check: * - If the new `default` value does not match the form value: * - If the old `default` value DOES match the form value, then: * - Replace `removeOldSchemaData[key]` with the new `default` * - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined * - Get the old and new `const` values from the schema and check: * - If the new `const` value does not match the form value: * - If the old `const` value DOES match the form value, then: * - Replace `removeOldSchemaData[key]` with the new `const` * - Otherwise, replace `removeOldSchemaData[key]` with undefined * - Once all keys have been processed, return an object built as follows: * - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }` * - If the new and old schema types are array and the `data` is an array then: * - If the type of the old and new schema `items` are a non-array objects: * - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items` * - If the `type`s of both items are the same (or the old does not have a type): * - If the type is "object", then: * - For each element in the `data` recursively sanitize the data, stopping at `maxItems` if specified * - Otherwise, just return the `data` removing any values after `maxItems` if it is set * - If the type of the old and new schema `items` are booleans of the same value, return `data` as is * - Otherwise return `undefined` * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param rootSchema - The root JSON schema of the entire form * @param [newSchema] - The new schema for which the data is being sanitized * @param [oldSchema] - The old schema from which the data originated * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined * @returns - The new form data, with all the fields uniquely associated with the old schema set * to `undefined`. Will return `undefined` if the new schema is not an object containing properties. */ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) { // By default, we will clear the form data let newFormData; // If the new schema is of type object and that object contains a list of properties if (has_default()(newSchema, PROPERTIES_KEY)) { // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data const removeOldSchemaData = {}; if (has_default()(oldSchema, PROPERTIES_KEY)) { const properties = get_default()(oldSchema, PROPERTIES_KEY, {}); Object.keys(properties).forEach((key) => { if (has_default()(data, key)) { removeOldSchemaData[key] = undefined; } }); } const keys = Object.keys(get_default()(newSchema, PROPERTIES_KEY, {})); // Create a place to store nested data that will be a side-effect of the filter const nestedData = {}; keys.forEach((key) => { const formValue = get_default()(data, key); let oldKeyedSchema = get_default()(oldSchema, [PROPERTIES_KEY, key], {}); let newKeyedSchema = get_default()(newSchema, [PROPERTIES_KEY, key], {}); // Resolve the refs if they exist if (has_default()(oldKeyedSchema, REF_KEY)) { oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue); } if (has_default()(newKeyedSchema, REF_KEY)) { newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue); } // Now get types and see if they are the same const oldSchemaTypeForKey = get_default()(oldKeyedSchema, 'type'); const newSchemaTypeForKey = get_default()(newKeyedSchema, 'type'); // Check if the old option has the same key with the same type if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) { if (has_default()(removeOldSchemaData, key)) { // SIDE-EFFECT: remove the undefined value for a key that has the same type between the old and new schemas delete removeOldSchemaData[key]; } // If it is an object, we'll recurse and store the resulting sanitized data for the key if (newSchemaTypeForKey === 'object' || (newSchemaTypeForKey === 'array' && Array.isArray(formValue))) { // SIDE-EFFECT: process the new schema type of object recursively to save iterations const itemData = sanitizeDataForNewSchema(validator, rootSchema, newKeyedSchema, oldKeyedSchema, formValue); if (itemData !== undefined || newSchemaTypeForKey === 'array') { // only put undefined values for the array type and not the object type nestedData[key] = itemData; } } else { // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced // with the new default or const. This allows the case where two schemas differ that only by the default/const // value to be properly selected const newOptionDefault = get_default()(newKeyedSchema, 'default', NO_VALUE); const oldOptionDefault = get_default()(oldKeyedSchema, 'default', NO_VALUE); if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) { if (oldOptionDefault === formValue) { // If the old default matches the formValue, we'll update the new value to match the new default removeOldSchemaData[key] = newOptionDefault; } else if (get_default()(newKeyedSchema, 'readOnly') === true) { // If the new schema has the default set to read-only, treat it like a const and remove the value removeOldSchemaData[key] = undefined; } } const newOptionConst = get_default()(newKeyedSchema, 'const', NO_VALUE); const oldOptionConst = get_default()(oldKeyedSchema, 'const', NO_VALUE); if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) { // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined; } } } }); newFormData = { ...(typeof data == 'string' || Array.isArray(data) ? undefined : data), ...removeOldSchemaData, ...nestedData, }; // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep } else if (get_default()(oldSchema, 'type') === 'array' && get_default()(newSchema, 'type') === 'array' && Array.isArray(data)) { let oldSchemaItems = get_default()(oldSchema, 'items'); let newSchemaItems = get_default()(newSchema, 'items'); // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations if (typeof oldSchemaItems === 'object' && typeof newSchemaItems === 'object' && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) { if (has_default()(oldSchemaItems, REF_KEY)) { oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data); } if (has_default()(newSchemaItems, REF_KEY)) { newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data); } // Now get types and see if they are the same const oldSchemaType = get_default()(oldSchemaItems, 'type'); const newSchemaType = get_default()(newSchemaItems, 'type'); // Check if the old option has the same key with the same type if (!oldSchemaType || oldSchemaType === newSchemaType) { const maxItems = get_default()(newSchema, 'maxItems', -1); if (newSchemaType === 'object') { newFormData = data.reduce((newValue, aValue) => { const itemValue = sanitizeDataForNewSchema(validator, rootSchema, newSchemaItems, oldSchemaItems, aValue); if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) { newValue.push(itemValue); } return newValue; }, []); } else { newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data; } } } else if (typeof oldSchemaItems === 'boolean' && typeof newSchemaItems === 'boolean' && oldSchemaItems === newSchemaItems) { // If they are both booleans and have the same value just return the data as is otherwise fall-thru to undefined newFormData = data; } // Also probably want to deal with `prefixItems` as tuples with the latest 2020 draft } return newFormData; } //# sourceMappingURL=sanitizeDataForNewSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/toIdSchema.js /** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against * infinite recursion * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which the `IdSchema` is desired * @param idPrefix - The prefix to use for the id * @param idSeparator - The separator to use for the path segments in the id * @param [id] - The base id for the schema * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [formData] - The current formData, if any, to assist retrieving a schema * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion * @returns - The `IdSchema` object for the `schema` */ function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) { if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) { const _schema = retrieveSchema(validator, schema, rootSchema, formData); const sameSchemaIndex = _recurseList.findIndex((item) => isEqual_default()(item, _schema)); if (sameSchemaIndex === -1) { return toIdSchemaInternal(validator, _schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList.concat(_schema)); } } if (ITEMS_KEY in schema && !get_default()(schema, [ITEMS_KEY, REF_KEY])) { return toIdSchemaInternal(validator, get_default()(schema, ITEMS_KEY), idPrefix, idSeparator, id, rootSchema, formData, _recurseList); } const $id = id || idPrefix; const idSchema = { $id }; if (getSchemaType(schema) === 'object' && PROPERTIES_KEY in schema) { for (const name in schema.properties) { const field = get_default()(schema, [PROPERTIES_KEY, name]); const fieldId = idSchema[ID_KEY] + idSeparator + name; idSchema[name] = toIdSchemaInternal(validator, isObject(field) ? field : {}, idPrefix, idSeparator, fieldId, rootSchema, // It's possible that formData is not an object -- this can happen if an // array item has just been added, but not populated with data yet get_default()(formData, [name]), _recurseList); } } return idSchema; } /** Generates an `IdSchema` object for the `schema`, recursively * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which the `IdSchema` is desired * @param [id] - The base id for the schema * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [formData] - The current formData, if any, to assist retrieving a schema * @param [idPrefix='root'] - The prefix to use for the id * @param [idSeparator='_'] - The separator to use for the path segments in the id * @returns - The `IdSchema` object for the `schema` */ function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = 'root', idSeparator = '_') { return toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData); } //# sourceMappingURL=toIdSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/toPathSchema.js /** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against * infinite recursion * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which the `PathSchema` is desired * @param [name=''] - The base name for the schema * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [formData] - The current formData, if any, to assist retrieving a schema * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion * @returns - The `PathSchema` object for the `schema` */ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) { if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) { const _schema = retrieveSchema(validator, schema, rootSchema, formData); const sameSchemaIndex = _recurseList.findIndex((item) => isEqual_default()(item, _schema)); if (sameSchemaIndex === -1) { return toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList.concat(_schema)); } } let pathSchema = { [NAME_KEY]: name.replace(/^\./, ''), }; if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) { const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf; const discriminator = getDiscriminatorFieldFromSchema(schema); const index = getClosestMatchingOption(validator, rootSchema, formData, xxxOf, 0, discriminator); const _schema = xxxOf[index]; pathSchema = { ...pathSchema, ...toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList), }; } if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) { set_default()(pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true); } if (ITEMS_KEY in schema && Array.isArray(formData)) { const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema; if (Array.isArray(schemaItems)) { formData.forEach((element, i) => { if (schemaItems[i]) { pathSchema[i] = toPathSchemaInternal(validator, schemaItems[i], `${name}.${i}`, rootSchema, element, _recurseList); } else if (schemaAdditionalItems) { pathSchema[i] = toPathSchemaInternal(validator, schemaAdditionalItems, `${name}.${i}`, rootSchema, element, _recurseList); } else { console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`); } }); } else { formData.forEach((element, i) => { pathSchema[i] = toPathSchemaInternal(validator, schemaItems, `${name}.${i}`, rootSchema, element, _recurseList); }); } } else if (PROPERTIES_KEY in schema) { for (const property in schema.properties) { const field = get_default()(schema, [PROPERTIES_KEY, property]); pathSchema[property] = toPathSchemaInternal(validator, field, `${name}.${property}`, rootSchema, // It's possible that formData is not an object -- this can happen if an // array item has just been added, but not populated with data yet get_default()(formData, [property]), _recurseList); } } return pathSchema; } /** Generates an `PathSchema` object for the `schema`, recursively * * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary * @param schema - The schema for which the `PathSchema` is desired * @param [name=''] - The base name for the schema * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param [formData] - The current formData, if any, to assist retrieving a schema * @returns - The `PathSchema` object for the `schema` */ function toPathSchema(validator, schema, name = '', rootSchema, formData) { return toPathSchemaInternal(validator, schema, name, rootSchema, formData); } //# sourceMappingURL=toPathSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schema/index.js //# sourceMappingURL=index.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/createSchemaUtils.js /** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such * that one does not have to explicitly pass the `validator`, `rootSchema`, or `experimental_defaultFormStateBehavior` to each method. * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface. */ class SchemaUtils { /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables * * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param rootSchema - The root schema that will be forwarded to all the APIs * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior */ constructor(validator, rootSchema, experimental_defaultFormStateBehavior) { this.rootSchema = rootSchema; this.validator = validator; this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior; } /** Returns the `ValidatorType` in the `SchemaUtilsType` * * @returns - The `ValidatorType` */ getValidator() { return this.validator; } /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation * of a new `SchemaUtilsType` with incomplete properties. * * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one * @param rootSchema - The root schema that will be compared against the current one * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema` */ doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}) { if (!validator || !rootSchema) { return false; } return (this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior)); } /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have * computed to have defaults provided in the `schema`. * * @param schema - The schema for which the default state is desired * @param [formData] - The current formData, if any, onto which to provide any missing defaults * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults. * If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested * object properties. * @returns - The resulting `formData` with all the defaults provided */ getDefaultFormState(schema, formData, includeUndefinedValues = false) { return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues, this.experimental_defaultFormStateBehavior); } /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema` * should be displayed in a UI. * * @param schema - The schema for which the display label flag is desired * @param [uiSchema] - The UI schema from which to derive potentially displayable information * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options * @returns - True if the label should be displayed or false if it should not */ getDisplayLabel(schema, uiSchema, globalOptions) { return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions); } /** Determines which of the given `options` provided most closely matches the `formData`. * Returns the index of the option that is valid and is the closest match, or 0 if there is no match. * * The closest match is determined using the number of matching properties, and more heavily favors options with * matching readOnly, default, or const values. * * @param formData - The form data associated with the schema * @param options - The list of options that can be selected from * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match */ getClosestMatchingOption(formData, options, selectedOption, discriminatorField) { return getClosestMatchingOption(this.validator, this.rootSchema, formData, options, selectedOption, discriminatorField); } /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data. * Always returns the first option if there is nothing that matches. * * @param formData - The current formData, if any, used to figure out a match * @param options - The list of options to find a matching options from * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The firstindex of the matched option or 0 if none is available */ getFirstMatchingOption(formData, options, discriminatorField) { return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField); } /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data. * Deprecated, use `getFirstMatchingOption()` instead. * * @param formData - The current formData, if any, onto which to provide any missing defaults * @param options - The list of options to find a matching options from * @param [discriminatorField] - The optional name of the field within the options object whose value is used to * determine which option is selected * @returns - The index of the matched option or 0 if none is available * @deprecated */ getMatchingOption(formData, options, discriminatorField) { return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField); } /** Checks to see if the `schema` and `uiSchema` combination represents an array of files * * @param schema - The schema for which check for array of files flag is desired * @param [uiSchema] - The UI schema from which to check the widget * @returns - True if schema/uiSchema contains an array of files, otherwise false */ isFilesArray(schema, uiSchema) { return isFilesArray(this.validator, schema, uiSchema, this.rootSchema); } /** Checks to see if the `schema` combination represents a multi-select * * @param schema - The schema for which check for a multi-select flag is desired * @returns - True if schema contains a multi-select, otherwise false */ isMultiSelect(schema) { return isMultiSelect(this.validator, schema, this.rootSchema); } /** Checks to see if the `schema` combination represents a select * * @param schema - The schema for which check for a select flag is desired * @returns - True if schema contains a select, otherwise false */ isSelect(schema) { return isSelect(this.validator, schema, this.rootSchema); } /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, * then `validationData` is returned. * * @param validationData - The current `ValidationData` into which to merge the additional errors * @param [additionalErrorSchema] - The additional set of errors * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided. * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be * removed in the next major release. */ mergeValidationData(validationData, additionalErrorSchema) { return mergeValidationData(this.validator, validationData, additionalErrorSchema); } /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially * recursive resolution. * * @param schema - The schema for which retrieving a schema is desired * @param [rawFormData] - The current formData, if any, to assist retrieving a schema * @returns - The schema having its conditions, additional properties, references and dependencies resolved */ retrieveSchema(schema, rawFormData) { return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData); } /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the * old schemas that are non-existent in the new schema are set to `undefined`. * * @param [newSchema] - The new schema for which the data is being sanitized * @param [oldSchema] - The old schema from which the data originated * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined * @returns - The new form data, with all the fields uniquely associated with the old schema set * to `undefined`. Will return `undefined` if the new schema is not an object containing properties. */ sanitizeDataForNewSchema(newSchema, oldSchema, data) { return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data); } /** Generates an `IdSchema` object for the `schema`, recursively * * @param schema - The schema for which the display label flag is desired * @param [id] - The base id for the schema * @param [formData] - The current formData, if any, onto which to provide any missing defaults * @param [idPrefix='root'] - The prefix to use for the id * @param [idSeparator='_'] - The separator to use for the path segments in the id * @returns - The `IdSchema` object for the `schema` */ toIdSchema(schema, id, formData, idPrefix = 'root', idSeparator = '_') { return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator); } /** Generates an `PathSchema` object for the `schema`, recursively * * @param schema - The schema for which the display label flag is desired * @param [name] - The base name for the schema * @param [formData] - The current formData, if any, onto which to provide any missing defaults * @returns - The `PathSchema` object for the `schema` */ toPathSchema(schema, name, formData) { return toPathSchema(this.validator, schema, name, this.rootSchema, formData); } } /** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs. * * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs * @param rootSchema - The root schema that will be forwarded to all the APIs * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior * @returns - An implementation of a `SchemaUtilsType` interface */ function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}) { return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior); } //# sourceMappingURL=createSchemaUtils.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/dataURItoBlob.js /** Given the `FileReader.readAsDataURL()` based `dataURI` extracts that data into an actual Blob along with the name * of that Blob if provided in the URL. If no name is provided, then the name falls back to `unknown`. * * @param dataURI - The `DataUrl` potentially containing name and raw data to be converted to a Blob * @returns - an object containing a Blob and its name, extracted from the URI */ function dataURItoBlob(dataURI) { // Split metadata from data const splitted = dataURI.split(','); // Split params const params = splitted[0].split(';'); // Get mime-type from params const type = params[0].replace('data:', ''); // Filter the name property from params const properties = params.filter((param) => { return param.split('=')[0] === 'name'; }); // Look for the name and use unknown if no name property. let name; if (properties.length !== 1) { name = 'unknown'; } else { // Because we filtered out the other property, // we only have the name case here, which we decode to make it human-readable name = decodeURI(properties[0].split('=')[1]); } // Built the Uint8Array Blob parameter from the base64 string. try { const binary = atob(splitted[1]); const array = []; for (let i = 0; i < binary.length; i++) { array.push(binary.charCodeAt(i)); } // Create the blob object const blob = new window.Blob([new Uint8Array(array)], { type }); return { blob, name }; } catch (error) { return { blob: { size: 0, type: error.message }, name: dataURI }; } } //# sourceMappingURL=dataURItoBlob.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/replaceStringParameters.js /** Potentially substitutes all replaceable parameters with the associated value(s) from the `params` if available. When * a `params` array is provided, each value in the array is used to replace any of the replaceable parameters in the * `inputString` using the `%1`, `%2`, etc. replacement specifiers. * * @param inputString - The string which will be potentially updated with replacement parameters * @param params - The optional list of replaceable parameter values to substitute into the english string * @returns - The updated string with any replacement specifiers replaced */ function replaceStringParameters(inputString, params) { let output = inputString; if (Array.isArray(params)) { const parts = output.split(/(%\d)/); params.forEach((param, index) => { const partIndex = parts.findIndex((part) => part === `%${index + 1}`); if (partIndex >= 0) { parts[partIndex] = param; } }); output = parts.join(''); } return output; } //# sourceMappingURL=replaceStringParameters.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/englishStringTranslator.js /** Translates a `TranslatableString` value `stringToTranslate` into english. When a `params` array is provided, each * value in the array is used to replace any of the replaceable parameters in the `stringToTranslate` using the `%1`, * `%2`, etc. replacement specifiers. * * @param stringToTranslate - The `TranslatableString` value to convert to english * @param params - The optional list of replaceable parameter values to substitute into the english string * @returns - The `stringToTranslate` itself with any replaceable parameter values substituted */ function englishStringTranslator(stringToTranslate, params) { return replaceStringParameters(stringToTranslate, params); } //# sourceMappingURL=englishStringTranslator.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enumOptionsValueForIndex.js /** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it * contains an invalid index, the returned array will have the resulting undefined values filtered out, leaving only * valid values or in the worst case, an empty array. * * @param valueIndex - The index(es) of the value(s) that should be returned * @param [allEnumOptions=[]] - The list of all the known enumOptions * @param [emptyValue] - The value to return when the non-array `valueIndex` does not refer to a real option * @returns - The single or list of values specified by the single or list of indexes if they are valid. Otherwise, * `emptyValue` or an empty list. */ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) { if (Array.isArray(valueIndex)) { return valueIndex.map((index) => enumOptionsValueForIndex(index, allEnumOptions)).filter((val) => val); } // So Number(null) and Number('') both return 0, so use emptyValue for those two values const index = valueIndex === '' || valueIndex === null ? -1 : Number(valueIndex); const option = allEnumOptions[index]; return option ? option.value : emptyValue; } //# sourceMappingURL=enumOptionsValueForIndex.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enumOptionsDeselectValue.js /** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is * a single value, then if the enum option value with the `valueIndex` in `allEnumOptions` matches `selected`, undefined * is returned, otherwise the `selected` value is returned. * * @param valueIndex - The index of the value to be removed from the selected list or single value * @param selected - The current (list of) selected value(s) * @param [allEnumOptions=[]] - The list of all the known enumOptions * @returns - The updated `selected` with the enum option value at `valueIndex` in `allEnumOptions` removed from it, * unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns * undefined, otherwise `selected`. */ function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) { const value = enumOptionsValueForIndex(valueIndex, allEnumOptions); if (Array.isArray(selected)) { return selected.filter((v) => !isEqual_default()(v, value)); } return isEqual_default()(value, selected) ? undefined : selected; } //# sourceMappingURL=enumOptionsDeselectValue.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enumOptionsIsSelected.js /** Determines whether the given `value` is (one of) the `selected` value(s). * * @param value - The value being checked to see if it is selected * @param selected - The current selected value or list of values * @returns - true if the `value` is one of the `selected` ones, false otherwise */ function enumOptionsIsSelected(value, selected) { if (Array.isArray(selected)) { return selected.some((sel) => isEqual_default()(sel, value)); } return isEqual_default()(selected, value); } //# sourceMappingURL=enumOptionsIsSelected.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enumOptionsIndexForValue.js /** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is * returned. * * @param value - The single value or list of values for which indexes are desired * @param [allEnumOptions=[]] - The list of all the known enumOptions * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list * of indexes for (each of) the value(s) in `value`. */ function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) { const selectedIndexes = allEnumOptions .map((opt, index) => (enumOptionsIsSelected(opt.value, value) ? String(index) : undefined)) .filter((opt) => typeof opt !== 'undefined'); if (!multiple) { return selectedIndexes[0]; } return selectedIndexes; } //# sourceMappingURL=enumOptionsIndexForValue.js.map // EXTERNAL MODULE: ../node_modules/lodash/isNil.js var isNil = __webpack_require__(30644); var isNil_default = /*#__PURE__*/__webpack_require__.n(isNil); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enumOptionsSelectValue.js /** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by * `allEnumOptions` * * @param valueIndex - The index of the value that should be selected * @param selected - The current list of selected values * @param [allEnumOptions=[]] - The list of all the known enumOptions * @returns - The updated list of selected enum values with enum value at the `valueIndex` added to it */ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) { const value = enumOptionsValueForIndex(valueIndex, allEnumOptions); if (!isNil_default()(value)) { const index = allEnumOptions.findIndex((opt) => value === opt.value); const all = allEnumOptions.map(({ value: val }) => val); const updated = selected.slice(0, index).concat(value, selected.slice(index)); // As inserting values at predefined index positions doesn't work with empty // arrays, we need to reorder the updated selection to match the initial order return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b))); } return selected; } //# sourceMappingURL=enumOptionsSelectValue.js.map // EXTERNAL MODULE: ../node_modules/lodash/cloneDeep.js var cloneDeep = __webpack_require__(30454); var cloneDeep_default = /*#__PURE__*/__webpack_require__.n(cloneDeep); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/ErrorSchemaBuilder.js /** The `ErrorSchemaBuilder` is used to build an `ErrorSchema` since the definition of the `ErrorSchema` type is * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can * get the result and/or reset all the errors back to an initial set and start again. */ class ErrorSchemaBuilder { /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`. * * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class */ constructor(initialSchema) { /** The error schema being built * * @private */ this.errorSchema = {}; this.resetAllErrors(initialSchema); } /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder` */ get ErrorSchema() { return this.errorSchema; } /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one. * * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s) * @returns - The error block for the given `pathOfError` or the root if not provided * @private */ getOrCreateErrorBlock(pathOfError) { const hasPath = (Array.isArray(pathOfError) && pathOfError.length > 0) || typeof pathOfError === 'string'; let errorBlock = hasPath ? get_default()(this.errorSchema, pathOfError) : this.errorSchema; if (!errorBlock && pathOfError) { errorBlock = {}; set_default()(this.errorSchema, pathOfError, errorBlock); } return errorBlock; } /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set. * * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class * @returns - The `ErrorSchemaBuilder` object for chaining purposes */ resetAllErrors(initialSchema) { this.errorSchema = initialSchema ? cloneDeep_default()(initialSchema) : {}; return this; } /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within * the schema described by the `pathOfError`. For more information about how to specify the path see the * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md). * * @param errorOrList - The error or list of errors to add into the `ErrorSchema` * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s) * @returns - The `ErrorSchemaBuilder` object for chaining purposes */ addErrors(errorOrList, pathOfError) { const errorBlock = this.getOrCreateErrorBlock(pathOfError); let errorsList = get_default()(errorBlock, ERRORS_KEY); if (!Array.isArray(errorsList)) { errorsList = []; errorBlock[ERRORS_KEY] = errorsList; } if (Array.isArray(errorOrList)) { errorsList.push(...errorOrList); } else { errorsList.push(errorOrList); } return this; } /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location * within the schema described by the `pathOfError`. For more information about how to specify the path see the * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md). * * @param errorOrList - The error or list of errors to set into the `ErrorSchema` * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s) * @returns - The `ErrorSchemaBuilder` object for chaining purposes */ setErrors(errorOrList, pathOfError) { const errorBlock = this.getOrCreateErrorBlock(pathOfError); // Effectively clone the array being given to prevent accidental outside manipulation of the given list const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList]; set_default()(errorBlock, ERRORS_KEY, listToAdd); return this; } /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by * the `pathOfError`. For more information about how to specify the path see the * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md). * * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s) * @returns - The `ErrorSchemaBuilder` object for chaining purposes */ clearErrors(pathOfError) { const errorBlock = this.getOrCreateErrorBlock(pathOfError); set_default()(errorBlock, ERRORS_KEY, []); return this; } } //# sourceMappingURL=ErrorSchemaBuilder.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getDateElementProps.js /** Given date & time information with optional yearRange & format, returns props for DateElement * * @param date - Object containing date with optional time information * @param time - Determines whether to include time or not * @param [yearRange=[1900, new Date().getFullYear() + 2]] - Controls the list of years to be displayed * @param [format='YMD'] - Controls the order in which day, month and year input element will be displayed * @returns Array of props for DateElement */ function getDateElementProps(date, time, yearRange = [1900, new Date().getFullYear() + 2], format = 'YMD') { const { day, month, year, hour, minute, second } = date; const dayObj = { type: 'day', range: [1, 31], value: day }; const monthObj = { type: 'month', range: [1, 12], value: month }; const yearObj = { type: 'year', range: yearRange, value: year }; const dateElementProp = []; switch (format) { case 'MDY': dateElementProp.push(monthObj, dayObj, yearObj); break; case 'DMY': dateElementProp.push(dayObj, monthObj, yearObj); break; case 'YMD': default: dateElementProp.push(yearObj, monthObj, dayObj); } if (time) { dateElementProp.push({ type: 'hour', range: [0, 23], value: hour }, { type: 'minute', range: [0, 59], value: minute }, { type: 'second', range: [0, 59], value: second }); } return dateElementProp; } //# sourceMappingURL=getDateElementProps.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/rangeSpec.js /** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`. * * @param schema - The schema from which to extract the range spec * @returns - A range specification from the schema */ function rangeSpec(schema) { const spec = {}; if (schema.multipleOf) { spec.step = schema.multipleOf; } if (schema.minimum || schema.minimum === 0) { spec.min = schema.minimum; } if (schema.maximum || schema.maximum === 0) { spec.max = schema.maximum; } return spec; } //# sourceMappingURL=rangeSpec.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getInputProps.js /** Using the `schema`, `defaultType` and `options`, extract out the props for the element that make sense. * * @param schema - The schema for the field provided by the widget * @param [defaultType] - The default type, if any, for the field provided by the widget * @param [options={}] - The UI Options for the field provided by the widget * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step * @returns - The extracted `InputPropsType` object */ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = true) { const inputProps = { type: defaultType || 'text', ...rangeSpec(schema), }; // If options.inputType is set use that as the input type if (options.inputType) { inputProps.type = options.inputType; } else if (!defaultType) { // If the schema is of type number or integer, set the input type to number if (schema.type === 'number') { inputProps.type = 'number'; // Only add step if one isn't already defined and we are auto-defaulting the "any" step if (autoDefaultStepAny && inputProps.step === undefined) { // Setting step to 'any' fixes a bug in Safari where decimals are not // allowed in number inputs inputProps.step = 'any'; } } else if (schema.type === 'integer') { inputProps.type = 'number'; // Only add step if one isn't already defined if (inputProps.step === undefined) { // Since this is integer, you always want to step up or down in multiples of 1 inputProps.step = 1; } } } if (options.autocomplete) { inputProps.autoComplete = options.autocomplete; } return inputProps; } //# sourceMappingURL=getInputProps.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getSubmitButtonOptions.js /** The default submit button options, exported for testing purposes */ const DEFAULT_OPTIONS = { props: { disabled: false, }, submitText: 'Submit', norender: false, }; /** Extracts any `ui:submitButtonOptions` from the `uiSchema` and merges them onto the `DEFAULT_OPTIONS` * * @param [uiSchema={}] - the UI Schema from which to extract submit button props * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones */ function getSubmitButtonOptions(uiSchema = {}) { const uiOptions = getUiOptions(uiSchema); if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) { const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY]; return { ...DEFAULT_OPTIONS, ...options }; } return DEFAULT_OPTIONS; } //# sourceMappingURL=getSubmitButtonOptions.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getTemplate.js /** Returns the template with the given `name` from either the `uiSchema` if it is defined or from the `registry` * otherwise. NOTE, since `ButtonTemplates` are not overridden in `uiSchema` only those in the `registry` are returned. * * @param name - The name of the template to fetch, restricted to the keys of `TemplatesType` * @param registry - The `Registry` from which to read the template * @param [uiOptions={}] - The `UIOptionsType` from which to read an alternate template * @returns - The template from either the `uiSchema` or `registry` for the `name` */ function getTemplate(name, registry, uiOptions = {}) { const { templates } = registry; if (name === 'ButtonTemplates') { return templates[name]; } return ( // Evaluating uiOptions[name] results in TS2590: Expression produces a union type that is too complex to represent // To avoid that, we cast uiOptions to `any` before accessing the name field uiOptions[name] || templates[name]); } //# sourceMappingURL=getTemplate.js.map // EXTERNAL MODULE: ../node_modules/react/jsx-runtime.js var jsx_runtime = __webpack_require__(24246); // EXTERNAL MODULE: consume shared module (default) react@~18.2.0 (singleton) (fallback: ../node_modules/react/index.js) var index_js_ = __webpack_require__(78156); // EXTERNAL MODULE: ../node_modules/react-is/index.js var react_is = __webpack_require__(19185); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/getWidget.js /** The map of schema types to widget type to widget name */ const widgetMap = { boolean: { checkbox: 'CheckboxWidget', radio: 'RadioWidget', select: 'SelectWidget', hidden: 'HiddenWidget', }, string: { text: 'TextWidget', password: 'PasswordWidget', email: 'EmailWidget', hostname: 'TextWidget', ipv4: 'TextWidget', ipv6: 'TextWidget', uri: 'URLWidget', 'data-url': 'FileWidget', radio: 'RadioWidget', select: 'SelectWidget', textarea: 'TextareaWidget', hidden: 'HiddenWidget', date: 'DateWidget', datetime: 'DateTimeWidget', 'date-time': 'DateTimeWidget', 'alt-date': 'AltDateWidget', 'alt-datetime': 'AltDateTimeWidget', time: 'TimeWidget', color: 'ColorWidget', file: 'FileWidget', }, number: { text: 'TextWidget', select: 'SelectWidget', updown: 'UpDownWidget', range: 'RangeWidget', radio: 'RadioWidget', hidden: 'HiddenWidget', }, integer: { text: 'TextWidget', select: 'SelectWidget', updown: 'UpDownWidget', range: 'RangeWidget', radio: 'RadioWidget', hidden: 'HiddenWidget', }, array: { select: 'SelectWidget', checkboxes: 'CheckboxesWidget', files: 'FileWidget', hidden: 'HiddenWidget', }, }; /** Wraps the given widget with stateless functional component that will merge any `defaultProps.options` with the * `options` that are provided in the props. It will add the wrapper component as a `MergedWidget` property onto the * `Widget` so that future attempts to wrap `AWidget` will return the already existing wrapper. * * @param AWidget - A widget that will be wrapped or one that is already wrapped * @returns - The wrapper widget */ function mergeWidgetOptions(AWidget) { let MergedWidget = get_default()(AWidget, 'MergedWidget'); // cache return value as property of widget for proper react reconciliation if (!MergedWidget) { const defaultOptions = (AWidget.defaultProps && AWidget.defaultProps.options) || {}; MergedWidget = ({ options, ...props }) => { return (0,jsx_runtime.jsx)(AWidget, { options: { ...defaultOptions, ...options }, ...props }); }; set_default()(AWidget, 'MergedWidget', MergedWidget); } return MergedWidget; } /** Given a schema representing a field to render and either the name or actual `Widget` implementation, returns the * React component that is used to render the widget. If the `widget` is already a React component, then it is wrapped * with a `MergedWidget`. Otherwise an attempt is made to look up the widget inside of the `registeredWidgets` map based * on the schema type and `widget` name. If no widget component can be found an `Error` is thrown. * * @param schema - The schema for the field * @param [widget] - Either the name of the widget OR a `Widget` implementation to use * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation * @returns - The `Widget` component to use * @throws - An error if there is no `Widget` component that can be returned */ function getWidget(schema, widget, registeredWidgets = {}) { const type = getSchemaType(schema); if (typeof widget === 'function' || (widget && react_is.isForwardRef((0,index_js_.createElement)(widget))) || react_is.isMemo(widget)) { return mergeWidgetOptions(widget); } if (typeof widget !== 'string') { throw new Error(`Unsupported widget definition: ${typeof widget}`); } if (widget in registeredWidgets) { const registeredWidget = registeredWidgets[widget]; return getWidget(schema, registeredWidget, registeredWidgets); } if (typeof type === 'string') { if (!(type in widgetMap)) { throw new Error(`No widget for type '${type}'`); } if (widget in widgetMap[type]) { const registeredWidget = registeredWidgets[widgetMap[type][widget]]; return getWidget(schema, registeredWidget, registeredWidgets); } } throw new Error(`No widget '${widget}' for type '${type}'`); } //# sourceMappingURL=getWidget.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/hashForSchema.js /** JS has no built-in hashing function, so rolling our own * based on Java's hashing fn: * http://www.java2s.com/example/nodejs-utility-method/string-hash/hashcode-4dc2b.html * * @param string - The string for which to get the hash * @returns - The resulting hash of the string in hex format */ function hashString(string) { let hash = 0; for (let i = 0; i < string.length; i += 1) { const chr = string.charCodeAt(i); hash = (hash << 5) - hash + chr; hash = hash & hash; // Convert to 32bit integer } return hash.toString(16); } /** Stringifies the schema and returns the hash of the resulting string. Sorts schema fields * in consistent order before stringify to prevent different hash ids for the same schema. * * @param schema - The schema for which the hash is desired * @returns - The string obtained from the hash of the stringified schema */ function hashForSchema(schema) { const allKeys = new Set(); // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328 JSON.stringify(schema, (key, value) => (allKeys.add(key), value)); return hashString(JSON.stringify(schema, Array.from(allKeys).sort())); } //# sourceMappingURL=hashForSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/hasWidget.js /** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it * does, or false if it doesn't. * * @param schema - The schema for the field * @param widget - Either the name of the widget OR a `Widget` implementation to use * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation * @returns - True if the widget exists, false otherwise */ function hasWidget(schema, widget, registeredWidgets = {}) { try { getWidget(schema, widget, registeredWidgets); return true; } catch (e) { const err = e; if (err.message && (err.message.startsWith('No widget') || err.message.startsWith('Unsupported widget'))) { return false; } throw e; } } //# sourceMappingURL=hasWidget.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/idGenerators.js /** Generates a consistent `id` pattern for a given `id` and a `suffix` * * @param id - Either simple string id or an IdSchema from which to extract it * @param suffix - The suffix to append to the id */ function idGenerator(id, suffix) { const theId = isString_default()(id) ? id : id[ID_KEY]; return `${theId}__${suffix}`; } /** Return a consistent `id` for the field description element * * @param id - Either simple string id or an IdSchema from which to extract it * @returns - The consistent id for the field description element from the given `id` */ function descriptionId(id) { return idGenerator(id, 'description'); } /** Return a consistent `id` for the field error element * * @param id - Either simple string id or an IdSchema from which to extract it * @returns - The consistent id for the field error element from the given `id` */ function errorId(id) { return idGenerator(id, 'error'); } /** Return a consistent `id` for the field examples element * * @param id - Either simple string id or an IdSchema from which to extract it * @returns - The consistent id for the field examples element from the given `id` */ function examplesId(id) { return idGenerator(id, 'examples'); } /** Return a consistent `id` for the field help element * * @param id - Either simple string id or an IdSchema from which to extract it * @returns - The consistent id for the field help element from the given `id` */ function helpId(id) { return idGenerator(id, 'help'); } /** Return a consistent `id` for the field title element * * @param id - Either simple string id or an IdSchema from which to extract it * @returns - The consistent id for the field title element from the given `id` */ function titleId(id) { return idGenerator(id, 'title'); } /** Return a list of element ids that contain additional information about the field that can be used to as the aria * description of the field. This is correctly omitting `titleId` which would be "labeling" rather than "describing" the * element. * * @param id - Either simple string id or an IdSchema from which to extract it * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute */ function ariaDescribedByIds(id, includeExamples = false) { const examples = includeExamples ? ` ${examplesId(id)}` : ''; return `${errorId(id)} ${descriptionId(id)} ${helpId(id)}${examples}`; } /** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget * * @param id - The id of the parent component for the option * @param optionIndex - The index of the option for which the id is desired * @returns - An id for the option index based on the parent `id` */ function optionId(id, optionIndex) { return `${id}-${optionIndex}`; } //# sourceMappingURL=idGenerators.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/labelValue.js function labelValue(label, hideLabel, fallback) { return hideLabel ? fallback : label; } //# sourceMappingURL=labelValue.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/localToUTC.js /** Converts a local Date string into a UTC date string * * @param dateString - The string representation of a date as accepted by the `Date()` constructor * @returns - A UTC date string if `dateString` is truthy, otherwise undefined */ function localToUTC(dateString) { return dateString ? new Date(dateString).toJSON() : undefined; } //# sourceMappingURL=localToUTC.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/toConstant.js /** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise * throws an error. * * @param schema - The schema from which to obtain the constant value * @returns - The constant value for the schema * @throws - Error when the schema does not have a constant value */ function toConstant(schema) { if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) { return schema.enum[0]; } if (CONST_KEY in schema) { return schema.const; } throw new Error('schema cannot be inferred as a constant'); } //# sourceMappingURL=toConstant.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/optionsList.js /** Gets the list of options from the schema. If the schema has an enum list, then those enum values are returned. The * labels for the options will be extracted from the non-standard, RJSF-deprecated `enumNames` if it exists, otherwise * the label will be the same as the `value`. If the schema has a `oneOf` or `anyOf`, then the value is the list of * `const` values from the schema and the label is either the `schema.title` or the value. * * @param schema - The schema from which to extract the options list * @returns - The list of options from the schema */ function optionsList(schema) { // enumNames was deprecated in v5 and is intentionally omitted from the RJSFSchema type. // Cast the type to include enumNames so the feature still works. const schemaWithEnumNames = schema; if (schemaWithEnumNames.enumNames && "production" !== 'production') {} if (schema.enum) { return schema.enum.map((value, i) => { const label = (schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i]) || String(value); return { label, value }; }); } const altSchemas = schema.oneOf || schema.anyOf; return (altSchemas && altSchemas.map((aSchemaDef) => { const aSchema = aSchemaDef; const value = toConstant(aSchema); const label = aSchema.title || String(value); return { schema: aSchema, label, value, }; })); } //# sourceMappingURL=optionsList.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/orderProperties.js /** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly. * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per * the `order` list. If `order` contains a '*' then any `properties` that are not mentioned explicity in `order` will be * places in the location of the `*`. * * @param properties - The list of property keys to be ordered * @param order - An array of property keys to be ordered first, with an optional '*' property * @returns - A list with the `properties` ordered * @throws - Error when the properties cannot be ordered correctly */ function orderProperties(properties, order) { if (!Array.isArray(order)) { return properties; } const arrayToHash = (arr) => arr.reduce((prev, curr) => { prev[curr] = true; return prev; }, {}); const errorPropList = (arr) => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`; const propertyHash = arrayToHash(properties); const orderFiltered = order.filter((prop) => prop === '*' || propertyHash[prop]); const orderHash = arrayToHash(orderFiltered); const rest = properties.filter((prop) => !orderHash[prop]); const restIndex = orderFiltered.indexOf('*'); if (restIndex === -1) { if (rest.length) { throw new Error(`uiSchema order list does not contain ${errorPropList(rest)}`); } return orderFiltered; } if (restIndex !== orderFiltered.lastIndexOf('*')) { throw new Error('uiSchema order list contains more than one wildcard item'); } const complete = [...orderFiltered]; complete.splice(restIndex, 1, ...rest); return complete; } //# sourceMappingURL=orderProperties.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/pad.js /** Returns a string representation of the `num` that is padded with leading "0"s if necessary * * @param num - The number to pad * @param width - The width of the string at which no lead padding is necessary * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width` */ function pad(num, width) { let s = String(num); while (s.length < width) { s = '0' + s; } return s; } //# sourceMappingURL=pad.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/parseDateString.js /** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true * * @param dateString - The date string to parse into a DateObject * @param [includeTime=true] - Optional flag, if false, will not include the time data into the object * @returns - The date string converted to a `DateObject` * @throws - Error when the date cannot be parsed from the string */ function parseDateString(dateString, includeTime = true) { if (!dateString) { return { year: -1, month: -1, day: -1, hour: includeTime ? -1 : 0, minute: includeTime ? -1 : 0, second: includeTime ? -1 : 0, }; } const date = new Date(dateString); if (Number.isNaN(date.getTime())) { throw new Error('Unable to parse date ' + dateString); } return { year: date.getUTCFullYear(), month: date.getUTCMonth() + 1, day: date.getUTCDate(), hour: includeTime ? date.getUTCHours() : 0, minute: includeTime ? date.getUTCMinutes() : 0, second: includeTime ? date.getUTCSeconds() : 0, }; } //# sourceMappingURL=parseDateString.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/schemaRequiresTrueValue.js /** Check to see if a `schema` specifies that a value must be true. This happens when: * - `schema.const` is truthy * - `schema.enum` == `[true]` * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true * - `schema.allOf` has at least one value which recursively returns true * * @param schema - The schema to check * @returns - True if the schema specifies a value that must be true, false otherwise */ function schemaRequiresTrueValue(schema) { // Check if const is a truthy value if (schema.const) { return true; } // Check if an enum has a single value of true if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) { return true; } // If anyOf has a single value, evaluate the subschema if (schema.anyOf && schema.anyOf.length === 1) { return schemaRequiresTrueValue(schema.anyOf[0]); } // If oneOf has a single value, evaluate the subschema if (schema.oneOf && schema.oneOf.length === 1) { return schemaRequiresTrueValue(schema.oneOf[0]); } // Evaluate each subschema in allOf, to see if one of them requires a true value if (schema.allOf) { const schemaSome = (subSchema) => schemaRequiresTrueValue(subSchema); return schema.allOf.some(schemaSome); } return false; } //# sourceMappingURL=schemaRequiresTrueValue.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/shouldRender.js /** Determines whether the given `component` should be rerendered by comparing its current set of props and state * against the next set. If either of those two sets are not the same, then the component should be rerendered. * * @param component - A React component being checked * @param nextProps - The next set of props against which to check * @param nextState - The next set of state against which to check * @returns - True if the component should be re-rendered, false otherwise */ function shouldRender(component, nextProps, nextState) { const { props, state } = component; return !deepEquals(props, nextProps) || !deepEquals(state, nextState); } //# sourceMappingURL=shouldRender.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/toDateString.js /** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is * removed. * * @param dateObject - The `DateObject` to convert to a date string * @param [time=true] - Optional flag used to remove the time portion of the date string if false * @returns - The UTC date string */ function toDateString(dateObject, time = true) { const { year, month, day, hour = 0, minute = 0, second = 0 } = dateObject; const utcTime = Date.UTC(year, month - 1, day, hour, minute, second); const datetime = new Date(utcTime).toJSON(); return time ? datetime : datetime.slice(0, 10); } //# sourceMappingURL=toDateString.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/toErrorList.js /** Converts an `errorSchema` into a list of `RJSFValidationErrors` * * @param errorSchema - The `ErrorSchema` instance to convert * @param [fieldPath=[]] - The current field path, defaults to [] if not specified * @returns - The list of `RJSFValidationErrors` extracted from the `errorSchema` */ function toErrorList(errorSchema, fieldPath = []) { if (!errorSchema) { return []; } let errorList = []; if (ERRORS_KEY in errorSchema) { errorList = errorList.concat(errorSchema[ERRORS_KEY].map((message) => { const property = `.${fieldPath.join('.')}`; return { property, message, stack: `${property} ${message}`, }; })); } return Object.keys(errorSchema).reduce((acc, key) => { if (key !== ERRORS_KEY) { const childSchema = errorSchema[key]; if (isPlainObject_default()(childSchema)) { acc = acc.concat(toErrorList(childSchema, [...fieldPath, key])); } } return acc; }, errorList); } //# sourceMappingURL=toErrorList.js.map // EXTERNAL MODULE: ../node_modules/lodash/toPath.js var toPath = __webpack_require__(40110); var toPath_default = /*#__PURE__*/__webpack_require__.n(toPath); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/toErrorSchema.js /** Transforms a rjsf validation errors list: * [ * {property: '.level1.level2[2].level3', message: 'err a'}, * {property: '.level1.level2[2].level3', message: 'err b'}, * {property: '.level1.level2[4].level3', message: 'err b'}, * ] * Into an error tree: * { * level1: { * level2: { * 2: {level3: {errors: ['err a', 'err b']}}, * 4: {level3: {errors: ['err b']}}, * } * } * }; * * @param errors - The list of RJSFValidationError objects * @returns - The `ErrorSchema` built from the list of `RJSFValidationErrors` */ function toErrorSchema(errors) { const builder = new ErrorSchemaBuilder(); if (errors.length) { errors.forEach((error) => { const { property, message } = error; // When the property is the root element, just use an empty array for the path const path = property === '.' ? [] : toPath_default()(property); // If the property is at the root (.level1) then toPath creates // an empty array element at the first index. Remove it. if (path.length > 0 && path[0] === '') { path.splice(0, 1); } if (message) { builder.addErrors(message, path); } }); } return builder.ErrorSchema; } //# sourceMappingURL=toErrorSchema.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/unwrapErrorHandler.js /** Unwraps the `errorHandler` structure into the associated `ErrorSchema`, stripping the `addError()` functions from it * * @param errorHandler - The `FormValidation` error handling structure * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function */ function unwrapErrorHandler(errorHandler) { return Object.keys(errorHandler).reduce((acc, key) => { if (key === 'addError') { return acc; } else { const childSchema = errorHandler[key]; if (isPlainObject_default()(childSchema)) { return { ...acc, [key]: unwrapErrorHandler(childSchema), }; } return { ...acc, [key]: childSchema }; } }, {}); } //# sourceMappingURL=unwrapErrorHandler.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/utcToLocal.js /** Converts a UTC date string into a local Date format * * @param jsonDate - A UTC date string * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format */ function utcToLocal(jsonDate) { if (!jsonDate) { return ''; } // required format of `'yyyy-MM-ddThh:mm' followed by optional ':ss' or ':ss.SSS' // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type%3Ddatetime-local) // > should be a _valid local date and time string_ (not GMT) // Note - date constructor passed local ISO-8601 does not correctly // change time to UTC in node pre-8 const date = new Date(jsonDate); const yyyy = pad(date.getFullYear(), 4); const MM = pad(date.getMonth() + 1, 2); const dd = pad(date.getDate(), 2); const hh = pad(date.getHours(), 2); const mm = pad(date.getMinutes(), 2); const ss = pad(date.getSeconds(), 2); const SSS = pad(date.getMilliseconds(), 3); return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`; } //# sourceMappingURL=utcToLocal.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/validationDataMerge.js /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling * `toErrorList()` on the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then * `validationData` is returned. * * @param validationData - The current `ValidationData` into which to merge the additional errors * @param [additionalErrorSchema] - The optional additional set of errors in an `ErrorSchema` * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided. */ function validationDataMerge(validationData, additionalErrorSchema) { if (!additionalErrorSchema) { return validationData; } const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData; let errors = toErrorList(additionalErrorSchema); let errorSchema = additionalErrorSchema; if (!isEmpty_default()(oldErrorSchema)) { errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true); errors = [...oldErrors].concat(errors); } return { errorSchema, errors }; } //# sourceMappingURL=validationDataMerge.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/withIdRefPrefix.js /** Takes a `node` object and transforms any contained `$ref` node variables with a prefix, recursively calling * `withIdRefPrefix` for any other elements. * * @param node - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it */ function withIdRefPrefixObject(node) { for (const key in node) { const realObj = node; const value = realObj[key]; if (key === REF_KEY && typeof value === 'string' && value.startsWith('#')) { realObj[key] = ROOT_SCHEMA_PREFIX + value; } else { realObj[key] = withIdRefPrefix(value); } } return node; } /** Takes a `node` object list and transforms any contained `$ref` node variables with a prefix, recursively calling * `withIdRefPrefix` for any other elements. * * @param node - The list of object nodes to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it */ function withIdRefPrefixArray(node) { for (let i = 0; i < node.length; i++) { node[i] = withIdRefPrefix(node[i]); } return node; } /** Recursively prefixes all `$ref`s in a schema with the value of the `ROOT_SCHEMA_PREFIX` constant. * This is used in isValid to make references to the rootSchema * * @param schemaNode - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it * @returns - A copy of the `schemaNode` with updated `$ref`s */ function withIdRefPrefix(schemaNode) { if (Array.isArray(schemaNode)) { return withIdRefPrefixArray([...schemaNode]); } if (isObject_default()(schemaNode)) { return withIdRefPrefixObject({ ...schemaNode }); } return schemaNode; } //# sourceMappingURL=withIdRefPrefix.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/enums.js /** An enumeration of all the translatable strings used by `@rjsf/core` and its themes. The value of each of the * enumeration keys is expected to be the actual english string. Some strings contain replaceable parameter values * as indicated by `%1`, `%2`, etc. The number after the `%` indicates the order of the parameter. The ordering of * parameters is important because some languages may choose to put the second parameter before the first in its * translation. Also, some strings are rendered using `markdown-to-jsx` and thus support markdown and inline html. */ var TranslatableString; (function (TranslatableString) { /** Fallback title of an array item, used by ArrayField */ TranslatableString["ArrayItemTitle"] = "Item"; /** Missing items reason, used by ArrayField */ TranslatableString["MissingItems"] = "Missing items definition"; /** Yes label, used by BooleanField */ TranslatableString["YesLabel"] = "Yes"; /** No label, used by BooleanField */ TranslatableString["NoLabel"] = "No"; /** Close label, used by ErrorList */ TranslatableString["CloseLabel"] = "Close"; /** Errors label, used by ErrorList */ TranslatableString["ErrorsLabel"] = "Errors"; /** New additionalProperties string default value, used by ObjectField */ TranslatableString["NewStringDefault"] = "New Value"; /** Add button title, used by AddButton */ TranslatableString["AddButton"] = "Add"; /** Add button title, used by AddButton */ TranslatableString["AddItemButton"] = "Add Item"; /** Copy button title, used by IconButton */ TranslatableString["CopyButton"] = "Copy"; /** Move down button title, used by IconButton */ TranslatableString["MoveDownButton"] = "Move down"; /** Move up button title, used by IconButton */ TranslatableString["MoveUpButton"] = "Move up"; /** Remove button title, used by IconButton */ TranslatableString["RemoveButton"] = "Remove"; /** Now label, used by AltDateWidget */ TranslatableString["NowLabel"] = "Now"; /** Clear label, used by AltDateWidget */ TranslatableString["ClearLabel"] = "Clear"; /** Aria date label, used by DateWidget */ TranslatableString["AriaDateLabel"] = "Select a date"; /** File preview label, used by FileWidget */ TranslatableString["PreviewLabel"] = "Preview"; /** Decrement button aria label, used by UpDownWidget */ TranslatableString["DecrementAriaLabel"] = "Decrease value by 1"; /** Increment button aria label, used by UpDownWidget */ TranslatableString["IncrementAriaLabel"] = "Increase value by 1"; // Strings with replaceable parameters /** Unknown field type reason, where %1 will be replaced with the type as provided by SchemaField */ TranslatableString["UnknownFieldType"] = "Unknown field type %1"; /** Option prefix, where %1 will be replaced with the option index as provided by MultiSchemaField */ TranslatableString["OptionPrefix"] = "Option %1"; /** Option prefix, where %1 and %2 will be replaced by the schema title and option index, respectively as provided by * MultiSchemaField */ TranslatableString["TitleOptionPrefix"] = "%1 option %2"; /** Key label, where %1 will be replaced by the label as provided by WrapIfAdditionalTemplate */ TranslatableString["KeyLabel"] = "%1 Key"; // Strings with replaceable parameters AND/OR that support markdown and html /** Invalid object field configuration as provided by the ObjectField */ TranslatableString["InvalidObjectField"] = "Invalid \"%1\" object field configuration: %2."; /** Unsupported field schema, used by UnsupportedField */ TranslatableString["UnsupportedField"] = "Unsupported field schema."; /** Unsupported field schema, where %1 will be replaced by the idSchema.$id as provided by UnsupportedField */ TranslatableString["UnsupportedFieldWithId"] = "Unsupported field schema for field %1."; /** Unsupported field schema, where %1 will be replaced by the reason string as provided by UnsupportedField */ TranslatableString["UnsupportedFieldWithReason"] = "Unsupported field schema: %1."; /** Unsupported field schema, where %1 and %2 will be replaced by the idSchema.$id and reason strings, respectively, * as provided by UnsupportedField */ TranslatableString["UnsupportedFieldWithIdAndReason"] = "Unsupported field schema for field %1: %2."; /** File name, type and size info, where %1, %2 and %3 will be replaced by the file name, file type and file size as * provided by FileWidget */ TranslatableString["FilesInfo"] = "%1 (%2, %3 bytes)"; })(TranslatableString || (TranslatableString = {})); //# sourceMappingURL=enums.js.map // EXTERNAL MODULE: ../node_modules/lodash/forEach.js var forEach = __webpack_require__(47003); var forEach_default = /*#__PURE__*/__webpack_require__.n(forEach); ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/parser/ParserValidator.js /** An implementation of the `ValidatorType` interface that is designed for use in capturing schemas used by the * `isValid()` function. The rest of the implementation of the interface throws errors when it is attempted to be used. * An instance of the object allows the caller to capture the schemas used in calls to the `isValid()` function. These * captured schema, along with the root schema used to construct the object are stored in the map of schemas keyed by * the hashed value of the schema. NOTE: After hashing the schema, an $id with the hash value is added to the * schema IF that schema doesn't already have an $id, prior to putting the schema into the map. */ class ParserValidator { /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap` * first. * * @param rootSchema - The root schema against which this validator will be executed */ constructor(rootSchema) { /** The map of schemas encountered by the ParserValidator */ this.schemaMap = {}; this.rootSchema = rootSchema; this.addSchema(rootSchema, hashForSchema(rootSchema)); } /** Adds the given `schema` to the `schemaMap` keyed by the `hash` or `ID_KEY` if present on the `schema`. If the * schema does not have an `ID_KEY`, then the `hash` will be added as the `ID_KEY` to allow the schema to be * associated with it's `hash` for future use (by a schema compiler). * * @param schema - The schema which is to be added to the map * @param hash - The hash value at which to map the schema */ addSchema(schema, hash) { const key = get_default()(schema, ID_KEY, hash); const identifiedSchema = { ...schema, [ID_KEY]: key }; const existing = this.schemaMap[key]; if (!existing) { this.schemaMap[key] = identifiedSchema; } else if (!isEqual_default()(existing, identifiedSchema)) { console.error('existing schema:', JSON.stringify(existing, null, 2)); console.error('new schema:', JSON.stringify(identifiedSchema, null, 2)); throw new Error(`Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`); } } /** Returns the current `schemaMap` to the caller */ getSchemaMap() { return this.schemaMap; } /** Implements the `ValidatorType` `isValid()` method to capture the `schema` in the `schemaMap`. Throws an error when * the `rootSchema` is not the same as the root schema provided during construction. * * @param schema - The schema to record in the `schemaMap` * @param _formData - The formData parameter that is ignored * @param rootSchema - The root schema associated with the schema * @throws - Error when the given `rootSchema` differs from the root schema provided during construction */ isValid(schema, _formData, rootSchema) { if (!isEqual_default()(rootSchema, this.rootSchema)) { throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema'); } this.addSchema(schema, hashForSchema(schema)); return false; } /** Implements the `ValidatorType` `rawValidation()` method to throw an error since it is never supposed to be called * * @param _schema - The schema parameter that is ignored * @param _formData - The formData parameter that is ignored */ rawValidation(_schema, _formData) { throw new Error('Unexpectedly calling the `rawValidation()` method during schema parsing'); } /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called * * @param _errorSchema - The error schema parameter that is ignored * @param _fieldPath - The field path parameter that is ignored */ toErrorList(_errorSchema, _fieldPath) { throw new Error('Unexpectedly calling the `toErrorList()` method during schema parsing'); } /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be * called * * @param _formData - The formData parameter that is ignored * @param _schema - The schema parameter that is ignored * @param _customValidate - The customValidate parameter that is ignored * @param _transformErrors - The transformErrors parameter that is ignored * @param _uiSchema - The uiSchema parameter that is ignored */ validateFormData(_formData, _schema, _customValidate, _transformErrors, _uiSchema) { throw new Error('Unexpectedly calling the `validateFormData()` method during schema parsing'); } } //# sourceMappingURL=ParserValidator.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/parser/schemaParser.js /** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the * `retrieveSchemaInternal()`, the `resolveAnyOrOneOfSchemas()` function is called. For each of the schemas returned * from THAT call have `properties`, then each of the sub-schema property objects are then recursively parsed. * * @param validator - The `ParserValidator` implementation used to capture `isValid()` calls during parsing * @param recurseList - The list of schemas returned from the `retrieveSchemaInternal`, preventing infinite recursion * @param rootSchema - The root schema from which the schema parsing began * @param schema - The current schema element being parsed */ function parseSchema(validator, recurseList, rootSchema, schema) { const schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true); schemas.forEach((schema) => { const sameSchemaIndex = recurseList.findIndex((item) => isEqual_default()(item, schema)); if (sameSchemaIndex === -1) { recurseList.push(schema); const allOptions = resolveAnyOrOneOfSchemas(validator, schema, rootSchema, true); allOptions.forEach((s) => { if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) { forEach_default()(schema[PROPERTIES_KEY], (value) => { parseSchema(validator, recurseList, rootSchema, value); }); } }); if (ITEMS_KEY in schema && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') { parseSchema(validator, recurseList, rootSchema, schema.items); } } }); } /** Parses the given `rootSchema` to extract out all the sub-schemas that maybe contained within it. Returns a map of * the hash of the schema to schema/sub-schema. * * @param rootSchema - The root schema to parse for sub-schemas used by `isValid()` calls * @returns - The `SchemaMap` of all schemas that were parsed */ function schemaParser(rootSchema) { const validator = new ParserValidator(rootSchema); const recurseList = []; parseSchema(validator, recurseList, rootSchema, rootSchema); return validator.getSchemaMap(); } //# sourceMappingURL=schemaParser.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/parser/index.js //# sourceMappingURL=index.js.map ;// CONCATENATED MODULE: ../node_modules/@rjsf/utils/lib/index.js //# sourceMappingURL=index.js.map /***/ }), /***/ 15422: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { "use strict"; // MODULES // var isArray = __webpack_require__( 17604 ), isIntegerArray = __webpack_require__( 9333 ), isFunction = __webpack_require__( 86401 ); // VARIABLES // var MAXINT = Math.pow( 2, 31 ) - 1; // FUNCTIONS // /** * FUNCTION: gcd( a, b ) * Computes the greatest common divisor of two integers `a` and `b`, using the binary GCD algorithm. * * @param {Number} a - integer * @param {Number} b - integer * @returns {Number} greatest common divisor */ function gcd( a, b ) { var k = 1, t; // Simple cases: if ( a === 0 ) { return b; } if ( b === 0 ) { return a; } // Reduce `a` and/or `b` to odd numbers and keep track of the greatest power of 2 dividing both `a` and `b`... while ( a%2 === 0 && b%2 === 0 ) { a = a / 2; // right shift b = b / 2; // right shift k = k * 2; // left shift } // Reduce `a` to an odd number... while ( a%2 === 0 ) { a = a / 2; // right shift } // Henceforth, `a` is always odd... while ( b ) { // Remove all factors of 2 in `b`, as they are not common... while ( b%2 === 0 ) { b = b / 2; // right shift } // `a` and `b` are both odd. Swap values such that `b` is the larger of the two values, and then set `b` to the difference (which is even)... if ( a > b ) { t = b; b = a; a = t; } b = b - a; // b=0 iff b=a } // Restore common factors of 2... return k * a; } // end FUNCTION gcd() /** * FUNCTION: bitwise( a, b ) * Computes the greatest common divisor of two integers `a` and `b`, using the binary GCD algorithm and bitwise operations. * * @param {Number} a - safe integer * @param {Number} b - safe integer * @returns {Number} greatest common divisor */ function bitwise( a, b ) { var k = 0, t; // Simple cases: if ( a === 0 ) { return b; } if ( b === 0 ) { return a; } // Reduce `a` and/or `b` to odd numbers and keep track of the greatest power of 2 dividing both `a` and `b`... while ( (a & 1) === 0 && (b & 1) === 0 ) { a >>>= 1; // right shift b >>>= 1; // right shift k++; } // Reduce `a` to an odd number... while ( (a & 1) === 0 ) { a >>>= 1; // right shift } // Henceforth, `a` is always odd... while ( b ) { // Remove all factors of 2 in `b`, as they are not common... while ( (b & 1) === 0 ) { b >>>= 1; // right shift } // `a` and `b` are both odd. Swap values such that `b` is the larger of the two values, and then set `b` to the difference (which is even)... if ( a > b ) { t = b; b = a; a = t; } b = b - a; // b=0 iff b=a } // Restore common factors of 2... return a << k; } // end FUNCTION bitwise() // GREATEST COMMON DIVISOR // /** * FUNCTION: compute( arr[, clbk] ) * Computes the greatest common divisor. * * @param {Number[]|Number} arr - input array of integers * @param {Function|Number} [clbk] - accessor function for accessing array values * @returns {Number|Null} greatest common divisor or null */ function compute() { var nargs = arguments.length, args, clbk, arr, len, a, b, i; // Copy the input arguments to an array... args = new Array( nargs ); for ( i = 0; i < nargs; i++ ) { args[ i ] = arguments[ i ]; } // Have we been provided with integer arguments? if ( isIntegerArray( args ) ) { if ( nargs === 2 ) { a = args[ 0 ]; b = args[ 1 ]; if ( a < 0 ) { a = -a; } if ( b < 0 ) { b = -b; } if ( a <= MAXINT && b <= MAXINT ) { return bitwise( a, b ); } else { return gcd( a, b ); } } arr = args; } // If not integers, ensure the first argument is an array... else if ( !isArray( args[ 0 ] ) ) { throw new TypeError( 'gcd()::invalid input argument. Must provide an array of integers. Value: `' + args[ 0 ] + '`.' ); } // Have we been provided with more than one argument? If so, ensure that the accessor argument is a function... else if ( nargs > 1 ) { arr = args[ 0 ]; clbk = args[ 1 ]; if ( !isFunction( clbk ) ) { throw new TypeError( 'gcd()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' ); } } // We have been provided an array... else { arr = args[ 0 ]; } len = arr.length; // Check if a sufficient number of values have been provided... if ( len < 2 ) { return null; } // If an accessor is provided, extract the array values... if ( clbk ) { a = new Array( len ); for ( i = 0; i < len; i++ ) { a[ i ] = clbk( arr[ i ], i ); } arr = a; } // Given an input array, ensure all array values are integers... if ( nargs < 3 ) { if ( !isIntegerArray( arr ) ) { throw new TypeError( 'gcd()::invalid input argument. Accessed array values must be integers. Value: `' + arr + '`.' ); } } // Convert any negative integers to positive integers... for ( i = 0; i < len; i++ ) { a = arr[ i ]; if ( a < 0 ) { arr[ i ] = -a; } } // Exploit the fact that the gcd is an associative function... a = arr[ 0 ]; for ( i = 1; i < len; i++ ) { b = arr[ i ]; if ( b <= MAXINT && a <= MAXINT ) { a = bitwise( a, b ); } else { a = gcd( a, b ); } } return a; } // end FUNCTION compute() // EXPORTS // module.exports = compute; /***/ }), /***/ 72982: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { "use strict"; // MODULES // var gcd = __webpack_require__( 15422 ), isArray = __webpack_require__( 17604 ), isIntegerArray = __webpack_require__( 9333 ), isFunction = __webpack_require__( 86401 ); // LEAST COMMON MULTIPLE // /** * FUNCTION: lcm( arr[, clbk] ) * Computes the least common multiple (lcm). * * @param {Number[]|Number} arr - input array of integers * @param {Function|Number} [accessor] - accessor function for accessing array values * @returns {Number|Null} least common multiple or null */ function lcm() { var nargs = arguments.length, args, clbk, arr, len, a, b, i; // Copy the input arguments to an array... args = new Array( nargs ); for ( i = 0; i < nargs; i++ ) { args[ i ] = arguments[ i ]; } // Have we been provided with integer arguments? if ( isIntegerArray( args ) ) { if ( nargs === 2 ) { a = args[ 0 ]; b = args[ 1 ]; if ( a < 0 ) { a = -a; } if ( b < 0 ) { b = -b; } if ( a === 0 || b === 0 ) { return 0; } return ( a/gcd(a,b) ) * b; } arr = args; } // If not integers, ensure that the first argument is an array... else if ( !isArray( args[ 0 ] ) ) { throw new TypeError( 'lcm()::invalid input argument. Must provide an array of integers. Value: `' + args[ 0 ] + '`.' ); } // Have we been provided with more than one argument? If so, ensure that the accessor argument is a function... else if ( nargs > 1 ) { arr = args[ 0 ]; clbk = args[ 1 ]; if ( !isFunction( clbk ) ) { throw new TypeError( 'lcm()::invalid input argument. Accessor must be a function. Value: `' + clbk + '`.' ); } } // We have been provided an array... else { arr = args[ 0 ]; } len = arr.length; // Check if a sufficient number of values have been provided... if ( len < 2 ) { return null; } // If an accessor is provided, extract the array values... if ( clbk ) { a = new Array( len ); for ( i = 0; i < len; i++ ) { a[ i ] = clbk( arr[ i ], i ); } arr = a; } // Given an input array, ensure all array values are integers... if ( nargs < 3 ) { if ( !isIntegerArray( arr ) ) { throw new TypeError( 'lcm()::invalid input argument. Accessed array values must be integers. Value: `' + arr + '`.' ); } } // Convert any negative integers to positive integers... for ( i = 0; i < len; i++ ) { a = arr[ i ]; if ( a < 0 ) { arr[ i ] = -a; } } // Exploit the fact that the lcm is an associative function... a = arr[ 0 ]; for ( i = 1; i < len; i++ ) { b = arr[ i ]; if ( a === 0 || b === 0 ) { return 0; } a = ( a/gcd(a,b) ) * b; } return a; } // end FUNCTION lcm() // EXPORTS // module.exports = lcm; /***/ }), /***/ 64316: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isEqual = __webpack_require__(56141) var sortBy = __webpack_require__(95099) var uniq = __webpack_require__(83766) var uniqWith = __webpack_require__(52929) var defaults = __webpack_require__(70236) var intersectionWith = __webpack_require__(28054) var isPlainObject = __webpack_require__(40861) var isBoolean = __webpack_require__(3819) var normalizeArray = val => Array.isArray(val) ? val : [val] var undef = val => val === undefined var keys = obj => isPlainObject(obj) || Array.isArray(obj) ? Object.keys(obj) : [] var has = (obj, key) => obj.hasOwnProperty(key) var stringArray = arr => sortBy(uniq(arr)) var undefEmpty = val => undef(val) || (Array.isArray(val) && val.length === 0) var keyValEqual = (a, b, key, compare) => b && has(b, key) && a && has(a, key) && compare(a[key], b[key]) var undefAndZero = (a, b) => (undef(a) && b === 0) || (undef(b) && a === 0) || isEqual(a, b) var falseUndefined = (a, b) => (undef(a) && b === false) || (undef(b) && a === false) || isEqual(a, b) var emptySchema = schema => undef(schema) || isEqual(schema, {}) || schema === true var emptyObjUndef = schema => undef(schema) || isEqual(schema, {}) var isSchema = val => undef(val) || isPlainObject(val) || val === true || val === false function undefArrayEqual(a, b) { if (undefEmpty(a) && undefEmpty(b)) { return true } else { return isEqual(stringArray(a), stringArray(b)) } } function unsortedNormalizedArray(a, b) { a = normalizeArray(a) b = normalizeArray(b) return isEqual(stringArray(a), stringArray(b)) } function schemaGroup(a, b, key, compare) { var allProps = uniq(keys(a).concat(keys(b))) if (emptyObjUndef(a) && emptyObjUndef(b)) { return true } else if (emptyObjUndef(a) && keys(b).length) { return false } else if (emptyObjUndef(b) && keys(a).length) { return false } return allProps.every(function(key) { var aVal = a[key] var bVal = b[key] if (Array.isArray(aVal) && Array.isArray(bVal)) { return isEqual(stringArray(a), stringArray(b)) } else if (Array.isArray(aVal) && !Array.isArray(bVal)) { return false } else if (Array.isArray(bVal) && !Array.isArray(aVal)) { return false } return keyValEqual(a, b, key, compare) }) } function items(a, b, key, compare) { if (isPlainObject(a) && isPlainObject(b)) { return compare(a, b) } else if (Array.isArray(a) && Array.isArray(b)) { return schemaGroup(a, b, key, compare) } else { return isEqual(a, b) } } function unsortedArray(a, b, key, compare) { var uniqueA = uniqWith(a, compare) var uniqueB = uniqWith(b, compare) var inter = intersectionWith(uniqueA, uniqueB, compare) return inter.length === Math.max(uniqueA.length, uniqueB.length) } var comparers = { title: isEqual, uniqueItems: falseUndefined, minLength: undefAndZero, minItems: undefAndZero, minProperties: undefAndZero, required: undefArrayEqual, enum: undefArrayEqual, type: unsortedNormalizedArray, items: items, anyOf: unsortedArray, allOf: unsortedArray, oneOf: unsortedArray, properties: schemaGroup, patternProperties: schemaGroup, dependencies: schemaGroup } var acceptsUndefined = [ 'properties', 'patternProperties', 'dependencies', 'uniqueItems', 'minLength', 'minItems', 'minProperties', 'required' ] var schemaProps = ['additionalProperties', 'additionalItems', 'contains', 'propertyNames', 'not'] function compare(a, b, options) { options = defaults(options, { ignore: [] }) if (emptySchema(a) && emptySchema(b)) { return true } if (!isSchema(a) || !isSchema(b)) { throw new Error('Either of the values are not a JSON schema.') } if (a === b) { return true } if (isBoolean(a) && isBoolean(b)) { return a === b } if ((a === undefined && b === false) || (b === undefined && a === false)) { return false } if ((undef(a) && !undef(b)) || (!undef(a) && undef(b))) { return false } var allKeys = uniq(Object.keys(a).concat(Object.keys(b))) if (options.ignore.length) { allKeys = allKeys.filter(k => options.ignore.indexOf(k) === -1) } if (!allKeys.length) { return true } function innerCompare(a, b) { return compare(a, b, options) } return allKeys.every(function(key) { var aValue = a[key] var bValue = b[key] if (schemaProps.indexOf(key) !== -1) { return compare(aValue, bValue, options) } var comparer = comparers[key] if (!comparer) { comparer = isEqual } // do simple lodash check first if (isEqual(aValue, bValue)) { return true } if (acceptsUndefined.indexOf(key) === -1) { if ((!has(a, key) && has(b, key)) || (has(a, key) && !has(b, key))) { return aValue === bValue } } var result = comparer(aValue, bValue, key, innerCompare) if (!isBoolean(result)) { throw new Error('Comparer must return true or false') } return result }) } module.exports = compare /***/ }), /***/ 2143: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { const flatten = __webpack_require__(89754) const flattenDeep = __webpack_require__(84812) const isPlainObject = __webpack_require__(40861) const uniq = __webpack_require__(83766) const uniqWith = __webpack_require__(52929) const without = __webpack_require__(81889) function deleteUndefinedProps(returnObject) { // cleanup empty for (const prop in returnObject) { if (has(returnObject, prop) && isEmptySchema(returnObject[prop])) { delete returnObject[prop] } } return returnObject } const allUniqueKeys = (arr) => uniq(flattenDeep(arr.map(keys))) const getValues = (schemas, key) => schemas.map(schema => schema && schema[key]) const has = (obj, propName) => Object.prototype.hasOwnProperty.call(obj, propName) const keys = obj => { if (isPlainObject(obj) || Array.isArray(obj)) { return Object.keys(obj) } else { return [] } } const notUndefined = (val) => val !== undefined const isSchema = (val) => isPlainObject(val) || val === true || val === false const isEmptySchema = (obj) => (!keys(obj).length) && obj !== false && obj !== true const withoutArr = (arr, ...rest) => without.apply(null, [arr].concat(flatten(rest))) module.exports = { allUniqueKeys, deleteUndefinedProps, getValues, has, isEmptySchema, isSchema, keys, notUndefined, uniqWith, withoutArr } /***/ }), /***/ 71020: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { const compare = __webpack_require__(64316) const forEach = __webpack_require__(47003) const { allUniqueKeys, deleteUndefinedProps, has, isSchema, notUndefined, uniqWith } = __webpack_require__(2143) function removeFalseSchemasFromArray(target) { forEach(target, function(schema, index) { if (schema === false) { target.splice(index, 1) } }) } function getItemSchemas(subSchemas, key) { return subSchemas.map(function(sub) { if (!sub) { return undefined } if (Array.isArray(sub.items)) { const schemaAtPos = sub.items[key] if (isSchema(schemaAtPos)) { return schemaAtPos } else if (has(sub, 'additionalItems')) { return sub.additionalItems } } else { return sub.items } return undefined }) } function getAdditionalSchemas(subSchemas) { return subSchemas.map(function(sub) { if (!sub) { return undefined } if (Array.isArray(sub.items)) { return sub.additionalItems } return sub.items }) } // Provide source when array function mergeItems(group, mergeSchemas, items) { const allKeys = allUniqueKeys(items) return allKeys.reduce(function(all, key) { const schemas = getItemSchemas(group, key) const compacted = uniqWith(schemas.filter(notUndefined), compare) all[key] = mergeSchemas(compacted, key) return all }, []) } module.exports = { keywords: ['items', 'additionalItems'], resolver(values, parents, mergers) { // const createSubMerger = groupKey => (schemas, key) => mergeSchemas(schemas, parents.concat(groupKey, key)) const items = values.map(s => s.items) const itemsCompacted = items.filter(notUndefined) const returnObject = {} // if all items keyword values are schemas, we can merge them as simple schemas // if not we need to merge them as mixed if (itemsCompacted.every(isSchema)) { returnObject.items = mergers.items(items) } else { returnObject.items = mergeItems(values, mergers.items, items) } let schemasAtLastPos if (itemsCompacted.every(Array.isArray)) { schemasAtLastPos = values.map(s => s.additionalItems) } else if (itemsCompacted.some(Array.isArray)) { schemasAtLastPos = getAdditionalSchemas(values) } if (schemasAtLastPos) { returnObject.additionalItems = mergers.additionalItems(schemasAtLastPos) } if (returnObject.additionalItems === false && Array.isArray(returnObject.items)) { removeFalseSchemasFromArray(returnObject.items) } return deleteUndefinedProps(returnObject) } } /***/ }), /***/ 88807: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { const compare = __webpack_require__(64316) const forEach = __webpack_require__(47003) const { allUniqueKeys, deleteUndefinedProps, getValues, keys, notUndefined, uniqWith, withoutArr } = __webpack_require__(2143) function removeFalseSchemas(target) { forEach(target, function(schema, prop) { if (schema === false) { delete target[prop] } }) } function mergeSchemaGroup(group, mergeSchemas) { const allKeys = allUniqueKeys(group) return allKeys.reduce(function(all, key) { const schemas = getValues(group, key) const compacted = uniqWith(schemas.filter(notUndefined), compare) all[key] = mergeSchemas(compacted, key) return all }, {}) } module.exports = { keywords: ['properties', 'patternProperties', 'additionalProperties'], resolver(values, parents, mergers, options) { // first get rid of all non permitted properties if (!options.ignoreAdditionalProperties) { values.forEach(function(subSchema) { const otherSubSchemas = values.filter(s => s !== subSchema) const ownKeys = keys(subSchema.properties) const ownPatternKeys = keys(subSchema.patternProperties) const ownPatterns = ownPatternKeys.map(k => new RegExp(k)) otherSubSchemas.forEach(function(other) { const allOtherKeys = keys(other.properties) const keysMatchingPattern = allOtherKeys.filter(k => ownPatterns.some(pk => pk.test(k))) const additionalKeys = withoutArr(allOtherKeys, ownKeys, keysMatchingPattern) additionalKeys.forEach(function(key) { other.properties[key] = mergers.properties([ other.properties[key], subSchema.additionalProperties ], key) }) }) }) // remove disallowed patternProperties values.forEach(function(subSchema) { const otherSubSchemas = values.filter(s => s !== subSchema) const ownPatternKeys = keys(subSchema.patternProperties) if (subSchema.additionalProperties === false) { otherSubSchemas.forEach(function(other) { const allOtherPatterns = keys(other.patternProperties) const additionalPatternKeys = withoutArr(allOtherPatterns, ownPatternKeys) additionalPatternKeys.forEach(key => delete other.patternProperties[key]) }) } }) } const returnObject = { additionalProperties: mergers.additionalProperties(values.map(s => s.additionalProperties)), patternProperties: mergeSchemaGroup(values.map(s => s.patternProperties), mergers.patternProperties), properties: mergeSchemaGroup(values.map(s => s.properties), mergers.properties) } if (returnObject.additionalProperties === false) { removeFalseSchemas(returnObject.properties) } return deleteUndefinedProps(returnObject) } } /***/ }), /***/ 64717: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { const cloneDeep = __webpack_require__(30454) const compare = __webpack_require__(64316) const computeLcm = __webpack_require__(72982) const defaultsDeep = __webpack_require__(53533) const flatten = __webpack_require__(89754) const flattenDeep = __webpack_require__(84812) const intersection = __webpack_require__(27921) const intersectionWith = __webpack_require__(28054) const isEqual = __webpack_require__(56141) const isPlainObject = __webpack_require__(40861) const pullAll = __webpack_require__(90254) const sortBy = __webpack_require__(95099) const uniq = __webpack_require__(83766) const uniqWith = __webpack_require__(52929) const propertiesResolver = __webpack_require__(88807) const itemsResolver = __webpack_require__(71020) const contains = (arr, val) => arr.indexOf(val) !== -1 const isSchema = (val) => isPlainObject(val) || val === true || val === false const isFalse = (val) => val === false const isTrue = (val) => val === true const schemaResolver = (compacted, key, mergeSchemas) => mergeSchemas(compacted) const stringArray = (values) => sortBy(uniq(flattenDeep(values))) const notUndefined = (val) => val !== undefined const allUniqueKeys = (arr) => uniq(flattenDeep(arr.map(keys))) // resolvers const first = compacted => compacted[0] const required = compacted => stringArray(compacted) const maximumValue = compacted => Math.max.apply(Math, compacted) const minimumValue = compacted => Math.min.apply(Math, compacted) const uniqueItems = compacted => compacted.some(isTrue) const examples = compacted => uniqWith(flatten(compacted), isEqual) function compareProp(key) { return function(a, b) { return compare({ [key]: a }, { [key]: b }) } } function getAllOf(schema) { let { allOf = [], ...copy } = schema copy = isPlainObject(schema) ? copy : schema // if schema is boolean return [copy, ...allOf.map(getAllOf)] } function getValues(schemas, key) { return schemas.map(schema => schema && schema[key]) } function tryMergeSchemaGroups(schemaGroups, mergeSchemas) { return schemaGroups.map(function(schemas, index) { try { return mergeSchemas(schemas, index) } catch (e) { return undefined } }).filter(notUndefined) } function keys(obj) { if (isPlainObject(obj) || Array.isArray(obj)) { return Object.keys(obj) } else { return [] } } function getAnyOfCombinations(arrOfArrays, combinations) { combinations = combinations || [] if (!arrOfArrays.length) { return combinations } const values = arrOfArrays.slice(0).shift() const rest = arrOfArrays.slice(1) if (combinations.length) { return getAnyOfCombinations(rest, flatten(combinations.map(combination => values.map(item => ([item].concat(combination)))))) } return getAnyOfCombinations(rest, values.map(item => (item))) } function throwIncompatible(values, paths) { let asJSON try { asJSON = values.map(function(val) { return JSON.stringify(val, null, 2) }).join('\n') } catch (variable) { asJSON = values.join(', ') } throw new Error('Could not resolve values for path:"' + paths.join('.') + '". They are probably incompatible. Values: \n' + asJSON) } function callGroupResolver(complexKeywords, resolverName, schemas, mergeSchemas, options, parents) { if (complexKeywords.length) { const resolverConfig = options.complexResolvers[resolverName] if (!resolverConfig || !resolverConfig.resolver) { throw new Error('No resolver found for ' + resolverName) } // extract all keywords from all the schemas that have one or more // then remove all undefined ones and not unique const extractedKeywordsOnly = schemas.map(schema => complexKeywords.reduce((all, key) => { if (schema[key] !== undefined) all[key] = schema[key] return all }, {})) const unique = uniqWith(extractedKeywordsOnly, compare) // create mergers that automatically add the path of the keyword for use in the complex resolver const mergers = resolverConfig.keywords.reduce((all, key) => ({ ...all, [key]: (schemas, extraKey = []) => mergeSchemas(schemas, null, parents.concat(key, extraKey)) }), {}) const result = resolverConfig.resolver(unique, parents.concat(resolverName), mergers, options) if (!isPlainObject(result)) { throwIncompatible(unique, parents.concat(resolverName)) } return result } } function createRequiredMetaArray(arr) { return { required: arr } } const schemaGroupProps = ['properties', 'patternProperties', 'definitions', 'dependencies'] const schemaArrays = ['anyOf', 'oneOf'] const schemaProps = [ 'additionalProperties', 'additionalItems', 'contains', 'propertyNames', 'not', 'items' ] const defaultResolvers = { type(compacted) { if (compacted.some(Array.isArray)) { const normalized = compacted.map(function(val) { return Array.isArray(val) ? val : [val] }) const common = intersection.apply(null, normalized) if (common.length === 1) { return common[0] } else if (common.length > 1) { return uniq(common) } } }, dependencies(compacted, paths, mergeSchemas) { const allChildren = allUniqueKeys(compacted) return allChildren.reduce(function(all, childKey) { const childSchemas = getValues(compacted, childKey) let innerCompacted = uniqWith(childSchemas.filter(notUndefined), isEqual) // to support dependencies const innerArrays = innerCompacted.filter(Array.isArray) if (innerArrays.length) { if (innerArrays.length === innerCompacted.length) { all[childKey] = stringArray(innerCompacted) } else { const innerSchemas = innerCompacted.filter(isSchema) const arrayMetaScheams = innerArrays.map(createRequiredMetaArray) all[childKey] = mergeSchemas(innerSchemas.concat(arrayMetaScheams), childKey) } return all } innerCompacted = uniqWith(innerCompacted, compare) all[childKey] = mergeSchemas(innerCompacted, childKey) return all }, {}) }, oneOf(compacted, paths, mergeSchemas) { const combinations = getAnyOfCombinations(cloneDeep(compacted)) const result = tryMergeSchemaGroups(combinations, mergeSchemas) const unique = uniqWith(result, compare) if (unique.length) { return unique } }, not(compacted) { return { anyOf: compacted } }, pattern(compacted) { return compacted.map(r => '(?=' + r + ')').join('') }, multipleOf(compacted) { let integers = compacted.slice(0) let factor = 1 while (integers.some(n => !Number.isInteger(n))) { integers = integers.map(n => n * 10) factor = factor * 10 } return computeLcm(integers) / factor }, enum(compacted) { const enums = intersectionWith.apply(null, compacted.concat(isEqual)) if (enums.length) { return sortBy(enums) } } } defaultResolvers.$id = first defaultResolvers.$ref = first defaultResolvers.$schema = first defaultResolvers.additionalItems = schemaResolver defaultResolvers.additionalProperties = schemaResolver defaultResolvers.anyOf = defaultResolvers.oneOf defaultResolvers.contains = schemaResolver defaultResolvers.default = first defaultResolvers.definitions = defaultResolvers.dependencies defaultResolvers.description = first defaultResolvers.examples = examples defaultResolvers.exclusiveMaximum = minimumValue defaultResolvers.exclusiveMinimum = maximumValue defaultResolvers.items = itemsResolver defaultResolvers.maximum = minimumValue defaultResolvers.maxItems = minimumValue defaultResolvers.maxLength = minimumValue defaultResolvers.maxProperties = minimumValue defaultResolvers.minimum = maximumValue defaultResolvers.minItems = maximumValue defaultResolvers.minLength = maximumValue defaultResolvers.minProperties = maximumValue defaultResolvers.properties = propertiesResolver defaultResolvers.propertyNames = schemaResolver defaultResolvers.required = required defaultResolvers.title = first defaultResolvers.uniqueItems = uniqueItems const defaultComplexResolvers = { properties: propertiesResolver, items: itemsResolver } function merger(rootSchema, options, totalSchemas) { totalSchemas = totalSchemas || [] options = defaultsDeep(options, { ignoreAdditionalProperties: false, resolvers: defaultResolvers, complexResolvers: defaultComplexResolvers, deep: true }) const complexResolvers = Object.entries(options.complexResolvers) function mergeSchemas(schemas, base, parents) { schemas = cloneDeep(schemas.filter(notUndefined)) parents = parents || [] const merged = isPlainObject(base) ? base : {} // return undefined, an empty schema if (!schemas.length) { return } if (schemas.some(isFalse)) { return false } if (schemas.every(isTrue)) { return true } // there are no false and we don't need the true ones as they accept everything schemas = schemas.filter(isPlainObject) const allKeys = allUniqueKeys(schemas) if (options.deep && contains(allKeys, 'allOf')) { return merger({ allOf: schemas }, options, totalSchemas) } const complexKeysArr = complexResolvers.map(([mainKeyWord, resolverConf]) => allKeys.filter(k => resolverConf.keywords.includes(k))) // remove all complex keys before simple resolvers complexKeysArr.forEach(keys => pullAll(allKeys, keys)) // call all simple resolvers for relevant keywords allKeys.forEach(function(key) { const values = getValues(schemas, key) const compacted = uniqWith(values.filter(notUndefined), compareProp(key)) // arrayprops like anyOf and oneOf must be merged first, as they contains schemas // allOf is treated differently alltogether if (compacted.length === 1 && contains(schemaArrays, key)) { merged[key] = compacted[0].map(schema => mergeSchemas([schema], schema)) // prop groups must always be resolved } else if (compacted.length === 1 && !contains(schemaGroupProps, key) && !contains(schemaProps, key)) { merged[key] = compacted[0] } else { const resolver = options.resolvers[key] || options.resolvers.defaultResolver if (!resolver) throw new Error('No resolver found for key ' + key + '. You can provide a resolver for this keyword in the options, or provide a default resolver.') const merger = (schemas, extraKey = []) => mergeSchemas(schemas, null, parents.concat(key, extraKey)) merged[key] = resolver(compacted, parents.concat(key), merger, options) if (merged[key] === undefined) { throwIncompatible(compacted, parents.concat(key)) } else if (merged[key] === undefined) { delete merged[key] } } }) return complexResolvers.reduce((all, [resolverKeyword, config], index) => ({ ...all, ...callGroupResolver(complexKeysArr[index], resolverKeyword, schemas, mergeSchemas, options, parents) }), merged) } const allSchemas = flattenDeep(getAllOf(rootSchema)) const merged = mergeSchemas(allSchemas) return merged } merger.options = { resolvers: defaultResolvers } module.exports = merger /***/ }), /***/ 88208: /***/ ((__unused_webpack_module, exports) => { var hasExcape = /~/ var escapeMatcher = /~[01]/g function escapeReplacer (m) { switch (m) { case '~1': return '/' case '~0': return '~' } throw new Error('Invalid tilde escape: ' + m) } function untilde (str) { if (!hasExcape.test(str)) return str return str.replace(escapeMatcher, escapeReplacer) } function setter (obj, pointer, value) { var part var hasNextPart for (var p = 1, len = pointer.length; p < len;) { if (pointer[p] === 'constructor' || pointer[p] === 'prototype' || pointer[p] === '__proto__') return obj part = untilde(pointer[p++]) hasNextPart = len > p if (typeof obj[part] === 'undefined') { // support setting of /- if (Array.isArray(obj) && part === '-') { part = obj.length } // support nested objects/array when setting values if (hasNextPart) { if ((pointer[p] !== '' && pointer[p] < Infinity) || pointer[p] === '-') obj[part] = [] else obj[part] = {} } } if (!hasNextPart) break obj = obj[part] } var oldValue = obj[part] if (value === undefined) delete obj[part] else obj[part] = value return oldValue } function compilePointer (pointer) { if (typeof pointer === 'string') { pointer = pointer.split('/') if (pointer[0] === '') return pointer throw new Error('Invalid JSON pointer.') } else if (Array.isArray(pointer)) { for (const part of pointer) { if (typeof part !== 'string' && typeof part !== 'number') { throw new Error('Invalid JSON pointer. Must be of type string or number.') } } return pointer } throw new Error('Invalid JSON pointer.') } function get (obj, pointer) { if (typeof obj !== 'object') throw new Error('Invalid input object.') pointer = compilePointer(pointer) var len = pointer.length if (len === 1) return obj for (var p = 1; p < len;) { obj = obj[untilde(pointer[p++])] if (len === p) return obj if (typeof obj !== 'object' || obj === null) return undefined } } function set (obj, pointer, value) { if (typeof obj !== 'object') throw new Error('Invalid input object.') pointer = compilePointer(pointer) if (pointer.length === 0) throw new Error('Invalid JSON pointer for set.') return setter(obj, pointer, value) } function compile (pointer) { var compiled = compilePointer(pointer) return { get: function (object) { return get(object, compiled) }, set: function (object, value) { return set(object, compiled, value) } } } exports.get = get exports.set = set exports.compile = compile /***/ }), /***/ 52485: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var MapCache = __webpack_require__(74554), setCacheAdd = __webpack_require__(38639), setCacheHas = __webpack_require__(88379); /** * * Creates an array cache object to store unique values. * * @private * @constructor * @param {Array} [values] The values to cache. */ function SetCache(values) { var index = -1, length = values == null ? 0 : values.length; this.__data__ = new MapCache; while (++index < length) { this.add(values[index]); } } // Add methods to `SetCache`. SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; SetCache.prototype.has = setCacheHas; module.exports = SetCache; /***/ }), /***/ 58095: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIndexOf = __webpack_require__(8817); /** * A specialized version of `_.includes` for arrays without support for * specifying an index to search from. * * @private * @param {Array} [array] The array to inspect. * @param {*} target The value to search for. * @returns {boolean} Returns `true` if `target` is found, else `false`. */ function arrayIncludes(array, value) { var length = array == null ? 0 : array.length; return !!length && baseIndexOf(array, value, 0) > -1; } module.exports = arrayIncludes; /***/ }), /***/ 21796: /***/ ((module) => { /** * This function is like `arrayIncludes` except that it accepts a comparator. * * @private * @param {Array} [array] The array to inspect. * @param {*} target The value to search for. * @param {Function} comparator The comparator invoked per element. * @returns {boolean} Returns `true` if `target` is found, else `false`. */ function arrayIncludesWith(array, value, comparator) { var index = -1, length = array == null ? 0 : array.length; while (++index < length) { if (comparator(value, array[index])) { return true; } } return false; } module.exports = arrayIncludesWith; /***/ }), /***/ 6446: /***/ ((module) => { /** * A specialized version of `_.reduce` for arrays without support for * iteratee shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {*} [accumulator] The initial value. * @param {boolean} [initAccum] Specify using the first element of `array` as * the initial value. * @returns {*} Returns the accumulated value. */ function arrayReduce(array, iteratee, accumulator, initAccum) { var index = -1, length = array == null ? 0 : array.length; if (initAccum && length) { accumulator = array[++index]; } while (++index < length) { accumulator = iteratee(accumulator, array[index], index, array); } return accumulator; } module.exports = arrayReduce; /***/ }), /***/ 90756: /***/ ((module) => { /** * A specialized version of `_.some` for arrays without support for iteratee * shorthands. * * @private * @param {Array} [array] The array to iterate over. * @param {Function} predicate The function invoked per iteration. * @returns {boolean} Returns `true` if any element passes the predicate check, * else `false`. */ function arraySome(array, predicate) { var index = -1, length = array == null ? 0 : array.length; while (++index < length) { if (predicate(array[index], index, array)) { return true; } } return false; } module.exports = arraySome; /***/ }), /***/ 73140: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseAssignValue = __webpack_require__(88799), eq = __webpack_require__(85638); /** * This function is like `assignValue` except that it doesn't assign * `undefined` values. * * @private * @param {Object} object The object to modify. * @param {string} key The key of the property to assign. * @param {*} value The value to assign. */ function assignMergeValue(object, key, value) { if ((value !== undefined && !eq(object[key], value)) || (value === undefined && !(key in object))) { baseAssignValue(object, key, value); } } module.exports = assignMergeValue; /***/ }), /***/ 11005: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var SetCache = __webpack_require__(52485), arrayIncludes = __webpack_require__(58095), arrayIncludesWith = __webpack_require__(21796), arrayMap = __webpack_require__(66070), baseUnary = __webpack_require__(39334), cacheHas = __webpack_require__(65581); /** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200; /** * The base implementation of methods like `_.difference` without support * for excluding multiple arrays or iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Array} values The values to exclude. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new array of filtered values. */ function baseDifference(array, values, iteratee, comparator) { var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length; if (!length) { return result; } if (iteratee) { values = arrayMap(values, baseUnary(iteratee)); } if (comparator) { includes = arrayIncludesWith; isCommon = false; } else if (values.length >= LARGE_ARRAY_SIZE) { includes = cacheHas; isCommon = false; values = new SetCache(values); } outer: while (++index < length) { var value = array[index], computed = iteratee == null ? value : iteratee(value); value = (comparator || value !== 0) ? value : 0; if (isCommon && computed === computed) { var valuesIndex = valuesLength; while (valuesIndex--) { if (values[valuesIndex] === computed) { continue outer; } } result.push(value); } else if (!includes(values, computed, comparator)) { result.push(value); } } return result; } module.exports = baseDifference; /***/ }), /***/ 52033: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseForOwn = __webpack_require__(26194), createBaseEach = __webpack_require__(26789); /** * The base implementation of `_.forEach` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array|Object} Returns `collection`. */ var baseEach = createBaseEach(baseForOwn); module.exports = baseEach; /***/ }), /***/ 95372: /***/ ((module) => { /** * The base implementation of `_.findIndex` and `_.findLastIndex` without * support for iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Function} predicate The function invoked per iteration. * @param {number} fromIndex The index to search from. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseFindIndex(array, predicate, fromIndex, fromRight) { var length = array.length, index = fromIndex + (fromRight ? 1 : -1); while ((fromRight ? index-- : ++index < length)) { if (predicate(array[index], index, array)) { return index; } } return -1; } module.exports = baseFindIndex; /***/ }), /***/ 49819: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var createBaseFor = __webpack_require__(18911); /** * The base implementation of `baseForOwn` which iterates over `object` * properties returned by `keysFunc` and invokes `iteratee` for each property. * Iteratee functions may exit iteration early by explicitly returning `false`. * * @private * @param {Object} object The object to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {Function} keysFunc The function to get the keys of `object`. * @returns {Object} Returns `object`. */ var baseFor = createBaseFor(); module.exports = baseFor; /***/ }), /***/ 26194: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseFor = __webpack_require__(49819), keys = __webpack_require__(50098); /** * The base implementation of `_.forOwn` without support for iteratee shorthands. * * @private * @param {Object} object The object to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Object} Returns `object`. */ function baseForOwn(object, iteratee) { return object && baseFor(object, iteratee, keys); } module.exports = baseForOwn; /***/ }), /***/ 8817: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseFindIndex = __webpack_require__(95372), baseIsNaN = __webpack_require__(1129), strictIndexOf = __webpack_require__(58263); /** * The base implementation of `_.indexOf` without `fromIndex` bounds checks. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseIndexOf(array, value, fromIndex) { return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex); } module.exports = baseIndexOf; /***/ }), /***/ 56006: /***/ ((module) => { /** * This function is like `baseIndexOf` except that it accepts a comparator. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @param {Function} comparator The comparator invoked per element. * @returns {number} Returns the index of the matched value, else `-1`. */ function baseIndexOfWith(array, value, fromIndex, comparator) { var index = fromIndex - 1, length = array.length; while (++index < length) { if (comparator(array[index], value)) { return index; } } return -1; } module.exports = baseIndexOfWith; /***/ }), /***/ 96638: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var SetCache = __webpack_require__(52485), arrayIncludes = __webpack_require__(58095), arrayIncludesWith = __webpack_require__(21796), arrayMap = __webpack_require__(66070), baseUnary = __webpack_require__(39334), cacheHas = __webpack_require__(65581); /* Built-in method references for those with the same name as other `lodash` methods. */ var nativeMin = Math.min; /** * The base implementation of methods like `_.intersection`, without support * for iteratee shorthands, that accepts an array of arrays to inspect. * * @private * @param {Array} arrays The arrays to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new array of shared values. */ function baseIntersection(arrays, iteratee, comparator) { var includes = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = []; while (othIndex--) { var array = arrays[othIndex]; if (othIndex && iteratee) { array = arrayMap(array, baseUnary(iteratee)); } maxLength = nativeMin(array.length, maxLength); caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) ? new SetCache(othIndex && array) : undefined; } array = arrays[0]; var index = -1, seen = caches[0]; outer: while (++index < length && result.length < maxLength) { var value = array[index], computed = iteratee ? iteratee(value) : value; value = (comparator || value !== 0) ? value : 0; if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator) )) { othIndex = othLength; while (--othIndex) { var cache = caches[othIndex]; if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator)) ) { continue outer; } } if (seen) { seen.push(computed); } result.push(value); } } return result; } module.exports = baseIntersection; /***/ }), /***/ 32866: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIsEqualDeep = __webpack_require__(12772), isObjectLike = __webpack_require__(92360); /** * The base implementation of `_.isEqual` which supports partial comparisons * and tracks traversed objects. * * @private * @param {*} value The value to compare. * @param {*} other The other value to compare. * @param {boolean} bitmask The bitmask flags. * 1 - Unordered comparison * 2 - Partial comparison * @param {Function} [customizer] The function to customize comparisons. * @param {Object} [stack] Tracks traversed `value` and `other` objects. * @returns {boolean} Returns `true` if the values are equivalent, else `false`. */ function baseIsEqual(value, other, bitmask, customizer, stack) { if (value === other) { return true; } if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { return value !== value && other !== other; } return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); } module.exports = baseIsEqual; /***/ }), /***/ 12772: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var Stack = __webpack_require__(23694), equalArrays = __webpack_require__(27042), equalByTag = __webpack_require__(370), equalObjects = __webpack_require__(39584), getTag = __webpack_require__(3533), isArray = __webpack_require__(19785), isBuffer = __webpack_require__(43854), isTypedArray = __webpack_require__(48519); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1; /** `Object#toString` result references. */ var argsTag = '[object Arguments]', arrayTag = '[object Array]', objectTag = '[object Object]'; /** Used for built-in method references. */ var objectProto = Object.prototype; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; /** * A specialized version of `baseIsEqual` for arrays and objects which performs * deep comparisons and tracks traversed objects enabling objects with circular * references to be compared. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} [stack] Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other); objTag = objTag == argsTag ? objectTag : objTag; othTag = othTag == argsTag ? objectTag : othTag; var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag; if (isSameTag && isBuffer(object)) { if (!isBuffer(other)) { return false; } objIsArr = true; objIsObj = false; } if (isSameTag && !objIsObj) { stack || (stack = new Stack); return (objIsArr || isTypedArray(object)) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); } if (!(bitmask & COMPARE_PARTIAL_FLAG)) { var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); if (objIsWrapped || othIsWrapped) { var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other; stack || (stack = new Stack); return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); } } if (!isSameTag) { return false; } stack || (stack = new Stack); return equalObjects(object, other, bitmask, customizer, equalFunc, stack); } module.exports = baseIsEqualDeep; /***/ }), /***/ 19850: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var Stack = __webpack_require__(23694), baseIsEqual = __webpack_require__(32866); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; /** * The base implementation of `_.isMatch` without support for iteratee shorthands. * * @private * @param {Object} object The object to inspect. * @param {Object} source The object of property values to match. * @param {Array} matchData The property names, values, and compare flags to match. * @param {Function} [customizer] The function to customize comparisons. * @returns {boolean} Returns `true` if `object` is a match, else `false`. */ function baseIsMatch(object, source, matchData, customizer) { var index = matchData.length, length = index, noCustomizer = !customizer; if (object == null) { return !length; } object = Object(object); while (index--) { var data = matchData[index]; if ((noCustomizer && data[2]) ? data[1] !== object[data[0]] : !(data[0] in object) ) { return false; } } while (++index < length) { data = matchData[index]; var key = data[0], objValue = object[key], srcValue = data[1]; if (noCustomizer && data[2]) { if (objValue === undefined && !(key in object)) { return false; } } else { var stack = new Stack; if (customizer) { var result = customizer(objValue, srcValue, key, object, source, stack); } if (!(result === undefined ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result )) { return false; } } } return true; } module.exports = baseIsMatch; /***/ }), /***/ 1129: /***/ ((module) => { /** * The base implementation of `_.isNaN` without support for number objects. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. */ function baseIsNaN(value) { return value !== value; } module.exports = baseIsNaN; /***/ }), /***/ 89278: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseMatches = __webpack_require__(71410), baseMatchesProperty = __webpack_require__(57518), identity = __webpack_require__(31137), isArray = __webpack_require__(19785), property = __webpack_require__(96001); /** * The base implementation of `_.iteratee`. * * @private * @param {*} [value=_.identity] The value to convert to an iteratee. * @returns {Function} Returns the iteratee. */ function baseIteratee(value) { // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. if (typeof value == 'function') { return value; } if (value == null) { return identity; } if (typeof value == 'object') { return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); } return property(value); } module.exports = baseIteratee; /***/ }), /***/ 67375: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseEach = __webpack_require__(52033), isArrayLike = __webpack_require__(80068); /** * The base implementation of `_.map` without support for iteratee shorthands. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @returns {Array} Returns the new mapped array. */ function baseMap(collection, iteratee) { var index = -1, result = isArrayLike(collection) ? Array(collection.length) : []; baseEach(collection, function(value, key, collection) { result[++index] = iteratee(value, key, collection); }); return result; } module.exports = baseMap; /***/ }), /***/ 71410: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIsMatch = __webpack_require__(19850), getMatchData = __webpack_require__(68125), matchesStrictComparable = __webpack_require__(65042); /** * The base implementation of `_.matches` which doesn't clone `source`. * * @private * @param {Object} source The object of property values to match. * @returns {Function} Returns the new spec function. */ function baseMatches(source) { var matchData = getMatchData(source); if (matchData.length == 1 && matchData[0][2]) { return matchesStrictComparable(matchData[0][0], matchData[0][1]); } return function(object) { return object === source || baseIsMatch(object, source, matchData); }; } module.exports = baseMatches; /***/ }), /***/ 57518: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIsEqual = __webpack_require__(32866), get = __webpack_require__(99729), hasIn = __webpack_require__(79749), isKey = __webpack_require__(40318), isStrictComparable = __webpack_require__(68302), matchesStrictComparable = __webpack_require__(65042), toKey = __webpack_require__(37948); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; /** * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. * * @private * @param {string} path The path of the property to get. * @param {*} srcValue The value to match. * @returns {Function} Returns the new spec function. */ function baseMatchesProperty(path, srcValue) { if (isKey(path) && isStrictComparable(srcValue)) { return matchesStrictComparable(toKey(path), srcValue); } return function(object) { var objValue = get(object, path); return (objValue === undefined && objValue === srcValue) ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); }; } module.exports = baseMatchesProperty; /***/ }), /***/ 40015: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var Stack = __webpack_require__(23694), assignMergeValue = __webpack_require__(73140), baseFor = __webpack_require__(49819), baseMergeDeep = __webpack_require__(68867), isObject = __webpack_require__(11611), keysIn = __webpack_require__(53893), safeGet = __webpack_require__(97494); /** * The base implementation of `_.merge` without support for multiple sources. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {number} srcIndex The index of `source`. * @param {Function} [customizer] The function to customize merged values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMerge(object, source, srcIndex, customizer, stack) { if (object === source) { return; } baseFor(source, function(srcValue, key) { stack || (stack = new Stack); if (isObject(srcValue)) { baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); } else { var newValue = customizer ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) : undefined; if (newValue === undefined) { newValue = srcValue; } assignMergeValue(object, key, newValue); } }, keysIn); } module.exports = baseMerge; /***/ }), /***/ 68867: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var assignMergeValue = __webpack_require__(73140), cloneBuffer = __webpack_require__(2734), cloneTypedArray = __webpack_require__(63428), copyArray = __webpack_require__(37561), initCloneObject = __webpack_require__(9560), isArguments = __webpack_require__(2900), isArray = __webpack_require__(19785), isArrayLikeObject = __webpack_require__(36468), isBuffer = __webpack_require__(43854), isFunction = __webpack_require__(28338), isObject = __webpack_require__(11611), isPlainObject = __webpack_require__(40861), isTypedArray = __webpack_require__(48519), safeGet = __webpack_require__(97494), toPlainObject = __webpack_require__(89328); /** * A specialized version of `baseMerge` for arrays and objects which performs * deep merges and tracks traversed objects enabling objects with circular * references to be merged. * * @private * @param {Object} object The destination object. * @param {Object} source The source object. * @param {string} key The key of the value to merge. * @param {number} srcIndex The index of `source`. * @param {Function} mergeFunc The function to merge values. * @param {Function} [customizer] The function to customize assigned values. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. */ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue); if (stacked) { assignMergeValue(object, key, stacked); return; } var newValue = customizer ? customizer(objValue, srcValue, (key + ''), object, source, stack) : undefined; var isCommon = newValue === undefined; if (isCommon) { var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue); newValue = srcValue; if (isArr || isBuff || isTyped) { if (isArray(objValue)) { newValue = objValue; } else if (isArrayLikeObject(objValue)) { newValue = copyArray(objValue); } else if (isBuff) { isCommon = false; newValue = cloneBuffer(srcValue, true); } else if (isTyped) { isCommon = false; newValue = cloneTypedArray(srcValue, true); } else { newValue = []; } } else if (isPlainObject(srcValue) || isArguments(srcValue)) { newValue = objValue; if (isArguments(objValue)) { newValue = toPlainObject(objValue); } else if (!isObject(objValue) || isFunction(objValue)) { newValue = initCloneObject(srcValue); } } else { isCommon = false; } } if (isCommon) { // Recursively merge objects and arrays (susceptible to call stack limits). stack.set(srcValue, newValue); mergeFunc(newValue, srcValue, srcIndex, customizer, stack); stack['delete'](srcValue); } assignMergeValue(object, key, newValue); } module.exports = baseMergeDeep; /***/ }), /***/ 98497: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayMap = __webpack_require__(66070), baseGet = __webpack_require__(79867), baseIteratee = __webpack_require__(89278), baseMap = __webpack_require__(67375), baseSortBy = __webpack_require__(73303), baseUnary = __webpack_require__(39334), compareMultiple = __webpack_require__(96348), identity = __webpack_require__(31137), isArray = __webpack_require__(19785); /** * The base implementation of `_.orderBy` without param guards. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. * @param {string[]} orders The sort orders of `iteratees`. * @returns {Array} Returns the new sorted array. */ function baseOrderBy(collection, iteratees, orders) { if (iteratees.length) { iteratees = arrayMap(iteratees, function(iteratee) { if (isArray(iteratee)) { return function(value) { return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee); } } return iteratee; }); } else { iteratees = [identity]; } var index = -1; iteratees = arrayMap(iteratees, baseUnary(baseIteratee)); var result = baseMap(collection, function(value, key, collection) { var criteria = arrayMap(iteratees, function(iteratee) { return iteratee(value); }); return { 'criteria': criteria, 'index': ++index, 'value': value }; }); return baseSortBy(result, function(object, other) { return compareMultiple(object, other, orders); }); } module.exports = baseOrderBy; /***/ }), /***/ 50517: /***/ ((module) => { /** * The base implementation of `_.property` without support for deep paths. * * @private * @param {string} key The key of the property to get. * @returns {Function} Returns the new accessor function. */ function baseProperty(key) { return function(object) { return object == null ? undefined : object[key]; }; } module.exports = baseProperty; /***/ }), /***/ 10301: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseGet = __webpack_require__(79867); /** * A specialized version of `baseProperty` which supports deep paths. * * @private * @param {Array|string} path The path of the property to get. * @returns {Function} Returns the new accessor function. */ function basePropertyDeep(path) { return function(object) { return baseGet(object, path); }; } module.exports = basePropertyDeep; /***/ }), /***/ 61933: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayMap = __webpack_require__(66070), baseIndexOf = __webpack_require__(8817), baseIndexOfWith = __webpack_require__(56006), baseUnary = __webpack_require__(39334), copyArray = __webpack_require__(37561); /** Used for built-in method references. */ var arrayProto = Array.prototype; /** Built-in value references. */ var splice = arrayProto.splice; /** * The base implementation of `_.pullAllBy` without support for iteratee * shorthands. * * @private * @param {Array} array The array to modify. * @param {Array} values The values to remove. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns `array`. */ function basePullAll(array, values, iteratee, comparator) { var indexOf = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values.length, seen = array; if (array === values) { values = copyArray(values); } if (iteratee) { seen = arrayMap(array, baseUnary(iteratee)); } while (++index < length) { var fromIndex = 0, value = values[index], computed = iteratee ? iteratee(value) : value; while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { if (seen !== array) { splice.call(seen, fromIndex, 1); } splice.call(array, fromIndex, 1); } } return array; } module.exports = basePullAll; /***/ }), /***/ 19356: /***/ ((module) => { /** * The base implementation of `_.reduce` and `_.reduceRight`, without support * for iteratee shorthands, which iterates over `collection` using `eachFunc`. * * @private * @param {Array|Object} collection The collection to iterate over. * @param {Function} iteratee The function invoked per iteration. * @param {*} accumulator The initial value. * @param {boolean} initAccum Specify using the first or last element of * `collection` as the initial value. * @param {Function} eachFunc The function to iterate over `collection`. * @returns {*} Returns the accumulated value. */ function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { eachFunc(collection, function(value, index, collection) { accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection); }); return accumulator; } module.exports = baseReduce; /***/ }), /***/ 1197: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var identity = __webpack_require__(31137), overRest = __webpack_require__(11871), setToString = __webpack_require__(63132); /** * The base implementation of `_.rest` which doesn't validate or coerce arguments. * * @private * @param {Function} func The function to apply a rest parameter to. * @param {number} [start=func.length-1] The start position of the rest parameter. * @returns {Function} Returns the new function. */ function baseRest(func, start) { return setToString(overRest(func, start, identity), func + ''); } module.exports = baseRest; /***/ }), /***/ 73303: /***/ ((module) => { /** * The base implementation of `_.sortBy` which uses `comparer` to define the * sort order of `array` and replaces criteria objects with their corresponding * values. * * @private * @param {Array} array The array to sort. * @param {Function} comparer The function to define sort order. * @returns {Array} Returns `array`. */ function baseSortBy(array, comparer) { var length = array.length; array.sort(comparer); while (length--) { array[length] = array[length].value; } return array; } module.exports = baseSortBy; /***/ }), /***/ 74833: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var trimmedEndIndex = __webpack_require__(56127); /** Used to match leading whitespace. */ var reTrimStart = /^\s+/; /** * The base implementation of `_.trim`. * * @private * @param {string} string The string to trim. * @returns {string} Returns the trimmed string. */ function baseTrim(string) { return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string; } module.exports = baseTrim; /***/ }), /***/ 92198: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var SetCache = __webpack_require__(52485), arrayIncludes = __webpack_require__(58095), arrayIncludesWith = __webpack_require__(21796), cacheHas = __webpack_require__(65581), createSet = __webpack_require__(47111), setToArray = __webpack_require__(43735); /** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200; /** * The base implementation of `_.uniqBy` without support for iteratee shorthands. * * @private * @param {Array} array The array to inspect. * @param {Function} [iteratee] The iteratee invoked per element. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new duplicate free array. */ function baseUniq(array, iteratee, comparator) { var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result; if (comparator) { isCommon = false; includes = arrayIncludesWith; } else if (length >= LARGE_ARRAY_SIZE) { var set = iteratee ? null : createSet(array); if (set) { return setToArray(set); } isCommon = false; includes = cacheHas; seen = new SetCache; } else { seen = iteratee ? [] : result; } outer: while (++index < length) { var value = array[index], computed = iteratee ? iteratee(value) : value; value = (comparator || value !== 0) ? value : 0; if (isCommon && computed === computed) { var seenIndex = seen.length; while (seenIndex--) { if (seen[seenIndex] === computed) { continue outer; } } if (iteratee) { seen.push(computed); } result.push(value); } else if (!includes(seen, computed, comparator)) { if (seen !== result) { seen.push(computed); } result.push(value); } } return result; } module.exports = baseUniq; /***/ }), /***/ 65581: /***/ ((module) => { /** * Checks if a `cache` value for `key` exists. * * @private * @param {Object} cache The cache to query. * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ function cacheHas(cache, key) { return cache.has(key); } module.exports = cacheHas; /***/ }), /***/ 60923: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isArrayLikeObject = __webpack_require__(36468); /** * Casts `value` to an empty array if it's not an array like object. * * @private * @param {*} value The value to inspect. * @returns {Array|Object} Returns the cast array-like object. */ function castArrayLikeObject(value) { return isArrayLikeObject(value) ? value : []; } module.exports = castArrayLikeObject; /***/ }), /***/ 62079: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var identity = __webpack_require__(31137); /** * Casts `value` to `identity` if it's not a function. * * @private * @param {*} value The value to inspect. * @returns {Function} Returns cast function. */ function castFunction(value) { return typeof value == 'function' ? value : identity; } module.exports = castFunction; /***/ }), /***/ 17845: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isSymbol = __webpack_require__(55193); /** * Compares values to sort them in ascending order. * * @private * @param {*} value The value to compare. * @param {*} other The other value to compare. * @returns {number} Returns the sort order indicator for `value`. */ function compareAscending(value, other) { if (value !== other) { var valIsDefined = value !== undefined, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value); var othIsDefined = other !== undefined, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other); if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || (valIsNull && othIsDefined && othIsReflexive) || (!valIsDefined && othIsReflexive) || !valIsReflexive) { return 1; } if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || (othIsNull && valIsDefined && valIsReflexive) || (!othIsDefined && valIsReflexive) || !othIsReflexive) { return -1; } } return 0; } module.exports = compareAscending; /***/ }), /***/ 96348: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var compareAscending = __webpack_require__(17845); /** * Used by `_.orderBy` to compare multiple properties of a value to another * and stable sort them. * * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, * specify an order of "desc" for descending or "asc" for ascending sort order * of corresponding values. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {boolean[]|string[]} orders The order to sort by for each property. * @returns {number} Returns the sort order indicator for `object`. */ function compareMultiple(object, other, orders) { var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length; while (++index < length) { var result = compareAscending(objCriteria[index], othCriteria[index]); if (result) { if (index >= ordersLength) { return result; } var order = orders[index]; return result * (order == 'desc' ? -1 : 1); } } // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications // that causes it, under certain circumstances, to provide the same value for // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 // for more details. // // This also ensures a stable sort in V8 and other engines. // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. return object.index - other.index; } module.exports = compareMultiple; /***/ }), /***/ 7270: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseRest = __webpack_require__(1197), isIterateeCall = __webpack_require__(57535); /** * Creates a function like `_.assign`. * * @private * @param {Function} assigner The function to assign values. * @returns {Function} Returns the new assigner function. */ function createAssigner(assigner) { return baseRest(function(object, sources) { var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined, guard = length > 2 ? sources[2] : undefined; customizer = (assigner.length > 3 && typeof customizer == 'function') ? (length--, customizer) : undefined; if (guard && isIterateeCall(sources[0], sources[1], guard)) { customizer = length < 3 ? undefined : customizer; length = 1; } object = Object(object); while (++index < length) { var source = sources[index]; if (source) { assigner(object, source, index, customizer); } } return object; }); } module.exports = createAssigner; /***/ }), /***/ 26789: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isArrayLike = __webpack_require__(80068); /** * Creates a `baseEach` or `baseEachRight` function. * * @private * @param {Function} eachFunc The function to iterate over a collection. * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new base function. */ function createBaseEach(eachFunc, fromRight) { return function(collection, iteratee) { if (collection == null) { return collection; } if (!isArrayLike(collection)) { return eachFunc(collection, iteratee); } var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection); while ((fromRight ? index-- : ++index < length)) { if (iteratee(iterable[index], index, iterable) === false) { break; } } return collection; }; } module.exports = createBaseEach; /***/ }), /***/ 18911: /***/ ((module) => { /** * Creates a base function for methods like `_.forIn` and `_.forOwn`. * * @private * @param {boolean} [fromRight] Specify iterating from right to left. * @returns {Function} Returns the new base function. */ function createBaseFor(fromRight) { return function(object, iteratee, keysFunc) { var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; while (length--) { var key = props[fromRight ? length : ++index]; if (iteratee(iterable[key], key, iterable) === false) { break; } } return object; }; } module.exports = createBaseFor; /***/ }), /***/ 47111: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var Set = __webpack_require__(46151), noop = __webpack_require__(50344), setToArray = __webpack_require__(43735); /** Used as references for various `Number` constants. */ var INFINITY = 1 / 0; /** * Creates a set object of `values`. * * @private * @param {Array} values The values to add to the set. * @returns {Object} Returns the new set. */ var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { return new Set(values); }; module.exports = createSet; /***/ }), /***/ 19491: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseMerge = __webpack_require__(40015), isObject = __webpack_require__(11611); /** * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source * objects into destination objects that are passed thru. * * @private * @param {*} objValue The destination value. * @param {*} srcValue The source value. * @param {string} key The key of the property to merge. * @param {Object} object The parent object of `objValue`. * @param {Object} source The parent object of `srcValue`. * @param {Object} [stack] Tracks traversed source values and their merged * counterparts. * @returns {*} Returns the value to assign. */ function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { if (isObject(objValue) && isObject(srcValue)) { // Recursively merge objects and arrays (susceptible to call stack limits). stack.set(srcValue, objValue); baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack); stack['delete'](srcValue); } return objValue; } module.exports = customDefaultsMerge; /***/ }), /***/ 27042: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var SetCache = __webpack_require__(52485), arraySome = __webpack_require__(90756), cacheHas = __webpack_require__(65581); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; /** * A specialized version of `baseIsEqualDeep` for arrays with support for * partial deep comparisons. * * @private * @param {Array} array The array to compare. * @param {Array} other The other array to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `array` and `other` objects. * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. */ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length; if (arrLength != othLength && !(isPartial && othLength > arrLength)) { return false; } // Check that cyclic values are equal. var arrStacked = stack.get(array); var othStacked = stack.get(other); if (arrStacked && othStacked) { return arrStacked == other && othStacked == array; } var index = -1, result = true, seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; stack.set(array, other); stack.set(other, array); // Ignore non-index properties. while (++index < arrLength) { var arrValue = array[index], othValue = other[index]; if (customizer) { var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); } if (compared !== undefined) { if (compared) { continue; } result = false; break; } // Recursively compare arrays (susceptible to call stack limits). if (seen) { if (!arraySome(other, function(othValue, othIndex) { if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { return seen.push(othIndex); } })) { result = false; break; } } else if (!( arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack) )) { result = false; break; } } stack['delete'](array); stack['delete'](other); return result; } module.exports = equalArrays; /***/ }), /***/ 370: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var Symbol = __webpack_require__(96539), Uint8Array = __webpack_require__(59942), eq = __webpack_require__(85638), equalArrays = __webpack_require__(27042), mapToArray = __webpack_require__(19383), setToArray = __webpack_require__(43735); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; /** `Object#toString` result references. */ var boolTag = '[object Boolean]', dateTag = '[object Date]', errorTag = '[object Error]', mapTag = '[object Map]', numberTag = '[object Number]', regexpTag = '[object RegExp]', setTag = '[object Set]', stringTag = '[object String]', symbolTag = '[object Symbol]'; var arrayBufferTag = '[object ArrayBuffer]', dataViewTag = '[object DataView]'; /** Used to convert symbols to primitives and strings. */ var symbolProto = Symbol ? Symbol.prototype : undefined, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; /** * A specialized version of `baseIsEqualDeep` for comparing objects of * the same `toStringTag`. * * **Note:** This function only supports comparing values with tags of * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {string} tag The `toStringTag` of the objects to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { switch (tag) { case dataViewTag: if ((object.byteLength != other.byteLength) || (object.byteOffset != other.byteOffset)) { return false; } object = object.buffer; other = other.buffer; case arrayBufferTag: if ((object.byteLength != other.byteLength) || !equalFunc(new Uint8Array(object), new Uint8Array(other))) { return false; } return true; case boolTag: case dateTag: case numberTag: // Coerce booleans to `1` or `0` and dates to milliseconds. // Invalid dates are coerced to `NaN`. return eq(+object, +other); case errorTag: return object.name == other.name && object.message == other.message; case regexpTag: case stringTag: // Coerce regexes to strings and treat strings, primitives and objects, // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring // for more details. return object == (other + ''); case mapTag: var convert = mapToArray; case setTag: var isPartial = bitmask & COMPARE_PARTIAL_FLAG; convert || (convert = setToArray); if (object.size != other.size && !isPartial) { return false; } // Assume cyclic values are equal. var stacked = stack.get(object); if (stacked) { return stacked == other; } bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits). stack.set(object, other); var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); stack['delete'](object); return result; case symbolTag: if (symbolValueOf) { return symbolValueOf.call(object) == symbolValueOf.call(other); } } return false; } module.exports = equalByTag; /***/ }), /***/ 39584: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var getAllKeys = __webpack_require__(51385); /** Used to compose bitmasks for value comparisons. */ var COMPARE_PARTIAL_FLAG = 1; /** Used for built-in method references. */ var objectProto = Object.prototype; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; /** * A specialized version of `baseIsEqualDeep` for objects with support for * partial deep comparisons. * * @private * @param {Object} object The object to compare. * @param {Object} other The other object to compare. * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. * @param {Function} customizer The function to customize comparisons. * @param {Function} equalFunc The function to determine equivalents of values. * @param {Object} stack Tracks traversed `object` and `other` objects. * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. */ function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length; if (objLength != othLength && !isPartial) { return false; } var index = objLength; while (index--) { var key = objProps[index]; if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { return false; } } // Check that cyclic values are equal. var objStacked = stack.get(object); var othStacked = stack.get(other); if (objStacked && othStacked) { return objStacked == other && othStacked == object; } var result = true; stack.set(object, other); stack.set(other, object); var skipCtor = isPartial; while (++index < objLength) { key = objProps[index]; var objValue = object[key], othValue = other[key]; if (customizer) { var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); } // Recursively compare objects (susceptible to call stack limits). if (!(compared === undefined ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) : compared )) { result = false; break; } skipCtor || (skipCtor = key == 'constructor'); } if (result && !skipCtor) { var objCtor = object.constructor, othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal. if (objCtor != othCtor && ('constructor' in object && 'constructor' in other) && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) { result = false; } } stack['delete'](object); stack['delete'](other); return result; } module.exports = equalObjects; /***/ }), /***/ 68125: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isStrictComparable = __webpack_require__(68302), keys = __webpack_require__(50098); /** * Gets the property names, values, and compare flags of `object`. * * @private * @param {Object} object The object to query. * @returns {Array} Returns the match data of `object`. */ function getMatchData(object) { var result = keys(object), length = result.length; while (length--) { var key = result[length], value = object[key]; result[length] = [key, value, isStrictComparable(value)]; } return result; } module.exports = getMatchData; /***/ }), /***/ 57535: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var eq = __webpack_require__(85638), isArrayLike = __webpack_require__(80068), isIndex = __webpack_require__(42383), isObject = __webpack_require__(11611); /** * Checks if the given arguments are from an iteratee call. * * @private * @param {*} value The potential iteratee value argument. * @param {*} index The potential iteratee index or key argument. * @param {*} object The potential iteratee object argument. * @returns {boolean} Returns `true` if the arguments are from an iteratee call, * else `false`. */ function isIterateeCall(value, index, object) { if (!isObject(object)) { return false; } var type = typeof index; if (type == 'number' ? (isArrayLike(object) && isIndex(index, object.length)) : (type == 'string' && index in object) ) { return eq(object[index], value); } return false; } module.exports = isIterateeCall; /***/ }), /***/ 68302: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isObject = __webpack_require__(11611); /** * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. * * @private * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` if suitable for strict * equality comparisons, else `false`. */ function isStrictComparable(value) { return value === value && !isObject(value); } module.exports = isStrictComparable; /***/ }), /***/ 19383: /***/ ((module) => { /** * Converts `map` to its key-value pairs. * * @private * @param {Object} map The map to convert. * @returns {Array} Returns the key-value pairs. */ function mapToArray(map) { var index = -1, result = Array(map.size); map.forEach(function(value, key) { result[++index] = [key, value]; }); return result; } module.exports = mapToArray; /***/ }), /***/ 65042: /***/ ((module) => { /** * A specialized version of `matchesProperty` for source values suitable * for strict equality comparisons, i.e. `===`. * * @private * @param {string} key The key of the property to get. * @param {*} srcValue The value to match. * @returns {Function} Returns the new spec function. */ function matchesStrictComparable(key, srcValue) { return function(object) { if (object == null) { return false; } return object[key] === srcValue && (srcValue !== undefined || (key in Object(object))); }; } module.exports = matchesStrictComparable; /***/ }), /***/ 97494: /***/ ((module) => { /** * Gets the value at `key`, unless `key` is "__proto__" or "constructor". * * @private * @param {Object} object The object to query. * @param {string} key The key of the property to get. * @returns {*} Returns the property value. */ function safeGet(object, key) { if (key === 'constructor' && typeof object[key] === 'function') { return; } if (key == '__proto__') { return; } return object[key]; } module.exports = safeGet; /***/ }), /***/ 38639: /***/ ((module) => { /** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = '__lodash_hash_undefined__'; /** * Adds `value` to the array cache. * * @private * @name add * @memberOf SetCache * @alias push * @param {*} value The value to cache. * @returns {Object} Returns the cache instance. */ function setCacheAdd(value) { this.__data__.set(value, HASH_UNDEFINED); return this; } module.exports = setCacheAdd; /***/ }), /***/ 88379: /***/ ((module) => { /** * Checks if `value` is in the array cache. * * @private * @name has * @memberOf SetCache * @param {*} value The value to search for. * @returns {number} Returns `true` if `value` is found, else `false`. */ function setCacheHas(value) { return this.__data__.has(value); } module.exports = setCacheHas; /***/ }), /***/ 43735: /***/ ((module) => { /** * Converts `set` to an array of its values. * * @private * @param {Object} set The set to convert. * @returns {Array} Returns the values. */ function setToArray(set) { var index = -1, result = Array(set.size); set.forEach(function(value) { result[++index] = value; }); return result; } module.exports = setToArray; /***/ }), /***/ 58263: /***/ ((module) => { /** * A specialized version of `_.indexOf` which performs strict equality * comparisons of values, i.e. `===`. * * @private * @param {Array} array The array to inspect. * @param {*} value The value to search for. * @param {number} fromIndex The index to search from. * @returns {number} Returns the index of the matched value, else `-1`. */ function strictIndexOf(array, value, fromIndex) { var index = fromIndex - 1, length = array.length; while (++index < length) { if (array[index] === value) { return index; } } return -1; } module.exports = strictIndexOf; /***/ }), /***/ 56127: /***/ ((module) => { /** Used to match a single whitespace character. */ var reWhitespace = /\s/; /** * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace * character of `string`. * * @private * @param {string} string The string to inspect. * @returns {number} Returns the index of the last non-whitespace character. */ function trimmedEndIndex(string) { var index = string.length; while (index-- && reWhitespace.test(string.charAt(index))) {} return index; } module.exports = trimmedEndIndex; /***/ }), /***/ 70236: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseRest = __webpack_require__(1197), eq = __webpack_require__(85638), isIterateeCall = __webpack_require__(57535), keysIn = __webpack_require__(53893); /** Used for built-in method references. */ var objectProto = Object.prototype; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; /** * Assigns own and inherited enumerable string keyed properties of source * objects to the destination object for all destination properties that * resolve to `undefined`. Source objects are applied from left to right. * Once a property is set, additional values of the same property are ignored. * * **Note:** This method mutates `object`. * * @static * @since 0.1.0 * @memberOf _ * @category Object * @param {Object} object The destination object. * @param {...Object} [sources] The source objects. * @returns {Object} Returns `object`. * @see _.defaultsDeep * @example * * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); * // => { 'a': 1, 'b': 2 } */ var defaults = baseRest(function(object, sources) { object = Object(object); var index = -1; var length = sources.length; var guard = length > 2 ? sources[2] : undefined; if (guard && isIterateeCall(sources[0], sources[1], guard)) { length = 1; } while (++index < length) { var source = sources[index]; var props = keysIn(source); var propsIndex = -1; var propsLength = props.length; while (++propsIndex < propsLength) { var key = props[propsIndex]; var value = object[key]; if (value === undefined || (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { object[key] = source[key]; } } } return object; }); module.exports = defaults; /***/ }), /***/ 53533: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var apply = __webpack_require__(79349), baseRest = __webpack_require__(1197), customDefaultsMerge = __webpack_require__(19491), mergeWith = __webpack_require__(73952); /** * This method is like `_.defaults` except that it recursively assigns * default properties. * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 3.10.0 * @category Object * @param {Object} object The destination object. * @param {...Object} [sources] The source objects. * @returns {Object} Returns `object`. * @see _.defaults * @example * * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); * // => { 'a': { 'b': 2, 'c': 3 } } */ var defaultsDeep = baseRest(function(args) { args.push(undefined, customDefaultsMerge); return apply(mergeWith, undefined, args); }); module.exports = defaultsDeep; /***/ }), /***/ 84812: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseFlatten = __webpack_require__(23545); /** Used as references for various `Number` constants. */ var INFINITY = 1 / 0; /** * Recursively flattens `array`. * * @static * @memberOf _ * @since 3.0.0 * @category Array * @param {Array} array The array to flatten. * @returns {Array} Returns the new flattened array. * @example * * _.flattenDeep([1, [2, [3, [4]], 5]]); * // => [1, 2, 3, 4, 5] */ function flattenDeep(array) { var length = array == null ? 0 : array.length; return length ? baseFlatten(array, INFINITY) : []; } module.exports = flattenDeep; /***/ }), /***/ 47003: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayEach = __webpack_require__(80594), baseEach = __webpack_require__(52033), castFunction = __webpack_require__(62079), isArray = __webpack_require__(19785); /** * Iterates over elements of `collection` and invokes `iteratee` for each element. * The iteratee is invoked with three arguments: (value, index|key, collection). * Iteratee functions may exit iteration early by explicitly returning `false`. * * **Note:** As with other "Collections" methods, objects with a "length" * property are iterated like arrays. To avoid this behavior use `_.forIn` * or `_.forOwn` for object iteration. * * @static * @memberOf _ * @since 0.1.0 * @alias each * @category Collection * @param {Array|Object} collection The collection to iterate over. * @param {Function} [iteratee=_.identity] The function invoked per iteration. * @returns {Array|Object} Returns `collection`. * @see _.forEachRight * @example * * _.forEach([1, 2], function(value) { * console.log(value); * }); * // => Logs `1` then `2`. * * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { * console.log(key); * }); * // => Logs 'a' then 'b' (iteration order is not guaranteed). */ function forEach(collection, iteratee) { var func = isArray(collection) ? arrayEach : baseEach; return func(collection, castFunction(iteratee)); } module.exports = forEach; /***/ }), /***/ 27921: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayMap = __webpack_require__(66070), baseIntersection = __webpack_require__(96638), baseRest = __webpack_require__(1197), castArrayLikeObject = __webpack_require__(60923); /** * Creates an array of unique values that are included in all given arrays * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * for equality comparisons. The order and references of result values are * determined by the first array. * * @static * @memberOf _ * @since 0.1.0 * @category Array * @param {...Array} [arrays] The arrays to inspect. * @returns {Array} Returns the new array of intersecting values. * @example * * _.intersection([2, 1], [2, 3]); * // => [2] */ var intersection = baseRest(function(arrays) { var mapped = arrayMap(arrays, castArrayLikeObject); return (mapped.length && mapped[0] === arrays[0]) ? baseIntersection(mapped) : []; }); module.exports = intersection; /***/ }), /***/ 28054: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayMap = __webpack_require__(66070), baseIntersection = __webpack_require__(96638), baseRest = __webpack_require__(1197), castArrayLikeObject = __webpack_require__(60923), last = __webpack_require__(31159); /** * This method is like `_.intersection` except that it accepts `comparator` * which is invoked to compare elements of `arrays`. The order and references * of result values are determined by the first array. The comparator is * invoked with two arguments: (arrVal, othVal). * * @static * @memberOf _ * @since 4.0.0 * @category Array * @param {...Array} [arrays] The arrays to inspect. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new array of intersecting values. * @example * * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; * * _.intersectionWith(objects, others, _.isEqual); * // => [{ 'x': 1, 'y': 2 }] */ var intersectionWith = baseRest(function(arrays) { var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject); comparator = typeof comparator == 'function' ? comparator : undefined; if (comparator) { mapped.pop(); } return (mapped.length && mapped[0] === arrays[0]) ? baseIntersection(mapped, undefined, comparator) : []; }); module.exports = intersectionWith; /***/ }), /***/ 36468: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var isArrayLike = __webpack_require__(80068), isObjectLike = __webpack_require__(92360); /** * This method is like `_.isArrayLike` except that it also checks if `value` * is an object. * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is an array-like object, * else `false`. * @example * * _.isArrayLikeObject([1, 2, 3]); * // => true * * _.isArrayLikeObject(document.body.children); * // => true * * _.isArrayLikeObject('abc'); * // => false * * _.isArrayLikeObject(_.noop); * // => false */ function isArrayLikeObject(value) { return isObjectLike(value) && isArrayLike(value); } module.exports = isArrayLikeObject; /***/ }), /***/ 3819: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseGetTag = __webpack_require__(99736), isObjectLike = __webpack_require__(92360); /** `Object#toString` result references. */ var boolTag = '[object Boolean]'; /** * Checks if `value` is classified as a boolean primitive or object. * * @static * @memberOf _ * @since 0.1.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. * @example * * _.isBoolean(false); * // => true * * _.isBoolean(null); * // => false */ function isBoolean(value) { return value === true || value === false || (isObjectLike(value) && baseGetTag(value) == boolTag); } module.exports = isBoolean; /***/ }), /***/ 56141: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIsEqual = __webpack_require__(32866); /** * Performs a deep comparison between two values to determine if they are * equivalent. * * **Note:** This method supports comparing arrays, array buffers, booleans, * date objects, error objects, maps, numbers, `Object` objects, regexes, * sets, strings, symbols, and typed arrays. `Object` objects are compared * by their own, not inherited, enumerable properties. Functions and DOM * nodes are compared by strict equality, i.e. `===`. * * @static * @memberOf _ * @since 0.1.0 * @category Lang * @param {*} value The value to compare. * @param {*} other The other value to compare. * @returns {boolean} Returns `true` if the values are equivalent, else `false`. * @example * * var object = { 'a': 1 }; * var other = { 'a': 1 }; * * _.isEqual(object, other); * // => true * * object === other; * // => false */ function isEqual(value, other) { return baseIsEqual(value, other); } module.exports = isEqual; /***/ }), /***/ 65191: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseIsEqual = __webpack_require__(32866); /** * This method is like `_.isEqual` except that it accepts `customizer` which * is invoked to compare values. If `customizer` returns `undefined`, comparisons * are handled by the method instead. The `customizer` is invoked with up to * six arguments: (objValue, othValue [, index|key, object, other, stack]). * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to compare. * @param {*} other The other value to compare. * @param {Function} [customizer] The function to customize comparisons. * @returns {boolean} Returns `true` if the values are equivalent, else `false`. * @example * * function isGreeting(value) { * return /^h(?:i|ello)$/.test(value); * } * * function customizer(objValue, othValue) { * if (isGreeting(objValue) && isGreeting(othValue)) { * return true; * } * } * * var array = ['hello', 'goodbye']; * var other = ['hi', 'goodbye']; * * _.isEqualWith(array, other, customizer); * // => true */ function isEqualWith(value, other, customizer) { customizer = typeof customizer == 'function' ? customizer : undefined; var result = customizer ? customizer(value, other) : undefined; return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result; } module.exports = isEqualWith; /***/ }), /***/ 30644: /***/ ((module) => { /** * Checks if `value` is `null` or `undefined`. * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is nullish, else `false`. * @example * * _.isNil(null); * // => true * * _.isNil(void 0); * // => true * * _.isNil(NaN); * // => false */ function isNil(value) { return value == null; } module.exports = isNil; /***/ }), /***/ 78581: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseGetTag = __webpack_require__(99736), isObjectLike = __webpack_require__(92360); /** `Object#toString` result references. */ var numberTag = '[object Number]'; /** * Checks if `value` is classified as a `Number` primitive or object. * * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are * classified as numbers, use the `_.isFinite` method. * * @static * @memberOf _ * @since 0.1.0 * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a number, else `false`. * @example * * _.isNumber(3); * // => true * * _.isNumber(Number.MIN_VALUE); * // => true * * _.isNumber(Infinity); * // => true * * _.isNumber('3'); * // => false */ function isNumber(value) { return typeof value == 'number' || (isObjectLike(value) && baseGetTag(value) == numberTag); } module.exports = isNumber; /***/ }), /***/ 47206: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseGetTag = __webpack_require__(99736), isArray = __webpack_require__(19785), isObjectLike = __webpack_require__(92360); /** `Object#toString` result references. */ var stringTag = '[object String]'; /** * Checks if `value` is classified as a `String` primitive or object. * * @static * @since 0.1.0 * @memberOf _ * @category Lang * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a string, else `false`. * @example * * _.isString('abc'); * // => true * * _.isString(1); * // => false */ function isString(value) { return typeof value == 'string' || (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); } module.exports = isString; /***/ }), /***/ 15409: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseMerge = __webpack_require__(40015), createAssigner = __webpack_require__(7270); /** * This method is like `_.assign` except that it recursively merges own and * inherited enumerable string keyed properties of source objects into the * destination object. Source properties that resolve to `undefined` are * skipped if a destination value exists. Array and plain object properties * are merged recursively. Other objects and value types are overridden by * assignment. Source objects are applied from left to right. Subsequent * sources overwrite property assignments of previous sources. * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 0.5.0 * @category Object * @param {Object} object The destination object. * @param {...Object} [sources] The source objects. * @returns {Object} Returns `object`. * @example * * var object = { * 'a': [{ 'b': 2 }, { 'd': 4 }] * }; * * var other = { * 'a': [{ 'c': 3 }, { 'e': 5 }] * }; * * _.merge(object, other); * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } */ var merge = createAssigner(function(object, source, srcIndex) { baseMerge(object, source, srcIndex); }); module.exports = merge; /***/ }), /***/ 73952: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseMerge = __webpack_require__(40015), createAssigner = __webpack_require__(7270); /** * This method is like `_.merge` except that it accepts `customizer` which * is invoked to produce the merged values of the destination and source * properties. If `customizer` returns `undefined`, merging is handled by the * method instead. The `customizer` is invoked with six arguments: * (objValue, srcValue, key, object, source, stack). * * **Note:** This method mutates `object`. * * @static * @memberOf _ * @since 4.0.0 * @category Object * @param {Object} object The destination object. * @param {...Object} sources The source objects. * @param {Function} customizer The function to customize assigned values. * @returns {Object} Returns `object`. * @example * * function customizer(objValue, srcValue) { * if (_.isArray(objValue)) { * return objValue.concat(srcValue); * } * } * * var object = { 'a': [1], 'b': [2] }; * var other = { 'a': [3], 'b': [4] }; * * _.mergeWith(object, other, customizer); * // => { 'a': [1, 3], 'b': [2, 4] } */ var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { baseMerge(object, source, srcIndex, customizer); }); module.exports = mergeWith; /***/ }), /***/ 50344: /***/ ((module) => { /** * This method returns `undefined`. * * @static * @memberOf _ * @since 2.3.0 * @category Util * @example * * _.times(2, _.noop); * // => [undefined, undefined] */ function noop() { // No operation performed. } module.exports = noop; /***/ }), /***/ 96001: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseProperty = __webpack_require__(50517), basePropertyDeep = __webpack_require__(10301), isKey = __webpack_require__(40318), toKey = __webpack_require__(37948); /** * Creates a function that returns the value at `path` of a given object. * * @static * @memberOf _ * @since 2.4.0 * @category Util * @param {Array|string} path The path of the property to get. * @returns {Function} Returns the new accessor function. * @example * * var objects = [ * { 'a': { 'b': 2 } }, * { 'a': { 'b': 1 } } * ]; * * _.map(objects, _.property('a.b')); * // => [2, 1] * * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b'); * // => [1, 2] */ function property(path) { return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); } module.exports = property; /***/ }), /***/ 90254: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var basePullAll = __webpack_require__(61933); /** * This method is like `_.pull` except that it accepts an array of values to remove. * * **Note:** Unlike `_.difference`, this method mutates `array`. * * @static * @memberOf _ * @since 4.0.0 * @category Array * @param {Array} array The array to modify. * @param {Array} values The values to remove. * @returns {Array} Returns `array`. * @example * * var array = ['a', 'b', 'c', 'a', 'b', 'c']; * * _.pullAll(array, ['a', 'c']); * console.log(array); * // => ['b', 'b'] */ function pullAll(array, values) { return (array && array.length && values && values.length) ? basePullAll(array, values) : array; } module.exports = pullAll; /***/ }), /***/ 34172: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayReduce = __webpack_require__(6446), baseEach = __webpack_require__(52033), baseIteratee = __webpack_require__(89278), baseReduce = __webpack_require__(19356), isArray = __webpack_require__(19785); /** * Reduces `collection` to a value which is the accumulated result of running * each element in `collection` thru `iteratee`, where each successive * invocation is supplied the return value of the previous. If `accumulator` * is not given, the first element of `collection` is used as the initial * value. The iteratee is invoked with four arguments: * (accumulator, value, index|key, collection). * * Many lodash methods are guarded to work as iteratees for methods like * `_.reduce`, `_.reduceRight`, and `_.transform`. * * The guarded methods are: * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, * and `sortBy` * * @static * @memberOf _ * @since 0.1.0 * @category Collection * @param {Array|Object} collection The collection to iterate over. * @param {Function} [iteratee=_.identity] The function invoked per iteration. * @param {*} [accumulator] The initial value. * @returns {*} Returns the accumulated value. * @see _.reduceRight * @example * * _.reduce([1, 2], function(sum, n) { * return sum + n; * }, 0); * // => 3 * * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { * (result[value] || (result[value] = [])).push(key); * return result; * }, {}); * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) */ function reduce(collection, iteratee, accumulator) { var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3; return func(collection, baseIteratee(iteratee, 4), accumulator, initAccum, baseEach); } module.exports = reduce; /***/ }), /***/ 95099: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseFlatten = __webpack_require__(23545), baseOrderBy = __webpack_require__(98497), baseRest = __webpack_require__(1197), isIterateeCall = __webpack_require__(57535); /** * Creates an array of elements, sorted in ascending order by the results of * running each element in a collection thru each iteratee. This method * performs a stable sort, that is, it preserves the original sort order of * equal elements. The iteratees are invoked with one argument: (value). * * @static * @memberOf _ * @since 0.1.0 * @category Collection * @param {Array|Object} collection The collection to iterate over. * @param {...(Function|Function[])} [iteratees=[_.identity]] * The iteratees to sort by. * @returns {Array} Returns the new sorted array. * @example * * var users = [ * { 'user': 'fred', 'age': 48 }, * { 'user': 'barney', 'age': 36 }, * { 'user': 'fred', 'age': 30 }, * { 'user': 'barney', 'age': 34 } * ]; * * _.sortBy(users, [function(o) { return o.user; }]); * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]] * * _.sortBy(users, ['user', 'age']); * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]] */ var sortBy = baseRest(function(collection, iteratees) { if (collection == null) { return []; } var length = iteratees.length; if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { iteratees = []; } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { iteratees = [iteratees[0]]; } return baseOrderBy(collection, baseFlatten(iteratees, 1), []); }); module.exports = sortBy; /***/ }), /***/ 41571: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseTimes = __webpack_require__(24701), castFunction = __webpack_require__(62079), toInteger = __webpack_require__(47991); /** Used as references for various `Number` constants. */ var MAX_SAFE_INTEGER = 9007199254740991; /** Used as references for the maximum length and index of an array. */ var MAX_ARRAY_LENGTH = 4294967295; /* Built-in method references for those with the same name as other `lodash` methods. */ var nativeMin = Math.min; /** * Invokes the iteratee `n` times, returning an array of the results of * each invocation. The iteratee is invoked with one argument; (index). * * @static * @since 0.1.0 * @memberOf _ * @category Util * @param {number} n The number of times to invoke `iteratee`. * @param {Function} [iteratee=_.identity] The function invoked per iteration. * @returns {Array} Returns the array of results. * @example * * _.times(3, String); * // => ['0', '1', '2'] * * _.times(4, _.constant(0)); * // => [0, 0, 0, 0] */ function times(n, iteratee) { n = toInteger(n); if (n < 1 || n > MAX_SAFE_INTEGER) { return []; } var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH); iteratee = castFunction(iteratee); n -= MAX_ARRAY_LENGTH; var result = baseTimes(length, iteratee); while (++index < n) { iteratee(index); } return result; } module.exports = times; /***/ }), /***/ 94919: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var toNumber = __webpack_require__(91936); /** Used as references for various `Number` constants. */ var INFINITY = 1 / 0, MAX_INTEGER = 1.7976931348623157e+308; /** * Converts `value` to a finite number. * * @static * @memberOf _ * @since 4.12.0 * @category Lang * @param {*} value The value to convert. * @returns {number} Returns the converted number. * @example * * _.toFinite(3.2); * // => 3.2 * * _.toFinite(Number.MIN_VALUE); * // => 5e-324 * * _.toFinite(Infinity); * // => 1.7976931348623157e+308 * * _.toFinite('3.2'); * // => 3.2 */ function toFinite(value) { if (!value) { return value === 0 ? value : 0; } value = toNumber(value); if (value === INFINITY || value === -INFINITY) { var sign = (value < 0 ? -1 : 1); return sign * MAX_INTEGER; } return value === value ? value : 0; } module.exports = toFinite; /***/ }), /***/ 47991: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var toFinite = __webpack_require__(94919); /** * Converts `value` to an integer. * * **Note:** This method is loosely based on * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to convert. * @returns {number} Returns the converted integer. * @example * * _.toInteger(3.2); * // => 3 * * _.toInteger(Number.MIN_VALUE); * // => 0 * * _.toInteger(Infinity); * // => 1.7976931348623157e+308 * * _.toInteger('3.2'); * // => 3 */ function toInteger(value) { var result = toFinite(value), remainder = result % 1; return result === result ? (remainder ? result - remainder : result) : 0; } module.exports = toInteger; /***/ }), /***/ 91936: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseTrim = __webpack_require__(74833), isObject = __webpack_require__(11611), isSymbol = __webpack_require__(55193); /** Used as references for various `Number` constants. */ var NAN = 0 / 0; /** Used to detect bad signed hexadecimal string values. */ var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; /** Used to detect binary string values. */ var reIsBinary = /^0b[01]+$/i; /** Used to detect octal string values. */ var reIsOctal = /^0o[0-7]+$/i; /** Built-in method references without a dependency on `root`. */ var freeParseInt = parseInt; /** * Converts `value` to a number. * * @static * @memberOf _ * @since 4.0.0 * @category Lang * @param {*} value The value to process. * @returns {number} Returns the number. * @example * * _.toNumber(3.2); * // => 3.2 * * _.toNumber(Number.MIN_VALUE); * // => 5e-324 * * _.toNumber(Infinity); * // => Infinity * * _.toNumber('3.2'); * // => 3.2 */ function toNumber(value) { if (typeof value == 'number') { return value; } if (isSymbol(value)) { return NAN; } if (isObject(value)) { var other = typeof value.valueOf == 'function' ? value.valueOf() : value; value = isObject(other) ? (other + '') : other; } if (typeof value != 'string') { return value === 0 ? value : +value; } value = baseTrim(value); var isBinary = reIsBinary.test(value); return (isBinary || reIsOctal.test(value)) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : (reIsBadHex.test(value) ? NAN : +value); } module.exports = toNumber; /***/ }), /***/ 89328: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var copyObject = __webpack_require__(35159), keysIn = __webpack_require__(53893); /** * Converts `value` to a plain object flattening inherited enumerable string * keyed properties of `value` to own properties of the plain object. * * @static * @memberOf _ * @since 3.0.0 * @category Lang * @param {*} value The value to convert. * @returns {Object} Returns the converted plain object. * @example * * function Foo() { * this.b = 2; * } * * Foo.prototype.c = 3; * * _.assign({ 'a': 1 }, new Foo); * // => { 'a': 1, 'b': 2 } * * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); * // => { 'a': 1, 'b': 2, 'c': 3 } */ function toPlainObject(value) { return copyObject(value, keysIn(value)); } module.exports = toPlainObject; /***/ }), /***/ 42673: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var arrayEach = __webpack_require__(80594), baseCreate = __webpack_require__(80158), baseForOwn = __webpack_require__(26194), baseIteratee = __webpack_require__(89278), getPrototype = __webpack_require__(2173), isArray = __webpack_require__(19785), isBuffer = __webpack_require__(43854), isFunction = __webpack_require__(28338), isObject = __webpack_require__(11611), isTypedArray = __webpack_require__(48519); /** * An alternative to `_.reduce`; this method transforms `object` to a new * `accumulator` object which is the result of running each of its own * enumerable string keyed properties thru `iteratee`, with each invocation * potentially mutating the `accumulator` object. If `accumulator` is not * provided, a new object with the same `[[Prototype]]` will be used. The * iteratee is invoked with four arguments: (accumulator, value, key, object). * Iteratee functions may exit iteration early by explicitly returning `false`. * * @static * @memberOf _ * @since 1.3.0 * @category Object * @param {Object} object The object to iterate over. * @param {Function} [iteratee=_.identity] The function invoked per iteration. * @param {*} [accumulator] The custom accumulator value. * @returns {*} Returns the accumulated value. * @example * * _.transform([2, 3, 4], function(result, n) { * result.push(n *= n); * return n % 2 == 0; * }, []); * // => [4, 9] * * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { * (result[value] || (result[value] = [])).push(key); * }, {}); * // => { '1': ['a', 'c'], '2': ['b'] } */ function transform(object, iteratee, accumulator) { var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object); iteratee = baseIteratee(iteratee, 4); if (accumulator == null) { var Ctor = object && object.constructor; if (isArrLike) { accumulator = isArr ? new Ctor : []; } else if (isObject(object)) { accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; } else { accumulator = {}; } } (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) { return iteratee(accumulator, value, index, object); }); return accumulator; } module.exports = transform; /***/ }), /***/ 68946: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseFlatten = __webpack_require__(23545), baseRest = __webpack_require__(1197), baseUniq = __webpack_require__(92198), isArrayLikeObject = __webpack_require__(36468); /** * Creates an array of unique values, in order, from all given arrays using * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * for equality comparisons. * * @static * @memberOf _ * @since 0.1.0 * @category Array * @param {...Array} [arrays] The arrays to inspect. * @returns {Array} Returns the new array of combined values. * @example * * _.union([2], [1, 2]); * // => [2, 1] */ var union = baseRest(function(arrays) { return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); }); module.exports = union; /***/ }), /***/ 83766: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseUniq = __webpack_require__(92198); /** * Creates a duplicate-free version of an array, using * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * for equality comparisons, in which only the first occurrence of each element * is kept. The order of result values is determined by the order they occur * in the array. * * @static * @memberOf _ * @since 0.1.0 * @category Array * @param {Array} array The array to inspect. * @returns {Array} Returns the new duplicate free array. * @example * * _.uniq([2, 1, 2]); * // => [2, 1] */ function uniq(array) { return (array && array.length) ? baseUniq(array) : []; } module.exports = uniq; /***/ }), /***/ 52929: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseUniq = __webpack_require__(92198); /** * This method is like `_.uniq` except that it accepts `comparator` which * is invoked to compare elements of `array`. The order of result values is * determined by the order they occur in the array.The comparator is invoked * with two arguments: (arrVal, othVal). * * @static * @memberOf _ * @since 4.0.0 * @category Array * @param {Array} array The array to inspect. * @param {Function} [comparator] The comparator invoked per element. * @returns {Array} Returns the new duplicate free array. * @example * * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; * * _.uniqWith(objects, _.isEqual); * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] */ function uniqWith(array, comparator) { comparator = typeof comparator == 'function' ? comparator : undefined; return (array && array.length) ? baseUniq(array, undefined, comparator) : []; } module.exports = uniqWith; /***/ }), /***/ 81889: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var baseDifference = __webpack_require__(11005), baseRest = __webpack_require__(1197), isArrayLikeObject = __webpack_require__(36468); /** * Creates an array excluding all given values using * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * for equality comparisons. * * **Note:** Unlike `_.pull`, this method returns a new array. * * @static * @memberOf _ * @since 0.1.0 * @category Array * @param {Array} array The array to inspect. * @param {...*} [values] The values to exclude. * @returns {Array} Returns the new array of filtered values. * @see _.difference, _.xor * @example * * _.without([2, 1, 2, 3], 1, 2); * // => [3] */ var without = baseRest(function(array, values) { return isArrayLikeObject(array) ? baseDifference(array, values) : []; }); module.exports = without; /***/ }), /***/ 58702: /***/ ((__unused_webpack_module, exports) => { "use strict"; /** * @license React * react-is.production.min.js * * Copyright (c) Facebook, Inc. and its affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ var b=Symbol.for("react.element"),c=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),e=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.for("react.provider"),h=Symbol.for("react.context"),k=Symbol.for("react.server_context"),l=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),n=Symbol.for("react.suspense_list"),p=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),t=Symbol.for("react.offscreen"),u;u=Symbol.for("react.module.reference"); function v(a){if("object"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m; exports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p}; exports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n}; exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||"object"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v; /***/ }), /***/ 19185: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { "use strict"; if (true) { module.exports = __webpack_require__(58702); } else {} /***/ }), /***/ 17604: /***/ ((module) => { "use strict"; /** * FUNCTION: isArray( value ) * Validates if a value is an array. * * @param {*} value - value to be validated * @returns {Boolean} boolean indicating whether value is an array */ function isArray( value ) { return Object.prototype.toString.call( value ) === '[object Array]'; } // end FUNCTION isArray() // EXPORTS // module.exports = Array.isArray || isArray; /***/ }), /***/ 86401: /***/ ((module) => { "use strict"; /** * * VALIDATE: function * * * DESCRIPTION: * - Validates if a value is a function. * * * NOTES: * [1] * * * TODO: * [1] * * * LICENSE: * MIT * * Copyright (c) 2014. Athan Reines. * * * AUTHOR: * Athan Reines. kgryte@gmail.com. 2014. * */ /** * FUNCTION: isFunction( value ) * Validates if a value is a function. * * @param {*} value - value to be validated * @returns {Boolean} boolean indicating whether value is a function */ function isFunction( value ) { return ( typeof value === 'function' ); } // end FUNCTION isFunction() // EXPORTS // module.exports = isFunction; /***/ }), /***/ 9333: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { "use strict"; /** * * VALIDATE: integer-array * * * DESCRIPTION: * - Validates if a value is an integer array. * * * NOTES: * [1] * * * TODO: * [1] * * * LICENSE: * MIT * * Copyright (c) 2015. Athan Reines. * * * AUTHOR: * Athan Reines. kgryte@gmail.com. 2015. * */ // MODULES // var isArray = __webpack_require__( 17604 ), isInteger = __webpack_require__( 50459 ); // IS INTEGER ARRAY // /** * FUNCTION: isIntegerArray( value ) * Validates if a value is an integer array. * * @param {*} value - value to be validated * @returns {Boolean} boolean indicating if a value is an integer array */ function isIntegerArray( value ) { var len; if ( !isArray( value ) ) { return false; } len = value.length; if ( !len ) { return false; } for ( var i = 0; i < len; i++ ) { if ( !isInteger( value[i] ) ) { return false; } } return true; } // end FUNCTION isIntegerArray() // EXPORTS // module.exports = isIntegerArray; /***/ }), /***/ 50459: /***/ ((module, __unused_webpack_exports, __webpack_require__) => { "use strict"; /** * * VALIDATE: integer * * * DESCRIPTION: * - Validates if a value is an integer. * * * NOTES: * [1] * * * TODO: * [1] * * * LICENSE: * MIT * * Copyright (c) 2014. Athan Reines. * * * AUTHOR: * Athan Reines. kgryte@gmail.com. 2014. * */ // MODULES // var isNumber = __webpack_require__( 7365 ); // ISINTEGER // /** * FUNCTION: isInteger( value ) * Validates if a value is an integer. * * @param {Number} value - value to be validated * @returns {Boolean} boolean indicating whether value is an integer */ function isInteger( value ) { return isNumber( value ) && value%1 === 0; } // end FUNCTION isInteger() // EXPORTS // module.exports = isInteger; /***/ }), /***/ 7365: /***/ ((module) => { "use strict"; /** * * VALIDATE: number * * * DESCRIPTION: * - Validates if a value is a number. * * * NOTES: * [1] * * * TODO: * [1] * * * LICENSE: * MIT * * Copyright (c) 2014. Athan Reines. * * * AUTHOR: * Athan Reines. kgryte@gmail.com. 2014. * */ /** * FUNCTION: isNumber( value ) * Validates if a value is a number. * * @param {*} value - value to be validated * @returns {Boolean} boolean indicating whether value is a number */ function isNumber( value ) { return ( typeof value === 'number' || Object.prototype.toString.call( value ) === '[object Number]' ) && value.valueOf() === value.valueOf(); } // end FUNCTION isNumber() // EXPORTS // module.exports = isNumber; /***/ }) }]); //# sourceMappingURL=7995.45be6443b704da1daafc.js.map?v=45be6443b704da1daafc