{"version":3,"file":"module.js","mappings":"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","sources":["webpack://mssql/webpack/runtime/async module","webpack://mssql/webpack/runtime/create fake namespace object","webpack://mssql/webpack/runtime/load script","webpack://mssql/../../../../../node_modules/lodash/_basePick.js","webpack://mssql/../../../../../node_modules/lodash/_getAllKeys.js","webpack://mssql/../../../../../node_modules/spel2js/dist/spel2js.js","webpack://mssql/../../../../../node_modules/lodash/isMap.js","webpack://mssql/external amd \"react-redux\"","webpack://mssql/external amd \"i18next\"","webpack://mssql/../../../../../node_modules/lodash/_setCacheAdd.js","webpack://mssql/../../../../../node_modules/lodash/_assignMergeValue.js","webpack://mssql/../../../../../node_modules/lodash/_stringToPath.js","webpack://mssql/../../../../../node_modules/lodash/_baseUnary.js","webpack://mssql/../../../../../node_modules/lodash/_baseSlice.js","webpack://mssql/../../../../../node_modules/lodash/pickBy.js","webpack://mssql/../../../../../node_modules/sqlstring/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorValues.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regenerator.js","webpack://mssql/../../../../../node_modules/lodash/_shortOut.js","webpack://mssql/../../../../../node_modules/json-logic-js/logic.js","webpack://mssql/../../../../../node_modules/lodash/_initCloneArray.js","webpack://mssql/../../../../../node_modules/lodash/_getMatchData.js","webpack://mssql/../../../../../node_modules/lodash/isLength.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsEqual.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/QueryEditor/types.js","webpack://mssql/../../../../../node_modules/void-elements/index.js","webpack://mssql/../../../../../node_modules/lodash/_baseProperty.js","webpack://mssql/../../../../../packages/grafana-i18n/src/languages.ts","webpack://mssql/../../../../../node_modules/lodash/_overRest.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js","webpack://mssql/./MSSqlQueryModel.ts","webpack://mssql/./sqlCompletionProvider.ts","webpack://mssql/./sqlUtil.ts","webpack://mssql/./datasource.ts","webpack://mssql/./MSSqlMetaQuery.ts","webpack://mssql/../../../../../node_modules/lodash/_mapCacheSet.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/ConfigEditor/ConfigSection/ConfigSubSection.js","webpack://mssql/../../../../../node_modules/lodash/_getAllKeysIn.js","webpack://mssql/../../../../../node_modules/lodash/_equalByTag.js","webpack://mssql/../../../../../node_modules/lodash/identity.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/tokenTypes.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/inherits.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/immutable/dist/immutable.es.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/uuid.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/stuff.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/configUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/treeUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/defaultUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/ruleUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/queryBuilder.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/config/default.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/jsonLogicUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/config/funcs.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/configSerialize.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/configMemo.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/configExtend.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/jsonLogic.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/mongoUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/mongoDb.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/spelUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/export.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/sql.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/spel.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/queryString.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/export/elasticSearch.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/tree.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/toArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/jsonLogic.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/i18n/validation/translations.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/i18n/validation/constains.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/i18n/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/getNewValueForFieldOp.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/listValues.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/validation.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/funcUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/defaultRuleUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/utils/autocomplete.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/spel/conv.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/spel/builder.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/spel/postprocess.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/spel/convert.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/import/spel/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/config/ctx.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/config/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/stores/constants.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/stores/tree.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/actions/tree.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/actions/group.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/actions/rule.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/esm/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/stores/tree.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/stores/context.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/stores/constants.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/actions/drag.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/actions/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/utils/stuff.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/utils/validationMemo.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/utils/reactUtils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/Query.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/QueryContainer.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/extends.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/containers/RuleContainer.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/containers/SortableContainer.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/containers/Draggable.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/Operator.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/utils.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/OperatorWrapper.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/Field.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/FuncSelect.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/WidgetFactory.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/Widget.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/FuncWidget.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/FieldWrapper.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/OperatorOptions.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/Rule.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/containers/GroupContainer.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/GroupActions.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/Group.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/get.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/esm/superPropBase.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/RuleGroupActions.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/RuleGroup.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/RuleGroupExtActions.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/RuleGroupExt.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/SwitchGroupActions.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/SwitchGroup.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/CaseGroup.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/item/Item.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/Builder.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/rule/ValueField.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaBoolean.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaText.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaTextArea.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaDate.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaTime.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaDateTime.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaMultiSelect.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaSelect.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaNumber.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/value/VanillaSlider.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaFieldSelect.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaConjs.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaButton.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaIcon.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaButtonGroup.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaValueSources.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/VanillaSwitch.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/core/vanillaConfirm.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/widgets/vanilla/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/components/operators/Proximity.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/config/index.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/hooks/useListValuesAutocomplete.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/esm/utils/index.js","webpack://mssql/../../../../../node_modules/lodash/_listCacheHas.js","webpack://mssql/../../../../../node_modules/lodash/_hashSet.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorDefine.js","webpack://mssql/../../../../../node_modules/lodash/_baseRest.js","webpack://mssql/../../../../../node_modules/lodash/toFinite.js","webpack://mssql/../../../../../node_modules/lodash/_initCloneObject.js","webpack://mssql/../../../../../node_modules/lodash/_copyArray.js","webpack://mssql/external amd \"rxjs\"","webpack://mssql/../../../../../node_modules/lodash/_trimmedEndIndex.js","webpack://mssql/../../../../../node_modules/lodash/_baseValues.js","webpack://mssql/../../../../../node_modules/lodash/includes.js","webpack://mssql/external amd \"module\"","webpack://mssql/../../../../../node_modules/lodash/_initCloneByTag.js","webpack://mssql/../../../../../node_modules/lodash/_baseFlatten.js","webpack://mssql/../../../../../node_modules/lodash/_arrayMap.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/languages/StandardSqlFormatter.js","webpack://mssql/../../../../../node_modules/lodash/_cacheHas.js","webpack://mssql/../../../../../node_modules/lodash/_copySymbolsIn.js","webpack://mssql/../../../../../node_modules/lodash/_hasPath.js","webpack://mssql/../../../../../node_modules/lodash/_MapCache.js","webpack://mssql/../../../../../node_modules/lodash/mapValues.js","webpack://mssql/../../../../../node_modules/lodash/values.js","webpack://mssql/../../../../../node_modules/lodash/_copySymbols.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/typeof.js","webpack://mssql/../../../../../packages/grafana-sql/src/expressions.ts","webpack://mssql/../../../../../node_modules/lodash/_mapCacheGet.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js","webpack://mssql/../../../../../node_modules/lodash/isFunction.js","webpack://mssql/../../../../../node_modules/lodash/_apply.js","webpack://mssql/../../../../../node_modules/lodash/_nodeUtil.js","webpack://mssql/../../../../../node_modules/lodash/_ListCache.js","webpack://mssql/external amd \"@grafana/ui\"","webpack://mssql/../../../../../node_modules/lodash/_customOmitClone.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsMap.js","webpack://mssql/../../../../../node_modules/lodash/_getNative.js","webpack://mssql/../../../../../node_modules/lodash/now.js","webpack://mssql/../../../../../node_modules/lodash/range.js","webpack://mssql/../../../../../node_modules/lodash/_isStrictComparable.js","webpack://mssql/../../../../../node_modules/lodash/_castPath.js","webpack://mssql/../../../../../node_modules/lodash/_baseAssignValue.js","webpack://mssql/external amd \"moment\"","webpack://mssql/../../../../../node_modules/lodash/_parent.js","webpack://mssql/../../../../../node_modules/lodash/_coreJsData.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/Indentation.js","webpack://mssql/../../../../../node_modules/classnames/index.js","webpack://mssql/../../../../../node_modules/lodash/_Symbol.js","webpack://mssql/../../../../../node_modules/lodash/_hashHas.js","webpack://mssql/../../../../../node_modules/lodash/_nativeKeysIn.js","webpack://mssql/../../../../../node_modules/lodash/_baseGet.js","webpack://mssql/../../../../../node_modules/lodash/_baseTimes.js","webpack://mssql/../../../../../node_modules/lodash/mergeWith.js","webpack://mssql/../../../../../node_modules/lodash/_Set.js","webpack://mssql/../../../../../node_modules/lodash/_memoizeCapped.js","webpack://mssql/../../../../../node_modules/lodash/_getRawTag.js","webpack://mssql/../../../../../node_modules/i18next-browser-languagedetector/dist/esm/i18nextBrowserLanguageDetector.js","webpack://mssql/../../../../../node_modules/html-parse-stringify/dist/html-parse-stringify.module.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/utils.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/unescape.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/defaults.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/i18nInstance.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/TransWithoutContext.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/initReactI18next.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/context.js","webpack://mssql/../../../../../node_modules/react-i18next/dist/es/Trans.js","webpack://mssql/../../../../../packages/grafana-i18n/src/i18n.tsx","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/typeof.js","webpack://mssql/external amd \"rxjs/operators\"","webpack://mssql/../../../../../node_modules/lodash/_baseIsArguments.js","webpack://mssql/../../../../../node_modules/lodash/_cloneDataView.js","webpack://mssql/../../../../../node_modules/lodash/_baseCreate.js","webpack://mssql/../../../../../packages/grafana-sql/src/types.ts","webpack://mssql/../../../../../node_modules/lodash/toString.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/Tokenizer.js","webpack://mssql/../../../../../node_modules/sqlstring/lib/SqlString.js","webpack://mssql/external amd \"lodash\"","webpack://mssql/../../../../../node_modules/lodash/_baseIteratee.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/SQLEditor/standardSql/macros.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/SQLEditor/standardSql/standardSQLCompletionItemProvider.js","webpack://mssql/../../../../../node_modules/lodash/_isMasked.js","webpack://mssql/../../../../../node_modules/lodash/memoize.js","webpack://mssql/../../../../../node_modules/lodash/_baseFindIndex.js","webpack://mssql/../../../../../node_modules/lodash/_equalObjects.js","webpack://mssql/../../../../../node_modules/lodash/_assocIndexOf.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/OverloadYield.js","webpack://mssql/../../../../../packages/grafana-sql/src/utils/sql.utils.ts","webpack://mssql/../../../../../node_modules/clone/clone.js","webpack://mssql/../../../../../node_modules/lodash/startsWith.js","webpack://mssql/../../../../../node_modules/lodash/_Uint8Array.js","webpack://mssql/../../../../../node_modules/lodash/_baseHasIn.js","webpack://mssql/../../../../../node_modules/lodash/_isIterateeCall.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js","webpack://mssql/../../../../../node_modules/lodash/toNumber.js","webpack://mssql/../../../../../node_modules/lodash/_setCacheHas.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/OverloadYield.js","webpack://mssql/../../../../../node_modules/lodash/_getMapData.js","webpack://mssql/../../../../../node_modules/lodash/_baseSet.js","webpack://mssql/../../../../../node_modules/lodash/_toSource.js","webpack://mssql/../../../../../node_modules/lodash/keys.js","webpack://mssql/../../../../../node_modules/lodash/_baseRepeat.js","webpack://mssql/./module.ts","webpack://mssql/../../../../../node_modules/lodash/hasIn.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://mssql/../../../../../packages/grafana-sql/src/components/configuration/NumberInput.tsx","webpack://mssql/../../../../../node_modules/lodash/_stackDelete.js","webpack://mssql/../../../../../node_modules/lodash/isBuffer.js","webpack://mssql/../../../../../node_modules/lodash/_listCacheDelete.js","webpack://mssql/../../../../../node_modules/lodash/_safeGet.js","webpack://mssql/../../../../../node_modules/lodash/merge.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsNative.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/languages/Db2Formatter.js","webpack://mssql/../../../../../node_modules/lodash/_baseSetToString.js","webpack://mssql/../../../../../node_modules/lodash/_baseMatchesProperty.js","webpack://mssql/../../../../../packages/grafana-sql/src/utils/formatSQL.ts","webpack://mssql/../../../../../node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorKeys.js","webpack://mssql/../../../../../node_modules/lodash/_listCacheSet.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/ConfigEditor/DataSourceDescription.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/ConfigEditor/ConfigSection/ConfigSection.js","webpack://mssql/../../../../../node_modules/react-use/esm/useEffectOnce.js","webpack://mssql/../../../../../node_modules/@grafana/azure-sdk/dist/esm/clouds.js","webpack://mssql/../../../../../node_modules/@grafana/azure-sdk/dist/esm/credentials/AzureCredentials.js","webpack://mssql/../../../../../node_modules/@grafana/azure-sdk/dist/esm/credentials/AzureCredentialsConfig.js","webpack://mssql/../../../../../node_modules/@grafana/azure-sdk/dist/esm/resources/ResourceTypes.js","webpack://mssql/./azureauth/AzureCredentialsConfig.ts","webpack://mssql/./azureauth/AzureCredentialsForm.tsx","webpack://mssql/./azureauth/AzureAuthSettings.tsx","webpack://mssql/./types.ts","webpack://mssql/./configuration/Kerberos.tsx","webpack://mssql/./configuration/ConfigurationEditor.tsx","webpack://mssql/../../../../../node_modules/lodash/_copyObject.js","webpack://mssql/../../../../../node_modules/lodash/_hashGet.js","webpack://mssql/../../../../../node_modules/lodash/_stackGet.js","webpack://mssql/../../../../../node_modules/prop-types/factoryWithThrowingShims.js","webpack://mssql/../../../../../node_modules/lodash/_equalArrays.js","webpack://mssql/../../../../../node_modules/lodash/_Hash.js","webpack://mssql/../../../../../node_modules/lodash/_baseAssign.js","webpack://mssql/../../../../../node_modules/lodash/isArray.js","webpack://mssql/../../../../../node_modules/lodash/_isFlattenable.js","webpack://mssql/../../../../../node_modules/lodash/_stackClear.js","webpack://mssql/../../../../../node_modules/lodash/isTypedArray.js","webpack://mssql/../../../../../node_modules/lodash/_listCacheGet.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorKeys.js","webpack://mssql/../../../../../node_modules/lodash/toPlainObject.js","webpack://mssql/../../../../../node_modules/lodash/isArguments.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsSet.js","webpack://mssql/../../../../../node_modules/lodash/isPlainObject.js","webpack://mssql/../../../../../node_modules/lodash/_getValue.js","webpack://mssql/../../../../../node_modules/lodash/_hashDelete.js","webpack://mssql/../../../../../node_modules/lodash/_basePropertyDeep.js","webpack://mssql/../../../../../node_modules/lodash/_Map.js","webpack://mssql/../../../../../node_modules/lodash/_baseForOwn.js","webpack://mssql/../../../../../node_modules/lodash/_hashClear.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/regenerator/index.js","webpack://mssql/../../../../../node_modules/lodash/get.js","webpack://mssql/../../../../../node_modules/lodash/_baseClamp.js","webpack://mssql/../../../../../node_modules/lodash/toInteger.js","webpack://mssql/../../../../../node_modules/lodash/_isPrototype.js","webpack://mssql/../../../../../node_modules/lodash/_stackSet.js","webpack://mssql/../../../../../node_modules/lodash/_createBaseFor.js","webpack://mssql/../../../../../packages/grafana-sql/src/defaults.ts","webpack://mssql/../../../../../node_modules/lodash/_DataView.js","webpack://mssql/../../../../../node_modules/lodash/_strictIndexOf.js","webpack://mssql/external amd \"react\"","webpack://mssql/../../../../../node_modules/lodash/keysIn.js","webpack://mssql/../../../../../node_modules/lodash/_getTag.js","webpack://mssql/../../../../../node_modules/lodash/_baseFor.js","webpack://mssql/external amd \"@emotion/css\"","webpack://mssql/../../../../../node_modules/lodash/_setToArray.js","webpack://mssql/../../../../../node_modules/uuid/dist/esm-browser/native.js","webpack://mssql/../../../../../node_modules/uuid/dist/esm-browser/rng.js","webpack://mssql/../../../../../node_modules/uuid/dist/esm-browser/stringify.js","webpack://mssql/../../../../../node_modules/uuid/dist/esm-browser/v4.js","webpack://mssql/../../../../../node_modules/lodash/_freeGlobal.js","webpack://mssql/../../../../../node_modules/lodash/_isKey.js","webpack://mssql/../../../../../node_modules/lodash/_mapCacheClear.js","webpack://mssql/../../../../../node_modules/lodash/_Promise.js","webpack://mssql/../../../../../node_modules/lodash/eq.js","webpack://mssql/../../../../../node_modules/lodash/_mapCacheHas.js","webpack://mssql/../../../../../node_modules/lodash/_arrayEach.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorAsync.js","webpack://mssql/../../../../../node_modules/lodash/_baseKeys.js","webpack://mssql/../../../../../node_modules/lodash/constant.js","webpack://mssql/../../../../../node_modules/lodash/_baseClone.js","webpack://mssql/../../../../../node_modules/lodash/_getSymbols.js","webpack://mssql/../../../../../node_modules/lodash/_getPrototype.js","webpack://mssql/../../../../../node_modules/lodash/_isIndex.js","webpack://mssql/../../../../../node_modules/lodash/property.js","webpack://mssql/../../../../../node_modules/lodash/_baseUnset.js","webpack://mssql/../../../../../node_modules/lodash/_arrayLikeKeys.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/ConfigEditor/ConfigSection/GenericConfigSection.js","webpack://mssql/../../../../../node_modules/lodash/_stackHas.js","webpack://mssql/../../../../../node_modules/lodash/_cloneRegExp.js","webpack://mssql/./CheatSheet.tsx","webpack://mssql/../../../../../node_modules/lodash/_cloneSymbol.js","webpack://mssql/../../../../../node_modules/lodash/_mapCacheDelete.js","webpack://mssql/../../../../../node_modules/lodash/omit.js","webpack://mssql/../../../../../node_modules/prop-types/index.js","webpack://mssql/../../../../../node_modules/lodash/isArrayLike.js","webpack://mssql/../../../../../node_modules/lodash/_objectToString.js","webpack://mssql/../../../../../node_modules/lodash/_baseTrim.js","webpack://mssql/../../../../../node_modules/lodash/_setToString.js","webpack://mssql/../../../../../node_modules/lodash/isSymbol.js","webpack://mssql/../../../../../node_modules/lodash/_matchesStrictComparable.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/sqlFormatter.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorValues.js","webpack://mssql/external amd \"redux\"","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://mssql/../../../../../node_modules/lodash/_listCacheClear.js","webpack://mssql/../../../../../node_modules/lodash/_cloneArrayBuffer.js","webpack://mssql/external amd \"@grafana/data\"","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regeneratorAsync.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsMatch.js","webpack://mssql/../../../../../node_modules/lodash/_baseAssignIn.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/languages/PlSqlFormatter.js","webpack://mssql/../../../../../node_modules/lodash/_cloneTypedArray.js","webpack://mssql/../../../../../node_modules/lodash/isArrayLikeObject.js","webpack://mssql/../../../../../node_modules/lodash/isEmpty.js","webpack://mssql/../../../../../node_modules/lodash/_nativeCreate.js","webpack://mssql/../../../../../node_modules/react/cjs/react-jsx-runtime.production.min.js","webpack://mssql/../../../../../node_modules/@grafana/plugin-ui/dist/esm/components/SQLEditor/types.js","webpack://mssql/../../../../../node_modules/lodash/_baseMergeDeep.js","webpack://mssql/../../../../../node_modules/lodash/_assignValue.js","webpack://mssql/../../../../../node_modules/lodash/_WeakMap.js","webpack://mssql/../../../../../node_modules/lodash/_toKey.js","webpack://mssql/../../../../../node_modules/lodash/_arrayPush.js","webpack://mssql/../../../../../node_modules/lodash/_baseMatches.js","webpack://mssql/../../../../../node_modules/lodash/_SetCache.js","webpack://mssql/../../../../../packages/grafana-sql/src/locales/ lazy ^\\.\\/.*\\/grafana\\-sql\\.json$ namespace object","webpack://mssql/../../../../../node_modules/lodash/_overArg.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/core/node_modules/@babel/runtime/helpers/regenerator.js","webpack://mssql/../../../../../node_modules/lodash/_baseGetAllKeys.js","webpack://mssql/../../../../../node_modules/lodash/_getSymbolsIn.js","webpack://mssql/../../../../../node_modules/lodash/escapeRegExp.js","webpack://mssql/../../../../../node_modules/lodash/_flatRest.js","webpack://mssql/external amd \"@grafana/runtime\"","webpack://mssql/../../../../../node_modules/lodash/_Stack.js","webpack://mssql/../../../../../node_modules/lodash/_createRange.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/helpers/regeneratorDefine.js","webpack://mssql/../../../../../node_modules/lodash/isSet.js","webpack://mssql/../../../../../node_modules/lodash/stubArray.js","webpack://mssql/../../../../../node_modules/lodash/pick.js","webpack://mssql/../../../../../node_modules/lodash/last.js","webpack://mssql/../../../../../node_modules/lodash/isString.js","webpack://mssql/../../../../../packages/grafana-sql/src/constants.ts","webpack://mssql/../../../../../packages/grafana-sql/src/ResponseParser.ts","webpack://mssql/../../../../../packages/grafana-sql/src/components/QueryEditorLazy.tsx","webpack://mssql/../../../../../packages/grafana-sql/src/utils/migration.ts","webpack://mssql/../../../../../packages/grafana-sql/src/datasource/SqlDatasource.ts","webpack://mssql/../../../../../packages/grafana-sql/src/components/configuration/MaxLifetimeField.tsx","webpack://mssql/../../../../../packages/grafana-sql/src/components/configuration/MaxOpenConnectionsField.tsx","webpack://mssql/../../../../../packages/grafana-sql/src/components/configuration/ConnectionLimits.tsx","webpack://mssql/../../../../../packages/grafana-sql/src/utils/logging.ts","webpack://mssql/../../../../../packages/grafana-sql/src/components/configuration/useMigrateDatabaseFields.ts","webpack://mssql/../../../../../packages/grafana-sql/src/loadResources.ts","webpack://mssql/../../../../../node_modules/lodash/_baseIsNaN.js","webpack://mssql/../../../../../node_modules/lodash/_cloneBuffer.js","webpack://mssql/../../../../../node_modules/lodash/_baseGetTag.js","webpack://mssql/../../../../../node_modules/lodash/_baseMerge.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsEqualDeep.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/InlineBlock.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/Formatter.js","webpack://mssql/../../../../../node_modules/lodash/_isKeyable.js","webpack://mssql/../../../../../node_modules/lodash/flatten.js","webpack://mssql/../../../../../node_modules/lodash/_arraySome.js","webpack://mssql/../../../../../node_modules/lodash/stubFalse.js","webpack://mssql/../../../../../node_modules/lodash/_baseRange.js","webpack://mssql/../../../../../node_modules/lodash/_arrayFilter.js","webpack://mssql/../../../../../node_modules/lodash/_baseKeysIn.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/core/Params.js","webpack://mssql/../../../../../node_modules/sql-formatter-plus/lib/languages/N1qlFormatter.js","webpack://mssql/../../../../../node_modules/lodash/_nativeKeys.js","webpack://mssql/../../../../../node_modules/lodash/isObjectLike.js","webpack://mssql/../../../../../node_modules/@react-awesome-query-builder/ui/node_modules/@babel/runtime/regenerator/index.js","webpack://mssql/../../../../../node_modules/lodash/_createAssigner.js","webpack://mssql/../../../../../node_modules/lodash/debounce.js","webpack://mssql/../../../../../node_modules/lodash/_baseIndexOf.js","webpack://mssql/../../../../../packages/grafana-i18n/src/constants.ts","webpack://mssql/../../../../../node_modules/lodash/_defineProperty.js","webpack://mssql/../../../../../node_modules/lodash/_baseIsTypedArray.js","webpack://mssql/../../../../../node_modules/react/jsx-runtime.js","webpack://mssql/../../../../../node_modules/lodash/_baseToString.js","webpack://mssql/../../../../../node_modules/lodash/isObject.js","webpack://mssql/./node_modules/grafana-public-path.js","webpack://mssql/../../../../../node_modules/lodash/_mapToArray.js","webpack://mssql/../../../../../node_modules/lodash/repeat.js","webpack://mssql/../../../../../node_modules/lodash/_basePickBy.js","webpack://mssql/../../../../../node_modules/lodash/_root.js","webpack://mssql/webpack/bootstrap","webpack://mssql/webpack/runtime/compat get default export","webpack://mssql/webpack/runtime/define property getters","webpack://mssql/webpack/runtime/ensure chunk","webpack://mssql/webpack/runtime/get javascript chunk filename","webpack://mssql/webpack/runtime/global","webpack://mssql/webpack/runtime/hasOwnProperty shorthand","webpack://mssql/webpack/runtime/make namespace object","webpack://mssql/webpack/runtime/node module decorator","webpack://mssql/webpack/runtime/publicPath","webpack://mssql/webpack/runtime/jsonp chunk loading","webpack://mssql/webpack/startup"],"sourcesContent":["var hasSymbol = typeof Symbol === \"function\";\nvar webpackQueues = hasSymbol ? Symbol(\"webpack queues\") : \"__webpack_queues__\";\nvar webpackExports = hasSymbol ? Symbol(\"webpack exports\") : \"__webpack_exports__\";\nvar webpackError = hasSymbol ? Symbol(\"webpack error\") : \"__webpack_error__\";\n\n\nvar resolveQueue = (queue) => {\n\tif(queue && queue.d < 1) {\n\t\tqueue.d = 1;\n\t\tqueue.forEach((fn) => (fn.r--));\n\t\tqueue.forEach((fn) => (fn.r-- ? fn.r++ : fn()));\n\t}\n}\nvar wrapDeps = (deps) => (deps.map((dep) => {\n\tif(dep !== null && typeof dep === \"object\") {\n\n\t\tif(dep[webpackQueues]) return dep;\n\t\tif(dep.then) {\n\t\t\tvar queue = [];\n\t\t\tqueue.d = 0;\n\t\t\tdep.then((r) => {\n\t\t\t\tobj[webpackExports] = r;\n\t\t\t\tresolveQueue(queue);\n\t\t\t}, (e) => {\n\t\t\t\tobj[webpackError] = e;\n\t\t\t\tresolveQueue(queue);\n\t\t\t});\n\t\t\tvar obj = {};\n\n\t\t\tobj[webpackQueues] = (fn) => (fn(queue));\n\t\t\treturn obj;\n\t\t}\n\t}\n\tvar ret = {};\n\tret[webpackQueues] = x => {};\n\tret[webpackExports] = dep;\n\treturn ret;\n}));\n__webpack_require__.a = (module, body, hasAwait) => {\n\tvar queue;\n\thasAwait && ((queue = []).d = -1);\n\tvar depQueues = new Set();\n\tvar exports = module.exports;\n\tvar currentDeps;\n\tvar outerResolve;\n\tvar reject;\n\tvar promise = new Promise((resolve, rej) => {\n\t\treject = rej;\n\t\touterResolve = resolve;\n\t});\n\tpromise[webpackExports] = exports;\n\tpromise[webpackQueues] = (fn) => (queue && fn(queue), depQueues.forEach(fn), promise[\"catch\"](x => {}));\n\tmodule.exports = promise;\n\tvar handle = (deps) => {\n\t\tcurrentDeps = wrapDeps(deps);\n\t\tvar fn;\n\t\tvar getResult = () => (currentDeps.map((d) => {\n\n\t\t\tif(d[webpackError]) throw d[webpackError];\n\t\t\treturn d[webpackExports];\n\t\t}))\n\t\tvar promise = new Promise((resolve) => {\n\t\t\tfn = () => (resolve(getResult));\n\t\t\tfn.r = 0;\n\t\t\tvar fnQueue = (q) => (q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn))));\n\t\t\tcurrentDeps.map((dep) => (dep[webpackQueues](fnQueue)));\n\t\t});\n\t\treturn fn.r ? promise : getResult();\n\t}\n\tvar done = (err) => ((err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue))\n\tbody(handle, done);\n\tqueue && queue.d < 0 && (queue.d = 0);\n};","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"mssql:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","var basePickBy = require('./_basePickBy'),\n hasIn = require('./hasIn');\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, paths) {\n return basePickBy(object, paths, function(value, path) {\n return hasIn(object, path);\n });\n}\n\nmodule.exports = basePick;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n getSymbols = require('./_getSymbols'),\n keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n","/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"spel2js\"] = factory();\n\telse\n\t\troot[\"spel2js\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 3);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The common supertype of all AST nodes in a parsed Spring Expression Language\n * format expression.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createSpelNode(nodeType, position) {\n var node = {},\n type = nodeType || 'Abstract',\n children = [],\n parent = null,\n activeContext;\n\n node._type = type;\n\n node.getType = function () {\n return type;\n };\n node.setType = function (nodeType) {\n type = nodeType;\n };\n\n node.getChildren = function () {\n return children;\n };\n node.addChild = function (childNode) {\n if (!childNode) {\n // See OpMinus and OpPlus: right node can be null for unary mode\n return;\n }\n if (!childNode.setParent) {\n throw {\n name: 'Error',\n message: 'Trying to add a child which is not a node: ' + JSON.stringify(childNode)\n };\n }\n childNode.setParent(node);\n children.push(childNode);\n };\n\n node.getParent = function () {\n return parent;\n };\n node.setParent = function (parentNode) {\n parent = parentNode;\n };\n\n node.getContext = function (state) {\n return activeContext || state.activeContext.peek();\n };\n node.setContext = function (nodeContext) {\n activeContext = nodeContext;\n };\n\n node.getStartPosition = function () {\n return position >> 16;\n };\n\n node.getEndPosition = function () {\n return position & 0xffff;\n };\n\n //must override\n node.getValue = function () {\n throw {\n name: 'MethodNotImplementedException',\n message: 'SpelNode#getValue() must be overridden.'\n };\n };\n\n node.toString = function () {\n var s = 'Kind: ' + node.getType();\n //s += ', Value: ' + node.getValue();\n s += ', Children: [';\n for (var i = 0, l = node.getChildren().length; i < l; i += 1) {\n s += '{' + node.getChildren()[i] + '}, ';\n }\n s += ']';\n return s;\n };\n\n //constructor\n if (position === 0) {\n throw {\n name: 'Error',\n message: 'Position cannot be 0'\n };\n }\n\n for (var _len = arguments.length, operands = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n operands[_key - 2] = arguments[_key];\n }\n\n if (operands) {\n operands.forEach(function (operand) {\n node.addChild(operand);\n });\n }\n\n return node;\n}\n\nvar SpelNode = exports.SpelNode = {\n create: createSpelNode\n};\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Stack = Stack;\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction Stack(startingElements) {\n this.elements = startingElements || [];\n}\n\nStack.prototype.push = function (el) {\n this.elements.push(el);\n return el;\n};\n\nStack.prototype.pop = function () {\n return this.elements.pop();\n};\n\nStack.prototype.peek = function () {\n return this.elements[this.elements.length - 1];\n};\n\nStack.prototype.empty = function () {\n return this.elements.length > 0;\n};\n\nStack.prototype.search = function (el) {\n return this.elements.length - this.elements.indexOf(el);\n};\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nvar types = {\n\n LITERAL_INT: 1, //tested\n\n LITERAL_LONG: 2, //tested\n\n LITERAL_HEXINT: 3, //tested\n\n LITERAL_HEXLONG: 4, //tested\n\n LITERAL_STRING: 5, //tested\n\n LITERAL_REAL: 6, //tested\n\n LITERAL_REAL_FLOAT: 7, //tested\n\n LPAREN: '(', //tested\n\n RPAREN: ')', //tested\n\n COMMA: ',', //tested\n\n IDENTIFIER: 0, //tested\n\n COLON: ':', //tested\n\n HASH: '#', //tested\n\n RSQUARE: ']', //tested\n\n LSQUARE: '[', //tested\n\n LCURLY: '{', //tested\n\n RCURLY: '}', //tested\n\n DOT: '.', //tested\n\n PLUS: '+', //tested\n\n STAR: '*', //tested\n\n MINUS: '-', //tested\n\n SELECT_FIRST: '^[', //tested\n\n SELECT_LAST: '$[', //tested\n\n QMARK: '?', //tested\n\n PROJECT: '![', //tested\n\n DIV: '/', //tested\n\n GE: '>=', //tested\n\n GT: '>', //tested\n\n LE: '<=', //tested\n\n LT: '<', //tested\n\n EQ: '==', //tested\n\n NE: '!=', //tested\n\n MOD: '%', //tested\n\n NOT: '!', //tested\n\n ASSIGN: '=', //tested\n\n INSTANCEOF: 'instanceof', //test fails\n\n MATCHES: 'matches', //test fails\n\n BETWEEN: 'between', //test fails\n\n SELECT: '?[', //tested\n\n POWER: '^', //tested\n\n ELVIS: '?:', //tested\n\n SAFE_NAVI: '?.', //tested\n\n BEAN_REF: '@', //tested\n\n SYMBOLIC_OR: '||', //tested\n\n SYMBOLIC_AND: '&&', //tested\n\n INC: '++', //tested\n\n DEC: '--' //tested\n};\n\nfunction TokenKind(type) {\n this.type = type;\n this.tokenChars = types[type];\n this._hasPayload = typeof types[type] !== 'string';\n if (typeof types[type] === 'number') {\n this._ordinal = types[type];\n }\n}\n\n//create enum\nfor (var t in types) {\n if (types.hasOwnProperty(t)) {\n TokenKind[t] = new TokenKind(t);\n }\n}\n\nTokenKind.prototype.toString = function () {\n return this.type + (this.tokenChars.length !== 0 ? '(' + this.tokenChars + ')' : '');\n};\n\nTokenKind.prototype.getLength = function () {\n return this.tokenChars.length;\n};\n\nTokenKind.prototype.hasPayload = function () {\n return this._hasPayload;\n};\n\nTokenKind.prototype.valueOf = function (id) {\n for (var t in types) {\n if (types.hasOwnProperty(t) && types[t] === id) {\n return TokenKind[t];\n }\n }\n};\n\nTokenKind.prototype.ordinal = function () {\n return this._ordinal;\n};\n\nexports.TokenKind = TokenKind;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.StandardContext = exports.SpelExpressionEvaluator = undefined;\n\nvar _SpelExpressionEvaluator = __webpack_require__(4);\n\nvar _StandardContext = __webpack_require__(50);\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Ben March\n * @since 0.2.0\n */\n\nexports.SpelExpressionEvaluator = _SpelExpressionEvaluator.SpelExpressionEvaluator;\nexports.StandardContext = _StandardContext.StandardContext;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.SpelExpressionEvaluator = undefined;\n\nvar _SpelExpressionParser = __webpack_require__(5);\n\nvar _Stack = __webpack_require__(1);\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Ben March\n * @since 0.2.0\n */\n\nvar spelExpressionEvaluator = {};\n\nfunction evalCompiled(compiledExpression, context, locals) {\n var activeContext = new _Stack.Stack(),\n state;\n\n if (!context) {\n context = {};\n }\n\n activeContext.push(context);\n\n state = {\n rootContext: context,\n activeContext: activeContext,\n locals: locals\n };\n return compiledExpression.getValue(state);\n}\n\nspelExpressionEvaluator.compile = function (expression) {\n var compiledExpression = (0, _SpelExpressionParser.SpelExpressionParser)().parse(expression);\n return {\n eval: function _eval(context, locals) {\n return evalCompiled(compiledExpression, context, locals);\n },\n _compiledExpression: compiledExpression\n };\n};\n\nspelExpressionEvaluator.eval = function (expression, context, locals) {\n return spelExpressionEvaluator.compile(expression).eval(context, locals);\n};\n\nexports.SpelExpressionEvaluator = spelExpressionEvaluator;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.SpelExpressionParser = undefined;\n\nvar _TokenKind = __webpack_require__(2);\n\nvar _Tokenizer = __webpack_require__(6);\n\nvar _BooleanLiteral = __webpack_require__(8);\n\nvar _NumberLiteral = __webpack_require__(9);\n\nvar _StringLiteral = __webpack_require__(10);\n\nvar _NullLiteral = __webpack_require__(11);\n\nvar _FunctionReference = __webpack_require__(12);\n\nvar _MethodReference = __webpack_require__(13);\n\nvar _PropertyReference = __webpack_require__(14);\n\nvar _VariableReference = __webpack_require__(15);\n\nvar _CompoundExpression = __webpack_require__(16);\n\nvar _Indexer = __webpack_require__(17);\n\nvar _Assign = __webpack_require__(18);\n\nvar _OpEQ = __webpack_require__(19);\n\nvar _OpNE = __webpack_require__(20);\n\nvar _OpGE = __webpack_require__(21);\n\nvar _OpGT = __webpack_require__(22);\n\nvar _OpLE = __webpack_require__(23);\n\nvar _OpLT = __webpack_require__(24);\n\nvar _OpPlus = __webpack_require__(25);\n\nvar _OpMinus = __webpack_require__(26);\n\nvar _OpMultiply = __webpack_require__(27);\n\nvar _OpDivide = __webpack_require__(28);\n\nvar _OpModulus = __webpack_require__(29);\n\nvar _OpPower = __webpack_require__(30);\n\nvar _OpInc = __webpack_require__(31);\n\nvar _OpDec = __webpack_require__(32);\n\nvar _OpNot = __webpack_require__(33);\n\nvar _OpAnd = __webpack_require__(34);\n\nvar _OpOr = __webpack_require__(35);\n\nvar _OpMatches = __webpack_require__(36);\n\nvar _Ternary = __webpack_require__(37);\n\nvar _Elvis = __webpack_require__(38);\n\nvar _InlineList = __webpack_require__(39);\n\nvar _InlineMap = __webpack_require__(40);\n\nvar _Selection = __webpack_require__(41);\n\nvar _Projection = __webpack_require__(42);\n\nvar _OpInstanceof = __webpack_require__(43);\n\nvar _OpBetween = __webpack_require__(44);\n\nvar _TypeReference = __webpack_require__(45);\n\nvar _BeanReference = __webpack_require__(46);\n\nvar _Identifier = __webpack_require__(47);\n\nvar _QualifiedIdentifier = __webpack_require__(48);\n\nvar _ConstructorReference = __webpack_require__(49);\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ben March\n * @since 0.2.0\n *\n */\n\nvar SpelExpressionParser = exports.SpelExpressionParser = function SpelExpressionParser() {\n\n var VALID_QUALIFIED_ID_PATTERN = new RegExp('[\\\\p{L}\\\\p{N}_$]+');\n\n var configuration;\n\n // For rules that build nodes, they are stacked here for return\n var constructedNodes = [];\n\n // The expression being parsed\n var expressionString;\n\n // The token stream constructed from that expression string\n var tokenStream;\n\n // length of a populated token stream\n var tokenStreamLength;\n\n // Current location in the token stream when processing tokens\n var tokenStreamPointer;\n\n /**\n * Create a parser with some configured behavior.\n * @param config custom configuration options\n */\n function setConfiguration(config) {\n configuration = config;\n }\n\n function parse(expression, context) {\n try {\n expressionString = expression;\n tokenStream = _Tokenizer.Tokenizer.tokenize(expression);\n tokenStreamLength = tokenStream.length;\n tokenStreamPointer = 0;\n constructedNodes = [];\n var ast = eatExpression();\n if (moreTokens()) {\n raiseInternalException(peekToken().startPos, 'MORE_INPUT', nextToken().toString());\n }\n //Assert.isTrue(this.constructedNodes.isEmpty());\n return ast;\n } catch (e) {\n throw e.message;\n }\n }\n\n //\texpression\n // : logicalOrExpression\n // ( (ASSIGN^ logicalOrExpression)\n //\t | (DEFAULT^ logicalOrExpression)\n //\t | (QMARK^ expression COLON! expression)\n // | (ELVIS^ expression))?;\n function eatExpression() {\n var expr = eatLogicalOrExpression();\n if (moreTokens()) {\n var token = peekToken();\n if (token.getKind() === _TokenKind.TokenKind.ASSIGN) {\n // a=b\n if (expr === null) {\n expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 1));\n }\n nextToken();\n var assignedValue = eatLogicalOrExpression();\n return _Assign.Assign.create(toPosToken(token), expr, assignedValue);\n }\n\n if (token.getKind() === _TokenKind.TokenKind.ELVIS) {\n // a?:b (a if it isn't null, otherwise b)\n if (expr === null) {\n expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 2));\n }\n nextToken(); // elvis has left the building\n var valueIfNull = eatExpression();\n if (valueIfNull === null) {\n valueIfNull = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos + 1, token.endPos + 1));\n }\n return _Elvis.Elvis.create(toPosToken(token), expr, valueIfNull);\n }\n\n if (token.getKind() === _TokenKind.TokenKind.QMARK) {\n // a?b:c\n if (expr === null) {\n expr = _NullLiteral.NullLiteral.create(toPosBounds(token.startPos - 1, token.endPos - 1));\n }\n nextToken();\n var ifTrueExprValue = eatExpression();\n eatToken(_TokenKind.TokenKind.COLON);\n var ifFalseExprValue = eatExpression();\n return _Ternary.Ternary.create(toPosToken(token), expr, ifTrueExprValue, ifFalseExprValue);\n }\n }\n return expr;\n }\n\n //logicalOrExpression : logicalAndExpression (OR^ logicalAndExpression)*;\n function eatLogicalOrExpression() {\n var expr = eatLogicalAndExpression();\n while (peekIdentifierToken('or') || peekTokenOne(_TokenKind.TokenKind.SYMBOLIC_OR)) {\n var token = nextToken(); //consume OR\n var rhExpr = eatLogicalAndExpression();\n checkOperands(token, expr, rhExpr);\n expr = _OpOr.OpOr.create(toPosToken(token), expr, rhExpr);\n }\n return expr;\n }\n\n // logicalAndExpression : relationalExpression (AND^ relationalExpression)*;\n function eatLogicalAndExpression() {\n var expr = eatRelationalExpression();\n while (peekIdentifierToken('and') || peekTokenOne(_TokenKind.TokenKind.SYMBOLIC_AND)) {\n var token = nextToken(); // consume 'AND'\n var rhExpr = eatRelationalExpression();\n checkOperands(token, expr, rhExpr);\n expr = _OpAnd.OpAnd.create(toPosToken(token), expr, rhExpr);\n }\n return expr;\n }\n\n // relationalExpression : sumExpression (relationalOperator^ sumExpression)?;\n function eatRelationalExpression() {\n var expr = eatSumExpression();\n var relationalOperatorToken = maybeEatRelationalOperator();\n if (relationalOperatorToken !== null) {\n var token = nextToken(); // consume relational operator token\n var rhExpr = eatSumExpression();\n checkOperands(token, expr, rhExpr);\n var tk = relationalOperatorToken.kind;\n\n if (relationalOperatorToken.isNumericRelationalOperator()) {\n var pos = toPosToken(token);\n if (tk === _TokenKind.TokenKind.GT) {\n return _OpGT.OpGT.create(pos, expr, rhExpr);\n }\n if (tk === _TokenKind.TokenKind.LT) {\n return _OpLT.OpLT.create(pos, expr, rhExpr);\n }\n if (tk === _TokenKind.TokenKind.LE) {\n return _OpLE.OpLE.create(pos, expr, rhExpr);\n }\n if (tk === _TokenKind.TokenKind.GE) {\n return _OpGE.OpGE.create(pos, expr, rhExpr);\n }\n if (tk === _TokenKind.TokenKind.EQ) {\n return _OpEQ.OpEQ.create(pos, expr, rhExpr);\n }\n //Assert.isTrue(tk === TokenKind.NE);\n return _OpNE.OpNE.create(pos, expr, rhExpr);\n }\n\n if (tk === _TokenKind.TokenKind.INSTANCEOF) {\n return _OpInstanceof.OpInstanceof.create(toPosToken(token), expr, rhExpr);\n }\n\n if (tk === _TokenKind.TokenKind.MATCHES) {\n return _OpMatches.OpMatches.create(toPosToken(token), expr, rhExpr);\n }\n\n //Assert.isTrue(tk === TokenKind.BETWEEN);\n return _OpBetween.OpBetween.create(toPosToken(token), expr, rhExpr);\n }\n return expr;\n }\n\n //sumExpression: productExpression ( (PLUS^ | MINUS^) productExpression)*;\n function eatSumExpression() {\n var expr = eatProductExpression();\n while (peekTokenAny(_TokenKind.TokenKind.PLUS, _TokenKind.TokenKind.MINUS, _TokenKind.TokenKind.INC)) {\n var token = nextToken(); //consume PLUS or MINUS or INC\n var rhExpr = eatProductExpression();\n checkRightOperand(token, rhExpr);\n if (token.getKind() === _TokenKind.TokenKind.PLUS) {\n expr = _OpPlus.OpPlus.create(toPosToken(token), expr, rhExpr);\n } else if (token.getKind() === _TokenKind.TokenKind.MINUS) {\n expr = _OpMinus.OpMinus.create(toPosToken(token), expr, rhExpr);\n }\n }\n return expr;\n }\n\n // productExpression: powerExpr ((STAR^ | DIV^| MOD^) powerExpr)* ;\n function eatProductExpression() {\n var expr = eatPowerIncDecExpression();\n while (peekTokenAny(_TokenKind.TokenKind.STAR, _TokenKind.TokenKind.DIV, _TokenKind.TokenKind.MOD)) {\n var token = nextToken(); // consume STAR/DIV/MOD\n var rhExpr = eatPowerIncDecExpression();\n checkOperands(token, expr, rhExpr);\n if (token.getKind() === _TokenKind.TokenKind.STAR) {\n expr = _OpMultiply.OpMultiply.create(toPosToken(token), expr, rhExpr);\n } else if (token.getKind() === _TokenKind.TokenKind.DIV) {\n expr = _OpDivide.OpDivide.create(toPosToken(token), expr, rhExpr);\n } else {\n //Assert.isTrue(token.getKind() === TokenKind.MOD);\n expr = _OpModulus.OpModulus.create(toPosToken(token), expr, rhExpr);\n }\n }\n return expr;\n }\n\n // powerExpr : unaryExpression (POWER^ unaryExpression)? (INC || DEC) ;\n function eatPowerIncDecExpression() {\n var expr = eatUnaryExpression(),\n token;\n\n if (peekTokenOne(_TokenKind.TokenKind.POWER)) {\n token = nextToken(); //consume POWER\n var rhExpr = eatUnaryExpression();\n checkRightOperand(token, rhExpr);\n return _OpPower.OpPower.create(toPosToken(token), expr, rhExpr);\n }\n\n if (expr !== null && peekTokenAny(_TokenKind.TokenKind.INC, _TokenKind.TokenKind.DEC)) {\n token = nextToken(); //consume INC/DEC\n if (token.getKind() === _TokenKind.TokenKind.INC) {\n return _OpInc.OpInc.create(toPosToken(token), true, expr);\n }\n return _OpDec.OpDec.create(toPosToken(token), true, expr);\n }\n\n return expr;\n }\n\n // unaryExpression: (PLUS^ | MINUS^ | BANG^ | INC^ | DEC^) unaryExpression | primaryExpression ;\n function eatUnaryExpression() {\n var token, expr;\n\n if (peekTokenAny(_TokenKind.TokenKind.PLUS, _TokenKind.TokenKind.MINUS, _TokenKind.TokenKind.NOT)) {\n token = nextToken();\n expr = eatUnaryExpression();\n if (token.getKind() === _TokenKind.TokenKind.NOT) {\n return _OpNot.OpNot.create(toPosToken(token), expr);\n }\n\n if (token.getKind() === _TokenKind.TokenKind.PLUS) {\n return _OpPlus.OpPlus.create(toPosToken(token), expr);\n }\n //Assert.isTrue(token.getKind() === TokenKind.MINUS);\n return _OpMinus.OpMinus.create(toPosToken(token), expr);\n }\n if (peekTokenAny(_TokenKind.TokenKind.INC, _TokenKind.TokenKind.DEC)) {\n token = nextToken();\n expr = eatUnaryExpression();\n if (token.getKind() === _TokenKind.TokenKind.INC) {\n return _OpInc.OpInc.create(toPosToken(token), false, expr);\n }\n return _OpDec.OpDec.create(toPosToken(token), false, expr);\n }\n\n return eatPrimaryExpression();\n }\n\n // primaryExpression : startNode (node)? -> ^(EXPRESSION startNode (node)?);\n function eatPrimaryExpression() {\n var nodes = [];\n var start = eatStartNode(); // always a start node\n nodes.push(start);\n while (maybeEatNode()) {\n nodes.push(pop());\n }\n if (nodes.length === 1) {\n return nodes[0];\n }\n return _CompoundExpression.CompoundExpression.create(toPosBounds(start.getStartPosition(), nodes[nodes.length - 1].getEndPosition()), nodes);\n }\n\n // node : ((DOT dottedNode) | (SAFE_NAVI dottedNode) | nonDottedNode)+;\n function maybeEatNode() {\n var expr = null;\n if (peekTokenAny(_TokenKind.TokenKind.DOT, _TokenKind.TokenKind.SAFE_NAVI)) {\n expr = eatDottedNode();\n } else {\n expr = maybeEatNonDottedNode();\n }\n\n if (expr === null) {\n return false;\n } else {\n push(expr);\n return true;\n }\n }\n\n // nonDottedNode: indexer;\n function maybeEatNonDottedNode() {\n if (peekTokenOne(_TokenKind.TokenKind.LSQUARE)) {\n if (maybeEatIndexer()) {\n return pop();\n }\n }\n return null;\n }\n\n //dottedNode\n // : ((methodOrProperty\n //\t | functionOrVar\n // | projection\n // | selection\n // | firstSelection\n // | lastSelection\n // ))\n //\t;\n function eatDottedNode() {\n var token = nextToken(); // it was a '.' or a '?.'\n var nullSafeNavigation = token.getKind() === _TokenKind.TokenKind.SAFE_NAVI;\n if (maybeEatMethodOrProperty(nullSafeNavigation) || maybeEatFunctionOrVar() || maybeEatProjection(nullSafeNavigation) || maybeEatSelection(nullSafeNavigation)) {\n return pop();\n }\n if (peekToken() === null) {\n // unexpectedly ran out of data\n raiseInternalException(token.startPos, 'OOD');\n } else {\n raiseInternalException(token.startPos, 'UNEXPECTED_DATA_AFTER_DOT', toString(peekToken()));\n }\n return null;\n }\n\n // functionOrVar\n // : (POUND ID LPAREN) => function\n // | var\n //\n // function : POUND id=ID methodArgs -> ^(FUNCTIONREF[$id] methodArgs);\n // var : POUND id=ID -> ^(VARIABLEREF[$id]);\n function maybeEatFunctionOrVar() {\n if (!peekTokenOne(_TokenKind.TokenKind.HASH)) {\n return false;\n }\n var token = nextToken();\n var functionOrVariableName = eatToken(_TokenKind.TokenKind.IDENTIFIER);\n var args = maybeEatMethodArgs();\n if (args === null) {\n push(_VariableReference.VariableReference.create(functionOrVariableName.data, toPosBounds(token.startPos, functionOrVariableName.endPos)));\n return true;\n }\n\n push(_FunctionReference.FunctionReference.create(functionOrVariableName.data, toPosBounds(token.startPos, functionOrVariableName.endPos), args));\n return true;\n }\n\n // methodArgs : LPAREN! (argument (COMMA! argument)* (COMMA!)?)? RPAREN!;\n function maybeEatMethodArgs() {\n if (!peekTokenOne(_TokenKind.TokenKind.LPAREN)) {\n return null;\n }\n var args = [];\n consumeArguments(args);\n eatToken(_TokenKind.TokenKind.RPAREN);\n return args;\n }\n\n function eatConstructorArgs(accumulatedArguments) {\n if (!peekTokenOne(_TokenKind.TokenKind.LPAREN)) {\n raiseInternalException(toPosToken(peekToken()), 'MISSING_CONSTRUCTOR_ARGS');\n }\n consumeArguments(accumulatedArguments);\n eatToken(_TokenKind.TokenKind.RPAREN);\n }\n\n /**\n * Used for consuming arguments for either a method or a constructor call\n */\n function consumeArguments(accumulatedArguments) {\n var pos = peekToken().startPos;\n var next;\n do {\n nextToken(); // consume ( (first time through) or comma (subsequent times)\n var token = peekToken();\n if (token === null) {\n raiseInternalException(pos, 'RUN_OUT_OF_ARGUMENTS');\n }\n if (token.getKind() !== _TokenKind.TokenKind.RPAREN) {\n accumulatedArguments.push(eatExpression());\n }\n next = peekToken();\n } while (next !== null && next.kind === _TokenKind.TokenKind.COMMA);\n\n if (next === null) {\n raiseInternalException(pos, 'RUN_OUT_OF_ARGUMENTS');\n }\n }\n\n function positionOf(token) {\n if (token === null) {\n // if null assume the problem is because the right token was\n // not found at the end of the expression\n return expressionString.length;\n }\n return token.startPos;\n }\n\n //startNode\n // : parenExpr | literal\n //\t | type\n //\t | methodOrProperty\n //\t | functionOrVar\n //\t | projection\n //\t | selection\n //\t | firstSelection\n //\t | lastSelection\n //\t | indexer\n //\t | constructor\n function eatStartNode() {\n if (maybeEatLiteral()) {\n return pop();\n } else if (maybeEatParenExpression()) {\n return pop();\n } else if (maybeEatTypeReference() || maybeEatNullReference() || maybeEatConstructorReference() || maybeEatMethodOrProperty(false) || maybeEatFunctionOrVar()) {\n return pop();\n } else if (maybeEatBeanReference()) {\n return pop();\n } else if (maybeEatProjection(false) || maybeEatSelection(false) || maybeEatIndexer()) {\n return pop();\n } else if (maybeEatInlineListOrMap()) {\n return pop();\n } else {\n return null;\n }\n }\n\n // parse: @beanname @'bean.name'\n // quoted if dotted\n function maybeEatBeanReference() {\n if (peekTokenOne(_TokenKind.TokenKind.BEAN_REF)) {\n var beanRefToken = nextToken();\n var beanNameToken = null;\n var beanName = null;\n if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {\n beanNameToken = eatToken(_TokenKind.TokenKind.IDENTIFIER);\n beanName = beanNameToken.data;\n } else if (peekTokenOne(_TokenKind.TokenKind.LITERAL_STRING)) {\n beanNameToken = eatToken(_TokenKind.TokenKind.LITERAL_STRING);\n beanName = beanNameToken.stringValue();\n beanName = beanName.substring(1, beanName.length() - 1);\n } else {\n raiseInternalException(beanRefToken.startPos, 'INVALID_BEAN_REFERENCE');\n }\n\n var beanReference = _BeanReference.BeanReference.create(toPosToken(beanNameToken), beanName);\n push(beanReference);\n return true;\n }\n return false;\n }\n\n function maybeEatTypeReference() {\n if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {\n var typeName = peekToken();\n if (typeName.stringValue() !== 'T') {\n return false;\n }\n // It looks like a type reference but is T being used as a map key?\n var token = nextToken();\n if (peekTokenOne(_TokenKind.TokenKind.RSQUARE)) {\n // looks like 'T]' (T is map key)\n push(_PropertyReference.PropertyReference.create(token.stringValue(), toPosToken(token)));\n return true;\n }\n eatToken(_TokenKind.TokenKind.LPAREN);\n var node = eatPossiblyQualifiedId();\n // dotted qualified id\n // Are there array dimensions?\n var dims = 0;\n while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) {\n eatToken(_TokenKind.TokenKind.RSQUARE);\n dims++;\n }\n eatToken(_TokenKind.TokenKind.RPAREN);\n push(_TypeReference.TypeReference.create(toPosToken(typeName), node, dims));\n return true;\n }\n return false;\n }\n\n function maybeEatNullReference() {\n if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {\n var nullToken = peekToken();\n if (nullToken.stringValue().toLowerCase() !== 'null') {\n return false;\n }\n nextToken();\n push(_NullLiteral.NullLiteral.create(toPosToken(nullToken)));\n return true;\n }\n return false;\n }\n\n //projection: PROJECT^ expression RCURLY!;\n function maybeEatProjection(nullSafeNavigation) {\n var token = peekToken();\n if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.PROJECT, true)) {\n return false;\n }\n var expr = eatExpression();\n eatToken(_TokenKind.TokenKind.RSQUARE);\n push(_Projection.Projection.create(nullSafeNavigation, toPosToken(token), expr));\n return true;\n }\n\n // list = LCURLY (element (COMMA element)*) RCURLY\n // map = LCURLY (key ':' value (COMMA key ':' value)*) RCURLY\n function maybeEatInlineListOrMap() {\n var token = peekToken(),\n listElements = [];\n\n if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.LCURLY, true)) {\n return false;\n }\n var expr = null;\n var closingCurly = peekToken();\n if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.RCURLY, true)) {\n // empty list '{}'\n expr = _InlineList.InlineList.create(toPosBounds(token.startPos, closingCurly.endPos));\n } else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COLON, true)) {\n closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);\n // empty map '{:}'\n expr = _InlineMap.InlineMap.create(toPosBounds(token.startPos, closingCurly.endPos));\n } else {\n var firstExpression = eatExpression();\n // Next is either:\n // '}' - end of list\n // ',' - more expressions in this list\n // ':' - this is a map!\n\n if (peekTokenOne(_TokenKind.TokenKind.RCURLY)) {\n // list with one item in it\n listElements.push(firstExpression);\n closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);\n expr = _InlineList.InlineList.create(toPosBounds(token.startPos, closingCurly.endPos), listElements);\n } else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true)) {\n // multi item list\n listElements.push(firstExpression);\n do {\n listElements.push(eatExpression());\n } while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true));\n closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);\n expr = _InlineList.InlineList.create(toPosToken(token.startPos, closingCurly.endPos), listElements);\n } else if (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COLON, true)) {\n // map!\n var mapElements = [];\n mapElements.push(firstExpression);\n mapElements.push(eatExpression());\n while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.COMMA, true)) {\n mapElements.push(eatExpression());\n eatToken(_TokenKind.TokenKind.COLON);\n mapElements.push(eatExpression());\n }\n closingCurly = eatToken(_TokenKind.TokenKind.RCURLY);\n expr = _InlineMap.InlineMap.create(toPosBounds(token.startPos, closingCurly.endPos), mapElements);\n } else {\n raiseInternalException(token.startPos, 'OOD');\n }\n }\n push(expr);\n return true;\n }\n\n function maybeEatIndexer() {\n var token = peekToken();\n if (!peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) {\n return false;\n }\n var expr = eatExpression();\n eatToken(_TokenKind.TokenKind.RSQUARE);\n push(_Indexer.Indexer.create(toPosToken(token), expr));\n return true;\n }\n\n function maybeEatSelection(nullSafeNavigation) {\n var token = peekToken();\n if (!peekSelectToken()) {\n return false;\n }\n nextToken();\n var expr = eatExpression();\n if (expr === null) {\n raiseInternalException(toPosToken(token), 'MISSING_SELECTION_EXPRESSION');\n }\n eatToken(_TokenKind.TokenKind.RSQUARE);\n if (token.getKind() === _TokenKind.TokenKind.SELECT_FIRST) {\n push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.FIRST, toPosToken(token), expr));\n } else if (token.getKind() === _TokenKind.TokenKind.SELECT_LAST) {\n push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.LAST, toPosToken(token), expr));\n } else {\n push(_Selection.Selection.create(nullSafeNavigation, _Selection.Selection.ALL, toPosToken(token), expr));\n }\n return true;\n }\n\n /**\n * Eat an identifier, possibly qualified (meaning that it is dotted).\n * TODO AndyC Could create complete identifiers (a.b.c) here rather than a sequence of them? (a, b, c)\n */\n function eatPossiblyQualifiedId() {\n var qualifiedIdPieces = [];\n var node = peekToken();\n while (isValidQualifiedId(node)) {\n nextToken();\n if (node.kind !== _TokenKind.TokenKind.DOT) {\n qualifiedIdPieces.push(_Identifier.Identifier.create(node.stringValue(), toPosToken(node)));\n }\n node = peekToken();\n }\n if (!qualifiedIdPieces.length) {\n if (node === null) {\n raiseInternalException(expressionString.length(), 'OOD');\n }\n raiseInternalException(node.startPos, 'NOT_EXPECTED_TOKEN', 'qualified ID', node.getKind().toString().toLowerCase());\n }\n var pos = toPosBounds(qualifiedIdPieces[0].getStartPosition(), qualifiedIdPieces[qualifiedIdPieces.length - 1].getEndPosition());\n return _QualifiedIdentifier.QualifiedIdentifier.create(pos, qualifiedIdPieces);\n }\n\n function isValidQualifiedId(node) {\n if (node === null || node.kind === _TokenKind.TokenKind.LITERAL_STRING) {\n return false;\n }\n if (node.kind === _TokenKind.TokenKind.DOT || node.kind === _TokenKind.TokenKind.IDENTIFIER) {\n return true;\n }\n var value = node.stringValue();\n return value && value.length && VALID_QUALIFIED_ID_PATTERN.test(value);\n }\n\n // This is complicated due to the support for dollars in identifiers. Dollars are normally separate tokens but\n // there we want to combine a series of identifiers and dollars into a single identifier\n function maybeEatMethodOrProperty(nullSafeNavigation) {\n if (peekTokenOne(_TokenKind.TokenKind.IDENTIFIER)) {\n var methodOrPropertyName = nextToken();\n var args = maybeEatMethodArgs();\n if (args === null) {\n // property\n push(_PropertyReference.PropertyReference.create(nullSafeNavigation, methodOrPropertyName.stringValue(), toPosToken(methodOrPropertyName)));\n return true;\n }\n // methodreference\n push(_MethodReference.MethodReference.create(nullSafeNavigation, methodOrPropertyName.stringValue(), toPosToken(methodOrPropertyName), args));\n // TODO what is the end position for a method reference? the name or the last arg?\n return true;\n }\n return false;\n }\n\n //constructor\n //:\t('new' qualifiedId LPAREN) => 'new' qualifiedId ctorArgs -> ^(CONSTRUCTOR qualifiedId ctorArgs)\n function maybeEatConstructorReference() {\n if (peekIdentifierToken('new')) {\n var newToken = nextToken();\n // It looks like a constructor reference but is NEW being used as a map key?\n if (peekTokenOne(_TokenKind.TokenKind.RSQUARE)) {\n // looks like 'NEW]' (so NEW used as map key)\n push(_PropertyReference.PropertyReference.create(newToken.stringValue(), toPosToken(newToken)));\n return true;\n }\n var possiblyQualifiedConstructorName = eatPossiblyQualifiedId();\n var nodes = [];\n nodes.push(possiblyQualifiedConstructorName);\n if (peekTokenOne(_TokenKind.TokenKind.LSQUARE)) {\n // array initializer\n var dimensions = [];\n while (peekTokenConsumeIfMatched(_TokenKind.TokenKind.LSQUARE, true)) {\n if (!peekTokenOne(_TokenKind.TokenKind.RSQUARE)) {\n dimensions.push(eatExpression());\n } else {\n dimensions.push(null);\n }\n eatToken(_TokenKind.TokenKind.RSQUARE);\n }\n if (maybeEatInlineListOrMap()) {\n nodes.push(pop());\n }\n push(_ConstructorReference.ConstructorReference.create(toPosToken(newToken), dimensions, nodes));\n } else {\n // regular constructor invocation\n eatConstructorArgs(nodes);\n // TODO correct end position?\n push(_ConstructorReference.ConstructorReference.create(toPosToken(newToken), nodes));\n }\n return true;\n }\n return false;\n }\n\n function push(newNode) {\n constructedNodes.push(newNode);\n }\n\n function pop() {\n return constructedNodes.pop();\n }\n\n //\tliteral\n // : INTEGER_LITERAL\n //\t| boolLiteral\n //\t| STRING_LITERAL\n // | HEXADECIMAL_INTEGER_LITERAL\n // | REAL_LITERAL\n //\t| DQ_STRING_LITERAL\n //\t| NULL_LITERAL\n function maybeEatLiteral() {\n var token = peekToken();\n if (token === null) {\n return false;\n }\n if (token.getKind() === _TokenKind.TokenKind.LITERAL_INT || token.getKind() === _TokenKind.TokenKind.LITERAL_LONG) {\n push(_NumberLiteral.NumberLiteral.create(parseInt(token.stringValue(), 10), toPosToken(token)));\n } else if (token.getKind() === _TokenKind.TokenKind.LITERAL_REAL || token.getKind() === _TokenKind.TokenKind.LITERAL_REAL_FLOAT) {\n push(_NumberLiteral.NumberLiteral.create(parseFloat(token.stringValue()), toPosToken(token)));\n } else if (token.getKind() === _TokenKind.TokenKind.LITERAL_HEXINT || token.getKind() === _TokenKind.TokenKind.LITERAL_HEXLONG) {\n push(_NumberLiteral.NumberLiteral.create(parseInt(token.stringValue(), 16), toPosToken(token)));\n } else if (peekIdentifierToken('true')) {\n push(_BooleanLiteral.BooleanLiteral.create(true, toPosToken(token)));\n } else if (peekIdentifierToken('false')) {\n push(_BooleanLiteral.BooleanLiteral.create(false, toPosToken(token)));\n } else if (token.getKind() === _TokenKind.TokenKind.LITERAL_STRING) {\n push(_StringLiteral.StringLiteral.create(token.stringValue(), toPosToken(token)));\n } else {\n return false;\n }\n nextToken();\n return true;\n }\n\n //parenExpr : LPAREN! expression RPAREN!;\n function maybeEatParenExpression() {\n if (peekTokenOne(_TokenKind.TokenKind.LPAREN)) {\n nextToken();\n var expr = eatExpression();\n eatToken(_TokenKind.TokenKind.RPAREN);\n push(expr);\n return true;\n } else {\n return false;\n }\n }\n\n // relationalOperator\n // : EQUAL | NOT_EQUAL | LESS_THAN | LESS_THAN_OR_EQUAL | GREATER_THAN\n // | GREATER_THAN_OR_EQUAL | INSTANCEOF | BETWEEN | MATCHES\n function maybeEatRelationalOperator() {\n var token = peekToken();\n if (token === null) {\n return null;\n }\n if (token.isNumericRelationalOperator()) {\n return token;\n }\n if (token.isIdentifier()) {\n var idString = token.stringValue();\n if (idString.toLowerCase() === 'instanceof') {\n return token.asInstanceOfToken();\n }\n if (idString.toLowerCase() === 'matches') {\n return token.asMatchesToken();\n }\n if (idString.toLowerCase() === 'between') {\n return token.asBetweenToken();\n }\n }\n return null;\n }\n\n function eatToken(expectedKind) {\n var token = nextToken();\n if (token === null) {\n raiseInternalException(expressionString.length, 'OOD');\n }\n if (token.getKind() !== expectedKind) {\n raiseInternalException(token.startPos, 'NOT_EXPECTED_TOKEN', expectedKind.toString().toLowerCase(), token.getKind().toString().toLowerCase());\n }\n return token;\n }\n\n function peekTokenOne(desiredTokenKind) {\n return peekTokenConsumeIfMatched(desiredTokenKind, false);\n }\n\n function peekTokenConsumeIfMatched(desiredTokenKind, consumeIfMatched) {\n if (!moreTokens()) {\n return false;\n }\n var token = peekToken();\n if (token.getKind() === desiredTokenKind) {\n if (consumeIfMatched) {\n tokenStreamPointer++;\n }\n return true;\n }\n\n if (desiredTokenKind === _TokenKind.TokenKind.IDENTIFIER) {\n // might be one of the textual forms of the operators (e.g. NE for !== ) - in which case we can treat it as an identifier\n // The list is represented here: Tokenizer.alternativeOperatorNames and those ones are in order in the TokenKind enum\n if (token.getKind().ordinal() >= _TokenKind.TokenKind.DIV.ordinal() && token.getKind().ordinal() <= _TokenKind.TokenKind.NOT.ordinal() && token.data !== null) {\n // if token.data were null, we'd know it wasn'token the textual form, it was the symbol form\n return true;\n }\n }\n return false;\n }\n\n function peekTokenAny() {\n if (!moreTokens()) {\n return false;\n }\n var token = peekToken();\n var args = Array.prototype.slice.call(arguments);\n for (var i = 0, l = args.length; i < l; i += 1) {\n if (token.getKind() === args[i]) {\n return true;\n }\n }\n return false;\n }\n\n function peekIdentifierToken(identifierString) {\n if (!moreTokens()) {\n return false;\n }\n var token = peekToken();\n return token.getKind() === _TokenKind.TokenKind.IDENTIFIER && token.stringValue().toLowerCase() === identifierString.toLowerCase();\n }\n\n function peekSelectToken() {\n if (!moreTokens()) {\n return false;\n }\n var token = peekToken();\n return token.getKind() === _TokenKind.TokenKind.SELECT || token.getKind() === _TokenKind.TokenKind.SELECT_FIRST || token.getKind() === _TokenKind.TokenKind.SELECT_LAST;\n }\n\n function moreTokens() {\n return tokenStreamPointer < tokenStream.length;\n }\n\n function nextToken() {\n if (tokenStreamPointer >= tokenStreamLength) {\n return null;\n }\n return tokenStream[tokenStreamPointer++];\n }\n\n function peekToken() {\n if (tokenStreamPointer >= tokenStreamLength) {\n return null;\n }\n return tokenStream[tokenStreamPointer];\n }\n\n function raiseInternalException(pos, message, expected, actual) {\n if (expected) {\n message += '\\nExpected: ' + expected;\n }\n if (actual) {\n message += '\\nActual: ' + actual;\n }\n throw {\n name: 'InternalParseException',\n message: 'Error occurred while attempting to parse expression \\'' + expressionString + '\\' at position ' + pos + '. Message: ' + message\n };\n }\n\n function toString(token) {\n if (token.getKind().hasPayload()) {\n return token.stringValue();\n }\n return token.getKind().toString().toLowerCase();\n }\n\n function checkOperands(token, left, right) {\n checkLeftOperand(token, left);\n checkRightOperand(token, right);\n }\n\n function checkLeftOperand(token, operandExpression) {\n if (operandExpression === null) {\n raiseInternalException(token.startPos, 'LEFT_OPERAND_PROBLEM');\n }\n }\n\n function checkRightOperand(token, operandExpression) {\n if (operandExpression === null) {\n raiseInternalException(token.startPos, 'RIGHT_OPERAND_PROBLEM');\n }\n }\n\n /**\n * Compress the start and end of a token into a single int.\n */\n function toPosToken(token) {\n return (token.startPos << 16) + token.endPos;\n }\n\n function toPosBounds(start, end) {\n return (start << 16) + end;\n }\n\n return {\n setConfiguration: setConfiguration,\n parse: parse\n };\n};\n\n//not yet implemented\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Tokenizer = undefined;\n\nvar _Token = __webpack_require__(7);\n\nvar _TokenKind = __webpack_require__(2);\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Andy Clement\n * @author Phillip Webb\n * @author Ben March\n * @since 0.2.0\n */\n\nvar ALTERNATIVE_OPERATOR_NAMES = ['DIV', 'EQ', 'GE', 'GT', 'LE', 'LT', 'MOD', 'NE', 'NOT'],\n FLAGS = [],\n IS_DIGIT = 1,\n IS_HEXDIGIT = 2,\n IS_ALPHA = 4;\n\nfunction init() {\n var ch;\n\n for (ch = '0'.charCodeAt(0); ch <= '9'.charCodeAt(0); ch += 1) {\n FLAGS[ch] |= IS_DIGIT | IS_HEXDIGIT;\n }\n for (ch = 'A'.charCodeAt(0); ch <= 'F'.charCodeAt(0); ch += 1) {\n FLAGS[ch] |= IS_HEXDIGIT;\n }\n for (ch = 'a'.charCodeAt(0); ch <= 'f'.charCodeAt(0); ch += 1) {\n FLAGS[ch] |= IS_HEXDIGIT;\n }\n for (ch = 'A'.charCodeAt(0); ch <= 'Z'.charCodeAt(0); ch += 1) {\n FLAGS[ch] |= IS_ALPHA;\n }\n for (ch = 'a'.charCodeAt(0); ch <= 'z'.charCodeAt(0); ch += 1) {\n FLAGS[ch] |= IS_ALPHA;\n }\n}\n\ninit();\n\nfunction tokenize(inputData) {\n var expressionString = inputData,\n toProcess = inputData + '\\0',\n max = toProcess.length,\n pos = 0,\n tokens = [];\n\n function process() {\n var ch;\n\n while (pos < max) {\n ch = toProcess[pos];\n if (isAlphabetic(ch)) {\n lexIdentifier();\n } else {\n switch (ch) {\n case '+':\n if (isTwoCharToken(_TokenKind.TokenKind.INC)) {\n pushPairToken(_TokenKind.TokenKind.INC);\n } else {\n pushCharToken(_TokenKind.TokenKind.PLUS);\n }\n break;\n case '_':\n // the other way to start an identifier\n lexIdentifier();\n break;\n case '-':\n if (isTwoCharToken(_TokenKind.TokenKind.DEC)) {\n pushPairToken(_TokenKind.TokenKind.DEC);\n } else {\n pushCharToken(_TokenKind.TokenKind.MINUS);\n }\n break;\n case ':':\n pushCharToken(_TokenKind.TokenKind.COLON);\n break;\n case '.':\n pushCharToken(_TokenKind.TokenKind.DOT);\n break;\n case ',':\n pushCharToken(_TokenKind.TokenKind.COMMA);\n break;\n case '*':\n pushCharToken(_TokenKind.TokenKind.STAR);\n break;\n case '/':\n pushCharToken(_TokenKind.TokenKind.DIV);\n break;\n case '%':\n pushCharToken(_TokenKind.TokenKind.MOD);\n break;\n case '(':\n pushCharToken(_TokenKind.TokenKind.LPAREN);\n break;\n case ')':\n pushCharToken(_TokenKind.TokenKind.RPAREN);\n break;\n case '[':\n pushCharToken(_TokenKind.TokenKind.LSQUARE);\n break;\n case '#':\n pushCharToken(_TokenKind.TokenKind.HASH);\n break;\n case ']':\n pushCharToken(_TokenKind.TokenKind.RSQUARE);\n break;\n case '{':\n pushCharToken(_TokenKind.TokenKind.LCURLY);\n break;\n case '}':\n pushCharToken(_TokenKind.TokenKind.RCURLY);\n break;\n case '@':\n pushCharToken(_TokenKind.TokenKind.BEAN_REF);\n break;\n case '^':\n if (isTwoCharToken(_TokenKind.TokenKind.SELECT_FIRST)) {\n pushPairToken(_TokenKind.TokenKind.SELECT_FIRST);\n } else {\n pushCharToken(_TokenKind.TokenKind.POWER);\n }\n break;\n case '!':\n if (isTwoCharToken(_TokenKind.TokenKind.NE)) {\n pushPairToken(_TokenKind.TokenKind.NE);\n } else if (isTwoCharToken(_TokenKind.TokenKind.PROJECT)) {\n pushPairToken(_TokenKind.TokenKind.PROJECT);\n } else {\n pushCharToken(_TokenKind.TokenKind.NOT);\n }\n break;\n case '=':\n if (isTwoCharToken(_TokenKind.TokenKind.EQ)) {\n pushPairToken(_TokenKind.TokenKind.EQ);\n } else {\n pushCharToken(_TokenKind.TokenKind.ASSIGN);\n }\n break;\n case '&':\n if (!isTwoCharToken(_TokenKind.TokenKind.SYMBOLIC_AND)) {\n throw {\n name: 'SpelParseException',\n message: 'Missing character \\'&\\' in expression (' + expressionString + ') at position ' + pos\n };\n }\n pushPairToken(_TokenKind.TokenKind.SYMBOLIC_AND);\n break;\n case '|':\n if (!isTwoCharToken(_TokenKind.TokenKind.SYMBOLIC_OR)) {\n throw {\n name: 'SpelParseException',\n message: 'Missing character \\'|\\' in expression (' + expressionString + ') at position ' + pos\n };\n }\n pushPairToken(_TokenKind.TokenKind.SYMBOLIC_OR);\n break;\n case '?':\n if (isTwoCharToken(_TokenKind.TokenKind.SELECT)) {\n pushPairToken(_TokenKind.TokenKind.SELECT);\n } else if (isTwoCharToken(_TokenKind.TokenKind.ELVIS)) {\n pushPairToken(_TokenKind.TokenKind.ELVIS);\n } else if (isTwoCharToken(_TokenKind.TokenKind.SAFE_NAVI)) {\n pushPairToken(_TokenKind.TokenKind.SAFE_NAVI);\n } else {\n pushCharToken(_TokenKind.TokenKind.QMARK);\n }\n break;\n case '$':\n if (isTwoCharToken(_TokenKind.TokenKind.SELECT_LAST)) {\n pushPairToken(_TokenKind.TokenKind.SELECT_LAST);\n } else {\n lexIdentifier();\n }\n break;\n case '>':\n if (isTwoCharToken(_TokenKind.TokenKind.GE)) {\n pushPairToken(_TokenKind.TokenKind.GE);\n } else {\n pushCharToken(_TokenKind.TokenKind.GT);\n }\n break;\n case '<':\n if (isTwoCharToken(_TokenKind.TokenKind.LE)) {\n pushPairToken(_TokenKind.TokenKind.LE);\n } else {\n pushCharToken(_TokenKind.TokenKind.LT);\n }\n break;\n case '0':\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7':\n case '8':\n case '9':\n lexNumericLiteral(ch === '0');\n break;\n case ' ':\n case '\\t':\n case '\\r':\n case '\\n':\n // drift over white space\n pos += 1;\n break;\n case '\\'':\n lexQuotedStringLiteral();\n break;\n case '\"':\n lexDoubleQuotedStringLiteral();\n break;\n case '\\0':\n // hit sentinel at end of value\n pos += 1; // will take us to the end\n break;\n case '\\\\':\n throw {\n name: 'SpelParseException',\n message: 'Unexpected escape character in expression (' + expressionString + ') at position ' + pos\n };\n default:\n throw {\n name: 'SpelParseException',\n message: 'Cannot handle character \\'' + ch + '\\' in expression (' + expressionString + ') at position ' + pos\n };\n }\n }\n }\n }\n\n function lexQuotedStringLiteral() {\n var start = pos,\n terminated = false,\n ch;\n\n while (!terminated) {\n pos += 1;\n ch = toProcess[pos];\n if (ch === '\\'') {\n // may not be the end if the char after is also a '\n if (toProcess[pos + 1] === '\\'') {\n pos += 1; // skip over that too, and continue\n } else {\n terminated = true;\n }\n }\n if (ch.charCodeAt(0) === 0) {\n throw {\n name: 'SpelParseException',\n message: 'Non-terminating quoted string in expression (' + expressionString + ') at position ' + pos\n };\n }\n }\n pos += 1;\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_STRING, subarray(start, pos), start, pos));\n }\n function lexDoubleQuotedStringLiteral() {\n var start = pos,\n terminated = false,\n ch;\n\n while (!terminated) {\n pos += 1;\n ch = toProcess[pos];\n if (ch === '\"') {\n // may not be the end if the char after is also a '\n if (toProcess[pos + 1] === '\"') {\n pos += 1; // skip over that too, and continue\n } else {\n terminated = true;\n }\n }\n if (ch.charCodeAt(0) === 0) {\n throw {\n name: 'SpelParseException',\n message: 'Non-terminating double-quoted string in expression (' + expressionString + ') at position ' + pos\n };\n }\n }\n pos += 1;\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_STRING, subarray(start, pos), start, pos));\n }\n\n // REAL_LITERAL :\n // ('.' (DECIMAL_DIGIT)+ (EXPONENT_PART)? (REAL_TYPE_SUFFIX)?) |\n // ((DECIMAL_DIGIT)+ '.' (DECIMAL_DIGIT)+ (EXPONENT_PART)? (REAL_TYPE_SUFFIX)?) |\n // ((DECIMAL_DIGIT)+ (EXPONENT_PART) (REAL_TYPE_SUFFIX)?) |\n // ((DECIMAL_DIGIT)+ (REAL_TYPE_SUFFIX));\n // fragment INTEGER_TYPE_SUFFIX : ( 'L' | 'l' );\n // fragment HEX_DIGIT :\n // '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'|'A'|'B'|'C'|'D'|'E'|'F'|'a'|'b'|'c'|'d'|'e'|'f';\n //\n // fragment EXPONENT_PART : 'e' (SIGN)* (DECIMAL_DIGIT)+ | 'E' (SIGN)*\n // (DECIMAL_DIGIT)+ ;\n // fragment SIGN : '+' | '-' ;\n // fragment REAL_TYPE_SUFFIX : 'F' | 'f' | 'D' | 'd';\n // INTEGER_LITERAL\n // : (DECIMAL_DIGIT)+ (INTEGER_TYPE_SUFFIX)?;\n\n function lexNumericLiteral(firstCharIsZero) {\n var isReal = false,\n start = pos,\n ch = toProcess[pos + 1],\n isHex = ch === 'x' || ch === 'X',\n dotpos,\n endOfNumber,\n possibleSign,\n isFloat;\n\n // deal with hexadecimal\n if (firstCharIsZero && isHex) {\n pos = pos + 1;\n do {\n pos += 1;\n } while (isHexadecimalDigit(toProcess[pos]));\n if (isChar('L', 'l')) {\n pushHexIntToken(subarray(start + 2, pos), true, start, pos);\n pos += 1;\n } else {\n pushHexIntToken(subarray(start + 2, pos), false, start, pos);\n }\n return;\n }\n\n // real numbers must have leading digits\n\n // Consume first part of number\n do {\n pos += 1;\n } while (isDigit(toProcess[pos]));\n\n // a '.' indicates this number is a real\n ch = toProcess[pos];\n if (ch === '.') {\n isReal = true;\n dotpos = pos;\n // carry on consuming digits\n do {\n pos += 1;\n } while (isDigit(toProcess[pos]));\n if (pos === dotpos + 1) {\n // the number is something like '3.'. It is really an int but may be\n // part of something like '3.toString()'. In this case process it as\n // an int and leave the dot as a separate token.\n pos = dotpos;\n pushIntToken(subarray(start, pos), false, start, pos);\n return;\n }\n }\n\n endOfNumber = pos;\n\n // Now there may or may not be an exponent\n\n // is it a long ?\n if (isChar('L', 'l')) {\n if (isReal) {\n // 3.4L - not allowed\n throw {\n name: 'SpelParseException',\n message: 'Real cannot be long in expression (' + expressionString + ') at position ' + pos\n };\n }\n pushIntToken(subarray(start, endOfNumber), true, start, endOfNumber);\n pos += 1;\n } else if (isExponentChar(toProcess[pos])) {\n isReal = true; // if it wasn't before, it is now\n pos += 1;\n possibleSign = toProcess[pos];\n if (isSign(possibleSign)) {\n pos += 1;\n }\n\n // exponent digits\n do {\n pos += 1;\n } while (isDigit(toProcess[pos]));\n isFloat = false;\n if (isFloatSuffix(toProcess[pos])) {\n isFloat = true;\n pos += 1;\n endOfNumber = pos;\n } else if (isDoubleSuffix(toProcess[pos])) {\n pos += 1;\n endOfNumber = pos;\n }\n pushRealToken(subarray(start, pos), isFloat, start, pos);\n } else {\n ch = toProcess[pos];\n isFloat = false;\n if (isFloatSuffix(ch)) {\n isReal = true;\n isFloat = true;\n pos += 1;\n endOfNumber = pos;\n } else if (isDoubleSuffix(ch)) {\n isReal = true;\n pos += 1;\n endOfNumber = pos;\n }\n if (isReal) {\n pushRealToken(subarray(start, endOfNumber), isFloat, start, endOfNumber);\n } else {\n pushIntToken(subarray(start, endOfNumber), false, start, endOfNumber);\n }\n }\n }\n\n function lexIdentifier() {\n var start = pos,\n substring,\n asString,\n idx;\n do {\n pos += 1;\n } while (isIdentifier(toProcess[pos]));\n substring = subarray(start, pos);\n\n // Check if this is the alternative (textual) representation of an operator (see\n // alternativeOperatorNames)\n if (pos - start === 2 || pos - start === 3) {\n asString = substring.toUpperCase();\n idx = ALTERNATIVE_OPERATOR_NAMES.indexOf(asString);\n if (idx >= 0) {\n pushOneCharOrTwoCharToken(_TokenKind.TokenKind.valueOf(asString), start, substring);\n return;\n }\n }\n tokens.push(new _Token.Token(_TokenKind.TokenKind.IDENTIFIER, substring.replace('\\0', ''), start, pos));\n }\n\n function pushIntToken(data, isLong, start, end) {\n if (isLong) {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_LONG, data, start, end));\n } else {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_INT, data, start, end));\n }\n }\n\n function pushHexIntToken(data, isLong, start, end) {\n if (data.length === 0) {\n if (isLong) {\n throw {\n name: 'SpelParseException',\n message: 'Not a long in expression (' + expressionString + ') at position ' + pos\n };\n } else {\n throw {\n name: 'SpelParseException',\n message: 'Not an int in expression (' + expressionString + ') at position ' + pos\n };\n }\n }\n if (isLong) {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_HEXLONG, data, start, end));\n } else {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_HEXINT, data, start, end));\n }\n }\n\n function pushRealToken(data, isFloat, start, end) {\n if (isFloat) {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_REAL_FLOAT, data, start, end));\n } else {\n tokens.push(new _Token.Token(_TokenKind.TokenKind.LITERAL_REAL, data, start, end));\n }\n }\n\n function subarray(start, end) {\n return toProcess.substring(start, end);\n }\n\n /**\n * Check if this might be a two character token.\n */\n function isTwoCharToken(kind) {\n if (kind.tokenChars.length === 2 && toProcess[pos] === kind.tokenChars[0]) {\n return toProcess[pos + 1] === kind.tokenChars[1];\n }\n return false;\n }\n\n /**\n * Push a token of just one character in length.\n */\n function pushCharToken(kind) {\n tokens.push(new _Token.Token(kind, null, pos, pos + 1));\n pos += 1;\n }\n\n /**\n * Push a token of two characters in length.\n */\n function pushPairToken(kind) {\n tokens.push(new _Token.Token(kind, null, pos, pos + 2));\n pos += 2;\n }\n\n function pushOneCharOrTwoCharToken(kind, pos, data) {\n tokens.push(new _Token.Token(kind, data, pos, pos + kind.getLength()));\n }\n\n // ID: ('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'$'|'0'..'9'|DOT_ESCAPED)*;\n function isIdentifier(ch) {\n return isAlphabetic(ch) || isDigit(ch) || ch === '_' || ch === '$';\n }\n\n function isChar(a, b) {\n var ch = toProcess[pos];\n return ch === a || ch === b;\n }\n\n function isExponentChar(ch) {\n return ch === 'e' || ch === 'E';\n }\n\n function isFloatSuffix(ch) {\n return ch === 'f' || ch === 'F';\n }\n\n function isDoubleSuffix(ch) {\n return ch === 'd' || ch === 'D';\n }\n\n function isSign(ch) {\n return ch === '+' || ch === '-';\n }\n\n function isDigit(ch) {\n if (ch.charCodeAt(0) > 255) {\n return false;\n }\n return (FLAGS[ch.charCodeAt(0)] & IS_DIGIT) !== 0;\n }\n\n function isAlphabetic(ch) {\n if (ch.charCodeAt(0) > 255) {\n return false;\n }\n return (FLAGS[ch.charCodeAt(0)] & IS_ALPHA) !== 0;\n }\n\n function isHexadecimalDigit(ch) {\n if (ch.charCodeAt(0) > 255) {\n return false;\n }\n return (FLAGS[ch.charCodeAt(0)] & IS_HEXDIGIT) !== 0;\n }\n\n process();\n\n return tokens;\n}\n\nvar Tokenizer = exports.Tokenizer = {\n tokenize: tokenize\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Token = undefined;\n\nvar _TokenKind = __webpack_require__(2);\n\nfunction Token(tokenKind, tokenData, startPos, endPos) {\n this.kind = tokenKind;\n this.startPos = startPos;\n this.endPos = endPos;\n if (tokenData) {\n this.data = tokenData;\n }\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nToken.prototype.getKind = function () {\n return this.kind;\n};\n\nToken.prototype.toString = function () {\n var s = '[';\n s += this.kind.toString();\n if (this.kind.hasPayload()) {\n s += ':' + this.data;\n }\n s += ']';\n s += '(' + this.startPos + ',' + this.endPos + ')';\n return s;\n};\n\nToken.prototype.isIdentifier = function () {\n return this.kind === _TokenKind.TokenKind.IDENTIFIER;\n};\n\nToken.prototype.isNumericRelationalOperator = function () {\n return this.kind === _TokenKind.TokenKind.GT || this.kind === _TokenKind.TokenKind.GE || this.kind === _TokenKind.TokenKind.LT || this.kind === _TokenKind.TokenKind.LE || this.kind === _TokenKind.TokenKind.EQ || this.kind === _TokenKind.TokenKind.NE;\n};\n\nToken.prototype.stringValue = function () {\n return this.data;\n};\n\nToken.prototype.asInstanceOfToken = function () {\n return new Token(_TokenKind.TokenKind.INSTANCEOF, this.startPos, this.endPos);\n};\n\nToken.prototype.asMatchesToken = function () {\n return new Token(_TokenKind.TokenKind.MATCHES, this.startPos, this.endPos);\n};\n\nToken.prototype.asBetweenToken = function () {\n return new Token(_TokenKind.TokenKind.BETWEEN, this.startPos, this.endPos);\n};\n\nToken.prototype.getStartPosition = function () {\n return this.startPos;\n};\n\nToken.prototype.getEndPosition = function () {\n return this.endPos;\n};\n\nexports.Token = Token;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.BooleanLiteral = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents the literal values TRUE and FALSE.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(value, position) {\n var node = _SpelNode.SpelNode.create('boolean', position);\n\n node.getValue = function () {\n return value;\n };\n\n node.setValue = function (newValue) {\n /*jshint -W093 */\n return value = newValue;\n /*jshint +W093 */\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar BooleanLiteral = exports.BooleanLiteral = {\n create: createNode\n};\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.NumberLiteral = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Expression language AST node that represents a literal number of any kind (since JavaScript only supports doubles anyway)\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(value, position) {\n var node = _SpelNode.SpelNode.create('number', position);\n\n node.getValue = function () {\n return value;\n };\n\n node.setValue = function (newValue) {\n /*jshint -W093 */\n return value = newValue;\n /*jshint +W093 */\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar NumberLiteral = exports.NumberLiteral = {\n create: createNode\n};\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.StringLiteral = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Expression language AST node that represents a string literal.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(value, position) {\n var node = _SpelNode.SpelNode.create('string', position);\n\n function stripQuotes(value) {\n if (value[0] === '\\'' && value[value.length - 1] === '\\'' || value[0] === '\"' && value[value.length - 1] === '\"') {\n value = value.substring(1, value.length - 1);\n }\n\n return value.replace(/''/g, '\\'').replace(/\"\"/g, '\"');\n }\n\n //value cannot be null so no check\n value = stripQuotes(value);\n\n node.getValue = function () {\n return value;\n };\n\n node.setValue = function (newValue) {\n /*jshint -W093 */\n return value = newValue;\n /*jshint +W093 */\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar StringLiteral = exports.StringLiteral = {\n create: createNode\n};\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.NullLiteral = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Expression language AST node that represents null.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(value, position) {\n var node = _SpelNode.SpelNode.create('null', position);\n\n node.getValue = function () {\n return null;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar NullLiteral = exports.NullLiteral = {\n create: createNode\n};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.FunctionReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\nvar _Stack = __webpack_require__(1);\n\n/**\n * A function reference is of the form \"#someFunction(a,b,c)\". Functions may be defined in\n * the context prior to the expression being evaluated or within the expression itself\n * using a lambda function definition. For example: Lambda function definition in an\n * expression: \"(#max = {|x,y|$x>$y?$x:$y};max(2,3))\" Calling context defined function:\n * \"#isEven(37)\". Functions may also be static java methods, registered in the context\n * prior to invocation of the expression.\n *\n * <p>Functions are very simplistic, the arguments are not part of the definition (right\n * now), so the names must be unique.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nfunction createNode(functionName, position, args) {\n var node = _SpelNode.SpelNode.create('function', position);\n\n node.getRaw = function () {\n return {\n functionName: functionName,\n args: args\n };\n };\n\n node.getValue = function (state) {\n var locals = state.locals || {},\n context = state.rootContext,\n compiledArgs = [];\n\n //populate arguments\n args.forEach(function (arg) {\n // reset the active context to root context for evaluating argument\n var currentActiveContext = state.activeContext;\n state.activeContext = new _Stack.Stack();\n state.activeContext.push(state.rootContext);\n\n // evaluate argument\n compiledArgs.push(arg.getValue(state));\n\n // reset the active context\n state.activeContext = currentActiveContext;\n });\n\n if (locals[functionName]) {\n return locals[functionName].apply(context, compiledArgs);\n }\n\n throw {\n name: 'FunctionDoesNotExistException',\n message: 'Function \\'' + functionName + '\\' does not exist.'\n };\n };\n\n return node;\n}\n\nvar FunctionReference = exports.FunctionReference = {\n create: createNode\n};\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.MethodReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\nvar _Stack = __webpack_require__(1);\n\n/**\n * Expression language AST node that represents a method reference.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ben March\n * @since 0.2.0\n */\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nfunction createNode(nullSafeNavigation, methodName, position, args) {\n var node = _SpelNode.SpelNode.create('method', position);\n\n node.getRaw = function () {\n return {\n methodName: methodName,\n args: args\n };\n };\n\n node.getValue = function (state) {\n var context = state.activeContext.peek(),\n compiledArgs = [],\n method;\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to look up property \\'' + methodName + '\\' for an undefined context.'\n };\n }\n\n //handle safe navigation\n function maybeHandleNullSafeNavigation(member) {\n if (member === undefined || member === null) {\n if (nullSafeNavigation) {\n return null;\n }\n\n throw {\n name: 'NullPointerException',\n message: 'Method ' + methodName + ' does not exist.'\n };\n }\n\n return member;\n }\n\n //populate arguments\n args.forEach(function (arg) {\n // reset the active context to root context for evaluating argument\n var currentActiveContext = state.activeContext;\n state.activeContext = new _Stack.Stack();\n state.activeContext.push(state.rootContext);\n\n // evaluate argument\n compiledArgs.push(arg.getValue(state));\n\n // reset the active context\n state.activeContext = currentActiveContext;\n });\n\n //accessors might not be available\n if (methodName.substr(0, 3) === 'get' && !context[methodName]) {\n return maybeHandleNullSafeNavigation(context[methodName.charAt(3).toLowerCase() + methodName.substring(4)]);\n }\n if (methodName.substr(0, 3) === 'set' && !context[methodName]) {\n /*jshint -W093 */\n return context[methodName.charAt(3).toLowerCase() + methodName.substring(4)] = compiledArgs[0];\n /*jshint +W093 */\n }\n\n //array methods\n if (Array.isArray(context)) {\n //size() -> length\n if (methodName === 'size') {\n return context.length;\n }\n\n if (methodName === 'contains') {\n return context.includes(compiledArgs[0]);\n }\n }\n\n method = maybeHandleNullSafeNavigation(context[methodName]);\n if (method) {\n return method.apply(context, compiledArgs);\n }\n return null;\n };\n\n return node;\n}\n\nvar MethodReference = exports.MethodReference = {\n create: createNode\n};\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.PropertyReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a simple property or field reference.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Clark Duplichien\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(nullSafeNavigation, propertyName, position) {\n var node = _SpelNode.SpelNode.create('property', position);\n\n node.getRaw = function () {\n return propertyName;\n };\n\n node.getValue = function (state) {\n var context = state.activeContext.peek();\n\n if (!context) {\n if (nullSafeNavigation) {\n return null;\n }\n\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to look up property \\'' + propertyName + '\\' for an undefined context.'\n };\n }\n\n if (context[propertyName] === undefined || context[propertyName] === null) {\n //handle safe navigation\n if (nullSafeNavigation) {\n return null;\n }\n\n //handle conversion of Java properties to JavaScript properties\n if (propertyName === 'size' && Array.isArray(context)) {\n return context.length;\n }\n\n throw {\n name: 'NullPointerException',\n message: 'Property \\'' + propertyName + '\\' does not exist.'\n };\n }\n\n return context[propertyName];\n };\n\n node.setValue = function (value, state) {\n var context = state.activeContext.peek();\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to assign property \\'' + propertyName + '\\' for an undefined context.'\n };\n }\n\n /*jshint -W093 */\n return context[propertyName] = value;\n /*jshint +W093 */\n };\n\n node.getName = function () {\n return propertyName;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar PropertyReference = exports.PropertyReference = {\n create: createNode\n};\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.VariableReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a variable reference, eg. #someVar. Note this is different to a *local*\n * variable like $someVar\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(variableName, position) {\n var node = _SpelNode.SpelNode.create('variable', position);\n\n node.getRaw = function () {\n return variableName;\n };\n\n node.getValue = function (state) {\n var context = state.activeContext.peek(),\n locals = state.locals;\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to look up variable \\'' + variableName + '\\' for an undefined context.'\n };\n }\n\n //there are 2 keywords (root, this) that need to be dealt with\n if (variableName === 'this') {\n return context;\n }\n if (variableName === 'root') {\n return state.rootContext;\n }\n\n return locals[variableName];\n };\n\n node.setValue = function (value, state) {\n var locals = state.locals;\n\n /*jshint -W093 */\n return locals[variableName] = value;\n /*jshint +W093 */\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar VariableReference = exports.VariableReference = {\n create: createNode\n};\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.CompoundExpression = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a DOT separated expression sequence, such as 'property1.property2.methodOne()'\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, expressionComponents) {\n var node = _SpelNode.SpelNode.create.apply(null, ['compound', position].concat(expressionComponents));\n\n function buildContextStack(state) {\n var childrenCount = node.getChildren().length,\n i;\n\n for (i = 0; i < childrenCount; i += 1) {\n if (node.getChildren()[i].getType() === 'indexer') {\n state.activeContext.push(state.activeContext.peek()[node.getChildren()[i].getValue(state)]);\n } else {\n state.activeContext.push(node.getChildren()[i].getValue(state));\n }\n }\n\n return function unbuildContextStack() {\n for (i = 0; i < childrenCount; i += 1) {\n state.activeContext.pop();\n }\n };\n }\n\n node.getValue = function (state) {\n var context = state.activeContext.peek(),\n value;\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to evaluate compound expression with an undefined context.'\n };\n }\n\n var unbuildContextStack = buildContextStack(state);\n\n value = state.activeContext.peek();\n\n unbuildContextStack();\n\n return value;\n };\n\n node.setValue = function (value, state) {\n var unbuildContextStack = buildContextStack(state),\n childCount = node.getChildren().length;\n\n state.activeContext.pop();\n\n value = node.getChildren()[childCount - 1].setValue(value, state);\n\n state.activeContext.push(null);\n\n unbuildContextStack();\n\n return value;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar CompoundExpression = exports.CompoundExpression = {\n create: createNode\n};\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Indexer = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\nvar _Stack = __webpack_require__(1);\n\n/**\n * An Indexer can index into some proceeding structure to access a particular piece of it.\n * Supported structures are: strings / collections (lists/sets) / arrays.\n *\n * @author Andy Clement\n * @author Phillip Webb\n * @author Stephane Nicoll\n * @author Ben March\n * @since 0.2.0\n */\n\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nfunction createNode(position, expressionComponents) {\n var node = _SpelNode.SpelNode.create.apply(null, ['indexer', position].concat(expressionComponents));\n\n node.getValue = function (state) {\n var activeContext = state.activeContext,\n context,\n childrenCount = node.getChildren().length,\n i,\n value;\n\n state.activeContext = new _Stack.Stack();\n state.activeContext.push(state.rootContext);\n\n context = state.activeContext.peek();\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to evaluate compound expression with an undefined context.'\n };\n }\n\n for (i = 0; i < childrenCount; i += 1) {\n state.activeContext.push(node.getChildren()[i].getValue(state));\n }\n\n value = state.activeContext.peek();\n\n for (i = 0; i < childrenCount; i += 1) {\n state.activeContext.pop();\n }\n\n state.activeContext = activeContext;\n\n return value;\n };\n\n //node.setContext(node.getValue());\n\n return node;\n}\n\nvar Indexer = exports.Indexer = {\n create: createNode\n};\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Assign = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents assignment. An alternative to calling setValue() for an expression is to use\n * an assign.\n *\n * <p>Example: 'someNumberProperty=42'\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, property, assignedValue) {\n var node = _SpelNode.SpelNode.create('assign', position, property, assignedValue);\n\n node.getValue = function (state) {\n var context = state.activeContext.peek();\n\n if (!context) {\n throw {\n name: 'ContextDoesNotExistException',\n message: 'Attempting to assign property \\'' + property.getValue(state) + '\\' for an undefined context.'\n };\n }\n\n return property.setValue(assignedValue.getValue(state), state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar Assign = exports.Assign = {\n create: createNode\n};\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpEQ = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the equality operator.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-eq', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) === right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpEQ = exports.OpEQ = {\n create: createNode\n};\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpNE = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the not-equal operator.\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-ne', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) !== right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpNE = exports.OpNE = {\n create: createNode\n};\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpGE = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements greater-than-or-equal operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-ge', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) >= right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpGE = exports.OpGE = {\n create: createNode\n};\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpGT = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the greater-than operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-gt', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) > right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpGT = exports.OpGT = {\n create: createNode\n};\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpLE = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the less-than-or-equal operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-le', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) <= right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpLE = exports.OpLE = {\n create: createNode\n};\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpLT = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the less-than operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-lt', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) < right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpLT = exports.OpLT = {\n create: createNode\n};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpPlus = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * The plus operator will:\n * <ul>\n * <li>add numbers\n * <li>concatenate strings\n * </ul>\n *\n * <p>It can be used as a unary operator for numbers.\n * The standard promotions are performed when the operand types vary (double+int=double).\n * For other options it defers to the registered overloader.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ivo Smid\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-plus', position, left, right);\n\n node.getValue = function (state) {\n if (!right) {\n return +left.getValue(state);\n }\n //javascript will handle string concatenation or addition depending on types\n return left.getValue(state) + right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpPlus = exports.OpPlus = {\n create: createNode\n};\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpMinus = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * The minus operator supports:\n * <ul>\n * <li>subtraction of numbers\n * <li>subtraction of an int from a string of one character\n * (effectively decreasing that character), so 'd'-3='a'\n * </ul>\n *\n * <p>It can be used as a unary operator for numbers.\n * The standard promotions are performed when the operand types vary (double-int=double).\n * For other options it defers to the registered overloader.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-minus', position, left, right);\n\n node.getValue = function (state) {\n if (!right) {\n return -left.getValue(state);\n }\n return left.getValue(state) - right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpMinus = exports.OpMinus = {\n create: createNode\n};\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpMultiply = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the {@code multiply} operator.\n *\n * <p>Conversions and promotions are handled as defined in\n * <a href=\"http://java.sun.com/docs/books/jls/third_edition/html/conversions.html\">Section 5.6.2 of the\n * Java Language Specification</a>, with the addiction of {@code BigDecimal}/{@code BigInteger} management:\n *\n * <p>If any of the operands is of a reference type, unboxing conversion (Section 5.1.8)\n * is performed. Then:<br>\n * If either operand is of type {@code BigDecimal}, the other is converted to {@code BigDecimal}.<br>\n * If either operand is of type double, the other is converted to double.<br>\n * Otherwise, if either operand is of type float, the other is converted to float.<br>\n * If either operand is of type {@code BigInteger}, the other is converted to {@code BigInteger}.<br>\n * Otherwise, if either operand is of type long, the other is converted to long.<br>\n * Otherwise, both operands are converted to type int.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Sam Brannen\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-multiply', position, left, right);\n\n node.getValue = function (state) {\n var leftValue = left.getValue(state),\n rightValue = right.getValue(state);\n\n if (typeof leftValue === 'number' && typeof rightValue === 'number') {\n return leftValue * rightValue;\n }\n\n //repeats (ex. 'abc' * 2 = 'abcabc')\n if (typeof leftValue === 'string' && typeof rightValue === 'number') {\n var s = '',\n i = 0;\n for (; i < rightValue; i += 1) {\n s += leftValue;\n }\n return s;\n }\n\n return null;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpMultiply = exports.OpMultiply = {\n create: createNode\n};\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpDivide = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements division operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-divide', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) / right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpDivide = exports.OpDivide = {\n create: createNode\n};\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpModulus = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the modulus operator.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-modulus', position, left, right);\n\n node.getValue = function (state) {\n return left.getValue(state) % right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpModulus = exports.OpModulus = {\n create: createNode\n};\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpPower = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * The power operator.\n *\n * @author Andy Clement\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, base, exp) {\n var node = _SpelNode.SpelNode.create('op-power', position, base, exp);\n\n node.getValue = function (state) {\n return Math.pow(base.getValue(state), exp.getValue(state));\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpPower = exports.OpPower = {\n create: createNode\n};\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpInc = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Increment operator. Can be used in a prefix or postfix form. This will throw\n * appropriate exceptions if the operand in question does not support increment.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, postfix, int) {\n var node = _SpelNode.SpelNode.create('op-inc', position, int);\n\n node.getValue = function (state) {\n var cur = int.getValue(state);\n int.setValue(cur + 1, state);\n if (postfix) {\n return cur;\n }\n return cur + 1;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpInc = exports.OpInc = {\n create: createNode\n};\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpDec = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Decrement operator. Can be used in a prefix or postfix form. This will throw\n * appropriate exceptions if the operand in question does not support decrement.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Giovanni Dall'Oglio Risso\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, postfix, int) {\n var node = _SpelNode.SpelNode.create('op-dec', position, int);\n\n node.getValue = function (state) {\n var cur = int.getValue(state);\n int.setValue(cur - 1, state);\n if (postfix) {\n return cur;\n }\n return cur - 1;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpDec = exports.OpDec = {\n create: createNode\n};\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpNot = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a NOT operation.\n *\n * @author Andy Clement\n * @author Mark Fisher\n * @author Oliver Becker\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, expr) {\n var node = _SpelNode.SpelNode.create('op-not', position, expr);\n\n node.getValue = function (state) {\n return !expr.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpNot = exports.OpNot = {\n create: createNode\n};\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpAnd = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents the boolean AND operation.\n *\n * @author Andy Clement\n * @author Mark Fisher\n * @author Oliver Becker\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-and', position, left, right);\n\n node.getValue = function (state) {\n //double bang for javascript\n return !!left.getValue(state) && !!right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpAnd = exports.OpAnd = {\n create: createNode\n};\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpOr = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents the boolean OR operation.\n *\n * @author Andy Clement\n * @author Mark Fisher\n * @author Oliver Becker\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('op-or', position, left, right);\n\n node.getValue = function (state) {\n //double bang for javascript\n return !!left.getValue(state) || !!right.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpOr = exports.OpOr = {\n create: createNode\n};\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpMatches = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Implements the matches operator. Matches takes two operands:\n * The first is a String and the second is a Java regex.\n * It will return {@code true} when {@link #getValue} is called\n * if the first operand matches the regex.\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Chris Thielen\n * @since 3.0\n */\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('matches', position, left, right);\n\n /**\n * Check the first operand matches the regex specified as the second operand.\n * @param state the expression state\n * @return {@code true} if the first operand matches the regex specified as the\n * second operand, otherwise {@code false}\n * @throws EvaluationException if there is a problem evaluating the expression\n * (e.g. the regex is invalid)\n */\n node.getValue = function (state) {\n var data = left.getValue(state);\n var regexpString = right.getValue(state);\n\n try {\n var regexp = new RegExp(regexpString);\n return !!regexp.exec(data);\n } catch (error) {\n throw {\n name: 'EvaluationException',\n message: error.toString()\n };\n }\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpMatches = exports.OpMatches = {\n create: createNode\n};\n\n/***/ }),\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Ternary = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a ternary expression, for example: \"someCheck()?true:false\".\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, expression, ifTrue, ifFalse) {\n var node = _SpelNode.SpelNode.create('ternary', position, expression, ifTrue, ifFalse);\n\n node.getValue = function (state) {\n return expression.getValue(state) ? ifTrue.getValue(state) : ifFalse.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar Ternary = exports.Ternary = {\n create: createNode\n};\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Elvis = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents the elvis operator ?:. For an expression \"a?:b\" if a is not null, the value\n * of the expression is \"a\", if a is null then the value of the expression is \"b\".\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, expression, ifFalse) {\n var node = _SpelNode.SpelNode.create('elvis', position, expression, ifFalse);\n\n node.getValue = function (state) {\n return expression.getValue(state) !== null ? expression.getValue(state) : ifFalse.getValue(state);\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar Elvis = exports.Elvis = {\n create: createNode\n};\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.InlineList = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represent a list in an expression, e.g. '{1,2,3}'\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, elements) {\n var node = _SpelNode.SpelNode.create('list', position),\n list = [].concat(elements || []);\n\n node.getRaw = function () {\n return list;\n };\n\n node.getValue = function (state) {\n return list.map(function (element) {\n return element.getValue(state);\n });\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar InlineList = exports.InlineList = {\n create: createNode\n};\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.InlineMap = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represent a map in an expression, e.g. '{name:'foo',age:12}'\n *\n * @author Andy Clement\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction createNode(position, elements) {\n var node = _SpelNode.SpelNode.create('map', position),\n mapPieces = [].concat(elements || []);\n\n node.getValue = function (state) {\n var key = true,\n keyValue = null,\n map = {};\n\n mapPieces.forEach(function (piece) {\n if (key) {\n //unquoted property names come as type \"property\" but should be treated as strings\n if (piece.getType() === 'property') {\n keyValue = piece.getName();\n } else {\n keyValue = piece.getValue(state);\n }\n } else {\n map[keyValue] = piece.getValue(state);\n }\n key = !key;\n });\n\n return map;\n };\n\n return node;\n} /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar InlineMap = exports.InlineMap = {\n create: createNode\n};\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Selection = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents selection over a map or collection.\n * For example: {1,2,3,4,5,6,7,8,9,10}.?{#isEven(#this) == 'y'} returns [2, 4, 6, 8, 10]\n *\n * <p>Basically a subset of the input data is returned based on the\n * evaluation of the expression supplied as selection criteria.\n *\n * @author Andy Clement\n * @author Mark Fisher\n * @author Sam Brannen\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction matches(element, expr, state) {\n var doesMatch = false;\n state.activeContext.push(element);\n doesMatch = expr.getValue(state);\n state.activeContext.pop();\n return doesMatch;\n}\n\nfunction selectFromArray(collection, whichElement, expr, state) {\n var newCollection = collection.filter(function (element) {\n return matches(element, expr, state);\n });\n\n switch (whichElement) {\n case 'ALL':\n return newCollection;\n case 'FIRST':\n return newCollection[0] || null;\n case 'LAST':\n if (newCollection.length) {\n return newCollection[newCollection.length - 1];\n }\n return null;\n }\n}\n\nfunction selectFromMap(collection, whichElement, expr, state) {\n var newCollection = {},\n entry,\n key,\n entries = [],\n returnValue = {};\n\n for (key in collection) {\n if (collection.hasOwnProperty(key)) {\n entry = {\n key: key,\n value: collection[key]\n };\n if (matches(entry, expr, state)) {\n entries.push(entry);\n }\n }\n }\n\n switch (whichElement) {\n case 'ALL':\n entries.forEach(function (entry) {\n newCollection[entry.key] = entry.value;\n });\n return newCollection;\n case 'FIRST':\n if (entries.length) {\n returnValue[entries[0].key] = entries[0].value;\n return returnValue;\n }\n return null;\n case 'LAST':\n if (entries.length) {\n returnValue[entries[entries.length - 1].key] = entries[entries.length - 1].value;\n return returnValue;\n }\n return null;\n }\n\n entries.forEach(function (entry) {\n newCollection[entry.key] = entry.value;\n });\n}\n\nfunction createNode(nullSafeNavigation, whichElement, position, expr) {\n var node = _SpelNode.SpelNode.create('selection', position, expr);\n\n node.getValue = function (state) {\n var collection = state.activeContext.peek();\n\n if (collection) {\n if (Array.isArray(collection)) {\n return selectFromArray(collection, whichElement, expr, state);\n } else if ((typeof collection === 'undefined' ? 'undefined' : _typeof(collection)) === 'object') {\n return selectFromMap(collection, whichElement, expr, state);\n }\n }\n\n return null;\n };\n\n return node;\n}\n\nvar Selection = exports.Selection = {\n create: createNode,\n FIRST: 'FIRST',\n LAST: 'LAST',\n ALL: 'ALL'\n};\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Projection = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; /*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents projection, where a given operation is performed on all elements in some\n * input sequence, returning a new sequence of the same size. For example:\n * \"{1,2,3,4,5,6,7,8,9,10}.!{#isEven(#this)}\" returns \"[n, y, n, y, n, y, n, y, n, y]\"\n *\n * @author Andy Clement\n * @author Mark Fisher\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction projectCollection(collection, expr, state) {\n return collection.map(function (element) {\n var matches;\n state.activeContext.push(element);\n matches = expr.getValue(state);\n state.activeContext.pop();\n return matches;\n });\n}\n\nfunction createNode(nullSafeNavigation, position, expr) {\n var node = _SpelNode.SpelNode.create('projection', position, expr);\n\n node.getValue = function (state) {\n var collection = state.activeContext.peek(),\n entries = [],\n key;\n\n if (Array.isArray(collection)) {\n return projectCollection(collection, expr, state);\n } else if ((typeof collection === 'undefined' ? 'undefined' : _typeof(collection)) === 'object') {\n for (key in collection) {\n if (collection.hasOwnProperty(key)) {\n entries.push(collection[key]);\n }\n }\n return projectCollection(entries, expr, state);\n }\n\n return null;\n };\n\n return node;\n}\n\nvar Projection = exports.Projection = {\n create: createNode\n};\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpInstanceof = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * The operator 'instanceof' checks if an object is of the class specified in the right\n * hand operand, in the same way that {@code instanceof} does in Java.\n *\n * THIS OPERATOR IS NOT IMPLEMENTED AND WILL THROW AN EXCEPTION\n *\n * @author Andy Clement\n * @since 3.0\n */\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('instanceof', position, left, right);\n\n /**\n * Compare the left operand to see it is an instance of the type specified as the\n * right operand. The right operand must be a class.\n * @param state the expression state\n * @return {@code true} if the left operand is an instanceof of the right operand,\n * otherwise {@code false}\n * @throws EvaluationException if there is a problem evaluating the expression\n */\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'OpInstanceOf: Not implemented'\n };\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpInstanceof = exports.OpInstanceof = {\n create: createNode\n};\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.OpBetween = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents the between operator. The left operand to between must be a single value and\n * the right operand must be a list - this operator returns true if the left operand is\n * between (using the registered comparator) the two elements in the list. The definition\n * of between being inclusive follows the SQL BETWEEN definition.\n *\n * @author Andy Clement\n * @since 3.0\n */\nfunction createNode(position, left, right) {\n var node = _SpelNode.SpelNode.create('between', position, left, right);\n\n /**\n * Returns a boolean based on whether a value is in the range expressed. The first\n * operand is any value whilst the second is a list of two values - those two values\n * being the bounds allowed for the first operand (inclusive).\n * @param state the expression state\n * @return true if the left operand is in the range specified, false otherwise\n * @throws EvaluationException if there is a problem evaluating the expression\n */\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'OpBetween: Not implemented'\n };\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar OpBetween = exports.OpBetween = {\n create: createNode\n};\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.TypeReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a reference to a type, for example\n * {@code \"T(String)\" or \"T(com.somewhere.Foo)\"}.\n *\n * @author Andy Clement\n */\nfunction createNode(position, node, _dims) {\n var node = _SpelNode.SpelNode.create('typeref', position, node);\n\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'TypeReference: Not implemented'\n };\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar TypeReference = exports.TypeReference = {\n create: createNode\n};\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.BeanReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * Represents a bean reference to a type, for example <tt>@foo</tt> or <tt>@'foo.bar'</tt>.\n * For a FactoryBean the syntax <tt>&foo</tt> can be used to access the factory itself.\n *\n * @author Andy Clement\n */\nfunction createNode(position, beanName) {\n var node = _SpelNode.SpelNode.create('beanref', position);\n\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'BeanReference: Not implemented'\n };\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar BeanReference = exports.BeanReference = {\n create: createNode\n};\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Identifier = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\n/**\n * An 'identifier' {@link SpelNode}.\n *\n * @author Andy Clement\n * @since 3.0\n */\nfunction createNode(identifierName, position) {\n var node = _SpelNode.SpelNode.create('identifier', position);\n\n node.getRaw = function () {\n return identifierName;\n };\n\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'Identifier: Not implemented'\n };\n };\n\n return node;\n} /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar Identifier = exports.Identifier = {\n create: createNode\n};\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.QualifiedIdentifier = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Represents a dot separated sequence of strings that indicate a package qualified type\n * reference.\n *\n * <p>Example: \"java.lang.String\" as in the expression \"new java.lang.String('hello')\"\n *\n * @author Andy Clement\n * @since 3.0\n */\nfunction createNode(position, pieces) {\n var node = _SpelNode.SpelNode.create.apply(_SpelNode.SpelNode, ['qualifiedidentifier', position].concat(_toConsumableArray(pieces)));\n\n node.getRaw = function () {\n return pieces.map(function (p) {\n return p.getRaw();\n });\n };\n\n node.getValue = function (state) {\n throw {\n name: 'MethodNotImplementedException',\n message: 'QualifiedIdentifier: Not implemented'\n };\n };\n\n return node;\n}\n\nvar QualifiedIdentifier = exports.QualifiedIdentifier = {\n create: createNode\n};\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.ConstructorReference = undefined;\n\nvar _SpelNode = __webpack_require__(0);\n\nvar _Stack = __webpack_require__(1);\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); } /*\n * Copyright 2002-2019 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Represents the invocation of a constructor. Either a constructor on a regular type or\n * construction of an array. When an array is constructed, an initializer can be specified.\n *\n * <p>Examples:<br>\n * new String('hello world')<br>\n * new int[]{1,2,3,4}<br>\n * new int[3] new int[3]{1,2,3}\n *\n * @author Andy Clement\n * @author Juergen Hoeller\n * @since 3.0\n */\nfunction createNode(position, dimensions, nodes) {\n var isArray = nodes !== undefined;\n var dimension;\n if (isArray) {\n dimension = dimensions.length && dimensions[0] && dimensions[0].getType() === 'number' ? dimensions[0].getValue() : null;\n } else {\n nodes = dimensions;\n dimensions = undefined;\n }\n\n var _nodes = nodes,\n _nodes2 = _toArray(_nodes),\n _qualifiedIdentifier = _nodes2[0],\n args = _nodes2.slice(1);\n\n var node = _SpelNode.SpelNode.create.apply(_SpelNode.SpelNode, ['constructorref', position].concat(_toConsumableArray(nodes)));\n\n node.getRaw = function () {\n return dimension;\n };\n\n node.getValue = function (state) {\n if (isArray && args.length <= 1) {\n var compiledArgs = [];\n\n //populate arguments\n args.forEach(function (arg) {\n // reset the active context to root context for evaluating argument\n var currentActiveContext = state.activeContext;\n state.activeContext = new _Stack.Stack();\n state.activeContext.push(state.rootContext);\n\n // evaluate argument\n compiledArgs.push(arg.getValue(state));\n\n // reset the active context\n state.activeContext = currentActiveContext;\n });\n\n if (args.length === 1) {\n return compiledArgs[0];\n } else {\n return dimension ? new Array(dimension) : [];\n }\n }\n\n throw {\n name: 'MethodNotImplementedException',\n message: 'ConstructorReference: Not implemented'\n };\n };\n\n return node;\n}\n\nvar ConstructorReference = exports.ConstructorReference = {\n create: createNode\n};\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n/*\n * Copyright 2002-2015 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author Ben March\n * @since 0.2.0\n */\n\nfunction create(authentication, principal) {\n var context = {};\n\n context.authentication = authentication || {};\n context.principal = principal || {};\n\n context.hasRole = function (role) {\n var hasRole = false;\n\n if (!role) {\n return false;\n }\n if (!context.authentication && !Array.isArray(context.authentication.authorities)) {\n return false;\n }\n\n context.authentication.authorities.forEach(function (grantedAuthority) {\n if (grantedAuthority.authority.toLowerCase() === role.toLowerCase()) {\n hasRole = true;\n }\n });\n\n return hasRole;\n };\n\n context.hasPermission = function () /*variable arguments*/{\n var args = Array.prototype.slice.call(arguments);\n\n if (args.length === 1) {\n return context.hasRole(args[0]);\n }\n };\n\n return context;\n}\n\nvar StandardContext = exports.StandardContext = {\n create: create\n};\n\n/***/ })\n/******/ ]);\n});","var baseIsMap = require('./_baseIsMap'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nmodule.exports = isMap;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__200__;","module.exports = __WEBPACK_EXTERNAL_MODULE__211__;","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\nmodule.exports = setCacheAdd;\n","var baseAssignValue = require('./_baseAssignValue'),\n eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nmodule.exports = assignMergeValue;\n","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nmodule.exports = stringToPath;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nmodule.exports = baseUnary;\n","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n}\n\nmodule.exports = baseSlice;\n","var arrayMap = require('./_arrayMap'),\n baseIteratee = require('./_baseIteratee'),\n basePickBy = require('./_basePickBy'),\n getAllKeysIn = require('./_getAllKeysIn');\n\n/**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\nfunction pickBy(object, predicate) {\n if (object == null) {\n return {};\n }\n var props = arrayMap(getAllKeysIn(object), function(prop) {\n return [prop];\n });\n predicate = baseIteratee(predicate);\n return basePickBy(object, props, function(value, path) {\n return predicate(value, path[0]);\n });\n}\n\nmodule.exports = pickBy;\n","module.exports = require('./lib/SqlString');\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorValues(e) {\n if (null != e) {\n var t = e[\"function\" == typeof Symbol && Symbol.iterator || \"@@iterator\"],\n r = 0;\n if (t) return t.call(e);\n if (\"function\" == typeof e.next) return e;\n if (!isNaN(e.length)) return {\n next: function next() {\n return e && r >= e.length && (e = void 0), {\n value: e && e[r++],\n done: !e\n };\n }\n };\n }\n throw new TypeError(_typeof(e) + \" is not iterable\");\n}\nmodule.exports = _regeneratorValues, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var regeneratorDefine = require(\"./regeneratorDefine.js\");\nfunction _regenerator() {\n /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */\n var e,\n t,\n r = \"function\" == typeof Symbol ? Symbol : {},\n n = r.iterator || \"@@iterator\",\n o = r.toStringTag || \"@@toStringTag\";\n function i(r, n, o, i) {\n var c = n && n.prototype instanceof Generator ? n : Generator,\n u = Object.create(c.prototype);\n return regeneratorDefine(u, \"_invoke\", function (r, n, o) {\n var i,\n c,\n u,\n f = 0,\n p = o || [],\n y = !1,\n G = {\n p: 0,\n n: 0,\n v: e,\n a: d,\n f: d.bind(e, 4),\n d: function d(t, r) {\n return i = t, c = 0, u = e, G.n = r, a;\n }\n };\n function d(r, n) {\n for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {\n var o,\n i = p[t],\n d = G.p,\n l = i[2];\n r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));\n }\n if (o || r > 1) return a;\n throw y = !0, n;\n }\n return function (o, p, l) {\n if (f > 1) throw TypeError(\"Generator is already running\");\n for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {\n i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);\n try {\n if (f = 2, i) {\n if (c || (o = \"next\"), t = i[o]) {\n if (!(t = t.call(i, u))) throw TypeError(\"iterator result is not an object\");\n if (!t.done) return t;\n u = t.value, c < 2 && (c = 0);\n } else 1 === c && (t = i[\"return\"]) && t.call(i), c < 2 && (u = TypeError(\"The iterator does not provide a '\" + o + \"' method\"), c = 1);\n i = e;\n } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;\n } catch (t) {\n i = e, c = 1, u = t;\n } finally {\n f = 1;\n }\n }\n return {\n value: t,\n done: y\n };\n };\n }(r, o, i), !0), u;\n }\n var a = {};\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n t = Object.getPrototypeOf;\n var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function () {\n return this;\n }), t),\n u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);\n function f(e) {\n return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, \"GeneratorFunction\")), e.prototype = Object.create(u), e;\n }\n return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, \"constructor\", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction), GeneratorFunction.displayName = \"GeneratorFunction\", regeneratorDefine(GeneratorFunctionPrototype, o, \"GeneratorFunction\"), regeneratorDefine(u), regeneratorDefine(u, o, \"Generator\"), regeneratorDefine(u, n, function () {\n return this;\n }), regeneratorDefine(u, \"toString\", function () {\n return \"[object Generator]\";\n }), (module.exports = _regenerator = function _regenerator() {\n return {\n w: i,\n m: f\n };\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports)();\n}\nmodule.exports = _regenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n}\n\nmodule.exports = shortOut;\n","/* globals define,module */\n/*\nUsing a Universal Module Loader that should be browser, require, and AMD friendly\nhttp://ricostacruz.com/cheatsheets/umdjs.html\n*/\n;(function(root, factory) {\n if (typeof define === \"function\" && define.amd) {\n define(factory);\n } else if (typeof exports === \"object\") {\n module.exports = factory();\n } else {\n root.jsonLogic = factory();\n }\n}(this, function() {\n \"use strict\";\n /* globals console:false */\n\n if ( ! Array.isArray) {\n Array.isArray = function(arg) {\n return Object.prototype.toString.call(arg) === \"[object Array]\";\n };\n }\n\n /**\n * Return an array that contains no duplicates (original not modified)\n * @param {array} array Original reference array\n * @return {array} New array with no duplicates\n */\n function arrayUnique(array) {\n var a = [];\n for (var i=0, l=array.length; i<l; i++) {\n if (a.indexOf(array[i]) === -1) {\n a.push(array[i]);\n }\n }\n return a;\n }\n\n var jsonLogic = {};\n var operations = {\n \"==\": function(a, b) {\n return a == b;\n },\n \"===\": function(a, b) {\n return a === b;\n },\n \"!=\": function(a, b) {\n return a != b;\n },\n \"!==\": function(a, b) {\n return a !== b;\n },\n \">\": function(a, b) {\n return a > b;\n },\n \">=\": function(a, b) {\n return a >= b;\n },\n \"<\": function(a, b, c) {\n return (c === undefined) ? a < b : (a < b) && (b < c);\n },\n \"<=\": function(a, b, c) {\n return (c === undefined) ? a <= b : (a <= b) && (b <= c);\n },\n \"!!\": function(a) {\n return jsonLogic.truthy(a);\n },\n \"!\": function(a) {\n return !jsonLogic.truthy(a);\n },\n \"%\": function(a, b) {\n return a % b;\n },\n \"log\": function(a) {\n console.log(a); return a;\n },\n \"in\": function(a, b) {\n if (!b || typeof b.indexOf === \"undefined\") return false;\n return (b.indexOf(a) !== -1);\n },\n \"cat\": function() {\n return Array.prototype.join.call(arguments, \"\");\n },\n \"substr\": function(source, start, end) {\n if (end < 0) {\n // JavaScript doesn't support negative end, this emulates PHP behavior\n var temp = String(source).substr(start);\n return temp.substr(0, temp.length + end);\n }\n return String(source).substr(start, end);\n },\n \"+\": function() {\n return Array.prototype.reduce.call(arguments, function(a, b) {\n return parseFloat(a, 10) + parseFloat(b, 10);\n }, 0);\n },\n \"*\": function() {\n return Array.prototype.reduce.call(arguments, function(a, b) {\n return parseFloat(a, 10) * parseFloat(b, 10);\n });\n },\n \"-\": function(a, b) {\n if (b === undefined) {\n return -a;\n } else {\n return a - b;\n }\n },\n \"/\": function(a, b) {\n return a / b;\n },\n \"min\": function() {\n return Math.min.apply(this, arguments);\n },\n \"max\": function() {\n return Math.max.apply(this, arguments);\n },\n \"merge\": function() {\n return Array.prototype.reduce.call(arguments, function(a, b) {\n return a.concat(b);\n }, []);\n },\n \"var\": function(a, b) {\n var not_found = (b === undefined) ? null : b;\n var data = this;\n if (typeof a === \"undefined\" || a===\"\" || a===null) {\n return data;\n }\n var sub_props = String(a).split(\".\");\n for (var i = 0; i < sub_props.length; i++) {\n if (data === null || data === undefined) {\n return not_found;\n }\n // Descending into data\n data = data[sub_props[i]];\n if (data === undefined) {\n return not_found;\n }\n }\n return data;\n },\n \"missing\": function() {\n /*\n Missing can receive many keys as many arguments, like {\"missing:[1,2]}\n Missing can also receive *one* argument that is an array of keys,\n which typically happens if it's actually acting on the output of another command\n (like 'if' or 'merge')\n */\n\n var missing = [];\n var keys = Array.isArray(arguments[0]) ? arguments[0] : arguments;\n\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n var value = jsonLogic.apply({\"var\": key}, this);\n if (value === null || value === \"\") {\n missing.push(key);\n }\n }\n\n return missing;\n },\n \"missing_some\": function(need_count, options) {\n // missing_some takes two arguments, how many (minimum) items must be present, and an array of keys (just like 'missing') to check for presence.\n var are_missing = jsonLogic.apply({\"missing\": options}, this);\n\n if (options.length - are_missing.length >= need_count) {\n return [];\n } else {\n return are_missing;\n }\n },\n };\n\n jsonLogic.is_logic = function(logic) {\n return (\n typeof logic === \"object\" && // An object\n logic !== null && // but not null\n ! Array.isArray(logic) && // and not an array\n Object.keys(logic).length === 1 // with exactly one key\n );\n };\n\n /*\n This helper will defer to the JsonLogic spec as a tie-breaker when different language interpreters define different behavior for the truthiness of primitives. E.g., PHP considers empty arrays to be falsy, but Javascript considers them to be truthy. JsonLogic, as an ecosystem, needs one consistent answer.\n\n Spec and rationale here: http://jsonlogic.com/truthy\n */\n jsonLogic.truthy = function(value) {\n if (Array.isArray(value) && value.length === 0) {\n return false;\n }\n return !! value;\n };\n\n\n jsonLogic.get_operator = function(logic) {\n return Object.keys(logic)[0];\n };\n\n jsonLogic.get_values = function(logic) {\n return logic[jsonLogic.get_operator(logic)];\n };\n\n jsonLogic.apply = function(logic, data) {\n // Does this array contain logic? Only one way to find out.\n if (Array.isArray(logic)) {\n return logic.map(function(l) {\n return jsonLogic.apply(l, data);\n });\n }\n // You've recursed to a primitive, stop!\n if ( ! jsonLogic.is_logic(logic) ) {\n return logic;\n }\n\n var op = jsonLogic.get_operator(logic);\n var values = logic[op];\n var i;\n var current;\n var scopedLogic;\n var scopedData;\n var initial;\n\n // easy syntax for unary operators, like {\"var\" : \"x\"} instead of strict {\"var\" : [\"x\"]}\n if ( ! Array.isArray(values)) {\n values = [values];\n }\n\n // 'if', 'and', and 'or' violate the normal rule of depth-first calculating consequents, let each manage recursion as needed.\n if (op === \"if\" || op == \"?:\") {\n /* 'if' should be called with a odd number of parameters, 3 or greater\n This works on the pattern:\n if( 0 ){ 1 }else{ 2 };\n if( 0 ){ 1 }else if( 2 ){ 3 }else{ 4 };\n if( 0 ){ 1 }else if( 2 ){ 3 }else if( 4 ){ 5 }else{ 6 };\n\n The implementation is:\n For pairs of values (0,1 then 2,3 then 4,5 etc)\n If the first evaluates truthy, evaluate and return the second\n If the first evaluates falsy, jump to the next pair (e.g, 0,1 to 2,3)\n given one parameter, evaluate and return it. (it's an Else and all the If/ElseIf were false)\n given 0 parameters, return NULL (not great practice, but there was no Else)\n */\n for (i = 0; i < values.length - 1; i += 2) {\n if ( jsonLogic.truthy( jsonLogic.apply(values[i], data) ) ) {\n return jsonLogic.apply(values[i+1], data);\n }\n }\n if (values.length === i+1) {\n return jsonLogic.apply(values[i], data);\n }\n return null;\n } else if (op === \"and\") { // Return first falsy, or last\n for (i=0; i < values.length; i+=1) {\n current = jsonLogic.apply(values[i], data);\n if ( ! jsonLogic.truthy(current)) {\n return current;\n }\n }\n return current; // Last\n } else if (op === \"or\") {// Return first truthy, or last\n for (i=0; i < values.length; i+=1) {\n current = jsonLogic.apply(values[i], data);\n if ( jsonLogic.truthy(current) ) {\n return current;\n }\n }\n return current; // Last\n } else if (op === \"filter\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n\n if ( ! Array.isArray(scopedData)) {\n return [];\n }\n // Return only the elements from the array in the first argument,\n // that return truthy when passed to the logic in the second argument.\n // For parity with JavaScript, reindex the returned array\n return scopedData.filter(function(datum) {\n return jsonLogic.truthy( jsonLogic.apply(scopedLogic, datum));\n });\n } else if (op === \"map\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n\n if ( ! Array.isArray(scopedData)) {\n return [];\n }\n\n return scopedData.map(function(datum) {\n return jsonLogic.apply(scopedLogic, datum);\n });\n } else if (op === \"reduce\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n initial = typeof values[2] !== \"undefined\" ? values[2] : null;\n\n if ( ! Array.isArray(scopedData)) {\n return initial;\n }\n\n return scopedData.reduce(\n function(accumulator, current) {\n return jsonLogic.apply(\n scopedLogic,\n {current: current, accumulator: accumulator}\n );\n },\n initial\n );\n } else if (op === \"all\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n // All of an empty set is false. Note, some and none have correct fallback after the for loop\n if ( ! Array.isArray(scopedData) || ! scopedData.length) {\n return false;\n }\n for (i=0; i < scopedData.length; i+=1) {\n if ( ! jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {\n return false; // First falsy, short circuit\n }\n }\n return true; // All were truthy\n } else if (op === \"none\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n\n if ( ! Array.isArray(scopedData) || ! scopedData.length) {\n return true;\n }\n for (i=0; i < scopedData.length; i+=1) {\n if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {\n return false; // First truthy, short circuit\n }\n }\n return true; // None were truthy\n } else if (op === \"some\") {\n scopedData = jsonLogic.apply(values[0], data);\n scopedLogic = values[1];\n\n if ( ! Array.isArray(scopedData) || ! scopedData.length) {\n return false;\n }\n for (i=0; i < scopedData.length; i+=1) {\n if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {\n return true; // First truthy, short circuit\n }\n }\n return false; // None were truthy\n }\n\n // Everyone else gets immediate depth-first recursion\n values = values.map(function(val) {\n return jsonLogic.apply(val, data);\n });\n\n\n // The operation is called with \"data\" bound to its \"this\" and \"values\" passed as arguments.\n // Structured commands like % or > can name formal arguments while flexible commands (like missing or merge) can operate on the pseudo-array arguments\n // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments\n if (operations.hasOwnProperty(op) && typeof operations[op] === \"function\") {\n return operations[op].apply(data, values);\n } else if (op.indexOf(\".\") > 0) { // Contains a dot, and not in the 0th position\n var sub_ops = String(op).split(\".\");\n var operation = operations;\n for (i = 0; i < sub_ops.length; i++) {\n if (!operation.hasOwnProperty(sub_ops[i])) {\n throw new Error(\"Unrecognized operation \" + op +\n \" (failed at \" + sub_ops.slice(0, i+1).join(\".\") + \")\");\n }\n // Descending into operations\n operation = operation[sub_ops[i]];\n }\n\n return operation.apply(data, values);\n }\n\n throw new Error(\"Unrecognized operation \" + op );\n };\n\n jsonLogic.uses_data = function(logic) {\n var collection = [];\n\n if (jsonLogic.is_logic(logic)) {\n var op = jsonLogic.get_operator(logic);\n var values = logic[op];\n\n if ( ! Array.isArray(values)) {\n values = [values];\n }\n\n if (op === \"var\") {\n // This doesn't cover the case where the arg to var is itself a rule.\n collection.push(values[0]);\n } else {\n // Recursion!\n values.forEach(function(val) {\n collection.push.apply(collection, jsonLogic.uses_data(val) );\n });\n }\n }\n\n return arrayUnique(collection);\n };\n\n jsonLogic.add_operation = function(name, code) {\n operations[name] = code;\n };\n\n jsonLogic.rm_operation = function(name) {\n delete operations[name];\n };\n\n jsonLogic.rule_like = function(rule, pattern) {\n // console.log(\"Is \". JSON.stringify(rule) . \" like \" . JSON.stringify(pattern) . \"?\");\n if (pattern === rule) {\n return true;\n } // TODO : Deep object equivalency?\n if (pattern === \"@\") {\n return true;\n } // Wildcard!\n if (pattern === \"number\") {\n return (typeof rule === \"number\");\n }\n if (pattern === \"string\") {\n return (typeof rule === \"string\");\n }\n if (pattern === \"array\") {\n // !logic test might be superfluous in JavaScript\n return Array.isArray(rule) && ! jsonLogic.is_logic(rule);\n }\n\n if (jsonLogic.is_logic(pattern)) {\n if (jsonLogic.is_logic(rule)) {\n var pattern_op = jsonLogic.get_operator(pattern);\n var rule_op = jsonLogic.get_operator(rule);\n\n if (pattern_op === \"@\" || pattern_op === rule_op) {\n // echo \"\\nOperators match, go deeper\\n\";\n return jsonLogic.rule_like(\n jsonLogic.get_values(rule, false),\n jsonLogic.get_values(pattern, false)\n );\n }\n }\n return false; // pattern is logic, rule isn't, can't be eq\n }\n\n if (Array.isArray(pattern)) {\n if (Array.isArray(rule)) {\n if (pattern.length !== rule.length) {\n return false;\n }\n /*\n Note, array order MATTERS, because we're using this array test logic to consider arguments, where order can matter. (e.g., + is commutative, but '-' or 'if' or 'var' are NOT)\n */\n for (var i = 0; i < pattern.length; i += 1) {\n // If any fail, we fail\n if ( ! jsonLogic.rule_like(rule[i], pattern[i])) {\n return false;\n }\n }\n return true; // If they *all* passed, we pass\n } else {\n return false; // Pattern is array, rule isn't\n }\n }\n\n // Not logic, not array, not a === match for rule.\n return false;\n };\n\n return jsonLogic;\n}));\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n var length = array.length,\n result = new array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\nmodule.exports = initCloneArray;\n","var isStrictComparable = require('./_isStrictComparable'),\n keys = require('./keys');\n\n/**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n var result = keys(object),\n length = result.length;\n\n while (length--) {\n var key = result[length],\n value = object[key];\n\n result[length] = [key, value, isStrictComparable(value)];\n }\n return result;\n}\n\nmodule.exports = getMatchData;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","import '@react-awesome-query-builder/ui';\nimport { toOption as toOption$1 } from '@grafana/data';\nimport 'lodash';\nimport '@grafana/ui';\nimport 'react';\nimport '../SQLEditor/standardSql/language.js';\nimport 'uuid';\nimport '@grafana/runtime';\nimport '../SQLEditor/utils/debugger.js';\nimport '../SQLEditor/standardSql/macros.js';\n\nvar _a;\nvar QueryFormat = /* @__PURE__ */ ((QueryFormat2) => {\n QueryFormat2[QueryFormat2[\"Timeseries\"] = 0] = \"Timeseries\";\n QueryFormat2[QueryFormat2[\"Table\"] = 1] = \"Table\";\n QueryFormat2[QueryFormat2[\"Logs\"] = 2] = \"Logs\";\n QueryFormat2[QueryFormat2[\"Trace\"] = 3] = \"Trace\";\n QueryFormat2[QueryFormat2[\"OptionMulti\"] = 4] = \"OptionMulti\";\n return QueryFormat2;\n})(QueryFormat || {});\nvar EditorMode = /* @__PURE__ */ ((EditorMode2) => {\n EditorMode2[\"Builder\"] = \"builder\";\n EditorMode2[\"Code\"] = \"code\";\n return EditorMode2;\n})(EditorMode || {});\nconst QUERY_FORMAT_OPTIONS = [\n { label: \"Time series\", value: 0 /* Timeseries */ },\n { label: \"Table\", value: 1 /* Table */ }\n];\nconst backWardToOption = (value) => ({ label: value, value });\nconst toOption = (_a = toOption$1) != null ? _a : backWardToOption;\n\nexport { EditorMode, QUERY_FORMAT_OPTIONS, QueryFormat, toOption };\n//# sourceMappingURL=types.js.map\n","/**\n * This file automatically generated from `pre-publish.js`.\n * Do not manually edit.\n */\n\nmodule.exports = {\n \"area\": true,\n \"base\": true,\n \"br\": true,\n \"col\": true,\n \"embed\": true,\n \"hr\": true,\n \"img\": true,\n \"input\": true,\n \"link\": true,\n \"meta\": true,\n \"param\": true,\n \"source\": true,\n \"track\": true,\n \"wbr\": true\n};\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n}\n\nmodule.exports = baseProperty;\n","import {\n ENGLISH_US,\n FRENCH_FRANCE,\n SPANISH_SPAIN,\n GERMAN_GERMANY,\n CHINESE_SIMPLIFIED,\n BRAZILIAN_PORTUGUESE,\n CHINESE_TRADITIONAL,\n ITALIAN_ITALY,\n JAPANESE_JAPAN,\n INDONESIAN_INDONESIA,\n KOREAN_KOREA,\n RUSSIAN_RUSSIA,\n CZECH_CZECHIA,\n DUTCH_NETHERLANDS,\n HUNGARIAN_HUNGARY,\n PORTUGUESE_PORTUGAL,\n POLISH_POLAND,\n SWEDISH_SWEDEN,\n TURKISH_TURKEY,\n} from './constants';\n\ninterface TranslationDefinition {\n /** IETF language tag */\n code: string;\n\n /** The language name in its own language (e.g. \"Français\" for French) */\n name: string;\n}\n\n/**\n * Supported languages for translation.\n */\nexport const LANGUAGES: TranslationDefinition[] = [\n { code: ENGLISH_US, name: 'English' },\n { code: FRENCH_FRANCE, name: 'Français' },\n { code: SPANISH_SPAIN, name: 'Español' },\n { code: GERMAN_GERMANY, name: 'Deutsch' },\n { code: CHINESE_SIMPLIFIED, name: '中文（简体）' },\n { code: BRAZILIAN_PORTUGUESE, name: 'Português Brasileiro' },\n { code: CHINESE_TRADITIONAL, name: '中文（繁體）' },\n { code: ITALIAN_ITALY, name: 'Italiano' },\n { code: JAPANESE_JAPAN, name: '日本語' },\n { code: INDONESIAN_INDONESIA, name: 'Bahasa Indonesia' },\n { code: KOREAN_KOREA, name: '한국어' },\n { code: RUSSIAN_RUSSIA, name: 'Русский' },\n { code: CZECH_CZECHIA, name: 'Čeština' },\n { code: DUTCH_NETHERLANDS, name: 'Nederlands' },\n { code: HUNGARIAN_HUNGARY, name: 'Magyar' },\n { code: PORTUGUESE_PORTUGAL, name: 'Português' },\n { code: POLISH_POLAND, name: 'Polski' },\n { code: SWEDISH_SWEDEN, name: 'Svenska' },\n { code: TURKISH_TURKEY, name: 'Türkçe' },\n];\n","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n}\n\nmodule.exports = overRest;\n","var OverloadYield = require(\"./OverloadYield.js\");\nvar regeneratorDefine = require(\"./regeneratorDefine.js\");\nfunction AsyncIterator(t, e) {\n function n(r, o, i, f) {\n try {\n var c = t[r](o),\n u = c.value;\n return u instanceof OverloadYield ? e.resolve(u.v).then(function (t) {\n n(\"next\", t, i, f);\n }, function (t) {\n n(\"throw\", t, i, f);\n }) : e.resolve(u).then(function (t) {\n c.value = t, i(c);\n }, function (t) {\n return n(\"throw\", t, i, f);\n });\n } catch (t) {\n f(t);\n }\n }\n var r;\n this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, \"function\" == typeof Symbol && Symbol.asyncIterator || \"@asyncIterator\", function () {\n return this;\n })), regeneratorDefine(this, \"_invoke\", function (t, o, i) {\n function f() {\n return new e(function (e, r) {\n n(t, i, e, r);\n });\n }\n return r = r ? r.then(f, f) : f();\n }, !0);\n}\nmodule.exports = AsyncIterator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import { ScopedVars } from '@grafana/data';\nimport { TemplateSrv } from '@grafana/runtime';\nimport { applyQueryDefaults, SQLQuery, SqlQueryModel } from '@grafana/sql';\n\nexport class MSSqlQueryModel implements SqlQueryModel {\n target: SQLQuery;\n templateSrv?: TemplateSrv;\n scopedVars?: ScopedVars;\n\n constructor(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars) {\n this.target = applyQueryDefaults(target || { refId: 'A' });\n this.templateSrv = templateSrv;\n this.scopedVars = scopedVars;\n }\n\n quoteLiteral(value: string) {\n return \"'\" + value.replace(/'/g, \"''\") + \"'\";\n }\n}\n","import {\n ColumnDefinition,\n getStandardSQLCompletionProvider,\n LanguageCompletionProvider,\n LinkedToken,\n TableDefinition,\n TableIdentifier,\n TokenType,\n} from '@grafana/plugin-ui';\nimport { DB, SQLQuery } from '@grafana/sql';\n\ninterface CompletionProviderGetterArgs {\n getColumns: React.MutableRefObject<(t: SQLQuery) => Promise<ColumnDefinition[]>>;\n getTables: React.MutableRefObject<(d?: string) => Promise<TableDefinition[]>>;\n}\n\nexport const getSqlCompletionProvider: (args: CompletionProviderGetterArgs) => LanguageCompletionProvider =\n ({ getColumns, getTables }) =>\n (monaco, language) => ({\n ...(language && getStandardSQLCompletionProvider(monaco, language)),\n tables: {\n resolve: async (identifier) => {\n return await getTables.current(identifier?.table);\n },\n parseName: (token: LinkedToken | undefined | null) => {\n if (!token) {\n return { table: '' };\n }\n\n let processedToken = token;\n let tablePath = processedToken.value;\n\n while (processedToken.next && processedToken.next.type !== TokenType.Whitespace) {\n tablePath += processedToken.next.value;\n processedToken = processedToken.next;\n }\n\n if (processedToken.value.endsWith('.')) {\n tablePath = processedToken.value.slice(0, processedToken.value.length - 1);\n }\n\n return { table: tablePath };\n },\n },\n\n columns: {\n resolve: async (t: TableIdentifier | undefined) => {\n if (!t?.table) {\n return [];\n }\n // TODO: Use schema instead of table\n const [database, schema, tableName] = t.table.split('.');\n return await getColumns.current({ table: `${schema}.${tableName}`, dataset: database, refId: 'A' });\n },\n },\n });\n\nexport async function fetchColumns(db: DB, q: SQLQuery) {\n const cols = await db.fields(q);\n if (cols.length > 0) {\n return cols.map((c) => {\n return { name: c.value, type: c.value, description: c.value };\n });\n } else {\n return [];\n }\n}\n\nexport async function fetchTables(db: DB, dataset?: string) {\n const tables = await db.lookup?.(dataset);\n return tables || [];\n}\n","import { isEmpty } from 'lodash';\n\nimport { RAQBFieldTypes, SQLExpression, SQLQuery, haveColumns } from '@grafana/sql';\n\nexport function getIcon(type: string): string | undefined {\n switch (type) {\n case 'datetimeoffset':\n case 'date':\n case 'datetime2':\n case 'smalldatetime':\n case 'datetime':\n case 'time':\n return 'clock-nine';\n case 'bit':\n return 'toggle-off';\n case 'tinyint':\n case 'smallint':\n case 'int':\n case 'bigint':\n case 'decimal':\n case 'numeric':\n case 'real':\n case 'float':\n case 'money':\n case 'smallmoney':\n return 'calculator-alt';\n case 'char':\n case 'varchar':\n case 'text':\n case 'nchar':\n case 'nvarchar':\n case 'ntext':\n case 'binary':\n case 'varbinary':\n case 'image':\n return 'text';\n default:\n return undefined;\n }\n}\n\nexport function getRAQBType(type: string): RAQBFieldTypes {\n switch (type) {\n case 'datetimeoffset':\n case 'datetime2':\n case 'smalldatetime':\n case 'datetime':\n return 'datetime';\n case 'time':\n return 'time';\n case 'date':\n return 'date';\n case 'bit':\n return 'boolean';\n case 'tinyint':\n case 'smallint':\n case 'int':\n case 'bigint':\n case 'decimal':\n case 'numeric':\n case 'real':\n case 'float':\n case 'money':\n case 'smallmoney':\n return 'number';\n case 'char':\n case 'varchar':\n case 'text':\n case 'nchar':\n case 'nvarchar':\n case 'ntext':\n case 'binary':\n case 'varbinary':\n case 'image':\n return 'text';\n default:\n return 'text';\n }\n}\n\nexport function toRawSql({ sql, dataset, table }: SQLQuery): string {\n let rawQuery = '';\n\n // Return early with empty string if there is no sql column\n if (!sql || !haveColumns(sql.columns)) {\n return rawQuery;\n }\n\n rawQuery += createSelectClause(sql.columns, sql.limit);\n\n if (dataset && table) {\n rawQuery += `FROM [${dataset}].${table} `;\n }\n\n if (sql.whereString) {\n rawQuery += `WHERE ${sql.whereString} `;\n }\n\n if (sql.groupBy?.[0]?.property.name) {\n const groupBy = sql.groupBy.map((g) => g.property.name).filter((g) => !isEmpty(g));\n rawQuery += `GROUP BY ${groupBy.join(', ')} `;\n }\n\n if (sql.orderBy?.property.name) {\n rawQuery += `ORDER BY ${sql.orderBy.property.name} `;\n }\n\n if (sql.orderBy?.property.name && sql.orderByDirection) {\n rawQuery += `${sql.orderByDirection} `;\n }\n\n return rawQuery;\n}\n\nfunction createSelectClause(sqlColumns: NonNullable<SQLExpression['columns']>, limit?: number): string {\n const columns = sqlColumns.map((c) => {\n let rawColumn = '';\n if (c.name && c.alias) {\n rawColumn += `${c.name}(${c.parameters?.map((p) => `${p.name}`)}) AS ${c.alias}`;\n } else if (c.name) {\n rawColumn += `${c.name}(${c.parameters?.map((p) => `${p.name}`)})`;\n } else if (c.alias) {\n rawColumn += `${c.parameters?.map((p) => `${p.name}`)} AS ${c.alias}`;\n } else {\n rawColumn += `${c.parameters?.map((p) => `${p.name}`)}`;\n }\n return rawColumn;\n });\n return `SELECT ${isLimit(limit) ? 'TOP(' + limit + ')' : ''} ${columns.join(', ')} `;\n}\n\nconst isLimit = (limit: number | undefined): boolean => limit !== undefined && limit >= 0;\n","import { v4 as uuidv4 } from 'uuid';\n\nimport { DataSourceInstanceSettings, ScopedVars } from '@grafana/data';\nimport { LanguageDefinition } from '@grafana/plugin-ui';\nimport { TemplateSrv } from '@grafana/runtime';\nimport {\n COMMON_FNS,\n DB,\n FuncParameter,\n MACRO_FUNCTIONS,\n SQLQuery,\n SQLSelectableValue,\n SqlDatasource,\n formatSQL,\n} from '@grafana/sql';\n\nimport { getSchema, getSchemaAndName, showDatabases } from './MSSqlMetaQuery';\nimport { MSSqlQueryModel } from './MSSqlQueryModel';\nimport { fetchColumns, fetchTables, getSqlCompletionProvider } from './sqlCompletionProvider';\nimport { getIcon, getRAQBType, toRawSql } from './sqlUtil';\nimport { MssqlOptions } from './types';\n\nexport class MssqlDatasource extends SqlDatasource {\n sqlLanguageDefinition: LanguageDefinition | undefined = undefined;\n constructor(instanceSettings: DataSourceInstanceSettings<MssqlOptions>) {\n super(instanceSettings);\n }\n\n getQueryModel(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars): MSSqlQueryModel {\n return new MSSqlQueryModel(target, templateSrv, scopedVars);\n }\n\n async fetchDatasets(): Promise<string[]> {\n const datasets = await this.runSql<{ name: string[] }>(showDatabases(), { refId: 'datasets' });\n return datasets.fields.name?.values.flat() ?? [];\n }\n\n async fetchTables(dataset?: string): Promise<string[]> {\n // We get back the table name with the schema as well. like dbo.table\n const tables = await this.runSql<{ schemaAndName: string[] }>(getSchemaAndName(dataset), { refId: 'tables' });\n return tables.fields.schemaAndName?.values.flat() ?? [];\n }\n\n async fetchFields(query: SQLQuery): Promise<SQLSelectableValue[]> {\n if (!query.table) {\n return [];\n }\n const [_, table] = query.table.split('.');\n const schema = await this.runSql<{ column: string; type: string }>(getSchema(query.dataset, table), {\n refId: `columns-${uuidv4()}`,\n });\n const result: SQLSelectableValue[] = [];\n for (let i = 0; i < schema.length; i++) {\n const column = schema.fields.column.values[i];\n const type = schema.fields.type.values[i];\n result.push({ label: column, value: column, type, icon: getIcon(type), raqbFieldType: getRAQBType(type) });\n }\n return result;\n }\n\n getSqlLanguageDefinition(db: DB): LanguageDefinition {\n if (this.sqlLanguageDefinition !== undefined) {\n return this.sqlLanguageDefinition;\n }\n const args = {\n getColumns: { current: (query: SQLQuery) => fetchColumns(db, query) },\n getTables: { current: (dataset?: string) => fetchTables(db, dataset) },\n };\n this.sqlLanguageDefinition = {\n id: 'sql',\n completionProvider: getSqlCompletionProvider(args),\n formatter: formatSQL,\n };\n return this.sqlLanguageDefinition;\n }\n\n getFunctions = (): ReturnType<DB['functions']> => {\n const columnParam: FuncParameter = {\n name: 'Column',\n required: true,\n options: (query) => this.fetchFields(query),\n };\n\n return [...MACRO_FUNCTIONS(columnParam), ...COMMON_FNS.map((fn) => ({ ...fn, parameters: [columnParam] }))];\n };\n\n getDB(): DB {\n if (this.db !== undefined) {\n return this.db;\n }\n return {\n init: () => Promise.resolve(true),\n datasets: () => this.fetchDatasets(),\n tables: (dataset?: string) => this.fetchTables(dataset),\n getEditorLanguageDefinition: () => this.getSqlLanguageDefinition(this.db),\n fields: async (query: SQLQuery) => {\n if (!query?.dataset || !query?.table) {\n return [];\n }\n return this.fetchFields(query);\n },\n validateQuery: (query) =>\n Promise.resolve({ isError: false, isValid: true, query, error: '', rawSql: query.rawSql }),\n dsID: () => this.id,\n dispose: (_dsID?: string) => {},\n toRawSql,\n functions: () => this.getFunctions(),\n lookup: async (path?: string) => {\n if (!path) {\n const datasets = await this.fetchDatasets();\n return datasets.map((d) => ({ name: d, completion: `${d}.` }));\n } else {\n const parts = path.split('.').filter((s: string) => s);\n if (parts.length > 2) {\n return [];\n }\n if (parts.length === 1) {\n const tables = await this.fetchTables(parts[0]);\n return tables.map((t) => ({ name: t, completion: t }));\n } else {\n return [];\n }\n }\n },\n };\n }\n}\n","export function showDatabases() {\n // Return only user defined databases\n return `SELECT name FROM sys.databases WHERE name NOT IN ('master', 'tempdb', 'model', 'msdb');`;\n}\n\nexport function getSchemaAndName(database?: string) {\n return `SELECT TABLE_SCHEMA + '.' + TABLE_NAME as schemaAndName\n FROM [${database}].INFORMATION_SCHEMA.TABLES`;\n}\n\nexport function getSchema(database?: string, table?: string) {\n return `\n USE [${database}]\n SELECT COLUMN_NAME as 'column',DATA_TYPE as 'type'\n FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='${table}';`;\n}\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nmodule.exports = mapCacheSet;\n","import React__default from 'react';\nimport { GenericConfigSection } from './GenericConfigSection.js';\n\nconst ConfigSubSection = ({ children, ...props }) => {\n return /* @__PURE__ */ React__default.createElement(GenericConfigSection, { ...props, kind: \"sub-section\" }, children);\n};\n\nexport { ConfigSubSection };\n//# sourceMappingURL=ConfigSubSection.js.map\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n getSymbolsIn = require('./_getSymbolsIn'),\n keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n","var Symbol = require('./_Symbol'),\n Uint8Array = require('./_Uint8Array'),\n eq = require('./eq'),\n equalArrays = require('./_equalArrays'),\n mapToArray = require('./_mapToArray'),\n setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n}\n\nmodule.exports = equalByTag;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\n/**\r\n * Constants for token types\r\n */\nvar _default = {\n WHITESPACE: 'whitespace',\n WORD: 'word',\n STRING: 'string',\n RESERVED: 'reserved',\n RESERVED_TOP_LEVEL: 'reserved-top-level',\n RESERVED_TOP_LEVEL_NO_INDENT: 'reserved-top-level-no-indent',\n RESERVED_NEWLINE: 'reserved-newline',\n OPERATOR: 'operator',\n OPEN_PAREN: 'open-paren',\n CLOSE_PAREN: 'close-paren',\n LINE_COMMENT: 'line-comment',\n BLOCK_COMMENT: 'block-comment',\n NUMBER: 'number',\n PLACEHOLDER: 'placeholder'\n};\nexports[\"default\"] = _default;\nmodule.exports = exports.default;","function _classCallCheck(a, n) {\n if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nexport { _classCallCheck as default };","function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n var i = toPrimitive(t, \"string\");\n return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n if (\"object\" != _typeof(t) || !t) return t;\n var e = t[Symbol.toPrimitive];\n if (void 0 !== e) {\n var i = e.call(t, r || \"default\");\n if (\"object\" != _typeof(i)) return i;\n throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n }\n return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n for (var t = 0; t < r.length; t++) {\n var o = r[t];\n o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n }\n}\nfunction _createClass(e, r, t) {\n return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n writable: !1\n }), e;\n}\nexport { _createClass as default };","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nfunction _possibleConstructorReturn(t, e) {\n if (e && (\"object\" == _typeof(e) || \"function\" == typeof e)) return e;\n if (void 0 !== e) throw new TypeError(\"Derived constructors may only return object or undefined\");\n return assertThisInitialized(t);\n}\nexport { _possibleConstructorReturn as default };","function _assertThisInitialized(e) {\n if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n return e;\n}\nexport { _assertThisInitialized as default };","function _getPrototypeOf(t) {\n return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {\n return t.__proto__ || Object.getPrototypeOf(t);\n }, _getPrototypeOf(t);\n}\nexport { _getPrototypeOf as default };","function _setPrototypeOf(t, e) {\n return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n return t.__proto__ = e, t;\n }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inherits(t, e) {\n if (\"function\" != typeof e && null !== e) throw new TypeError(\"Super expression must either be null or a function\");\n t.prototype = Object.create(e && e.prototype, {\n constructor: {\n value: t,\n writable: !0,\n configurable: !0\n }\n }), Object.defineProperty(t, \"prototype\", {\n writable: !1\n }), e && setPrototypeOf(t, e);\n}\nexport { _inherits as default };","function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n var i = toPrimitive(t, \"string\");\n return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n if (\"object\" != _typeof(t) || !t) return t;\n var e = t[Symbol.toPrimitive];\n if (void 0 !== e) {\n var i = e.call(t, r || \"default\");\n if (\"object\" != _typeof(i)) return i;\n throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n }\n return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n value: t,\n enumerable: !0,\n configurable: !0,\n writable: !0\n }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","function _arrayWithHoles(r) {\n if (Array.isArray(r)) return r;\n}\nexport { _arrayWithHoles as default };","function _arrayLikeToArray(r, a) {\n (null == a || a > r.length) && (a = r.length);\n for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n return n;\n}\nexport { _arrayLikeToArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n if (r) {\n if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n var t = {}.toString.call(r).slice(8, -1);\n return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n }\n}\nexport { _unsupportedIterableToArray as default };","function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableRest as default };","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _slicedToArray(r, e) {\n return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();\n}\nexport { _slicedToArray as default };","function _iterableToArrayLimit(r, l) {\n var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n if (null != t) {\n var e,\n n,\n i,\n u,\n a = [],\n f = !0,\n o = !1;\n try {\n if (i = (t = t.call(r)).next, 0 === l) {\n if (Object(t) !== t) return;\n f = !1;\n } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n } catch (r) {\n o = !0, n = r;\n } finally {\n try {\n if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n } finally {\n if (o) throw n;\n }\n }\n return a;\n }\n}\nexport { _iterableToArrayLimit as default };","function _iterableToArray(r) {\n if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","/**\n * MIT License\n * \n * Copyright (c) 2014-present, Lee Byron and other contributors.\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nvar DELETE = 'delete';\n\n// Constants describing the size of trie nodes.\nvar SHIFT = 5; // Resulted in best performance after ______?\nvar SIZE = 1 << SHIFT;\nvar MASK = SIZE - 1;\n\n// A consistent shared value representing \"not set\" which equals nothing other\n// than itself, and nothing that could be provided externally.\nvar NOT_SET = {};\n\n// Boolean references, Rough equivalent of `bool &`.\nfunction MakeRef() {\n return { value: false };\n}\n\nfunction SetRef(ref) {\n if (ref) {\n ref.value = true;\n }\n}\n\n// A function which returns a value representing an \"owner\" for transient writes\n// to tries. The return value will only ever equal itself, and will not equal\n// the return of any subsequent call of this function.\nfunction OwnerID() {}\n\nfunction ensureSize(iter) {\n if (iter.size === undefined) {\n iter.size = iter.__iterate(returnTrue);\n }\n return iter.size;\n}\n\nfunction wrapIndex(iter, index) {\n // This implements \"is array index\" which the ECMAString spec defines as:\n //\n // A String property name P is an array index if and only if\n // ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n // to 2^32−1.\n //\n // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n if (typeof index !== 'number') {\n var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n if ('' + uint32Index !== index || uint32Index === 4294967295) {\n return NaN;\n }\n index = uint32Index;\n }\n return index < 0 ? ensureSize(iter) + index : index;\n}\n\nfunction returnTrue() {\n return true;\n}\n\nfunction wholeSlice(begin, end, size) {\n return (\n ((begin === 0 && !isNeg(begin)) ||\n (size !== undefined && begin <= -size)) &&\n (end === undefined || (size !== undefined && end >= size))\n );\n}\n\nfunction resolveBegin(begin, size) {\n return resolveIndex(begin, size, 0);\n}\n\nfunction resolveEnd(end, size) {\n return resolveIndex(end, size, size);\n}\n\nfunction resolveIndex(index, size, defaultIndex) {\n // Sanitize indices using this shorthand for ToInt32(argument)\n // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n return index === undefined\n ? defaultIndex\n : isNeg(index)\n ? size === Infinity\n ? size\n : Math.max(0, size + index) | 0\n : size === undefined || size === index\n ? index\n : Math.min(size, index) | 0;\n}\n\nfunction isNeg(value) {\n // Account for -0 which is negative, but not less than 0.\n return value < 0 || (value === 0 && 1 / value === -Infinity);\n}\n\nvar IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';\n\nfunction isCollection(maybeCollection) {\n return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);\n}\n\nvar IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';\n\nfunction isKeyed(maybeKeyed) {\n return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);\n}\n\nvar IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';\n\nfunction isIndexed(maybeIndexed) {\n return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);\n}\n\nfunction isAssociative(maybeAssociative) {\n return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n}\n\nvar Collection = function Collection(value) {\n // eslint-disable-next-line no-constructor-return\n return isCollection(value) ? value : Seq(value);\n};\n\nvar KeyedCollection = /*@__PURE__*/(function (Collection) {\n function KeyedCollection(value) {\n // eslint-disable-next-line no-constructor-return\n return isKeyed(value) ? value : KeyedSeq(value);\n }\n\n if ( Collection ) KeyedCollection.__proto__ = Collection;\n KeyedCollection.prototype = Object.create( Collection && Collection.prototype );\n KeyedCollection.prototype.constructor = KeyedCollection;\n\n return KeyedCollection;\n}(Collection));\n\nvar IndexedCollection = /*@__PURE__*/(function (Collection) {\n function IndexedCollection(value) {\n // eslint-disable-next-line no-constructor-return\n return isIndexed(value) ? value : IndexedSeq(value);\n }\n\n if ( Collection ) IndexedCollection.__proto__ = Collection;\n IndexedCollection.prototype = Object.create( Collection && Collection.prototype );\n IndexedCollection.prototype.constructor = IndexedCollection;\n\n return IndexedCollection;\n}(Collection));\n\nvar SetCollection = /*@__PURE__*/(function (Collection) {\n function SetCollection(value) {\n // eslint-disable-next-line no-constructor-return\n return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);\n }\n\n if ( Collection ) SetCollection.__proto__ = Collection;\n SetCollection.prototype = Object.create( Collection && Collection.prototype );\n SetCollection.prototype.constructor = SetCollection;\n\n return SetCollection;\n}(Collection));\n\nCollection.Keyed = KeyedCollection;\nCollection.Indexed = IndexedCollection;\nCollection.Set = SetCollection;\n\nvar IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';\n\nfunction isSeq(maybeSeq) {\n return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);\n}\n\nvar IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';\n\nfunction isRecord(maybeRecord) {\n return Boolean(maybeRecord && maybeRecord[IS_RECORD_SYMBOL]);\n}\n\nfunction isImmutable(maybeImmutable) {\n return isCollection(maybeImmutable) || isRecord(maybeImmutable);\n}\n\nvar IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';\n\nfunction isOrdered(maybeOrdered) {\n return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);\n}\n\nvar ITERATE_KEYS = 0;\nvar ITERATE_VALUES = 1;\nvar ITERATE_ENTRIES = 2;\n\nvar REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\n\nvar ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\nvar Iterator = function Iterator(next) {\n this.next = next;\n};\n\nIterator.prototype.toString = function toString () {\n return '[Iterator]';\n};\n\nIterator.KEYS = ITERATE_KEYS;\nIterator.VALUES = ITERATE_VALUES;\nIterator.ENTRIES = ITERATE_ENTRIES;\n\nIterator.prototype.inspect = Iterator.prototype.toSource = function () {\n return this.toString();\n};\nIterator.prototype[ITERATOR_SYMBOL] = function () {\n return this;\n};\n\nfunction iteratorValue(type, k, v, iteratorResult) {\n var value = type === 0 ? k : type === 1 ? v : [k, v];\n iteratorResult\n ? (iteratorResult.value = value)\n : (iteratorResult = {\n value: value,\n done: false,\n });\n return iteratorResult;\n}\n\nfunction iteratorDone() {\n return { value: undefined, done: true };\n}\n\nfunction hasIterator(maybeIterable) {\n if (Array.isArray(maybeIterable)) {\n // IE11 trick as it does not support `Symbol.iterator`\n return true;\n }\n\n return !!getIteratorFn(maybeIterable);\n}\n\nfunction isIterator(maybeIterator) {\n return maybeIterator && typeof maybeIterator.next === 'function';\n}\n\nfunction getIterator(iterable) {\n var iteratorFn = getIteratorFn(iterable);\n return iteratorFn && iteratorFn.call(iterable);\n}\n\nfunction getIteratorFn(iterable) {\n var iteratorFn =\n iterable &&\n ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n iterable[FAUX_ITERATOR_SYMBOL]);\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n}\n\nfunction isEntriesIterable(maybeIterable) {\n var iteratorFn = getIteratorFn(maybeIterable);\n return iteratorFn && iteratorFn === maybeIterable.entries;\n}\n\nfunction isKeysIterable(maybeIterable) {\n var iteratorFn = getIteratorFn(maybeIterable);\n return iteratorFn && iteratorFn === maybeIterable.keys;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction isArrayLike(value) {\n if (Array.isArray(value) || typeof value === 'string') {\n return true;\n }\n\n return (\n value &&\n typeof value === 'object' &&\n Number.isInteger(value.length) &&\n value.length >= 0 &&\n (value.length === 0\n ? // Only {length: 0} is considered Array-like.\n Object.keys(value).length === 1\n : // An object is only Array-like if it has a property where the last value\n // in the array-like may be found (which could be undefined).\n value.hasOwnProperty(value.length - 1))\n );\n}\n\nvar Seq = /*@__PURE__*/(function (Collection) {\n function Seq(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptySequence()\n : isImmutable(value)\n ? value.toSeq()\n : seqFromValue(value);\n }\n\n if ( Collection ) Seq.__proto__ = Collection;\n Seq.prototype = Object.create( Collection && Collection.prototype );\n Seq.prototype.constructor = Seq;\n\n Seq.prototype.toSeq = function toSeq () {\n return this;\n };\n\n Seq.prototype.toString = function toString () {\n return this.__toString('Seq {', '}');\n };\n\n Seq.prototype.cacheResult = function cacheResult () {\n if (!this._cache && this.__iterateUncached) {\n this._cache = this.entrySeq().toArray();\n this.size = this._cache.length;\n }\n return this;\n };\n\n // abstract __iterateUncached(fn, reverse)\n\n Seq.prototype.__iterate = function __iterate (fn, reverse) {\n var cache = this._cache;\n if (cache) {\n var size = cache.length;\n var i = 0;\n while (i !== size) {\n var entry = cache[reverse ? size - ++i : i++];\n if (fn(entry[1], entry[0], this) === false) {\n break;\n }\n }\n return i;\n }\n return this.__iterateUncached(fn, reverse);\n };\n\n // abstract __iteratorUncached(type, reverse)\n\n Seq.prototype.__iterator = function __iterator (type, reverse) {\n var cache = this._cache;\n if (cache) {\n var size = cache.length;\n var i = 0;\n return new Iterator(function () {\n if (i === size) {\n return iteratorDone();\n }\n var entry = cache[reverse ? size - ++i : i++];\n return iteratorValue(type, entry[0], entry[1]);\n });\n }\n return this.__iteratorUncached(type, reverse);\n };\n\n return Seq;\n}(Collection));\n\nvar KeyedSeq = /*@__PURE__*/(function (Seq) {\n function KeyedSeq(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptySequence().toKeyedSeq()\n : isCollection(value)\n ? isKeyed(value)\n ? value.toSeq()\n : value.fromEntrySeq()\n : isRecord(value)\n ? value.toSeq()\n : keyedSeqFromValue(value);\n }\n\n if ( Seq ) KeyedSeq.__proto__ = Seq;\n KeyedSeq.prototype = Object.create( Seq && Seq.prototype );\n KeyedSeq.prototype.constructor = KeyedSeq;\n\n KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () {\n return this;\n };\n\n return KeyedSeq;\n}(Seq));\n\nvar IndexedSeq = /*@__PURE__*/(function (Seq) {\n function IndexedSeq(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptySequence()\n : isCollection(value)\n ? isKeyed(value)\n ? value.entrySeq()\n : value.toIndexedSeq()\n : isRecord(value)\n ? value.toSeq().entrySeq()\n : indexedSeqFromValue(value);\n }\n\n if ( Seq ) IndexedSeq.__proto__ = Seq;\n IndexedSeq.prototype = Object.create( Seq && Seq.prototype );\n IndexedSeq.prototype.constructor = IndexedSeq;\n\n IndexedSeq.of = function of (/*...values*/) {\n return IndexedSeq(arguments);\n };\n\n IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () {\n return this;\n };\n\n IndexedSeq.prototype.toString = function toString () {\n return this.__toString('Seq [', ']');\n };\n\n return IndexedSeq;\n}(Seq));\n\nvar SetSeq = /*@__PURE__*/(function (Seq) {\n function SetSeq(value) {\n // eslint-disable-next-line no-constructor-return\n return (\n isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)\n ).toSetSeq();\n }\n\n if ( Seq ) SetSeq.__proto__ = Seq;\n SetSeq.prototype = Object.create( Seq && Seq.prototype );\n SetSeq.prototype.constructor = SetSeq;\n\n SetSeq.of = function of (/*...values*/) {\n return SetSeq(arguments);\n };\n\n SetSeq.prototype.toSetSeq = function toSetSeq () {\n return this;\n };\n\n return SetSeq;\n}(Seq));\n\nSeq.isSeq = isSeq;\nSeq.Keyed = KeyedSeq;\nSeq.Set = SetSeq;\nSeq.Indexed = IndexedSeq;\n\nSeq.prototype[IS_SEQ_SYMBOL] = true;\n\n// #pragma Root Sequences\n\nvar ArraySeq = /*@__PURE__*/(function (IndexedSeq) {\n function ArraySeq(array) {\n this._array = array;\n this.size = array.length;\n }\n\n if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq;\n ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n ArraySeq.prototype.constructor = ArraySeq;\n\n ArraySeq.prototype.get = function get (index, notSetValue) {\n return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n };\n\n ArraySeq.prototype.__iterate = function __iterate (fn, reverse) {\n var array = this._array;\n var size = array.length;\n var i = 0;\n while (i !== size) {\n var ii = reverse ? size - ++i : i++;\n if (fn(array[ii], ii, this) === false) {\n break;\n }\n }\n return i;\n };\n\n ArraySeq.prototype.__iterator = function __iterator (type, reverse) {\n var array = this._array;\n var size = array.length;\n var i = 0;\n return new Iterator(function () {\n if (i === size) {\n return iteratorDone();\n }\n var ii = reverse ? size - ++i : i++;\n return iteratorValue(type, ii, array[ii]);\n });\n };\n\n return ArraySeq;\n}(IndexedSeq));\n\nvar ObjectSeq = /*@__PURE__*/(function (KeyedSeq) {\n function ObjectSeq(object) {\n var keys = Object.keys(object).concat(\n Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []\n );\n this._object = object;\n this._keys = keys;\n this.size = keys.length;\n }\n\n if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq;\n ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n ObjectSeq.prototype.constructor = ObjectSeq;\n\n ObjectSeq.prototype.get = function get (key, notSetValue) {\n if (notSetValue !== undefined && !this.has(key)) {\n return notSetValue;\n }\n return this._object[key];\n };\n\n ObjectSeq.prototype.has = function has (key) {\n return hasOwnProperty.call(this._object, key);\n };\n\n ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) {\n var object = this._object;\n var keys = this._keys;\n var size = keys.length;\n var i = 0;\n while (i !== size) {\n var key = keys[reverse ? size - ++i : i++];\n if (fn(object[key], key, this) === false) {\n break;\n }\n }\n return i;\n };\n\n ObjectSeq.prototype.__iterator = function __iterator (type, reverse) {\n var object = this._object;\n var keys = this._keys;\n var size = keys.length;\n var i = 0;\n return new Iterator(function () {\n if (i === size) {\n return iteratorDone();\n }\n var key = keys[reverse ? size - ++i : i++];\n return iteratorValue(type, key, object[key]);\n });\n };\n\n return ObjectSeq;\n}(KeyedSeq));\nObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;\n\nvar CollectionSeq = /*@__PURE__*/(function (IndexedSeq) {\n function CollectionSeq(collection) {\n this._collection = collection;\n this.size = collection.length || collection.size;\n }\n\n if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq;\n CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n CollectionSeq.prototype.constructor = CollectionSeq;\n\n CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {\n if (reverse) {\n return this.cacheResult().__iterate(fn, reverse);\n }\n var collection = this._collection;\n var iterator = getIterator(collection);\n var iterations = 0;\n if (isIterator(iterator)) {\n var step;\n while (!(step = iterator.next()).done) {\n if (fn(step.value, iterations++, this) === false) {\n break;\n }\n }\n }\n return iterations;\n };\n\n CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {\n if (reverse) {\n return this.cacheResult().__iterator(type, reverse);\n }\n var collection = this._collection;\n var iterator = getIterator(collection);\n if (!isIterator(iterator)) {\n return new Iterator(iteratorDone);\n }\n var iterations = 0;\n return new Iterator(function () {\n var step = iterator.next();\n return step.done ? step : iteratorValue(type, iterations++, step.value);\n });\n };\n\n return CollectionSeq;\n}(IndexedSeq));\n\n// # pragma Helper functions\n\nvar EMPTY_SEQ;\n\nfunction emptySequence() {\n return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n}\n\nfunction keyedSeqFromValue(value) {\n var seq = maybeIndexedSeqFromValue(value);\n if (seq) {\n return seq.fromEntrySeq();\n }\n if (typeof value === 'object') {\n return new ObjectSeq(value);\n }\n throw new TypeError(\n 'Expected Array or collection object of [k, v] entries, or keyed object: ' +\n value\n );\n}\n\nfunction indexedSeqFromValue(value) {\n var seq = maybeIndexedSeqFromValue(value);\n if (seq) {\n return seq;\n }\n throw new TypeError(\n 'Expected Array or collection object of values: ' + value\n );\n}\n\nfunction seqFromValue(value) {\n var seq = maybeIndexedSeqFromValue(value);\n if (seq) {\n return isEntriesIterable(value)\n ? seq.fromEntrySeq()\n : isKeysIterable(value)\n ? seq.toSetSeq()\n : seq;\n }\n if (typeof value === 'object') {\n return new ObjectSeq(value);\n }\n throw new TypeError(\n 'Expected Array or collection object of values, or keyed object: ' + value\n );\n}\n\nfunction maybeIndexedSeqFromValue(value) {\n return isArrayLike(value)\n ? new ArraySeq(value)\n : hasIterator(value)\n ? new CollectionSeq(value)\n : undefined;\n}\n\nvar IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';\n\nfunction isMap(maybeMap) {\n return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);\n}\n\nfunction isOrderedMap(maybeOrderedMap) {\n return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n}\n\nfunction isValueObject(maybeValue) {\n return Boolean(\n maybeValue &&\n typeof maybeValue.equals === 'function' &&\n typeof maybeValue.hashCode === 'function'\n );\n}\n\n/**\n * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n *\n * NaN is considered the same as NaN, however -0 and 0 are considered the same\n * value, which is different from the algorithm described by\n * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n *\n * This is extended further to allow Objects to describe the values they\n * represent, by way of `valueOf` or `equals` (and `hashCode`).\n *\n * Note: because of this extension, the key equality of Immutable.Map and the\n * value equality of Immutable.Set will differ from ES6 Map and Set.\n *\n * ### Defining custom values\n *\n * The easiest way to describe the value an object represents is by implementing\n * `valueOf`. For example, `Date` represents a value by returning a unix\n * timestamp for `valueOf`:\n *\n * var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n * var date2 = new Date(1234567890000);\n * date1.valueOf(); // 1234567890000\n * assert( date1 !== date2 );\n * assert( Immutable.is( date1, date2 ) );\n *\n * Note: overriding `valueOf` may have other implications if you use this object\n * where JavaScript expects a primitive, such as implicit string coercion.\n *\n * For more complex types, especially collections, implementing `valueOf` may\n * not be performant. An alternative is to implement `equals` and `hashCode`.\n *\n * `equals` takes another object, presumably of similar type, and returns true\n * if it is equal. Equality is symmetrical, so the same result should be\n * returned if this and the argument are flipped.\n *\n * assert( a.equals(b) === b.equals(a) );\n *\n * `hashCode` returns a 32bit integer number representing the object which will\n * be used to determine how to store the value object in a Map or Set. You must\n * provide both or neither methods, one must not exist without the other.\n *\n * Also, an important relationship between these methods must be upheld: if two\n * values are equal, they *must* return the same hashCode. If the values are not\n * equal, they might have the same hashCode; this is called a hash collision,\n * and while undesirable for performance reasons, it is acceptable.\n *\n * if (a.equals(b)) {\n * assert( a.hashCode() === b.hashCode() );\n * }\n *\n * All Immutable collections are Value Objects: they implement `equals()`\n * and `hashCode()`.\n */\nfunction is(valueA, valueB) {\n if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n return true;\n }\n if (!valueA || !valueB) {\n return false;\n }\n if (\n typeof valueA.valueOf === 'function' &&\n typeof valueB.valueOf === 'function'\n ) {\n valueA = valueA.valueOf();\n valueB = valueB.valueOf();\n if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n return true;\n }\n if (!valueA || !valueB) {\n return false;\n }\n }\n return !!(\n isValueObject(valueA) &&\n isValueObject(valueB) &&\n valueA.equals(valueB)\n );\n}\n\nvar imul =\n typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2\n ? Math.imul\n : function imul(a, b) {\n a |= 0; // int\n b |= 0; // int\n var c = a & 0xffff;\n var d = b & 0xffff;\n // Shift by 0 fixes the sign on the high part.\n return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int\n };\n\n// v8 has an optimization for storing 31-bit signed numbers.\n// Values which have either 00 or 11 as the high order bits qualify.\n// This function drops the highest order bit in a signed number, maintaining\n// the sign bit.\nfunction smi(i32) {\n return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);\n}\n\nvar defaultValueOf = Object.prototype.valueOf;\n\nfunction hash(o) {\n if (o == null) {\n return hashNullish(o);\n }\n\n if (typeof o.hashCode === 'function') {\n // Drop any high bits from accidentally long hash codes.\n return smi(o.hashCode(o));\n }\n\n var v = valueOf(o);\n\n if (v == null) {\n return hashNullish(v);\n }\n\n switch (typeof v) {\n case 'boolean':\n // The hash values for built-in constants are a 1 value for each 5-byte\n // shift region expect for the first, which encodes the value. This\n // reduces the odds of a hash collision for these common values.\n return v ? 0x42108421 : 0x42108420;\n case 'number':\n return hashNumber(v);\n case 'string':\n return v.length > STRING_HASH_CACHE_MIN_STRLEN\n ? cachedHashString(v)\n : hashString(v);\n case 'object':\n case 'function':\n return hashJSObj(v);\n case 'symbol':\n return hashSymbol(v);\n default:\n if (typeof v.toString === 'function') {\n return hashString(v.toString());\n }\n throw new Error('Value type ' + typeof v + ' cannot be hashed.');\n }\n}\n\nfunction hashNullish(nullish) {\n return nullish === null ? 0x42108422 : /* undefined */ 0x42108423;\n}\n\n// Compress arbitrarily large numbers into smi hashes.\nfunction hashNumber(n) {\n if (n !== n || n === Infinity) {\n return 0;\n }\n var hash = n | 0;\n if (hash !== n) {\n hash ^= n * 0xffffffff;\n }\n while (n > 0xffffffff) {\n n /= 0xffffffff;\n hash ^= n;\n }\n return smi(hash);\n}\n\nfunction cachedHashString(string) {\n var hashed = stringHashCache[string];\n if (hashed === undefined) {\n hashed = hashString(string);\n if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n STRING_HASH_CACHE_SIZE = 0;\n stringHashCache = {};\n }\n STRING_HASH_CACHE_SIZE++;\n stringHashCache[string] = hashed;\n }\n return hashed;\n}\n\n// http://jsperf.com/hashing-strings\nfunction hashString(string) {\n // This is the hash from JVM\n // The hash code for a string is computed as\n // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n // where s[i] is the ith character of the string and n is the length of\n // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n // (exclusive) by dropping high bits.\n var hashed = 0;\n for (var ii = 0; ii < string.length; ii++) {\n hashed = (31 * hashed + string.charCodeAt(ii)) | 0;\n }\n return smi(hashed);\n}\n\nfunction hashSymbol(sym) {\n var hashed = symbolMap[sym];\n if (hashed !== undefined) {\n return hashed;\n }\n\n hashed = nextHash();\n\n symbolMap[sym] = hashed;\n\n return hashed;\n}\n\nfunction hashJSObj(obj) {\n var hashed;\n if (usingWeakMap) {\n hashed = weakMap.get(obj);\n if (hashed !== undefined) {\n return hashed;\n }\n }\n\n hashed = obj[UID_HASH_KEY];\n if (hashed !== undefined) {\n return hashed;\n }\n\n if (!canDefineProperty) {\n hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n if (hashed !== undefined) {\n return hashed;\n }\n\n hashed = getIENodeHash(obj);\n if (hashed !== undefined) {\n return hashed;\n }\n }\n\n hashed = nextHash();\n\n if (usingWeakMap) {\n weakMap.set(obj, hashed);\n } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n throw new Error('Non-extensible objects are not allowed as keys.');\n } else if (canDefineProperty) {\n Object.defineProperty(obj, UID_HASH_KEY, {\n enumerable: false,\n configurable: false,\n writable: false,\n value: hashed,\n });\n } else if (\n obj.propertyIsEnumerable !== undefined &&\n obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable\n ) {\n // Since we can't define a non-enumerable property on the object\n // we'll hijack one of the less-used non-enumerable properties to\n // save our hash on it. Since this is a function it will not show up in\n // `JSON.stringify` which is what we want.\n obj.propertyIsEnumerable = function () {\n return this.constructor.prototype.propertyIsEnumerable.apply(\n this,\n arguments\n );\n };\n obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;\n } else if (obj.nodeType !== undefined) {\n // At this point we couldn't get the IE `uniqueID` to use as a hash\n // and we couldn't use a non-enumerable property to exploit the\n // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n // itself.\n obj[UID_HASH_KEY] = hashed;\n } else {\n throw new Error('Unable to set a non-enumerable property on object.');\n }\n\n return hashed;\n}\n\n// Get references to ES5 object methods.\nvar isExtensible = Object.isExtensible;\n\n// True if Object.defineProperty works as expected. IE8 fails this test.\nvar canDefineProperty = (function () {\n try {\n Object.defineProperty({}, '@', {});\n return true;\n } catch (e) {\n return false;\n }\n})();\n\n// IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n// and avoid memory leaks from the IE cloneNode bug.\nfunction getIENodeHash(node) {\n if (node && node.nodeType > 0) {\n switch (node.nodeType) {\n case 1: // Element\n return node.uniqueID;\n case 9: // Document\n return node.documentElement && node.documentElement.uniqueID;\n }\n }\n}\n\nfunction valueOf(obj) {\n return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'\n ? obj.valueOf(obj)\n : obj;\n}\n\nfunction nextHash() {\n var nextHash = ++_objHashUID;\n if (_objHashUID & 0x40000000) {\n _objHashUID = 0;\n }\n return nextHash;\n}\n\n// If possible, use a WeakMap.\nvar usingWeakMap = typeof WeakMap === 'function';\nvar weakMap;\nif (usingWeakMap) {\n weakMap = new WeakMap();\n}\n\nvar symbolMap = Object.create(null);\n\nvar _objHashUID = 0;\n\nvar UID_HASH_KEY = '__immutablehash__';\nif (typeof Symbol === 'function') {\n UID_HASH_KEY = Symbol(UID_HASH_KEY);\n}\n\nvar STRING_HASH_CACHE_MIN_STRLEN = 16;\nvar STRING_HASH_CACHE_MAX_SIZE = 255;\nvar STRING_HASH_CACHE_SIZE = 0;\nvar stringHashCache = {};\n\nvar ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) {\n function ToKeyedSequence(indexed, useKeys) {\n this._iter = indexed;\n this._useKeys = useKeys;\n this.size = indexed.size;\n }\n\n if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq;\n ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n ToKeyedSequence.prototype.constructor = ToKeyedSequence;\n\n ToKeyedSequence.prototype.get = function get (key, notSetValue) {\n return this._iter.get(key, notSetValue);\n };\n\n ToKeyedSequence.prototype.has = function has (key) {\n return this._iter.has(key);\n };\n\n ToKeyedSequence.prototype.valueSeq = function valueSeq () {\n return this._iter.valueSeq();\n };\n\n ToKeyedSequence.prototype.reverse = function reverse () {\n var this$1$1 = this;\n\n var reversedSequence = reverseFactory(this, true);\n if (!this._useKeys) {\n reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); };\n }\n return reversedSequence;\n };\n\n ToKeyedSequence.prototype.map = function map (mapper, context) {\n var this$1$1 = this;\n\n var mappedSequence = mapFactory(this, mapper, context);\n if (!this._useKeys) {\n mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); };\n }\n return mappedSequence;\n };\n\n ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse);\n };\n\n ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) {\n return this._iter.__iterator(type, reverse);\n };\n\n return ToKeyedSequence;\n}(KeyedSeq));\nToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;\n\nvar ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {\n function ToIndexedSequence(iter) {\n this._iter = iter;\n this.size = iter.size;\n }\n\n if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq;\n ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n ToIndexedSequence.prototype.constructor = ToIndexedSequence;\n\n ToIndexedSequence.prototype.includes = function includes (value) {\n return this._iter.includes(value);\n };\n\n ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n var i = 0;\n reverse && ensureSize(this);\n return this._iter.__iterate(\n function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); },\n reverse\n );\n };\n\n ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) {\n var this$1$1 = this;\n\n var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n var i = 0;\n reverse && ensureSize(this);\n return new Iterator(function () {\n var step = iterator.next();\n return step.done\n ? step\n : iteratorValue(\n type,\n reverse ? this$1$1.size - ++i : i++,\n step.value,\n step\n );\n });\n };\n\n return ToIndexedSequence;\n}(IndexedSeq));\n\nvar ToSetSequence = /*@__PURE__*/(function (SetSeq) {\n function ToSetSequence(iter) {\n this._iter = iter;\n this.size = iter.size;\n }\n\n if ( SetSeq ) ToSetSequence.__proto__ = SetSeq;\n ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype );\n ToSetSequence.prototype.constructor = ToSetSequence;\n\n ToSetSequence.prototype.has = function has (key) {\n return this._iter.includes(key);\n };\n\n ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse);\n };\n\n ToSetSequence.prototype.__iterator = function __iterator (type, reverse) {\n var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n return new Iterator(function () {\n var step = iterator.next();\n return step.done\n ? step\n : iteratorValue(type, step.value, step.value, step);\n });\n };\n\n return ToSetSequence;\n}(SetSeq));\n\nvar FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) {\n function FromEntriesSequence(entries) {\n this._iter = entries;\n this.size = entries.size;\n }\n\n if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq;\n FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n FromEntriesSequence.prototype.constructor = FromEntriesSequence;\n\n FromEntriesSequence.prototype.entrySeq = function entrySeq () {\n return this._iter.toSeq();\n };\n\n FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n return this._iter.__iterate(function (entry) {\n // Check if entry exists first so array access doesn't throw for holes\n // in the parent iteration.\n if (entry) {\n validateEntry(entry);\n var indexedCollection = isCollection(entry);\n return fn(\n indexedCollection ? entry.get(1) : entry[1],\n indexedCollection ? entry.get(0) : entry[0],\n this$1$1\n );\n }\n }, reverse);\n };\n\n FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) {\n var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n return new Iterator(function () {\n while (true) {\n var step = iterator.next();\n if (step.done) {\n return step;\n }\n var entry = step.value;\n // Check if entry exists first so array access doesn't throw for holes\n // in the parent iteration.\n if (entry) {\n validateEntry(entry);\n var indexedCollection = isCollection(entry);\n return iteratorValue(\n type,\n indexedCollection ? entry.get(0) : entry[0],\n indexedCollection ? entry.get(1) : entry[1],\n step\n );\n }\n }\n });\n };\n\n return FromEntriesSequence;\n}(KeyedSeq));\n\nToIndexedSequence.prototype.cacheResult =\n ToKeyedSequence.prototype.cacheResult =\n ToSetSequence.prototype.cacheResult =\n FromEntriesSequence.prototype.cacheResult =\n cacheResultThrough;\n\nfunction flipFactory(collection) {\n var flipSequence = makeSequence(collection);\n flipSequence._iter = collection;\n flipSequence.size = collection.size;\n flipSequence.flip = function () { return collection; };\n flipSequence.reverse = function () {\n var reversedSequence = collection.reverse.apply(this); // super.reverse()\n reversedSequence.flip = function () { return collection.reverse(); };\n return reversedSequence;\n };\n flipSequence.has = function (key) { return collection.includes(key); };\n flipSequence.includes = function (key) { return collection.has(key); };\n flipSequence.cacheResult = cacheResultThrough;\n flipSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse);\n };\n flipSequence.__iteratorUncached = function (type, reverse) {\n if (type === ITERATE_ENTRIES) {\n var iterator = collection.__iterator(type, reverse);\n return new Iterator(function () {\n var step = iterator.next();\n if (!step.done) {\n var k = step.value[0];\n step.value[0] = step.value[1];\n step.value[1] = k;\n }\n return step;\n });\n }\n return collection.__iterator(\n type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n reverse\n );\n };\n return flipSequence;\n}\n\nfunction mapFactory(collection, mapper, context) {\n var mappedSequence = makeSequence(collection);\n mappedSequence.size = collection.size;\n mappedSequence.has = function (key) { return collection.has(key); };\n mappedSequence.get = function (key, notSetValue) {\n var v = collection.get(key, NOT_SET);\n return v === NOT_SET\n ? notSetValue\n : mapper.call(context, v, key, collection);\n };\n mappedSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n return collection.__iterate(\n function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; },\n reverse\n );\n };\n mappedSequence.__iteratorUncached = function (type, reverse) {\n var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n return new Iterator(function () {\n var step = iterator.next();\n if (step.done) {\n return step;\n }\n var entry = step.value;\n var key = entry[0];\n return iteratorValue(\n type,\n key,\n mapper.call(context, entry[1], key, collection),\n step\n );\n });\n };\n return mappedSequence;\n}\n\nfunction reverseFactory(collection, useKeys) {\n var this$1$1 = this;\n\n var reversedSequence = makeSequence(collection);\n reversedSequence._iter = collection;\n reversedSequence.size = collection.size;\n reversedSequence.reverse = function () { return collection; };\n if (collection.flip) {\n reversedSequence.flip = function () {\n var flipSequence = flipFactory(collection);\n flipSequence.reverse = function () { return collection.flip(); };\n return flipSequence;\n };\n }\n reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); };\n reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); };\n reversedSequence.includes = function (value) { return collection.includes(value); };\n reversedSequence.cacheResult = cacheResultThrough;\n reversedSequence.__iterate = function (fn, reverse) {\n var this$1$1 = this;\n\n var i = 0;\n reverse && ensureSize(collection);\n return collection.__iterate(\n function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },\n !reverse\n );\n };\n reversedSequence.__iterator = function (type, reverse) {\n var i = 0;\n reverse && ensureSize(collection);\n var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);\n return new Iterator(function () {\n var step = iterator.next();\n if (step.done) {\n return step;\n }\n var entry = step.value;\n return iteratorValue(\n type,\n useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++,\n entry[1],\n step\n );\n });\n };\n return reversedSequence;\n}\n\nfunction filterFactory(collection, predicate, context, useKeys) {\n var filterSequence = makeSequence(collection);\n if (useKeys) {\n filterSequence.has = function (key) {\n var v = collection.get(key, NOT_SET);\n return v !== NOT_SET && !!predicate.call(context, v, key, collection);\n };\n filterSequence.get = function (key, notSetValue) {\n var v = collection.get(key, NOT_SET);\n return v !== NOT_SET && predicate.call(context, v, key, collection)\n ? v\n : notSetValue;\n };\n }\n filterSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n var iterations = 0;\n collection.__iterate(function (v, k, c) {\n if (predicate.call(context, v, k, c)) {\n iterations++;\n return fn(v, useKeys ? k : iterations - 1, this$1$1);\n }\n }, reverse);\n return iterations;\n };\n filterSequence.__iteratorUncached = function (type, reverse) {\n var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n var iterations = 0;\n return new Iterator(function () {\n while (true) {\n var step = iterator.next();\n if (step.done) {\n return step;\n }\n var entry = step.value;\n var key = entry[0];\n var value = entry[1];\n if (predicate.call(context, value, key, collection)) {\n return iteratorValue(type, useKeys ? key : iterations++, value, step);\n }\n }\n });\n };\n return filterSequence;\n}\n\nfunction countByFactory(collection, grouper, context) {\n var groups = Map().asMutable();\n collection.__iterate(function (v, k) {\n groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; });\n });\n return groups.asImmutable();\n}\n\nfunction groupByFactory(collection, grouper, context) {\n var isKeyedIter = isKeyed(collection);\n var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();\n collection.__iterate(function (v, k) {\n groups.update(\n grouper.call(context, v, k, collection),\n function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); }\n );\n });\n var coerce = collectionClass(collection);\n return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable();\n}\n\nfunction partitionFactory(collection, predicate, context) {\n var isKeyedIter = isKeyed(collection);\n var groups = [[], []];\n collection.__iterate(function (v, k) {\n groups[predicate.call(context, v, k, collection) ? 1 : 0].push(\n isKeyedIter ? [k, v] : v\n );\n });\n var coerce = collectionClass(collection);\n return groups.map(function (arr) { return reify(collection, coerce(arr)); });\n}\n\nfunction sliceFactory(collection, begin, end, useKeys) {\n var originalSize = collection.size;\n\n if (wholeSlice(begin, end, originalSize)) {\n return collection;\n }\n\n // begin or end can not be resolved if they were provided as negative numbers and\n // this collection's size is unknown. In that case, cache first so there is\n // a known size and these do not resolve to NaN.\n if (typeof originalSize === 'undefined' && (begin < 0 || end < 0)) {\n return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys);\n }\n\n var resolvedBegin = resolveBegin(begin, originalSize);\n var resolvedEnd = resolveEnd(end, originalSize);\n\n // Note: resolvedEnd is undefined when the original sequence's length is\n // unknown and this slice did not supply an end and should contain all\n // elements after resolvedBegin.\n // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n var resolvedSize = resolvedEnd - resolvedBegin;\n var sliceSize;\n if (resolvedSize === resolvedSize) {\n sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n }\n\n var sliceSeq = makeSequence(collection);\n\n // If collection.size is undefined, the size of the realized sliceSeq is\n // unknown at this point unless the number of items to slice is 0\n sliceSeq.size =\n sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined;\n\n if (!useKeys && isSeq(collection) && sliceSize >= 0) {\n sliceSeq.get = function (index, notSetValue) {\n index = wrapIndex(this, index);\n return index >= 0 && index < sliceSize\n ? collection.get(index + resolvedBegin, notSetValue)\n : notSetValue;\n };\n }\n\n sliceSeq.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n if (sliceSize === 0) {\n return 0;\n }\n if (reverse) {\n return this.cacheResult().__iterate(fn, reverse);\n }\n var skipped = 0;\n var isSkipping = true;\n var iterations = 0;\n collection.__iterate(function (v, k) {\n if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n iterations++;\n return (\n fn(v, useKeys ? k : iterations - 1, this$1$1) !== false &&\n iterations !== sliceSize\n );\n }\n });\n return iterations;\n };\n\n sliceSeq.__iteratorUncached = function (type, reverse) {\n if (sliceSize !== 0 && reverse) {\n return this.cacheResult().__iterator(type, reverse);\n }\n // Don't bother instantiating parent iterator if taking 0.\n if (sliceSize === 0) {\n return new Iterator(iteratorDone);\n }\n var iterator = collection.__iterator(type, reverse);\n var skipped = 0;\n var iterations = 0;\n return new Iterator(function () {\n while (skipped++ < resolvedBegin) {\n iterator.next();\n }\n if (++iterations > sliceSize) {\n return iteratorDone();\n }\n var step = iterator.next();\n if (useKeys || type === ITERATE_VALUES || step.done) {\n return step;\n }\n if (type === ITERATE_KEYS) {\n return iteratorValue(type, iterations - 1, undefined, step);\n }\n return iteratorValue(type, iterations - 1, step.value[1], step);\n });\n };\n\n return sliceSeq;\n}\n\nfunction takeWhileFactory(collection, predicate, context) {\n var takeSequence = makeSequence(collection);\n takeSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n if (reverse) {\n return this.cacheResult().__iterate(fn, reverse);\n }\n var iterations = 0;\n collection.__iterate(\n function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); }\n );\n return iterations;\n };\n takeSequence.__iteratorUncached = function (type, reverse) {\n var this$1$1 = this;\n\n if (reverse) {\n return this.cacheResult().__iterator(type, reverse);\n }\n var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n var iterating = true;\n return new Iterator(function () {\n if (!iterating) {\n return iteratorDone();\n }\n var step = iterator.next();\n if (step.done) {\n return step;\n }\n var entry = step.value;\n var k = entry[0];\n var v = entry[1];\n if (!predicate.call(context, v, k, this$1$1)) {\n iterating = false;\n return iteratorDone();\n }\n return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);\n });\n };\n return takeSequence;\n}\n\nfunction skipWhileFactory(collection, predicate, context, useKeys) {\n var skipSequence = makeSequence(collection);\n skipSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n if (reverse) {\n return this.cacheResult().__iterate(fn, reverse);\n }\n var isSkipping = true;\n var iterations = 0;\n collection.__iterate(function (v, k, c) {\n if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n iterations++;\n return fn(v, useKeys ? k : iterations - 1, this$1$1);\n }\n });\n return iterations;\n };\n skipSequence.__iteratorUncached = function (type, reverse) {\n var this$1$1 = this;\n\n if (reverse) {\n return this.cacheResult().__iterator(type, reverse);\n }\n var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n var skipping = true;\n var iterations = 0;\n return new Iterator(function () {\n var step;\n var k;\n var v;\n do {\n step = iterator.next();\n if (step.done) {\n if (useKeys || type === ITERATE_VALUES) {\n return step;\n }\n if (type === ITERATE_KEYS) {\n return iteratorValue(type, iterations++, undefined, step);\n }\n return iteratorValue(type, iterations++, step.value[1], step);\n }\n var entry = step.value;\n k = entry[0];\n v = entry[1];\n skipping && (skipping = predicate.call(context, v, k, this$1$1));\n } while (skipping);\n return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);\n });\n };\n return skipSequence;\n}\n\nfunction concatFactory(collection, values) {\n var isKeyedCollection = isKeyed(collection);\n var iters = [collection]\n .concat(values)\n .map(function (v) {\n if (!isCollection(v)) {\n v = isKeyedCollection\n ? keyedSeqFromValue(v)\n : indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n } else if (isKeyedCollection) {\n v = KeyedCollection(v);\n }\n return v;\n })\n .filter(function (v) { return v.size !== 0; });\n\n if (iters.length === 0) {\n return collection;\n }\n\n if (iters.length === 1) {\n var singleton = iters[0];\n if (\n singleton === collection ||\n (isKeyedCollection && isKeyed(singleton)) ||\n (isIndexed(collection) && isIndexed(singleton))\n ) {\n return singleton;\n }\n }\n\n var concatSeq = new ArraySeq(iters);\n if (isKeyedCollection) {\n concatSeq = concatSeq.toKeyedSeq();\n } else if (!isIndexed(collection)) {\n concatSeq = concatSeq.toSetSeq();\n }\n concatSeq = concatSeq.flatten(true);\n concatSeq.size = iters.reduce(function (sum, seq) {\n if (sum !== undefined) {\n var size = seq.size;\n if (size !== undefined) {\n return sum + size;\n }\n }\n }, 0);\n return concatSeq;\n}\n\nfunction flattenFactory(collection, depth, useKeys) {\n var flatSequence = makeSequence(collection);\n flatSequence.__iterateUncached = function (fn, reverse) {\n if (reverse) {\n return this.cacheResult().__iterate(fn, reverse);\n }\n var iterations = 0;\n var stopped = false;\n function flatDeep(iter, currentDepth) {\n iter.__iterate(function (v, k) {\n if ((!depth || currentDepth < depth) && isCollection(v)) {\n flatDeep(v, currentDepth + 1);\n } else {\n iterations++;\n if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {\n stopped = true;\n }\n }\n return !stopped;\n }, reverse);\n }\n flatDeep(collection, 0);\n return iterations;\n };\n flatSequence.__iteratorUncached = function (type, reverse) {\n if (reverse) {\n return this.cacheResult().__iterator(type, reverse);\n }\n var iterator = collection.__iterator(type, reverse);\n var stack = [];\n var iterations = 0;\n return new Iterator(function () {\n while (iterator) {\n var step = iterator.next();\n if (step.done !== false) {\n iterator = stack.pop();\n continue;\n }\n var v = step.value;\n if (type === ITERATE_ENTRIES) {\n v = v[1];\n }\n if ((!depth || stack.length < depth) && isCollection(v)) {\n stack.push(iterator);\n iterator = v.__iterator(type, reverse);\n } else {\n return useKeys ? step : iteratorValue(type, iterations++, v, step);\n }\n }\n return iteratorDone();\n });\n };\n return flatSequence;\n}\n\nfunction flatMapFactory(collection, mapper, context) {\n var coerce = collectionClass(collection);\n return collection\n .toSeq()\n .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); })\n .flatten(true);\n}\n\nfunction interposeFactory(collection, separator) {\n var interposedSequence = makeSequence(collection);\n interposedSequence.size = collection.size && collection.size * 2 - 1;\n interposedSequence.__iterateUncached = function (fn, reverse) {\n var this$1$1 = this;\n\n var iterations = 0;\n collection.__iterate(\n function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) &&\n fn(v, iterations++, this$1$1) !== false; },\n reverse\n );\n return iterations;\n };\n interposedSequence.__iteratorUncached = function (type, reverse) {\n var iterator = collection.__iterator(ITERATE_VALUES, reverse);\n var iterations = 0;\n var step;\n return new Iterator(function () {\n if (!step || iterations % 2) {\n step = iterator.next();\n if (step.done) {\n return step;\n }\n }\n return iterations % 2\n ? iteratorValue(type, iterations++, separator)\n : iteratorValue(type, iterations++, step.value, step);\n });\n };\n return interposedSequence;\n}\n\nfunction sortFactory(collection, comparator, mapper) {\n if (!comparator) {\n comparator = defaultComparator;\n }\n var isKeyedCollection = isKeyed(collection);\n var index = 0;\n var entries = collection\n .toSeq()\n .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; })\n .valueSeq()\n .toArray();\n entries\n .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; })\n .forEach(\n isKeyedCollection\n ? function (v, i) {\n entries[i].length = 2;\n }\n : function (v, i) {\n entries[i] = v[1];\n }\n );\n return isKeyedCollection\n ? KeyedSeq(entries)\n : isIndexed(collection)\n ? IndexedSeq(entries)\n : SetSeq(entries);\n}\n\nfunction maxFactory(collection, comparator, mapper) {\n if (!comparator) {\n comparator = defaultComparator;\n }\n if (mapper) {\n var entry = collection\n .toSeq()\n .map(function (v, k) { return [v, mapper(v, k, collection)]; })\n .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); });\n return entry && entry[0];\n }\n return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); });\n}\n\nfunction maxCompare(comparator, a, b) {\n var comp = comparator(b, a);\n // b is considered the new max if the comparator declares them equal, but\n // they are not equal and b is in fact a nullish value.\n return (\n (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||\n comp > 0\n );\n}\n\nfunction zipWithFactory(keyIter, zipper, iters, zipAll) {\n var zipSequence = makeSequence(keyIter);\n var sizes = new ArraySeq(iters).map(function (i) { return i.size; });\n zipSequence.size = zipAll ? sizes.max() : sizes.min();\n // Note: this a generic base implementation of __iterate in terms of\n // __iterator which may be more generically useful in the future.\n zipSequence.__iterate = function (fn, reverse) {\n /* generic:\n var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n var step;\n var iterations = 0;\n while (!(step = iterator.next()).done) {\n iterations++;\n if (fn(step.value[1], step.value[0], this) === false) {\n break;\n }\n }\n return iterations;\n */\n // indexed:\n var iterator = this.__iterator(ITERATE_VALUES, reverse);\n var step;\n var iterations = 0;\n while (!(step = iterator.next()).done) {\n if (fn(step.value, iterations++, this) === false) {\n break;\n }\n }\n return iterations;\n };\n zipSequence.__iteratorUncached = function (type, reverse) {\n var iterators = iters.map(\n function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); }\n );\n var iterations = 0;\n var isDone = false;\n return new Iterator(function () {\n var steps;\n if (!isDone) {\n steps = iterators.map(function (i) { return i.next(); });\n isDone = zipAll ? steps.every(function (s) { return s.done; }) : steps.some(function (s) { return s.done; });\n }\n if (isDone) {\n return iteratorDone();\n }\n return iteratorValue(\n type,\n iterations++,\n zipper.apply(\n null,\n steps.map(function (s) { return s.value; })\n )\n );\n });\n };\n return zipSequence;\n}\n\n// #pragma Helper Functions\n\nfunction reify(iter, seq) {\n return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);\n}\n\nfunction validateEntry(entry) {\n if (entry !== Object(entry)) {\n throw new TypeError('Expected [K, V] tuple: ' + entry);\n }\n}\n\nfunction collectionClass(collection) {\n return isKeyed(collection)\n ? KeyedCollection\n : isIndexed(collection)\n ? IndexedCollection\n : SetCollection;\n}\n\nfunction makeSequence(collection) {\n return Object.create(\n (isKeyed(collection)\n ? KeyedSeq\n : isIndexed(collection)\n ? IndexedSeq\n : SetSeq\n ).prototype\n );\n}\n\nfunction cacheResultThrough() {\n if (this._iter.cacheResult) {\n this._iter.cacheResult();\n this.size = this._iter.size;\n return this;\n }\n return Seq.prototype.cacheResult.call(this);\n}\n\nfunction defaultComparator(a, b) {\n if (a === undefined && b === undefined) {\n return 0;\n }\n\n if (a === undefined) {\n return 1;\n }\n\n if (b === undefined) {\n return -1;\n }\n\n return a > b ? 1 : a < b ? -1 : 0;\n}\n\nfunction arrCopy(arr, offset) {\n offset = offset || 0;\n var len = Math.max(0, arr.length - offset);\n var newArr = new Array(len);\n for (var ii = 0; ii < len; ii++) {\n newArr[ii] = arr[ii + offset];\n }\n return newArr;\n}\n\nfunction invariant(condition, error) {\n if (!condition) { throw new Error(error); }\n}\n\nfunction assertNotInfinite(size) {\n invariant(\n size !== Infinity,\n 'Cannot perform this action with an infinite size.'\n );\n}\n\nfunction coerceKeyPath(keyPath) {\n if (isArrayLike(keyPath) && typeof keyPath !== 'string') {\n return keyPath;\n }\n if (isOrdered(keyPath)) {\n return keyPath.toArray();\n }\n throw new TypeError(\n 'Invalid keyPath: expected Ordered Collection or Array: ' + keyPath\n );\n}\n\nvar toString = Object.prototype.toString;\n\nfunction isPlainObject(value) {\n // The base prototype's toString deals with Argument objects and native namespaces like Math\n if (\n !value ||\n typeof value !== 'object' ||\n toString.call(value) !== '[object Object]'\n ) {\n return false;\n }\n\n var proto = Object.getPrototypeOf(value);\n if (proto === null) {\n return true;\n }\n\n // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)\n var parentProto = proto;\n var nextProto = Object.getPrototypeOf(proto);\n while (nextProto !== null) {\n parentProto = nextProto;\n nextProto = Object.getPrototypeOf(parentProto);\n }\n return parentProto === proto;\n}\n\n/**\n * Returns true if the value is a potentially-persistent data structure, either\n * provided by Immutable.js or a plain Array or Object.\n */\nfunction isDataStructure(value) {\n return (\n typeof value === 'object' &&\n (isImmutable(value) || Array.isArray(value) || isPlainObject(value))\n );\n}\n\nfunction quoteString(value) {\n try {\n return typeof value === 'string' ? JSON.stringify(value) : String(value);\n } catch (_ignoreError) {\n return JSON.stringify(value);\n }\n}\n\nfunction has(collection, key) {\n return isImmutable(collection)\n ? collection.has(key)\n : isDataStructure(collection) && hasOwnProperty.call(collection, key);\n}\n\nfunction get(collection, key, notSetValue) {\n return isImmutable(collection)\n ? collection.get(key, notSetValue)\n : !has(collection, key)\n ? notSetValue\n : typeof collection.get === 'function'\n ? collection.get(key)\n : collection[key];\n}\n\nfunction shallowCopy(from) {\n if (Array.isArray(from)) {\n return arrCopy(from);\n }\n var to = {};\n for (var key in from) {\n if (hasOwnProperty.call(from, key)) {\n to[key] = from[key];\n }\n }\n return to;\n}\n\nfunction remove(collection, key) {\n if (!isDataStructure(collection)) {\n throw new TypeError(\n 'Cannot update non-data-structure value: ' + collection\n );\n }\n if (isImmutable(collection)) {\n if (!collection.remove) {\n throw new TypeError(\n 'Cannot update immutable value without .remove() method: ' + collection\n );\n }\n return collection.remove(key);\n }\n if (!hasOwnProperty.call(collection, key)) {\n return collection;\n }\n var collectionCopy = shallowCopy(collection);\n if (Array.isArray(collectionCopy)) {\n collectionCopy.splice(key, 1);\n } else {\n delete collectionCopy[key];\n }\n return collectionCopy;\n}\n\nfunction set(collection, key, value) {\n if (!isDataStructure(collection)) {\n throw new TypeError(\n 'Cannot update non-data-structure value: ' + collection\n );\n }\n if (isImmutable(collection)) {\n if (!collection.set) {\n throw new TypeError(\n 'Cannot update immutable value without .set() method: ' + collection\n );\n }\n return collection.set(key, value);\n }\n if (hasOwnProperty.call(collection, key) && value === collection[key]) {\n return collection;\n }\n var collectionCopy = shallowCopy(collection);\n collectionCopy[key] = value;\n return collectionCopy;\n}\n\nfunction updateIn$1(collection, keyPath, notSetValue, updater) {\n if (!updater) {\n updater = notSetValue;\n notSetValue = undefined;\n }\n var updatedValue = updateInDeeply(\n isImmutable(collection),\n collection,\n coerceKeyPath(keyPath),\n 0,\n notSetValue,\n updater\n );\n return updatedValue === NOT_SET ? notSetValue : updatedValue;\n}\n\nfunction updateInDeeply(\n inImmutable,\n existing,\n keyPath,\n i,\n notSetValue,\n updater\n) {\n var wasNotSet = existing === NOT_SET;\n if (i === keyPath.length) {\n var existingValue = wasNotSet ? notSetValue : existing;\n var newValue = updater(existingValue);\n return newValue === existingValue ? existing : newValue;\n }\n if (!wasNotSet && !isDataStructure(existing)) {\n throw new TypeError(\n 'Cannot update within non-data-structure value in path [' +\n keyPath.slice(0, i).map(quoteString) +\n ']: ' +\n existing\n );\n }\n var key = keyPath[i];\n var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);\n var nextUpdated = updateInDeeply(\n nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting),\n nextExisting,\n keyPath,\n i + 1,\n notSetValue,\n updater\n );\n return nextUpdated === nextExisting\n ? existing\n : nextUpdated === NOT_SET\n ? remove(existing, key)\n : set(\n wasNotSet ? (inImmutable ? emptyMap() : {}) : existing,\n key,\n nextUpdated\n );\n}\n\nfunction setIn$1(collection, keyPath, value) {\n return updateIn$1(collection, keyPath, NOT_SET, function () { return value; });\n}\n\nfunction setIn(keyPath, v) {\n return setIn$1(this, keyPath, v);\n}\n\nfunction removeIn(collection, keyPath) {\n return updateIn$1(collection, keyPath, function () { return NOT_SET; });\n}\n\nfunction deleteIn(keyPath) {\n return removeIn(this, keyPath);\n}\n\nfunction update$1(collection, key, notSetValue, updater) {\n return updateIn$1(collection, [key], notSetValue, updater);\n}\n\nfunction update(key, notSetValue, updater) {\n return arguments.length === 1\n ? key(this)\n : update$1(this, key, notSetValue, updater);\n}\n\nfunction updateIn(keyPath, notSetValue, updater) {\n return updateIn$1(this, keyPath, notSetValue, updater);\n}\n\nfunction merge$1() {\n var iters = [], len = arguments.length;\n while ( len-- ) iters[ len ] = arguments[ len ];\n\n return mergeIntoKeyedWith(this, iters);\n}\n\nfunction mergeWith$1(merger) {\n var iters = [], len = arguments.length - 1;\n while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n if (typeof merger !== 'function') {\n throw new TypeError('Invalid merger function: ' + merger);\n }\n return mergeIntoKeyedWith(this, iters, merger);\n}\n\nfunction mergeIntoKeyedWith(collection, collections, merger) {\n var iters = [];\n for (var ii = 0; ii < collections.length; ii++) {\n var collection$1 = KeyedCollection(collections[ii]);\n if (collection$1.size !== 0) {\n iters.push(collection$1);\n }\n }\n if (iters.length === 0) {\n return collection;\n }\n if (\n collection.toSeq().size === 0 &&\n !collection.__ownerID &&\n iters.length === 1\n ) {\n return collection.constructor(iters[0]);\n }\n return collection.withMutations(function (collection) {\n var mergeIntoCollection = merger\n ? function (value, key) {\n update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); }\n );\n }\n : function (value, key) {\n collection.set(key, value);\n };\n for (var ii = 0; ii < iters.length; ii++) {\n iters[ii].forEach(mergeIntoCollection);\n }\n });\n}\n\nfunction merge(collection) {\n var sources = [], len = arguments.length - 1;\n while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];\n\n return mergeWithSources(collection, sources);\n}\n\nfunction mergeWith(merger, collection) {\n var sources = [], len = arguments.length - 2;\n while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];\n\n return mergeWithSources(collection, sources, merger);\n}\n\nfunction mergeDeep$1(collection) {\n var sources = [], len = arguments.length - 1;\n while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];\n\n return mergeDeepWithSources(collection, sources);\n}\n\nfunction mergeDeepWith$1(merger, collection) {\n var sources = [], len = arguments.length - 2;\n while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];\n\n return mergeDeepWithSources(collection, sources, merger);\n}\n\nfunction mergeDeepWithSources(collection, sources, merger) {\n return mergeWithSources(collection, sources, deepMergerWith(merger));\n}\n\nfunction mergeWithSources(collection, sources, merger) {\n if (!isDataStructure(collection)) {\n throw new TypeError(\n 'Cannot merge into non-data-structure value: ' + collection\n );\n }\n if (isImmutable(collection)) {\n return typeof merger === 'function' && collection.mergeWith\n ? collection.mergeWith.apply(collection, [ merger ].concat( sources ))\n : collection.merge\n ? collection.merge.apply(collection, sources)\n : collection.concat.apply(collection, sources);\n }\n var isArray = Array.isArray(collection);\n var merged = collection;\n var Collection = isArray ? IndexedCollection : KeyedCollection;\n var mergeItem = isArray\n ? function (value) {\n // Copy on write\n if (merged === collection) {\n merged = shallowCopy(merged);\n }\n merged.push(value);\n }\n : function (value, key) {\n var hasVal = hasOwnProperty.call(merged, key);\n var nextVal =\n hasVal && merger ? merger(merged[key], value, key) : value;\n if (!hasVal || nextVal !== merged[key]) {\n // Copy on write\n if (merged === collection) {\n merged = shallowCopy(merged);\n }\n merged[key] = nextVal;\n }\n };\n for (var i = 0; i < sources.length; i++) {\n Collection(sources[i]).forEach(mergeItem);\n }\n return merged;\n}\n\nfunction deepMergerWith(merger) {\n function deepMerger(oldValue, newValue, key) {\n return isDataStructure(oldValue) &&\n isDataStructure(newValue) &&\n areMergeable(oldValue, newValue)\n ? mergeWithSources(oldValue, [newValue], deepMerger)\n : merger\n ? merger(oldValue, newValue, key)\n : newValue;\n }\n return deepMerger;\n}\n\n/**\n * It's unclear what the desired behavior is for merging two collections that\n * fall into separate categories between keyed, indexed, or set-like, so we only\n * consider them mergeable if they fall into the same category.\n */\nfunction areMergeable(oldDataStructure, newDataStructure) {\n var oldSeq = Seq(oldDataStructure);\n var newSeq = Seq(newDataStructure);\n // This logic assumes that a sequence can only fall into one of the three\n // categories mentioned above (since there's no `isSetLike()` method).\n return (\n isIndexed(oldSeq) === isIndexed(newSeq) &&\n isKeyed(oldSeq) === isKeyed(newSeq)\n );\n}\n\nfunction mergeDeep() {\n var iters = [], len = arguments.length;\n while ( len-- ) iters[ len ] = arguments[ len ];\n\n return mergeDeepWithSources(this, iters);\n}\n\nfunction mergeDeepWith(merger) {\n var iters = [], len = arguments.length - 1;\n while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n return mergeDeepWithSources(this, iters, merger);\n}\n\nfunction mergeIn(keyPath) {\n var iters = [], len = arguments.length - 1;\n while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); });\n}\n\nfunction mergeDeepIn(keyPath) {\n var iters = [], len = arguments.length - 1;\n while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); }\n );\n}\n\nfunction withMutations(fn) {\n var mutable = this.asMutable();\n fn(mutable);\n return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n}\n\nfunction asMutable() {\n return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n}\n\nfunction asImmutable() {\n return this.__ensureOwner();\n}\n\nfunction wasAltered() {\n return this.__altered;\n}\n\nvar Map = /*@__PURE__*/(function (KeyedCollection) {\n function Map(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptyMap()\n : isMap(value) && !isOrdered(value)\n ? value\n : emptyMap().withMutations(function (map) {\n var iter = KeyedCollection(value);\n assertNotInfinite(iter.size);\n iter.forEach(function (v, k) { return map.set(k, v); });\n });\n }\n\n if ( KeyedCollection ) Map.__proto__ = KeyedCollection;\n Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype );\n Map.prototype.constructor = Map;\n\n Map.of = function of () {\n var keyValues = [], len = arguments.length;\n while ( len-- ) keyValues[ len ] = arguments[ len ];\n\n return emptyMap().withMutations(function (map) {\n for (var i = 0; i < keyValues.length; i += 2) {\n if (i + 1 >= keyValues.length) {\n throw new Error('Missing value for key: ' + keyValues[i]);\n }\n map.set(keyValues[i], keyValues[i + 1]);\n }\n });\n };\n\n Map.prototype.toString = function toString () {\n return this.__toString('Map {', '}');\n };\n\n // @pragma Access\n\n Map.prototype.get = function get (k, notSetValue) {\n return this._root\n ? this._root.get(0, undefined, k, notSetValue)\n : notSetValue;\n };\n\n // @pragma Modification\n\n Map.prototype.set = function set (k, v) {\n return updateMap(this, k, v);\n };\n\n Map.prototype.remove = function remove (k) {\n return updateMap(this, k, NOT_SET);\n };\n\n Map.prototype.deleteAll = function deleteAll (keys) {\n var collection = Collection(keys);\n\n if (collection.size === 0) {\n return this;\n }\n\n return this.withMutations(function (map) {\n collection.forEach(function (key) { return map.remove(key); });\n });\n };\n\n Map.prototype.clear = function clear () {\n if (this.size === 0) {\n return this;\n }\n if (this.__ownerID) {\n this.size = 0;\n this._root = null;\n this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return emptyMap();\n };\n\n // @pragma Composition\n\n Map.prototype.sort = function sort (comparator) {\n // Late binding\n return OrderedMap(sortFactory(this, comparator));\n };\n\n Map.prototype.sortBy = function sortBy (mapper, comparator) {\n // Late binding\n return OrderedMap(sortFactory(this, comparator, mapper));\n };\n\n Map.prototype.map = function map (mapper, context) {\n var this$1$1 = this;\n\n return this.withMutations(function (map) {\n map.forEach(function (value, key) {\n map.set(key, mapper.call(context, value, key, this$1$1));\n });\n });\n };\n\n // @pragma Mutability\n\n Map.prototype.__iterator = function __iterator (type, reverse) {\n return new MapIterator(this, type, reverse);\n };\n\n Map.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n var iterations = 0;\n this._root &&\n this._root.iterate(function (entry) {\n iterations++;\n return fn(entry[1], entry[0], this$1$1);\n }, reverse);\n return iterations;\n };\n\n Map.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n if (!ownerID) {\n if (this.size === 0) {\n return emptyMap();\n }\n this.__ownerID = ownerID;\n this.__altered = false;\n return this;\n }\n return makeMap(this.size, this._root, ownerID, this.__hash);\n };\n\n return Map;\n}(KeyedCollection));\n\nMap.isMap = isMap;\n\nvar MapPrototype = Map.prototype;\nMapPrototype[IS_MAP_SYMBOL] = true;\nMapPrototype[DELETE] = MapPrototype.remove;\nMapPrototype.removeAll = MapPrototype.deleteAll;\nMapPrototype.setIn = setIn;\nMapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;\nMapPrototype.update = update;\nMapPrototype.updateIn = updateIn;\nMapPrototype.merge = MapPrototype.concat = merge$1;\nMapPrototype.mergeWith = mergeWith$1;\nMapPrototype.mergeDeep = mergeDeep;\nMapPrototype.mergeDeepWith = mergeDeepWith;\nMapPrototype.mergeIn = mergeIn;\nMapPrototype.mergeDeepIn = mergeDeepIn;\nMapPrototype.withMutations = withMutations;\nMapPrototype.wasAltered = wasAltered;\nMapPrototype.asImmutable = asImmutable;\nMapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable;\nMapPrototype['@@transducer/step'] = function (result, arr) {\n return result.set(arr[0], arr[1]);\n};\nMapPrototype['@@transducer/result'] = function (obj) {\n return obj.asImmutable();\n};\n\n// #pragma Trie Nodes\n\nvar ArrayMapNode = function ArrayMapNode(ownerID, entries) {\n this.ownerID = ownerID;\n this.entries = entries;\n};\n\nArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n var entries = this.entries;\n for (var ii = 0, len = entries.length; ii < len; ii++) {\n if (is(key, entries[ii][0])) {\n return entries[ii][1];\n }\n }\n return notSetValue;\n};\n\nArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n var removed = value === NOT_SET;\n\n var entries = this.entries;\n var idx = 0;\n var len = entries.length;\n for (; idx < len; idx++) {\n if (is(key, entries[idx][0])) {\n break;\n }\n }\n var exists = idx < len;\n\n if (exists ? entries[idx][1] === value : removed) {\n return this;\n }\n\n SetRef(didAlter);\n (removed || !exists) && SetRef(didChangeSize);\n\n if (removed && entries.length === 1) {\n return; // undefined\n }\n\n if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n return createNodes(ownerID, entries, key, value);\n }\n\n var isEditable = ownerID && ownerID === this.ownerID;\n var newEntries = isEditable ? entries : arrCopy(entries);\n\n if (exists) {\n if (removed) {\n idx === len - 1\n ? newEntries.pop()\n : (newEntries[idx] = newEntries.pop());\n } else {\n newEntries[idx] = [key, value];\n }\n } else {\n newEntries.push([key, value]);\n }\n\n if (isEditable) {\n this.entries = newEntries;\n return this;\n }\n\n return new ArrayMapNode(ownerID, newEntries);\n};\n\nvar BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) {\n this.ownerID = ownerID;\n this.bitmap = bitmap;\n this.nodes = nodes;\n};\n\nBitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n if (keyHash === undefined) {\n keyHash = hash(key);\n }\n var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);\n var bitmap = this.bitmap;\n return (bitmap & bit) === 0\n ? notSetValue\n : this.nodes[popCount(bitmap & (bit - 1))].get(\n shift + SHIFT,\n keyHash,\n key,\n notSetValue\n );\n};\n\nBitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n if (keyHash === undefined) {\n keyHash = hash(key);\n }\n var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n var bit = 1 << keyHashFrag;\n var bitmap = this.bitmap;\n var exists = (bitmap & bit) !== 0;\n\n if (!exists && value === NOT_SET) {\n return this;\n }\n\n var idx = popCount(bitmap & (bit - 1));\n var nodes = this.nodes;\n var node = exists ? nodes[idx] : undefined;\n var newNode = updateNode(\n node,\n ownerID,\n shift + SHIFT,\n keyHash,\n key,\n value,\n didChangeSize,\n didAlter\n );\n\n if (newNode === node) {\n return this;\n }\n\n if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n }\n\n if (\n exists &&\n !newNode &&\n nodes.length === 2 &&\n isLeafNode(nodes[idx ^ 1])\n ) {\n return nodes[idx ^ 1];\n }\n\n if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n return newNode;\n }\n\n var isEditable = ownerID && ownerID === this.ownerID;\n var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;\n var newNodes = exists\n ? newNode\n ? setAt(nodes, idx, newNode, isEditable)\n : spliceOut(nodes, idx, isEditable)\n : spliceIn(nodes, idx, newNode, isEditable);\n\n if (isEditable) {\n this.bitmap = newBitmap;\n this.nodes = newNodes;\n return this;\n }\n\n return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n};\n\nvar HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) {\n this.ownerID = ownerID;\n this.count = count;\n this.nodes = nodes;\n};\n\nHashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n if (keyHash === undefined) {\n keyHash = hash(key);\n }\n var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n var node = this.nodes[idx];\n return node\n ? node.get(shift + SHIFT, keyHash, key, notSetValue)\n : notSetValue;\n};\n\nHashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n if (keyHash === undefined) {\n keyHash = hash(key);\n }\n var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n var removed = value === NOT_SET;\n var nodes = this.nodes;\n var node = nodes[idx];\n\n if (removed && !node) {\n return this;\n }\n\n var newNode = updateNode(\n node,\n ownerID,\n shift + SHIFT,\n keyHash,\n key,\n value,\n didChangeSize,\n didAlter\n );\n if (newNode === node) {\n return this;\n }\n\n var newCount = this.count;\n if (!node) {\n newCount++;\n } else if (!newNode) {\n newCount--;\n if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n return packNodes(ownerID, nodes, newCount, idx);\n }\n }\n\n var isEditable = ownerID && ownerID === this.ownerID;\n var newNodes = setAt(nodes, idx, newNode, isEditable);\n\n if (isEditable) {\n this.count = newCount;\n this.nodes = newNodes;\n return this;\n }\n\n return new HashArrayMapNode(ownerID, newCount, newNodes);\n};\n\nvar HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) {\n this.ownerID = ownerID;\n this.keyHash = keyHash;\n this.entries = entries;\n};\n\nHashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n var entries = this.entries;\n for (var ii = 0, len = entries.length; ii < len; ii++) {\n if (is(key, entries[ii][0])) {\n return entries[ii][1];\n }\n }\n return notSetValue;\n};\n\nHashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n if (keyHash === undefined) {\n keyHash = hash(key);\n }\n\n var removed = value === NOT_SET;\n\n if (keyHash !== this.keyHash) {\n if (removed) {\n return this;\n }\n SetRef(didAlter);\n SetRef(didChangeSize);\n return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n }\n\n var entries = this.entries;\n var idx = 0;\n var len = entries.length;\n for (; idx < len; idx++) {\n if (is(key, entries[idx][0])) {\n break;\n }\n }\n var exists = idx < len;\n\n if (exists ? entries[idx][1] === value : removed) {\n return this;\n }\n\n SetRef(didAlter);\n (removed || !exists) && SetRef(didChangeSize);\n\n if (removed && len === 2) {\n return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n }\n\n var isEditable = ownerID && ownerID === this.ownerID;\n var newEntries = isEditable ? entries : arrCopy(entries);\n\n if (exists) {\n if (removed) {\n idx === len - 1\n ? newEntries.pop()\n : (newEntries[idx] = newEntries.pop());\n } else {\n newEntries[idx] = [key, value];\n }\n } else {\n newEntries.push([key, value]);\n }\n\n if (isEditable) {\n this.entries = newEntries;\n return this;\n }\n\n return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n};\n\nvar ValueNode = function ValueNode(ownerID, keyHash, entry) {\n this.ownerID = ownerID;\n this.keyHash = keyHash;\n this.entry = entry;\n};\n\nValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n};\n\nValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n var removed = value === NOT_SET;\n var keyMatch = is(key, this.entry[0]);\n if (keyMatch ? value === this.entry[1] : removed) {\n return this;\n }\n\n SetRef(didAlter);\n\n if (removed) {\n SetRef(didChangeSize);\n return; // undefined\n }\n\n if (keyMatch) {\n if (ownerID && ownerID === this.ownerID) {\n this.entry[1] = value;\n return this;\n }\n return new ValueNode(ownerID, this.keyHash, [key, value]);\n }\n\n SetRef(didChangeSize);\n return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n};\n\n// #pragma Iterators\n\nArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate =\n function (fn, reverse) {\n var entries = this.entries;\n for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n return false;\n }\n }\n };\n\nBitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate =\n function (fn, reverse) {\n var nodes = this.nodes;\n for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n var node = nodes[reverse ? maxIndex - ii : ii];\n if (node && node.iterate(fn, reverse) === false) {\n return false;\n }\n }\n };\n\n// eslint-disable-next-line no-unused-vars\nValueNode.prototype.iterate = function (fn, reverse) {\n return fn(this.entry);\n};\n\nvar MapIterator = /*@__PURE__*/(function (Iterator) {\n function MapIterator(map, type, reverse) {\n this._type = type;\n this._reverse = reverse;\n this._stack = map._root && mapIteratorFrame(map._root);\n }\n\n if ( Iterator ) MapIterator.__proto__ = Iterator;\n MapIterator.prototype = Object.create( Iterator && Iterator.prototype );\n MapIterator.prototype.constructor = MapIterator;\n\n MapIterator.prototype.next = function next () {\n var type = this._type;\n var stack = this._stack;\n while (stack) {\n var node = stack.node;\n var index = stack.index++;\n var maxIndex = (void 0);\n if (node.entry) {\n if (index === 0) {\n return mapIteratorValue(type, node.entry);\n }\n } else if (node.entries) {\n maxIndex = node.entries.length - 1;\n if (index <= maxIndex) {\n return mapIteratorValue(\n type,\n node.entries[this._reverse ? maxIndex - index : index]\n );\n }\n } else {\n maxIndex = node.nodes.length - 1;\n if (index <= maxIndex) {\n var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n if (subNode) {\n if (subNode.entry) {\n return mapIteratorValue(type, subNode.entry);\n }\n stack = this._stack = mapIteratorFrame(subNode, stack);\n }\n continue;\n }\n }\n stack = this._stack = this._stack.__prev;\n }\n return iteratorDone();\n };\n\n return MapIterator;\n}(Iterator));\n\nfunction mapIteratorValue(type, entry) {\n return iteratorValue(type, entry[0], entry[1]);\n}\n\nfunction mapIteratorFrame(node, prev) {\n return {\n node: node,\n index: 0,\n __prev: prev,\n };\n}\n\nfunction makeMap(size, root, ownerID, hash) {\n var map = Object.create(MapPrototype);\n map.size = size;\n map._root = root;\n map.__ownerID = ownerID;\n map.__hash = hash;\n map.__altered = false;\n return map;\n}\n\nvar EMPTY_MAP;\nfunction emptyMap() {\n return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n}\n\nfunction updateMap(map, k, v) {\n var newRoot;\n var newSize;\n if (!map._root) {\n if (v === NOT_SET) {\n return map;\n }\n newSize = 1;\n newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n } else {\n var didChangeSize = MakeRef();\n var didAlter = MakeRef();\n newRoot = updateNode(\n map._root,\n map.__ownerID,\n 0,\n undefined,\n k,\n v,\n didChangeSize,\n didAlter\n );\n if (!didAlter.value) {\n return map;\n }\n newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);\n }\n if (map.__ownerID) {\n map.size = newSize;\n map._root = newRoot;\n map.__hash = undefined;\n map.__altered = true;\n return map;\n }\n return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n}\n\nfunction updateNode(\n node,\n ownerID,\n shift,\n keyHash,\n key,\n value,\n didChangeSize,\n didAlter\n) {\n if (!node) {\n if (value === NOT_SET) {\n return node;\n }\n SetRef(didAlter);\n SetRef(didChangeSize);\n return new ValueNode(ownerID, keyHash, [key, value]);\n }\n return node.update(\n ownerID,\n shift,\n keyHash,\n key,\n value,\n didChangeSize,\n didAlter\n );\n}\n\nfunction isLeafNode(node) {\n return (\n node.constructor === ValueNode || node.constructor === HashCollisionNode\n );\n}\n\nfunction mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n if (node.keyHash === keyHash) {\n return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n }\n\n var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n var newNode;\n var nodes =\n idx1 === idx2\n ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]\n : ((newNode = new ValueNode(ownerID, keyHash, entry)),\n idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n}\n\nfunction createNodes(ownerID, entries, key, value) {\n if (!ownerID) {\n ownerID = new OwnerID();\n }\n var node = new ValueNode(ownerID, hash(key), [key, value]);\n for (var ii = 0; ii < entries.length; ii++) {\n var entry = entries[ii];\n node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n }\n return node;\n}\n\nfunction packNodes(ownerID, nodes, count, excluding) {\n var bitmap = 0;\n var packedII = 0;\n var packedNodes = new Array(count);\n for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n var node = nodes[ii];\n if (node !== undefined && ii !== excluding) {\n bitmap |= bit;\n packedNodes[packedII++] = node;\n }\n }\n return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n}\n\nfunction expandNodes(ownerID, nodes, bitmap, including, node) {\n var count = 0;\n var expandedNodes = new Array(SIZE);\n for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n }\n expandedNodes[including] = node;\n return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n}\n\nfunction popCount(x) {\n x -= (x >> 1) & 0x55555555;\n x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n x = (x + (x >> 4)) & 0x0f0f0f0f;\n x += x >> 8;\n x += x >> 16;\n return x & 0x7f;\n}\n\nfunction setAt(array, idx, val, canEdit) {\n var newArray = canEdit ? array : arrCopy(array);\n newArray[idx] = val;\n return newArray;\n}\n\nfunction spliceIn(array, idx, val, canEdit) {\n var newLen = array.length + 1;\n if (canEdit && idx + 1 === newLen) {\n array[idx] = val;\n return array;\n }\n var newArray = new Array(newLen);\n var after = 0;\n for (var ii = 0; ii < newLen; ii++) {\n if (ii === idx) {\n newArray[ii] = val;\n after = -1;\n } else {\n newArray[ii] = array[ii + after];\n }\n }\n return newArray;\n}\n\nfunction spliceOut(array, idx, canEdit) {\n var newLen = array.length - 1;\n if (canEdit && idx === newLen) {\n array.pop();\n return array;\n }\n var newArray = new Array(newLen);\n var after = 0;\n for (var ii = 0; ii < newLen; ii++) {\n if (ii === idx) {\n after = 1;\n }\n newArray[ii] = array[ii + after];\n }\n return newArray;\n}\n\nvar MAX_ARRAY_MAP_SIZE = SIZE / 4;\nvar MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\nvar MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\nvar IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';\n\nfunction isList(maybeList) {\n return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);\n}\n\nvar List = /*@__PURE__*/(function (IndexedCollection) {\n function List(value) {\n var empty = emptyList();\n if (value === undefined || value === null) {\n // eslint-disable-next-line no-constructor-return\n return empty;\n }\n if (isList(value)) {\n // eslint-disable-next-line no-constructor-return\n return value;\n }\n var iter = IndexedCollection(value);\n var size = iter.size;\n if (size === 0) {\n // eslint-disable-next-line no-constructor-return\n return empty;\n }\n assertNotInfinite(size);\n if (size > 0 && size < SIZE) {\n // eslint-disable-next-line no-constructor-return\n return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n }\n // eslint-disable-next-line no-constructor-return\n return empty.withMutations(function (list) {\n list.setSize(size);\n iter.forEach(function (v, i) { return list.set(i, v); });\n });\n }\n\n if ( IndexedCollection ) List.__proto__ = IndexedCollection;\n List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );\n List.prototype.constructor = List;\n\n List.of = function of (/*...values*/) {\n return this(arguments);\n };\n\n List.prototype.toString = function toString () {\n return this.__toString('List [', ']');\n };\n\n // @pragma Access\n\n List.prototype.get = function get (index, notSetValue) {\n index = wrapIndex(this, index);\n if (index >= 0 && index < this.size) {\n index += this._origin;\n var node = listNodeFor(this, index);\n return node && node.array[index & MASK];\n }\n return notSetValue;\n };\n\n // @pragma Modification\n\n List.prototype.set = function set (index, value) {\n return updateList(this, index, value);\n };\n\n List.prototype.remove = function remove (index) {\n return !this.has(index)\n ? this\n : index === 0\n ? this.shift()\n : index === this.size - 1\n ? this.pop()\n : this.splice(index, 1);\n };\n\n List.prototype.insert = function insert (index, value) {\n return this.splice(index, 0, value);\n };\n\n List.prototype.clear = function clear () {\n if (this.size === 0) {\n return this;\n }\n if (this.__ownerID) {\n this.size = this._origin = this._capacity = 0;\n this._level = SHIFT;\n this._root = this._tail = this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return emptyList();\n };\n\n List.prototype.push = function push (/*...values*/) {\n var values = arguments;\n var oldSize = this.size;\n return this.withMutations(function (list) {\n setListBounds(list, 0, oldSize + values.length);\n for (var ii = 0; ii < values.length; ii++) {\n list.set(oldSize + ii, values[ii]);\n }\n });\n };\n\n List.prototype.pop = function pop () {\n return setListBounds(this, 0, -1);\n };\n\n List.prototype.unshift = function unshift (/*...values*/) {\n var values = arguments;\n return this.withMutations(function (list) {\n setListBounds(list, -values.length);\n for (var ii = 0; ii < values.length; ii++) {\n list.set(ii, values[ii]);\n }\n });\n };\n\n List.prototype.shift = function shift () {\n return setListBounds(this, 1);\n };\n\n // @pragma Composition\n\n List.prototype.concat = function concat (/*...collections*/) {\n var arguments$1 = arguments;\n\n var seqs = [];\n for (var i = 0; i < arguments.length; i++) {\n var argument = arguments$1[i];\n var seq = IndexedCollection(\n typeof argument !== 'string' && hasIterator(argument)\n ? argument\n : [argument]\n );\n if (seq.size !== 0) {\n seqs.push(seq);\n }\n }\n if (seqs.length === 0) {\n return this;\n }\n if (this.size === 0 && !this.__ownerID && seqs.length === 1) {\n return this.constructor(seqs[0]);\n }\n return this.withMutations(function (list) {\n seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); });\n });\n };\n\n List.prototype.setSize = function setSize (size) {\n return setListBounds(this, 0, size);\n };\n\n List.prototype.map = function map (mapper, context) {\n var this$1$1 = this;\n\n return this.withMutations(function (list) {\n for (var i = 0; i < this$1$1.size; i++) {\n list.set(i, mapper.call(context, list.get(i), i, this$1$1));\n }\n });\n };\n\n // @pragma Iteration\n\n List.prototype.slice = function slice (begin, end) {\n var size = this.size;\n if (wholeSlice(begin, end, size)) {\n return this;\n }\n return setListBounds(\n this,\n resolveBegin(begin, size),\n resolveEnd(end, size)\n );\n };\n\n List.prototype.__iterator = function __iterator (type, reverse) {\n var index = reverse ? this.size : 0;\n var values = iterateList(this, reverse);\n return new Iterator(function () {\n var value = values();\n return value === DONE\n ? iteratorDone()\n : iteratorValue(type, reverse ? --index : index++, value);\n });\n };\n\n List.prototype.__iterate = function __iterate (fn, reverse) {\n var index = reverse ? this.size : 0;\n var values = iterateList(this, reverse);\n var value;\n while ((value = values()) !== DONE) {\n if (fn(value, reverse ? --index : index++, this) === false) {\n break;\n }\n }\n return index;\n };\n\n List.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n if (!ownerID) {\n if (this.size === 0) {\n return emptyList();\n }\n this.__ownerID = ownerID;\n this.__altered = false;\n return this;\n }\n return makeList(\n this._origin,\n this._capacity,\n this._level,\n this._root,\n this._tail,\n ownerID,\n this.__hash\n );\n };\n\n return List;\n}(IndexedCollection));\n\nList.isList = isList;\n\nvar ListPrototype = List.prototype;\nListPrototype[IS_LIST_SYMBOL] = true;\nListPrototype[DELETE] = ListPrototype.remove;\nListPrototype.merge = ListPrototype.concat;\nListPrototype.setIn = setIn;\nListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;\nListPrototype.update = update;\nListPrototype.updateIn = updateIn;\nListPrototype.mergeIn = mergeIn;\nListPrototype.mergeDeepIn = mergeDeepIn;\nListPrototype.withMutations = withMutations;\nListPrototype.wasAltered = wasAltered;\nListPrototype.asImmutable = asImmutable;\nListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable;\nListPrototype['@@transducer/step'] = function (result, arr) {\n return result.push(arr);\n};\nListPrototype['@@transducer/result'] = function (obj) {\n return obj.asImmutable();\n};\n\nvar VNode = function VNode(array, ownerID) {\n this.array = array;\n this.ownerID = ownerID;\n};\n\n// TODO: seems like these methods are very similar\n\nVNode.prototype.removeBefore = function removeBefore (ownerID, level, index) {\n if (index === level ? 1 << level : this.array.length === 0) {\n return this;\n }\n var originIndex = (index >>> level) & MASK;\n if (originIndex >= this.array.length) {\n return new VNode([], ownerID);\n }\n var removingFirst = originIndex === 0;\n var newChild;\n if (level > 0) {\n var oldChild = this.array[originIndex];\n newChild =\n oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n if (newChild === oldChild && removingFirst) {\n return this;\n }\n }\n if (removingFirst && !newChild) {\n return this;\n }\n var editable = editableVNode(this, ownerID);\n if (!removingFirst) {\n for (var ii = 0; ii < originIndex; ii++) {\n editable.array[ii] = undefined;\n }\n }\n if (newChild) {\n editable.array[originIndex] = newChild;\n }\n return editable;\n};\n\nVNode.prototype.removeAfter = function removeAfter (ownerID, level, index) {\n if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n return this;\n }\n var sizeIndex = ((index - 1) >>> level) & MASK;\n if (sizeIndex >= this.array.length) {\n return this;\n }\n\n var newChild;\n if (level > 0) {\n var oldChild = this.array[sizeIndex];\n newChild =\n oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n return this;\n }\n }\n\n var editable = editableVNode(this, ownerID);\n editable.array.splice(sizeIndex + 1);\n if (newChild) {\n editable.array[sizeIndex] = newChild;\n }\n return editable;\n};\n\nvar DONE = {};\n\nfunction iterateList(list, reverse) {\n var left = list._origin;\n var right = list._capacity;\n var tailPos = getTailOffset(right);\n var tail = list._tail;\n\n return iterateNodeOrLeaf(list._root, list._level, 0);\n\n function iterateNodeOrLeaf(node, level, offset) {\n return level === 0\n ? iterateLeaf(node, offset)\n : iterateNode(node, level, offset);\n }\n\n function iterateLeaf(node, offset) {\n var array = offset === tailPos ? tail && tail.array : node && node.array;\n var from = offset > left ? 0 : left - offset;\n var to = right - offset;\n if (to > SIZE) {\n to = SIZE;\n }\n return function () {\n if (from === to) {\n return DONE;\n }\n var idx = reverse ? --to : from++;\n return array && array[idx];\n };\n }\n\n function iterateNode(node, level, offset) {\n var values;\n var array = node && node.array;\n var from = offset > left ? 0 : (left - offset) >> level;\n var to = ((right - offset) >> level) + 1;\n if (to > SIZE) {\n to = SIZE;\n }\n return function () {\n while (true) {\n if (values) {\n var value = values();\n if (value !== DONE) {\n return value;\n }\n values = null;\n }\n if (from === to) {\n return DONE;\n }\n var idx = reverse ? --to : from++;\n values = iterateNodeOrLeaf(\n array && array[idx],\n level - SHIFT,\n offset + (idx << level)\n );\n }\n };\n }\n}\n\nfunction makeList(origin, capacity, level, root, tail, ownerID, hash) {\n var list = Object.create(ListPrototype);\n list.size = capacity - origin;\n list._origin = origin;\n list._capacity = capacity;\n list._level = level;\n list._root = root;\n list._tail = tail;\n list.__ownerID = ownerID;\n list.__hash = hash;\n list.__altered = false;\n return list;\n}\n\nvar EMPTY_LIST;\nfunction emptyList() {\n return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n}\n\nfunction updateList(list, index, value) {\n index = wrapIndex(list, index);\n\n if (index !== index) {\n return list;\n }\n\n if (index >= list.size || index < 0) {\n return list.withMutations(function (list) {\n index < 0\n ? setListBounds(list, index).set(0, value)\n : setListBounds(list, 0, index + 1).set(index, value);\n });\n }\n\n index += list._origin;\n\n var newTail = list._tail;\n var newRoot = list._root;\n var didAlter = MakeRef();\n if (index >= getTailOffset(list._capacity)) {\n newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n } else {\n newRoot = updateVNode(\n newRoot,\n list.__ownerID,\n list._level,\n index,\n value,\n didAlter\n );\n }\n\n if (!didAlter.value) {\n return list;\n }\n\n if (list.__ownerID) {\n list._root = newRoot;\n list._tail = newTail;\n list.__hash = undefined;\n list.__altered = true;\n return list;\n }\n return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n}\n\nfunction updateVNode(node, ownerID, level, index, value, didAlter) {\n var idx = (index >>> level) & MASK;\n var nodeHas = node && idx < node.array.length;\n if (!nodeHas && value === undefined) {\n return node;\n }\n\n var newNode;\n\n if (level > 0) {\n var lowerNode = node && node.array[idx];\n var newLowerNode = updateVNode(\n lowerNode,\n ownerID,\n level - SHIFT,\n index,\n value,\n didAlter\n );\n if (newLowerNode === lowerNode) {\n return node;\n }\n newNode = editableVNode(node, ownerID);\n newNode.array[idx] = newLowerNode;\n return newNode;\n }\n\n if (nodeHas && node.array[idx] === value) {\n return node;\n }\n\n if (didAlter) {\n SetRef(didAlter);\n }\n\n newNode = editableVNode(node, ownerID);\n if (value === undefined && idx === newNode.array.length - 1) {\n newNode.array.pop();\n } else {\n newNode.array[idx] = value;\n }\n return newNode;\n}\n\nfunction editableVNode(node, ownerID) {\n if (ownerID && node && ownerID === node.ownerID) {\n return node;\n }\n return new VNode(node ? node.array.slice() : [], ownerID);\n}\n\nfunction listNodeFor(list, rawIndex) {\n if (rawIndex >= getTailOffset(list._capacity)) {\n return list._tail;\n }\n if (rawIndex < 1 << (list._level + SHIFT)) {\n var node = list._root;\n var level = list._level;\n while (node && level > 0) {\n node = node.array[(rawIndex >>> level) & MASK];\n level -= SHIFT;\n }\n return node;\n }\n}\n\nfunction setListBounds(list, begin, end) {\n // Sanitize begin & end using this shorthand for ToInt32(argument)\n // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n if (begin !== undefined) {\n begin |= 0;\n }\n if (end !== undefined) {\n end |= 0;\n }\n var owner = list.__ownerID || new OwnerID();\n var oldOrigin = list._origin;\n var oldCapacity = list._capacity;\n var newOrigin = oldOrigin + begin;\n var newCapacity =\n end === undefined\n ? oldCapacity\n : end < 0\n ? oldCapacity + end\n : oldOrigin + end;\n if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n return list;\n }\n\n // If it's going to end after it starts, it's empty.\n if (newOrigin >= newCapacity) {\n return list.clear();\n }\n\n var newLevel = list._level;\n var newRoot = list._root;\n\n // New origin might need creating a higher root.\n var offsetShift = 0;\n while (newOrigin + offsetShift < 0) {\n newRoot = new VNode(\n newRoot && newRoot.array.length ? [undefined, newRoot] : [],\n owner\n );\n newLevel += SHIFT;\n offsetShift += 1 << newLevel;\n }\n if (offsetShift) {\n newOrigin += offsetShift;\n oldOrigin += offsetShift;\n newCapacity += offsetShift;\n oldCapacity += offsetShift;\n }\n\n var oldTailOffset = getTailOffset(oldCapacity);\n var newTailOffset = getTailOffset(newCapacity);\n\n // New size might need creating a higher root.\n while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n newRoot = new VNode(\n newRoot && newRoot.array.length ? [newRoot] : [],\n owner\n );\n newLevel += SHIFT;\n }\n\n // Locate or create the new tail.\n var oldTail = list._tail;\n var newTail =\n newTailOffset < oldTailOffset\n ? listNodeFor(list, newCapacity - 1)\n : newTailOffset > oldTailOffset\n ? new VNode([], owner)\n : oldTail;\n\n // Merge Tail into tree.\n if (\n oldTail &&\n newTailOffset > oldTailOffset &&\n newOrigin < oldCapacity &&\n oldTail.array.length\n ) {\n newRoot = editableVNode(newRoot, owner);\n var node = newRoot;\n for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n var idx = (oldTailOffset >>> level) & MASK;\n node = node.array[idx] = editableVNode(node.array[idx], owner);\n }\n node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n }\n\n // If the size has been reduced, there's a chance the tail needs to be trimmed.\n if (newCapacity < oldCapacity) {\n newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n }\n\n // If the new origin is within the tail, then we do not need a root.\n if (newOrigin >= newTailOffset) {\n newOrigin -= newTailOffset;\n newCapacity -= newTailOffset;\n newLevel = SHIFT;\n newRoot = null;\n newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n // Otherwise, if the root has been trimmed, garbage collect.\n } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n offsetShift = 0;\n\n // Identify the new top root node of the subtree of the old root.\n while (newRoot) {\n var beginIndex = (newOrigin >>> newLevel) & MASK;\n if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {\n break;\n }\n if (beginIndex) {\n offsetShift += (1 << newLevel) * beginIndex;\n }\n newLevel -= SHIFT;\n newRoot = newRoot.array[beginIndex];\n }\n\n // Trim the new sides of the new root.\n if (newRoot && newOrigin > oldOrigin) {\n newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n }\n if (newRoot && newTailOffset < oldTailOffset) {\n newRoot = newRoot.removeAfter(\n owner,\n newLevel,\n newTailOffset - offsetShift\n );\n }\n if (offsetShift) {\n newOrigin -= offsetShift;\n newCapacity -= offsetShift;\n }\n }\n\n if (list.__ownerID) {\n list.size = newCapacity - newOrigin;\n list._origin = newOrigin;\n list._capacity = newCapacity;\n list._level = newLevel;\n list._root = newRoot;\n list._tail = newTail;\n list.__hash = undefined;\n list.__altered = true;\n return list;\n }\n return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n}\n\nfunction getTailOffset(size) {\n return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;\n}\n\nvar OrderedMap = /*@__PURE__*/(function (Map) {\n function OrderedMap(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptyOrderedMap()\n : isOrderedMap(value)\n ? value\n : emptyOrderedMap().withMutations(function (map) {\n var iter = KeyedCollection(value);\n assertNotInfinite(iter.size);\n iter.forEach(function (v, k) { return map.set(k, v); });\n });\n }\n\n if ( Map ) OrderedMap.__proto__ = Map;\n OrderedMap.prototype = Object.create( Map && Map.prototype );\n OrderedMap.prototype.constructor = OrderedMap;\n\n OrderedMap.of = function of (/*...values*/) {\n return this(arguments);\n };\n\n OrderedMap.prototype.toString = function toString () {\n return this.__toString('OrderedMap {', '}');\n };\n\n // @pragma Access\n\n OrderedMap.prototype.get = function get (k, notSetValue) {\n var index = this._map.get(k);\n return index !== undefined ? this._list.get(index)[1] : notSetValue;\n };\n\n // @pragma Modification\n\n OrderedMap.prototype.clear = function clear () {\n if (this.size === 0) {\n return this;\n }\n if (this.__ownerID) {\n this.size = 0;\n this._map.clear();\n this._list.clear();\n this.__altered = true;\n return this;\n }\n return emptyOrderedMap();\n };\n\n OrderedMap.prototype.set = function set (k, v) {\n return updateOrderedMap(this, k, v);\n };\n\n OrderedMap.prototype.remove = function remove (k) {\n return updateOrderedMap(this, k, NOT_SET);\n };\n\n OrderedMap.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n return this._list.__iterate(\n function (entry) { return entry && fn(entry[1], entry[0], this$1$1); },\n reverse\n );\n };\n\n OrderedMap.prototype.__iterator = function __iterator (type, reverse) {\n return this._list.fromEntrySeq().__iterator(type, reverse);\n };\n\n OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n var newMap = this._map.__ensureOwner(ownerID);\n var newList = this._list.__ensureOwner(ownerID);\n if (!ownerID) {\n if (this.size === 0) {\n return emptyOrderedMap();\n }\n this.__ownerID = ownerID;\n this.__altered = false;\n this._map = newMap;\n this._list = newList;\n return this;\n }\n return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n };\n\n return OrderedMap;\n}(Map));\n\nOrderedMap.isOrderedMap = isOrderedMap;\n\nOrderedMap.prototype[IS_ORDERED_SYMBOL] = true;\nOrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\nfunction makeOrderedMap(map, list, ownerID, hash) {\n var omap = Object.create(OrderedMap.prototype);\n omap.size = map ? map.size : 0;\n omap._map = map;\n omap._list = list;\n omap.__ownerID = ownerID;\n omap.__hash = hash;\n omap.__altered = false;\n return omap;\n}\n\nvar EMPTY_ORDERED_MAP;\nfunction emptyOrderedMap() {\n return (\n EMPTY_ORDERED_MAP ||\n (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))\n );\n}\n\nfunction updateOrderedMap(omap, k, v) {\n var map = omap._map;\n var list = omap._list;\n var i = map.get(k);\n var has = i !== undefined;\n var newMap;\n var newList;\n if (v === NOT_SET) {\n // removed\n if (!has) {\n return omap;\n }\n if (list.size >= SIZE && list.size >= map.size * 2) {\n newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; });\n newMap = newList\n .toKeyedSeq()\n .map(function (entry) { return entry[0]; })\n .flip()\n .toMap();\n if (omap.__ownerID) {\n newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n }\n } else {\n newMap = map.remove(k);\n newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n }\n } else if (has) {\n if (v === list.get(i)[1]) {\n return omap;\n }\n newMap = map;\n newList = list.set(i, [k, v]);\n } else {\n newMap = map.set(k, list.size);\n newList = list.set(list.size, [k, v]);\n }\n if (omap.__ownerID) {\n omap.size = newMap.size;\n omap._map = newMap;\n omap._list = newList;\n omap.__hash = undefined;\n omap.__altered = true;\n return omap;\n }\n return makeOrderedMap(newMap, newList);\n}\n\nvar IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@';\n\nfunction isStack(maybeStack) {\n return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);\n}\n\nvar Stack = /*@__PURE__*/(function (IndexedCollection) {\n function Stack(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptyStack()\n : isStack(value)\n ? value\n : emptyStack().pushAll(value);\n }\n\n if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;\n Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );\n Stack.prototype.constructor = Stack;\n\n Stack.of = function of (/*...values*/) {\n return this(arguments);\n };\n\n Stack.prototype.toString = function toString () {\n return this.__toString('Stack [', ']');\n };\n\n // @pragma Access\n\n Stack.prototype.get = function get (index, notSetValue) {\n var head = this._head;\n index = wrapIndex(this, index);\n while (head && index--) {\n head = head.next;\n }\n return head ? head.value : notSetValue;\n };\n\n Stack.prototype.peek = function peek () {\n return this._head && this._head.value;\n };\n\n // @pragma Modification\n\n Stack.prototype.push = function push (/*...values*/) {\n var arguments$1 = arguments;\n\n if (arguments.length === 0) {\n return this;\n }\n var newSize = this.size + arguments.length;\n var head = this._head;\n for (var ii = arguments.length - 1; ii >= 0; ii--) {\n head = {\n value: arguments$1[ii],\n next: head,\n };\n }\n if (this.__ownerID) {\n this.size = newSize;\n this._head = head;\n this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return makeStack(newSize, head);\n };\n\n Stack.prototype.pushAll = function pushAll (iter) {\n iter = IndexedCollection(iter);\n if (iter.size === 0) {\n return this;\n }\n if (this.size === 0 && isStack(iter)) {\n return iter;\n }\n assertNotInfinite(iter.size);\n var newSize = this.size;\n var head = this._head;\n iter.__iterate(function (value) {\n newSize++;\n head = {\n value: value,\n next: head,\n };\n }, /* reverse */ true);\n if (this.__ownerID) {\n this.size = newSize;\n this._head = head;\n this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return makeStack(newSize, head);\n };\n\n Stack.prototype.pop = function pop () {\n return this.slice(1);\n };\n\n Stack.prototype.clear = function clear () {\n if (this.size === 0) {\n return this;\n }\n if (this.__ownerID) {\n this.size = 0;\n this._head = undefined;\n this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return emptyStack();\n };\n\n Stack.prototype.slice = function slice (begin, end) {\n if (wholeSlice(begin, end, this.size)) {\n return this;\n }\n var resolvedBegin = resolveBegin(begin, this.size);\n var resolvedEnd = resolveEnd(end, this.size);\n if (resolvedEnd !== this.size) {\n // super.slice(begin, end);\n return IndexedCollection.prototype.slice.call(this, begin, end);\n }\n var newSize = this.size - resolvedBegin;\n var head = this._head;\n while (resolvedBegin--) {\n head = head.next;\n }\n if (this.__ownerID) {\n this.size = newSize;\n this._head = head;\n this.__hash = undefined;\n this.__altered = true;\n return this;\n }\n return makeStack(newSize, head);\n };\n\n // @pragma Mutability\n\n Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n if (!ownerID) {\n if (this.size === 0) {\n return emptyStack();\n }\n this.__ownerID = ownerID;\n this.__altered = false;\n return this;\n }\n return makeStack(this.size, this._head, ownerID, this.__hash);\n };\n\n // @pragma Iteration\n\n Stack.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n if (reverse) {\n return new ArraySeq(this.toArray()).__iterate(\n function (v, k) { return fn(v, k, this$1$1); },\n reverse\n );\n }\n var iterations = 0;\n var node = this._head;\n while (node) {\n if (fn(node.value, iterations++, this) === false) {\n break;\n }\n node = node.next;\n }\n return iterations;\n };\n\n Stack.prototype.__iterator = function __iterator (type, reverse) {\n if (reverse) {\n return new ArraySeq(this.toArray()).__iterator(type, reverse);\n }\n var iterations = 0;\n var node = this._head;\n return new Iterator(function () {\n if (node) {\n var value = node.value;\n node = node.next;\n return iteratorValue(type, iterations++, value);\n }\n return iteratorDone();\n });\n };\n\n return Stack;\n}(IndexedCollection));\n\nStack.isStack = isStack;\n\nvar StackPrototype = Stack.prototype;\nStackPrototype[IS_STACK_SYMBOL] = true;\nStackPrototype.shift = StackPrototype.pop;\nStackPrototype.unshift = StackPrototype.push;\nStackPrototype.unshiftAll = StackPrototype.pushAll;\nStackPrototype.withMutations = withMutations;\nStackPrototype.wasAltered = wasAltered;\nStackPrototype.asImmutable = asImmutable;\nStackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable;\nStackPrototype['@@transducer/step'] = function (result, arr) {\n return result.unshift(arr);\n};\nStackPrototype['@@transducer/result'] = function (obj) {\n return obj.asImmutable();\n};\n\nfunction makeStack(size, head, ownerID, hash) {\n var map = Object.create(StackPrototype);\n map.size = size;\n map._head = head;\n map.__ownerID = ownerID;\n map.__hash = hash;\n map.__altered = false;\n return map;\n}\n\nvar EMPTY_STACK;\nfunction emptyStack() {\n return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n}\n\nvar IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';\n\nfunction isSet(maybeSet) {\n return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);\n}\n\nfunction isOrderedSet(maybeOrderedSet) {\n return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n}\n\nfunction deepEqual(a, b) {\n if (a === b) {\n return true;\n }\n\n if (\n !isCollection(b) ||\n (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||\n (a.__hash !== undefined &&\n b.__hash !== undefined &&\n a.__hash !== b.__hash) ||\n isKeyed(a) !== isKeyed(b) ||\n isIndexed(a) !== isIndexed(b) ||\n isOrdered(a) !== isOrdered(b)\n ) {\n return false;\n }\n\n if (a.size === 0 && b.size === 0) {\n return true;\n }\n\n var notAssociative = !isAssociative(a);\n\n if (isOrdered(a)) {\n var entries = a.entries();\n return (\n b.every(function (v, k) {\n var entry = entries.next().value;\n return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n }) && entries.next().done\n );\n }\n\n var flipped = false;\n\n if (a.size === undefined) {\n if (b.size === undefined) {\n if (typeof a.cacheResult === 'function') {\n a.cacheResult();\n }\n } else {\n flipped = true;\n var _ = a;\n a = b;\n b = _;\n }\n }\n\n var allEqual = true;\n var bSize = b.__iterate(function (v, k) {\n if (\n notAssociative\n ? !a.has(v)\n : flipped\n ? !is(v, a.get(k, NOT_SET))\n : !is(a.get(k, NOT_SET), v)\n ) {\n allEqual = false;\n return false;\n }\n });\n\n return allEqual && a.size === bSize;\n}\n\nfunction mixin(ctor, methods) {\n var keyCopier = function (key) {\n ctor.prototype[key] = methods[key];\n };\n Object.keys(methods).forEach(keyCopier);\n Object.getOwnPropertySymbols &&\n Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n return ctor;\n}\n\nfunction toJS(value) {\n if (!value || typeof value !== 'object') {\n return value;\n }\n if (!isCollection(value)) {\n if (!isDataStructure(value)) {\n return value;\n }\n value = Seq(value);\n }\n if (isKeyed(value)) {\n var result$1 = {};\n value.__iterate(function (v, k) {\n result$1[k] = toJS(v);\n });\n return result$1;\n }\n var result = [];\n value.__iterate(function (v) {\n result.push(toJS(v));\n });\n return result;\n}\n\nvar Set = /*@__PURE__*/(function (SetCollection) {\n function Set(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptySet()\n : isSet(value) && !isOrdered(value)\n ? value\n : emptySet().withMutations(function (set) {\n var iter = SetCollection(value);\n assertNotInfinite(iter.size);\n iter.forEach(function (v) { return set.add(v); });\n });\n }\n\n if ( SetCollection ) Set.__proto__ = SetCollection;\n Set.prototype = Object.create( SetCollection && SetCollection.prototype );\n Set.prototype.constructor = Set;\n\n Set.of = function of (/*...values*/) {\n return this(arguments);\n };\n\n Set.fromKeys = function fromKeys (value) {\n return this(KeyedCollection(value).keySeq());\n };\n\n Set.intersect = function intersect (sets) {\n sets = Collection(sets).toArray();\n return sets.length\n ? SetPrototype.intersect.apply(Set(sets.pop()), sets)\n : emptySet();\n };\n\n Set.union = function union (sets) {\n sets = Collection(sets).toArray();\n return sets.length\n ? SetPrototype.union.apply(Set(sets.pop()), sets)\n : emptySet();\n };\n\n Set.prototype.toString = function toString () {\n return this.__toString('Set {', '}');\n };\n\n // @pragma Access\n\n Set.prototype.has = function has (value) {\n return this._map.has(value);\n };\n\n // @pragma Modification\n\n Set.prototype.add = function add (value) {\n return updateSet(this, this._map.set(value, value));\n };\n\n Set.prototype.remove = function remove (value) {\n return updateSet(this, this._map.remove(value));\n };\n\n Set.prototype.clear = function clear () {\n return updateSet(this, this._map.clear());\n };\n\n // @pragma Composition\n\n Set.prototype.map = function map (mapper, context) {\n var this$1$1 = this;\n\n // keep track if the set is altered by the map function\n var didChanges = false;\n\n var newMap = updateSet(\n this,\n this._map.mapEntries(function (ref) {\n var v = ref[1];\n\n var mapped = mapper.call(context, v, v, this$1$1);\n\n if (mapped !== v) {\n didChanges = true;\n }\n\n return [mapped, mapped];\n }, context)\n );\n\n return didChanges ? newMap : this;\n };\n\n Set.prototype.union = function union () {\n var iters = [], len = arguments.length;\n while ( len-- ) iters[ len ] = arguments[ len ];\n\n iters = iters.filter(function (x) { return x.size !== 0; });\n if (iters.length === 0) {\n return this;\n }\n if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n return this.constructor(iters[0]);\n }\n return this.withMutations(function (set) {\n for (var ii = 0; ii < iters.length; ii++) {\n if (typeof iters[ii] === 'string') {\n set.add(iters[ii]);\n } else {\n SetCollection(iters[ii]).forEach(function (value) { return set.add(value); });\n }\n }\n });\n };\n\n Set.prototype.intersect = function intersect () {\n var iters = [], len = arguments.length;\n while ( len-- ) iters[ len ] = arguments[ len ];\n\n if (iters.length === 0) {\n return this;\n }\n iters = iters.map(function (iter) { return SetCollection(iter); });\n var toRemove = [];\n this.forEach(function (value) {\n if (!iters.every(function (iter) { return iter.includes(value); })) {\n toRemove.push(value);\n }\n });\n return this.withMutations(function (set) {\n toRemove.forEach(function (value) {\n set.remove(value);\n });\n });\n };\n\n Set.prototype.subtract = function subtract () {\n var iters = [], len = arguments.length;\n while ( len-- ) iters[ len ] = arguments[ len ];\n\n if (iters.length === 0) {\n return this;\n }\n iters = iters.map(function (iter) { return SetCollection(iter); });\n var toRemove = [];\n this.forEach(function (value) {\n if (iters.some(function (iter) { return iter.includes(value); })) {\n toRemove.push(value);\n }\n });\n return this.withMutations(function (set) {\n toRemove.forEach(function (value) {\n set.remove(value);\n });\n });\n };\n\n Set.prototype.sort = function sort (comparator) {\n // Late binding\n return OrderedSet(sortFactory(this, comparator));\n };\n\n Set.prototype.sortBy = function sortBy (mapper, comparator) {\n // Late binding\n return OrderedSet(sortFactory(this, comparator, mapper));\n };\n\n Set.prototype.wasAltered = function wasAltered () {\n return this._map.wasAltered();\n };\n\n Set.prototype.__iterate = function __iterate (fn, reverse) {\n var this$1$1 = this;\n\n return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse);\n };\n\n Set.prototype.__iterator = function __iterator (type, reverse) {\n return this._map.__iterator(type, reverse);\n };\n\n Set.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n var newMap = this._map.__ensureOwner(ownerID);\n if (!ownerID) {\n if (this.size === 0) {\n return this.__empty();\n }\n this.__ownerID = ownerID;\n this._map = newMap;\n return this;\n }\n return this.__make(newMap, ownerID);\n };\n\n return Set;\n}(SetCollection));\n\nSet.isSet = isSet;\n\nvar SetPrototype = Set.prototype;\nSetPrototype[IS_SET_SYMBOL] = true;\nSetPrototype[DELETE] = SetPrototype.remove;\nSetPrototype.merge = SetPrototype.concat = SetPrototype.union;\nSetPrototype.withMutations = withMutations;\nSetPrototype.asImmutable = asImmutable;\nSetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable;\nSetPrototype['@@transducer/step'] = function (result, arr) {\n return result.add(arr);\n};\nSetPrototype['@@transducer/result'] = function (obj) {\n return obj.asImmutable();\n};\n\nSetPrototype.__empty = emptySet;\nSetPrototype.__make = makeSet;\n\nfunction updateSet(set, newMap) {\n if (set.__ownerID) {\n set.size = newMap.size;\n set._map = newMap;\n return set;\n }\n return newMap === set._map\n ? set\n : newMap.size === 0\n ? set.__empty()\n : set.__make(newMap);\n}\n\nfunction makeSet(map, ownerID) {\n var set = Object.create(SetPrototype);\n set.size = map ? map.size : 0;\n set._map = map;\n set.__ownerID = ownerID;\n return set;\n}\n\nvar EMPTY_SET;\nfunction emptySet() {\n return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n}\n\n/**\n * Returns a lazy seq of nums from start (inclusive) to end\n * (exclusive), by step, where start defaults to 0, step to 1, and end to\n * infinity. When start is equal to end, returns empty list.\n */\nvar Range = /*@__PURE__*/(function (IndexedSeq) {\n function Range(start, end, step) {\n if (!(this instanceof Range)) {\n // eslint-disable-next-line no-constructor-return\n return new Range(start, end, step);\n }\n invariant(step !== 0, 'Cannot step a Range by 0');\n start = start || 0;\n if (end === undefined) {\n end = Infinity;\n }\n step = step === undefined ? 1 : Math.abs(step);\n if (end < start) {\n step = -step;\n }\n this._start = start;\n this._end = end;\n this._step = step;\n this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n if (this.size === 0) {\n if (EMPTY_RANGE) {\n // eslint-disable-next-line no-constructor-return\n return EMPTY_RANGE;\n }\n EMPTY_RANGE = this;\n }\n }\n\n if ( IndexedSeq ) Range.__proto__ = IndexedSeq;\n Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n Range.prototype.constructor = Range;\n\n Range.prototype.toString = function toString () {\n if (this.size === 0) {\n return 'Range []';\n }\n return (\n 'Range [ ' +\n this._start +\n '...' +\n this._end +\n (this._step !== 1 ? ' by ' + this._step : '') +\n ' ]'\n );\n };\n\n Range.prototype.get = function get (index, notSetValue) {\n return this.has(index)\n ? this._start + wrapIndex(this, index) * this._step\n : notSetValue;\n };\n\n Range.prototype.includes = function includes (searchValue) {\n var possibleIndex = (searchValue - this._start) / this._step;\n return (\n possibleIndex >= 0 &&\n possibleIndex < this.size &&\n possibleIndex === Math.floor(possibleIndex)\n );\n };\n\n Range.prototype.slice = function slice (begin, end) {\n if (wholeSlice(begin, end, this.size)) {\n return this;\n }\n begin = resolveBegin(begin, this.size);\n end = resolveEnd(end, this.size);\n if (end <= begin) {\n return new Range(0, 0);\n }\n return new Range(\n this.get(begin, this._end),\n this.get(end, this._end),\n this._step\n );\n };\n\n Range.prototype.indexOf = function indexOf (searchValue) {\n var offsetValue = searchValue - this._start;\n if (offsetValue % this._step === 0) {\n var index = offsetValue / this._step;\n if (index >= 0 && index < this.size) {\n return index;\n }\n }\n return -1;\n };\n\n Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {\n return this.indexOf(searchValue);\n };\n\n Range.prototype.__iterate = function __iterate (fn, reverse) {\n var size = this.size;\n var step = this._step;\n var value = reverse ? this._start + (size - 1) * step : this._start;\n var i = 0;\n while (i !== size) {\n if (fn(value, reverse ? size - ++i : i++, this) === false) {\n break;\n }\n value += reverse ? -step : step;\n }\n return i;\n };\n\n Range.prototype.__iterator = function __iterator (type, reverse) {\n var size = this.size;\n var step = this._step;\n var value = reverse ? this._start + (size - 1) * step : this._start;\n var i = 0;\n return new Iterator(function () {\n if (i === size) {\n return iteratorDone();\n }\n var v = value;\n value += reverse ? -step : step;\n return iteratorValue(type, reverse ? size - ++i : i++, v);\n });\n };\n\n Range.prototype.equals = function equals (other) {\n return other instanceof Range\n ? this._start === other._start &&\n this._end === other._end &&\n this._step === other._step\n : deepEqual(this, other);\n };\n\n return Range;\n}(IndexedSeq));\n\nvar EMPTY_RANGE;\n\nfunction getIn$1(collection, searchKeyPath, notSetValue) {\n var keyPath = coerceKeyPath(searchKeyPath);\n var i = 0;\n while (i !== keyPath.length) {\n collection = get(collection, keyPath[i++], NOT_SET);\n if (collection === NOT_SET) {\n return notSetValue;\n }\n }\n return collection;\n}\n\nfunction getIn(searchKeyPath, notSetValue) {\n return getIn$1(this, searchKeyPath, notSetValue);\n}\n\nfunction hasIn$1(collection, keyPath) {\n return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;\n}\n\nfunction hasIn(searchKeyPath) {\n return hasIn$1(this, searchKeyPath);\n}\n\nfunction toObject() {\n assertNotInfinite(this.size);\n var object = {};\n this.__iterate(function (v, k) {\n object[k] = v;\n });\n return object;\n}\n\n// Note: all of these methods are deprecated.\nCollection.isIterable = isCollection;\nCollection.isKeyed = isKeyed;\nCollection.isIndexed = isIndexed;\nCollection.isAssociative = isAssociative;\nCollection.isOrdered = isOrdered;\n\nCollection.Iterator = Iterator;\n\nmixin(Collection, {\n // ### Conversion to other types\n\n toArray: function toArray() {\n assertNotInfinite(this.size);\n var array = new Array(this.size || 0);\n var useTuples = isKeyed(this);\n var i = 0;\n this.__iterate(function (v, k) {\n // Keyed collections produce an array of tuples.\n array[i++] = useTuples ? [k, v] : v;\n });\n return array;\n },\n\n toIndexedSeq: function toIndexedSeq() {\n return new ToIndexedSequence(this);\n },\n\n toJS: function toJS$1() {\n return toJS(this);\n },\n\n toKeyedSeq: function toKeyedSeq() {\n return new ToKeyedSequence(this, true);\n },\n\n toMap: function toMap() {\n // Use Late Binding here to solve the circular dependency.\n return Map(this.toKeyedSeq());\n },\n\n toObject: toObject,\n\n toOrderedMap: function toOrderedMap() {\n // Use Late Binding here to solve the circular dependency.\n return OrderedMap(this.toKeyedSeq());\n },\n\n toOrderedSet: function toOrderedSet() {\n // Use Late Binding here to solve the circular dependency.\n return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n },\n\n toSet: function toSet() {\n // Use Late Binding here to solve the circular dependency.\n return Set(isKeyed(this) ? this.valueSeq() : this);\n },\n\n toSetSeq: function toSetSeq() {\n return new ToSetSequence(this);\n },\n\n toSeq: function toSeq() {\n return isIndexed(this)\n ? this.toIndexedSeq()\n : isKeyed(this)\n ? this.toKeyedSeq()\n : this.toSetSeq();\n },\n\n toStack: function toStack() {\n // Use Late Binding here to solve the circular dependency.\n return Stack(isKeyed(this) ? this.valueSeq() : this);\n },\n\n toList: function toList() {\n // Use Late Binding here to solve the circular dependency.\n return List(isKeyed(this) ? this.valueSeq() : this);\n },\n\n // ### Common JavaScript methods and properties\n\n toString: function toString() {\n return '[Collection]';\n },\n\n __toString: function __toString(head, tail) {\n if (this.size === 0) {\n return head + tail;\n }\n return (\n head +\n ' ' +\n this.toSeq().map(this.__toStringMapper).join(', ') +\n ' ' +\n tail\n );\n },\n\n // ### ES6 Collection methods (ES6 Array and Map)\n\n concat: function concat() {\n var values = [], len = arguments.length;\n while ( len-- ) values[ len ] = arguments[ len ];\n\n return reify(this, concatFactory(this, values));\n },\n\n includes: function includes(searchValue) {\n return this.some(function (value) { return is(value, searchValue); });\n },\n\n entries: function entries() {\n return this.__iterator(ITERATE_ENTRIES);\n },\n\n every: function every(predicate, context) {\n assertNotInfinite(this.size);\n var returnValue = true;\n this.__iterate(function (v, k, c) {\n if (!predicate.call(context, v, k, c)) {\n returnValue = false;\n return false;\n }\n });\n return returnValue;\n },\n\n filter: function filter(predicate, context) {\n return reify(this, filterFactory(this, predicate, context, true));\n },\n\n partition: function partition(predicate, context) {\n return partitionFactory(this, predicate, context);\n },\n\n find: function find(predicate, context, notSetValue) {\n var entry = this.findEntry(predicate, context);\n return entry ? entry[1] : notSetValue;\n },\n\n forEach: function forEach(sideEffect, context) {\n assertNotInfinite(this.size);\n return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n },\n\n join: function join(separator) {\n assertNotInfinite(this.size);\n separator = separator !== undefined ? '' + separator : ',';\n var joined = '';\n var isFirst = true;\n this.__iterate(function (v) {\n isFirst ? (isFirst = false) : (joined += separator);\n joined += v !== null && v !== undefined ? v.toString() : '';\n });\n return joined;\n },\n\n keys: function keys() {\n return this.__iterator(ITERATE_KEYS);\n },\n\n map: function map(mapper, context) {\n return reify(this, mapFactory(this, mapper, context));\n },\n\n reduce: function reduce$1(reducer, initialReduction, context) {\n return reduce(\n this,\n reducer,\n initialReduction,\n context,\n arguments.length < 2,\n false\n );\n },\n\n reduceRight: function reduceRight(reducer, initialReduction, context) {\n return reduce(\n this,\n reducer,\n initialReduction,\n context,\n arguments.length < 2,\n true\n );\n },\n\n reverse: function reverse() {\n return reify(this, reverseFactory(this, true));\n },\n\n slice: function slice(begin, end) {\n return reify(this, sliceFactory(this, begin, end, true));\n },\n\n some: function some(predicate, context) {\n assertNotInfinite(this.size);\n var returnValue = false;\n this.__iterate(function (v, k, c) {\n if (predicate.call(context, v, k, c)) {\n returnValue = true;\n return false;\n }\n });\n return returnValue;\n },\n\n sort: function sort(comparator) {\n return reify(this, sortFactory(this, comparator));\n },\n\n values: function values() {\n return this.__iterator(ITERATE_VALUES);\n },\n\n // ### More sequential methods\n\n butLast: function butLast() {\n return this.slice(0, -1);\n },\n\n isEmpty: function isEmpty() {\n return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; });\n },\n\n count: function count(predicate, context) {\n return ensureSize(\n predicate ? this.toSeq().filter(predicate, context) : this\n );\n },\n\n countBy: function countBy(grouper, context) {\n return countByFactory(this, grouper, context);\n },\n\n equals: function equals(other) {\n return deepEqual(this, other);\n },\n\n entrySeq: function entrySeq() {\n var collection = this;\n if (collection._cache) {\n // We cache as an entries array, so we can just return the cache!\n return new ArraySeq(collection._cache);\n }\n var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq();\n entriesSequence.fromEntrySeq = function () { return collection.toSeq(); };\n return entriesSequence;\n },\n\n filterNot: function filterNot(predicate, context) {\n return this.filter(not(predicate), context);\n },\n\n findEntry: function findEntry(predicate, context, notSetValue) {\n var found = notSetValue;\n this.__iterate(function (v, k, c) {\n if (predicate.call(context, v, k, c)) {\n found = [k, v];\n return false;\n }\n });\n return found;\n },\n\n findKey: function findKey(predicate, context) {\n var entry = this.findEntry(predicate, context);\n return entry && entry[0];\n },\n\n findLast: function findLast(predicate, context, notSetValue) {\n return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n },\n\n findLastEntry: function findLastEntry(predicate, context, notSetValue) {\n return this.toKeyedSeq()\n .reverse()\n .findEntry(predicate, context, notSetValue);\n },\n\n findLastKey: function findLastKey(predicate, context) {\n return this.toKeyedSeq().reverse().findKey(predicate, context);\n },\n\n first: function first(notSetValue) {\n return this.find(returnTrue, null, notSetValue);\n },\n\n flatMap: function flatMap(mapper, context) {\n return reify(this, flatMapFactory(this, mapper, context));\n },\n\n flatten: function flatten(depth) {\n return reify(this, flattenFactory(this, depth, true));\n },\n\n fromEntrySeq: function fromEntrySeq() {\n return new FromEntriesSequence(this);\n },\n\n get: function get(searchKey, notSetValue) {\n return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue);\n },\n\n getIn: getIn,\n\n groupBy: function groupBy(grouper, context) {\n return groupByFactory(this, grouper, context);\n },\n\n has: function has(searchKey) {\n return this.get(searchKey, NOT_SET) !== NOT_SET;\n },\n\n hasIn: hasIn,\n\n isSubset: function isSubset(iter) {\n iter = typeof iter.includes === 'function' ? iter : Collection(iter);\n return this.every(function (value) { return iter.includes(value); });\n },\n\n isSuperset: function isSuperset(iter) {\n iter = typeof iter.isSubset === 'function' ? iter : Collection(iter);\n return iter.isSubset(this);\n },\n\n keyOf: function keyOf(searchValue) {\n return this.findKey(function (value) { return is(value, searchValue); });\n },\n\n keySeq: function keySeq() {\n return this.toSeq().map(keyMapper).toIndexedSeq();\n },\n\n last: function last(notSetValue) {\n return this.toSeq().reverse().first(notSetValue);\n },\n\n lastKeyOf: function lastKeyOf(searchValue) {\n return this.toKeyedSeq().reverse().keyOf(searchValue);\n },\n\n max: function max(comparator) {\n return maxFactory(this, comparator);\n },\n\n maxBy: function maxBy(mapper, comparator) {\n return maxFactory(this, comparator, mapper);\n },\n\n min: function min(comparator) {\n return maxFactory(\n this,\n comparator ? neg(comparator) : defaultNegComparator\n );\n },\n\n minBy: function minBy(mapper, comparator) {\n return maxFactory(\n this,\n comparator ? neg(comparator) : defaultNegComparator,\n mapper\n );\n },\n\n rest: function rest() {\n return this.slice(1);\n },\n\n skip: function skip(amount) {\n return amount === 0 ? this : this.slice(Math.max(0, amount));\n },\n\n skipLast: function skipLast(amount) {\n return amount === 0 ? this : this.slice(0, -Math.max(0, amount));\n },\n\n skipWhile: function skipWhile(predicate, context) {\n return reify(this, skipWhileFactory(this, predicate, context, true));\n },\n\n skipUntil: function skipUntil(predicate, context) {\n return this.skipWhile(not(predicate), context);\n },\n\n sortBy: function sortBy(mapper, comparator) {\n return reify(this, sortFactory(this, comparator, mapper));\n },\n\n take: function take(amount) {\n return this.slice(0, Math.max(0, amount));\n },\n\n takeLast: function takeLast(amount) {\n return this.slice(-Math.max(0, amount));\n },\n\n takeWhile: function takeWhile(predicate, context) {\n return reify(this, takeWhileFactory(this, predicate, context));\n },\n\n takeUntil: function takeUntil(predicate, context) {\n return this.takeWhile(not(predicate), context);\n },\n\n update: function update(fn) {\n return fn(this);\n },\n\n valueSeq: function valueSeq() {\n return this.toIndexedSeq();\n },\n\n // ### Hashable Object\n\n hashCode: function hashCode() {\n return this.__hash || (this.__hash = hashCollection(this));\n },\n\n // ### Internal\n\n // abstract __iterate(fn, reverse)\n\n // abstract __iterator(type, reverse)\n});\n\nvar CollectionPrototype = Collection.prototype;\nCollectionPrototype[IS_COLLECTION_SYMBOL] = true;\nCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;\nCollectionPrototype.toJSON = CollectionPrototype.toArray;\nCollectionPrototype.__toStringMapper = quoteString;\nCollectionPrototype.inspect = CollectionPrototype.toSource = function () {\n return this.toString();\n};\nCollectionPrototype.chain = CollectionPrototype.flatMap;\nCollectionPrototype.contains = CollectionPrototype.includes;\n\nmixin(KeyedCollection, {\n // ### More sequential methods\n\n flip: function flip() {\n return reify(this, flipFactory(this));\n },\n\n mapEntries: function mapEntries(mapper, context) {\n var this$1$1 = this;\n\n var iterations = 0;\n return reify(\n this,\n this.toSeq()\n .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); })\n .fromEntrySeq()\n );\n },\n\n mapKeys: function mapKeys(mapper, context) {\n var this$1$1 = this;\n\n return reify(\n this,\n this.toSeq()\n .flip()\n .map(function (k, v) { return mapper.call(context, k, v, this$1$1); })\n .flip()\n );\n },\n});\n\nvar KeyedCollectionPrototype = KeyedCollection.prototype;\nKeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;\nKeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;\nKeyedCollectionPrototype.toJSON = toObject;\nKeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); };\n\nmixin(IndexedCollection, {\n // ### Conversion to other types\n\n toKeyedSeq: function toKeyedSeq() {\n return new ToKeyedSequence(this, false);\n },\n\n // ### ES6 Collection methods (ES6 Array and Map)\n\n filter: function filter(predicate, context) {\n return reify(this, filterFactory(this, predicate, context, false));\n },\n\n findIndex: function findIndex(predicate, context) {\n var entry = this.findEntry(predicate, context);\n return entry ? entry[0] : -1;\n },\n\n indexOf: function indexOf(searchValue) {\n var key = this.keyOf(searchValue);\n return key === undefined ? -1 : key;\n },\n\n lastIndexOf: function lastIndexOf(searchValue) {\n var key = this.lastKeyOf(searchValue);\n return key === undefined ? -1 : key;\n },\n\n reverse: function reverse() {\n return reify(this, reverseFactory(this, false));\n },\n\n slice: function slice(begin, end) {\n return reify(this, sliceFactory(this, begin, end, false));\n },\n\n splice: function splice(index, removeNum /*, ...values*/) {\n var numArgs = arguments.length;\n removeNum = Math.max(removeNum || 0, 0);\n if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n return this;\n }\n // If index is negative, it should resolve relative to the size of the\n // collection. However size may be expensive to compute if not cached, so\n // only call count() if the number is in fact negative.\n index = resolveBegin(index, index < 0 ? this.count() : this.size);\n var spliced = this.slice(0, index);\n return reify(\n this,\n numArgs === 1\n ? spliced\n : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n );\n },\n\n // ### More collection methods\n\n findLastIndex: function findLastIndex(predicate, context) {\n var entry = this.findLastEntry(predicate, context);\n return entry ? entry[0] : -1;\n },\n\n first: function first(notSetValue) {\n return this.get(0, notSetValue);\n },\n\n flatten: function flatten(depth) {\n return reify(this, flattenFactory(this, depth, false));\n },\n\n get: function get(index, notSetValue) {\n index = wrapIndex(this, index);\n return index < 0 ||\n this.size === Infinity ||\n (this.size !== undefined && index > this.size)\n ? notSetValue\n : this.find(function (_, key) { return key === index; }, undefined, notSetValue);\n },\n\n has: function has(index) {\n index = wrapIndex(this, index);\n return (\n index >= 0 &&\n (this.size !== undefined\n ? this.size === Infinity || index < this.size\n : this.indexOf(index) !== -1)\n );\n },\n\n interpose: function interpose(separator) {\n return reify(this, interposeFactory(this, separator));\n },\n\n interleave: function interleave(/*...collections*/) {\n var collections = [this].concat(arrCopy(arguments));\n var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);\n var interleaved = zipped.flatten(true);\n if (zipped.size) {\n interleaved.size = zipped.size * collections.length;\n }\n return reify(this, interleaved);\n },\n\n keySeq: function keySeq() {\n return Range(0, this.size);\n },\n\n last: function last(notSetValue) {\n return this.get(-1, notSetValue);\n },\n\n skipWhile: function skipWhile(predicate, context) {\n return reify(this, skipWhileFactory(this, predicate, context, false));\n },\n\n zip: function zip(/*, ...collections */) {\n var collections = [this].concat(arrCopy(arguments));\n return reify(this, zipWithFactory(this, defaultZipper, collections));\n },\n\n zipAll: function zipAll(/*, ...collections */) {\n var collections = [this].concat(arrCopy(arguments));\n return reify(this, zipWithFactory(this, defaultZipper, collections, true));\n },\n\n zipWith: function zipWith(zipper /*, ...collections */) {\n var collections = arrCopy(arguments);\n collections[0] = this;\n return reify(this, zipWithFactory(this, zipper, collections));\n },\n});\n\nvar IndexedCollectionPrototype = IndexedCollection.prototype;\nIndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;\nIndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;\n\nmixin(SetCollection, {\n // ### ES6 Collection methods (ES6 Array and Map)\n\n get: function get(value, notSetValue) {\n return this.has(value) ? value : notSetValue;\n },\n\n includes: function includes(value) {\n return this.has(value);\n },\n\n // ### More sequential methods\n\n keySeq: function keySeq() {\n return this.valueSeq();\n },\n});\n\nvar SetCollectionPrototype = SetCollection.prototype;\nSetCollectionPrototype.has = CollectionPrototype.includes;\nSetCollectionPrototype.contains = SetCollectionPrototype.includes;\nSetCollectionPrototype.keys = SetCollectionPrototype.values;\n\n// Mixin subclasses\n\nmixin(KeyedSeq, KeyedCollectionPrototype);\nmixin(IndexedSeq, IndexedCollectionPrototype);\nmixin(SetSeq, SetCollectionPrototype);\n\n// #pragma Helper functions\n\nfunction reduce(collection, reducer, reduction, context, useFirst, reverse) {\n assertNotInfinite(collection.size);\n collection.__iterate(function (v, k, c) {\n if (useFirst) {\n useFirst = false;\n reduction = v;\n } else {\n reduction = reducer.call(context, reduction, v, k, c);\n }\n }, reverse);\n return reduction;\n}\n\nfunction keyMapper(v, k) {\n return k;\n}\n\nfunction entryMapper(v, k) {\n return [k, v];\n}\n\nfunction not(predicate) {\n return function () {\n return !predicate.apply(this, arguments);\n };\n}\n\nfunction neg(predicate) {\n return function () {\n return -predicate.apply(this, arguments);\n };\n}\n\nfunction defaultZipper() {\n return arrCopy(arguments);\n}\n\nfunction defaultNegComparator(a, b) {\n return a < b ? 1 : a > b ? -1 : 0;\n}\n\nfunction hashCollection(collection) {\n if (collection.size === Infinity) {\n return 0;\n }\n var ordered = isOrdered(collection);\n var keyed = isKeyed(collection);\n var h = ordered ? 1 : 0;\n var size = collection.__iterate(\n keyed\n ? ordered\n ? function (v, k) {\n h = (31 * h + hashMerge(hash(v), hash(k))) | 0;\n }\n : function (v, k) {\n h = (h + hashMerge(hash(v), hash(k))) | 0;\n }\n : ordered\n ? function (v) {\n h = (31 * h + hash(v)) | 0;\n }\n : function (v) {\n h = (h + hash(v)) | 0;\n }\n );\n return murmurHashOfSize(size, h);\n}\n\nfunction murmurHashOfSize(size, h) {\n h = imul(h, 0xcc9e2d51);\n h = imul((h << 15) | (h >>> -15), 0x1b873593);\n h = imul((h << 13) | (h >>> -13), 5);\n h = ((h + 0xe6546b64) | 0) ^ size;\n h = imul(h ^ (h >>> 16), 0x85ebca6b);\n h = imul(h ^ (h >>> 13), 0xc2b2ae35);\n h = smi(h ^ (h >>> 16));\n return h;\n}\n\nfunction hashMerge(a, b) {\n return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int\n}\n\nvar OrderedSet = /*@__PURE__*/(function (Set) {\n function OrderedSet(value) {\n // eslint-disable-next-line no-constructor-return\n return value === undefined || value === null\n ? emptyOrderedSet()\n : isOrderedSet(value)\n ? value\n : emptyOrderedSet().withMutations(function (set) {\n var iter = SetCollection(value);\n assertNotInfinite(iter.size);\n iter.forEach(function (v) { return set.add(v); });\n });\n }\n\n if ( Set ) OrderedSet.__proto__ = Set;\n OrderedSet.prototype = Object.create( Set && Set.prototype );\n OrderedSet.prototype.constructor = OrderedSet;\n\n OrderedSet.of = function of (/*...values*/) {\n return this(arguments);\n };\n\n OrderedSet.fromKeys = function fromKeys (value) {\n return this(KeyedCollection(value).keySeq());\n };\n\n OrderedSet.prototype.toString = function toString () {\n return this.__toString('OrderedSet {', '}');\n };\n\n return OrderedSet;\n}(Set));\n\nOrderedSet.isOrderedSet = isOrderedSet;\n\nvar OrderedSetPrototype = OrderedSet.prototype;\nOrderedSetPrototype[IS_ORDERED_SYMBOL] = true;\nOrderedSetPrototype.zip = IndexedCollectionPrototype.zip;\nOrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;\nOrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;\n\nOrderedSetPrototype.__empty = emptyOrderedSet;\nOrderedSetPrototype.__make = makeOrderedSet;\n\nfunction makeOrderedSet(map, ownerID) {\n var set = Object.create(OrderedSetPrototype);\n set.size = map ? map.size : 0;\n set._map = map;\n set.__ownerID = ownerID;\n return set;\n}\n\nvar EMPTY_ORDERED_SET;\nfunction emptyOrderedSet() {\n return (\n EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))\n );\n}\n\nvar PairSorting = {\n LeftThenRight: -1,\n RightThenLeft: +1,\n};\n\nfunction throwOnInvalidDefaultValues(defaultValues) {\n if (isRecord(defaultValues)) {\n throw new Error(\n 'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.'\n );\n }\n\n if (isImmutable(defaultValues)) {\n throw new Error(\n 'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.'\n );\n }\n\n if (defaultValues === null || typeof defaultValues !== 'object') {\n throw new Error(\n 'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.'\n );\n }\n}\n\nvar Record = function Record(defaultValues, name) {\n var hasInitialized;\n\n throwOnInvalidDefaultValues(defaultValues);\n\n var RecordType = function Record(values) {\n var this$1$1 = this;\n\n if (values instanceof RecordType) {\n return values;\n }\n if (!(this instanceof RecordType)) {\n return new RecordType(values);\n }\n if (!hasInitialized) {\n hasInitialized = true;\n var keys = Object.keys(defaultValues);\n var indices = (RecordTypePrototype._indices = {});\n // Deprecated: left to attempt not to break any external code which\n // relies on a ._name property existing on record instances.\n // Use Record.getDescriptiveName() instead\n RecordTypePrototype._name = name;\n RecordTypePrototype._keys = keys;\n RecordTypePrototype._defaultValues = defaultValues;\n for (var i = 0; i < keys.length; i++) {\n var propName = keys[i];\n indices[propName] = i;\n if (RecordTypePrototype[propName]) {\n /* eslint-disable no-console */\n typeof console === 'object' &&\n console.warn &&\n console.warn(\n 'Cannot define ' +\n recordName(this) +\n ' with property \"' +\n propName +\n '\" since that property name is part of the Record API.'\n );\n /* eslint-enable no-console */\n } else {\n setProp(RecordTypePrototype, propName);\n }\n }\n }\n this.__ownerID = undefined;\n this._values = List().withMutations(function (l) {\n l.setSize(this$1$1._keys.length);\n KeyedCollection(values).forEach(function (v, k) {\n l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v);\n });\n });\n return this;\n };\n\n var RecordTypePrototype = (RecordType.prototype =\n Object.create(RecordPrototype));\n RecordTypePrototype.constructor = RecordType;\n\n if (name) {\n RecordType.displayName = name;\n }\n\n // eslint-disable-next-line no-constructor-return\n return RecordType;\n};\n\nRecord.prototype.toString = function toString () {\n var str = recordName(this) + ' { ';\n var keys = this._keys;\n var k;\n for (var i = 0, l = keys.length; i !== l; i++) {\n k = keys[i];\n str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k));\n }\n return str + ' }';\n};\n\nRecord.prototype.equals = function equals (other) {\n return (\n this === other ||\n (isRecord(other) && recordSeq(this).equals(recordSeq(other)))\n );\n};\n\nRecord.prototype.hashCode = function hashCode () {\n return recordSeq(this).hashCode();\n};\n\n// @pragma Access\n\nRecord.prototype.has = function has (k) {\n return this._indices.hasOwnProperty(k);\n};\n\nRecord.prototype.get = function get (k, notSetValue) {\n if (!this.has(k)) {\n return notSetValue;\n }\n var index = this._indices[k];\n var value = this._values.get(index);\n return value === undefined ? this._defaultValues[k] : value;\n};\n\n// @pragma Modification\n\nRecord.prototype.set = function set (k, v) {\n if (this.has(k)) {\n var newValues = this._values.set(\n this._indices[k],\n v === this._defaultValues[k] ? undefined : v\n );\n if (newValues !== this._values && !this.__ownerID) {\n return makeRecord(this, newValues);\n }\n }\n return this;\n};\n\nRecord.prototype.remove = function remove (k) {\n return this.set(k);\n};\n\nRecord.prototype.clear = function clear () {\n var newValues = this._values.clear().setSize(this._keys.length);\n\n return this.__ownerID ? this : makeRecord(this, newValues);\n};\n\nRecord.prototype.wasAltered = function wasAltered () {\n return this._values.wasAltered();\n};\n\nRecord.prototype.toSeq = function toSeq () {\n return recordSeq(this);\n};\n\nRecord.prototype.toJS = function toJS$1 () {\n return toJS(this);\n};\n\nRecord.prototype.entries = function entries () {\n return this.__iterator(ITERATE_ENTRIES);\n};\n\nRecord.prototype.__iterator = function __iterator (type, reverse) {\n return recordSeq(this).__iterator(type, reverse);\n};\n\nRecord.prototype.__iterate = function __iterate (fn, reverse) {\n return recordSeq(this).__iterate(fn, reverse);\n};\n\nRecord.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n if (ownerID === this.__ownerID) {\n return this;\n }\n var newValues = this._values.__ensureOwner(ownerID);\n if (!ownerID) {\n this.__ownerID = ownerID;\n this._values = newValues;\n return this;\n }\n return makeRecord(this, newValues, ownerID);\n};\n\nRecord.isRecord = isRecord;\nRecord.getDescriptiveName = recordName;\nvar RecordPrototype = Record.prototype;\nRecordPrototype[IS_RECORD_SYMBOL] = true;\nRecordPrototype[DELETE] = RecordPrototype.remove;\nRecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;\nRecordPrototype.getIn = getIn;\nRecordPrototype.hasIn = CollectionPrototype.hasIn;\nRecordPrototype.merge = merge$1;\nRecordPrototype.mergeWith = mergeWith$1;\nRecordPrototype.mergeIn = mergeIn;\nRecordPrototype.mergeDeep = mergeDeep;\nRecordPrototype.mergeDeepWith = mergeDeepWith;\nRecordPrototype.mergeDeepIn = mergeDeepIn;\nRecordPrototype.setIn = setIn;\nRecordPrototype.update = update;\nRecordPrototype.updateIn = updateIn;\nRecordPrototype.withMutations = withMutations;\nRecordPrototype.asMutable = asMutable;\nRecordPrototype.asImmutable = asImmutable;\nRecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;\nRecordPrototype.toJSON = RecordPrototype.toObject =\n CollectionPrototype.toObject;\nRecordPrototype.inspect = RecordPrototype.toSource = function () {\n return this.toString();\n};\n\nfunction makeRecord(likeRecord, values, ownerID) {\n var record = Object.create(Object.getPrototypeOf(likeRecord));\n record._values = values;\n record.__ownerID = ownerID;\n return record;\n}\n\nfunction recordName(record) {\n return record.constructor.displayName || record.constructor.name || 'Record';\n}\n\nfunction recordSeq(record) {\n return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; }));\n}\n\nfunction setProp(prototype, name) {\n try {\n Object.defineProperty(prototype, name, {\n get: function () {\n return this.get(name);\n },\n set: function (value) {\n invariant(this.__ownerID, 'Cannot set on an immutable record.');\n this.set(name, value);\n },\n });\n } catch (error) {\n // Object.defineProperty failed. Probably IE8.\n }\n}\n\n/**\n * Returns a lazy Seq of `value` repeated `times` times. When `times` is\n * undefined, returns an infinite sequence of `value`.\n */\nvar Repeat = /*@__PURE__*/(function (IndexedSeq) {\n function Repeat(value, times) {\n if (!(this instanceof Repeat)) {\n // eslint-disable-next-line no-constructor-return\n return new Repeat(value, times);\n }\n this._value = value;\n this.size = times === undefined ? Infinity : Math.max(0, times);\n if (this.size === 0) {\n if (EMPTY_REPEAT) {\n // eslint-disable-next-line no-constructor-return\n return EMPTY_REPEAT;\n }\n EMPTY_REPEAT = this;\n }\n }\n\n if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq;\n Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n Repeat.prototype.constructor = Repeat;\n\n Repeat.prototype.toString = function toString () {\n if (this.size === 0) {\n return 'Repeat []';\n }\n return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n };\n\n Repeat.prototype.get = function get (index, notSetValue) {\n return this.has(index) ? this._value : notSetValue;\n };\n\n Repeat.prototype.includes = function includes (searchValue) {\n return is(this._value, searchValue);\n };\n\n Repeat.prototype.slice = function slice (begin, end) {\n var size = this.size;\n return wholeSlice(begin, end, size)\n ? this\n : new Repeat(\n this._value,\n resolveEnd(end, size) - resolveBegin(begin, size)\n );\n };\n\n Repeat.prototype.reverse = function reverse () {\n return this;\n };\n\n Repeat.prototype.indexOf = function indexOf (searchValue) {\n if (is(this._value, searchValue)) {\n return 0;\n }\n return -1;\n };\n\n Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) {\n if (is(this._value, searchValue)) {\n return this.size;\n }\n return -1;\n };\n\n Repeat.prototype.__iterate = function __iterate (fn, reverse) {\n var size = this.size;\n var i = 0;\n while (i !== size) {\n if (fn(this._value, reverse ? size - ++i : i++, this) === false) {\n break;\n }\n }\n return i;\n };\n\n Repeat.prototype.__iterator = function __iterator (type, reverse) {\n var this$1$1 = this;\n\n var size = this.size;\n var i = 0;\n return new Iterator(function () { return i === size\n ? iteratorDone()\n : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); }\n );\n };\n\n Repeat.prototype.equals = function equals (other) {\n return other instanceof Repeat\n ? is(this._value, other._value)\n : deepEqual(this, other);\n };\n\n return Repeat;\n}(IndexedSeq));\n\nvar EMPTY_REPEAT;\n\nfunction fromJS(value, converter) {\n return fromJSWith(\n [],\n converter || defaultConverter,\n value,\n '',\n converter && converter.length > 2 ? [] : undefined,\n { '': value }\n );\n}\n\nfunction fromJSWith(stack, converter, value, key, keyPath, parentValue) {\n if (\n typeof value !== 'string' &&\n !isImmutable(value) &&\n (isArrayLike(value) || hasIterator(value) || isPlainObject(value))\n ) {\n if (~stack.indexOf(value)) {\n throw new TypeError('Cannot convert circular structure to Immutable');\n }\n stack.push(value);\n keyPath && key !== '' && keyPath.push(key);\n var converted = converter.call(\n parentValue,\n key,\n Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }\n ),\n keyPath && keyPath.slice()\n );\n stack.pop();\n keyPath && keyPath.pop();\n return converted;\n }\n return value;\n}\n\nfunction defaultConverter(k, v) {\n // Effectively the opposite of \"Collection.toSeq()\"\n return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();\n}\n\nvar version = \"4.3.7\";\n\nvar Immutable = {\n version: version,\n\n Collection: Collection,\n // Note: Iterable is deprecated\n Iterable: Collection,\n\n Seq: Seq,\n Map: Map,\n OrderedMap: OrderedMap,\n List: List,\n Stack: Stack,\n Set: Set,\n OrderedSet: OrderedSet,\n PairSorting: PairSorting,\n\n Record: Record,\n Range: Range,\n Repeat: Repeat,\n\n is: is,\n fromJS: fromJS,\n hash: hash,\n\n isImmutable: isImmutable,\n isCollection: isCollection,\n isKeyed: isKeyed,\n isIndexed: isIndexed,\n isAssociative: isAssociative,\n isOrdered: isOrdered,\n isValueObject: isValueObject,\n isPlainObject: isPlainObject,\n isSeq: isSeq,\n isList: isList,\n isMap: isMap,\n isOrderedMap: isOrderedMap,\n isStack: isStack,\n isSet: isSet,\n isOrderedSet: isOrderedSet,\n isRecord: isRecord,\n\n get: get,\n getIn: getIn$1,\n has: has,\n hasIn: hasIn$1,\n merge: merge,\n mergeDeep: mergeDeep$1,\n mergeWith: mergeWith,\n mergeDeepWith: mergeDeepWith$1,\n remove: remove,\n removeIn: removeIn,\n set: set,\n setIn: setIn$1,\n update: update$1,\n updateIn: updateIn$1,\n};\n\n// Note: Iterable is deprecated\nvar Iterable = Collection;\n\nexport default Immutable;\nexport { Collection, Iterable, List, Map, OrderedMap, OrderedSet, PairSorting, Range, Record, Repeat, Seq, Set, Stack, fromJS, get, getIn$1 as getIn, has, hasIn$1 as hasIn, hash, is, isAssociative, isCollection, isImmutable, isIndexed, isKeyed, isList, isMap, isOrdered, isOrderedMap, isOrderedSet, isPlainObject, isRecord, isSeq, isSet, isStack, isValueObject, merge, mergeDeep$1 as mergeDeep, mergeDeepWith$1 as mergeDeepWith, mergeWith, remove, removeIn, set, setIn$1 as setIn, update$1 as update, updateIn$1 as updateIn, version };\n","// Had to make uuid use a constant seed so it would generate same sequence across runs. This was needed\n// so server side rendering and client side rendering yield same results (e.g. the uuid is used when rendering\n// the concunctions with their name and id)\nvar query_builder_seed = 0;\nexport default (function () {\n // Generate a random GUID http://stackoverflow.com/a/2117523.\n var timePart = (new Date().getTime().toString(16) + \"FF\").substr(0, 11);\n var s = \"ssssssss-xxxx-4xxx-yxxx-x\".replace(/[xys]/g, function (c) {\n var r = c === \"s\" ? Math.floor(Math.random() * 16) : query_builder_seed++ & 0xf;\n var v = c === \"x\" ? r : r & 0x3 | 0x8;\n return v.toString(16);\n });\n return s + timePart;\n});","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport Immutable, { Map } from \"immutable\";\nimport { default as uuid } from \"./uuid\";\nimport { default as clone } from \"clone\";\nimport { default as moment } from \"moment\";\nexport { uuid, clone, moment };\nexport var widgetDefKeysToOmit = [\"formatValue\", \"mongoFormatValue\", \"sqlFormatValue\", \"jsonLogic\", \"elasticSearchFormatValue\", \"spelFormatValue\", \"spelImportFuncs\", \"spelImportValue\"];\nexport var opDefKeysToOmit = [\"formatOp\", \"mongoFormatOp\", \"sqlFormatOp\", \"jsonLogic\", \"spelFormatOp\"];\nexport var isObject = function isObject(v) {\n return _typeof(v) === \"object\" && v !== null && Object.prototype.toString.call(v) === \"[object Object]\";\n};\n// export const isObject = (v) => (typeof v == \"object\" && v !== null && !Array.isArray(v));\nexport var isObjectOrArray = function isObjectOrArray(v) {\n return _typeof(v) === \"object\" && v !== null;\n};\nexport var typeOf = function typeOf(v) {\n var t = _typeof(v);\n if (t && v !== null && Array.isArray(v)) return \"array\";else return t;\n};\nexport var isTypeOf = function isTypeOf(v, type) {\n if (typeOf(v) === type) return true;\n if (type === \"number\" && !isNaN(v)) return true; //can be casted\n return false;\n};\nexport var shallowCopy = function shallowCopy(v) {\n if (_typeof(v) === \"object\" && v !== null) {\n if (Array.isArray(v)) {\n return _toConsumableArray(v);\n } else if (isObject(v)) {\n return _objectSpread({}, v);\n }\n }\n return v;\n};\nexport var isSafeKeyForObject = function isSafeKeyForObject(k) {\n return ![\"__proto__\", \"constructor\", \"prototype\"].includes(k);\n};\nexport var hasSafeOwnProperty = function hasSafeOwnProperty(obj, k) {\n return Object.prototype.hasOwnProperty.call(obj, k) && isSafeKeyForObject(k);\n};\nexport var setIn = function setIn(obj, path, newValue, opts) {\n var defaultOpts = {\n canCreate: false,\n canIgnore: false,\n canChangeType: false\n };\n opts = _objectSpread(_objectSpread({}, defaultOpts), opts !== null && opts !== void 0 ? opts : {});\n var _opts = opts,\n canCreate = _opts.canCreate,\n canIgnore = _opts.canIgnore,\n canChangeType = _opts.canChangeType;\n if (!Array.isArray(path)) {\n throw new Error(\"path is not an array\");\n }\n if (!path.length) {\n throw new Error(\"path is empty\");\n }\n var expectedObjType = typeof path[0] === \"number\" ? \"array\" : \"object\";\n if (!isTypeOf(obj, expectedObjType)) {\n throw new Error(\"obj is not of type \".concat(expectedObjType));\n }\n var newObj = shallowCopy(obj);\n var target = newObj;\n var pathToTarget = _toConsumableArray(path);\n var targetKey = pathToTarget.pop();\n var goodPath = [];\n var _iterator = _createForOfIteratorHelper(pathToTarget),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var k = _step.value;\n if (!isSafeKeyForObject(k)) {\n throw new Error(\"path contains unsafe \".concat(k));\n }\n var nextKey = path[goodPath.length];\n var expectedType = typeof nextKey === \"number\" ? \"array\" : \"object\";\n if (!isTypeOf(target[k], expectedType)) {\n // value at path has another type\n if (target[k] ? canChangeType : canCreate) {\n target[k] = expectedType === \"array\" ? [] : {};\n } else if (canIgnore) {\n target = undefined;\n newObj = obj; // return initial obj as-is\n break;\n } else {\n throw new Error(\"Value by path \".concat(goodPath.join(\".\"), \" should have type \").concat(expectedType, \" but got \").concat(typeOf(target[k])));\n }\n }\n goodPath.push(k);\n target[k] = shallowCopy(target[k]);\n target = target[k];\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n if (target) {\n if (newValue === undefined) {\n delete target[targetKey];\n } else {\n var oldValue = target[targetKey];\n if (typeof newValue === \"function\") {\n target[targetKey] = newValue(oldValue);\n } else {\n target[targetKey] = newValue;\n }\n }\n }\n return newObj;\n};\nexport var mergeIn = function mergeIn(obj, mixin, opts) {\n var defaultOpts = {\n canCreate: true,\n canChangeType: true,\n deepCopyObj: false,\n deepCopyMixin: false,\n arrayMergeMode: \"merge\",\n // \"merge\" | \"join\" | \"joinMissing\" | \"joinRespectOrder\" | \"overwrite\"\n circularRefs: false,\n specialSymbols: true\n };\n opts = _objectSpread(_objectSpread({}, defaultOpts), opts !== null && opts !== void 0 ? opts : {});\n var _opts2 = opts,\n deepCopyObj = _opts2.deepCopyObj,\n deepCopyMixin = _opts2.deepCopyMixin,\n circularRefs = _opts2.circularRefs,\n specialSymbols = _opts2.specialSymbols;\n if (!isTypeOf(obj, \"object\")) {\n throw new Error(\"obj is not an object\");\n }\n if (!isTypeOf(mixin, \"object\")) {\n throw new Error(\"mixin is not an object\");\n }\n\n // symbols\n var $v = Symbol[\"for\"](\"_v\");\n var $type = Symbol[\"for\"](\"_type\");\n var $canCreate = Symbol[\"for\"](\"_canCreate\");\n var $canChangeType = Symbol[\"for\"](\"_canChangeType\");\n var $arrayMergeMode = Symbol[\"for\"](\"_arrayMergeMode\");\n var newObj = deepCopyObj ? clone(obj, circularRefs) : shallowCopy(obj);\n var newObjChanged = false;\n var _process2 = function _process(path, targetMix, target) {\n var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},\n isMixingArray = _ref.isMixingArray,\n isMixingRealArray = _ref.isMixingRealArray;\n var indexDelta = 0;\n var _loop = function _loop() {\n if (!isSafeKeyForObject(mk)) {\n throw new Error(\"mixin contains unsafe key \".concat(mk));\n // newObjChanged = false;\n // break;\n }\n if (!hasSafeOwnProperty(targetMix, mk)) {\n return 0; // continue\n }\n var k = isMixingArray ? Number(mk) + indexDelta : mk;\n var useSymbols = specialSymbols && isObjectOrArray(targetMix[mk]);\n var canCreate = opts.canCreate,\n canChangeType = opts.canChangeType,\n arrayMergeMode = opts.arrayMergeMode;\n var targetMixValue = targetMix[mk];\n var isMixValueExplicit = false;\n var expectedType = typeOf(targetMixValue);\n if (useSymbols) {\n var _targetMix$mk, _targetMix$mk$$canCre, _targetMix$mk2, _targetMix$mk$$canCha, _targetMix$mk3, _targetMix$mk$$arrayM, _targetMix$mk4;\n if ($v in targetMix[mk]) {\n isMixValueExplicit = true;\n targetMixValue = targetMix[mk][$v];\n }\n expectedType = ((_targetMix$mk = targetMix[mk]) === null || _targetMix$mk === void 0 ? void 0 : _targetMix$mk[$type]) || typeOf(targetMixValue);\n canCreate = (_targetMix$mk$$canCre = (_targetMix$mk2 = targetMix[mk]) === null || _targetMix$mk2 === void 0 ? void 0 : _targetMix$mk2[$canCreate]) !== null && _targetMix$mk$$canCre !== void 0 ? _targetMix$mk$$canCre : canCreate;\n canChangeType = (_targetMix$mk$$canCha = (_targetMix$mk3 = targetMix[mk]) === null || _targetMix$mk3 === void 0 ? void 0 : _targetMix$mk3[$canChangeType]) !== null && _targetMix$mk$$canCha !== void 0 ? _targetMix$mk$$canCha : canChangeType;\n arrayMergeMode = (_targetMix$mk$$arrayM = (_targetMix$mk4 = targetMix[mk]) === null || _targetMix$mk4 === void 0 ? void 0 : _targetMix$mk4[$arrayMergeMode]) !== null && _targetMix$mk$$arrayM !== void 0 ? _targetMix$mk$$arrayM : arrayMergeMode;\n if (expectedType === \"array\" && arrayMergeMode === \"overwrite\") {\n isMixValueExplicit = true;\n }\n }\n if (expectedType !== \"array\") {\n arrayMergeMode = undefined;\n }\n if (!isTypeOf(target[k], expectedType)) {\n // value at path has another type\n if (target[k] ? canChangeType : canCreate) {\n if (expectedType === \"array\" || expectedType === \"object\") {\n target[k] = expectedType === \"array\" ? [] : {};\n newObjChanged = true;\n } else {\n // primitive\n }\n } else {\n return 0; // continue\n }\n }\n if (expectedType === \"array\" || expectedType === \"object\") {\n if (isMixValueExplicit) {\n // deep copy from mix to target\n newObjChanged = true;\n target[k] = deepCopyMixin ? clone(targetMixValue, circularRefs) : shallowCopy(targetMixValue);\n } else {\n if (arrayMergeMode && [\"join\", \"joinMissing\", \"joinRespectOrder\"].includes(arrayMergeMode)) {\n // join 2 arrays\n newObjChanged = true;\n var left = deepCopyObj ? target[k] : clone(target[k], circularRefs);\n var right = deepCopyMixin ? clone(targetMixValue, circularRefs) : targetMixValue;\n if (arrayMergeMode === \"joinRespectOrder\") {\n target[k] = mergeArraysSmart(left, right);\n } else {\n if (arrayMergeMode === \"joinMissing\") {\n right = right.filter(function (v) {\n return !left.includes(v);\n });\n }\n target[k] = [].concat(_toConsumableArray(left), _toConsumableArray(right));\n }\n } else {\n var _targetMix$mk5;\n // recursive merge\n if (!deepCopyObj) {\n target[k] = shallowCopy(target[k]);\n }\n _process2([].concat(_toConsumableArray(path), [mk]), targetMixValue, target[k], {\n isMixingArray: expectedType === \"array\",\n isMixingRealArray: expectedType === \"array\" && !((_targetMix$mk5 = targetMix[mk]) !== null && _targetMix$mk5 !== void 0 && _targetMix$mk5[$type])\n });\n }\n }\n } else {\n var needDelete = targetMixValue === undefined && !isMixingRealArray && !isMixValueExplicit;\n var valueExists = k in target;\n if (needDelete) {\n if (valueExists) {\n newObjChanged = true;\n if (Array.isArray(target)) {\n target.splice(k, 1);\n indexDelta--;\n } else {\n delete target[k];\n }\n }\n } else {\n newObjChanged = true;\n target[k] = targetMixValue;\n }\n }\n },\n _ret;\n for (var mk in targetMix) {\n _ret = _loop();\n if (_ret === 0) continue;\n }\n };\n _process2([], mixin, newObj);\n return newObjChanged ? newObj : obj;\n};\nexport var omit = function omit(obj, keys) {\n return Object.fromEntries(Object.entries(obj).filter(function (_ref2) {\n var _ref3 = _slicedToArray(_ref2, 1),\n k = _ref3[0];\n return !keys.includes(k);\n }));\n};\n\n// RegExp.quote = function (str) {\n// return str.replace(/([.?*+^$[\\]\\\\(){}|-])/g, \"\\\\$1\");\n// };\n\nexport var getOpCardinality = function getOpCardinality(opDef) {\n var _opDef$cardinality;\n return (_opDef$cardinality = opDef === null || opDef === void 0 ? void 0 : opDef.cardinality) !== null && _opDef$cardinality !== void 0 ? _opDef$cardinality : 1;\n};\n\n// const immutableEqual = function(v1, v2) {\n// if (v1 === v2) {\n// return true;\n// } else {\n// return v1.equals(v2);\n// }\n// };\n\nexport var deepEqual = function deepEqual(v1, v2) {\n if (v1 === v2) {\n return true;\n } else if (Map.isMap(v1)) {\n return v1.equals(v2);\n } else {\n return JSON.stringify(v1) == JSON.stringify(v2);\n }\n};\n\n// //Do sets have same values?\n// const eqSet = function (as, bs) {\n// if (as.size !== bs.size) return false;\n// for (var a of as) if (!bs.has(a)) return false;\n// return true;\n// };\n\n// //Do arrays have same values?\n// const eqArrSet = function (arr1, arr2) {\n// return eqSet(new Set(arr1), new Set(arr2));\n// };\n\nexport var shallowEqual = function shallowEqual(a, b) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (a === b) {\n return true;\n } else if (Array.isArray(a)) return shallowEqualArrays(a, b, deep);else if (Map.isMap(a)) return a.equals(b);else if (_typeof(a) == \"object\") return shallowEqualObjects(a, b, deep);else return a === b;\n};\nfunction shallowEqualArrays(arrA, arrB) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (arrA === arrB) {\n return true;\n }\n if (!arrA || !arrB) {\n return false;\n }\n var len = arrA.length;\n if (arrB.length !== len) {\n return false;\n }\n for (var i = 0; i < len; i++) {\n var isEqual = deep ? shallowEqual(arrA[i], arrB[i], deep) : arrA[i] === arrB[i];\n if (!isEqual) {\n return false;\n }\n }\n return true;\n}\nfunction shallowEqualObjects(objA, objB) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (objA === objB) {\n return true;\n }\n if (!objA || !objB) {\n return false;\n }\n var aKeys = Object.keys(objA);\n var bKeys = Object.keys(objB);\n var len = aKeys.length;\n if (bKeys.length !== len) {\n return false;\n }\n for (var i = 0; i < len; i++) {\n var key = aKeys[i];\n var isEqual = deep ? shallowEqual(objA[key], objB[key], deep) : objA[key] === objB[key];\n if (!isEqual) {\n return false;\n }\n }\n return true;\n}\nexport var isImmutable = function isImmutable(v) {\n return _typeof(v) === \"object\" && v !== null && typeof v.toJS === \"function\";\n};\nexport var isImmutableList = function isImmutableList(v) {\n return isImmutable(v) && Immutable.isList(v); // Immutable.isIndexed(v)\n};\nexport function toImmutableList(v) {\n return isImmutableList(v) ? v : new Immutable.List(v);\n}\nexport function applyToJS(v) {\n return isImmutable(v) ? v.toJS() : v;\n}\nexport var escapeRegExp = function escapeRegExp(string) {\n return string.replace(/[.*+?^${}()|[\\]\\\\/]/g, \"\\\\$&\"); // $& means the whole matched string\n};\nexport var mergeCustomizerNoArrays = function mergeCustomizerNoArrays(objValue, srcValue, _key, _object, _source, _stack) {\n if (Array.isArray(objValue)) {\n return srcValue;\n }\n};\nvar _cleanJSX = function cleanJSX(jsx) {\n var jsxKeys = [\"$$typeof\", \"_owner\", \"_store\", \"ref\", \"key\"];\n var getName = function getName(val) {\n if (typeof val === \"string\") {\n return val;\n } else if (typeof val === \"function\") {\n return val.name;\n }\n return val;\n };\n if (jsx instanceof Array) {\n return jsx.map(function (el, _i) {\n return _cleanJSX(el);\n });\n } else if (_typeof(jsx) === \"object\" && jsx !== null) {\n if (isDirtyJSX(jsx)) {\n var _cleaned$props;\n var cleaned = omit(jsx, jsxKeys);\n if (cleaned.type) {\n cleaned.type = getName(cleaned.type);\n }\n if (cleaned !== null && cleaned !== void 0 && (_cleaned$props = cleaned.props) !== null && _cleaned$props !== void 0 && _cleaned$props.children) {\n cleaned.props.children = _cleanJSX(cleaned.props.children);\n }\n return cleaned;\n }\n }\n return jsx;\n};\nexport { _cleanJSX as cleanJSX };\nexport var isDirtyJSX = function isDirtyJSX(jsx) {\n return _typeof(jsx) === \"object\" && jsx !== null && !Array.isArray(jsx) && Object.keys(jsx).includes(\"type\") && Object.keys(jsx).includes(\"props\") // even if {}\n && Object.keys(jsx).includes(\"key\") // even if null\n && Object.keys(jsx).includes(\"ref\") // even if null\n && Object.keys(jsx).includes(\"$$typeof\"); // Symbol(react.element)\n};\nexport var isJSX = function isJSX(jsx) {\n return _typeof(jsx) === \"object\" && jsx !== null && !Array.isArray(jsx) && typeof jsx[\"type\"] === \"string\" && Object.keys(jsx).includes(\"props\");\n};\nexport var isJsonLogic = function isJsonLogic(logic) {\n var isJL = _typeof(logic) === \"object\" // An object\n && logic !== null // but not null\n && !Array.isArray(logic) // and not an array\n && Object.keys(logic).length === 1; // with exactly one key\n if (isJL) {\n // additional checks ?\n }\n return isJL;\n};\nexport function sleep(delay) {\n return new Promise(function (resolve) {\n setTimeout(resolve, delay);\n });\n}\n\n// [1, 4, 9] + [1, 5, 9] => [1, 4, 5, 9]\n// Used for merging arrays of operators for different widgets of 1 type\nexport function mergeArraysSmart(arr1, arr2) {\n if (!arr1) arr1 = [];\n if (!arr2) arr2 = [];\n return arr2.map(function (op) {\n return [op, arr1.indexOf(op)];\n }).map(function (_ref4, i, orig) {\n var _ref5 = _slicedToArray(_ref4, 2),\n op = _ref5[0],\n ind = _ref5[1];\n if (ind == -1) {\n var next = orig.slice(i + 1);\n var prevs = orig.slice(0, i);\n var after = _toConsumableArray(prevs).reverse().find(function (_ref6) {\n var _ref7 = _slicedToArray(_ref6, 2),\n _cop = _ref7[0],\n ci = _ref7[1];\n return ci != -1;\n });\n var prev = prevs[prevs.length - 1];\n var before = next.find(function (_ref8) {\n var _ref9 = _slicedToArray(_ref8, 2),\n _cop = _ref9[0],\n ci = _ref9[1];\n return ci != -1;\n });\n var isAfterDirectly = after && after === prevs[prevs.length - 1];\n var isBeforeDirectly = before && next === next[0];\n if (isAfterDirectly) {\n return [op, \"after\", after[0]];\n } else if (isBeforeDirectly) {\n return [op, \"before\", before[0]];\n } else if (after) {\n if (prev) {\n return [op, \"after\", prev[0]];\n }\n return [op, \"after\", after[0]];\n } else if (before) {\n return [op, \"before\", before[0]];\n } else {\n return [op, \"append\", null];\n }\n } else {\n // already exists\n return null;\n }\n }).filter(function (x) {\n return x !== null;\n }).reduce(function (acc, _ref10) {\n var _ref11 = _slicedToArray(_ref10, 3),\n newOp = _ref11[0],\n rel = _ref11[1],\n relOp = _ref11[2];\n var ind = acc.indexOf(relOp);\n if (acc.indexOf(newOp) === -1) {\n if (ind > -1) {\n // insert after or before\n var offset = rel === \"after\" ? 1 : 0;\n acc.splice(ind + offset, 0, newOp);\n } else {\n // insert to end or start\n acc.splice(rel === \"append\" ? Infinity : 0, 0, newOp);\n }\n }\n return acc;\n }, arr1.slice());\n}\nvar _deepFreeze = function deepFreeze(obj) {\n if (_typeof(obj) === \"object\" && obj !== null && !isDirtyJSX(obj)) {\n Object.keys(obj).forEach(function (prop) {\n if (prop !== \"__cache\") {\n _deepFreeze(obj[prop]);\n }\n });\n Object.freeze(obj);\n }\n};\nexport { _deepFreeze as deepFreeze };\nvar _isJsonCompatible = function isJsonCompatible(tpl, obj) {\n var bag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n if (isObject(tpl)) {\n if (tpl[\"var\"]) {\n bag[tpl[\"var\"]] = obj;\n return true;\n }\n if (!isObject(obj)) return false;\n for (var k in tpl) {\n var tv = tpl[k];\n var ov = obj[k];\n if (!_isJsonCompatible(tv, ov, bag, [].concat(_toConsumableArray(path), [k]))) return false;\n }\n return true;\n } else if (Array.isArray(tpl)) {\n if (!Array.isArray(obj)) return false;\n for (var i = 0; i < tpl.length; i++) {\n var _tv = tpl[i];\n var _ov = obj[i];\n if (!_isJsonCompatible(_tv, _ov, bag, [].concat(_toConsumableArray(path), [i]))) return false;\n }\n return true;\n } else {\n return tpl === obj;\n }\n};\nexport { _isJsonCompatible as isJsonCompatible };\nvar isDev = function isDev() {\n var _process3;\n return typeof process !== \"undefined\" && ((_process3 = process) === null || _process3 === void 0 || (_process3 = _process3.env) === null || _process3 === void 0 ? void 0 : _process3.NODE_ENV) == \"development\";\n};\nvar isTest = function isTest() {\n var _process4;\n return typeof process !== \"undefined\" && ((_process4 = process) === null || _process4 === void 0 || (_process4 = _process4.env) === null || _process4 === void 0 ? void 0 : _process4.NODE_ENV_TEST) == \"true\";\n};\nexport var getLogger = function getLogger(devMode) {\n if (isTest()) {\n return _objectSpread(_objectSpread({}, console), {}, {\n log: function log() {},\n debug: function debug() {},\n info: function info() {}\n });\n }\n var verbose = devMode != undefined ? devMode : isDev();\n return verbose ? console : {\n error: function error() {},\n log: function log() {},\n warn: function warn() {},\n debug: function debug() {},\n info: function info() {}\n };\n};\nexport var getFirstDefined = function getFirstDefined() {\n var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n var ret;\n for (var i = 0; i < arr.length; i++) {\n var v = arr[i];\n if (v !== undefined) {\n ret = v;\n break;\n }\n }\n return ret;\n};\nexport var logger = getLogger();","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport _regeneratorRuntime from \"@babel/runtime/regenerator\";\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(iterateFuncs),\n _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(iterateFields);\nimport pick from \"lodash/pick\";\nimport { widgetDefKeysToOmit, omit } from \"./stuff\";\nexport var _widgetDefKeysToOmit = widgetDefKeysToOmit; // for ui\n\nexport var configKeys = [\"conjunctions\", \"fields\", \"types\", \"operators\", \"widgets\", \"settings\", \"funcs\", \"ctx\"];\nexport var selectTypes = [\"select\", \"multiselect\", \"treeselect\", \"treemultiselect\"];\nexport function iterateFuncs(config) {\n return _regeneratorRuntime.wrap(function iterateFuncs$(_context) {\n while (1) switch (_context.prev = _context.next) {\n case 0:\n return _context.delegateYield(_iterateFields(config, config.funcs || {}, []), \"t0\", 1);\n case 1:\n case \"end\":\n return _context.stop();\n }\n }, _marked);\n}\nexport function iterateFields(config) {\n return _regeneratorRuntime.wrap(function iterateFields$(_context2) {\n while (1) switch (_context2.prev = _context2.next) {\n case 0:\n return _context2.delegateYield(_iterateFields(config, config.fields || {}, []), \"t0\", 1);\n case 1:\n case \"end\":\n return _context2.stop();\n }\n }, _marked2);\n}\nfunction _iterateFields(config, subfields, path) {\n var subfieldsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"subfields\";\n return /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_config$settings) {\n var fieldSeparator, fieldKey, fieldConfig;\n return _regeneratorRuntime.wrap(function _callee$(_context3) {\n while (1) switch (_context3.prev = _context3.next) {\n case 0:\n fieldSeparator = (config === null || config === void 0 || (_config$settings = config.settings) === null || _config$settings === void 0 ? void 0 : _config$settings.fieldSeparator) || \".\";\n _context3.t0 = _regeneratorRuntime.keys(subfields);\n case 2:\n if ((_context3.t1 = _context3.t0()).done) {\n _context3.next = 13;\n break;\n }\n fieldKey = _context3.t1.value;\n fieldConfig = subfields[fieldKey];\n if (!fieldConfig[subfieldsKey]) {\n _context3.next = 9;\n break;\n }\n return _context3.delegateYield(_iterateFields(config, fieldConfig[subfieldsKey], [].concat(_toConsumableArray(path), [fieldKey]), subfieldsKey), \"t2\", 7);\n case 7:\n _context3.next = 11;\n break;\n case 9:\n _context3.next = 11;\n return [[].concat(_toConsumableArray(path), [fieldKey]).join(fieldSeparator), fieldConfig, fieldKey];\n case 11:\n _context3.next = 2;\n break;\n case 13:\n case \"end\":\n return _context3.stop();\n }\n }, _callee);\n })();\n}\nexport var getFieldRawConfig = function getFieldRawConfig(config, field) {\n var _config$settings3;\n var fieldsKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : \"fields\";\n var subfieldsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"subfields\";\n if (!field) return null;\n if (field === \"!case_value\") {\n var _config$settings2;\n return config === null || config === void 0 || (_config$settings2 = config.settings) === null || _config$settings2 === void 0 ? void 0 : _config$settings2.caseValueField;\n }\n var fieldSeparator = (config === null || config === void 0 || (_config$settings3 = config.settings) === null || _config$settings3 === void 0 ? void 0 : _config$settings3.fieldSeparator) || \".\";\n var parts = getFieldParts(field, config);\n var targetFields = config[fieldsKey];\n if (!targetFields) return null;\n var fields = targetFields;\n var fieldConfig = null;\n var path = [];\n for (var i = 0; i < parts.length; i++) {\n var part = parts[i];\n path.push(part);\n var pathKey = path.join(fieldSeparator);\n fieldConfig = fields[pathKey];\n if (i < parts.length - 1) {\n if (fieldConfig && fieldConfig[subfieldsKey]) {\n fields = fieldConfig[subfieldsKey];\n path = [];\n } else {\n fieldConfig = null;\n }\n }\n }\n return fieldConfig;\n};\n\n// if `field` is alias (fieldName), convert to original full path\nexport var normalizeField = function normalizeField(config, field) {\n var _config$__fieldNames$, _config$__fieldNames$2;\n var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n // tip: if parentField is present, field is not full path\n var fieldSeparator = config.settings.fieldSeparator;\n var path = [parentField].concat(_toConsumableArray(field.split(fieldSeparator))).filter(function (f) {\n return f != null;\n });\n var findStr = field;\n var normalizedPath = (_config$__fieldNames$ = config.__fieldNames[findStr]) === null || _config$__fieldNames$ === void 0 || (_config$__fieldNames$2 = _config$__fieldNames$.find) === null || _config$__fieldNames$2 === void 0 || (_config$__fieldNames$2 = _config$__fieldNames$2.call(_config$__fieldNames$, function (_ref) {\n var inGroup = _ref.inGroup;\n if (inGroup) return parentField === null || parentField === void 0 ? void 0 : parentField.startsWith(inGroup);\n return true;\n })) === null || _config$__fieldNames$2 === void 0 ? void 0 : _config$__fieldNames$2.fullPath;\n return (normalizedPath || path).join(fieldSeparator);\n};\nexport var getFuncSignature = function getFuncSignature(config, func) {\n if (!func) return null;\n var funcConfig = getFieldRawConfig(config, func, \"funcs\", \"subfields\");\n if (!funcConfig) return null;\n var returnType = funcConfig.returnType,\n args = funcConfig.args;\n var argsSignature = Object.fromEntries(Object.entries(args || {}).map(function (_ref2) {\n var _ref3 = _slicedToArray(_ref2, 2),\n k = _ref3[0],\n v = _ref3[1];\n var argSignature = pick(v, [\"type\", \"valueSources\", \"defaultValue\", \"fieldSettings\",\n // \"asyncListValues\", // not supported\n \"isOptional\",\n // to get proper caching key\n \"_funcKey\", \"_argKey\", \"_isFuncArg\"]);\n return [k, argSignature];\n }));\n var signature = {\n returnType: returnType,\n args: argsSignature\n };\n return signature;\n};\nexport var getFuncConfig = function getFuncConfig(config, func) {\n if (!func) return null;\n var funcConfig = getFieldRawConfig(config, func, \"funcs\", \"subfields\");\n if (!funcConfig) return null; //throw new Error(\"Can't find func \" + func + \", please check your config\");\n return funcConfig;\n};\nexport var getFuncArgConfig = function getFuncArgConfig(config, funcKey, argKey) {\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) return null; //throw new Error(`Can't find func ${funcKey}, please check your config`);\n var argConfig = funcConfig.args && funcConfig.args[argKey] || null;\n if (!argConfig) return null; //throw new Error(`Can't find arg ${argKey} for func ${funcKey}, please check your config`);\n return argConfig;\n};\nexport var isFieldDescendantOfField = function isFieldDescendantOfField(field, parentField) {\n var _config$settings4;\n var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n if (!parentField) return false;\n var fieldSeparator = (config === null || config === void 0 || (_config$settings4 = config.settings) === null || _config$settings4 === void 0 ? void 0 : _config$settings4.fieldSeparator) || \".\";\n var path = getFieldPath(field, config);\n var parentPath = getFieldPath(parentField, config);\n return path.startsWith(parentPath + fieldSeparator);\n};\nexport var getFieldPath = function getFieldPath(field) {\n var _config$settings5;\n var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n if (typeof field === \"string\") return field;\n var fieldSeparator = (config === null || config === void 0 || (_config$settings5 = config.settings) === null || _config$settings5 === void 0 ? void 0 : _config$settings5.fieldSeparator) || \".\";\n return getFieldParts(field, config).join(fieldSeparator);\n};\nexport var getFieldParts = function getFieldParts(field) {\n var _config$settings6, _field$get, _field$split;\n var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n if (!field) return [];\n if (Array.isArray(field)) return field;\n var fieldSeparator = (config === null || config === void 0 || (_config$settings6 = config.settings) === null || _config$settings6 === void 0 ? void 0 : _config$settings6.fieldSeparator) || \".\";\n if (field !== null && field !== void 0 && field.func) {\n return Array.isArray(field.func) ? field.func : field.func.split(fieldSeparator);\n }\n if (field !== null && field !== void 0 && (_field$get = field.get) !== null && _field$get !== void 0 && _field$get.call(field, \"func\")) {\n var _field$get2;\n // immutable\n return field === null || field === void 0 || (_field$get2 = field.get) === null || _field$get2 === void 0 ? void 0 : _field$get2.call(field, \"func\").split(fieldSeparator);\n }\n return (field === null || field === void 0 || (_field$split = field.split) === null || _field$split === void 0 ? void 0 : _field$split.call(field, fieldSeparator)) || [];\n};\nexport var getFieldPathParts = function getFieldPathParts(field, config) {\n var onlyKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (!field) return null;\n var fieldSeparator = config.settings.fieldSeparator;\n var parts = getFieldParts(field, config);\n if (onlyKeys) return parts;else return parts.map(function (_curr, ind, arr) {\n return arr.slice(0, ind + 1);\n }).map(function (parts) {\n return parts.join(fieldSeparator);\n });\n};\nexport var getFieldId = function getFieldId(field) {\n var _field$get3;\n if (typeof field === \"string\" || Array.isArray(field)) {\n return \"field:\".concat(getFieldPath(field));\n }\n if (_typeof(field) === \"object\" && field) {\n if (field._funcKey && field._argKey) {\n // it's func arg config\n return \"arg:\".concat(getFieldPath(field._funcKey), \"__\").concat(field._argKey);\n }\n if (field._funcKey) {\n // it's func config\n return \"func:\".concat(getFieldPath(field._funcKey));\n }\n if (field.func && field.arg) {\n // it's func arg\n return \"arg:\".concat(getFieldPath(field.func), \"__\").concat(field.arg);\n }\n if (field.func) {\n // it's field func\n return \"func:\".concat(getFieldPath(field.func));\n }\n if (field.type) {\n // it's already a config\n return null;\n }\n }\n if (field !== null && field !== void 0 && (_field$get3 = field.get) !== null && _field$get3 !== void 0 && _field$get3.call(field, \"func\")) {\n // immutable\n if (field !== null && field !== void 0 && field.get(\"arg\")) {\n // it's func arg\n return \"arg:\".concat(getFieldPath(field.get(\"func\")), \"__\").concat(field.get(\"arg\"));\n } else {\n // it's field func\n return \"func:\".concat(getFieldPath(field.get(\"func\")));\n }\n }\n return null;\n};\nexport var _getFromConfigCache = function _getFromConfigCache(config, bucketKey, cacheKey) {\n var _config$__cache;\n return (_config$__cache = config.__cache) === null || _config$__cache === void 0 || (_config$__cache = _config$__cache[bucketKey]) === null || _config$__cache === void 0 ? void 0 : _config$__cache[cacheKey];\n};\nexport var _saveToConfigCache = function _saveToConfigCache(config, bucketKey, cacheKey, value) {\n if (!config.__cache || !cacheKey) {\n return;\n }\n if (!config.__cache[bucketKey]) {\n config.__cache[bucketKey] = {};\n }\n config.__cache[bucketKey][cacheKey] = value;\n};\nexport var getFieldSrc = function getFieldSrc(field) {\n var _field$get4;\n if (!field) return null;\n if (_typeof(field) === \"object\") {\n // should not be possible\n // if (field._isFuncArg) {\n // // it's func arg\n // return null;\n // }\n // if (field._isFunc) {\n // // it's field func\n // return \"func\";\n // }\n if (!field.func && field.type) {\n // it's already a config\n return \"field\";\n }\n if (field.func) {\n if (field.func && field.arg) {\n // it's func arg\n return null;\n } else {\n // it's field func\n return \"func\";\n }\n }\n }\n if (field !== null && field !== void 0 && (_field$get4 = field.get) !== null && _field$get4 !== void 0 && _field$get4.call(field, \"func\")) {\n // immutable\n if (field !== null && field !== void 0 && field.get(\"arg\")) {\n // it's func arg\n return null;\n } else {\n // it's field func\n return \"func\";\n }\n }\n return \"field\";\n};\nexport var getFieldConfig = function getFieldConfig(config, field) {\n var _field$get5;\n if (!field) return null;\n if (_typeof(field) == \"object\") {\n if (!field.func && !!field.type && !!field.widgets) {\n // it's already a config\n // but don't mess up with obj from `getFuncSignature`, it has `type` but no `widgets` and other keys !\n return field;\n }\n if (field._isFuncArg) {\n // it's func arg\n return getFuncArgConfig(config, field._funcKey, field._argKey);\n }\n if (field._isFunc) {\n // it's a func\n return getFuncConfig(config, field._funcKey);\n }\n if (field.func) {\n if (field.func && field.arg) {\n // it's func arg\n return getFuncArgConfig(config, field.func, field.arg);\n } else {\n // it's a func\n return getFuncConfig(config, field.func);\n }\n }\n }\n if (field !== null && field !== void 0 && (_field$get5 = field.get) !== null && _field$get5 !== void 0 && _field$get5.call(field, \"func\")) {\n // immutable\n if (field !== null && field !== void 0 && field.get(\"arg\")) {\n // it's func arg\n return getFuncArgConfig(config, field.get(\"func\"), field.get(\"arg\"));\n } else {\n // it's field func\n return getFuncConfig(config, field.get(\"func\"));\n }\n }\n var fieldConfig = getFieldRawConfig(config, field);\n if (!fieldConfig) return null; //throw new Error(\"Can't find field \" + field + \", please check your config\");\n return fieldConfig;\n};\nexport var getOperatorConfig = function getOperatorConfig(config, operator) {\n var field = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n if (!operator) return null;\n var opConfig = config.operators[operator];\n if (field) {\n var _widgetConfig$opProps, _fieldWidgetConfig$op;\n var fieldCacheKey = getFieldId(field);\n var cacheKey = fieldCacheKey ? \"\".concat(fieldCacheKey, \"__\").concat(operator) : null;\n var cached = _getFromConfigCache(config, \"getOperatorConfig\", cacheKey);\n if (cached) return cached;\n var fieldConfig = getFieldConfig(config, field);\n var widget = getWidgetForFieldOp(config, field, operator, null);\n var widgetConfig = config.widgets[widget] || {};\n var fieldWidgetConfig = (fieldConfig && fieldConfig.widgets ? fieldConfig.widgets[widget] : {}) || {};\n var widgetOpProps = ((_widgetConfig$opProps = widgetConfig.opProps) === null || _widgetConfig$opProps === void 0 ? void 0 : _widgetConfig$opProps[operator]) || {};\n var fieldWidgetOpProps = ((_fieldWidgetConfig$op = fieldWidgetConfig.opProps) === null || _fieldWidgetConfig$op === void 0 ? void 0 : _fieldWidgetConfig$op[operator]) || {};\n var mergedConfig = _objectSpread(_objectSpread(_objectSpread({}, opConfig), widgetOpProps), fieldWidgetOpProps);\n _saveToConfigCache(config, \"getOperatorConfig\", cacheKey, mergedConfig);\n return mergedConfig;\n } else {\n return opConfig;\n }\n};\nexport var getFieldWidgetConfig = function getFieldWidgetConfig(config, field) {\n var _fieldConfig$widgets;\n var operator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var widget = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var valueSrc = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var meta = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};\n if (!field) return null;\n var fieldConfig = getFieldConfig(config, field);\n var fieldCacheKey = getFieldId(field);\n if (!widget) {\n widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n }\n var cacheKey = fieldCacheKey ? \"\".concat(fieldCacheKey, \"__\").concat(operator, \"__\").concat(widget, \"__\").concat(valueSrc) : null;\n var cached = _getFromConfigCache(config, \"getFieldWidgetConfig\", cacheKey);\n if (cached) return cached;\n var widgetConfig = config.widgets[widget] || {};\n var fieldWidgetConfig = (fieldConfig === null || fieldConfig === void 0 || (_fieldConfig$widgets = fieldConfig.widgets) === null || _fieldConfig$widgets === void 0 ? void 0 : _fieldConfig$widgets[widget]) || {};\n var fieldWidgetProps = fieldWidgetConfig.widgetProps || {};\n var valueFieldSettings = valueSrc === \"value\" || !valueSrc ? fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.fieldSettings : {}; // useful to take 'validateValue'\n var mergedConfig = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, widgetConfig), fieldWidgetConfig), fieldWidgetProps), valueFieldSettings);\n _saveToConfigCache(config, \"getFieldWidgetConfig\", cacheKey, mergedConfig);\n if (meta.forExport) {\n mergedConfig = omit(mergedConfig, \"factory\");\n }\n return mergedConfig;\n};\nexport var getFirstField = function getFirstField(config) {\n var parentRuleGroupField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n var fieldSeparator = config.settings.fieldSeparator;\n var parentPathArr = getFieldParts(parentRuleGroupField, config);\n var parentField = parentRuleGroupField ? getFieldRawConfig(config, parentRuleGroupField) : config;\n var firstField = parentField,\n key = null,\n keysPath = [];\n do {\n var _firstField;\n var subfields = firstField === config ? config.fields : (_firstField = firstField) === null || _firstField === void 0 ? void 0 : _firstField.subfields;\n if (!subfields || !Object.keys(subfields).length) {\n firstField = key = null;\n break;\n }\n key = Object.keys(subfields)[0];\n keysPath.push(key);\n firstField = subfields[key];\n } while (firstField.type == \"!struct\" || firstField.type == \"!group\");\n return (parentPathArr || []).concat(keysPath).join(fieldSeparator);\n};\nexport function _getWidgetsAndSrcsForFieldOp(config, field) {\n var operator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var widgets = [];\n var valueSrcs = [];\n if (!field) return {\n widgets: widgets,\n valueSrcs: valueSrcs\n };\n var fieldCacheKey = getFieldId(field);\n var cacheKey = fieldCacheKey ? \"\".concat(fieldCacheKey, \"__\").concat(operator, \"__\").concat(valueSrc) : null;\n var cached = _getFromConfigCache(config, \"_getWidgetsAndSrcsForFieldOp\", cacheKey);\n if (cached) return cached;\n var isFuncArg = _typeof(field) === \"object\" && (!!field.func && !!field.arg || field._isFuncArg);\n var fieldConfig = getFieldConfig(config, field);\n var opConfig = operator ? config.operators[operator] : null;\n if (fieldConfig !== null && fieldConfig !== void 0 && fieldConfig.widgets) {\n var _loop = function _loop() {\n var widgetConfig = fieldConfig.widgets[widget];\n if (!config.widgets[widget]) {\n return 1; // continue\n }\n var widgetValueSrc = config.widgets[widget].valueSrc || \"value\";\n var canAdd = true;\n if (widget === \"field\") {\n canAdd = canAdd && filterValueSourcesForField(config, [\"field\"], fieldConfig, operator).length > 0;\n }\n if (widget === \"func\") {\n canAdd = canAdd && filterValueSourcesForField(config, [\"func\"], fieldConfig, operator).length > 0;\n }\n // If can't check operators, don't add\n // Func args don't have operators\n if (valueSrc === \"value\" && !widgetConfig.operators && !isFuncArg && field !== \"!case_value\") canAdd = false;\n if (widgetConfig.operators && operator) canAdd = canAdd && widgetConfig.operators.indexOf(operator) != -1;\n if (valueSrc && valueSrc != widgetValueSrc && valueSrc !== \"const\") canAdd = false;\n if (opConfig && opConfig.cardinality == 0 && widgetValueSrc !== \"value\") canAdd = false;\n if (canAdd) {\n var _fieldConfig$valueSou, _opConfig$valueSource;\n widgets.push(widget);\n var canAddValueSrc = ((_fieldConfig$valueSou = fieldConfig.valueSources) === null || _fieldConfig$valueSou === void 0 ? void 0 : _fieldConfig$valueSou.indexOf(widgetValueSrc)) != -1;\n if ((opConfig === null || opConfig === void 0 || (_opConfig$valueSource = opConfig.valueSources) === null || _opConfig$valueSource === void 0 ? void 0 : _opConfig$valueSource.indexOf(widgetValueSrc)) == -1) canAddValueSrc = false;\n if (canAddValueSrc && !valueSrcs.find(function (v) {\n return v == widgetValueSrc;\n })) valueSrcs.push(widgetValueSrc);\n }\n };\n for (var widget in fieldConfig.widgets) {\n if (_loop()) continue;\n }\n }\n var widgetWeight = function widgetWeight(w) {\n var wg = 0;\n if (fieldConfig.preferWidgets) {\n if (fieldConfig.preferWidgets.includes(w)) wg += 10 - fieldConfig.preferWidgets.indexOf(w);\n } else if (w == fieldConfig.mainWidget) {\n wg += 100;\n }\n if (w === \"field\") {\n wg -= 1;\n }\n if (w === \"func\") {\n wg -= 2;\n }\n return wg;\n };\n widgets.sort(function (w1, w2) {\n return widgetWeight(w2) - widgetWeight(w1);\n });\n var res = {\n widgets: widgets,\n valueSrcs: valueSrcs\n };\n _saveToConfigCache(config, \"_getWidgetsAndSrcsForFieldOp\", cacheKey, res);\n return res;\n}\nexport var filterValueSourcesForField = function filterValueSourcesForField(config, valueSrcs, fieldDefinition) {\n var _fieldDefinition$type;\n var operator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n if (!fieldDefinition) return valueSrcs;\n var fieldType = (_fieldDefinition$type = fieldDefinition.type) !== null && _fieldDefinition$type !== void 0 ? _fieldDefinition$type : fieldDefinition.returnType;\n if (fieldType === \"!group\") {\n // todo: aggregation can be not only number?\n fieldType = \"number\";\n }\n var isOtherType = false;\n if (operator) {\n var opConfig = config.operators[operator];\n if (opConfig !== null && opConfig !== void 0 && opConfig.valueTypes) {\n // Important: for \"select\" field and \"select_any_in\" op valueTypes are [\"multiselect\"]\n fieldType = opConfig.valueTypes[0];\n isOtherType = true;\n }\n }\n // const { _isCaseValue } = fieldDefinition;\n if (!valueSrcs) valueSrcs = Object.keys(config.settings.valueSourcesInfo);\n return valueSrcs.filter(function (vs) {\n var canAdd = true;\n if (vs === \"field\") {\n if (config.__fieldsCntByType) {\n // tip: LHS field can be used as arg in RHS function\n var minCnt = fieldDefinition._isFuncArg || isOtherType ? 0 : 1;\n canAdd = canAdd && config.__fieldsCntByType[fieldType] > minCnt;\n }\n }\n if (vs === \"func\") {\n if (fieldDefinition.funcs) {\n canAdd = canAdd && fieldDefinition.funcs.length > 0;\n }\n if (config.__funcsCntByType) {\n canAdd = canAdd && config.__funcsCntByType[fieldType] > 0;\n }\n }\n return canAdd;\n });\n};\nexport var getWidgetForFieldOp = function getWidgetForFieldOp(config, field, operator) {\n var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var _getWidgetsAndSrcsFor = _getWidgetsAndSrcsForFieldOp(config, field, operator, valueSrc),\n widgets = _getWidgetsAndSrcsFor.widgets;\n var widget = null;\n if (widgets.length) widget = widgets[0];\n return widget;\n};\nexport var getValueSourcesForFieldOp = function getValueSourcesForFieldOp(config, field, operator) {\n var fieldDefinition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var _getWidgetsAndSrcsFor2 = _getWidgetsAndSrcsForFieldOp(config, field, operator, null),\n valueSrcs = _getWidgetsAndSrcsFor2.valueSrcs;\n var filteredValueSrcs = filterValueSourcesForField(config, valueSrcs, fieldDefinition, operator);\n return filteredValueSrcs;\n};\nexport var getWidgetsForFieldOp = function getWidgetsForFieldOp(config, field, operator) {\n var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var _getWidgetsAndSrcsFor3 = _getWidgetsAndSrcsForFieldOp(config, field, operator, valueSrc),\n widgets = _getWidgetsAndSrcsFor3.widgets;\n return widgets;\n};\nexport var getOperatorsForType = function getOperatorsForType(config, fieldType) {\n var _config$types$fieldTy;\n return ((_config$types$fieldTy = config.types[fieldType]) === null || _config$types$fieldTy === void 0 ? void 0 : _config$types$fieldTy.operators) || null;\n};\nexport var getOperatorsForField = function getOperatorsForField(config, field) {\n var fieldConfig = getFieldConfig(config, field);\n var fieldOps = fieldConfig ? fieldConfig.operators : [];\n return fieldOps;\n};\nexport var getFirstOperator = function getFirstOperator(config, field) {\n var _fieldOps$;\n var fieldOps = getOperatorsForField(config, field);\n return (_fieldOps$ = fieldOps === null || fieldOps === void 0 ? void 0 : fieldOps[0]) !== null && _fieldOps$ !== void 0 ? _fieldOps$ : null;\n};\nexport var getFieldPartsConfigs = function getFieldPartsConfigs(field, config) {\n var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n if (!field) return null;\n var parentFieldDef = parentField && getFieldRawConfig(config, parentField) || null;\n var fieldSeparator = config.settings.fieldSeparator;\n var parts = getFieldParts(field, config);\n var isDescendant = isFieldDescendantOfField(field, parentField, config);\n var parentParts = !isDescendant ? [] : getFieldParts(parentField, config);\n return parts.slice(parentParts.length).map(function (_curr, ind, arr) {\n return arr.slice(0, ind + 1);\n }).map(function (parts) {\n return {\n part: [].concat(_toConsumableArray(parentParts), _toConsumableArray(parts)).join(fieldSeparator),\n key: parts[parts.length - 1]\n };\n }).map(function (_ref4) {\n var part = _ref4.part,\n key = _ref4.key;\n var cnf = getFieldRawConfig(config, part);\n return {\n key: key,\n cnf: cnf\n };\n }).map(function (_ref5, ind, arr) {\n var key = _ref5.key,\n cnf = _ref5.cnf;\n var parentCnf = ind > 0 ? arr[ind - 1].cnf : parentFieldDef;\n return [key, cnf, parentCnf];\n });\n};","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport Immutable, { fromJS } from \"immutable\";\nimport { toImmutableList, isImmutable, applyToJS as immutableToJs } from \"./stuff\";\nimport { getFieldConfig } from \"./configUtils\";\nimport uuid from \"./uuid\";\nexport { toImmutableList, immutableToJs, isImmutable };\n\n/**\n * @param {Immutable.List} path\n * @param {...string} suffix\n * @return {Immutable.List}\n */\nexport var expandTreePath = function expandTreePath(path) {\n for (var _len = arguments.length, suffix = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n suffix[_key - 1] = arguments[_key];\n }\n return path.interpose(\"children1\").withMutations(function (list) {\n list.skip(1);\n list.push.apply(list, suffix);\n return list;\n });\n};\n\n/**\n * @param {Immutable.List} path\n * @param {...string} suffix\n * @return {Immutable.List}\n */\nexport var expandTreeSubpath = function expandTreeSubpath(path) {\n for (var _len2 = arguments.length, suffix = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n suffix[_key2 - 1] = arguments[_key2];\n }\n return path.interpose(\"children1\").withMutations(function (list) {\n list.push.apply(list, suffix);\n return list;\n });\n};\n\n/**\n * @param {Immutable.Map} tree\n * @param {Immutable.List} path\n * @return {Immutable.Map}\n */\nexport var getItemByPath = function getItemByPath(tree, path) {\n var children = new Immutable.OrderedMap(_defineProperty({}, tree.get(\"id\"), tree));\n var res = tree;\n path.forEach(function (id) {\n var _children, _res;\n res = (_children = children) === null || _children === void 0 ? void 0 : _children.get(id);\n children = (_res = res) === null || _res === void 0 ? void 0 : _res.get(\"children1\");\n });\n return res;\n};\n\n/**\n * @param {Immutable.Map} tree\n * @param {Immutable.List} path\n * @return {field, path}[] ordered by closest\n */\nexport var getAncestorRuleGroups = function getAncestorRuleGroups(tree, path) {\n var parentRuleGroups = path.map(function (_id, i) {\n return path.take(i + 1);\n }).reverse().toJS().map(function (path) {\n return {\n item: getItemByPath(tree, path),\n path: path\n };\n }).filter(function (_ref) {\n var item = _ref.item;\n return (item === null || item === void 0 ? void 0 : item.get(\"type\")) === \"rule_group\";\n });\n if (parentRuleGroups.length) {\n return parentRuleGroups.map(function (_ref2) {\n var item = _ref2.item,\n path = _ref2.path;\n return {\n path: path,\n field: item.get(\"properties\").get(\"field\")\n };\n });\n }\n return [];\n};\n\n/**\n * Remove `path` in every item\n * @param {Immutable.Map} tree\n * @return {Immutable.Map} tree\n */\n// export const removePathsInTree = (tree) => {\n// let newTree = tree;\n\n// function _processNode (item, path) {\n// const itemPath = path.push(item.get(\"id\"));\n// if (item.get(\"path\")) {\n// newTree = newTree.removeIn(expandTreePath(itemPath, \"path\"));\n// }\n\n// const children = item.get(\"children1\");\n// if (children) {\n// children.map((child, _childId) => {\n// _processNode(child, itemPath);\n// });\n// }\n// }\n\n// _processNode(tree, new Immutable.List());\n\n// return newTree;\n// };\n\n/**\n * Remove `isLocked` in items that inherit parent's `isLocked`\n * @param {Immutable.Map} tree\n * @return {Immutable.Map} tree\n */\nexport var removeIsLockedInTree = function removeIsLockedInTree(tree) {\n var newTree = tree;\n function _processNode(item, path) {\n var isParentLocked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var itemPath = path.push(item.get(\"id\"));\n var isLocked = item.getIn([\"properties\", \"isLocked\"]);\n if (isParentLocked && isLocked) {\n newTree = newTree.deleteIn(expandTreePath(itemPath, \"properties\", \"isLocked\"));\n }\n var children = item.get(\"children1\");\n if (children) {\n children.map(function (child, _childId) {\n _processNode(child, itemPath, isLocked || isParentLocked);\n });\n }\n }\n _processNode(tree, new Immutable.List());\n return newTree;\n};\n\n/**\n * Set correct `path` and `id` in every item\n * @param {Immutable.Map} tree\n * @return {Immutable.Map} tree\n */\nexport var fixPathsInTree = function fixPathsInTree(tree) {\n var newTree = tree;\n function _processNode(item, path, lev, nodeId) {\n if (!item) return;\n var currPath = item.get(\"path\");\n var currId = item.get(\"id\");\n var itemId = currId || nodeId || uuid();\n var itemPath = path.push(itemId);\n if (!currPath || !currPath.equals(itemPath)) {\n newTree = newTree.setIn(expandTreePath(itemPath, \"path\"), itemPath);\n }\n if (!currId) {\n newTree = newTree.setIn(expandTreePath(itemPath, \"id\"), itemId);\n }\n var children = item.get(\"children1\");\n if (children) {\n if (children.constructor.name === \"Map\") {\n // protect: should be OrderedMap, not Map (issue #501)\n newTree = newTree.setIn(expandTreePath(itemPath, \"children1\"), new Immutable.OrderedMap(children));\n }\n children.map(function (child, childId) {\n _processNode(child, itemPath, lev + 1, childId);\n });\n }\n }\n _processNode(tree, new Immutable.List(), 0);\n return newTree;\n};\nexport var fixEmptyGroupsInTree = function fixEmptyGroupsInTree(tree) {\n var newTree = tree;\n function _processNode(item, path, lev, nodeId) {\n if (!item) return false;\n var itemId = item.get(\"id\") || nodeId;\n var itemPath = path.push(itemId);\n var children = item.get(\"children1\");\n if (children) {\n var allChildrenGone = children.map(function (child, childId) {\n return _processNode(child, itemPath, lev + 1, childId);\n }).reduce(function (curr, v) {\n return curr && v;\n }, true);\n if ((children.size == 0 || allChildrenGone) && lev > 0) {\n newTree = newTree.deleteIn(expandTreePath(itemPath));\n return true;\n }\n }\n return false;\n }\n _processNode(tree, new Immutable.List(), 0);\n return newTree;\n};\n\n/**\n * @param {Immutable.Map} tree\n * @return {Object} {flat, items}\n */\nexport var getFlatTree = function getFlatTree(tree, config) {\n var flat = [];\n var items = {};\n var cases = [];\n var visibleHeight = 0; // number of non-collapsed nodes\n var globalLeafCount = 0;\n var globalAtomicCount = 0;\n var globalGroupCount = 0;\n var globalCountByType = {};\n // rule_group_ext can be counted as group (group #x)\n // or by similars (rule-group #x) (NOT both _ext and no ext)\n\n function _flatizeTree(item, path, insideCollapsed, insideLocked, insideRuleGroup, lev, atomicLev, caseId, childNo) {\n var _items$closestRuleGro, _items$closestRuleGro2, _items$closestRuleGro3;\n var isRoot = item === tree;\n var type = item.get(\"type\");\n var collapsed = item.get(\"collapsed\");\n var id = item.get(\"id\");\n var children = item.get(\"children1\");\n var isLocked = item.getIn([\"properties\", \"isLocked\"]);\n var childrenIds = children ? children.map(function (_child, childId) {\n return childId;\n }).valueSeq().toArray() : null;\n var isRuleGroup = type === \"rule_group\";\n var isRule = type === \"rule\";\n var isGroup = type === \"group\";\n var isCaseGroup = type === \"case_group\";\n // tip: count rule_group as 1 atomic rule\n var isAtomicRule = !insideRuleGroup && (!children || isRuleGroup);\n var hasChildren = (childrenIds === null || childrenIds === void 0 ? void 0 : childrenIds.length) > 0;\n var parentId = path.length ? path[path.length - 1] : null;\n var closestRuleGroupId = _toConsumableArray(path).reverse().find(function (id) {\n return items[id].type == \"rule_group\";\n });\n var field = item.getIn([\"properties\", \"field\"]);\n var fieldConfig = field && config && getFieldConfig(config, field);\n var canRegroup = fieldConfig ? (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.canRegroup) !== false : undefined;\n var maxNesting = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.maxNesting;\n var closestRuleGroupCanRegroup = items === null || items === void 0 || (_items$closestRuleGro = items[closestRuleGroupId]) === null || _items$closestRuleGro === void 0 ? void 0 : _items$closestRuleGro.canRegroup;\n var closestRuleGroupMaxNesting = items === null || items === void 0 || (_items$closestRuleGro2 = items[closestRuleGroupId]) === null || _items$closestRuleGro2 === void 0 ? void 0 : _items$closestRuleGro2.maxNesting;\n var closestRuleGroupLev = items === null || items === void 0 || (_items$closestRuleGro3 = items[closestRuleGroupId]) === null || _items$closestRuleGro3 === void 0 ? void 0 : _items$closestRuleGro3.lev;\n var currentCaseId = isCaseGroup ? id : caseId;\n\n // Calculations before\n if (isCaseGroup) {\n cases.push(id);\n // reset counters\n globalLeafCount = 0;\n globalAtomicCount = 0;\n globalGroupCount = 0;\n globalCountByType = {};\n }\n var caseNo = currentCaseId ? cases.indexOf(currentCaseId) : null;\n var itemsBefore = flat.length;\n var top = visibleHeight;\n var position;\n if (!isRoot) {\n position = {};\n position.caseNo = caseNo;\n position.globalNoByType = isCaseGroup ? caseNo : globalCountByType[type] || 0;\n position.indexPath = [].concat(_toConsumableArray(path.slice(1).map(function (id) {\n return items[id].childNo;\n })), [childNo]);\n if (isRule) {\n position.globalLeafNo = globalLeafCount;\n } else if (isGroup) {\n position.globalGroupNo = globalGroupCount;\n }\n }\n var nextAtomicLev = insideRuleGroup || isRuleGroup ? atomicLev : atomicLev + 1;\n flat.push(id);\n items[id] = {\n node: item,\n index: itemsBefore,\n // index in `flat`\n id: id,\n type: type,\n parent: parentId,\n children: childrenIds,\n childNo: childNo,\n caseId: currentCaseId,\n caseNo: caseNo,\n closestRuleGroupId: closestRuleGroupId,\n closestRuleGroupLev: closestRuleGroupLev,\n closestRuleGroupMaxNesting: closestRuleGroupMaxNesting,\n closestRuleGroupCanRegroup: closestRuleGroupCanRegroup,\n maxNesting: maxNesting,\n canRegroup: canRegroup,\n path: path.concat(id),\n lev: lev,\n // depth level (0 for root node)\n atomicLev: atomicLev,\n // same as lev, but rules inside rule_group retains same number\n nextAtomicLev: nextAtomicLev,\n isLeaf: !children,\n // is atomic rule OR rule inside rule_group\n isAtomicRule: isAtomicRule,\n // is atomic (rule or rule_group, but not rules inside rule_group)\n isLocked: isLocked || insideLocked,\n // vertical\n top: insideCollapsed ? null : top,\n // for case\n isDefaultCase: isCaseGroup ? !children : undefined,\n atomicRulesCountInCase: isCaseGroup ? 0 : undefined,\n // object with numbers indicating # of item in tree\n position: position,\n // unused\n collapsed: collapsed,\n _top: itemsBefore,\n parentType: parentId ? items[parentId].type : null,\n // @deprecated use isLeaf instead\n leaf: !children\n\n // will be added later:\n // prev\n // next\n // depth - for any group (children of rule_group are not counted, collapsed are not counted)\n // height - visible height\n // bottom = (insideCollapsed ? null : top + height)\n // _height = (itemsAfter - itemsBefore) - real height (incl. collapsed)\n };\n\n // Calculations before traversing children\n var height = 0;\n var depth = 0;\n if (!insideCollapsed) {\n visibleHeight += 1;\n height += 1;\n if (hasChildren && !collapsed && !isRuleGroup) {\n // tip: don't count children of rule_group\n depth += 1;\n }\n if (!isRoot && !isCaseGroup) {\n isGroup && globalGroupCount++;\n isAtomicRule && globalAtomicCount++;\n isRule && globalLeafCount++;\n globalCountByType[type] = (globalCountByType[type] || 0) + 1;\n }\n }\n if (caseId && isAtomicRule) {\n items[caseId].atomicRulesCountInCase++;\n }\n\n // Traverse children deeply\n var maxChildDepth = 0;\n var sumHeight = 0;\n if (hasChildren) {\n var childCount = 0;\n children.map(function (child, childId) {\n if (child) {\n _flatizeTree(child, path.concat(id), insideCollapsed || collapsed, insideLocked || isLocked, insideRuleGroup || isRuleGroup, lev + 1, nextAtomicLev, currentCaseId, childCount);\n var childItem = items[childId];\n // Calculations after deep traversing 1 child\n maxChildDepth = Math.max(maxChildDepth, childItem.depth || 0);\n sumHeight += childItem.height;\n childCount++;\n }\n });\n }\n\n // Calculations after deep traversing ALL children\n height += sumHeight;\n depth += maxChildDepth;\n var itemsAfter = flat.length;\n var _height = itemsAfter - itemsBefore;\n var bottom = insideCollapsed ? null : top + height;\n Object.assign(items[id], {\n depth: children ? depth : undefined,\n _height: _height,\n height: height,\n bottom: bottom\n });\n }\n\n // Start recursion\n _flatizeTree(tree, [], false, false, false, 0, 0, null, null);\n\n // Calc after recursion\n for (var i = 0; i < flat.length; i++) {\n var prevId = i > 0 ? flat[i - 1] : null;\n var nextId = i < flat.length - 1 ? flat[i + 1] : null;\n var item = items[flat[i]];\n item.prev = prevId;\n item.next = nextId;\n }\n return {\n flat: flat,\n items: items,\n cases: cases\n };\n};\n\n/**\n * Returns count of reorderable(!) nodes\n * @param {Immutable.Map} tree\n * @return {Integer}\n */\nexport var getTotalReordableNodesCountInTree = function getTotalReordableNodesCountInTree(tree) {\n if (!tree) return -1;\n var cnt = 0;\n function _processNode(item, path, lev) {\n var id, children, type;\n if (typeof item.get === \"function\") {\n id = item.get(\"id\");\n children = item.get(\"children1\");\n type = item.get(\"type\");\n } else {\n id = item.id;\n children = item.children1;\n type = item.type;\n }\n cnt++;\n if (type == \"rule_group\" && lev > 0) {\n //tip: rules in rule-group can be reordered only inside\n } else if (children) {\n children.map(function (child, _childId) {\n if (child) {\n _processNode(child, path.concat(id), lev + 1);\n }\n });\n }\n }\n _processNode(tree, [], 0);\n return cnt - 1; // -1 for root\n};\n\n/**\n * Returns count of atomic rules (i.e. don't count groups; count rule_group as 1 atomic rule)\n * @param {Immutable.Map} tree\n * @return {Integer}\n */\nexport var getTotalRulesCountInTree = function getTotalRulesCountInTree(tree) {\n if (!tree) return -1;\n var cnt = 0;\n function _processNode(item, path, lev) {\n var id, children, type;\n if (typeof item.get === \"function\") {\n id = item.get(\"id\");\n children = item.get(\"children1\");\n type = item.get(\"type\");\n } else {\n id = item.id;\n children = item.children1;\n type = item.type;\n }\n if (type == \"rule\" || type == \"rule_group\" && lev > 0) {\n // tip: count rule_group as 1 rule\n cnt++;\n } else if (children) {\n children.map(function (child, _childId) {\n if (child) {\n _processNode(child, path.concat(id), lev + 1);\n }\n });\n }\n }\n _processNode(tree, [], 0);\n return cnt;\n};\n\n// Remove fields that can be calced: \"id\", \"path\"\n// Remove empty fields: \"operatorOptions\"\nexport var getLightTree = function getLightTree(tree) {\n var deleteExcess = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var children1AsArray = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n var newTree = tree;\n function _processNode(item, itemId) {\n if (deleteExcess && item.path) {\n delete item.path;\n }\n if (deleteExcess && !children1AsArray && itemId) {\n delete item.id;\n }\n var properties = item.properties;\n if (properties) {\n if (properties.operatorOptions == null) {\n delete properties.operatorOptions;\n }\n }\n var children = item.children1;\n if (children) {\n for (var id in children) {\n if (children[id]) {\n _processNode(children[id], id);\n }\n }\n if (children1AsArray) {\n item.children1 = Object.values(children);\n }\n }\n }\n _processNode(tree, null);\n return newTree;\n};\nexport var getSwitchValues = function getSwitchValues(tree) {\n var vals = [];\n var children = tree.get(\"children1\");\n if (children) {\n children.map(function (child) {\n var value = child.getIn([\"properties\", \"value\"]);\n var caseValue;\n if (value && value.size == 1) {\n caseValue = value.get(0);\n if (Array.isArray(caseValue) && caseValue.length == 0) {\n caseValue = null;\n }\n } else {\n caseValue = null;\n }\n vals = [].concat(_toConsumableArray(vals), [caseValue]);\n });\n }\n return vals;\n};\nexport var isEmptyTree = function isEmptyTree(tree) {\n return !tree.get(\"children1\") || tree.get(\"children1\").size == 0;\n};\nexport var hasChildren = function hasChildren(tree, path) {\n return tree.getIn(expandTreePath(path, \"children1\")).size > 0;\n};\nexport var _fixImmutableValue = function _fixImmutableValue(v) {\n if (v !== null && v !== void 0 && v.toJS) {\n var _v$toJS;\n var vJs = v === null || v === void 0 || (_v$toJS = v.toJS) === null || _v$toJS === void 0 ? void 0 : _v$toJS.call(v);\n if (vJs !== null && vJs !== void 0 && vJs.func) {\n // `v` is a func, keep Immutable\n return v.toOrderedMap();\n } else {\n // for values of multiselect use Array instead of List\n return vJs;\n }\n } else {\n return v;\n }\n};\nexport function jsToImmutable(tree) {\n var imm = fromJS(tree, function (key, value, path) {\n var isFuncArg = path && path.length > 3 && path[path.length - 1] === \"value\" && path[path.length - 3] === \"args\";\n var isRuleValue = path && path.length > 3 && path[path.length - 1] === \"value\" && path[path.length - 2] === \"properties\";\n var outValue;\n if (key == \"properties\") {\n outValue = value.toOrderedMap();\n\n // `value` should be undefined instead of null\n // JSON doesn't support undefined and replaces undefined -> null\n // So fix: null -> undefined\n for (var i = 0; i < 2; i++) {\n var _outValue$get, _outValue$get$get;\n if (((_outValue$get = outValue.get(\"value\")) === null || _outValue$get === void 0 || (_outValue$get$get = _outValue$get.get) === null || _outValue$get$get === void 0 ? void 0 : _outValue$get$get.call(_outValue$get, i)) === null) {\n outValue = outValue.setIn([\"value\", i], undefined);\n }\n }\n } else if (isFuncArg) {\n outValue = _fixImmutableValue(value);\n } else if ((path ? isRuleValue : key == \"value\") && Immutable.Iterable.isIndexed(value)) {\n outValue = value.map(_fixImmutableValue).toList();\n } else if (key == \"asyncListValues\") {\n // keep in JS format\n outValue = value.toJS();\n } else if (key == \"children1\" && Immutable.Iterable.isIndexed(value)) {\n outValue = new Immutable.OrderedMap(value.map(function (child) {\n return [(child === null || child === void 0 ? void 0 : child.get(\"id\")) || uuid(), child];\n }));\n } else {\n outValue = Immutable.Iterable.isIndexed(value) ? value.toList() : value.toOrderedMap();\n }\n return outValue;\n });\n return imm;\n}","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport Immutable from \"immutable\";\nimport { getFieldConfig, getFieldParts, getFirstField, getOperatorConfig, getFirstOperator } from \"./configUtils\";\nimport { isImmutable, isImmutableList } from \"./stuff\";\nimport { jsToImmutable } from \"./treeUtils\";\n\n// @deprecated Use defaultGroupConjunction\nexport var defaultConjunction = function defaultConjunction(config) {\n return defaultGroupConjunction(config);\n};\n\n//used for complex operators like proximity\nexport var defaultOperatorOptions = function defaultOperatorOptions(config, operator, field) {\n var operatorConfig = operator ? getOperatorConfig(config, operator, field) : null;\n if (!operatorConfig) return null; //new Immutable.Map();\n return operatorConfig.options ? new Immutable.Map(operatorConfig.options && operatorConfig.options.defaults || {}) : null;\n};\nexport var defaultGroupConjunction = function defaultGroupConjunction(config) {\n var _groupFieldConfig, _groupFieldConfig2;\n var groupFieldConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n groupFieldConfig = getFieldConfig(config, groupFieldConfig); // if `groupFieldConfig` is field name, not config\n var conjs = ((_groupFieldConfig = groupFieldConfig) === null || _groupFieldConfig === void 0 ? void 0 : _groupFieldConfig.conjunctions) || Object.keys(config.conjunctions);\n if (conjs.length == 1) return conjs[0];\n // todo: config.settings.defaultGroupConjunction is deprecated, defaultConjunction should be used instead\n return ((_groupFieldConfig2 = groupFieldConfig) === null || _groupFieldConfig2 === void 0 ? void 0 : _groupFieldConfig2.defaultConjunction) || config.settings.defaultConjunction || config.settings.defaultGroupConjunction || conjs[0];\n};\nexport var defaultGroupProperties = function defaultGroupProperties(config) {\n var groupFieldConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n return new Immutable.Map({\n conjunction: defaultGroupConjunction(config, groupFieldConfig),\n not: false\n });\n};\nexport var getDefaultField = function getDefaultField(config) {\n var canGetFirst = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var parentRuleGroupField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var defaultField = config.settings.defaultField;\n var f = (!parentRuleGroupField ? defaultField : getDefaultSubField(config, parentRuleGroupField)) || canGetFirst && getFirstField(config, parentRuleGroupField) || null;\n // if default LHS is func, convert to Immutable\n if (f != null && typeof f !== \"string\" && !isImmutable(f)) {\n f = jsToImmutable(f);\n }\n return f;\n};\nexport var getDefaultSubField = function getDefaultSubField(config) {\n var _config$settings;\n var parentRuleGroupField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n if (!parentRuleGroupField) return null;\n var fieldSeparator = (config === null || config === void 0 || (_config$settings = config.settings) === null || _config$settings === void 0 ? void 0 : _config$settings.fieldSeparator) || \".\";\n var parentRuleGroupConfig = getFieldConfig(config, parentRuleGroupField);\n var f = parentRuleGroupConfig === null || parentRuleGroupConfig === void 0 ? void 0 : parentRuleGroupConfig.defaultField;\n if (f) {\n f = [].concat(_toConsumableArray(getFieldParts(parentRuleGroupField)), [f]).join(fieldSeparator);\n }\n return f;\n};\nexport var getDefaultFieldSrc = function getDefaultFieldSrc(config) {\n var _config$settings$fiel;\n var canGetFirst = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n return canGetFirst && ((_config$settings$fiel = config.settings.fieldSources) === null || _config$settings$fiel === void 0 ? void 0 : _config$settings$fiel[0]) || \"field\";\n};\nexport var getDefaultOperator = function getDefaultOperator(config, field) {\n var canGetFirst = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n var fieldConfig = getFieldConfig(config, field);\n var fieldOperators = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.operators) || [];\n var globalDefaultOperator = config.settings.defaultOperator;\n if (globalDefaultOperator && !fieldOperators.includes(globalDefaultOperator)) globalDefaultOperator = null;\n var fieldDefaultOperator = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.defaultOperator;\n var fieldOwnDefaultOperator = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.ownDefaultOperator;\n var firstOperator = canGetFirst ? getFirstOperator(config, field) : null;\n var op = fieldOwnDefaultOperator || globalDefaultOperator || fieldDefaultOperator || firstOperator;\n return op;\n};\nexport var createListWithOneElement = function createListWithOneElement(el) {\n if (isImmutableList(el)) return el; // already Immutable list\n return createListFromArray([el]);\n};\nexport var createListFromArray = function createListFromArray(arr) {\n if (isImmutableList(arr)) return arr; // already Immutable list\n return new Immutable.List(arr);\n};\nexport var emptyProperties = function emptyProperties() {\n return new Immutable.Map();\n};","import _typeof from \"@babel/runtime/helpers/typeof\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport Immutable from \"immutable\";\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFieldRawConfig, getFuncConfig, getFieldParts, isFieldDescendantOfField, _getFromConfigCache, _saveToConfigCache, _getWidgetsAndSrcsForFieldOp, filterValueSourcesForField } from \"./configUtils\";\nimport { isObject } from \"./stuff\";\nimport last from \"lodash/last\";\nexport var calculateValueType = function calculateValueType(value, valueSrc, config) {\n var calculatedValueType = null;\n if (value) {\n if (valueSrc === \"field\") {\n var fieldConfig = getFieldConfig(config, value);\n if (fieldConfig) {\n calculatedValueType = fieldConfig.type;\n }\n } else if (valueSrc === \"func\") {\n var funcKey = value.get(\"func\");\n if (funcKey) {\n var funcConfig = getFuncConfig(config, funcKey);\n if (funcConfig) {\n calculatedValueType = funcConfig.returnType || funcConfig.type;\n }\n }\n }\n }\n return calculatedValueType;\n};\nexport var getFuncPathLabels = function getFuncPathLabels(field, config) {\n var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n return getFieldPathLabels(field, config, parentField, \"funcs\", \"subfields\");\n};\nexport var getFieldPathLabels = function getFieldPathLabels(field, config) {\n var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var fieldsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"fields\";\n var subfieldsKey = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : \"subfields\";\n if (!field) return null;\n var fieldSeparator = config.settings.fieldSeparator;\n var parts = getFieldParts(field, config);\n var parentParts = getFieldParts(parentField, config);\n var res = parts.slice(parentParts.length).map(function (_curr, ind, arr) {\n return arr.slice(0, ind + 1);\n }).map(function (parts) {\n return [].concat(_toConsumableArray(parentParts), _toConsumableArray(parts)).join(fieldSeparator);\n }).map(function (part) {\n var cnf = getFieldRawConfig(config, part, fieldsKey, subfieldsKey);\n return cnf && cnf.label || last(part.split(fieldSeparator));\n }).filter(function (label) {\n return label != null;\n });\n return res;\n};\nexport var getValueLabel = function getValueLabel(config, field, operator, delta) {\n var valueSrc = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var isSpecialRange = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n // const isFuncArg = field && typeof field == \"object\" && !!field.func && !!field.arg;\n // const {showLabels} = config.settings;\n // const fieldConfig = getFieldConfig(config, field);\n var fieldWidgetConfig = getFieldWidgetConfig(config, field, operator, null, valueSrc) || {};\n var mergedOpConfig = getOperatorConfig(config, operator, field) || {};\n var cardinality = isSpecialRange ? 1 : mergedOpConfig.cardinality;\n var ret = null;\n if (cardinality > 1) {\n var valueLabels = fieldWidgetConfig.valueLabels || mergedOpConfig.valueLabels;\n if (valueLabels) ret = valueLabels[delta];\n if (ret && _typeof(ret) !== \"object\") {\n ret = {\n label: ret,\n placeholder: ret\n };\n }\n if (!ret) {\n ret = {\n label: config.settings.valueLabel + \" \" + (delta + 1),\n placeholder: config.settings.valuePlaceholder + \" \" + (delta + 1)\n };\n }\n } else {\n var label = fieldWidgetConfig.valueLabel;\n var placeholder = fieldWidgetConfig.valuePlaceholder;\n // tip: this logic moved to extendFieldConfig(), see comment \"label for func arg\"\n // if (isFuncArg) {\n // if (!label)\n // label = fieldConfig.label || field.arg;\n // if (!placeholder && !showLabels)\n // placeholder = fieldConfig.label || field.arg;\n // }\n\n ret = {\n label: label || config.settings.valueLabel,\n placeholder: placeholder || config.settings.valuePlaceholder\n };\n }\n return ret;\n};\n\n// can use alias (fieldName)\n// even if `parentField` is provided, `field` is still a full path\nexport var formatFieldName = function formatFieldName(field, config, meta) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};\n if (!field) return;\n var fieldDef = getFieldConfig(config, field) || {};\n var fieldSeparator = config.settings.fieldSeparator;\n var fieldParts = getFieldParts(field, config);\n var fieldName = Array.isArray(field) ? field.join(fieldSeparator) : field;\n if (options !== null && options !== void 0 && options.useTableName && fieldDef.tableName) {\n // legacy\n var fieldPartsCopy = _toConsumableArray(fieldParts);\n fieldPartsCopy[0] = fieldDef.tableName;\n fieldName = fieldPartsCopy.join(fieldSeparator);\n }\n if (fieldDef.fieldName) {\n fieldName = fieldDef.fieldName;\n }\n if (parentField) {\n var parentFieldDef = getFieldConfig(config, parentField) || {};\n var parentFieldName = parentField;\n if (fieldName.indexOf(parentFieldName + fieldSeparator) == 0) {\n fieldName = fieldName.slice((parentFieldName + fieldSeparator).length);\n // fieldName = \"#this.\" + fieldName; // ? for spel\n } else {\n if (fieldDef.fieldName) {\n // ignore\n } else {\n meta.errors.push(\"Can't cut group \".concat(parentFieldName, \" from field \").concat(fieldName));\n }\n }\n }\n return fieldName;\n};\n\n/**\n * Used together with keepInputOnChangeFieldSrc\n */\nexport var isEmptyItem = function isEmptyItem(item, config) {\n var type = item.get(\"type\");\n var mode = item.getIn([\"properties\", \"mode\"]);\n if (type == \"rule_group\" && mode == \"array\") {\n return isEmptyRuleGroupExt(item, config);\n } else if (type == \"group\" || type == \"rule_group\") {\n return isEmptyGroup(item, config);\n } else {\n return isEmptyRule(item, config);\n }\n};\nvar isEmptyRuleGroupExt = function isEmptyRuleGroupExt(item, config) {\n var children = item.get(\"children1\");\n var properties = item.get(\"properties\");\n return isEmptyRuleGroupExtPropertiesAndChildren(properties.toObject(), children, config);\n};\n\n/**\n * Used to remove group ext without confirmation\n * \n * If group operator is count, children can be empty.\n * If group operator is some/none/all, there should be at least one non-empty (even incomplete) child.\n */\nexport var isEmptyRuleGroupExtPropertiesAndChildren = function isEmptyRuleGroupExtPropertiesAndChildren(properties, children, config) {\n var _config$operators$ope, _config$operators$ope2;\n var operator = properties.operator;\n var cardinality = (_config$operators$ope = (_config$operators$ope2 = config.operators[operator]) === null || _config$operators$ope2 === void 0 ? void 0 : _config$operators$ope2.cardinality) !== null && _config$operators$ope !== void 0 ? _config$operators$ope : 1;\n var childrenAreRequired = cardinality == 0; // tip: for group operators some/none/all\n var filledParts = {\n group: !isEmptyRuleProperties(properties, config),\n children: !isEmptyGroupChildren(children, config)\n };\n var hasEnough = filledParts.group && (childrenAreRequired ? filledParts.children : true);\n return !hasEnough;\n};\nvar isEmptyGroup = function isEmptyGroup(group, config) {\n var children = group.get(\"children1\");\n return isEmptyGroupChildren(children, config);\n};\n\n/**\n * Used to remove group without confirmation\n * @returns {boolean} false if there is at least one (even incomplete) child\n */\nexport var isEmptyGroupChildren = function isEmptyGroupChildren(children, config) {\n var hasEnough = (children === null || children === void 0 ? void 0 : children.size) > 0 && children.filter(function (ch) {\n return !isEmptyItem(ch, config);\n }).size > 0;\n return !hasEnough;\n};\nvar isEmptyRule = function isEmptyRule(rule, config) {\n var properties = rule.get(\"properties\");\n return isEmptyRuleProperties((properties === null || properties === void 0 ? void 0 : properties.toObject()) || {}, config);\n};\n\n/**\n * Used to remove rule without confirmation\n * @param properties is an Object, but properties (like value) are Immutable\n * @returns {boolean} true if there is no enough data in rule\n */\nexport var isEmptyRuleProperties = function isEmptyRuleProperties(properties, config) {\n var liteCheck = true;\n var scoreThreshold = 3;\n var compl = whatRulePropertiesAreCompleted(properties, config, liteCheck);\n var hasEnough = compl.score >= scoreThreshold;\n return !hasEnough;\n};\n\n/**\n * Used to validate rule\n * @param properties is an Object, but its properties (like `value`) are Immutable\n * @param liteCheck true can be used to check that rule has enough data to ask confirmation before delete\n * @return {{parts: {field: boolean, operator: boolean, value: boolean}, score: number}}\n */\nexport var whatRulePropertiesAreCompleted = function whatRulePropertiesAreCompleted(_ref, config) {\n var _config$operators$ope3, _config$operators$ope4, _value$filter;\n var field = _ref.field,\n fieldSrc = _ref.fieldSrc,\n fieldType = _ref.fieldType,\n operator = _ref.operator,\n value = _ref.value,\n valueSrc = _ref.valueSrc,\n valueType = _ref.valueType;\n var liteCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var cardinality = (_config$operators$ope3 = (_config$operators$ope4 = config.operators[operator]) === null || _config$operators$ope4 === void 0 ? void 0 : _config$operators$ope4.cardinality) !== null && _config$operators$ope3 !== void 0 ? _config$operators$ope3 : 1;\n var valueSrcs = valueSrc !== null && valueSrc !== void 0 && valueSrc.get ? valueSrc.toJS() : valueSrc;\n\n // tip: for liteCheck==true `score` should equal 3 if both LHS and RHS are at least partially filled\n var res = {\n parts: {},\n score: 0\n };\n res.parts.field = liteCheck ? field != null : _isCompletedValue(field, fieldSrc, config);\n res.parts.operator = !!operator;\n res.parts.value = (value === null || value === void 0 || (_value$filter = value.filter(function (val, delta) {\n return _isCompletedValue(val, valueSrcs === null || valueSrcs === void 0 ? void 0 : valueSrcs[delta], config, liteCheck);\n })) === null || _value$filter === void 0 ? void 0 : _value$filter.size) >= (liteCheck ? Math.min(cardinality, 1) : cardinality);\n res.score = Object.keys(res.parts).filter(function (k) {\n return !!res.parts[k];\n }).length;\n if (liteCheck && res.score < 3) {\n // Boost score to confirm deletion:\n // - if RHS is empty, but LHS is a completed function\n // - if LHS is empty (only fieldType is set), but there is a completed function in RHS\n var deepCheck = true;\n if (!res.parts.value && fieldSrc === \"func\" && _isCompletedValue(field, fieldSrc, config, false, deepCheck)) {\n res.score++;\n }\n if (!res.parts.field) {\n value === null || value === void 0 || value.map(function (val, delta) {\n if ((valueSrcs === null || valueSrcs === void 0 ? void 0 : valueSrcs[delta]) === \"func\" && _isCompletedValue(val, valueSrcs === null || valueSrcs === void 0 ? void 0 : valueSrcs[delta], config, false, deepCheck)) {\n res.score++;\n }\n });\n }\n }\n return res;\n};\nvar _isCompletedValue = function isCompletedValue(value, valueSrc, config) {\n var liteCheck = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var deepCheck = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;\n if (!liteCheck && valueSrc == \"func\" && value) {\n var _value$get;\n var funcKey = (_value$get = value.get) === null || _value$get === void 0 ? void 0 : _value$get.call(value, \"func\");\n var funcConfig = getFuncConfig(config, funcKey);\n if (funcConfig) {\n var args = value.get(\"args\");\n for (var argKey in funcConfig.args) {\n var argConfig = funcConfig.args[argKey];\n var argVal = args ? args.get(argKey) : undefined;\n // const argDef = getFieldConfig(config, argConfig);\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValue == undefined && (argConfig === null || argConfig === void 0 ? void 0 : argConfig.defaultValue) === undefined && !(argConfig !== null && argConfig !== void 0 && argConfig.isOptional)) {\n // arg is not completed\n return false;\n }\n if (argValue != undefined) {\n if (!_isCompletedValue(argValue, argValueSrc, config, deepCheck ? liteCheck : true)) {\n // arg is complex and is not completed\n return false;\n }\n }\n }\n // all args are completed\n return true;\n }\n }\n return value != undefined;\n};\n\n/**\n * @param {*} value\n * @param {'value'|'field'|'func'} valueSrc\n * @param {object} config\n * @return {* | undefined} undefined if func value is not complete (missing required arg vals); can return completed value != value\n */\nexport var completeValue = function completeValue(value, valueSrc, config) {\n if (valueSrc == \"func\") return completeFuncValue(value, config);else return value;\n};\n\n/**\n * @param {Immutable.Map} value\n * @param {object} config\n * @return {Immutable.Map | undefined} - undefined if func value is not complete (missing required arg vals); can return completed value != value\n */\nexport var completeFuncValue = function completeFuncValue(value, config) {\n if (!value) return undefined;\n var funcKey = value.get(\"func\");\n var funcConfig = funcKey && getFuncConfig(config, funcKey);\n if (!funcConfig) return undefined;\n var complValue = value;\n var tmpHasOptional = false;\n for (var argKey in funcConfig.args) {\n var argConfig = funcConfig.args[argKey];\n var valueSources = argConfig.valueSources,\n isOptional = argConfig.isOptional,\n defaultValue = argConfig.defaultValue;\n var filteredValueSources = filterValueSourcesForField(config, valueSources, argConfig);\n var args = complValue.get(\"args\");\n var argDefaultValueSrc = filteredValueSources.length == 1 ? filteredValueSources[0] : undefined;\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = (argVal ? argVal.get(\"valueSrc\") : undefined) || argDefaultValueSrc;\n if (argValue !== undefined) {\n var completeArgValue = completeValue(argValue, argValueSrc, config);\n if (completeArgValue === undefined) {\n return undefined;\n } else if (completeArgValue !== argValue) {\n complValue = complValue.setIn([\"args\", argKey, \"value\"], completeArgValue);\n }\n if (tmpHasOptional) {\n // has gap\n return undefined;\n }\n } else if (defaultValue !== undefined && !isObject(defaultValue)) {\n complValue = complValue.setIn([\"args\", argKey, \"value\"], getDefaultArgValue(argConfig));\n complValue = complValue.setIn([\"args\", argKey, \"valueSrc\"], \"value\");\n } else if (isOptional) {\n // optional\n tmpHasOptional = true;\n } else {\n // missing value\n return undefined;\n }\n }\n return complValue;\n};\n\n// item - Immutable\nvar _getOneChildOrDescendant = function getOneChildOrDescendant(item) {\n var children = item.get(\"children1\");\n if ((children === null || children === void 0 ? void 0 : children.size) == 1) {\n var child = children.first();\n var childType = child.get(\"type\");\n if (childType === \"group\") {\n return _getOneChildOrDescendant(child);\n }\n return child;\n }\n return null;\n};\n\n///// Func utils\nexport { _getOneChildOrDescendant as getOneChildOrDescendant };\nexport var getDefaultArgValue = function getDefaultArgValue(_ref2) {\n var value = _ref2.defaultValue;\n if (isObject(value) && !Immutable.Map.isMap(value) && value.func) {\n return Immutable.fromJS(value, function (k, v) {\n return Immutable.Iterable.isIndexed(v) ? v.toList() : v.toOrderedMap();\n });\n }\n return value;\n};\n\n/**\n* Used @ FuncWidget\n* @param {Immutable.Map} value \n* @param {string} argKey \n* @param {*} argVal \n* @param {object} argConfig \n*/\nexport var setArgValue = function setArgValue(value, argKey, argVal, argConfig, config) {\n if (value && value.get(\"func\")) {\n value = value.setIn([\"args\", argKey, \"value\"], argVal);\n\n // set default arg value source\n var valueSrc = value.getIn([\"args\", argKey, \"valueSrc\"]);\n var valueSources = argConfig.valueSources;\n var filteredValueSources = filterValueSourcesForField(config, valueSources, argConfig);\n var argDefaultValueSrc = filteredValueSources.length == 1 ? filteredValueSources[0] : undefined;\n if (!argDefaultValueSrc && filteredValueSources.includes(\"value\")) {\n argDefaultValueSrc = \"value\";\n }\n if (!valueSrc && argDefaultValueSrc) {\n value = value.setIn([\"args\", argKey, \"valueSrc\"], argDefaultValueSrc);\n }\n }\n return value;\n};\nexport var setFuncDefaultArgs = function setFuncDefaultArgs(config, funcValue, funcConfig) {\n if (funcConfig) {\n for (var argKey in funcConfig.args) {\n funcValue = setFuncDefaultArg(config, funcValue, funcConfig, argKey);\n }\n }\n return funcValue;\n};\nexport var setFuncDefaultArg = function setFuncDefaultArg(config, funcValue, funcConfig, argKey) {\n var argConfig = funcConfig.args[argKey];\n var valueSources = argConfig.valueSources,\n defaultValue = argConfig.defaultValue;\n var filteredValueSources = filterValueSourcesForField(config, valueSources, argConfig);\n var firstValueSrc = filteredValueSources.length ? filteredValueSources[0] : undefined;\n var defaultValueSrc = defaultValue ? isObject(defaultValue) && !!defaultValue.func ? \"func\" : \"value\" : undefined;\n var argDefaultValueSrc = defaultValueSrc || firstValueSrc;\n var hasValue = funcValue.getIn([\"args\", argKey]);\n if (!hasValue) {\n if (defaultValue !== undefined) {\n funcValue = funcValue.setIn([\"args\", argKey, \"value\"], getDefaultArgValue(argConfig));\n }\n if (argDefaultValueSrc) {\n funcValue = funcValue.setIn([\"args\", argKey, \"valueSrc\"], argDefaultValueSrc);\n }\n }\n return funcValue;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getOpCardinality } from \"../utils/stuff\";\nimport { getFieldConfig, getOperatorConfig } from \"../utils/configUtils\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { formatFieldName } from \"../utils/ruleUtils\";\nimport { Map } from \"immutable\";\n\n/*\n Build tree to http://querybuilder.js.org/ like format\n\n Example:\n {\n \"condition\": \"AND\",\n \"rules\": [\n {\n \"id\": \"price\",\n \"field\": \"price\",\n \"type\": \"double\",\n \"input\": \"text\",\n \"operator\": \"less\",\n \"value\": \"10.25\"\n },\n {\n \"condition\": \"OR\",\n \"rules\": [\n {\n \"id\": \"category\",\n \"field\": \"category\",\n \"type\": \"integer\",\n \"input\": \"select\",\n \"operator\": \"equal\",\n \"value\": \"2\"\n },\n {\n \"id\": \"category\",\n \"field\": \"category\",\n \"type\": \"integer\",\n \"input\": \"select\",\n \"operator\": \"equal\",\n \"value\": \"1\"\n }\n ]\n }\n ]\n }\n */\n\nexport var queryBuilderFormat = function queryBuilderFormat(item, config) {\n //meta is mutable\n var meta = {\n usedFields: []\n };\n var res = formatItem(item, config, meta);\n if (!res) return undefined;\n return _objectSpread(_objectSpread({}, res), meta);\n};\nvar formatItem = function formatItem(item, config, meta) {\n if (!item) return undefined;\n var type = item.get(\"type\");\n var children = item.get(\"children1\");\n if ((type === \"group\" || type === \"rule_group\") && children && children.size) {\n return formatGroup(item, config, meta);\n } else if (type === \"rule\") {\n return formatRule(item, config, meta);\n }\n return undefined;\n};\nvar formatGroup = function formatGroup(item, config, meta) {\n var properties = item.get(\"properties\") || new Map();\n var children = item.get(\"children1\");\n var id = item.get(\"id\");\n var list = children.map(function (currentChild) {\n return formatItem(currentChild, config, meta);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n });\n if (!list.size) return undefined;\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var not = properties.get(\"not\");\n var resultQuery = {\n id: id,\n rules: list.toList(),\n condition: conjunction.toUpperCase(),\n not: not\n };\n return resultQuery;\n};\nvar formatRule = function formatRule(item, config, meta) {\n var _valueType;\n var properties = item.get(\"properties\") || new Map();\n var id = item.get(\"id\");\n var operator = properties.get(\"operator\");\n var options = properties.get(\"operatorOptions\");\n var field = properties.get(\"field\");\n var value = properties.get(\"value\");\n var valueSrc = properties.get(\"valueSrc\");\n var valueType = properties.get(\"valueType\");\n var hasUndefinedValues = value.filter(function (v) {\n return v === undefined;\n }).size > 0;\n if (field == null || operator == null || hasUndefinedValues) return undefined;\n var fieldDefinition = getFieldConfig(config, field) || {};\n var operatorDefinition = getOperatorConfig(config, operator, field) || {};\n var fieldType = fieldDefinition.type || \"undefined\";\n var cardinality = getOpCardinality(operatorDefinition);\n var typeConfig = config.types[fieldDefinition.type] || {};\n var fieldName = formatFieldName(field, config, meta);\n if (value.size < cardinality) return undefined;\n if (meta.usedFields.indexOf(field) == -1) meta.usedFields.push(field);\n value = value.toArray();\n valueSrc = valueSrc.toArray();\n valueType = ((_valueType = valueType) === null || _valueType === void 0 ? void 0 : _valueType.toArray()) || [];\n var values = [];\n for (var i = 0; i < value.length; i++) {\n var val = {\n type: valueType[i],\n value: value[i]\n };\n values.push(val);\n if (valueSrc[i] == \"field\") {\n var secondField = value[i];\n if (meta.usedFields.indexOf(secondField) == -1) meta.usedFields.push(secondField);\n }\n }\n var operatorOptions = options ? options.toJS() : null;\n if (operatorOptions && !Object.keys(operatorOptions).length) operatorOptions = null;\n var ruleQuery = {\n id: id,\n fieldName: fieldName,\n type: fieldType,\n input: typeConfig.mainWidget,\n operator: operator\n };\n if (operatorOptions) ruleQuery.operatorOptions = operatorOptions;\n ruleQuery.values = values;\n return ruleQuery;\n};","export var settings = {\n reverseOperatorsForNot: false,\n canShortMongoQuery: true,\n fixJsonLogicDateCompareOp: false,\n // todo: change to true in next minor/major version\n formatField: function formatField(field, parts, label2, fieldDefinition, config, isForDisplay) {\n if (isForDisplay) return label2;else return field;\n },\n caseValueField: {\n type: \"case_value\"\n },\n fieldSources: [\"field\"],\n keepInputOnChangeFieldSrc: true,\n fieldItemKeysForSearch: [\"label\", \"path\", \"altLabel\", \"grouplabel\"],\n listKeysForSearch: [\"title\", \"value\"],\n valueSourcesInfo: {\n value: {}\n },\n fieldSeparator: \".\",\n fieldSeparatorDisplay: \".\",\n canReorder: true,\n canRegroup: true,\n canDeleteLocked: false,\n canLeaveEmptyGroup: true,\n shouldCreateEmptyGroup: false,\n exportPreserveGroups: false,\n removeEmptyGroupsOnLoad: true,\n removeEmptyRulesOnLoad: true,\n removeIncompleteRulesOnLoad: false,\n removeInvalidMultiSelectValuesOnLoad: true,\n showErrorMessage: false,\n setOpOnChangeField: [\"keep\", \"default\"],\n // 'default' (default if present), 'keep' (keep prev from last field), 'first', 'none'\n groupOperators: [\"some\", \"all\", \"none\"],\n defaultConjunction: \"AND\",\n // todo: deprecated, remove this in favour of defaultConjunction\n defaultGroupConjunction: \"AND\",\n // localization\n locale: {\n moment: \"en\"\n },\n valueLabel: \"Value\",\n valuePlaceholder: \"Value\",\n fieldLabel: \"Field\",\n operatorLabel: \"Operator\",\n funcLabel: \"Function\",\n fieldPlaceholder: \"Select field\",\n funcPlaceholder: \"Select function\",\n operatorPlaceholder: \"Select operator\",\n lockLabel: \"Lock\",\n lockedLabel: \"Locked\",\n deleteLabel: \"Delete\",\n addGroupLabel: \"Add group\",\n addCaseLabel: \"Add condition\",\n addDefaultCaseLabel: \"Add default condition\",\n defaultCaseLabel: \"Default:\",\n addRuleLabel: \"Add rule\",\n addSubRuleLabel: \"Add sub rule\",\n addSubGroupLabel: \"Add sub group\",\n delGroupLabel: \"Delete\",\n notLabel: \"Not\",\n fieldSourcesPopupTitle: \"Select source\",\n valueSourcesPopupTitle: \"Select value source\",\n removeRuleConfirmOptions: null,\n removeGroupConfirmOptions: null,\n loadMoreLabel: \"Load more...\",\n loadingMoreLabel: \"Loading more...\",\n typeToSearchLabel: \"Type to search\",\n loadingLabel: \"Loading...\",\n notFoundLabel: \"Not found\"\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport JL from \"json-logic-js\";\nimport moment from \"moment\";\nexport function applyJsonLogic(logic, data) {\n return JL.apply(logic, data);\n}\nexport function addJsonLogicOperation(name, op) {\n var jl = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : JL;\n return jl.add_operation(name, op);\n}\nexport var customJsonLogicOperations = {\n CALL: function CALL(fn, ctx) {\n for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n args[_key - 2] = arguments[_key];\n }\n return fn.call.apply(fn, [ctx].concat(args));\n },\n JSX: function JSX(type, props) {\n return {\n type: type,\n props: props\n };\n },\n mergeObjects: function mergeObjects(obj1, obj2) {\n return _objectSpread(_objectSpread({}, obj1), obj2);\n },\n fromEntries: function fromEntries(entries) {\n return Object.fromEntries(entries);\n },\n //\n // string\n //\n toLowerCase: function toLowerCase(str) {\n return str.toLowerCase();\n },\n toUpperCase: function toUpperCase(str) {\n return str.toUpperCase();\n },\n strlen: function strlen(str) {\n return (str === null || str === void 0 ? void 0 : str.length) || 0;\n },\n regexTest: function regexTest(str, pattern, flags) {\n return (str === null || str === void 0 ? void 0 : str.match(new RegExp(pattern, flags))) != null;\n },\n //\n // date / datetime\n //\n \"date==\": function date(a, b) {\n if (a == null || b == null) {\n return false;\n }\n var dateA = moment(a).startOf(\"day\");\n var dateB = moment(b).startOf(\"day\");\n return dateA.isSame(dateB);\n },\n \"date!=\": function date(a, b) {\n return !customJsonLogicOperations[\"date==\"](a, b);\n },\n \"datetime==\": function datetime(a, b) {\n if (a == null || b == null) {\n return false;\n }\n var dateA = moment(a);\n var dateB = moment(b);\n return dateA.isSame(dateB);\n },\n \"datetime!=\": function datetime(a, b) {\n return !customJsonLogicOperations[\"datetime==\"](a, b);\n },\n now: function now() {\n return new Date();\n },\n today: function today() {\n var start = moment().startOf(\"day\");\n var y = start.year();\n var m = start.month();\n var d = start.date();\n // tip: we use UTC to return same result as eg. new Date(\"2025-05-16\")\n var startUtc = moment.utc([y, m, d]);\n return startUtc.toDate();\n },\n start_of_today: function start_of_today() {\n return moment().startOf(\"day\").toDate();\n },\n date_add: function date_add(date, val, dim) {\n return moment(date).add(val, dim).toDate();\n },\n datetime_add: function datetime_add(datetime, val, dim) {\n return moment(datetime).add(val, dim).toDate();\n },\n datetime_truncate: function datetime_truncate(datetime, dim) {\n return moment(datetime).startOf(dim).toDate();\n }\n};\nexport function addRequiredJsonLogicOperations() {\n var jl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : JL;\n for (var k in customJsonLogicOperations) {\n addJsonLogicOperation(k, customJsonLogicOperations[k], jl);\n }\n}\n\n/**\n * @deprecated\n */\nexport var jsonLogicFormatConcat = function jsonLogicFormatConcat(parts) {\n if (parts && Array.isArray(parts) && parts.length) {\n return parts.map(function (part) {\n var _part$value;\n return (_part$value = part === null || part === void 0 ? void 0 : part.value) !== null && _part$value !== void 0 ? _part$value : part;\n }).filter(function (r) {\n return r != undefined;\n });\n } else {\n return undefined;\n }\n};\n\n/**\n * @deprecated\n */\nexport var jsonLogicImportConcat = function jsonLogicImportConcat(val) {\n if (val == undefined) return undefined;\n var errors = [];\n var parts = Array.isArray(val) ? val : [val];\n var res = parts.filter(function (v) {\n return v != undefined;\n }).map(function (v) {\n return {\n type: \"property\",\n value: val\n };\n });\n if (errors.length) {\n throw new Error(errors.join(\"\\n\"));\n }\n return res;\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\n//import { customJsonLogicOperations } from \"../utils/jsonLogic\";\n\n// Tip: search for `customJsonLogicOperations` in codebase to see custom JL funcs we use in `jsonLogicCustomOps`\n\nvar dateDimListValues = {\n day: \"day\",\n week: \"week\",\n month: \"month\",\n year: \"year\"\n};\nvar dateDimDefault = \"day\";\nvar datetimeDimListValues = _objectSpread({\n hour: \"hour\",\n minute: \"minute\",\n second: \"second\"\n}, dateDimListValues);\nvar datetimeDimDefault = \"day\";\nvar NOW = {\n label: \"Now\",\n returnType: \"datetime\",\n jsonLogicCustomOps: {\n now: {}\n },\n // jsonLogic: \"now\",\n jsonLogic: function jsonLogic() {\n return {\n now: []\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n if (v[\"now\"]) {\n return [];\n }\n },\n //spelFunc: \"new java.util.Date()\",\n spelFunc: \"T(java.time.LocalDateTime).now()\",\n sqlFormatFunc: function sqlFormatFunc() {\n return \"NOW()\";\n },\n sqlFunc: \"NOW\",\n mongoFormatFunc: function mongoFormatFunc() {\n return {\n \"$toDate\": \"$$NOW\"\n };\n // return {\n // \"$dateFromString\": {\n // \"dateString\": this.utils.moment(new Date()).format(\"YYYY-MM-DD HH:mm:ss\"),\n // \"format\": \"%Y-%m-%d %H:%M:%S\"\n // }\n // };\n },\n formatFunc: function formatFunc() {\n return \"NOW\";\n }\n};\n\n// todo: add option like `resolveWithValueOnExport: false` for NOW, TODAY, START_OF_TODAY (issue #1234) ???\n\nvar TODAY = {\n label: \"Today\",\n returnType: \"date\",\n //jsonLogic: \"today\",\n jsonLogicCustomOps: {\n today: {}\n },\n jsonLogic: function jsonLogic() {\n return {\n today: []\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n if (v[\"today\"]) {\n return [];\n }\n },\n spelFunc: \"T(java.time.LocalDate).now()\",\n sqlFormatFunc: function sqlFormatFunc() {\n return \"CURDATE()\";\n },\n sqlFunc: \"CURDATE\",\n mongoFormatFunc: function mongoFormatFunc() {\n return {\n \"$dateTrunc\": {\n // or \"date\": \"$$NOW\",\n \"date\": {\n \"$toDate\": \"$$NOW\"\n },\n \"unit\": \"day\"\n }\n };\n // return {\n // \"$dateFromString\": {\n // \"dateString\": this.utils.moment(new Date()).format(\"YYYY-MM-DD\"),\n // \"format\": \"%Y-%m-%d\"\n // }\n // };\n },\n formatFunc: function formatFunc() {\n return \"TODAY\";\n }\n};\nvar START_OF_TODAY = {\n label: \"Start of today\",\n returnType: \"datetime\",\n jsonLogicCustomOps: {\n start_of_today: {}\n },\n // jsonLogic: \"start_of_today\",\n jsonLogic: function jsonLogic() {\n return {\n start_of_today: []\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n if (v[\"start_of_today\"]) {\n return [];\n }\n },\n spelFunc: \"T(java.time.LocalDateTime).now().truncatedTo(T(java.time.temporal.ChronoUnit).DAYS)\",\n spelImport: function spelImport(spel) {\n var _obj$obj, _oneArg$children, _oneArg$children2, _oneArgType$cls;\n // spel = {\n // \"type\": \"!func\",\n // \"methodName\": \"truncatedTo\",\n // \"args\": [\n // {\n // \"type\": \"compound\",\n // \"children\": [\n // { \"type\": \"!type\", \"cls\": [ \"java\", \"time\", \"temporal\", \"ChronoUnit\" ] },\n // { \"type\": \"property\", \"val\": \"DAYS\" }\n // ]\n // }\n // ],\n // \"obj\": {\n // \"type\": \"!func\",\n // \"methodName\": \"now\",\n // \"obj\": {\n // \"type\": \"!type\",\n // \"cls\": [ \"java\", \"time\", \"LocalDateTime\" ]\n // }\n // }\n // }\n var obj = spel.obj,\n args = spel.args;\n var isTruncate = (spel === null || spel === void 0 ? void 0 : spel.type) === \"!func\" && (spel === null || spel === void 0 ? void 0 : spel.methodName) === \"truncatedTo\";\n var isObjNow = (obj === null || obj === void 0 ? void 0 : obj.methodName) === \"now\" && (obj === null || obj === void 0 || (_obj$obj = obj.obj) === null || _obj$obj === void 0 || (_obj$obj = _obj$obj.cls) === null || _obj$obj === void 0 ? void 0 : _obj$obj.join(\".\")) === \"java.time.LocalDateTime\";\n var argsLength = (args === null || args === void 0 ? void 0 : args.length) || 0;\n var oneArg = args === null || args === void 0 ? void 0 : args[0];\n var oneArgType = oneArg === null || oneArg === void 0 || (_oneArg$children = oneArg.children) === null || _oneArg$children === void 0 ? void 0 : _oneArg$children[0];\n var oneArgProperty = oneArg === null || oneArg === void 0 || (_oneArg$children2 = oneArg.children) === null || _oneArg$children2 === void 0 ? void 0 : _oneArg$children2[1];\n var oneArgCls = (oneArgType === null || oneArgType === void 0 ? void 0 : oneArgType.type) === \"!type\" && (oneArgType === null || oneArgType === void 0 || (_oneArgType$cls = oneArgType.cls) === null || _oneArgType$cls === void 0 ? void 0 : _oneArgType$cls.join(\".\"));\n var oneArgConst = (oneArgProperty === null || oneArgProperty === void 0 ? void 0 : oneArgProperty.type) === \"property\" && (oneArgProperty === null || oneArgProperty === void 0 ? void 0 : oneArgProperty.val);\n var isArgDays = argsLength === 1 && oneArg.type === \"compound\" && oneArgCls === \"java.time.temporal.ChronoUnit\" && oneArgConst === \"DAYS\";\n if (isObjNow && isTruncate && isArgDays) {\n return {};\n }\n },\n sqlFormatFunc: function sqlFormatFunc() {\n return \"DATE_FORMAT(NOW(), '%Y-%m-%d 00:00:00')\";\n },\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n var _sqlObj$children;\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"DATE_FORMAT\" && ((_sqlObj$children = sqlObj.children) === null || _sqlObj$children === void 0 ? void 0 : _sqlObj$children.length) === 2) {\n var _sqlObj$children2 = _slicedToArray(sqlObj.children, 2),\n date = _sqlObj$children2[0],\n format = _sqlObj$children2[1];\n if ((format === null || format === void 0 ? void 0 : format.value) == \"%Y-%m-%d 00:00:00\" && (date === null || date === void 0 ? void 0 : date.func) == \"NOW\") {\n return {\n args: {}\n };\n }\n }\n },\n mongoFormatFunc: function mongoFormatFunc() {\n return {\n \"$dateTrunc\": {\n \"date\": {\n \"$toDate\": \"$$NOW\"\n },\n \"unit\": \"day\"\n }\n };\n // return {\n // \"$dateFromString\": {\n // \"dateString\": this.utils.moment(new Date()).format(\"YYYY-MM-DD\"),\n // \"format\": \"%Y-%m-%d\"\n // }\n // };\n },\n formatFunc: function formatFunc() {\n return \"START_OF_TODAY\";\n }\n};\nvar TRUNCATE_DATETIME = {\n label: \"Truncate\",\n returnType: \"datetime\",\n renderBrackets: [\"\", \"\"],\n renderSeps: [\"to\"],\n jsonLogicCustomOps: {\n datetime_truncate: {}\n },\n jsonLogic: function jsonLogic(_ref) {\n var date = _ref.date,\n dim = _ref.dim;\n return {\n \"datetime_truncate\": [date, dim]\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n if (v[\"datetime_truncate\"]) {\n var date = v[\"datetime_truncate\"][0];\n var dim = v[\"datetime_truncate\"][1];\n return [date, dim];\n }\n },\n spelFormatFunc: function spelFormatFunc(_ref2) {\n var date = _ref2.date,\n dim = _ref2.dim;\n var dimPluralUppercase = (dim.charAt(0).toUpperCase() + dim.slice(1) + \"s\").toUpperCase();\n return \"\".concat(date, \".truncatedTo(T(java.time.temporal.ChronoUnit).\").concat(dimPluralUppercase, \")\");\n },\n spelImport: function spelImport(spel) {\n var _oneArg$children3, _oneArg$children4, _oneArgType$cls2;\n // spel = {\n // \"type\": \"!func\",\n // \"methodName\": \"truncatedTo\",\n // \"args\": [\n // {\n // \"type\": \"compound\",\n // \"children\": [\n // { \"type\": \"!type\", \"cls\": [ \"java\", \"time\", \"temporal\", \"ChronoUnit\" ] },\n // { \"type\": \"property\", \"val\": \"DAYS\" }\n // ]\n // }\n // ],\n // }\n var args = spel.args;\n var isTruncate = (spel === null || spel === void 0 ? void 0 : spel.type) === \"!func\" && (spel === null || spel === void 0 ? void 0 : spel.methodName) === \"truncatedTo\";\n var argsLength = (args === null || args === void 0 ? void 0 : args.length) || 0;\n var oneArg = args === null || args === void 0 ? void 0 : args[0];\n var oneArgType = oneArg === null || oneArg === void 0 || (_oneArg$children3 = oneArg.children) === null || _oneArg$children3 === void 0 ? void 0 : _oneArg$children3[0];\n var oneArgProperty = oneArg === null || oneArg === void 0 || (_oneArg$children4 = oneArg.children) === null || _oneArg$children4 === void 0 ? void 0 : _oneArg$children4[1];\n var oneArgCls = (oneArgType === null || oneArgType === void 0 ? void 0 : oneArgType.type) === \"!type\" && (oneArgType === null || oneArgType === void 0 || (_oneArgType$cls2 = oneArgType.cls) === null || _oneArgType$cls2 === void 0 ? void 0 : _oneArgType$cls2.join(\".\"));\n var oneArgConst = (oneArgProperty === null || oneArgProperty === void 0 ? void 0 : oneArgProperty.type) === \"property\" && (oneArgProperty === null || oneArgProperty === void 0 ? void 0 : oneArgProperty.val);\n var isArgDays = argsLength === 1 && oneArg.type === \"compound\" && oneArgCls === \"java.time.temporal.ChronoUnit\" && oneArgConst;\n var dim = oneArgConst.toLowerCase().substring(0, oneArgConst.length - 1);\n if (isTruncate && isArgDays) {\n return {\n date: spel.obj,\n dim: {\n type: \"string\",\n val: dim\n }\n };\n }\n },\n // MySQL\n sqlFormatFunc: function sqlFormatFunc(_ref3, sqlDialect) {\n var date = _ref3.date,\n dim = _ref3.dim;\n if (!sqlDialect || sqlDialect === \"MySQL\") {\n dim = dim.replace(/^'|'$/g, \"\");\n switch (dim) {\n case \"second\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-%m-%d %H:%i:%s')\");\n case \"minute\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-%m-%d %H:%i:00')\");\n case \"hour\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-%m-%d %H:00:00')\");\n case \"day\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-%m-%d 00:00:00')\");\n case \"week\":\n return \"DATE_SUB(DATE_FORMAT(\".concat(date, \", '%Y-%m-%d 00:00:00'), INTERVAL WEEKDAY(\").concat(date, \") DAY)\");\n case \"month\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-%m-01 00:00:00')\");\n case \"year\":\n return \"DATE_FORMAT(\".concat(date, \", '%Y-01-01 00:00:00')\");\n }\n } else if (sqlDialect === \"PostgreSQL\") {\n return \"date_trunc(\".concat(dim, \", \").concat(date, \")\");\n }\n },\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n if (!sqlDialect || sqlDialect === \"MySQL\") {\n var _sqlObj$children3, _sqlObj$children5;\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"DATE_FORMAT\" && ((_sqlObj$children3 = sqlObj.children) === null || _sqlObj$children3 === void 0 ? void 0 : _sqlObj$children3.length) === 2) {\n var _sqlObj$children4 = _slicedToArray(sqlObj.children, 2),\n date = _sqlObj$children4[0],\n format = _sqlObj$children4[1];\n var dim;\n switch (format === null || format === void 0 ? void 0 : format.value) {\n case \"%Y-%m-%d %H:%i:%s\":\n dim = \"second\";\n break;\n case \"%Y-%m-%d %H:%i:00\":\n dim = \"minute\";\n break;\n case \"%Y-%m-%d %H:00:00\":\n dim = \"hour\";\n break;\n case \"%Y-%m-%d 00:00:00\":\n dim = \"day\";\n break;\n case \"%Y-%m-01 00:00:00\":\n dim = \"month\";\n break;\n case \"%Y-01-01 00:00:00\":\n dim = \"year\";\n }\n if (dim) {\n return {\n args: {\n date: date,\n dim: dim\n }\n };\n }\n } else if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"DATE_SUB\" && ((_sqlObj$children5 = sqlObj.children) === null || _sqlObj$children5 === void 0 ? void 0 : _sqlObj$children5.length) === 2) {\n var _dateFormat$children;\n var _sqlObj$children6 = _slicedToArray(sqlObj.children, 2),\n dateFormat = _sqlObj$children6[0],\n interval = _sqlObj$children6[1];\n var isFormat = (dateFormat === null || dateFormat === void 0 ? void 0 : dateFormat.func) === \"DATE_FORMAT\" && ((_dateFormat$children = dateFormat.children) === null || _dateFormat$children === void 0 ? void 0 : _dateFormat$children.length) === 2;\n var isIntervalDay = interval._type == \"interval\" && interval.unit === \"day\";\n if (isFormat && isIntervalDay) {\n var _dateFormat$children2 = _slicedToArray(dateFormat.children, 2),\n _date = _dateFormat$children2[0],\n _format = _dateFormat$children2[1];\n if ((_format === null || _format === void 0 ? void 0 : _format.value) === \"%Y-%m-%d 00:00:00\") {\n return {\n args: {\n date: _date,\n dim: \"week\"\n }\n };\n }\n }\n }\n return undefined;\n } else if (sqlDialect === \"PostgreSQL\") {\n var _sqlObj$children7;\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"date_trunc\" && ((_sqlObj$children7 = sqlObj.children) === null || _sqlObj$children7 === void 0 ? void 0 : _sqlObj$children7.length) === 2) {\n var _sqlObj$children8 = _slicedToArray(sqlObj.children, 2),\n _dim = _sqlObj$children8[0],\n _date2 = _sqlObj$children8[1];\n return {\n args: {\n date: _date2,\n dim: _dim.value\n }\n };\n }\n }\n },\n mongoFormatFunc: function mongoFormatFunc(_ref4) {\n var date = _ref4.date,\n dim = _ref4.dim;\n return {\n \"$dateTrunc\": {\n \"date\": date,\n \"unit\": dim\n }\n };\n },\n formatFunc: function formatFunc(_ref5) {\n var date = _ref5.date,\n dim = _ref5.dim;\n return \"TRUNCATE \".concat(date, \" TO \").concat(dim);\n },\n args: {\n date: {\n label: \"Datetime\",\n type: \"datetime\",\n defaultValue: {\n func: \"NOW\",\n args: []\n },\n valueSources: [\"value\", \"field\", \"func\"],\n escapeForFormat: true\n },\n dim: {\n label: \"Dimension\",\n type: \"select\",\n defaultValue: datetimeDimDefault,\n valueSources: [\"value\"],\n mainWidgetProps: {\n customProps: {\n showSearch: false\n }\n },\n fieldSettings: {\n listValues: datetimeDimListValues\n },\n escapeForFormat: false\n }\n }\n};\nvar RELATIVE_DATETIME = {\n label: \"Relative\",\n returnType: \"datetime\",\n renderBrackets: [\"\", \"\"],\n renderSeps: [\"\", \"\", \"\"],\n spelFormatFunc: function spelFormatFunc(_ref6) {\n var date = _ref6.date,\n op = _ref6.op,\n val = _ref6.val,\n dim = _ref6.dim;\n var dimPlural = dim.charAt(0).toUpperCase() + dim.slice(1) + \"s\";\n var method = op + dimPlural;\n return \"\".concat(date, \".\").concat(method, \"(\").concat(val, \")\");\n },\n spelImport: function spelImport(spel) {\n var _spel$methodName;\n var date, op, val, dim;\n var matchRes = (_spel$methodName = spel.methodName) === null || _spel$methodName === void 0 ? void 0 : _spel$methodName.match(/^(minus|plus)(\\w+)s$/);\n if (matchRes) {\n dim = matchRes[2].toLowerCase();\n op = matchRes[1];\n if ([\"minus\", \"plus\"].includes(op)) {\n if (Object.keys(datetimeDimListValues).includes(dim)) {\n op = {\n type: \"string\",\n val: op\n };\n dim = {\n type: \"string\",\n val: dim\n };\n val = spel.args[0];\n date = spel.obj;\n return {\n date: date,\n op: op,\n val: val,\n dim: dim\n };\n }\n }\n }\n },\n jsonLogic: function jsonLogic(_ref7) {\n var date = _ref7.date,\n op = _ref7.op,\n val = _ref7.val,\n dim = _ref7.dim;\n return {\n \"datetime_add\": [date, val * (op == \"minus\" ? -1 : +1), dim]\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n if (v[\"datetime_add\"]) {\n var date = v[\"datetime_add\"][0];\n var val = Math.abs(v[\"datetime_add\"][1]);\n var op = v[\"datetime_add\"][1] >= 0 ? \"plus\" : \"minus\";\n var dim = v[\"datetime_add\"][2];\n return [date, op, val, dim];\n }\n },\n jsonLogicCustomOps: {\n datetime_add: {}\n },\n // MySQL\n //todo: other SQL dialects?\n sqlFormatFunc: function sqlFormatFunc(_ref8) {\n var date = _ref8.date,\n op = _ref8.op,\n val = _ref8.val,\n dim = _ref8.dim;\n return \"DATE_ADD(\".concat(date, \", INTERVAL \").concat(parseInt(val) * (op == \"minus\" ? -1 : +1), \" \").concat(dim.replace(/^'|'$/g, \"\"), \")\");\n },\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n var _sqlObj$children9;\n if ([\"DATE_ADD\", \"DATE_SUB\"].includes(sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) && ((_sqlObj$children9 = sqlObj.children) === null || _sqlObj$children9 === void 0 ? void 0 : _sqlObj$children9.length) === 2) {\n var _sqlObj$children10 = _slicedToArray(sqlObj.children, 2),\n date = _sqlObj$children10[0],\n interval = _sqlObj$children10[1];\n if (interval._type == \"interval\") {\n return {\n args: {\n date: date,\n op: (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"DATE_ADD\" ? \"plus\" : \"minus\",\n val: interval.value,\n dim: interval.unit\n }\n };\n }\n }\n },\n mongoFormatFunc: function mongoFormatFunc(_ref9) {\n var date = _ref9.date,\n op = _ref9.op,\n val = _ref9.val,\n dim = _ref9.dim;\n return {\n \"$dateAdd\": {\n \"startDate\": date,\n \"unit\": dim,\n \"amount\": val * (op == \"minus\" ? -1 : +1)\n }\n };\n },\n formatFunc: function formatFunc(_ref10) {\n var date = _ref10.date,\n op = _ref10.op,\n val = _ref10.val,\n dim = _ref10.dim;\n return !val ? date : \"\".concat(date, \" \").concat(op == \"minus\" ? \"-\" : \"+\", \" \").concat(val, \" \").concat(dim);\n },\n args: {\n date: {\n label: \"Datetime\",\n type: \"datetime\",\n defaultValue: {\n func: \"NOW\",\n args: []\n },\n valueSources: [\"value\", \"field\", \"func\"],\n escapeForFormat: true\n },\n op: {\n label: \"Op\",\n type: \"select\",\n defaultValue: \"plus\",\n valueSources: [\"value\"],\n mainWidgetProps: {\n customProps: {\n showSearch: false\n }\n },\n fieldSettings: {\n listValues: {\n plus: \"+\",\n minus: \"-\"\n }\n },\n escapeForFormat: false\n },\n val: {\n label: \"Value\",\n type: \"number\",\n fieldSettings: {\n min: 0\n },\n defaultValue: 0,\n valueSources: [\"value\"],\n escapeForFormat: false\n },\n dim: {\n label: \"Dimension\",\n type: \"select\",\n defaultValue: datetimeDimDefault,\n valueSources: [\"value\"],\n mainWidgetProps: {\n customProps: {\n showSearch: false\n }\n },\n fieldSettings: {\n listValues: datetimeDimListValues\n },\n escapeForFormat: false\n }\n }\n};\nvar RELATIVE_DATE = _objectSpread(_objectSpread({}, RELATIVE_DATETIME), {}, {\n label: \"Relative\",\n returnType: \"date\",\n jsonLogic: function jsonLogic(_ref11) {\n var date = _ref11.date,\n op = _ref11.op,\n val = _ref11.val,\n dim = _ref11.dim;\n return {\n \"date_add\": [date, val * (op == \"minus\" ? -1 : +1), dim]\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n var date = v[\"date_add\"][0];\n var val = Math.abs(v[\"date_add\"][1]);\n var op = v[\"date_add\"][1] >= 0 ? \"plus\" : \"minus\";\n var dim = v[\"date_add\"][2];\n return [date, op, val, dim];\n },\n jsonLogicCustomOps: {\n date_add: {}\n },\n args: {\n date: _objectSpread(_objectSpread({}, RELATIVE_DATETIME.args.date), {}, {\n label: \"Date\",\n type: \"date\",\n defaultValue: {\n func: \"TODAY\",\n args: []\n }\n }),\n op: _objectSpread({}, RELATIVE_DATETIME.args.op),\n val: _objectSpread({}, RELATIVE_DATETIME.args.val),\n dim: _objectSpread(_objectSpread({}, RELATIVE_DATETIME.args.dim), {}, {\n defaultValue: dateDimDefault,\n fieldSettings: {\n listValues: dateDimListValues\n }\n })\n }\n});\n\n// todo: add DATEDIFF (issue #142)\n\nvar LOWER = {\n label: \"Lowercase\",\n mongoFunc: \"$toLower\",\n jsonLogic: \"toLowerCase\",\n sqlFunc: \"LOWER\",\n spelFunc: \"${str}.toLowerCase()\",\n //jsonLogicIsMethod: true, // Removed in JsonLogic 2.x due to Prototype Pollution\n jsonLogicCustomOps: {\n toLowerCase: {}\n },\n returnType: \"text\",\n args: {\n str: {\n label: \"String\",\n type: \"text\",\n valueSources: [\"value\", \"field\", \"func\"]\n }\n }\n};\nvar UPPER = {\n label: \"Uppercase\",\n mongoFunc: \"$toUpper\",\n jsonLogic: \"toUpperCase\",\n sqlFunc: \"UPPER\",\n spelFunc: \"${str}.toUpperCase()\",\n //jsonLogicIsMethod: true, // Removed in JsonLogic 2.x due to Prototype Pollution\n jsonLogicCustomOps: {\n toUpperCase: {}\n },\n returnType: \"text\",\n args: {\n str: {\n label: \"String\",\n type: \"text\",\n valueSources: [\"value\", \"field\", \"func\"]\n }\n }\n};\nvar LINEAR_REGRESSION = {\n label: \"Linear regression\",\n returnType: \"number\",\n formatFunc: function formatFunc(_ref12, _) {\n var coef = _ref12.coef,\n bias = _ref12.bias,\n val = _ref12.val;\n return \"(\".concat(coef, \" * \").concat(val, \" + \").concat(bias, \")\");\n },\n sqlFormatFunc: function sqlFormatFunc(_ref13) {\n var coef = _ref13.coef,\n bias = _ref13.bias,\n val = _ref13.val;\n return \"(\".concat(coef, \" * \").concat(val, \" + \").concat(bias, \")\");\n },\n spelFormatFunc: function spelFormatFunc(_ref14) {\n var coef = _ref14.coef,\n bias = _ref14.bias,\n val = _ref14.val;\n return \"(\".concat(coef, \" * \").concat(val, \" + \").concat(bias, \")\");\n },\n spelImport: function spelImport(spel) {\n var coef, val, bias, a;\n if (spel.type === \"op-plus\") {\n var _spel$children = _slicedToArray(spel.children, 2);\n a = _spel$children[0];\n bias = _spel$children[1];\n if (a.type === \"op-multiply\") {\n var _a$children = _slicedToArray(a.children, 2);\n coef = _a$children[0];\n val = _a$children[1];\n return {\n coef: coef,\n val: val,\n bias: bias\n };\n }\n }\n },\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n var _sqlObj$children11;\n if ([\"+\"].includes(sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) && ((_sqlObj$children11 = sqlObj.children) === null || _sqlObj$children11 === void 0 ? void 0 : _sqlObj$children11.length) === 2) {\n var _left$children;\n var _sqlObj$children12 = _slicedToArray(sqlObj.children, 2),\n left = _sqlObj$children12[0],\n bias = _sqlObj$children12[1];\n if ([\"*\"].includes(left === null || left === void 0 ? void 0 : left.operator) && ((_left$children = left.children) === null || _left$children === void 0 ? void 0 : _left$children.length) === 2) {\n var _left$children2 = _slicedToArray(left.children, 2),\n coef = _left$children2[0],\n val = _left$children2[1];\n return {\n args: {\n coef: coef,\n val: val,\n bias: bias\n }\n };\n }\n }\n },\n mongoFormatFunc: function mongoFormatFunc(_ref15) {\n var coef = _ref15.coef,\n bias = _ref15.bias,\n val = _ref15.val;\n return {\n \"$sum\": [{\n \"$multiply\": [coef, val]\n }, bias]\n };\n },\n jsonLogic: function jsonLogic(_ref16) {\n var coef = _ref16.coef,\n bias = _ref16.bias,\n val = _ref16.val;\n return {\n \"+\": [{\n \"*\": [coef, val]\n }, bias]\n };\n },\n jsonLogicImport: function jsonLogicImport(v) {\n var coef = v[\"+\"][0][\"*\"][0];\n var val = v[\"+\"][0][\"*\"][1];\n var bias = v[\"+\"][1];\n return [coef, val, bias];\n },\n renderBrackets: [\"\", \"\"],\n renderSeps: [\" * \", \" + \"],\n args: {\n coef: {\n label: \"Coef\",\n type: \"number\",\n defaultValue: 1,\n valueSources: [\"value\"]\n },\n val: {\n label: \"Value\",\n type: \"number\",\n valueSources: [\"value\", \"field\"]\n },\n bias: {\n label: \"Bias\",\n type: \"number\",\n defaultValue: 0,\n valueSources: [\"value\"]\n }\n }\n};\nexport { LOWER, UPPER, NOW, TODAY, START_OF_TODAY, RELATIVE_DATETIME, TRUNCATE_DATETIME, RELATIVE_DATE, LINEAR_REGRESSION };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport merge from \"lodash/merge\";\nimport pick from \"lodash/pick\";\nimport { isJsonLogic, isJSX, isDirtyJSX, cleanJSX, shallowEqual, isObject, hasSafeOwnProperty } from \"./stuff\";\nimport clone from \"clone\";\nimport JL from \"json-logic-js\";\nimport { addRequiredJsonLogicOperations, applyJsonLogic } from \"./jsonLogicUtils\";\nimport * as BasicFuncs from \"../config/funcs\";\nimport { getFieldRawConfig, configKeys } from \"./configUtils\";\n\n// Add new operations for JsonLogic\naddRequiredJsonLogicOperations();\nexport { isJSX, isDirtyJSX, cleanJSX, applyJsonLogic };\nfunction applyJsonLogicWithPath(logic, data, path) {\n var ret;\n try {\n ret = JL.apply(logic, data);\n } catch (e) {\n e.message = \"\".concat(path.join(\".\"), \" :: \").concat(e.message);\n throw e;\n }\n return ret;\n}\nfunction callContextFn(_this, fn, args, path) {\n var ret;\n try {\n ret = fn.call.apply(fn, [_this].concat(_toConsumableArray(args)));\n } catch (e) {\n e.message = \"\".concat(path.join(\".\"), \" :: \").concat(e.message);\n throw e;\n }\n return ret;\n}\n\n// type: \n// x - iterate (with nesting `subfields`)\n// \"r\" - RenderedReactElement\n// Will be compiled with renderReactElement() into React element rendered with `React.createElement` (`ctx.RCE`)\n// \"rf\" - JsonLogicFunction/string to render React\n// JL data is { props, ctx }\n// Should return {type, props} or string, where type or string - React component\n// Can use { JSX: [\"SomeComponent\", {var: \"props\"}] } or just return \"SomeComponent\"\n// Returned component will be searched in ctx.components/ctx.W/ctx.O, see getReactComponentFromCtx()\n// Will be compiled with compileJsonLogicReact() into function with args (props, ctx) that will return renderReactElement()\n// \"f\" - JsonLogicFunction/string\n// JL data is { args, ctx } plus named args defined in `args` inside `compileMeta`\n// Can use { CALL: [ {var: \"ctx.someFunc\"}, null, {var: \"args[0]\" }] } \n// If string is passed, it's a path to function in ctx (with dot notation)\n// Will be compiled with compileJsonLogic() into function with any args and `this` should be `ctx`\n\nvar compileMetaFieldSettings = {\n asyncFetch: {\n type: \"f\",\n args: [\"searchOrValues\", \"offset\"]\n },\n labelYes: {\n type: \"r\"\n },\n labelNo: {\n type: \"r\"\n },\n marks: {\n type: \"r\",\n isArr: true\n },\n validateValue: {\n type: \"f\",\n args: [\"val\", \"fieldSettings\", \"op\", \"opDef\", \"rightFieldDef\"]\n }\n};\nvar compileMetaWidget = _objectSpread(_objectSpread({}, compileMetaFieldSettings), {}, {\n factory: {\n type: \"rf\"\n },\n formatValue: {\n type: \"f\",\n args: [\"val\", \"fieldDef\", \"wgtDef\", \"isForDisplay\", \"op\", \"opDef\", \"rightFieldDef\"]\n },\n sqlFormatValue: {\n type: \"f\",\n args: [\"val\", \"fieldDef\", \"wgtDef\", \"op\", \"opDef\", \"rightFieldDef\", \"sqlDialect\"]\n },\n spelFormatValue: {\n type: \"f\",\n args: [\"val\", \"fieldDef\", \"wgtDef\", \"op\", \"opDef\", \"rightFieldDef\"]\n },\n spelImportValue: {\n type: \"f\",\n args: [\"val\", \"wgtDef\", \"args\"]\n },\n sqlImport: {\n type: \"f\",\n args: [\"sqlObj\", \"wgtDef\", \"sqlDialect\"]\n },\n mongoFormatValue: {\n type: \"f\",\n args: [\"val\", \"fieldDef\", \"wgtDef\", \"op\", \"opDef\"]\n },\n elasticSearchFormatValue: {\n type: \"f\",\n args: [\"queryType\", \"val\", \"op\", \"field\", \"config\"]\n },\n jsonLogic: {\n type: \"f\",\n args: [\"val\", \"fieldDef\", \"wgtDef\", \"op\", \"opDef\"]\n },\n jsonLogicImport: {\n type: \"f\",\n args: [\"val\", \"wgtDef\"]\n },\n validateValue: {\n type: \"f\",\n args: [\"val\", \"fieldSettings\", \"op\", \"opDef\", \"rightFieldDef\"]\n },\n // obsolete\n toJS: {\n type: \"f\",\n args: [\"val\"]\n }\n});\nvar compileMetaOperator = {\n options: {\n // proximity\n factory: {\n type: \"rf\"\n }\n },\n formatOp: {\n type: \"f\",\n args: [\"field\", \"op\", \"vals\", \"valueSrc\", \"valueType\", \"opDef\", \"operatorOptions\", \"isForDisplay\", \"fieldDef\"]\n },\n mongoFormatOp: {\n type: \"f\",\n args: [\"field\", \"op\", \"vals\", \"useExpr\", \"valueSrc\", \"valueType\", \"opDef\", \"operatorOptions\", \"fieldDef\"]\n },\n sqlFormatOp: {\n type: \"f\",\n args: [\"field\", \"op\", \"vals\", \"valueSrc\", \"valueType\", \"opDef\", \"operatorOptions\", \"fieldDef\"]\n },\n spelFormatOp: {\n type: \"f\",\n args: [\"field\", \"op\", \"vals\", \"valueSrc\", \"valueType\", \"opDef\", \"operatorOptions\", \"fieldDef\"]\n },\n jsonLogic: {\n type: \"f\",\n ignore: \"string\",\n args: [\"field\", \"op\", \"vals\", \"opDef\", \"operatorOptions\", \"fieldDef\", \"expectedType\", \"settings\"]\n },\n sqlImport: {\n type: \"f\",\n args: [\"sqlObj\", \"_\", \"sqlDialect\"]\n },\n elasticSearchQueryType: {\n type: \"f\",\n ignore: \"string\",\n args: [\"valueType\"]\n },\n textSeparators: {\n type: \"r\",\n isArr: true\n }\n};\nvar compileMetaConjunction = {\n formatConj: {\n type: \"f\",\n args: [\"children\", \"conj\", \"not\", \"isForDisplay\"]\n },\n sqlFormatConj: {\n type: \"f\",\n args: [\"children\", \"conj\", \"not\"]\n },\n spelFormatConj: {\n type: \"f\",\n args: [\"children\", \"conj\", \"not\", \"omitBrackets\"]\n }\n};\nvar compileMetaWidgetForType = {\n widgetProps: compileMetaWidget,\n opProps: compileMetaOperator\n};\nvar compileMetaFunc = {\n renderBrackets: {\n type: \"r\",\n isArr: true\n },\n renderSeps: {\n type: \"r\",\n isArr: true\n },\n jsonLogic: {\n type: \"f\",\n ignore: \"string\",\n args: [\"formattedArgs\"]\n },\n jsonLogicImport: {\n type: \"f\",\n args: [\"val\"]\n },\n spelImport: {\n type: \"f\",\n args: [\"spel\"]\n },\n sqlImport: {\n type: \"f\",\n args: [\"sqlObj\", \"_\", \"sqlDialect\"]\n },\n formatFunc: {\n type: \"f\",\n args: [\"formattedArgs\", \"isForDisplay\"]\n },\n sqlFormatFunc: {\n type: \"f\",\n args: [\"formattedArgs\", \"sqlDialect\"]\n },\n mongoFormatFunc: {\n type: \"f\",\n args: [\"formattedArgs\"]\n },\n spelFormatFunc: {\n type: \"f\",\n args: [\"formattedArgs\"]\n }\n};\nvar compileMetaFieldLike = _objectSpread(_objectSpread({}, compileMetaFieldSettings), {}, {\n fieldSettings: compileMetaFieldSettings\n});\nvar compileMetaField = _objectSpread(_objectSpread({}, compileMetaFieldSettings), {}, {\n fieldSettings: compileMetaFieldSettings,\n widgets: {\n x: compileMetaWidgetForType\n },\n mainWidgetProps: compileMetaWidget\n});\nvar compileMetaSettings = {\n locale: {\n mui: {\n type: \"f\",\n args: [],\n invokeWith: [],\n ignore: \"jl\"\n }\n },\n caseValueField: compileMetaField,\n canCompareFieldWithField: {\n type: \"f\",\n args: [\"leftField\", \"leftFieldConfig\", \"rightField\", \"rightFieldConfig\", \"op\"]\n },\n formatReverse: {\n type: \"f\",\n args: [\"q\", \"op\", \"reversedOp\", \"operatorDefinition\", \"revOperatorDefinition\", \"isForDisplay\"]\n },\n sqlFormatReverse: {\n type: \"f\",\n args: [\"q\"]\n },\n spelFormatReverse: {\n type: \"f\",\n args: [\"q\"]\n },\n formatField: {\n type: \"f\",\n args: [\"field\", \"parts\", \"label2\", \"fieldDefinition\", \"config\", \"isForDisplay\"]\n },\n formatSpelField: {\n type: \"f\",\n args: [\"field\", \"parentField\", \"parts\", \"partsExt\", \"fieldDefinition\", \"config\"]\n },\n formatAggr: {\n type: \"f\",\n args: [\"whereStr\", \"aggrField\", \"operator\", \"value\", \"valueSrc\", \"valueType\", \"opDef\", \"operatorOptions\", \"isForDisplay\", \"aggrFieldDef\"]\n },\n normalizeListValues: {\n type: \"f\",\n args: [\"listValues\", \"type\", \"fieldSettings\"]\n },\n renderConfirm: {\n type: \"f\",\n args: [\"props\"]\n },\n useConfirm: {\n type: \"f\",\n args: []\n },\n renderField: {\n type: \"rf\"\n },\n renderOperator: {\n type: \"rf\"\n },\n renderFunc: {\n type: \"rf\"\n },\n renderConjs: {\n type: \"rf\"\n },\n renderButton: {\n type: \"rf\"\n },\n renderIcon: {\n type: \"rf\"\n },\n renderButtonGroup: {\n type: \"rf\"\n },\n renderValueSources: {\n type: \"rf\"\n },\n renderFieldSources: {\n type: \"rf\"\n },\n renderProvider: {\n type: \"rf\"\n },\n renderSwitch: {\n type: \"rf\"\n },\n renderSwitchPrefix: {\n type: \"r\"\n },\n renderItem: {\n type: \"rf\"\n },\n renderBeforeWidget: {\n type: \"rf\"\n },\n renderAfterWidget: {\n type: \"rf\"\n },\n renderBeforeActions: {\n type: \"rf\"\n },\n renderAfterActions: {\n type: \"rf\"\n },\n renderBeforeCaseValue: {\n type: \"rf\"\n },\n renderAfterCaseValue: {\n type: \"rf\"\n },\n renderRuleError: {\n type: \"rf\"\n }\n};\nvar compileMeta = {\n fields: {\n x: compileMetaField\n },\n widgets: {\n x: compileMetaWidget\n },\n conjunctions: {\n x: compileMetaConjunction\n },\n operators: {\n x: compileMetaOperator\n },\n types: {\n x: {\n widgets: {\n x: compileMetaWidgetForType\n }\n }\n },\n funcs: {\n x: _objectSpread(_objectSpread(_objectSpread({}, compileMetaFieldLike), compileMetaFunc), {}, {\n args: {\n x: _objectSpread({}, compileMetaFieldLike)\n }\n })\n },\n settings: compileMetaSettings\n};\n\n/////////////\n\nexport var compressConfig = function compressConfig(config, baseConfig) {\n if (config.__fieldNames) {\n throw new Error(\"Don't apply `compressConfig()` to extended config\");\n }\n var zipConfig = pick(config, configKeys);\n delete zipConfig.ctx;\n var _clean2 = function _clean(target, base, path, meta) {\n if (isObject(target)) {\n if (isDirtyJSX(target)) {\n target = cleanJSX(target);\n }\n if (path[0] === \"funcs\" && !base) {\n var funcKey = path[path.length - 1];\n // todo: if there will be change in `BasicFuncs` when funcs can be nested, need to chnage code to find `base`\n base = getFieldRawConfig({\n funcs: meta.BasicFuncs\n }, funcKey, \"funcs\", \"subfields\") || undefined;\n if (base) {\n target[\"$$key\"] = funcKey;\n }\n }\n if (base !== undefined && isObject(base)) {\n for (var k in base) {\n if (Object.prototype.hasOwnProperty.call(base, k)) {\n if (!Object.keys(target).includes(k) || target[k] === undefined && base[k] !== undefined) {\n // deleted in target\n target[k] = \"$$deleted\";\n } else {\n target[k] = _clean2(target[k], base[k], [].concat(_toConsumableArray(path), [k]), meta);\n if (target[k] === undefined) {\n delete target[k];\n }\n }\n }\n }\n }\n for (var _k in target) {\n if (Object.prototype.hasOwnProperty.call(target, _k)) {\n if (!base || !Object.keys(base).includes(_k)) {\n var _base;\n // new in target\n target[_k] = _clean2(target[_k], (_base = base) === null || _base === void 0 ? void 0 : _base[_k], [].concat(_toConsumableArray(path), [_k]), meta);\n }\n if (target[_k] === undefined) {\n delete target[_k];\n }\n }\n }\n if (Object.keys(target).length === 0) {\n target = undefined;\n }\n } else if (Array.isArray(target)) {\n // don't deep compare arrays, but allow clean JSX inside array\n target.forEach(function (val, ind) {\n target[ind] = _clean2(target[ind], undefined, [].concat(_toConsumableArray(path), [ind]), meta);\n });\n }\n if (base !== undefined && shallowEqual(target, base, true)) {\n return undefined;\n }\n if (typeof target === \"function\") {\n throw new Error(\"compressConfig: function at \".concat(path.join(\".\"), \" should be converted to JsonLogic\"));\n }\n return target;\n };\n var _iterator = _createForOfIteratorHelper(configKeys),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var rootKey = _step.value;\n if (rootKey === \"ctx\") {\n // ignore\n } else if (rootKey === \"fields\") {\n // just copy\n zipConfig[rootKey] = clone(zipConfig[rootKey]);\n _clean2(zipConfig[rootKey], {}, [rootKey]);\n } else if (rootKey === \"funcs\") {\n // leave only diff for every used func\n zipConfig[rootKey] = clone(zipConfig[rootKey] || {});\n for (var k in zipConfig[rootKey]) {\n _clean2(zipConfig[rootKey][k], null, [rootKey, k], {\n BasicFuncs: BasicFuncs\n });\n }\n } else {\n // leave only diff\n zipConfig[rootKey] = clone(zipConfig[rootKey]);\n _clean2(zipConfig[rootKey], baseConfig[rootKey], [rootKey]);\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return zipConfig;\n};\nexport var decompressConfig = function decompressConfig(zipConfig, baseConfig, ctx) {\n if (!zipConfig.settings.useConfigCompress) {\n throw new Error(\"Please enable `useConfigCompress` in config settings to use decompressConfig()\");\n }\n var unzipConfig = {};\n var _mergeDeep2 = function _mergeDeep(target, mixin, path) {\n if (isObject(mixin)) {\n if (!isObject(target)) {\n target = {};\n }\n for (var k in mixin) {\n if (hasSafeOwnProperty(mixin, k)) {\n if (mixin[k] === \"$$deleted\") {\n delete target[k];\n } else {\n target[k] = _mergeDeep2(target[k], mixin[k], [].concat(_toConsumableArray(path), [k]));\n }\n }\n }\n } else if (Array.isArray(mixin)) {\n // don't merge arrays, just replace\n target = clone(mixin);\n } else {\n target = mixin;\n }\n return target;\n };\n var _resolveAndMergeDeep2 = function _resolveAndMergeDeep(target, path, meta) {\n // try to resolve by $$key and merge\n var resolved = false;\n if (isObject(target) && Object.prototype.hasOwnProperty.call(target, \"$$key\") && target[\"$$key\"]) {\n var func = getFieldRawConfig({\n funcs: meta.BasicFuncs\n }, target[\"$$key\"], \"funcs\", \"subfields\");\n if (func) {\n // deep merge func <- zip\n delete target[\"$$key\"];\n target = _mergeDeep2(clone(func), target, path);\n resolved = true;\n } else {\n throw new Error(\"decompressConfig: basic function not found by key \".concat(target[\"$$key\"], \" at \").concat(path.join(\".\")));\n }\n }\n if (!resolved) {\n if (isObject(target)) {\n // loop through object to find refs ($$key)\n for (var k in target) {\n if (Object.prototype.hasOwnProperty.call(target, k)) {\n target[k] = _resolveAndMergeDeep2(target[k], [].concat(_toConsumableArray(path), [k]), meta);\n }\n }\n } else if (Array.isArray(target)) {\n // also loop through array to find refs ($$key)\n var _iterator2 = _createForOfIteratorHelper(target),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _k2 = _step2.value;\n target[_k2] = _resolveAndMergeDeep2(target[_k2], [].concat(_toConsumableArray(path), [_k2]), meta);\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n }\n }\n return target;\n };\n var _iterator3 = _createForOfIteratorHelper(configKeys),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var rootKey = _step3.value;\n if (rootKey === \"ctx\") {\n // simple deep merge\n unzipConfig[rootKey] = merge({}, baseConfig.ctx || {}, ctx || {});\n } else if (rootKey === \"funcs\") {\n // use $$key to pick funcs from BasicFuncs\n unzipConfig[rootKey] = clone(zipConfig[rootKey] || {});\n _resolveAndMergeDeep2(unzipConfig[rootKey], [rootKey], {\n BasicFuncs: BasicFuncs\n });\n } else if (rootKey === \"fields\") {\n // just copy\n unzipConfig[rootKey] = clone(zipConfig[rootKey] || {});\n } else {\n // deep merge base <- zip\n unzipConfig[rootKey] = clone(baseConfig[rootKey] || {});\n _mergeDeep2(unzipConfig[rootKey], zipConfig[rootKey] || {}, [rootKey]);\n }\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n return unzipConfig;\n};\n\n/////////////\n\nexport var compileConfig = function compileConfig(config) {\n if (config.__compliled) {\n return config;\n }\n config = clone(config);\n var opts = {\n ctx: config.ctx\n };\n var logs = [];\n _compileConfigParts(config, config, opts, compileMeta, logs);\n //console.log(logs.join(\"\\n\"));\n\n Object.defineProperty(config, \"__compliled\", {\n enumerable: false,\n writable: false,\n value: true\n });\n return config;\n};\nfunction _compileConfigParts(config, subconfig, opts, meta, logs) {\n var path = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];\n if (!subconfig) return;\n var isRoot = !path.length;\n for (var k in meta) {\n var submeta = meta[k];\n var newPath = k === \"x\" ? path : [].concat(_toConsumableArray(path), [k]);\n // if (isRoot) {\n // //logs.push(`Cloned ${newPath.join(\".\")}`);\n // config[k] = clone(config[k]);\n // }\n if (submeta.type === \"r\") {\n var targetObj = subconfig;\n var val = targetObj[k];\n if (submeta.isArr) {\n for (var ind in val) {\n var newVal = renderReactElement(val[ind], opts, [].concat(_toConsumableArray(newPath), [ind]));\n if (newVal !== val[ind]) {\n logs.push(\"Compiled \".concat(newPath.join(\".\"), \"[\").concat(ind, \"]\"));\n val[ind] = newVal;\n }\n }\n } else {\n var _newVal = renderReactElement(val, opts, newPath, undefined);\n if (_newVal !== val) {\n logs.push(\"Compiled R \".concat(newPath.join(\".\")));\n targetObj[k] = _newVal;\n }\n }\n } else if (submeta.type === \"rf\") {\n var _targetObj = subconfig;\n var _val = _targetObj[k];\n var _newVal2 = compileJsonLogicReact(_val, opts, newPath, submeta.ignore);\n if (_newVal2 !== _val) {\n logs.push(\"Compiled JL-RF \".concat(newPath.join(\".\")));\n _targetObj[k] = _newVal2;\n }\n } else if (submeta.type === \"f\") {\n var _targetObj2 = subconfig;\n var _val2 = _targetObj2[k];\n var _newVal3 = compileJsonLogic(_val2, opts, newPath, submeta.args, submeta.ignore);\n if (submeta.invokeWith && _newVal3 && typeof _newVal3 === \"function\") {\n var _newVal4;\n _newVal3 = (_newVal4 = _newVal3).call.apply(_newVal4, [null].concat(_toConsumableArray(submeta.invokeWith)));\n }\n if (_newVal3 !== _val2) {\n logs.push(\"Compiled JL-F \".concat(newPath.join(\".\")));\n _targetObj2[k] = _newVal3;\n }\n } else if (k === \"x\") {\n for (var field in subconfig) {\n newPath = [].concat(_toConsumableArray(path), [field]);\n var def = subconfig[field];\n _compileConfigParts(config, def, opts, submeta, logs, newPath);\n if (def.subfields) {\n // tip: need to pass `meta`, not `submeta`\n _compileConfigParts(config, def.subfields, opts, meta, logs, newPath);\n }\n }\n } else {\n var _def = subconfig[k];\n _compileConfigParts(config, _def, opts, submeta, logs, newPath);\n }\n }\n}\nfunction compileJsonLogicReact(jl, opts, path) {\n var ignore = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n if (isJsonLogic(jl)) {\n return function (props, ctx) {\n ctx = ctx || (opts === null || opts === void 0 ? void 0 : opts.ctx); // can use context compile-time if not passed at runtime\n var data = {\n props: props,\n ctx: ctx\n };\n var re = applyJsonLogicWithPath(jl, data, path);\n if (typeof re === \"string\") {\n re = {\n type: re,\n props: props\n };\n }\n var ret = renderReactElement(re, {\n ctx: ctx\n }, path);\n return ret;\n };\n } else if (typeof jl === \"string\") {\n return function (props, ctx) {\n ctx = ctx || (opts === null || opts === void 0 ? void 0 : opts.ctx); // can use context compile-time if not passed at runtime\n var fn = jl.split(\".\").reduce(function (o, k) {\n return o === null || o === void 0 ? void 0 : o[k];\n }, ctx);\n if (fn) {\n return callContextFn(this, fn, [props, ctx], path);\n } else {\n var re = {\n type: jl,\n props: props\n };\n var ret = renderReactElement(re, {\n ctx: ctx\n }, path);\n return ret;\n }\n };\n }\n return jl;\n}\nfunction compileJsonLogic(jl, opts, path, argNames) {\n var ignore = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;\n if (isJsonLogic(jl) && ignore !== \"jl\") {\n return function () {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n var ctx = this || (opts === null || opts === void 0 ? void 0 : opts.ctx); // can use context compile-time if not passed at runtime\n var data = (argNames || []).reduce(function (acc, k, i) {\n return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, k, args[i]));\n }, {\n args: args,\n ctx: ctx\n });\n var ret = applyJsonLogicWithPath(jl, data, path);\n return ret;\n }.bind(opts === null || opts === void 0 ? void 0 : opts.ctx);\n } else if (typeof jl === \"string\" && ignore !== \"string\") {\n return function () {\n var ctx = this || (opts === null || opts === void 0 ? void 0 : opts.ctx); // can use context compile-time if not passed at runtime\n var fn = jl.split(\".\").reduce(function (o, k) {\n return o === null || o === void 0 ? void 0 : o[k];\n }, ctx);\n if (fn) {\n for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n return callContextFn(this, fn, args, path);\n } else {\n throw new Error(\"\".concat(path.join(\".\"), \" :: Function \").concat(jl, \" is not found in ctx\"));\n }\n }.bind(opts === null || opts === void 0 ? void 0 : opts.ctx);\n }\n return jl;\n}\nfunction getReactComponentFromCtx(name, ctx) {\n var _ctx$components;\n return (ctx === null || ctx === void 0 || (_ctx$components = ctx.components) === null || _ctx$components === void 0 ? void 0 : _ctx$components[name]) || ctx.W[name] || ctx.O[name];\n}\nfunction renderReactElement(jsx, opts, path) {\n var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n if (isJSX(jsx)) {\n var _props;\n var type = jsx.type,\n props = jsx.props;\n if (typeof type !== \"string\") {\n throw new Error(\"renderReactElement for \".concat(path.join(\".\"), \": type should be string\"));\n }\n var Cmp = getReactComponentFromCtx(type, opts.ctx) || type.toLowerCase();\n var children;\n if (key !== undefined) {\n props = _objectSpread(_objectSpread({}, props), {}, {\n key: key\n });\n }\n if ((_props = props) !== null && _props !== void 0 && _props.children) {\n children = renderReactElement(props.children, opts, path);\n props = _objectSpread(_objectSpread({}, props), {}, {\n children: children\n });\n }\n var res = opts.ctx.RCE(Cmp, props);\n return res;\n } else if (jsx instanceof Array) {\n return jsx.map(function (el, i) {\n return renderReactElement(el, opts, path, \"\" + i);\n });\n }\n return jsx;\n}","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport pick from \"lodash/pick\";\nimport { configKeys } from \"./configUtils\";\nvar memoId = 0;\nvar configId = 0;\nvar commonMemo;\nvar memos = {};\nexport var areConfigsSame = function areConfigsSame(config1, config2) {\n return configKeys.map(function (k) {\n return config1[k] === config2[k];\n }).filter(function (v) {\n return !v;\n }).length === 0;\n};\nexport var getCommonMemo = function getCommonMemo(extendConfig) {\n if (!commonMemo) {\n commonMemo = createConfigMemo({\n reactIndex: undefined,\n maxSize: 3,\n canCompile: undefined,\n // default is true\n extendConfig: extendConfig\n });\n }\n return commonMemo;\n};\nexport var findExtendedConfigInAllMemos = function findExtendedConfigInAllMemos(config, needsToBeCompiled) {\n var foundExtConfig;\n for (var k in memos) {\n var found = memos[k].findExtendedConfig(config, needsToBeCompiled);\n if (found) {\n foundExtConfig = found;\n break;\n }\n }\n return foundExtConfig;\n};\nexport var createConfigMemo = function createConfigMemo() {\n var meta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {\n reactIndex: undefined,\n maxSize: 2,\n // current and prev\n canCompile: true,\n extendConfig: undefined // should be passed!\n };\n var configStore = new Map();\n var maxSize = meta.maxSize || 2;\n var currentMemoId = ++memoId;\n var currentMemo;\n var isActive = true;\n var pickConfig = function pickConfig(props) {\n return pick(props, configKeys);\n };\n var extendAndStore = function extendAndStore(config) {\n var extendedConfig = meta.extendConfig(config, ++configId, meta.canCompile);\n storeConfigPair(config, extendedConfig);\n return extendedConfig;\n };\n var getSize = function getSize() {\n return configStore.size;\n };\n var storeConfigPair = function storeConfigPair(config, extendedConfig) {\n if (configStore.size + 1 > maxSize) {\n configStore[\"delete\"](configStore.keys().next().value);\n }\n // Note: because of desctructing, strict find would not be possible\n // (see commented line in `findExtended`)\n // (see issue #1187)\n configStore.set(_objectSpread({}, config), extendedConfig);\n };\n var findBasic = function findBasic(findConfig) {\n var _iterator = _createForOfIteratorHelper(configStore.keys()),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var basicConfig = _step.value;\n var extConfig = configStore.get(basicConfig);\n var found = areConfigsSame(extConfig, findConfig);\n if (found) {\n return basicConfig;\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return findConfig;\n };\n var findExtended = function findExtended(findConfig, needsToBeCompiled) {\n // strict find:\n // return configStore.get(findConfig) || configStore.values().find(ec => ec === findConfig);\n var _iterator2 = _createForOfIteratorHelper(configStore.keys()),\n _step2;\n try {\n var _loop = function _loop() {\n var savedConfig = _step2.value;\n var foundParts = configKeys.filter(function (k) {\n return savedConfig[k] === findConfig[k];\n });\n var found = foundParts.length === configKeys.length && (needsToBeCompiled ? savedConfig.__compliled : true);\n if (found) {\n return {\n v: configStore.get(savedConfig)\n };\n }\n },\n _ret;\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n _ret = _loop();\n if (_ret) return _ret.v;\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n var _iterator3 = _createForOfIteratorHelper(configStore.values()),\n _step3;\n try {\n var _loop2 = function _loop2() {\n var extendedConfig = _step3.value;\n var foundParts = configKeys.filter(function (k) {\n return extendedConfig[k] === findConfig[k];\n });\n var found = foundParts.length === configKeys.length && (needsToBeCompiled ? extendedConfig.__compliled : true);\n if (found) {\n return {\n v: extendedConfig\n };\n }\n },\n _ret2;\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n _ret2 = _loop2();\n if (_ret2) return _ret2.v;\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n return null;\n };\n var findOrExtend = function findOrExtend(config) {\n return findExtended(config) || extendAndStore(config);\n };\n var clearConfigMemo = function clearConfigMemo() {\n isActive = false;\n configStore.clear();\n delete memos[currentMemoId];\n if (commonMemo === currentMemo) {\n commonMemo = undefined;\n }\n };\n currentMemo = {\n getExtendedConfig: function getExtendedConfig(props) {\n return findOrExtend(pickConfig(props));\n },\n findExtendedConfig: findExtended,\n getBasicConfig: findBasic,\n clearConfigMemo: clearConfigMemo,\n configId: configId,\n storeConfigPair: storeConfigPair,\n getSize: getSize,\n configStore: configStore,\n memoId: currentMemoId,\n meta: meta\n };\n if (meta.reactIndex === undefined) {\n commonMemo = currentMemo;\n }\n memos[currentMemoId] = currentMemo;\n return currentMemo;\n};","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport uuid from \"./uuid\";\nimport mergeWith from \"lodash/mergeWith\";\nimport { settings as defaultSettings } from \"../config/default\";\nimport moment from \"moment\";\nimport { mergeArraysSmart, logger, deepFreeze, mergeCustomizerNoArrays, shallowCopy, omit } from \"./stuff\";\nimport clone from \"clone\";\nimport { compileConfig } from \"./configSerialize\";\nimport { getFieldRawConfig } from \"./configUtils\";\nimport { findExtendedConfigInAllMemos, getCommonMemo } from \"./configMemo\";\nvar widgetPropsForDeepMerge = [\"customProps\"];\nvar opPropsForDeepMerge = [\"options\"]; // tip: options for proximity\n\nvar _extendConfig = function extendConfig(config, configId) {\n var canCompile = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //operators, defaultOperator - merge\n //widgetProps (including valueLabel, valuePlaceholder, hideOperator, operatorInlineLabel) - concrete by widget\n\n canCompile = canCompile && config.settings.useConfigCompress;\n\n // Already extended?\n if (config.__configId) {\n return config;\n }\n\n // Try to take from memo (cache)\n var cachedExtConfig = findExtendedConfigInAllMemos(config, canCompile);\n if (cachedExtConfig) {\n return cachedExtConfig;\n }\n var origConfig = config;\n\n // Clone (and compile if need)\n if (canCompile) {\n if (config.__compliled) {\n // already compiled\n config = clone(config);\n } else {\n // will be cloned and compiled\n config = compileConfig(config);\n }\n } else {\n config = clone(config);\n }\n config.settings = mergeWith({}, defaultSettings, config.settings, mergeCustomizerNoArrays);\n config.__fieldsCntByType = {};\n config.__funcsCntByType = {};\n config.__fieldNames = {};\n extendTypesConfig(config.types, config);\n extendFieldsConfig(config.fields, config);\n extendFuncsConfig(config.funcs, config);\n var caseValueField = config.settings.caseValueField;\n if (caseValueField) {\n extendFieldConfig(caseValueField, config, [], false, true);\n }\n var momentLocale = config.settings.locale.moment;\n if (momentLocale) {\n moment.locale(momentLocale);\n }\n Object.defineProperty(config, \"__configId\", {\n enumerable: false,\n writable: false,\n value: configId || uuid()\n });\n config.__cache = {};\n deepFreeze(config);\n\n // Save to memo (cache)\n var memo = getCommonMemo(_extendConfig);\n memo.storeConfigPair(origConfig, config);\n return config;\n};\nexport { _extendConfig as extendConfig };\nfunction extendTypesConfig(typesConfig, config) {\n for (var type in typesConfig) {\n var typeConfig = typesConfig[type];\n extendTypeConfig(type, typeConfig, config);\n }\n}\nfunction extendTypeConfig(type, typeConfig, config) {\n var operators = null,\n defaultOperator = null;\n typeConfig.mainWidget = typeConfig.mainWidget || Object.keys(typeConfig.widgets).filter(function (w) {\n return w != \"field\" && w != \"func\";\n })[0];\n var excludeOperators = typeConfig.excludeOperators || [];\n for (var widget in typeConfig.widgets) {\n var typeWidgetConfig = typeConfig.widgets[widget];\n var defOp = typeWidgetConfig.defaultOperator;\n if (typeWidgetConfig.operators) {\n var typeWidgetOperators = typeWidgetConfig.operators.filter(function (op) {\n return !excludeOperators.includes(op);\n });\n operators = mergeArraysSmart(operators, typeWidgetOperators);\n }\n if (defOp && !excludeOperators.includes(defOp)) {\n if (!defaultOperator || widget === typeConfig.mainWidget) {\n defaultOperator = defOp;\n }\n }\n if (widget == typeConfig.mainWidget) {\n typeWidgetConfig.widgetProps = _objectSpread(_objectSpread({}, typeConfig.mainWidgetProps || {}), typeWidgetConfig.widgetProps || {});\n }\n typeConfig.widgets[widget] = typeWidgetConfig;\n }\n if (!typeConfig.valueSources) typeConfig.valueSources = Object.keys(config.settings.valueSourcesInfo);\n var _iterator = _createForOfIteratorHelper(typeConfig.valueSources),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var valueSrc = _step.value;\n if (valueSrc != \"value\" && !typeConfig.widgets[valueSrc]) {\n typeConfig.widgets[valueSrc] = {};\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n if (!typeConfig.operators && operators) typeConfig.operators = Array.from(new Set(operators)); //unique\n if (!typeConfig.defaultOperator && defaultOperator) typeConfig.defaultOperator = defaultOperator;\n}\nfunction extendFieldsConfig(subconfig, config) {\n var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n for (var field in subconfig) {\n var fieldPathArr = [].concat(_toConsumableArray(path), [field]);\n extendFieldConfig(subconfig[field], config, fieldPathArr);\n if (subconfig[field].subfields) {\n extendFieldsConfig(subconfig[field].subfields, config, fieldPathArr);\n }\n }\n}\nfunction extendFuncsConfig(subconfig, config) {\n var _config$settings;\n var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n if (!subconfig) return;\n var fieldSeparator = (config === null || config === void 0 || (_config$settings = config.settings) === null || _config$settings === void 0 ? void 0 : _config$settings.fieldSeparator) || \".\";\n for (var funcKey in subconfig) {\n var funcPathArr = [].concat(_toConsumableArray(path), [funcKey]);\n var funcPathStr = funcPathArr.join(fieldSeparator);\n var funcDef = subconfig[funcKey];\n if (funcDef.returnType) {\n funcDef.type = funcDef.returnType;\n if (!config.__funcsCntByType[funcDef.returnType]) config.__funcsCntByType[funcDef.returnType] = 0;\n config.__funcsCntByType[funcDef.returnType]++;\n }\n extendFieldConfig(funcDef, config, funcPathArr, false);\n if (funcDef.args) {\n for (var argKey in funcDef.args) {\n extendFieldConfig(funcDef.args[argKey], config, [].concat(_toConsumableArray(funcPathArr), [argKey]), true);\n }\n // isOptional can be only in the end\n var argKeys = Object.keys(funcDef.args);\n var tmpIsOptional = true;\n var _iterator2 = _createForOfIteratorHelper(argKeys.reverse()),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _argKey = _step2.value;\n var argDef = funcDef.args[_argKey];\n if (!tmpIsOptional && argDef.isOptional) {\n logger.info(\"Arg \".concat(_argKey, \" for func \").concat(funcPathStr, \" can't be optional\"));\n delete argDef.isOptional;\n }\n if (!argDef.isOptional) tmpIsOptional = false;\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n }\n if (funcDef.subfields) {\n extendFuncsConfig(funcDef.subfields, config, [].concat(_toConsumableArray(path), [funcKey]));\n }\n }\n}\nfunction normalizeFieldSettings(fieldConfig, config, type) {\n var _fieldConfig$fieldSet, _fieldConfig$fieldSet2;\n var keysToPutInFieldSettings = [\"listValues\", \"treeValues\", \"allowCustomValues\", \"validateValue\"];\n for (var _i = 0, _keysToPutInFieldSett = keysToPutInFieldSettings; _i < _keysToPutInFieldSett.length; _i++) {\n var k = _keysToPutInFieldSett[_i];\n if (fieldConfig[k]) {\n if (!fieldConfig.fieldSettings) fieldConfig.fieldSettings = {};\n fieldConfig.fieldSettings[k] = fieldConfig[k];\n delete fieldConfig[k];\n }\n }\n\n // normalize listValues\n if ((_fieldConfig$fieldSet = fieldConfig.fieldSettings) !== null && _fieldConfig$fieldSet !== void 0 && _fieldConfig$fieldSet.listValues) {\n if (config.settings.normalizeListValues) {\n fieldConfig.fieldSettings.listValues = config.settings.normalizeListValues.call(config.ctx, fieldConfig.fieldSettings.listValues, type, fieldConfig.fieldSettings);\n }\n }\n // same for treeValues\n if ((_fieldConfig$fieldSet2 = fieldConfig.fieldSettings) !== null && _fieldConfig$fieldSet2 !== void 0 && _fieldConfig$fieldSet2.treeValues) {\n if (config.settings.normalizeListValues) {\n fieldConfig.fieldSettings.treeValues = config.settings.normalizeListValues.call(config.ctx, fieldConfig.fieldSettings.treeValues, type, fieldConfig.fieldSettings);\n }\n }\n}\nfunction extendFieldConfig(fieldConfig, config) {\n var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n var isFuncArg = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var isCaseValue = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var _config$settings2 = config.settings,\n showLabels = _config$settings2.showLabels,\n fieldSeparator = _config$settings2.fieldSeparator;\n fieldSeparator = fieldSeparator !== null && fieldSeparator !== void 0 ? fieldSeparator : \".\";\n var argKey = path[path.length - 1];\n var funcKey = isFuncArg ? path.slice(0, path.length - 1).join(fieldSeparator) : path.join(fieldSeparator);\n var isFunc = !!fieldConfig.returnType;\n var type = fieldConfig.type || fieldConfig.returnType;\n // const isGroup = type === \"!struct\" || type === \"!group\";\n var typeConfig = config.types[type];\n var excludeOperatorsForField = fieldConfig.excludeOperators || [];\n var operators = (fieldConfig.operators || (typeConfig === null || typeConfig === void 0 ? void 0 : typeConfig.operators) || []).filter(function (op) {\n return !excludeOperatorsForField.includes(op);\n });\n var defaultOperator = fieldConfig.defaultOperator || (typeConfig === null || typeConfig === void 0 ? void 0 : typeConfig.defaultOperator);\n if (excludeOperatorsForField.includes(defaultOperator)) defaultOperator = undefined;\n var hasOwnDefaultOperator = !!defaultOperator && defaultOperator == fieldConfig.defaultOperator;\n if (hasOwnDefaultOperator) {\n fieldConfig.ownDefaultOperator = fieldConfig.defaultOperator;\n }\n if (!typeConfig) {\n if (fieldConfig.type !== \"!struct\") {\n // console.warn(`No type config for ${type}`);\n fieldConfig.disabled = true;\n }\n return;\n }\n if (!isFuncArg && !isFunc && !isCaseValue) {\n if (!config.__fieldsCntByType[type]) config.__fieldsCntByType[type] = 0;\n config.__fieldsCntByType[type]++;\n }\n if (isFuncArg) {\n fieldConfig._isFuncArg = true;\n fieldConfig._argKey = argKey;\n fieldConfig._funcKey = funcKey;\n }\n if (isFunc) {\n fieldConfig._isFunc = true;\n fieldConfig._funcKey = funcKey;\n }\n if (isCaseValue) {\n fieldConfig._isCaseValue = true;\n }\n normalizeFieldSettings(fieldConfig, config, type);\n\n // copy from type to field\n var excludeKeysFromType = [\"widgets\", \"operators\", \"defaultOperator\"];\n Object.keys(typeConfig).filter(function (k) {\n return !excludeKeysFromType.includes(k);\n }).map(function (k) {\n if (!fieldConfig[k]) {\n fieldConfig[k] = shallowCopy(typeConfig[k]);\n }\n });\n\n // copy/merge widgets\n var excludeOperatorsForType = typeConfig.excludeOperators || [];\n if (fieldConfig.operators) {\n // `operators` from field can override `excludeOperators` from type, see `prox1` at examples\n excludeOperatorsForType = excludeOperatorsForType.filter(function (op) {\n return !fieldConfig.operators.includes(op);\n });\n }\n if (!fieldConfig.widgets) fieldConfig.widgets = {};\n var _loop = function _loop() {\n var fieldWidgetConfig = _objectSpread({}, fieldConfig.widgets[widget] || {});\n var typeWidgetConfig = typeConfig.widgets[widget] || {};\n\n // merge operators, defaultOperator\n if (!isFuncArg) {\n // tip: operators are not used for func args\n var defOp = fieldWidgetConfig.defaultOperator;\n var excludeOperators = [].concat(_toConsumableArray(excludeOperatorsForField), _toConsumableArray(excludeOperatorsForType));\n var shouldIncludeOperators = fieldConfig.preferWidgets && (widget === \"field\" || fieldConfig.preferWidgets.includes(widget)) || excludeOperators.length > 0;\n if (fieldWidgetConfig.operators) {\n var addOperators = fieldWidgetConfig.operators.filter(function (op) {\n return !excludeOperators.includes(op);\n });\n fieldWidgetConfig.operators = addOperators;\n // operators = [...(operators || []), ...addOperators];\n operators = mergeArraysSmart(operators, addOperators);\n } else if (shouldIncludeOperators && typeWidgetConfig.operators) {\n var _addOperators = typeWidgetConfig.operators.filter(function (op) {\n return !excludeOperators.includes(op);\n });\n fieldWidgetConfig.operators = _addOperators;\n // operators = [...(operators || []), ...addOperators];\n operators = mergeArraysSmart(operators, _addOperators);\n }\n if (defOp && !excludeOperators.includes(defOp)) {\n if (!defaultOperator || !hasOwnDefaultOperator && widget === fieldConfig.mainWidget) {\n // tip: defOp can overwrite default operator from type config\n defaultOperator = defOp;\n }\n }\n }\n\n // merge widgetProps\n fieldWidgetConfig.widgetProps = _objectSpread(_objectSpread(_objectSpread({}, typeWidgetConfig.widgetProps || {}), widget === fieldConfig.mainWidget && fieldConfig.mainWidgetProps || {}), fieldWidgetConfig.widgetProps || {});\n // merge some object-type props (like `customProps`) deeply\n for (var _i2 = 0, _widgetPropsForDeepMe = widgetPropsForDeepMerge; _i2 < _widgetPropsForDeepMe.length; _i2++) {\n var prop = _widgetPropsForDeepMe[_i2];\n if (fieldWidgetConfig.widgetProps[prop]) {\n var _config$widgets$widge, _typeWidgetConfig$wid, _fieldConfig$mainWidg, _fieldWidgetConfig$wi;\n fieldWidgetConfig.widgetProps[prop] = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, ((_config$widgets$widge = config.widgets[widget]) === null || _config$widgets$widge === void 0 ? void 0 : _config$widgets$widge[prop]) || {}), ((_typeWidgetConfig$wid = typeWidgetConfig.widgetProps) === null || _typeWidgetConfig$wid === void 0 ? void 0 : _typeWidgetConfig$wid[prop]) || {}), widget === fieldConfig.mainWidget && ((_fieldConfig$mainWidg = fieldConfig.mainWidgetProps) === null || _fieldConfig$mainWidg === void 0 ? void 0 : _fieldConfig$mainWidg[prop]) || {}), ((_fieldWidgetConfig$wi = fieldWidgetConfig.widgetProps) === null || _fieldWidgetConfig$wi === void 0 ? void 0 : _fieldWidgetConfig$wi[prop]) || {});\n }\n }\n\n // merge opProps\n var opKeys = Array.from(new Set([].concat(_toConsumableArray(Object.keys(typeWidgetConfig.opProps || {})), _toConsumableArray(Object.keys(fieldWidgetConfig.opProps || {})))));\n if (opKeys.length) {\n var opProps = {};\n var _iterator3 = _createForOfIteratorHelper(opKeys),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var _typeWidgetConfig$opP, _fieldWidgetConfig$op;\n var op = _step3.value;\n opProps[op] = _objectSpread(_objectSpread({}, ((_typeWidgetConfig$opP = typeWidgetConfig.opProps) === null || _typeWidgetConfig$opP === void 0 ? void 0 : _typeWidgetConfig$opP[op]) || {}), ((_fieldWidgetConfig$op = fieldWidgetConfig.opProps) === null || _fieldWidgetConfig$op === void 0 ? void 0 : _fieldWidgetConfig$op[op]) || {});\n // merge some object-type props (like `options` for `complexity` op) deeply\n for (var _i3 = 0, _opPropsForDeepMerge = opPropsForDeepMerge; _i3 < _opPropsForDeepMerge.length; _i3++) {\n var opProp = _opPropsForDeepMerge[_i3];\n if (opProps[op][opProp]) {\n var _config$operators, _typeWidgetConfig$opP2, _fieldWidgetConfig$op2;\n opProps[op][opProp] = _objectSpread(_objectSpread(_objectSpread({}, ((_config$operators = config.operators) === null || _config$operators === void 0 || (_config$operators = _config$operators[op]) === null || _config$operators === void 0 ? void 0 : _config$operators[opProp]) || {}), ((_typeWidgetConfig$opP2 = typeWidgetConfig.opProps) === null || _typeWidgetConfig$opP2 === void 0 || (_typeWidgetConfig$opP2 = _typeWidgetConfig$opP2[op]) === null || _typeWidgetConfig$opP2 === void 0 ? void 0 : _typeWidgetConfig$opP2[opProp]) || {}), ((_fieldWidgetConfig$op2 = fieldWidgetConfig.opProps) === null || _fieldWidgetConfig$op2 === void 0 || (_fieldWidgetConfig$op2 = _fieldWidgetConfig$op2[op]) === null || _fieldWidgetConfig$op2 === void 0 ? void 0 : _fieldWidgetConfig$op2[opProp]) || {});\n }\n }\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n fieldWidgetConfig.opProps = opProps;\n }\n\n // label for func arg\n var _fieldWidgetConfig = fieldWidgetConfig,\n valueLabel = _fieldWidgetConfig.valueLabel,\n valuePlaceholder = _fieldWidgetConfig.valuePlaceholder;\n if (isFuncArg) {\n if (!valueLabel) fieldWidgetConfig.valueLabel = fieldConfig.label || argKey;\n if (!valuePlaceholder && !showLabels) fieldWidgetConfig.valuePlaceholder = fieldConfig.label || argKey;\n }\n\n // copy other widget configs from type to field\n fieldWidgetConfig = _objectSpread(_objectSpread({}, typeWidgetConfig), fieldWidgetConfig);\n fieldConfig.widgets[widget] = fieldWidgetConfig;\n };\n for (var widget in typeConfig.widgets) {\n _loop();\n }\n if (!isFuncArg) {\n // tip: operators are not used for func args\n if (!fieldConfig.operators) {\n fieldConfig.operators = Array.from(new Set(operators)); // unique\n }\n if (!fieldConfig.defaultOperator) {\n fieldConfig.defaultOperator = defaultOperator;\n }\n }\n if (!isFuncArg && !isFunc && !isCaseValue) {\n var _computeFieldName = computeFieldName(config, path),\n fieldName = _computeFieldName.fieldName,\n inGroup = _computeFieldName.inGroup;\n if (fieldName) {\n fieldConfig.fieldName = fieldName;\n if (!config.__fieldNames[fieldName]) config.__fieldNames[fieldName] = [];\n config.__fieldNames[fieldName].push({\n fullPath: path,\n inGroup: inGroup\n });\n }\n }\n}\nfunction computeFieldName(config, path) {\n if (!path) return {};\n var fieldSeparator = config.settings.fieldSeparator;\n var _reduce = _toConsumableArray(path).reduce(function (_ref, f, i, arr) {\n var computedPath = _ref.computedPath,\n computed = _ref.computed,\n inGroup = _ref.inGroup;\n var fullPath = [].concat(_toConsumableArray(arr.slice(0, i)), [f]);\n var fConfig = getFieldRawConfig(config, fullPath);\n if ((fConfig === null || fConfig === void 0 ? void 0 : fConfig.type) === \"!group\" && i < arr.length - 1) {\n // don't include group in final field name\n inGroup = fullPath.join(fieldSeparator);\n computedPath = [];\n } else if (fConfig !== null && fConfig !== void 0 && fConfig.fieldName) {\n // tip: fieldName overrides path !\n computed = true;\n computedPath = [fConfig.fieldName];\n } else {\n computedPath = [].concat(_toConsumableArray(computedPath), [f]);\n }\n return {\n computedPath: computedPath,\n computed: computed,\n inGroup: inGroup\n };\n }, {\n computedPath: [],\n computed: false,\n inGroup: undefined\n }),\n computedPath = _reduce.computedPath,\n computed = _reduce.computed,\n inGroup = _reduce.inGroup;\n return computed ? {\n fieldName: computedPath.join(fieldSeparator),\n inGroup: inGroup\n } : {};\n}","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nimport { getOpCardinality, widgetDefKeysToOmit, opDefKeysToOmit, omit } from \"../utils/stuff\";\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldParts, getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { formatFieldName, completeValue, getOneChildOrDescendant } from \"../utils/ruleUtils\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { List, Map } from \"immutable\";\nimport pick from \"lodash/pick\";\n\n// http://jsonlogic.com/\n\nexport var jsonLogicFormat = function jsonLogicFormat(item, config) {\n //meta is mutable\n var meta = {\n usedFields: [],\n errors: []\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var logic = formatItem(item, extendedConfig, meta, false, true);\n\n // build empty data\n var errors = meta.errors,\n usedFields = meta.usedFields;\n var fieldSeparator = extendedConfig.settings.fieldSeparator;\n var data = {};\n var _iterator = _createForOfIteratorHelper(usedFields),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var ff = _step.value;\n //const fieldSrc = typeof ff === \"string\" ? \"field\" : \"func\";\n var parts = getFieldParts(ff, config);\n var def = getFieldConfig(extendedConfig, ff) || {};\n var tmp = data;\n for (var i = 0; i < parts.length; i++) {\n var p = parts[i];\n var pdef = getFieldConfig(extendedConfig, parts.slice(0, i + 1)) || {};\n if (i != parts.length - 1) {\n if (pdef.type == \"!group\" && pdef.mode != \"struct\") {\n if (!tmp[p]) tmp[p] = [{}];\n tmp = tmp[p][0];\n } else {\n if (!tmp[p]) tmp[p] = {};\n tmp = tmp[p];\n }\n } else {\n if (!tmp[p]) tmp[p] = null; // can use def.type for sample values\n }\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return {\n errors: errors,\n logic: logic,\n data: data\n };\n};\nvar formatItem = function formatItem(item, config, meta) {\n var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var isRoot = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var parentField = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n if (!item) return undefined;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var isLocked = properties.get(\"isLocked\");\n var lockedOp = config.settings.jsonLogic.lockedOp;\n var ret;\n if (type === \"group\" || type === \"rule_group\") {\n ret = formatGroup(item, config, meta, _not, isRoot, parentField);\n } else if (type === \"rule\") {\n ret = formatRule(item, config, meta, _not, parentField);\n } else if (type == \"switch_group\") {\n ret = formatSwitch(item, config, meta, _not);\n } else if (type == \"case_group\") {\n ret = formatCase(item, config, meta, _not, parentField);\n }\n if (isLocked && ret && lockedOp) {\n ret = _defineProperty({}, lockedOp, ret);\n }\n return ret;\n};\nvar formatGroup = function formatGroup(item, config, meta) {\n var _groupOperatorDef, _groupOperatorDef2, _groupOperatorDef3, _reversedGroupOpDef, _reversedGroupOpDef2, _getOneChildOrDescend;\n var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var isRoot = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var parentField = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var mode = properties.get(\"mode\");\n var children = item.get(\"children1\") || new List();\n var field = properties.get(\"field\");\n var fieldDefinition = getFieldConfig(config, field);\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var conjunctionDefinition = config.conjunctions[conjunction];\n var conj = (conjunctionDefinition === null || conjunctionDefinition === void 0 ? void 0 : conjunctionDefinition.jsonLogicConj) || conjunction.toLowerCase();\n var origNot = !!properties.get(\"not\");\n var isRuleGroup = type === \"rule_group\" && !isRoot;\n var isRuleGroupArray = isRuleGroup && mode != \"struct\";\n var groupField = isRuleGroupArray ? field : parentField;\n var groupOperator = properties.get(\"operator\");\n var groupOperatorDef = groupOperator && getOperatorConfig(config, groupOperator, field) || null;\n var formattedValue = formatItemValue(config, properties, meta, groupOperator, parentField);\n // Tip: for demo app isGroup0 is true for \"Results\" and \"Cars\" with group op in \"some\", \"all\", \"none\"\n // If isGroup0 is false, we should use \"reduce\"\n var isGroup0 = isRuleGroup && (!groupOperator || ((_groupOperatorDef = groupOperatorDef) === null || _groupOperatorDef === void 0 ? void 0 : _groupOperatorDef.cardinality) == 0);\n var isRuleGroupWithChildren = isRuleGroup && (children === null || children === void 0 ? void 0 : children.size) > 0;\n var isRuleGroupWithoutChildren = isRuleGroup && !(children !== null && children !== void 0 && children.size);\n\n // rev\n var not = origNot;\n var filterNot = false;\n if (isRuleGroupWithChildren) {\n // for rule_group `not` there should be 2 NOTs: from properties (for children) and from parent group (_not)\n filterNot = origNot;\n not = _not;\n } else {\n if (_not) {\n not = !not;\n }\n }\n var revChildren = false;\n var reversedGroupOp = (_groupOperatorDef2 = groupOperatorDef) === null || _groupOperatorDef2 === void 0 ? void 0 : _groupOperatorDef2.reversedOp;\n var reversedGroupOpDef = getOperatorConfig(config, reversedGroupOp, field);\n var groupOpNeedsReverse = !((_groupOperatorDef3 = groupOperatorDef) !== null && _groupOperatorDef3 !== void 0 && _groupOperatorDef3.jsonLogic) && !!((_reversedGroupOpDef = reversedGroupOpDef) !== null && _reversedGroupOpDef !== void 0 && _reversedGroupOpDef.jsonLogic);\n var groupOpCanReverse = !!((_reversedGroupOpDef2 = reversedGroupOpDef) !== null && _reversedGroupOpDef2 !== void 0 && _reversedGroupOpDef2.jsonLogic);\n var oneChildType = (_getOneChildOrDescend = getOneChildOrDescendant(item)) === null || _getOneChildOrDescend === void 0 ? void 0 : _getOneChildOrDescend.get(\"type\");\n var canRevChildren = !!config.settings.reverseOperatorsForNot && (!isRuleGroup && not && oneChildType === \"rule\" || filterNot && (children === null || children === void 0 ? void 0 : children.size) === 1);\n if (canRevChildren) {\n if (isRuleGroupWithChildren) {\n filterNot = !filterNot;\n } else {\n not = !not;\n }\n revChildren = true;\n }\n var canRevGroupOp = not && isRuleGroup && groupOpCanReverse && (!!config.settings.reverseOperatorsForNot || groupOpNeedsReverse);\n if (canRevGroupOp) {\n not = !not;\n var _ref = [reversedGroupOp, groupOperator];\n groupOperator = _ref[0];\n reversedGroupOp = _ref[1];\n var _ref2 = [reversedGroupOpDef, groupOperatorDef];\n groupOperatorDef = _ref2[0];\n reversedGroupOpDef = _ref2[1];\n }\n var list = children.map(function (currentChild) {\n return formatItem(currentChild, config, meta, revChildren, false, groupField);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n });\n\n // allows for unnecessary (ie. empty or only one rule) groups to be exported\n var shouldPreserveGroups = !!config.settings.exportPreserveGroups;\n if (isRuleGroupArray && !isGroup0) {\n // \"count\" rule can have no \"having\" children, but should have number value\n if (formattedValue == undefined) return undefined;\n } else {\n if (!list.size && !shouldPreserveGroups) return undefined;\n }\n\n // I any of these conditions are true then we cannot remove group\n var preserveSingleRuleGroup = isRoot || shouldPreserveGroups || list.size != 1;\n\n // If preserveSingleRuleGroup is already true then there is no point to even check also if its not a negation group \n // then this does not matter\n if (!preserveSingleRuleGroup && origNot && !revChildren) {\n // We check all children even thuogh there should be only one in case the formatting of one of them failed.\n // From config we see if exclamation is part of reverse operator definition and if so then we cannot ever remove a negation single \n // rule group because then this combination would be identical to that reverse operator. see issue #1084\n preserveSingleRuleGroup = children.some(function (currentChild) {\n var _currentChild$get, _config$operators, _config$operators$rev, _config$operators2;\n var op = (_currentChild$get = currentChild.get(\"properties\")) === null || _currentChild$get === void 0 ? void 0 : _currentChild$get.get(\"operator\");\n var revOp = (_config$operators = config[\"operators\"]) === null || _config$operators === void 0 || (_config$operators = _config$operators[op]) === null || _config$operators === void 0 ? void 0 : _config$operators.reversedOp;\n return (_config$operators$rev = (_config$operators2 = config.operators) === null || _config$operators2 === void 0 || (_config$operators2 = _config$operators2[revOp]) === null || _config$operators2 === void 0 ? void 0 : _config$operators2._jsonLogicIsExclamationOp) !== null && _config$operators$rev !== void 0 ? _config$operators$rev : false;\n });\n }\n var filterQuery = {};\n if (preserveSingleRuleGroup) filterQuery[conj] = list.toList().toJS();else filterQuery = list.first();\n\n // reverse filter\n if (filterNot) {\n filterQuery = {\n \"!\": filterQuery\n };\n }\n var resultQuery = filterQuery;\n\n // rule_group (issue #246)\n if (isRuleGroupArray) {\n var _groupOperatorDef4;\n var formattedField = formatField(meta, config, field, parentField);\n var reduceQuery;\n if (!isGroup0) {\n // there is rule for count\n var filter = !list.size ? formattedField : {\n \"filter\": [formattedField, filterQuery]\n };\n reduceQuery = {\n \"reduce\": [filter, {\n \"+\": [1, {\n \"var\": \"accumulator\"\n }]\n }, 0]\n };\n }\n var formattedLhs = reduceQuery !== null && reduceQuery !== void 0 ? reduceQuery : formattedField;\n var optionsMap = new Map({\n having: filterQuery,\n reduce: reduceQuery,\n groupField: field,\n groupFieldFormatted: formattedField\n });\n // if groupOperator defines its own jsonLogic function, then we should use it (issue #1241)\n if (typeof ((_groupOperatorDef4 = groupOperatorDef) === null || _groupOperatorDef4 === void 0 ? void 0 : _groupOperatorDef4.jsonLogic) === \"function\") {\n // we should use optionsMap here\n resultQuery = formatLogic(config, properties, formattedLhs, formattedValue, groupOperator, optionsMap, fieldDefinition);\n } else {\n if (isGroup0) {\n // config.settings.groupOperators\n var op = groupOperator || \"some\";\n resultQuery = _defineProperty({}, op, [formattedField, filterQuery]);\n } else {\n resultQuery = formatLogic(config, properties, formattedLhs, formattedValue, groupOperator, null, fieldDefinition);\n }\n }\n }\n\n // reverse\n if (not) {\n resultQuery = {\n \"!\": resultQuery\n };\n }\n return resultQuery;\n};\nvar formatRule = function formatRule(item, config, meta) {\n var _operatorDefinition, _operatorDefinition2, _revOperatorDefinitio, _operatorDefinition3, _revOperatorDefinitio2, _revOperatorDefinitio3;\n var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var properties = item.get(\"properties\") || new Map();\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var operator = properties.get(\"operator\");\n var operatorOptions = properties.get(\"operatorOptions\");\n operatorOptions = operatorOptions ? operatorOptions.toJS() : null;\n if (operatorOptions && !Object.keys(operatorOptions).length) operatorOptions = null;\n if (field == null || operator == null) return undefined;\n var fieldDefinition = getFieldConfig(config, field);\n var operatorDefinition = getOperatorConfig(config, operator, field);\n var reversedOp = (_operatorDefinition = operatorDefinition) === null || _operatorDefinition === void 0 ? void 0 : _operatorDefinition.reversedOp;\n var revOperatorDefinition = getOperatorConfig(config, reversedOp, field);\n\n // check op\n if (!((_operatorDefinition2 = operatorDefinition) !== null && _operatorDefinition2 !== void 0 && _operatorDefinition2.jsonLogic) && !((_revOperatorDefinitio = revOperatorDefinition) !== null && _revOperatorDefinitio !== void 0 && _revOperatorDefinitio.jsonLogic)) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n\n // try reverse\n var not = _not;\n var opNeedsReverse = !((_operatorDefinition3 = operatorDefinition) !== null && _operatorDefinition3 !== void 0 && _operatorDefinition3.jsonLogic) && !!((_revOperatorDefinitio2 = revOperatorDefinition) !== null && _revOperatorDefinitio2 !== void 0 && _revOperatorDefinitio2.jsonLogic);\n var opCanReverse = !!((_revOperatorDefinitio3 = revOperatorDefinition) !== null && _revOperatorDefinitio3 !== void 0 && _revOperatorDefinitio3.jsonLogic);\n var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse);\n var needRev = not && canRev || opNeedsReverse;\n if (needRev) {\n not = !not;\n var _ref3 = [reversedOp, operator];\n operator = _ref3[0];\n reversedOp = _ref3[1];\n var _ref4 = [revOperatorDefinition, operatorDefinition];\n operatorDefinition = _ref4[0];\n revOperatorDefinition = _ref4[1];\n }\n var formattedValue = formatItemValue(config, properties, meta, operator, parentField);\n if (formattedValue === undefined) return undefined;\n var formattedField = fieldSrc === \"func\" ? formatFunc(meta, config, field, parentField) : formatField(meta, config, field, parentField);\n if (formattedField === undefined) return undefined;\n return formatLogic(config, properties, formattedField, formattedValue, operator, operatorOptions, fieldDefinition, not);\n};\nvar formatSwitch = function formatSwitch(item, config, meta) {\n var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var children = item.get(\"children1\");\n if (!children) return undefined;\n var cases = children.map(function (currentChild) {\n return formatCase(currentChild, config, meta, _not, null);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n }).valueSeq().toArray();\n var filteredCases = [];\n for (var i = 0; i < cases.length; i++) {\n if (i !== cases.length - 1 && !cases[i][0]) {\n meta.errors.push(\"No condition for case \".concat(i));\n } else {\n filteredCases.push(cases[i]);\n if (i === cases.length - 1 && cases[i][0]) {\n // no default - add null as default\n filteredCases.push([undefined, null]);\n }\n }\n }\n if (!filteredCases.length) return undefined;\n if (filteredCases.length === 1) {\n // only 1 case without condition\n var _filteredCases$ = _slicedToArray(filteredCases[0], 2),\n _cond = _filteredCases$[0],\n _defVal = _filteredCases$[1];\n if (_defVal == undefined) _defVal = null;\n return _defVal;\n }\n var ret = {\n \"if\": []\n };\n var ifArgs = ret[\"if\"];\n var _filteredCases = _slicedToArray(filteredCases[filteredCases.length - 1], 2),\n _ = _filteredCases[0],\n defVal = _filteredCases[1];\n for (var _i = 0; _i < filteredCases.length - 1; _i++) {\n var isLastIf = _i === filteredCases.length - 2;\n var _filteredCases$_i = _slicedToArray(filteredCases[_i], 2),\n cond = _filteredCases$_i[0],\n value = _filteredCases$_i[1];\n if (value == undefined) value = null;\n if (cond == undefined) cond = true;\n ifArgs.push(cond); // if\n ifArgs.push(value); // then\n if (isLastIf) {\n ifArgs.push(defVal); // else\n } else {\n // elif..\n ifArgs.push({\n \"if\": []\n });\n ifArgs = ifArgs[ifArgs.length - 1][\"if\"];\n }\n }\n return ret;\n};\nvar formatCase = function formatCase(item, config, meta) {\n var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var type = item.get(\"type\");\n if (type != \"case_group\") {\n meta.errors.push(\"Unexpected child of type \".concat(type, \" inside switch\"));\n return undefined;\n }\n var properties = item.get(\"properties\") || new Map();\n var cond = formatGroup(item, config, meta, _not, parentField);\n var formattedItem = formatItemValue(config, properties, meta, null, parentField, \"!case_value\");\n return [cond, formattedItem];\n};\nvar formatItemValue = function formatItemValue(config, properties, meta, operator, parentField) {\n var expectedValueType = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var field = properties.get(\"field\");\n var iValueSrc = properties.get(\"valueSrc\");\n var iValueType = properties.get(\"valueType\");\n if (expectedValueType == \"!case_value\" || iValueType && iValueType.get(0) == \"case_value\") {\n field = \"!case_value\";\n }\n var fieldDefinition = getFieldConfig(config, field);\n var operatorDefinition = getOperatorConfig(config, operator, field);\n var cardinality = getOpCardinality(operatorDefinition);\n var iValue = properties.get(\"value\");\n var asyncListValues = properties.get(\"asyncListValues\");\n if (iValue == undefined) return undefined;\n var valueSrcs = [];\n var valueTypes = [];\n var oldUsedFields = meta.usedFields;\n var fvalue = iValue.map(function (currentValue, ind) {\n var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;\n var valueType = iValueType ? iValueType.get(ind) : null;\n var cValue = completeValue(currentValue, valueSrc, config);\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, field, operator, widget, valueSrc, {\n forExport: true\n });\n var fv = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDef, fieldDefinition, operator, operatorDefinition, parentField, asyncListValues);\n if (fv !== undefined) {\n valueSrcs.push(valueSrc);\n valueTypes.push(valueType);\n }\n return fv;\n });\n var hasUndefinedValues = fvalue.filter(function (v) {\n return v === undefined;\n }).size > 0;\n if (fvalue.size < cardinality || hasUndefinedValues) {\n meta.usedFields = oldUsedFields; // restore\n return undefined;\n }\n return cardinality > 1 ? fvalue.toArray() : cardinality == 1 ? fvalue.first() : null;\n};\nvar formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef) {\n var parentField = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;\n var asyncListValues = arguments.length > 10 ? arguments[10] : undefined;\n if (currentValue === undefined) return undefined;\n var ret;\n if (valueSrc == \"field\") {\n ret = formatField(meta, config, currentValue, parentField);\n } else if (valueSrc == \"func\") {\n ret = formatFunc(meta, config, currentValue, parentField);\n } else if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.jsonLogic) === \"function\") {\n var fn = fieldWidgetDef.jsonLogic;\n var args = [currentValue, _objectSpread(_objectSpread({}, fieldDef ? pick(fieldDef, [\"fieldSettings\", \"listValues\"]) : {}), {}, {\n asyncListValues: asyncListValues\n }),\n //useful options: valueFormat for date/time\n omit(fieldWidgetDef, widgetDefKeysToOmit)];\n if (operator) {\n args.push(operator);\n args.push(operatorDef);\n }\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n } else {\n ret = currentValue;\n }\n return ret;\n};\nvar formatFunc = function formatFunc(meta, config, currentValue) {\n var _currentValue$get, _currentValue$get2;\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var funcKey = (_currentValue$get = currentValue.get) === null || _currentValue$get === void 0 ? void 0 : _currentValue$get.call(currentValue, \"func\");\n var args = (_currentValue$get2 = currentValue.get) === null || _currentValue$get2 === void 0 ? void 0 : _currentValue$get2.call(currentValue, \"args\");\n var funcConfig = getFuncConfig(config, funcKey);\n var funcParts = getFieldParts(funcKey, config);\n var funcLastKey = funcParts[funcParts.length - 1];\n if (!funcConfig) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not defined in config\"));\n return undefined;\n }\n if (!(funcConfig !== null && funcConfig !== void 0 && funcConfig.jsonLogic)) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not supported\"));\n return undefined;\n }\n var formattedArgs = {};\n var gaps = [];\n var missingArgKeys = [];\n for (var argKey in funcConfig.args) {\n var _argValue;\n var argConfig = funcConfig.args[argKey];\n var fieldDef = getFieldConfig(config, argConfig);\n var defaultValue = argConfig.defaultValue,\n isOptional = argConfig.isOptional;\n var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? \"func\" : \"value\";\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValueSrc !== \"func\" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {\n // value should not be Immutable\n argValue = argValue.toJS();\n }\n var operator = null;\n var widget = getWidgetForFieldOp(config, argConfig, operator, argValueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, widget, argValueSrc, {\n forExport: true\n });\n var formattedArgVal = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldWidgetDef, fieldDef, null, null, parentField);\n if (argValue != undefined && formattedArgVal === undefined) {\n if (argValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n var formattedDefaultVal = void 0;\n if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {\n var defaultWidget = getWidgetForFieldOp(config, argConfig, operator, defaultValueSrc);\n var defaultFieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, defaultWidget, defaultValueSrc, {\n forExport: true\n });\n formattedDefaultVal = formatValue(meta, config, defaultValue, defaultValueSrc, argConfig.type, defaultFieldWidgetDef, fieldDef, null, null, parentField);\n if (formattedDefaultVal === undefined) {\n if (defaultValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format default value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n }\n var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;\n if (finalFormattedVal !== undefined) {\n if (gaps.length) {\n var _iterator2 = _createForOfIteratorHelper(gaps),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var missedArgKey = _step2.value;\n formattedArgs[missedArgKey] = undefined;\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n gaps = [];\n }\n formattedArgs[argKey] = finalFormattedVal;\n } else {\n if (!isOptional) missingArgKeys.push(argKey);\n gaps.push(argKey);\n }\n }\n if (missingArgKeys.length) {\n //meta.errors.push(`Missing vals for args ${missingArgKeys.join(\", \")} for func ${funcKey}`);\n return undefined; // incomplete\n }\n var formattedArgsArr = Object.values(formattedArgs);\n var ret;\n if (typeof funcConfig.jsonLogic === \"function\") {\n var fn = funcConfig.jsonLogic;\n var _args = [formattedArgs];\n ret = fn.call.apply(fn, [config.ctx].concat(_args));\n } else {\n var funcName = funcConfig.jsonLogic || funcLastKey;\n var isMethod = !!funcConfig.jsonLogicIsMethod;\n if (isMethod) {\n var obj = formattedArgsArr[0],\n params = formattedArgsArr.slice(1);\n if (params.length) {\n ret = {\n \"method\": [obj, funcName, params]\n };\n } else {\n ret = {\n \"method\": [obj, funcName]\n };\n }\n } else {\n ret = _defineProperty({}, funcName, formattedArgsArr);\n }\n }\n return ret;\n};\nvar formatField = function formatField(meta, config, field) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var _config$settings = config.settings,\n fieldSeparator = _config$settings.fieldSeparator,\n jsonLogic = _config$settings.jsonLogic;\n var ret;\n if (field) {\n if (Array.isArray(field)) field = field.join(fieldSeparator);\n var fieldDef = getFieldConfig(config, field) || {};\n var fieldName = formatFieldName(field, config, meta, parentField);\n var varName = fieldDef.jsonLogicVar || (fieldDef.type == \"!group\" ? jsonLogic.groupVarKey : \"var\");\n ret = _defineProperty({}, varName, fieldName);\n if (meta.usedFields.indexOf(field) == -1) meta.usedFields.push(field);\n }\n return ret;\n};\nvar buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition, formattedField, formattedValue, expectedType) {\n var formattedOp = operator;\n var cardinality = getOpCardinality(operatorDefinition);\n if (typeof operatorDefinition.jsonLogic == \"string\") formattedOp = operatorDefinition.jsonLogic;\n var rangeOps = [\"<\", \"<=\", \">\", \">=\"];\n var eqOps = [\"==\", \"!=\"];\n var fn = function fn(field, op, val, opDef, opOpts) {\n if (cardinality == 0 && eqOps.includes(formattedOp)) return _defineProperty({}, formattedOp, [formattedField, null]);else if (cardinality == 0) return _defineProperty({}, formattedOp, formattedField);\n // else if (cardinality == 1 && eqOps.includes(formattedOp) && [\"date\", \"datetime\"].includes(expectedType))\n // return { [expectedType+formattedOp]: [formattedField, formattedValue] };\n else if (cardinality == 1) return _defineProperty({}, formattedOp, [formattedField, formattedValue]);else if (cardinality == 2 && rangeOps.includes(formattedOp)) return _defineProperty({}, formattedOp, [formattedValue[0], formattedField, formattedValue[1]]);else return _defineProperty({}, formattedOp, [formattedField].concat(_toConsumableArray(formattedValue)));\n };\n return fn;\n};\nvar formatLogic = function formatLogic(config, properties, formattedField, formattedValue, operator) {\n var _properties$get, _fieldDefinition$type;\n var operatorOptions = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var fieldDefinition = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var isRev = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;\n var field = properties.get(\"field\");\n //const fieldSrc = properties.get(\"fieldSrc\");\n var firstValueType = (_properties$get = properties.get(\"valueType\")) === null || _properties$get === void 0 ? void 0 : _properties$get.get(0);\n var operatorDefinition = getOperatorConfig(config, operator, field) || {};\n var expectedType = (_fieldDefinition$type = fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type) !== null && _fieldDefinition$type !== void 0 ? _fieldDefinition$type : firstValueType;\n var fn = typeof operatorDefinition.jsonLogic == \"function\" ? operatorDefinition.jsonLogic : buildFnToFormatOp(operator, operatorDefinition, formattedField, formattedValue, expectedType);\n var args = [formattedField, operator, formattedValue, omit(operatorDefinition, opDefKeysToOmit), operatorOptions, fieldDefinition, expectedType, config.settings];\n var ruleQuery = fn.call.apply(fn, [config.ctx].concat(args));\n if (isRev) {\n ruleQuery = {\n \"!\": ruleQuery\n };\n }\n return ruleQuery;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nexport var mongoEmptyValue = function mongoEmptyValue(fieldDef) {\n var v = \"\";\n var type = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type;\n if (type == \"number\") {\n v = 0;\n }\n return v;\n};\n\n// helpers for mongo format\nexport var mongoFormatOp1 = function mongoFormatOp1(mop, mc, opNot, field, _op, value, not, useExpr, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var $field = typeof field == \"string\" && !field.startsWith(\"$\") ? \"$\" + field : field;\n var mv = mc(value, fieldDef);\n if (mv === undefined) return undefined;\n var neg = not ^ opNot;\n if (useExpr && mop == \"$nin\") {\n // There is only `$in` aggregation operator but not `$nin` (`$nin` is only a query operator)\n // https://www.mongodb.com/docs/manual/reference/operator/aggregation/in/\n neg = !neg;\n mop = \"$in\";\n }\n if (useExpr && mop == \"$regex\") {\n // https://stackoverflow.com/questions/35750920/regex-as-filter-in-projection\n var e = {\n \"$regexFind\": {\n input: $field,\n regex: mv\n }\n };\n if (neg) {\n e = {\n \"$not\": e\n };\n }\n return e;\n }\n if (neg) {\n // if (!useExpr && (!mop || mop == \"$eq\"))\n // return { [field]: { \"$ne\": mv } }; // short form\n return !useExpr ? _defineProperty({}, field, {\n \"$not\": _defineProperty({}, mop, mv)\n }) : {\n \"$not\": _defineProperty({}, mop, [$field, mv])\n };\n } else {\n if (!useExpr && (!mop || mop == \"$eq\")) return _defineProperty({}, field, mv); // short form\n return !useExpr ? _defineProperty({}, field, _defineProperty({}, mop, mv)) : _defineProperty({}, mop, [$field, mv]);\n }\n};\nexport var mongoFormatOp2 = function mongoFormatOp2(mops, opNot, field, _op, values, not, useExpr, valueSrcs, valueTypes, opDef, operatorOptions, fieldDef) {\n var $field = typeof field == \"string\" && !field.startsWith(\"$\") ? \"$\" + field : field;\n if (not ^ opNot) {\n return !useExpr ? _defineProperty({}, field, {\n \"$not\": _defineProperty(_defineProperty({}, mops[0], values[0]), mops[1], values[1])\n }) : {\n \"$not\": {\n \"$and\": [_defineProperty({}, mops[0], [$field, values[0]]), _defineProperty({}, mops[1], [$field, values[1]])]\n }\n };\n } else {\n return !useExpr ? _defineProperty({}, field, _defineProperty(_defineProperty({}, mops[0], values[0]), mops[1], values[1])) : {\n \"$and\": [_defineProperty({}, mops[0], [$field, values[0]]), _defineProperty({}, mops[1], [$field, values[1]])]\n };\n }\n};\nexport var mongoFieldEscape = function mongoFieldEscape(input) {\n return input.replace(/\\$/g, \"\\uFF04\");\n};\nexport var mongoFieldUnescape = function mongoFieldUnescape(input) {\n return input.replace(/\\uFF04/g, \"$\");\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getOpCardinality, widgetDefKeysToOmit, opDefKeysToOmit, omit, isObject } from \"../utils/stuff\";\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldParts, getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { getFieldPathLabels, formatFieldName, completeValue, getOneChildOrDescendant } from \"../utils/ruleUtils\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { mongoFieldEscape } from \"../utils/mongoUtils\";\nimport pick from \"lodash/pick\";\nimport { List, Map } from \"immutable\";\nexport var mongodbFormat = function mongodbFormat(tree, config) {\n return _mongodbFormat(tree, config, false);\n};\nexport var _mongodbFormat = function _mongodbFormat(tree, config) {\n var returnErrors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //meta is mutable\n var meta = {\n errors: []\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var res = formatItem([], tree, extendedConfig, meta);\n if (returnErrors) {\n return [res, meta.errors];\n } else {\n if (meta.errors.length) console.warn(\"Errors while exporting to MongoDb:\", meta.errors);\n return res;\n }\n};\nvar formatItem = function formatItem(parents, item, config, meta) {\n var _not = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var _canWrapExpr = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;\n var _formatFieldName = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;\n var _value = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : undefined;\n if (!item) return undefined;\n var type = item.get(\"type\");\n if (type === \"group\" || type === \"rule_group\") {\n return formatGroup(parents, item, config, meta, _not, _canWrapExpr, _formatFieldName, _value);\n } else if (type === \"rule\") {\n return formatRule(parents, item, config, meta, _not, _canWrapExpr, _formatFieldName, _value);\n }\n return undefined;\n};\nvar formatGroup = function formatGroup(parents, item, config, meta) {\n var _parents$filter, _groupOperatorDef$car, _groupOperatorDef, _groupOperatorDef2, _groupOperatorDef3, _reversedGroupOpDef, _reversedGroupOpDef2, _getOneChildOrDescend, _conjunction;\n var _not = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var _canWrapExpr = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;\n var _formatFieldName = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;\n var _value = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : undefined;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var origNot = !!properties.get(\"not\");\n var children = item.get(\"children1\") || new List();\n var _config$settings = config.settings,\n canShortMongoQuery = _config$settings.canShortMongoQuery,\n fieldSeparator = _config$settings.fieldSeparator,\n exportPreserveGroups = _config$settings.exportPreserveGroups,\n reverseOperatorsForNot = _config$settings.reverseOperatorsForNot;\n var sep = fieldSeparator;\n var parentRuleGroup = (_parents$filter = parents.filter(function (it) {\n return it.get(\"type\") == \"rule_group\";\n })) === null || _parents$filter === void 0 || (_parents$filter = _parents$filter.slice(-1)) === null || _parents$filter === void 0 ? void 0 : _parents$filter.pop();\n var isInsideRuleGroup = !!parentRuleGroup;\n var parentRuleGroupField = parentRuleGroup === null || parentRuleGroup === void 0 ? void 0 : parentRuleGroup.get(\"properties\").get(\"field\");\n var isInsideRuleGroupArray = isInsideRuleGroup && parentRuleGroup.get(\"properties\").get(\"mode\") == \"array\";\n var isRuleGroup = type === \"rule_group\";\n var groupField = isRuleGroup ? properties.get(\"field\") : null;\n var groupOperator = isRuleGroup ? properties.get(\"operator\") : null;\n var groupOperatorDef = groupOperator && getOperatorConfig(config, groupOperator, groupField) || null;\n var groupOperatorCardinality = groupOperator ? (_groupOperatorDef$car = (_groupOperatorDef = groupOperatorDef) === null || _groupOperatorDef === void 0 ? void 0 : _groupOperatorDef.cardinality) !== null && _groupOperatorDef$car !== void 0 ? _groupOperatorDef$car : 1 : undefined;\n var groupFieldName = formatFieldName(groupField, config, meta, parentRuleGroupField);\n var groupFieldDef = getFieldConfig(config, groupField) || {};\n var mode = groupFieldDef.mode; //properties.get(\"mode\");\n var canHaveEmptyChildren = groupField && mode === \"array\" && groupOperatorCardinality >= 1;\n var isRuleGroupArray = isRuleGroup && mode != \"struct\";\n var isRuleGroupWithChildren = isRuleGroup && (children === null || children === void 0 ? void 0 : children.size) > 0;\n var isRuleGroupWithoutChildren = isRuleGroup && !(children !== null && children !== void 0 && children.size);\n\n // rev\n var revChildren = false;\n var not = origNot;\n var filterNot = false;\n if (isRuleGroupWithChildren) {\n // for rule_group `not` there should be 2 NOTs: from properties (for children) and from parent group (_not)\n filterNot = origNot;\n not = _not;\n } else {\n if (_not) {\n not = !not;\n }\n }\n var reversedGroupOp = (_groupOperatorDef2 = groupOperatorDef) === null || _groupOperatorDef2 === void 0 ? void 0 : _groupOperatorDef2.reversedOp;\n var reversedGroupOpDef = getOperatorConfig(config, reversedGroupOp, groupField);\n var groupOpNeedsReverse = !((_groupOperatorDef3 = groupOperatorDef) !== null && _groupOperatorDef3 !== void 0 && _groupOperatorDef3.mongoFormatOp) && !!((_reversedGroupOpDef = reversedGroupOpDef) !== null && _reversedGroupOpDef !== void 0 && _reversedGroupOpDef.mongoFormatOp);\n var groupOpCanReverse = !!((_reversedGroupOpDef2 = reversedGroupOpDef) !== null && _reversedGroupOpDef2 !== void 0 && _reversedGroupOpDef2.mongoFormatOp);\n var oneChildType = (_getOneChildOrDescend = getOneChildOrDescendant(item)) === null || _getOneChildOrDescend === void 0 ? void 0 : _getOneChildOrDescend.get(\"type\");\n var isSimpleGroupWithOneChild = !isRuleGroup && oneChildType === \"rule\";\n var canRevChildren = (not && isSimpleGroupWithOneChild || filterNot && (children === null || children === void 0 ? void 0 : children.size) === 1) && !exportPreserveGroups; // && !!reverseOperatorsForNot;\n if (canRevChildren) {\n if (isSimpleGroupWithOneChild) {\n not = !not;\n } else {\n filterNot = !filterNot;\n }\n revChildren = true;\n }\n var canRevGroupOp = not && isRuleGroup && groupOpCanReverse && (!!reverseOperatorsForNot && !exportPreserveGroups || groupOpNeedsReverse);\n if (canRevGroupOp) {\n not = !not;\n var _ref = [reversedGroupOp, groupOperator];\n groupOperator = _ref[0];\n reversedGroupOp = _ref[1];\n var _ref2 = [reversedGroupOpDef, groupOperatorDef];\n groupOperatorDef = _ref2[0];\n reversedGroupOpDef = _ref2[1];\n }\n\n // conj\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var conjunctionDefinition = config.conjunctions[conjunction];\n if (!conjunctionDefinition) return undefined;\n // rev conj\n var reversedConj = conjunctionDefinition.reversedConj;\n var canRev = not && ((_conjunction = conjunction) === null || _conjunction === void 0 ? void 0 : _conjunction.toLowerCase()) === \"or\" && reversedConj && !isRuleGroup && !!reverseOperatorsForNot && !exportPreserveGroups;\n if (canRev) {\n conjunction = reversedConj;\n conjunctionDefinition = config.conjunctions[conjunction];\n not = !not;\n revChildren = true;\n }\n var mongoConj = conjunctionDefinition.mongoConj;\n\n // tip: can't use \"$expr\" inside \"$filter\".\"cond\" or inside \"$elemMatch\"\n var canWrapExpr = !isRuleGroup && !isInsideRuleGroup;\n var formatFieldNameFn = mode == \"array\" ? function (f) {\n return \"$$el\".concat(sep).concat(f);\n } : _formatFieldName;\n var list = children.map(function (currentChild) {\n return formatItem([].concat(_toConsumableArray(parents), [item]), currentChild, config, meta, revChildren, canWrapExpr, formatFieldNameFn);\n }).filter(function (formattedChild) {\n return typeof formattedChild !== \"undefined\";\n });\n if (!canHaveEmptyChildren && !list.size) {\n return undefined;\n }\n var resultQuery;\n var shortQuery;\n if (list.size == 1) {\n resultQuery = list.first();\n } else if (list.size > 1) {\n var rules = list.toList().toJS();\n var canShort = canShortMongoQuery && mongoConj == \"$and\" && !exportPreserveGroups;\n if (canShort) {\n resultQuery = rules.reduce(function (acc, rule) {\n if (!acc) return undefined;\n for (var k in rule) {\n if (k[0] == \"$\") {\n acc = undefined;\n break;\n }\n if (acc[k] == undefined) {\n acc[k] = rule[k];\n } else {\n // https://github.com/ukrbublik/react-awesome-query-builder/issues/182\n var prev = acc[k],\n next = rule[k];\n if (!isObject(prev)) {\n prev = {\n \"$eq\": prev\n };\n }\n if (!isObject(next)) {\n next = {\n \"$eq\": next\n };\n }\n var prevOp = Object.keys(prev)[0],\n nextOp = Object.keys(next)[0];\n if (prevOp == nextOp) {\n acc = undefined;\n break;\n }\n acc[k] = Object.assign({}, prev, next);\n }\n }\n return acc;\n }, {});\n }\n if (resultQuery) {\n shortQuery = true;\n } else {\n // can't be shorten\n shortQuery = false;\n resultQuery = _defineProperty({}, mongoConj, rules);\n }\n }\n if (groupField) {\n if (mode == \"array\") {\n var totalQuery = {\n \"$size\": {\n \"$ifNull\": [\"$\" + mongoFieldEscape(groupFieldName), []]\n }\n };\n if (filterNot && resultQuery) {\n resultQuery = {\n \"$not\": resultQuery\n };\n filterNot = false;\n }\n var filterQuery = resultQuery ? {\n \"$size\": {\n \"$ifNull\": [{\n \"$filter\": {\n input: \"$\" + mongoFieldEscape(groupFieldName),\n as: \"el\",\n cond: resultQuery\n }\n }, []]\n }\n } : totalQuery;\n var notForRule = !exportPreserveGroups ? not : false;\n resultQuery = formatItem(parents, item.set(\"type\", \"rule\"), config, meta, notForRule, false, function (_f) {\n return filterQuery;\n }, totalQuery);\n if (notForRule) {\n not = false;\n }\n resultQuery = {\n \"$expr\": resultQuery\n };\n } else {\n // tip: $elemMatch can't have $not and $expr inside BUT can have $nor\n resultQuery = _defineProperty({}, mongoFieldEscape(groupFieldName), {\n \"$elemMatch\": resultQuery\n });\n }\n }\n if (not) {\n // tip: $nor can't be inside $filter.cond or $expr\n if (isInsideRuleGroupArray) {\n // inside $filter.cond\n resultQuery = {\n \"$not\": resultQuery\n };\n } else {\n resultQuery = {\n \"$nor\": [resultQuery]\n };\n }\n }\n return resultQuery;\n};\nvar formatRule = function formatRule(parents, item, config, meta) {\n var _parents$filter2, _operatorDefinition, _operatorDefinition2, _revOperatorDefinitio, _operatorDefinition3, _revOperatorDefinitio2, _revOperatorDefinitio3, _operatorDefinition4;\n var _not = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var _canWrapExpr = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;\n var _formatFieldName = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;\n var _value = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : undefined;\n var properties = item.get(\"properties\") || new Map();\n var parentRuleGroup = (_parents$filter2 = parents.filter(function (it) {\n return it.get(\"type\") == \"rule_group\";\n })) === null || _parents$filter2 === void 0 || (_parents$filter2 = _parents$filter2.slice(-1)) === null || _parents$filter2 === void 0 ? void 0 : _parents$filter2.pop();\n var parentRuleGroupField = parentRuleGroup === null || parentRuleGroup === void 0 ? void 0 : parentRuleGroup.get(\"properties\").get(\"field\");\n var operator = properties.get(\"operator\");\n var operatorOptions = properties.get(\"operatorOptions\");\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var iValue = properties.get(\"value\");\n var iValueSrc = properties.get(\"valueSrc\");\n var iValueType = properties.get(\"valueType\");\n var asyncListValues = properties.get(\"asyncListValues\");\n if (field == null || operator == null || iValue === undefined) return undefined;\n var fieldDef = getFieldConfig(config, field);\n\n // check op\n var operatorDefinition = getOperatorConfig(config, operator, field);\n var reversedOp = (_operatorDefinition = operatorDefinition) === null || _operatorDefinition === void 0 ? void 0 : _operatorDefinition.reversedOp;\n var revOperatorDefinition = getOperatorConfig(config, reversedOp, field);\n var cardinality = getOpCardinality(operatorDefinition);\n if (!((_operatorDefinition2 = operatorDefinition) !== null && _operatorDefinition2 !== void 0 && _operatorDefinition2.mongoFormatOp) && !((_revOperatorDefinitio = revOperatorDefinition) !== null && _revOperatorDefinitio !== void 0 && _revOperatorDefinitio.mongoFormatOp)) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n\n // try reverse\n var not = _not;\n var opNeedsReverse = !((_operatorDefinition3 = operatorDefinition) !== null && _operatorDefinition3 !== void 0 && _operatorDefinition3.mongoFormatOp) && !!((_revOperatorDefinitio2 = revOperatorDefinition) !== null && _revOperatorDefinitio2 !== void 0 && _revOperatorDefinitio2.mongoFormatOp);\n var opCanReverse = !!((_revOperatorDefinitio3 = revOperatorDefinition) !== null && _revOperatorDefinitio3 !== void 0 && _revOperatorDefinitio3.mongoFormatOp);\n var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse);\n var needRev = canRev && not || opNeedsReverse;\n var isRev = false;\n if (needRev) {\n var _ref3 = [reversedOp, operator];\n operator = _ref3[0];\n reversedOp = _ref3[1];\n var _ref4 = [revOperatorDefinition, operatorDefinition];\n operatorDefinition = _ref4[0];\n revOperatorDefinition = _ref4[1];\n not = !not;\n isRev = true;\n }\n var formattedField;\n var useExpr = false;\n if (fieldSrc == \"func\") {\n var _formatFunc = formatFunc(meta, config, field, parentRuleGroupField);\n var _formatFunc2 = _slicedToArray(_formatFunc, 2);\n formattedField = _formatFunc2[0];\n useExpr = _formatFunc2[1];\n } else {\n formattedField = formatFieldName(field, config, meta, parentRuleGroupField);\n formattedField = mongoFieldEscape(formattedField);\n if (_formatFieldName) {\n useExpr = true;\n formattedField = _formatFieldName(formattedField);\n }\n }\n if (formattedField == undefined) return undefined;\n\n //format value\n var valueSrcs = [];\n var valueTypes = [];\n var formattedValue;\n if (iValue != undefined) {\n var fvalue = iValue.map(function (currentValue, ind) {\n var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;\n var valueType = iValueType ? iValueType.get(ind) : null;\n var cValue = completeValue(currentValue, valueSrc, config);\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, field, operator, widget, valueSrc, {\n forExport: true\n });\n var _formatValue = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDef, fieldDef, parentRuleGroupField, operator, operatorDefinition, asyncListValues),\n _formatValue2 = _slicedToArray(_formatValue, 2),\n fv = _formatValue2[0],\n fvUseExpr = _formatValue2[1];\n if (fv !== undefined) {\n useExpr = useExpr || fvUseExpr;\n valueSrcs.push(valueSrc);\n valueTypes.push(valueType);\n }\n return fv;\n });\n var hasUndefinedValues = fvalue.filter(function (v) {\n return v === undefined;\n }).size > 0;\n if (fvalue.size < cardinality || hasUndefinedValues) return undefined;\n formattedValue = cardinality > 1 ? fvalue.toArray() : cardinality == 1 ? fvalue.first() : null;\n }\n var wrapExpr = useExpr && _canWrapExpr;\n\n //build rule\n var fn = (_operatorDefinition4 = operatorDefinition) === null || _operatorDefinition4 === void 0 ? void 0 : _operatorDefinition4.mongoFormatOp;\n var args = [formattedField, operator, _value !== undefined && formattedValue == null ? _value : formattedValue, not, useExpr, valueSrcs.length > 1 ? valueSrcs : valueSrcs[0], valueTypes.length > 1 ? valueTypes : valueTypes[0], omit(operatorDefinition, opDefKeysToOmit), operatorOptions, fieldDef];\n // `mongoFormatOp` function SHOULD handle `not`\n var ruleQuery = fn.call.apply(fn, [config.ctx].concat(args));\n if (wrapExpr) {\n // if (not) {\n // ruleQuery = { \"$not\": ruleQuery };\n // }\n ruleQuery = {\n \"$expr\": ruleQuery\n };\n } else {\n // if (not) {\n // ruleQuery = { \"$nor\": [ ruleQuery ] };\n // }\n }\n return ruleQuery;\n};\nvar formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, parentPath, operator, operatorDef, asyncListValues) {\n if (currentValue === undefined) return [undefined, false];\n var ret;\n var useExpr = false;\n if (valueSrc == \"field\") {\n var _formatRightField = formatRightField(meta, config, currentValue, parentPath);\n var _formatRightField2 = _slicedToArray(_formatRightField, 2);\n ret = _formatRightField2[0];\n useExpr = _formatRightField2[1];\n } else if (valueSrc == \"func\") {\n var _formatFunc3 = formatFunc(meta, config, currentValue, parentPath);\n var _formatFunc4 = _slicedToArray(_formatFunc3, 2);\n ret = _formatFunc4[0];\n useExpr = _formatFunc4[1];\n } else {\n var _ret;\n if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.mongoFormatValue) === \"function\") {\n var fn = fieldWidgetDef.mongoFormatValue;\n var args = [currentValue, _objectSpread(_objectSpread({}, fieldDef ? pick(fieldDef, [\"fieldSettings\", \"listValues\"]) : {}), {}, {\n asyncListValues: asyncListValues\n }),\n //useful options: valueFormat for date/time\n omit(fieldWidgetDef, widgetDefKeysToOmit)];\n if (operator) {\n args.push(operator);\n args.push(operatorDef);\n }\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n } else {\n ret = currentValue;\n }\n if ((_ret = ret) !== null && _ret !== void 0 && _ret[\"$dateFromString\"]) {\n // $dateFromString (or $toDate) is an aggregation operator only\n useExpr = true;\n }\n }\n return [ret, useExpr];\n};\nvar formatRightField = function formatRightField(meta, config, rightField, parentPath) {\n var fieldSeparator = config.settings.fieldSeparator;\n var ret;\n var useExpr = true;\n if (rightField) {\n var rightFieldDefinition = getFieldConfig(config, rightField) || {};\n var fieldParts = getFieldParts(rightField, config);\n var fieldPartsLabels = getFieldPathLabels(rightField, config);\n var fieldFullLabel = fieldPartsLabels ? fieldPartsLabels.join(fieldSeparator) : null;\n var formatFieldFn = config.settings.formatField;\n var rightFieldName = formatFieldName(rightField, config, meta, parentPath);\n var formattedField = formatFieldFn(rightFieldName, fieldParts, fieldFullLabel, rightFieldDefinition, config, false);\n ret = \"$\" + mongoFieldEscape(formattedField);\n }\n return [ret, useExpr];\n};\nvar formatFunc = function formatFunc(meta, config, currentValue, parentPath) {\n var _currentValue$get, _currentValue$get2;\n var useExpr = true;\n var ret;\n var funcKey = (_currentValue$get = currentValue.get) === null || _currentValue$get === void 0 ? void 0 : _currentValue$get.call(currentValue, \"func\");\n var args = (_currentValue$get2 = currentValue.get) === null || _currentValue$get2 === void 0 ? void 0 : _currentValue$get2.call(currentValue, \"args\");\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not defined in config\"));\n return [undefined, false];\n }\n var funcParts = getFieldParts(funcKey, config);\n var funcLastKey = funcParts[funcParts.length - 1];\n var funcName = funcConfig.mongoFunc || funcLastKey;\n var mongoArgsAsObject = funcConfig.mongoArgsAsObject;\n var formattedArgs = {};\n var argsCnt = 0;\n var lastArg = undefined;\n var gaps = [];\n var missingArgKeys = [];\n for (var argKey in funcConfig.args) {\n var _argValue;\n argsCnt++;\n var argConfig = funcConfig.args[argKey];\n var fieldDef = getFieldConfig(config, argConfig);\n var defaultValue = argConfig.defaultValue,\n isOptional = argConfig.isOptional;\n var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? \"func\" : \"value\";\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValueSrc !== \"func\" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {\n // value should not be Immutable\n argValue = argValue.toJS();\n }\n var argAsyncListValues = argVal ? argVal.get(\"asyncListValues\") : undefined;\n var operator = null;\n var widget = getWidgetForFieldOp(config, argConfig, operator, argValueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, widget, argValueSrc, {\n forExport: true\n });\n var _formatValue3 = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldWidgetDef, fieldDef, parentPath, null, null, argAsyncListValues),\n _formatValue4 = _slicedToArray(_formatValue3, 2),\n formattedArgVal = _formatValue4[0],\n _argUseExpr = _formatValue4[1];\n if (argValue != undefined && formattedArgVal === undefined) {\n if (argValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return [undefined, false];\n }\n var formattedDefaultVal = void 0;\n if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {\n var defaultWidget = getWidgetForFieldOp(config, argConfig, operator, defaultValueSrc);\n var defaultFieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, defaultWidget, defaultValueSrc, {\n forExport: true\n });\n var _ = void 0;\n var _formatValue5 = formatValue(meta, config, defaultValue, defaultValueSrc, argConfig.type, defaultFieldWidgetDef, fieldDef, parentPath, null, null, argAsyncListValues);\n var _formatValue6 = _slicedToArray(_formatValue5, 2);\n formattedDefaultVal = _formatValue6[0];\n _ = _formatValue6[1];\n if (formattedDefaultVal === undefined) {\n if (defaultValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format default value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return [undefined, false];\n }\n }\n var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;\n if (finalFormattedVal !== undefined) {\n if (gaps.length) {\n var _iterator = _createForOfIteratorHelper(gaps),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var missedArgKey = _step.value;\n formattedArgs[missedArgKey] = undefined;\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n gaps = [];\n }\n formattedArgs[argKey] = finalFormattedVal;\n lastArg = finalFormattedVal;\n } else {\n if (!isOptional) missingArgKeys.push(argKey);\n gaps.push(argKey);\n }\n }\n if (missingArgKeys.length) {\n //meta.errors.push(`Missing vals for args ${missingArgKeys.join(\", \")} for func ${funcKey}`);\n return [undefined, false]; // incomplete\n }\n if (typeof funcConfig.mongoFormatFunc === \"function\") {\n var fn = funcConfig.mongoFormatFunc;\n var _args = [formattedArgs];\n ret = fn.call.apply(fn, [config.ctx].concat(_args));\n } else if (funcConfig.mongoFormatFunc === null) {\n meta.errors.push(\"Functon \".concat(funcName, \" is not supported\"));\n return [undefined, false];\n } else {\n if (mongoArgsAsObject) ret = _defineProperty({}, funcName, formattedArgs);else if (argsCnt == 1 && lastArg !== undefined) ret = _defineProperty({}, funcName, lastArg);else ret = _defineProperty({}, funcName, Object.values(formattedArgs));\n }\n return [ret, useExpr];\n};","import _typeof from \"@babel/runtime/helpers/typeof\";\nvar spelEscapeString = function spelEscapeString(val) {\n // Strings are delimited by single quotes. To put a single quote itself in a string, use two single quote characters. \n return \"'\" + val.replace(/'/g, \"''\") + \"'\";\n};\nvar spelInlineList = function spelInlineList(vals) {\n var toArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n // find java type of values\n var javaType;\n var jt;\n var numberJavaTypes = [\"int\", \"float\"];\n vals.map(function (v) {\n if (v !== undefined && v !== null) {\n if (typeof v === \"string\") {\n jt = \"String\";\n } else if (typeof v === \"number\") {\n jt = Number.isInteger(v) ? \"int\" : \"float\";\n } else throw new Error(\"spelEscape: Can't use value \".concat(v, \" in array\"));\n if (!javaType) {\n javaType = jt;\n } else if (javaType != jt) {\n if (numberJavaTypes.includes(javaType) && numberJavaTypes.includes(jt)) {\n // found int and float in collecton - use float\n javaType = \"float\";\n } else throw new Error(\"spelEscape: Can't use different types in array: found \".concat(javaType, \" and \").concat(jt));\n }\n }\n });\n if (!javaType) {\n javaType = \"String\"; //default if empty array\n }\n\n // for floats we should add 'f' to all items\n var escapedVals;\n if (javaType == \"float\") {\n escapedVals = vals.map(function (v) {\n return spelEscape(v, true);\n });\n } else {\n escapedVals = vals.map(function (v) {\n return spelEscape(v);\n });\n }\n\n // build inline list or array\n var res;\n if (toArray) {\n res = \"new \".concat(javaType, \"[]{\").concat(escapedVals.join(\", \"), \"}\");\n } else {\n res = \"{\".concat(escapedVals.join(\", \"), \"}\");\n }\n return res;\n};\nexport var spelEscape = function spelEscape(val) {\n var numberToFloat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n var arrayToArray = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n // https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/expressions.html#expressions-ref-literal\n if (val === undefined || val === null) {\n return \"null\";\n }\n switch (_typeof(val)) {\n case \"boolean\":\n return val ? \"true\" : \"false\";\n case \"number\":\n if (!Number.isFinite(val) || isNaN(val)) return undefined;\n return val + (!Number.isInteger(val) || numberToFloat ? \"f\" : \"\");\n case \"object\":\n if (Array.isArray(val)) {\n return spelInlineList(val, arrayToArray);\n } else {\n // see `spelFormatValue` for Date, LocalTime\n throw new Error(\"spelEscape: Object is not supported\");\n }\n default:\n return spelEscapeString(val);\n }\n};\n\n// @deprecated\nexport var spelFormatConcat = function spelFormatConcat(parts) {\n if (parts && Array.isArray(parts) && parts.length) {\n return parts.map(function (part) {\n if (part.type == \"const\") {\n return spelEscape(part.value);\n } else if (part.type == \"property\") {\n return \"\" + part.value;\n } else if (part.type == \"variable\") {\n return \"#\" + part.value;\n }\n return undefined;\n }).filter(function (r) {\n return r != undefined;\n }).join(\" + \");\n } else {\n return \"null\";\n }\n};\n\n// @deprecated\n// `val` is {value, valueType, valueSrc}\n// If `valueType` == \"case_value\", `value` is array of such items (to be considered as concatenation)\nexport var spelImportConcat = function spelImportConcat(val) {\n if (val == undefined) return [undefined, []];\n var errors = [];\n var value = val.valueType == \"case_value\" ? val.value : val;\n var valueArr = Array.isArray(value) ? value : [value];\n var res = valueArr.map(function (child) {\n if (child.valueSrc === \"value\") {\n if (child.value === null) {\n return undefined;\n } else {\n return {\n type: \"const\",\n value: child.value\n };\n }\n } else if (child.valueSrc === \"field\") {\n return {\n type: child.isVariable ? \"variable\" : \"property\",\n value: child.value\n };\n } else {\n errors.push(\"Unsupported valueSrc \".concat(child.valueSrc, \" in concatenation\"));\n }\n }).filter(function (v) {\n return v != undefined;\n });\n return [res, errors];\n};\nexport var spelFixList = function spelFixList(val) {\n // `{1,2}.contains(1)` NOT works\n // `{1,2}.?[true].contains(1)` works\n return \"\".concat(val, \".?[true]\");\n};","import SqlStringOrig from \"sqlstring\";\n\n// @deprecated Use dedicated utils instead\nexport { mongoEmptyValue } from \"./mongoUtils\";\nexport { spelEscape, spelFixList, spelFormatConcat, spelImportConcat } from \"./spelUtils\";\n\n// todo: move to sqlUtils\nexport var SqlString = SqlStringOrig;\nSqlString.trim = function (val) {\n if ((val === null || val === void 0 ? void 0 : val.charAt(0)) == \"'\") return val.substring(1, val.length - 1);else return val;\n};\nSqlString.unescapeLike = function (val) {\n var sqlDialect = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;\n if (typeof val !== \"string\") {\n return val;\n }\n var res = val;\n // unescape % and _\n if (sqlDialect === \"BigQuery\") {\n // https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#like_operator\n res = res.replace(/\\\\\\\\([%_])/g, \"$1\");\n } else {\n res = res.replace(/\\\\([%_])/g, \"$1\");\n }\n return res;\n};\nSqlString.escapeLike = function (val) {\n var any_start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var any_end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n var sqlDialect = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n if (typeof val !== \"string\") {\n return val;\n }\n // normal escape\n var res = SqlString.escape(val);\n // unwrap ''\n res = SqlString.trim(res);\n // escape % and _\n if (sqlDialect === \"BigQuery\") {\n // https://cloud.google.com/bigquery/docs/reference/standard-sql/operators#like_operator\n res = res.replace(/[%_\\\\]/g, \"\\\\\\\\$&\");\n } else {\n res = res.replace(/[%_]/g, \"\\\\$&\");\n }\n // wrap with % for LIKE\n res = (any_start ? \"%\" : \"\") + res + (any_end ? \"%\" : \"\");\n // wrap ''\n res = \"'\" + res + \"'\";\n return res;\n};\nexport var sqlEmptyValue = function sqlEmptyValue(fieldDef) {\n var v = \"''\";\n var type = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type;\n if (type == \"date\") {\n //todo: support other SQL dialects? 0001-01-01 for oracle, 1970-01-01 for timestamp\n v = \"'0000-00-00'\";\n } else if (type == \"datetime\") {\n v = \"'0000-00-00 00:00'\";\n } else if (type == \"time\") {\n v = \"'00:00'\";\n } else if (type == \"number\") {\n v = \"0\";\n }\n return v;\n};\nexport var stringifyForDisplay = function stringifyForDisplay(v) {\n return v == null ? \"NULL\" : v.toString();\n};\nexport var wrapWithBrackets = function wrapWithBrackets(v) {\n if (v == undefined) return v;\n if ((v === null || v === void 0 ? void 0 : v[0]) === \"(\" && (v === null || v === void 0 ? void 0 : v[(v === null || v === void 0 ? void 0 : v.length) - 1]) === \")\") {\n // already wrapped\n return v;\n }\n return \"(\" + v + \")\";\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldParts, getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { getFieldPathLabels, formatFieldName, completeValue } from \"../utils/ruleUtils\";\nimport pick from \"lodash/pick\";\nimport { getOpCardinality, widgetDefKeysToOmit, opDefKeysToOmit, omit } from \"../utils/stuff\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { List, Map } from \"immutable\";\nimport { SqlString } from \"../utils/export\";\nexport var sqlFormat = function sqlFormat(tree, config) {\n return _sqlFormat(tree, config, false);\n};\nexport var _sqlFormat = function _sqlFormat(tree, config) {\n var returnErrors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //meta is mutable\n var meta = {\n errors: []\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var res = formatItem(tree, extendedConfig, meta);\n if (returnErrors) {\n return [res, meta.errors];\n } else {\n if (meta.errors.length) console.warn(\"Errors while exporting to SQL:\", meta.errors);\n return res;\n }\n};\nvar formatItem = function formatItem(item, config, meta) {\n if (!item) return undefined;\n var type = item.get(\"type\");\n var children = item.get(\"children1\");\n if (type === \"group\" || type === \"rule_group\") {\n return formatGroup(item, config, meta);\n } else if (type === \"rule\") {\n return formatRule(item, config, meta);\n }\n return undefined;\n};\nvar formatGroup = function formatGroup(item, config, meta) {\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var children = item.get(\"children1\") || new List();\n var isRuleGroup = type === \"rule_group\";\n var groupField = isRuleGroup ? properties.get(\"field\") : null;\n var groupFieldDef = getFieldConfig(config, groupField) || {};\n var mode = groupFieldDef.mode;\n if (mode == \"array\") {\n meta.errors.push(\"Aggregation is not supported for \".concat(groupField));\n }\n var not = properties.get(\"not\");\n var canHaveEmptyChildren = false; //isRuleGroup && mode == \"array\";\n var list = children.map(function (currentChild) {\n return formatItem(currentChild, config, meta);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n });\n if (!canHaveEmptyChildren && !list.size) return undefined;\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var conjunctionDefinition = config.conjunctions[conjunction];\n return conjunctionDefinition.sqlFormatConj.call(config.ctx, list, conjunction, not);\n};\nvar buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition) {\n var sqlOp = operatorDefinition.sqlOp || operator;\n var cardinality = getOpCardinality(operatorDefinition);\n var fn;\n if (cardinality == 0) {\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" \").concat(sqlOp);\n };\n } else if (cardinality == 1) {\n fn = function fn(field, op, value, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" \").concat(sqlOp, \" \").concat(value);\n };\n } else if (cardinality == 2) {\n // between\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var _values$first, _values$get;\n var valFrom = values === null || values === void 0 || (_values$first = values.first) === null || _values$first === void 0 ? void 0 : _values$first.call(values);\n var valTo = values === null || values === void 0 || (_values$get = values.get) === null || _values$get === void 0 ? void 0 : _values$get.call(values, 1);\n return \"\".concat(field, \" \").concat(sqlOp, \" \").concat(valFrom, \" AND \").concat(valTo);\n };\n }\n return fn;\n};\nvar formatRule = function formatRule(item, config, meta) {\n var properties = item.get(\"properties\") || new Map();\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var operator = properties.get(\"operator\");\n var operatorOptions = properties.get(\"operatorOptions\");\n var iValueSrc = properties.get(\"valueSrc\");\n var iValueType = properties.get(\"valueType\");\n var iValue = properties.get(\"value\");\n var asyncListValues = properties.get(\"asyncListValues\");\n if (field == null || operator == null) return undefined;\n var fieldDefinition = getFieldConfig(config, field) || {};\n var opDef = getOperatorConfig(config, operator, field) || {};\n var reversedOp = opDef.reversedOp;\n var revOpDef = getOperatorConfig(config, reversedOp, field) || {};\n var cardinality = getOpCardinality(opDef);\n\n // check op\n var isRev = false;\n var canFormatOp = opDef.sqlOp || opDef.sqlFormatOp;\n var canFormatRevOp = revOpDef.sqlOp || revOpDef.sqlFormatOp;\n if (!canFormatOp && !canFormatRevOp) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n if (!canFormatOp && canFormatRevOp) {\n isRev = true;\n var _ref = [reversedOp, operator];\n operator = _ref[0];\n reversedOp = _ref[1];\n var _ref2 = [revOpDef, opDef];\n opDef = _ref2[0];\n revOpDef = _ref2[1];\n }\n\n //format value\n var valueSrcs = [];\n var valueTypes = [];\n var formattedValue;\n if (iValue != undefined) {\n var fvalue = iValue.map(function (currentValue, ind) {\n var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;\n var valueType = iValueType ? iValueType.get(ind) : null;\n var cValue = completeValue(currentValue, valueSrc, config);\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDefinition = getFieldWidgetConfig(config, field, operator, widget, valueSrc, {\n forExport: true\n });\n var fv = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDefinition, fieldDefinition, operator, opDef, asyncListValues);\n if (fv !== undefined) {\n valueSrcs.push(valueSrc);\n valueTypes.push(valueType);\n }\n return fv;\n });\n var hasUndefinedValues = fvalue.filter(function (v) {\n return v === undefined;\n }).size > 0;\n if (hasUndefinedValues || fvalue.size < cardinality) return undefined;\n formattedValue = cardinality == 1 ? fvalue.first() : fvalue;\n }\n\n //find fn to format expr\n var fn = opDef.sqlFormatOp || buildFnToFormatOp(operator, opDef);\n if (!fn) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n\n //format field\n var formattedField = fieldSrc == \"func\" ? formatFunc(meta, config, field) : formatField(meta, config, field);\n if (formattedField == undefined) return undefined;\n\n //format expr\n var args = [formattedField, operator, formattedValue, valueSrcs.length > 1 ? valueSrcs : valueSrcs[0], valueTypes.length > 1 ? valueTypes : valueTypes[0], omit(opDef, opDefKeysToOmit), operatorOptions, fieldDefinition];\n var ret;\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n if (isRev) {\n ret = config.settings.sqlFormatReverse.call(config.ctx, ret);\n }\n if (ret === undefined) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported for value source \").concat(valueSrcs.join(\", \")));\n return undefined;\n }\n return ret;\n};\nvar formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef, asyncListValues) {\n if (currentValue === undefined) return undefined;\n var ret;\n if (valueSrc == \"field\") {\n ret = formatField(meta, config, currentValue);\n } else if (valueSrc == \"func\") {\n ret = formatFunc(meta, config, currentValue);\n } else if (currentValue == undefined) {\n ret = undefined;\n } else {\n if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.sqlFormatValue) === \"function\") {\n var fn = fieldWidgetDef.sqlFormatValue;\n var valFieldDefinition = valueSrc == \"field\" && getFieldConfig(config, currentValue) || {};\n var args = [currentValue, _objectSpread(_objectSpread({}, pick(fieldDef, [\"fieldSettings\", \"listValues\"])), {}, {\n asyncListValues: asyncListValues\n }),\n //useful options: valueFormat for date/time\n omit(fieldWidgetDef, widgetDefKeysToOmit), operator, operatorDef, valFieldDefinition, config.settings.sqlDialect];\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n } else {\n if (Array.isArray(currentValue)) {\n ret = currentValue.map(function (v) {\n return SqlString.escape(v);\n });\n } else {\n ret = SqlString.escape(currentValue);\n }\n }\n }\n return ret;\n};\nvar formatField = function formatField(meta, config, field) {\n if (!field) return;\n var fieldSeparator = config.settings.fieldSeparator;\n var fieldDefinition = getFieldConfig(config, field) || {};\n var fieldParts = getFieldParts(field, config);\n var fieldPartsLabels = getFieldPathLabels(field, config);\n var fieldFullLabel = fieldPartsLabels ? fieldPartsLabels.join(fieldSeparator) : null;\n var formatFieldFn = config.settings.formatField;\n var fieldName = formatFieldName(field, config, meta, null, {\n useTableName: true\n });\n var formattedField = formatFieldFn(fieldName, fieldParts, fieldFullLabel, fieldDefinition, config);\n return formattedField;\n};\nvar formatFunc = function formatFunc(meta, config, currentValue) {\n var _currentValue$get, _currentValue$get2;\n var funcKey = (_currentValue$get = currentValue.get) === null || _currentValue$get === void 0 ? void 0 : _currentValue$get.call(currentValue, \"func\");\n var args = (_currentValue$get2 = currentValue.get) === null || _currentValue$get2 === void 0 ? void 0 : _currentValue$get2.call(currentValue, \"args\");\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not defined in config\"));\n return undefined;\n }\n var funcParts = getFieldParts(funcKey, config);\n var funcLastKey = funcParts[funcParts.length - 1];\n var funcName = funcConfig.sqlFunc || funcLastKey;\n var formattedArgs = {};\n var gaps = [];\n var missingArgKeys = [];\n for (var argKey in funcConfig.args) {\n var _argValue;\n var argConfig = funcConfig.args[argKey];\n var fieldDef = getFieldConfig(config, argConfig);\n var defaultValue = argConfig.defaultValue,\n isOptional = argConfig.isOptional;\n var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? \"func\" : \"value\";\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValueSrc !== \"func\" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {\n // value should not be Immutable\n argValue = argValue.toJS();\n }\n var argAsyncListValues = argVal ? argVal.get(\"asyncListValues\") : undefined;\n var formattedArgVal = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldDef, argConfig, null, null, argAsyncListValues);\n if (argValue != undefined && formattedArgVal === undefined) {\n if (argValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n var formattedDefaultVal = void 0;\n if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {\n formattedDefaultVal = formatValue(meta, config, defaultValue, defaultValueSrc, argConfig.type, fieldDef, argConfig, null, null, argAsyncListValues);\n if (formattedDefaultVal === undefined) {\n if (defaultValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format default value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n }\n var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;\n if (finalFormattedVal !== undefined) {\n if (gaps.length) {\n var _iterator = _createForOfIteratorHelper(argKey),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var missedArgKey = _step.value;\n formattedArgs[missedArgKey] = undefined;\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n gaps = [];\n }\n formattedArgs[argKey] = finalFormattedVal;\n } else {\n if (!isOptional) missingArgKeys.push(argKey);\n gaps.push(argKey);\n }\n }\n if (missingArgKeys.length) {\n //meta.errors.push(`Missing vals for args ${missingArgKeys.join(\", \")} for func ${funcKey}`);\n return undefined; // incomplete\n }\n var ret;\n if (typeof funcConfig.sqlFormatFunc === \"function\") {\n var fn = funcConfig.sqlFormatFunc;\n var _args = [formattedArgs, config.settings.sqlDialect];\n ret = fn.call.apply(fn, [config.ctx].concat(_args));\n } else {\n var argsStr = Object.entries(formattedArgs).map(function (_ref3) {\n var _ref4 = _slicedToArray(_ref3, 2),\n k = _ref4[0],\n v = _ref4[1];\n return v;\n }).join(\", \");\n ret = \"\".concat(funcName, \"(\").concat(argsStr, \")\");\n }\n return ret;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldParts, getWidgetForFieldOp, getFieldPartsConfigs } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { formatFieldName, completeValue } from \"../utils/ruleUtils\";\nimport pick from \"lodash/pick\";\nimport { getOpCardinality, widgetDefKeysToOmit, opDefKeysToOmit, omit } from \"../utils/stuff\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { List, Map } from \"immutable\";\nimport { spelEscape } from \"../utils/spelUtils\";\n\n// https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/expressions.html#expressions\n\nexport var compareToSign = \"${0}.compareTo(${1})\";\nvar TypesWithCompareTo = {\n datetime: true,\n time: true,\n date: true\n};\nexport var spelFormat = function spelFormat(tree, config) {\n return _spelFormat(tree, config, false);\n};\nexport var _spelFormat = function _spelFormat(tree, config) {\n var returnErrors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //meta is mutable\n var meta = {\n errors: []\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var res = formatItem(tree, extendedConfig, meta, null);\n if (returnErrors) {\n return [res, meta.errors];\n } else {\n if (meta.errors.length) console.warn(\"Errors while exporting to SpEL:\", meta.errors);\n return res;\n }\n};\nvar formatItem = function formatItem(item, config, meta) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n if (!item) return undefined;\n var type = item.get(\"type\");\n if (type === \"group\" || type === \"rule_group\") {\n return formatGroup(item, config, meta, parentField);\n } else if (type === \"rule\") {\n return formatRule(item, config, meta, parentField);\n } else if (type == \"switch_group\") {\n return formatSwitch(item, config, meta, parentField);\n } else if (type == \"case_group\") {\n return formatCase(item, config, meta, parentField);\n }\n return undefined;\n};\nvar formatCase = function formatCase(item, config, meta) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var type = item.get(\"type\");\n if (type != \"case_group\") {\n meta.errors.push(\"Unexpected child of type \".concat(type, \" inside switch\"));\n return undefined;\n }\n var properties = item.get(\"properties\") || new Map();\n var _formatItemValue = formatItemValue(config, properties, meta, null, parentField, \"!case_value\"),\n formattedValue = _formatItemValue.value,\n valueSrc = _formatItemValue.valueSrc,\n valueType = _formatItemValue.valueType;\n var cond = formatGroup(item, config, meta, parentField);\n return [cond, formattedValue];\n};\nvar formatSwitch = function formatSwitch(item, config, meta) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var properties = item.get(\"properties\") || new Map();\n var children = item.get(\"children1\");\n if (!children) return undefined;\n var cases = children.map(function (currentChild) {\n return formatCase(currentChild, config, meta, null);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n }).valueSeq().toArray();\n if (!cases.length) return undefined;\n if (cases.length == 1 && !cases[0][0]) {\n // only 1 case without condition\n return cases[0][1];\n }\n var filteredCases = [];\n for (var i = 0; i < cases.length; i++) {\n if (i != cases.length - 1 && !cases[i][0]) {\n meta.errors.push(\"No condition for case \".concat(i));\n } else {\n filteredCases.push(cases[i]);\n if (i == cases.length - 1 && cases[i][0]) {\n // no default - add null as default\n filteredCases.push([undefined, null]);\n }\n }\n }\n var left = \"\",\n right = \"\";\n for (var _i = 0; _i < filteredCases.length; _i++) {\n var _filteredCases$_i = _slicedToArray(filteredCases[_i], 2),\n cond = _filteredCases$_i[0],\n value = _filteredCases$_i[1];\n if (value == undefined) value = \"null\";\n if (cond == undefined) cond = \"true\";\n if (_i != filteredCases.length - 1) {\n left += \"(\".concat(cond, \" ? \").concat(value, \" : \");\n right += \")\";\n } else {\n left += \"\".concat(value);\n }\n }\n return left + right;\n};\nvar formatGroup = function formatGroup(item, config, meta) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var mode = properties.get(\"mode\");\n var children = item.get(\"children1\") || new List();\n var field = properties.get(\"field\");\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var conjunctionDefinition = config.conjunctions[conjunction];\n var not = properties.get(\"not\");\n var isRuleGroup = type === \"rule_group\" && field;\n var isRuleGroupArray = isRuleGroup && mode != \"struct\";\n var groupField = isRuleGroupArray ? field : parentField;\n var groupFieldDef = getFieldConfig(config, groupField) || {};\n var isSpelArray = groupFieldDef.isSpelArray;\n var fieldSeparator = config.settings.fieldSeparator;\n\n // check op for reverse\n var groupOperator = properties.get(\"operator\");\n if (!groupOperator && (!mode || mode == \"some\")) {\n groupOperator = \"some\";\n }\n var realGroupOperator = checkOp(config, groupOperator, field);\n var isGroupOpRev = realGroupOperator != groupOperator;\n var realGroupOperatorDefinition = groupOperator && getOperatorConfig(config, realGroupOperator, field) || null;\n var isGroup0 = isRuleGroup && (!realGroupOperator || realGroupOperatorDefinition.cardinality == 0);\n\n // build value for aggregation op\n var _formatItemValue2 = formatItemValue(config, properties, meta, realGroupOperator, parentField, null),\n formattedValue = _formatItemValue2.value,\n valueSrc = _formatItemValue2.valueSrc,\n valueType = _formatItemValue2.valueType;\n\n // build filter in aggregation\n var list = children.map(function (currentChild) {\n return formatItem(currentChild, config, meta, groupField);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n });\n if (isRuleGroupArray && !isGroup0) {\n // \"count\" rule can have no \"having\" children, but should have number value\n if (formattedValue == undefined) return undefined;\n } else {\n if (!list.size) return undefined;\n }\n var omitBrackets = isRuleGroup;\n var filter = list.size ? conjunctionDefinition.spelFormatConj.call(config.ctx, list, conjunction, not, omitBrackets) : null;\n\n // build result\n var ret;\n if (isRuleGroupArray) {\n var _formatField = formatField(meta, config, field, parentField),\n formattedField = _formatField.value;\n var sep = fieldSeparator || \".\";\n var getSize = sep + (isSpelArray ? \"length\" : \"size()\");\n var fullSize = \"\".concat(formattedField).concat(getSize);\n // https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/expressions.html#expressions-collection-selection\n var filteredSize = filter ? \"\".concat(formattedField, \".?[\").concat(filter, \"]\").concat(getSize) : fullSize;\n var groupValue = isGroup0 ? fullSize : formattedValue;\n // format expression\n ret = formatExpression(meta, config, properties, filteredSize, groupValue, realGroupOperator, valueSrc, valueType, isGroupOpRev);\n } else {\n ret = filter;\n }\n return ret;\n};\nvar buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition, valueType) {\n var spelOp = operatorDefinition.spelOp;\n if (!spelOp) return undefined;\n var isSign = spelOp.includes(\"${0}\");\n var isCompareTo = TypesWithCompareTo[valueType];\n var sop = spelOp;\n var fn;\n var cardinality = getOpCardinality(operatorDefinition);\n if (isCompareTo) {\n // date1.compareTo(date2) >= 0\n // instead of\n // date1 >= date2\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var compareRes = compareToSign.replace(/\\${(\\w+)}/g, function (_, k) {\n return k == 0 ? field : cardinality > 1 ? values[k - 1] : values;\n });\n return \"\".concat(compareRes, \" \").concat(sop, \" 0\");\n };\n } else if (isSign) {\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n return spelOp.replace(/\\${(\\w+)}/g, function (_, k) {\n return k == 0 ? field : cardinality > 1 ? values[k - 1] : values;\n });\n };\n } else if (cardinality == 0) {\n // should not be\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" \").concat(sop);\n };\n } else if (cardinality == 1) {\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" \").concat(sop, \" \").concat(values);\n };\n }\n return fn;\n};\nvar formatExpression = function formatExpression(meta, config, properties, formattedField, formattedValue, operator, valueSrc, valueType) {\n var isRev = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var field = properties.get(\"field\");\n var opDef = getOperatorConfig(config, operator, field) || {};\n var fieldDef = getFieldConfig(config, field) || {};\n var operatorOptions = properties.get(\"operatorOptions\");\n\n //find fn to format expr\n var fn = opDef.spelFormatOp || buildFnToFormatOp(operator, opDef, valueType !== null && valueType !== void 0 ? valueType : fieldDef.type);\n if (!fn) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n\n //format expr\n var args = [formattedField, operator, formattedValue, valueSrc, valueType, omit(opDef, opDefKeysToOmit), operatorOptions, fieldDef];\n var ret;\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n\n //rev\n if (isRev) {\n ret = config.settings.spelFormatReverse.call(config.ctx, ret);\n }\n if (ret === undefined) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported for value source \").concat(valueSrc));\n }\n return ret;\n};\nvar checkOp = function checkOp(config, operator, field) {\n if (!operator) return undefined;\n var opDef = getOperatorConfig(config, operator, field) || {};\n var reversedOp = opDef.reversedOp;\n var revOpDef = getOperatorConfig(config, reversedOp, field) || {};\n var isRev = false;\n var canFormatOp = opDef.spelOp || opDef.spelFormatOp;\n var canFormatRevOp = revOpDef.spelOp || revOpDef.spelFormatOp;\n if (!canFormatOp && !canFormatRevOp) {\n return undefined;\n }\n if (!canFormatOp && canFormatRevOp) {\n isRev = true;\n var _ref = [reversedOp, operator];\n operator = _ref[0];\n reversedOp = _ref[1];\n var _ref2 = [revOpDef, opDef];\n opDef = _ref2[0];\n revOpDef = _ref2[1];\n }\n return operator;\n};\nvar formatRule = function formatRule(item, config, meta) {\n var _formatLhs;\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var properties = item.get(\"properties\") || new Map();\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var operator = properties.get(\"operator\");\n if (field == null || operator == null) return undefined;\n\n // check op for reverse\n var realOp = checkOp(config, operator, field);\n if (!realOp) {\n meta.errors.push(\"Operator \".concat(operator, \" is not supported\"));\n return undefined;\n }\n var isRev = realOp != operator;\n\n //format value\n var _formatItemValue3 = formatItemValue(config, properties, meta, realOp, parentField, null),\n formattedValue = _formatItemValue3.value,\n valueSrc = _formatItemValue3.valueSrc,\n valueType = _formatItemValue3.valueType;\n if (formattedValue === undefined) return undefined;\n\n //format field\n var _ref3 = (_formatLhs = formatLhs(meta, config, field, fieldSrc, parentField)) !== null && _formatLhs !== void 0 ? _formatLhs : {},\n formattedField = _ref3.value,\n _fieldSrc = _ref3.valueSrc,\n fieldType = _ref3.valueType;\n if (formattedField === undefined) return undefined;\n\n // format expression\n var res = formatExpression(meta, config, properties, formattedField, formattedValue, realOp, valueSrc, valueType !== null && valueType !== void 0 ? valueType : fieldType, isRev);\n return res;\n};\nvar formatLhs = function formatLhs(meta, config, field, fieldSrc) {\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (fieldSrc === \"func\") return formatFunc(meta, config, field, parentField);else return formatField(meta, config, field, parentField);\n};\nvar formatItemValue = function formatItemValue(config, properties, meta, operator, parentField) {\n var expectedValueType = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var field = properties.get(\"field\");\n var iValueSrc = properties.get(\"valueSrc\");\n var iValueType = properties.get(\"valueType\");\n if (expectedValueType == \"!case_value\" || iValueType && iValueType.get(0) == \"case_value\") {\n field = \"!case_value\";\n }\n var fieldDef = getFieldConfig(config, field) || {};\n var operatorDefinition = getOperatorConfig(config, operator, field) || {};\n var cardinality = getOpCardinality(operatorDefinition);\n var iValue = properties.get(\"value\");\n var asyncListValues = properties.get(\"asyncListValues\");\n var valueSrcs = [];\n var valueTypes = [];\n var formattedValue;\n if (iValue != undefined) {\n var fvalue = iValue.map(function (currentValue, ind) {\n var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;\n var valueType = iValueType ? iValueType.get(ind) : null;\n var cValue = completeValue(currentValue, valueSrc, config);\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, field, operator, widget, valueSrc, {\n forExport: true\n });\n var fv = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDefinition, parentField, asyncListValues);\n if (fv !== undefined) {\n valueSrcs.push(valueSrc);\n valueTypes.push(valueType);\n }\n return fv;\n });\n var hasUndefinedValues = fvalue.filter(function (v) {\n return v === undefined;\n }).size > 0;\n if (!(fvalue.size < cardinality || hasUndefinedValues)) {\n formattedValue = cardinality > 1 ? fvalue.toArray() : cardinality == 1 ? fvalue.first() : null;\n }\n }\n return {\n value: formattedValue,\n valueSrc: valueSrcs.length > 1 ? valueSrcs : valueSrcs[0],\n valueType: valueTypes.length > 1 ? valueTypes : valueTypes[0]\n };\n};\nvar formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef) {\n var parentField = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;\n var asyncListValues = arguments.length > 10 ? arguments[10] : undefined;\n if (currentValue === undefined) return undefined;\n var ret;\n if (valueSrc === \"field\") {\n var _formatField2;\n // formatField() returns type {value, valueSrc, valueType}\n ret = (_formatField2 = formatField(meta, config, currentValue, parentField)) === null || _formatField2 === void 0 ? void 0 : _formatField2.value;\n } else if (valueSrc === \"func\") {\n var _formatFunc;\n // formatFunc() returns type {value, valueSrc, valueType}\n ret = (_formatFunc = formatFunc(meta, config, currentValue, parentField, valueType)) === null || _formatFunc === void 0 ? void 0 : _formatFunc.value;\n } else {\n if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.spelFormatValue) === \"function\") {\n var fn = fieldWidgetDef.spelFormatValue;\n var args = [currentValue, _objectSpread(_objectSpread({}, pick(fieldDef, [\"fieldSettings\", \"listValues\"])), {}, {\n asyncListValues: asyncListValues\n }),\n //useful options: valueFormat for date/time\n omit(fieldWidgetDef, widgetDefKeysToOmit)];\n if (operator) {\n args.push(operator);\n args.push(operatorDef);\n }\n if (valueSrc == \"field\") {\n var valFieldDefinition = getFieldConfig(config, currentValue) || {};\n args.push(valFieldDefinition);\n }\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n } else {\n ret = spelEscape(currentValue);\n }\n }\n return ret;\n};\nvar formatField = function formatField(meta, config, field) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n if (!field) return;\n var fieldSeparator = config.settings.fieldSeparator;\n var fieldDefinition = getFieldConfig(config, field) || {};\n var fieldParts = getFieldParts(field, config);\n var fieldPartsConfigs = getFieldPartsConfigs(field, config, parentField);\n var formatFieldFn = config.settings.formatSpelField;\n var fieldName = formatFieldName(field, config, meta, parentField);\n var fieldPartsMeta = fieldPartsConfigs.map(function (_ref4) {\n var _ref5 = _slicedToArray(_ref4, 3),\n key = _ref5[0],\n cnf = _ref5[1],\n parentCnf = _ref5[2];\n var parent;\n if (parentCnf) {\n if (parentCnf.type == \"!struct\" || parentCnf.type == \"!group\" && parentCnf.mode == \"struct\") parent = cnf !== null && cnf !== void 0 && cnf.isSpelMap ? \"map\" : \"class\";else if (parentCnf.type == \"!group\") parent = cnf !== null && cnf !== void 0 && cnf.isSpelItemMap ? \"[map]\" : \"[class]\";else parent = \"class\";\n }\n var isSpelVariable = cnf === null || cnf === void 0 ? void 0 : cnf.isSpelVariable;\n return {\n key: key,\n parent: parent,\n isSpelVariable: isSpelVariable,\n fieldSeparator: fieldSeparator\n };\n });\n var formattedField = formatFieldFn.call(config.ctx, fieldName, parentField, fieldParts, fieldPartsMeta, fieldDefinition, config);\n return {\n value: formattedField,\n valueSrc: \"field\",\n valueType: fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type\n };\n};\nvar formatFunc = function formatFunc(meta, config, currentValue) {\n var _currentValue$get, _currentValue$get2;\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var valueType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var funcKey = (_currentValue$get = currentValue.get) === null || _currentValue$get === void 0 ? void 0 : _currentValue$get.call(currentValue, \"func\");\n var args = (_currentValue$get2 = currentValue.get) === null || _currentValue$get2 === void 0 ? void 0 : _currentValue$get2.call(currentValue, \"args\");\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not defined in config\"));\n return undefined;\n }\n var formattedArgs = {};\n var gaps = [];\n var missingArgKeys = [];\n for (var argKey in funcConfig.args) {\n var _argValue, _argConfig$escapeForF;\n var argConfig = funcConfig.args[argKey];\n var fieldDef = getFieldConfig(config, argConfig);\n var defaultValue = argConfig.defaultValue,\n isOptional = argConfig.isOptional;\n var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? \"func\" : \"value\";\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValueSrc !== \"func\" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {\n // value should not be Immutable\n argValue = argValue.toJS();\n }\n var argAsyncListValues = argVal ? argVal.get(\"asyncListValues\") : undefined;\n var doEscape = (_argConfig$escapeForF = argConfig.escapeForFormat) !== null && _argConfig$escapeForF !== void 0 ? _argConfig$escapeForF : true;\n var operator = null;\n var widget = getWidgetForFieldOp(config, argConfig, operator, argValueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, widget, argValueSrc, {\n forExport: true\n });\n var formattedArgVal = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldWidgetDef, fieldDef, null, null, parentField, argAsyncListValues);\n if (argValue != undefined && formattedArgVal === undefined) {\n if (argValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n var formattedDefaultVal = void 0;\n if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {\n var defaultWidget = getWidgetForFieldOp(config, argConfig, operator, defaultValueSrc);\n var defaultFieldWidgetDef = getFieldWidgetConfig(config, argConfig, operator, defaultWidget, defaultValueSrc, {\n forExport: true\n });\n formattedDefaultVal = formatValue(meta, config, defaultValue, defaultValueSrc, argConfig.type, defaultFieldWidgetDef, fieldDef, null, null, parentField, argAsyncListValues);\n if (formattedDefaultVal === undefined) {\n if (defaultValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format default value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n }\n var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;\n if (finalFormattedVal !== undefined) {\n if (gaps.length) {\n var _iterator = _createForOfIteratorHelper(gaps),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var missedArgKey = _step.value;\n formattedArgs[missedArgKey] = undefined;\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n gaps = [];\n }\n formattedArgs[argKey] = doEscape ? finalFormattedVal : argValue !== null && argValue !== void 0 ? argValue : defaultValue;\n } else {\n if (!isOptional) missingArgKeys.push(argKey);\n gaps.push(argKey);\n }\n }\n if (missingArgKeys.length) {\n //meta.errors.push(`Missing vals for args ${missingArgKeys.join(\", \")} for func ${funcKey}`);\n return undefined; // incomplete\n }\n var ret;\n if (typeof funcConfig.spelFormatFunc === \"function\") {\n var fn = funcConfig.spelFormatFunc;\n var _args = [formattedArgs];\n ret = fn.call.apply(fn, [config.ctx].concat(_args));\n } else if (funcConfig.spelFunc) {\n // fill arg values\n ret = funcConfig.spelFunc.replace(/\\${(\\w+)}/g, function (found, argKey) {\n var _formattedArgs$argKey;\n return (_formattedArgs$argKey = formattedArgs[argKey]) !== null && _formattedArgs$argKey !== void 0 ? _formattedArgs$argKey : found;\n });\n // remove optional args (from end only)\n var optionalArgs = Object.keys(funcConfig.args || {}).reverse().filter(function (argKey) {\n return !!funcConfig.args[argKey].isOptional;\n });\n var _iterator2 = _createForOfIteratorHelper(optionalArgs),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _argKey = _step2.value;\n if (formattedArgs[_argKey] != undefined) break;\n ret = ret.replace(new RegExp(\"(, )?\" + \"\\\\${\" + _argKey + \"}\", \"g\"), \"\");\n }\n // missing required arg vals\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n ret = ret.replace(/\\${(\\w+)}/g, \"null\");\n } else {\n meta.errors.push(\"Func \".concat(funcKey, \" is not supported\"));\n }\n // tip: returnType should equal valueType\n return {\n value: ret,\n valueSrc: \"func\",\n valueType: funcConfig.returnType\n };\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldParts, getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { getFieldPathLabels, formatFieldName, completeValue } from \"../utils/ruleUtils\";\nimport pick from \"lodash/pick\";\nimport { getOpCardinality, widgetDefKeysToOmit, opDefKeysToOmit, omit } from \"../utils/stuff\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { List, Map } from \"immutable\";\nexport var queryString = function queryString(item, config) {\n var isForDisplay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var isDebugMode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n //meta is mutable\n var meta = {\n errors: [],\n settings: {\n isForDisplay: isForDisplay,\n isDebugMode: isDebugMode\n }\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var res = formatItem([], item, extendedConfig, meta, null);\n if (meta.errors.length) console.warn(\"Errors while exporting to string:\", meta.errors);\n return res;\n};\nvar formatItem = function formatItem(parents, item, config, meta) {\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (!item) return undefined;\n var type = item.get(\"type\");\n var children = item.get(\"children1\");\n if (type === \"group\" || type === \"rule_group\") {\n return formatGroup(parents, item, config, meta, parentField);\n } else if (type === \"rule\") {\n return formatRule(parents, item, config, meta, parentField);\n }\n return undefined;\n};\nvar formatGroup = function formatGroup(parents, item, config, meta) {\n var _config$operators$gro, _config$operators$gro2;\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var _meta$settings = meta.settings,\n isForDisplay = _meta$settings.isForDisplay,\n isDebugMode = _meta$settings.isDebugMode;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\") || new Map();\n var mode = properties.get(\"mode\");\n var children = item.get(\"children1\") || new List();\n\n // const parentRuleGroup = parents.filter(it => it.get(\"type\") == \"rule_group\")?.slice(-1)?.pop();\n // const isInsideRuleGroup = !!parentRuleGroup;\n // const parentRuleGroupField = parentRuleGroup?.get(\"properties\").get(\"field\");\n // const isInsideRuleGroupArray = isInsideRuleGroup && parentRuleGroup.get(\"properties\").get(\"mode\") == \"array\";\n // // TIP: don't cut group for mode == 'struct'\n // const realParentGroupField = isInsideRuleGroupArray && parentRuleGroupField;\n var realParentGroupField = parentField;\n var isRuleGroup = type === \"rule_group\";\n // TIP: don't cut group for mode == 'struct' and don't do aggr format (maybe later)\n var groupField = isRuleGroup && mode == \"array\" ? properties.get(\"field\") : null;\n var groupOperator = type === \"rule_group\" ? properties.get(\"operator\") : null;\n var groupOperatorCardinality = groupOperator ? (_config$operators$gro = (_config$operators$gro2 = config.operators[groupOperator]) === null || _config$operators$gro2 === void 0 ? void 0 : _config$operators$gro2.cardinality) !== null && _config$operators$gro !== void 0 ? _config$operators$gro : 1 : undefined;\n var canHaveEmptyChildren = isRuleGroup && mode === \"array\" && groupOperatorCardinality >= 1;\n var not = properties.get(\"not\");\n var list = children.map(function (currentChild) {\n return formatItem([].concat(_toConsumableArray(parents), [item]), currentChild, config, meta, groupField !== null && groupField !== void 0 ? groupField : realParentGroupField);\n }).filter(function (currentChild) {\n return typeof currentChild !== \"undefined\";\n });\n if (!canHaveEmptyChildren && !list.size && !isDebugMode) {\n return undefined;\n }\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(config);\n var conjunctionDefinition = config.conjunctions[conjunction];\n var conjStr = list.size ? conjunctionDefinition.formatConj.call(config.ctx, list, conjunction, not, isForDisplay) : null;\n var ret;\n if (groupField) {\n var aggrArgs = formatRule(parents, item, config, meta, realParentGroupField, true);\n if (aggrArgs) {\n var _config$settings$form;\n var isRev = aggrArgs.pop();\n var args = [conjStr].concat(_toConsumableArray(aggrArgs));\n ret = (_config$settings$form = config.settings.formatAggr).call.apply(_config$settings$form, [config.ctx].concat(_toConsumableArray(args)));\n if (isRev) {\n ret = config.settings.formatReverse.call(config.ctx, ret, null, null, null, null, isForDisplay);\n }\n }\n } else {\n ret = conjStr;\n }\n if (isDebugMode && ret == null) {\n ret = \"?\";\n }\n return ret;\n};\nvar formatItemValue = function formatItemValue(config, properties, meta, _operator, parentField) {\n var _meta$settings2 = meta.settings,\n isForDisplay = _meta$settings2.isForDisplay,\n isDebugMode = _meta$settings2.isDebugMode;\n var field = properties.get(\"field\");\n var iValueSrc = properties.get(\"valueSrc\");\n var iValueType = properties.get(\"valueType\");\n var fieldDef = getFieldConfig(config, field) || {};\n var operator = _operator || properties.get(\"operator\");\n var operatorDef = getOperatorConfig(config, operator, field) || {};\n var cardinality = getOpCardinality(operatorDef);\n var iValue = properties.get(\"value\");\n var asyncListValues = properties.get(\"asyncListValues\");\n var valueSrcs = [];\n var valueTypes = [];\n var formattedValue;\n var fvalue;\n if (iValue != undefined) {\n fvalue = iValue.map(function (currentValue, ind) {\n var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;\n var valueType = iValueType ? iValueType.get(ind) : null;\n var cValue = !isDebugMode ? completeValue(currentValue, valueSrc, config) : currentValue;\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDef = getFieldWidgetConfig(config, field, operator, widget, valueSrc, {\n forExport: true\n });\n var fv = formatValue(config, meta, cValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef, parentField, asyncListValues);\n if (fv !== undefined) {\n valueSrcs.push(valueSrc);\n valueTypes.push(valueType);\n }\n return fv;\n });\n var hasUndefinedValues = fvalue.filter(function (v) {\n return v === undefined;\n }).size > 0;\n var isOK = !hasUndefinedValues && fvalue.size === cardinality;\n if (isOK) {\n formattedValue = cardinality == 1 ? fvalue.first() : fvalue;\n }\n }\n if (isDebugMode && !formattedValue) {\n formattedValue = cardinality > 1 ? new List(Array.from({\n length: cardinality\n }).map(function (_, i) {\n var _fvalue$get, _fvalue;\n return (_fvalue$get = (_fvalue = fvalue) === null || _fvalue === void 0 ? void 0 : _fvalue.get(i)) !== null && _fvalue$get !== void 0 ? _fvalue$get : \"?\";\n })) : \"?\";\n }\n return [formattedValue, valueSrcs.length > 1 ? valueSrcs : valueSrcs[0], valueTypes.length > 1 ? valueTypes : valueTypes[0]];\n};\nvar buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition, meta) {\n var isDebugMode = meta.settings.isDebugMode;\n var fop = (operatorDefinition === null || operatorDefinition === void 0 ? void 0 : operatorDefinition.labelForFormat) || operator;\n var cardinality = getOpCardinality(operatorDefinition);\n var fn;\n if (cardinality == 0) {\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return \"\".concat(field, \" \").concat(fop);\n };\n } else if (cardinality == 1) {\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (isDebugMode && op === \"?\" && values === \"?\") {\n return field && field !== \"?\" ? \"\".concat(field, \" ?\") : \"?\";\n }\n return \"\".concat(field, \" \").concat(fop, \" \").concat(values);\n };\n } else if (cardinality == 2) {\n // between\n fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n var _values$first, _values$get;\n var valFrom = values === null || values === void 0 || (_values$first = values.first) === null || _values$first === void 0 ? void 0 : _values$first.call(values);\n var valTo = values === null || values === void 0 || (_values$get = values.get) === null || _values$get === void 0 ? void 0 : _values$get.call(values, 1);\n return \"\".concat(field, \" \").concat(fop, \" \").concat(valFrom, \" AND \").concat(valTo);\n };\n }\n return fn;\n};\nvar formatRule = function formatRule(parents, item, config, meta) {\n var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var returnArgs = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n var _meta$settings3 = meta.settings,\n isForDisplay = _meta$settings3.isForDisplay,\n isDebugMode = _meta$settings3.isDebugMode;\n var properties = item.get(\"properties\") || new Map();\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var operator = properties.get(\"operator\");\n var operatorOptions = properties.get(\"operatorOptions\");\n if ((field == null || operator == null) && !isDebugMode) return undefined;\n var fieldDef = getFieldConfig(config, field) || {};\n var operatorDef = getOperatorConfig(config, operator, field) || {};\n var reversedOp = operatorDef.reversedOp;\n var revOperatorDef = getOperatorConfig(config, reversedOp, field) || {};\n\n //check op\n var isRev = false;\n var fn = operatorDef.formatOp;\n if (!fn && reversedOp) {\n fn = revOperatorDef.formatOp;\n if (fn) {\n isRev = true;\n var _ref = [reversedOp, operator];\n operator = _ref[0];\n reversedOp = _ref[1];\n var _ref2 = [revOperatorDef, operatorDef];\n operatorDef = _ref2[0];\n revOperatorDef = _ref2[1];\n }\n }\n if (isDebugMode && !operator) {\n operator = \"?\";\n }\n\n //find fn to format expr\n if (!fn) fn = buildFnToFormatOp(operator, operatorDef, meta);\n if (!fn) return undefined;\n\n //format field\n var formattedField = fieldSrc === \"func\" ? formatFunc(config, meta, field, parentField) : formatField(config, meta, field, parentField);\n if (formattedField == undefined) return undefined;\n\n //format value\n var _formatItemValue = formatItemValue(config, properties, meta, operator, parentField),\n _formatItemValue2 = _slicedToArray(_formatItemValue, 3),\n formattedValue = _formatItemValue2[0],\n valueSrc = _formatItemValue2[1],\n valueType = _formatItemValue2[2];\n if (formattedValue === undefined) {\n return undefined;\n }\n var args = [formattedField, operator, formattedValue, valueSrc, valueType, omit(operatorDef, opDefKeysToOmit), operatorOptions, isForDisplay, fieldDef, isRev];\n if (returnArgs) {\n return args;\n } else {\n var _fn;\n //format expr\n var ret = (_fn = fn).call.apply(_fn, [config.ctx].concat(args));\n\n //rev\n if (isRev) {\n ret = config.settings.formatReverse.call(config.ctx, ret, operator, reversedOp, operatorDef, revOperatorDef, isForDisplay);\n }\n return ret;\n }\n};\nvar formatValue = function formatValue(config, meta, value, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, opDef) {\n var parentField = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;\n var asyncListValues = arguments.length > 10 ? arguments[10] : undefined;\n var _meta$settings4 = meta.settings,\n isForDisplay = _meta$settings4.isForDisplay,\n isDebugMode = _meta$settings4.isDebugMode;\n if (value === undefined) {\n if (isDebugMode) {\n if ((fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.jsType) === \"array\") {\n return [];\n }\n return \"?\";\n } else {\n return undefined;\n }\n }\n var ret;\n if (valueSrc == \"field\") {\n ret = formatField(config, meta, value, parentField);\n } else if (valueSrc == \"func\") {\n ret = formatFunc(config, meta, value, parentField);\n } else if (value == undefined) {\n ret = undefined;\n } else {\n if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.formatValue) === \"function\") {\n var _fieldDef$escapeForFo;\n var fn = fieldWidgetDef.formatValue;\n var args = [value, _objectSpread(_objectSpread({}, pick(fieldDef, [\"fieldSettings\", \"listValues\"])), {}, {\n asyncListValues: asyncListValues\n }),\n //useful options: valueFormat for date/time\n omit(fieldWidgetDef, widgetDefKeysToOmit), isForDisplay];\n if (operator) {\n args.push(operator);\n args.push(opDef);\n }\n if (valueSrc == \"field\") {\n var valFieldDefinition = getFieldConfig(config, value) || {};\n args.push(valFieldDefinition);\n }\n var doEscape = (_fieldDef$escapeForFo = fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.escapeForFormat) !== null && _fieldDef$escapeForFo !== void 0 ? _fieldDef$escapeForFo : true;\n if (!doEscape) {\n ret = value;\n } else {\n ret = fn.call.apply(fn, [config.ctx].concat(args));\n }\n } else {\n ret = value;\n }\n }\n return ret;\n};\nvar formatField = function formatField(config, meta, field) {\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var cutParentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;\n var _meta$settings5 = meta.settings,\n isForDisplay = _meta$settings5.isForDisplay,\n isDebugMode = _meta$settings5.isDebugMode;\n var _config$settings = config.settings,\n fieldSeparator = _config$settings.fieldSeparator,\n fieldSeparatorDisplay = _config$settings.fieldSeparatorDisplay;\n var ret = null;\n if (field) {\n var fieldDefinition = getFieldConfig(config, field) || {};\n var fieldParts = getFieldParts(field, config);\n var fieldPartsLabels = getFieldPathLabels(field, config, cutParentField ? parentField : null);\n var fieldFullLabel = fieldPartsLabels ? fieldPartsLabels.join(fieldSeparatorDisplay) : null;\n var fieldLabel2 = fieldDefinition.label2 || fieldFullLabel;\n var formatFieldFn = config.settings.formatField;\n var fieldName = formatFieldName(field, config, meta, cutParentField ? parentField : null, {\n useTableName: true\n });\n ret = formatFieldFn(fieldName, fieldParts, fieldLabel2, fieldDefinition, config, isForDisplay);\n } else if (isDebugMode) {\n ret = \"?\";\n }\n return ret;\n};\nvar formatFunc = function formatFunc(config, meta, funcValue) {\n var _funcValue$get, _funcValue$get2, _args$keySeq;\n var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var _meta$settings6 = meta.settings,\n isForDisplay = _meta$settings6.isForDisplay,\n isDebugMode = _meta$settings6.isDebugMode;\n var funcKey = funcValue === null || funcValue === void 0 || (_funcValue$get = funcValue.get) === null || _funcValue$get === void 0 ? void 0 : _funcValue$get.call(funcValue, \"func\");\n if (!funcKey) {\n return isDebugMode ? \"?()\" : undefined;\n }\n var args = (_funcValue$get2 = funcValue.get) === null || _funcValue$get2 === void 0 ? void 0 : _funcValue$get2.call(funcValue, \"args\");\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) {\n if (!isDebugMode) {\n meta.errors.push(\"Func \".concat(funcKey, \" is not defined in config\"));\n return undefined;\n }\n }\n var funcParts = getFieldParts(funcKey, config);\n var funcLastKey = funcParts[funcParts.length - 1];\n var funcName = isForDisplay && (funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.label) || funcLastKey;\n var formattedArgs = {};\n var gaps = [];\n var missingArgKeys = [];\n var formattedArgsWithNames = {};\n var argsKeys = funcConfig ? Object.keys(funcConfig.args || {}) : (args === null || args === void 0 || (_args$keySeq = args.keySeq) === null || _args$keySeq === void 0 ? void 0 : _args$keySeq.call(args).toArray()) || [];\n var _iterator = _createForOfIteratorHelper(argsKeys),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var _argValue;\n var argKey = _step.value;\n var argConfig = funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.args[argKey];\n var fieldDef = getFieldConfig(config, argConfig);\n var _ref5 = argConfig || {},\n defaultValue = _ref5.defaultValue,\n isOptional = _ref5.isOptional;\n var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? \"func\" : \"value\";\n var fieldWidgetDef = getFieldWidgetConfig(config, argConfig, undefined, undefined, defaultValueSrc, {\n forExport: true\n });\n var argName = isForDisplay && (argConfig === null || argConfig === void 0 ? void 0 : argConfig.label) || argKey;\n var argVal = args ? args.get(argKey) : undefined;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValueSrc !== \"func\" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {\n // value should not be Immutable\n argValue = argValue.toJS();\n }\n var argAsyncListValues = argVal ? argVal.get(\"asyncListValues\") : undefined;\n var formattedArgVal = formatValue(config, meta, argValue, argValueSrc, argConfig === null || argConfig === void 0 ? void 0 : argConfig.type, fieldWidgetDef, argConfig, null, null, parentField, argAsyncListValues);\n if (argValue != undefined && formattedArgVal === undefined) {\n if (argValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format value of arg \".concat(argKey, \" for func \").concat(funcKey));\n }\n var formattedDefaultVal = void 0;\n if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {\n formattedDefaultVal = formatValue(config, meta, defaultValue, defaultValueSrc, argConfig === null || argConfig === void 0 ? void 0 : argConfig.type, fieldWidgetDef, argConfig, null, null, parentField, argAsyncListValues);\n if (formattedDefaultVal === undefined) {\n if (defaultValueSrc != \"func\")\n // don't triger error if args value is another incomplete function\n meta.errors.push(\"Can't format default value of arg \".concat(argKey, \" for func \").concat(funcKey));\n return undefined;\n }\n }\n var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;\n if (finalFormattedVal !== undefined) {\n if (gaps.length) {\n var _iterator2 = _createForOfIteratorHelper(argKey),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _step2$value = _slicedToArray(_step2.value, 2),\n missedArgKey = _step2$value[0],\n missedArgName = _step2$value[1];\n formattedArgs[missedArgKey] = undefined;\n //formattedArgsWithNames[missedArgName] = undefined;\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n gaps = [];\n }\n formattedArgs[argKey] = finalFormattedVal;\n formattedArgsWithNames[argName] = finalFormattedVal;\n } else {\n if (!isOptional) missingArgKeys.push(argKey);\n gaps.push([argKey, argName]);\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n if (missingArgKeys.length) {\n //meta.errors.push(`Missing vals for args ${missingArgKeys.join(\", \")} for func ${funcKey}`);\n if (!isDebugMode) {\n return undefined; // incomplete\n }\n }\n var ret = null;\n if (typeof (funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.formatFunc) === \"function\") {\n var fn = funcConfig.formatFunc;\n var _args = [formattedArgs, isForDisplay];\n ret = fn.call.apply(fn, [config.ctx].concat(_args));\n } else {\n var argsStr = Object.entries(isForDisplay ? formattedArgsWithNames : formattedArgs).map(function (_ref3) {\n var _ref4 = _slicedToArray(_ref3, 2),\n k = _ref4[0],\n v = _ref4[1];\n return isForDisplay ? \"\".concat(k, \": \").concat(v) : \"\".concat(v);\n }).join(\", \");\n ret = \"\".concat(funcName, \"(\").concat(argsStr, \")\");\n }\n return ret;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { defaultConjunction } from \"../utils/defaultUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\n\n/**\n * Converts a string representation of top_left and bottom_right cords to\n * a ES geo_point required for query\n *\n * @param {string} geoPointString - comma separated string of lat/lon coods\n * @returns {{top_left: {lon: number, lat: number}, bottom_right: {lon: number, lat: number}}} - ES geoPoint formatted object\n * @private\n */\nfunction buildEsGeoPoint(geoPointString) {\n if (geoPointString == null) {\n return null;\n }\n var coordsNumberArray = geoPointString.split(\",\").map(Number);\n return {\n top_left: {\n lat: coordsNumberArray[0],\n lon: coordsNumberArray[1]\n },\n bottom_right: {\n lat: coordsNumberArray[2],\n lon: coordsNumberArray[3]\n }\n };\n}\n\n/**\n * Converts a dateTime string from the query builder to a ES range formatted object\n *\n * @param {string} dateTime - dateTime formatted string\n * @param {string} operator - query builder operator type, see constants.js and query builder docs\n * @returns {{lt: string}|{lte: string}|{gte: string}|{gte: string, lte: string}|undefined} - ES range query parameter\n *\n * @private\n */\nfunction buildEsRangeParameters(value, operator) {\n // -- if value is greater than 1 then we assume this is a between operator : BUG this is wrong, a selectable list can have multiple values\n if (value.length > 1) {\n return {\n gte: \"\".concat(value[0]),\n lte: \"\".concat(value[1])\n };\n } // -- if value is only one we assume this is a date time query for a specific day\n\n var dateTime = value[0]; //TODO: Rethink about this part, what if someone adds a new type of opperator\n\n //todo: move this logic into config\n switch (operator) {\n case \"on_date\": //todo: not used\n case \"not_on_date\":\n case \"equal\":\n case \"select_equals\":\n case \"not_equal\":\n return {\n gte: \"\".concat(dateTime, \"||/d\"),\n lte: \"\".concat(dateTime, \"||+1d\")\n };\n case \"less_or_equal\":\n return {\n lte: \"\".concat(dateTime)\n };\n case \"greater_or_equal\":\n return {\n gte: \"\".concat(dateTime)\n };\n case \"less\":\n return {\n lt: \"\".concat(dateTime)\n };\n case \"greater\":\n return {\n gt: \"\".concat(dateTime)\n };\n default:\n return undefined;\n }\n}\n\n/**\n * Builds the DSL parameters for a Wildcard query\n *\n * @param {string} value - The match value\n * @returns {{value: string}} - The value = value parameter surrounded with * on each end\n * @private\n */\nfunction buildEsWildcardParameters(value) {\n return {\n value: \"*\" + value + \"*\"\n };\n}\n\n/**\n * Takes the match type string from awesome query builder like 'greater_or_equal' and\n * returns the ES occurrence required for bool queries\n *\n * @param {string} combinator - query group type or rule condition\n * @param {bool} not\n * @returns {string} - ES occurrence type. See constants.js\n * @private\n */\nfunction determineOccurrence(combinator, not) {\n //todo: move into config, like mongoConj\n switch (combinator) {\n case \"AND\":\n return not ? \"must_not\" : \"must\";\n // -- AND\n\n case \"OR\":\n return not ? \"should_not\" : \"should\";\n // -- OR\n\n case \"NOT\":\n return not ? \"must\" : \"must_not\";\n // -- NOT AND\n\n default:\n return undefined;\n }\n}\n\n/**\n * Determines what field to query off of given the operator type\n *\n * @param {string} fieldDataType - The type of data\n * @param {string} fullFieldName - A '.' separated string containing the property lineage (including self)\n * @param {string} queryType - The query type\n * @returns {string|*} - will be either the fullFieldName or fullFieldName.keyword\n * @private\n */\n//todo: not used\n// function determineQueryField(fieldDataType, fullFieldName, queryType) {\n// if (fieldDataType === \"boolean\") {\n// return fullFieldName;\n// }\n\n// switch (queryType) {\n// case \"term\":\n// case \"wildcard\":\n// return \"\".concat(fullFieldName, \".keyword\");\n\n// case \"geo_bounding_box\":\n// case \"range\":\n// case \"match\":\n// return fullFieldName;\n\n// default:\n// console.error(\"Can't determine query field for query type \".concat(queryType));\n// return null;\n// }\n// }\n\nfunction buildRegexpParameters(value) {\n return {\n value: value\n };\n}\nfunction determineField(fieldName, config) {\n //todo: ElasticSearchTextField - not used\n //return config.fields[fieldName].ElasticSearchTextField || fieldName;\n return fieldName;\n}\nfunction buildParameters(queryType, value, operator, fieldName, config, syntax) {\n var textField = determineField(fieldName, config);\n switch (queryType) {\n case \"filter\":\n //todo: elasticSearchScript - not used\n return {\n script: config.operators[operator].elasticSearchScript(fieldName, value)\n };\n case \"exists\":\n return {\n field: fieldName\n };\n case \"match\":\n return _defineProperty({}, textField, value[0]);\n case \"term\":\n return syntax === ES_7_SYNTAX ? _defineProperty({}, fieldName, {\n value: value[0]\n }) : _defineProperty({}, fieldName, value[0]);\n\n //todo: not used\n // need to add geo type into RAQB or remove this code\n case \"geo_bounding_box\":\n return _defineProperty({}, fieldName, buildEsGeoPoint(value[0]));\n case \"range\":\n return _defineProperty({}, fieldName, buildEsRangeParameters(value, operator));\n case \"wildcard\":\n return _defineProperty({}, fieldName, buildEsWildcardParameters(value[0]));\n case \"regexp\":\n return _defineProperty({}, fieldName, buildRegexpParameters(value[0]));\n default:\n return undefined;\n }\n}\n/**\n * Handles the building of the group portion of the DSL\n *\n * @param {string} fieldName - The name of the field you are building a rule for\n * @param {string} fieldDataType - The type of data this field holds\n * @param {string} value - The value of this rule\n * @param {string} operator - The condition on how the value is matched\n * @param {string} syntax - The version of ElasticSearch syntax to generate\n * @returns {object} - The ES rule\n * @private\n */\nfunction buildEsRule(fieldName, value, operator, config, valueSrc, syntax) {\n if (!fieldName || !operator || value == undefined) return undefined; // rule is not fully entered\n var op = operator;\n var opConfig = config.operators[op];\n if (!opConfig) return undefined; // unknown operator\n var _opConfig = opConfig,\n elasticSearchQueryType = _opConfig.elasticSearchQueryType;\n\n // not\n var not = false;\n if (!elasticSearchQueryType && opConfig.reversedOp) {\n not = true;\n op = opConfig.reversedOp;\n opConfig = config.operators[op];\n var _opConfig2 = opConfig;\n elasticSearchQueryType = _opConfig2.elasticSearchQueryType;\n }\n\n // handle if value 0 has multiple values like a select in a array\n var widget = getWidgetForFieldOp(config, fieldName, op, valueSrc);\n var widgetConfig = config.widgets[widget];\n if (!widgetConfig) return undefined; // unknown widget\n var elasticSearchFormatValue = widgetConfig.elasticSearchFormatValue;\n\n /** In most cases the queryType will be static however in some casese (like between) the query type will change\n * based on the data type. i.e. a between time will be different than between number, date, letters etc... */\n var queryType;\n if (typeof elasticSearchQueryType === \"function\") {\n queryType = elasticSearchQueryType(widget);\n } else {\n queryType = elasticSearchQueryType;\n }\n if (!queryType) {\n // Not supported\n return undefined;\n }\n\n /** If a widget has a rule on how to format that data then use that otherwise use default way of determineing search parameters\n * */\n var parameters;\n if (typeof elasticSearchFormatValue === \"function\") {\n parameters = elasticSearchFormatValue(queryType, value, op, fieldName, config);\n } else {\n parameters = buildParameters(queryType, value, op, fieldName, config, syntax);\n }\n if (not) {\n return {\n bool: {\n must_not: _defineProperty({}, queryType, _objectSpread({}, parameters))\n }\n };\n } else {\n return _defineProperty({}, queryType, _objectSpread({}, parameters));\n }\n}\n\n/**\n * Handles the building of the group portion of the DSL\n *\n * @param {object} children - The contents of the group\n * @param {string} conjunction - The way the contents of the group are joined together i.e. AND OR\n * @param {bool} not\n * @param {Function} recursiveFxn - The recursive fxn to build the contents of the groups children\n * @private\n * @returns {object} - The ES group\n */\nfunction buildEsGroup(children, conjunction, not, recursiveFxn, config, syntax) {\n if (!children || !children.size) return undefined;\n var childrenArray = children.valueSeq().toArray();\n var occurrence = determineOccurrence(conjunction, not);\n var result = childrenArray.map(function (c) {\n return recursiveFxn(c, config, syntax);\n }).filter(function (v) {\n return v !== undefined;\n });\n if (!result.length) return undefined;\n var resultFlat = result.flat(Infinity);\n return {\n bool: _defineProperty({}, occurrence, resultFlat)\n };\n}\nexport var ES_7_SYNTAX = \"ES_7_SYNTAX\";\nexport var ES_6_SYNTAX = \"ES_6_SYNTAX\";\nexport function elasticSearchFormat(tree, config) {\n var syntax = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ES_6_SYNTAX;\n var extendedConfig = extendConfig(config, undefined, false);\n // -- format the es dsl here\n if (!tree) return undefined;\n var type = tree.get(\"type\");\n var properties = tree.get(\"properties\") || new Map();\n if (type === \"rule\" && properties.get(\"field\")) {\n var _properties$get, _properties$get2, _properties$get3;\n // -- field is null when a new blank rule is added\n var operator = properties.get(\"operator\");\n var field = properties.get(\"field\");\n var fieldSrc = properties.get(\"fieldSrc\");\n var value = (_properties$get = properties.get(\"value\")) === null || _properties$get === void 0 ? void 0 : _properties$get.toJS();\n var _valueType = (_properties$get2 = properties.get(\"valueType\")) === null || _properties$get2 === void 0 ? void 0 : _properties$get2.get(0);\n var valueSrc = (_properties$get3 = properties.get(\"valueSrc\")) === null || _properties$get3 === void 0 ? void 0 : _properties$get3.get(0);\n if (valueSrc === \"func\" || fieldSrc == \"func\") {\n // -- elastic search doesn't support functions (that is post processing)\n return;\n }\n if (value && Array.isArray(value[0])) {\n //TODO : Handle case where the value has multiple values such as in the case of a list\n return value[0].map(function (val) {\n return buildEsRule(field, [val], operator, extendedConfig, valueSrc, syntax);\n });\n } else {\n return buildEsRule(field, value, operator, extendedConfig, valueSrc, syntax);\n }\n }\n if (type === \"group\" || type === \"rule_group\") {\n var not = properties.get(\"not\");\n var conjunction = properties.get(\"conjunction\");\n if (!conjunction) conjunction = defaultConjunction(extendedConfig);\n var children = tree.get(\"children1\");\n return buildEsGroup(children, conjunction, not, elasticSearchFormat, extendedConfig, syntax);\n }\n}","import _typeof from \"@babel/runtime/helpers/typeof\";\nimport Immutable, { Map } from \"immutable\";\nimport { getLightTree, _fixImmutableValue, fixPathsInTree, jsToImmutable } from \"../utils/treeUtils\";\nimport { isJsonLogic } from \"../utils/stuff\";\nexport { isJsonLogic, jsToImmutable };\nexport var getTree = function getTree(immutableTree) {\n var light = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var children1AsArray = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n if (!immutableTree) return undefined;\n var tree = immutableTree;\n tree = tree.toJS();\n tree = getLightTree(tree, light, children1AsArray);\n return tree;\n};\nexport var loadTree = function loadTree(serTree) {\n if (isImmutableTree(serTree)) {\n return serTree;\n } else if (isTree(serTree)) {\n return fixPathsInTree(jsToImmutable(serTree));\n } else if (typeof serTree == \"string\" && serTree.startsWith('[\"~#iM\"')) {\n //tip: old versions of RAQB were saving tree with `transit.toJSON()`\n // https://github.com/ukrbublik/react-awesome-query-builder/issues/69\n throw new Error(\"You are trying to load query in obsolete serialization format (Immutable string) which is not supported in versions starting from 2.1.17\");\n } else if (typeof serTree === \"string\") {\n return fixPathsInTree(jsToImmutable(JSON.parse(serTree)));\n } else throw new Error(\"Can't load tree!\");\n};\nexport var isImmutableTree = function isImmutableTree(tree) {\n return Map.isMap(tree);\n};\nexport var isTree = function isTree(tree) {\n return _typeof(tree) == \"object\" && (tree.type == \"group\" || tree.type == \"switch_group\");\n};","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _toArray(r) {\n return arrayWithHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableRest();\n}\nexport { _toArray as default };","import _toArray from \"@babel/runtime/helpers/toArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nimport uuid from \"../utils/uuid\";\nimport { getOpCardinality, isJsonLogic, shallowEqual } from \"../utils/stuff\";\nimport { getFieldConfig, normalizeField, getFuncConfig, iterateFuncs, getFieldParts, getWidgetForFieldOp } from \"../utils/configUtils\";\nimport { extendConfig } from \"../utils/configExtend\";\nimport { loadTree } from \"./tree\";\nimport { defaultGroupConjunction } from \"../utils/defaultUtils\";\nimport Immutable from \"immutable\";\nimport moment from \"moment\";\n\n// http://jsonlogic.com/\n\n// helpers\nvar arrayUniq = function arrayUniq(arr) {\n return Array.from(new Set(arr));\n};\n\n// constants\nvar jlFieldMarker = \"jlField\";\nvar jlRawFieldMarker = \"jlRawField\";\nvar jlHavingMarker = \"jlHavingMarker\";\nvar jlArgsMarker = new Proxy({\n __name: \"jlArgs\",\n __test: function __test(v) {\n var _v$match;\n var m = v === null || v === void 0 || (_v$match = v.match) === null || _v$match === void 0 ? void 0 : _v$match.call(v, /jlArgs\\[(\\d+)\\]/);\n if (m) {\n return parseInt(m[1]);\n }\n }\n}, {\n get: function get(target, k) {\n if (!isNaN(parseInt(k))) {\n return \"jlArgs[\" + k + \"]\";\n } else {\n return target[k];\n }\n }\n});\nvar jlEqOps = [\"==\", \"!=\", \"datetime==\", \"datetime!=\", \"date==\", \"date!=\"];\nvar jlRangeOps = [\"<\", \"<=\", \">\", \">=\"];\nvar jlDualMeaningOps = [\"in\", \"!in\"]; // can be mapped to \"select_any_in\" or \"like\"\nvar multiselectOps = [\"multiselect_equals\", \"multiselect_not_equals\", \"multiselect_contains\", \"multiselect_not_contains\"];\nvar createMeta = function createMeta(parentMeta) {\n return {\n errors: [],\n settings: parentMeta === null || parentMeta === void 0 ? void 0 : parentMeta.settings\n };\n};\nexport var loadFromJsonLogic = function loadFromJsonLogic(logicTree, config) {\n return _loadFromJsonLogic(logicTree, config, false);\n};\nexport var _loadFromJsonLogic = function _loadFromJsonLogic(logicTree, config) {\n var returnErrors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //meta is mutable\n var meta = createMeta();\n meta.settings = {\n allowUnknownFields: false,\n returnErrors: returnErrors\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var conv = buildConv(extendedConfig);\n var jsTree = logicTree ? _convertFromLogic(logicTree, conv, extendedConfig, [\"rule\", \"group\", \"switch\", \"case_val\"], meta) : undefined;\n var immTree = jsTree ? loadTree(jsTree) : undefined;\n meta.errors = Array.from(new Set(meta.errors));\n if (returnErrors) {\n return [immTree, meta.errors];\n } else {\n if (meta.errors.length) console.warn(\"Errors while importing from JsonLogic:\", meta.errors);\n return immTree;\n }\n};\nvar buildConv = function buildConv(config) {\n var operators = {};\n var combinationOperators = {};\n var _loop = function _loop(opKey) {\n var opConfig = config.operators[opKey];\n var cardinality = getOpCardinality(opConfig);\n if (typeof opConfig.jsonLogic == \"string\") {\n // example: \"</2\", \"#in/1\"\n var opk = opConfig.jsonLogic + \"/\" + cardinality;\n if (!operators[opk]) operators[opk] = [];\n operators[opk].push(opKey);\n } else if (typeof opConfig.jsonLogic === \"function\") {\n var _opConfig$jsonLogic, _opConfig$jsonLogic2$, _opConfig$jsonLogic2, _opConfig$jsonLogicOp;\n var template;\n try {\n template = opConfig.jsonLogic(jlFieldMarker, opKey, jlArgsMarker, opConfig, new Immutable.Map({\n having: jlHavingMarker,\n groupField: jlRawFieldMarker\n // reduce: undefined,\n // groupFieldFormatted: undefined,\n }));\n } catch (e) {\n console.warn(\"Error while running JsonLogic template for op \".concat(opKey), e);\n return 1; // continue\n }\n var opInTemplate = Object.keys(template)[0];\n var isRevArgs = (_opConfig$jsonLogic = opConfig.jsonLogic2) === null || _opConfig$jsonLogic === void 0 ? void 0 : _opConfig$jsonLogic.startsWith(\"#\");\n // example: \"all-in/1\"\n var newOp = (_opConfig$jsonLogic2$ = (_opConfig$jsonLogic2 = opConfig.jsonLogic2) === null || _opConfig$jsonLogic2 === void 0 ? void 0 : _opConfig$jsonLogic2.replace(/^#/, \"\")) !== null && _opConfig$jsonLogic2$ !== void 0 ? _opConfig$jsonLogic2$ : opInTemplate;\n var ops = (_opConfig$jsonLogicOp = opConfig.jsonLogicOps) !== null && _opConfig$jsonLogicOp !== void 0 ? _opConfig$jsonLogicOp : [newOp];\n ops.map(function (op) {\n var opk = op + \"/\" + cardinality;\n if (!operators[opk]) operators[opk] = [];\n operators[opk].push(opKey);\n });\n if (!combinationOperators[opKey]) combinationOperators[opKey] = {};\n combinationOperators[opKey] = {\n \"template\": template,\n \"newOp\": newOp,\n \"_jsonLogicIsExclamationOp\": !!opConfig._jsonLogicIsExclamationOp,\n \"isRevArgs\": isRevArgs\n };\n }\n };\n for (var opKey in config.operators) {\n if (_loop(opKey)) continue;\n }\n var conjunctions = {};\n for (var conjKey in config.conjunctions) {\n var conjunctionDefinition = config.conjunctions[conjKey];\n var ck = conjunctionDefinition.jsonLogicConj || conjKey.toLowerCase();\n conjunctions[ck] = conjKey;\n }\n var funcs = {};\n var _iterator = _createForOfIteratorHelper(iterateFuncs(config)),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var _step$value = _slicedToArray(_step.value, 2),\n funcPath = _step$value[0],\n funcConfig = _step$value[1];\n var fk = void 0;\n if (funcConfig.jsonLogicIsMethod) {\n fk = \"#\" + funcConfig.jsonLogic;\n } else if (typeof funcConfig.jsonLogic == \"string\") {\n fk = funcConfig.jsonLogic;\n }\n if (fk) {\n if (!funcs[fk]) funcs[fk] = [];\n funcs[fk].push(funcPath);\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n var _config$settings$json = config.settings.jsonLogic,\n groupVarKey = _config$settings$json.groupVarKey,\n altVarKey = _config$settings$json.altVarKey;\n return {\n operators: operators,\n conjunctions: conjunctions,\n funcs: funcs,\n varKeys: [\"var\", groupVarKey, altVarKey],\n combinationOperators: combinationOperators\n };\n};\n\n/**\n * This function checks a given jsonlogic object against a set of templates defined in 'conv'. \n * It determines if the jsonlogic object matches any of the specified templates.\n * \n * @param {*} jsonlogic The jsonlogic object to be matched against the templates.\n * @param {*} conv The object containing all potential templates and their associated logic for matching. \n * It is expected to have a 'combinationOperators' property that houses the templates.\n * @param {*} meta An object where any errors or metadata during the processing are stored. It's modified by reference.\n * @param {*} operatorsToCheck An optional array of operator keys that limits which operators in 'conv' are checked. \n * If null, all operators in 'conv' are considered.\n * @returns {Object|null} The response object containing the match result, and any relevant matched fields and \n * arguments if a match is found. Returns null if no match is found.\n */\nvar matchAgainstTemplates = function matchAgainstTemplates(jsonlogic, conv, meta) {\n var operatorsToCheck = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var response;\n if (conv !== null && conv !== void 0 && conv.combinationOperators) {\n for (var _i = 0, _Object$entries = Object.entries(conv.combinationOperators); _i < _Object$entries.length; _i++) {\n var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),\n key = _Object$entries$_i[0],\n value = _Object$entries$_i[1];\n if (operatorsToCheck == null || operatorsToCheck.includes(key)) {\n var tempResponse = _isTemplateMatch(value.template, jsonlogic);\n // Found a match\n if (tempResponse.match) {\n if (!response) response = tempResponse;\n // Templates should be spesific enough that only one match can be found. This should not happen\n else {\n meta.errors.push(\"Operator matched against 2 templates: \".concat(response.newOp, \" and \").concat(key));\n }\n // New op that is used to represent operator that is combosed of multiple operators\n response[\"newOp\"] = value.newOp;\n }\n }\n }\n }\n // Returns undefined if no matches found\n return response;\n};\n\n/**\n * This function recursively compares a jsonlogic object against a template to determine if they match structurally and content-wise.\n * It is used to support complex template matching where the template can include special markers indicating variable fields and arguments.\n *\n * @param {*} template The template object to match against, which can include special markers to denote fields and arguments.\n * @param {*} jsonlogic The jsonlogic object to test against the template.\n * @param {*} response An object to accumulate results such as whether a match is found, and to collect any fields or arguments identified \n * by the template markers. Default is initialized to a match state with empty fields and arguments.\n * @returns {Object} The updated response object after checking the current template level. It includes whether the current level \n * matches (match: true/false), any identified fields (jlField), and any arguments (jlArgs).\n */\nvar _isTemplateMatch = function isTemplateMatch(template, jsonlogic) {\n var response = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n \"match\": true,\n \"jlField\": null,\n \"jlArgs\": [],\n \"jlHaving\": null\n };\n if (template == undefined || jsonlogic == undefined) {\n response.match = false;\n return response;\n }\n // This lets us compare order easily\n var tKeys = Object.keys(template);\n var jKeys = Object.keys(jsonlogic);\n if (tKeys.length !== jKeys.length) {\n // Both have same length\n response.match = false;\n return response;\n }\n response.vals = [];\n for (var index = 0; index < tKeys.length; index++) {\n var key = tKeys[index];\n var value = template[key];\n response.vals.push(jsonlogic[key]);\n if (key !== jKeys[index]) {\n // Checks that both have exact same key at exact same place. Kind of pointless for arrays but whatever\n response.match = false;\n return response;\n }\n var maybeArgIndex = jlArgsMarker.__test(value);\n if (maybeArgIndex !== undefined) {\n response.jlArgs[maybeArgIndex] = jsonlogic[key];\n } else if (value === jlFieldMarker && isJsonLogic(jsonlogic[key])) {\n // If jlFieldMarker is found in template AND it's field or func we take the value from corresponding place in jsonlogic\n response.jlField = jsonlogic[key];\n } else if (value === jlRawFieldMarker) {\n response.jlField = {\n \"var\": jsonlogic[key]\n };\n } else if (value === jlArgsMarker) {\n // If jlArgsMarker is found in template we take the value from corresponding place in jsonlogic\n response.jlArgs.push(jsonlogic[key]);\n } else if (value === jlHavingMarker) {\n response.jlHaving = jsonlogic[key];\n } else if (_typeof(value) === \"object\" && value !== null || Array.isArray(value)) {\n // Here we recurse thru objects and arrays of template until we have gone thru it completely\n response = _isTemplateMatch(value, jsonlogic[key], response);\n } else if (value !== jsonlogic[key]) {\n // This is for cases of {var: \"\"}, which should be only case in default config that leads here\n response.match = false;\n return response;\n }\n }\n return response;\n};\n\n// expectedTypes - \"val\", \"rule\", \"group\", \"switch\", \"case_val\"\nvar _convertFromLogic = function convertFromLogic(logic, conv, config, expectedTypes, meta) {\n var not = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n var fieldConfig = arguments.length > 6 ? arguments[6] : undefined;\n var widget = arguments.length > 7 ? arguments[7] : undefined;\n var parentField = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : null;\n var _isLockedLogic = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;\n var op, vals;\n if (isJsonLogic(logic)) {\n op = Object.keys(logic)[0];\n vals = logic[op];\n if (!Array.isArray(vals)) vals = [vals];\n }\n var ret;\n var beforeErrorsCnt = meta.errors.length;\n var lockedOp = config.settings.jsonLogic.lockedOp;\n var isEmptyOp = op == \"!\" && vals.length == 1 && vals[0] && isJsonLogic(vals[0]) && conv.varKeys.includes(Object.keys(vals[0])[0]);\n // If matchAgainstTemplates returns match then op is replaced with special `newOp` value (usually taken from jsonLogic2)\n var match = matchAgainstTemplates(logic, conv, meta);\n if (match) {\n // We reset vals if match found\n vals = [];\n vals[0] = match.jlField;\n if (match.jlHaving) {\n vals.push(match.jlHaving);\n }\n match.jlArgs.forEach(function (arg) {\n return vals.push(arg);\n });\n // We reset op to new op that represents multiple jsonlogic operators\n op = match.newOp;\n if (jlDualMeaningOps.includes(op)) {\n // use original order of args\n vals = match.vals;\n }\n }\n var isNot = op == \"!\" && !isEmptyOp;\n var isLocked = lockedOp && op == lockedOp;\n var isSwitch = expectedTypes.includes(\"switch\");\n var isRoot = isSwitch;\n if (isLocked) {\n ret = _convertFromLogic(vals[0], conv, config, expectedTypes, meta, not, fieldConfig, widget, parentField, true);\n } else if (isNot) {\n // apply not\n ret = _convertFromLogic(vals[0], conv, config, expectedTypes, meta, !not, fieldConfig, widget, parentField);\n } else if (expectedTypes.includes(\"val\")) {\n // not is not used here\n ret = convertFieldRhs(op, vals, conv, config, not, meta, parentField) || convertFuncRhs(op, vals, conv, config, not, fieldConfig, meta, parentField) || convertValRhs(logic, fieldConfig, widget, config, meta);\n } else {\n var errorsBefore = _toConsumableArray(meta.errors);\n if (expectedTypes.includes(\"switch\")) {\n ret = convertSwitch(op, vals, conv, config, not, meta, parentField);\n }\n if (ret == undefined && expectedTypes.includes(\"group\")) {\n ret = convertConj(op, vals, conv, config, not, meta, parentField, false);\n }\n if (ret == undefined && expectedTypes.includes(\"rule\")) {\n ret = _convertOp(op, vals, conv, config, not, meta, parentField);\n }\n var errorsAfter = _toConsumableArray(meta.errors);\n if (ret == undefined && expectedTypes.includes(\"case_val\")) {\n // last resort\n meta.errors = errorsBefore;\n ret = convertCaseVal(op, vals, conv, config, not, meta, parentField);\n if (ret == undefined) {\n meta.errors = errorsAfter;\n }\n }\n if (ret) {\n if (isRoot && ![\"group\", \"switch_group\"].includes(ret.type)) {\n ret = wrapInDefaultConj(ret, config);\n }\n }\n }\n var afterErrorsCnt = meta.errors.length;\n if (op != \"!\" && ret === undefined && afterErrorsCnt == beforeErrorsCnt) {\n meta.errors.push(\"Can't parse logic \".concat(JSON.stringify(logic)));\n }\n if (isLocked) {\n ret.properties.isLocked = true;\n }\n return ret;\n};\nvar convertValRhs = function convertValRhs(val, fieldConfig, widget, config, meta) {\n var _fieldConfig$fieldSet2;\n if (val === undefined) val = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.defaultValue;\n if (val === undefined) return undefined;\n widget = widget || (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.mainWidget);\n var widgetConfig = config.widgets[widget];\n var fieldType = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type;\n if (fieldType && !widgetConfig) {\n meta.errors.push(\"No widget for type \".concat(fieldType));\n return undefined;\n }\n if (isJsonLogic(val)) {\n meta.errors.push(\"Unexpected logic in value: \".concat(JSON.stringify(val)));\n return undefined;\n }\n if (widgetConfig !== null && widgetConfig !== void 0 && widgetConfig.jsonLogicImport) {\n try {\n var _fieldConfig$fieldSet;\n val = widgetConfig.jsonLogicImport.call(config.ctx, val, _objectSpread(_objectSpread({}, widgetConfig), (_fieldConfig$fieldSet = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.fieldSettings) !== null && _fieldConfig$fieldSet !== void 0 ? _fieldConfig$fieldSet : {}));\n } catch (e) {\n var _e$message;\n meta.errors.push(\"Can't import value \".concat(val, \" using import func of widget \").concat(widget, \": \").concat((_e$message = e === null || e === void 0 ? void 0 : e.message) !== null && _e$message !== void 0 ? _e$message : e));\n val = undefined;\n }\n } else {\n // number of seconds -> time string\n if (fieldType === \"time\" && typeof val === \"number\") {\n var h = Math.floor(val / 60 / 60) % 24,\n m = Math.floor(val / 60) % 60,\n s = val % 60;\n var valueFormat = widgetConfig.valueFormat;\n if (valueFormat) {\n var dateVal = new Date(val);\n dateVal.setMilliseconds(0);\n dateVal.setHours(h);\n dateVal.setMinutes(m);\n dateVal.setSeconds(s);\n val = moment(dateVal).format(valueFormat);\n } else {\n val = \"\".concat(h, \":\").concat(m, \":\").concat(s);\n }\n }\n\n // \"2020-01-08T22:00:00.000Z\" -> Date object\n if ([\"date\", \"datetime\"].includes(fieldType) && val && !(val instanceof Date)) {\n try {\n var isEpoch = typeof val === \"number\" || typeof val === \"string\" && !isNaN(val);\n // Note: can import only from ms timestamp, not seconds timestamp\n var epoch = isEpoch && typeof val === \"string\" ? parseInt(val) : val;\n var _dateVal = new Date(isEpoch ? epoch : val);\n if (_dateVal instanceof Date) {\n val = _dateVal;\n }\n if (isNaN(_dateVal)) {\n throw new Error(\"Invalid date\");\n }\n } catch (e) {\n meta.errors.push(\"Can't convert value \".concat(val, \" as Date\"));\n val = undefined;\n }\n }\n }\n\n // Date object -> formatted string\n if (val instanceof Date && fieldConfig) {\n var _valueFormat = widgetConfig.valueFormat;\n if (_valueFormat) {\n val = moment(val).format(_valueFormat);\n }\n }\n var asyncListValues;\n if (val && fieldConfig !== null && fieldConfig !== void 0 && (_fieldConfig$fieldSet2 = fieldConfig.fieldSettings) !== null && _fieldConfig$fieldSet2 !== void 0 && _fieldConfig$fieldSet2.asyncFetch) {\n var vals = Array.isArray(val) ? val : [val];\n asyncListValues = vals;\n }\n return {\n valueSrc: \"value\",\n value: val,\n valueType: widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.type,\n asyncListValues: asyncListValues\n };\n};\nvar convertFieldRhs = function convertFieldRhs(op, vals, conv, config, not, meta) {\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n if (conv.varKeys.includes(op) && typeof vals[0] == \"string\") {\n var _meta$settings;\n var field = normalizeField(config, vals[0], parentField);\n var fieldConfig = getFieldConfig(config, field);\n if (!fieldConfig && !((_meta$settings = meta.settings) !== null && _meta$settings !== void 0 && _meta$settings.allowUnknownFields)) {\n meta.errors.push(\"No config for field \".concat(field));\n return undefined;\n }\n return {\n valueSrc: \"field\",\n value: field,\n valueType: fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type\n };\n }\n return undefined;\n};\nvar convertLhs = function convertLhs(groupOp, jlField, args, conv, config) {\n var not = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var fieldConfig = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var meta = arguments.length > 7 ? arguments[7] : undefined;\n var parentField = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : null;\n var groupOpConfig = config.operators[groupOp];\n var isGroup = !!groupOpConfig;\n // const isGroup0 = groupOpConfig?.cardinality == 0;\n var k = Object.keys(jlField)[0];\n var v = Object.values(jlField)[0];\n var _parse = function _parse(k, v) {\n return convertFieldLhs(k, v, conv, config, not, meta, parentField) || convertFuncLhs(k, v, conv, config, not, fieldConfig, meta, parentField);\n };\n var beforeErrorsCnt = meta.errors.length;\n var field, fieldSrc, having;\n var parsed = _parse(k, v);\n if (parsed) {\n field = parsed.field;\n fieldSrc = parsed.fieldSrc;\n }\n if (isGroup) {\n // If current op is in `config.groupOperators`, first arg is having query (see `match.jlHaving`)\n having = args[0];\n args = args.splice(1);\n }\n // reduce/filter for group ext\n if (k == \"reduce\" && Array.isArray(v) && v.length == 3) {\n var _v = v,\n _v2 = _slicedToArray(_v, 3),\n filter = _v2[0],\n acc = _v2[1],\n init = _v2[2];\n if (isJsonLogic(filter) && init == 0 && isJsonLogic(acc) && Array.isArray(acc[\"+\"]) && acc[\"+\"][0] == 1 && isJsonLogic(acc[\"+\"][1]) && acc[\"+\"][1][\"var\"] == \"accumulator\") {\n k = Object.keys(filter)[0];\n v = Object.values(filter)[0];\n if (k == \"filter\") {\n var _v3 = v,\n _v4 = _slicedToArray(_v3, 2),\n group = _v4[0],\n _filter = _v4[1];\n if (isJsonLogic(group)) {\n k = Object.keys(group)[0];\n v = Object.values(group)[0];\n var parsedGroup = _parse(k, v);\n if (parsedGroup) {\n field = parsedGroup.field;\n fieldSrc = parsedGroup.fieldSrc;\n having = _filter;\n isGroup = true;\n }\n }\n } else {\n var _parsedGroup = _parse(k, v);\n if (_parsedGroup) {\n field = _parsedGroup.field;\n fieldSrc = _parsedGroup.fieldSrc;\n isGroup = true;\n }\n }\n }\n }\n var afterErrorsCnt = meta.errors.length;\n if (!field && afterErrorsCnt == beforeErrorsCnt) {\n meta.errors.push(\"Unknown LHS \".concat(JSON.stringify(jlField)));\n }\n if (!field) return;\n return {\n field: field,\n fieldSrc: fieldSrc,\n having: having,\n isGroup: isGroup,\n args: args\n };\n};\nvar convertFieldLhs = function convertFieldLhs(op, vals, conv, config, not, meta) {\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n if (!Array.isArray(vals)) vals = [vals];\n var parsed = convertFieldRhs(op, vals, conv, config, not, meta, parentField);\n if (parsed) {\n return {\n fieldSrc: \"field\",\n field: parsed.value\n };\n }\n return undefined;\n};\nvar convertFuncLhs = function convertFuncLhs(op, vals, conv, config, not) {\n var fieldConfig = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var meta = arguments.length > 6 ? arguments[6] : undefined;\n var parentField = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;\n var parsed = convertFuncRhs(op, vals, conv, config, not, fieldConfig, meta, parentField);\n if (parsed) {\n return {\n fieldSrc: \"func\",\n field: parsed.value\n };\n }\n return undefined;\n};\nvar convertFuncRhs = function convertFuncRhs(op, vals, conv, config, not) {\n var fieldConfig = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var meta = arguments.length > 6 ? arguments[6] : undefined;\n var parentField = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;\n if (!op) return undefined;\n var func, argsArr, funcKey;\n var jsonLogicIsMethod = op == \"method\";\n if (jsonLogicIsMethod) {\n var obj, opts;\n var _vals = _toArray(vals);\n obj = _vals[0];\n func = _vals[1];\n opts = _vals.slice(2);\n argsArr = [obj].concat(_toConsumableArray(opts));\n } else {\n func = op;\n argsArr = vals;\n }\n var fk = (jsonLogicIsMethod ? \"#\" : \"\") + func;\n var returnType = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) || (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.returnType);\n var funcKeys = (conv.funcs[fk] || []).filter(function (k) {\n return fieldConfig ? getFuncConfig(config, k).returnType == returnType : true;\n });\n if (funcKeys.length) {\n funcKey = funcKeys[0];\n } else {\n var v = _defineProperty({}, op, vals);\n var _iterator2 = _createForOfIteratorHelper(iterateFuncs(config)),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _step2$value = _slicedToArray(_step2.value, 2),\n f = _step2$value[0],\n fc = _step2$value[1];\n if (fc.jsonLogicImport && (returnType ? fc.returnType == returnType : true)) {\n var parsed = void 0;\n try {\n parsed = fc.jsonLogicImport.call(config.ctx, v);\n } catch (_e) {\n // given expression `v` can't be parsed into function\n }\n if (parsed) {\n funcKey = f;\n argsArr = parsed;\n }\n }\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n }\n if (!funcKey) return undefined;\n if (funcKey) {\n var funcConfig = getFuncConfig(config, funcKey);\n var argKeys = Object.keys(funcConfig.args || {});\n var argsObj = argsArr.reduce(function (acc, val, ind) {\n var argKey = argKeys[ind];\n var argConfig = funcConfig.args[argKey];\n var argVal;\n if (argConfig) {\n argVal = _convertFromLogic(val, conv, config, [\"val\"], meta, false, argConfig, null, parentField);\n }\n return argVal !== undefined ? _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, argKey, argVal)) : acc;\n }, {});\n for (var argKey in funcConfig.args) {\n var argConfig = funcConfig.args[argKey];\n var argVal = argsObj[argKey];\n if (argVal === undefined) {\n argVal = argConfig === null || argConfig === void 0 ? void 0 : argConfig.defaultValue;\n if (argVal !== undefined) {\n var _argVal;\n argVal = {\n value: argVal,\n valueSrc: (_argVal = argVal) !== null && _argVal !== void 0 && _argVal.func ? \"func\" : \"value\",\n valueType: argConfig.type\n };\n }\n if (argVal === undefined) {\n if (argConfig !== null && argConfig !== void 0 && argConfig.isOptional) {\n //ignore\n } else {\n meta.errors.push(\"No value for arg \".concat(argKey, \" of func \").concat(funcKey));\n return undefined;\n }\n } else {\n argsObj[argKey] = argVal;\n }\n }\n }\n return {\n valueSrc: \"func\",\n value: {\n func: funcKey,\n args: argsObj\n },\n valueType: funcConfig.returnType\n };\n }\n return undefined;\n};\nvar convertConj = function convertConj(op, vals, conv, config, not, meta) {\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var isRuleGroup = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;\n var conjKey = conv.conjunctions[op];\n var fieldSeparator = config.settings.fieldSeparator;\n // const parentFieldConfig = parentField ? getFieldConfig(config, parentField) : null;\n // const isParentGroup = parentFieldConfig?.type == \"!group\";\n if (conjKey) {\n var type = \"group\";\n var children = vals.map(function (v) {\n return _convertFromLogic(v, conv, config, [\"rule\", \"group\"], meta, false, null, null, parentField);\n }).filter(function (r) {\n return r !== undefined;\n }).reduce(function (acc, r) {\n return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, r.id, r));\n }, {});\n var complexFields = Object.values(children).map(function (v) {\n var _v$properties, _v$properties2;\n return (v === null || v === void 0 || (_v$properties = v.properties) === null || _v$properties === void 0 ? void 0 : _v$properties.fieldSrc) == \"field\" && (v === null || v === void 0 || (_v$properties2 = v.properties) === null || _v$properties2 === void 0 ? void 0 : _v$properties2.field);\n }).filter(function (f) {\n var _f$includes;\n return f === null || f === void 0 || (_f$includes = f.includes) === null || _f$includes === void 0 ? void 0 : _f$includes.call(f, fieldSeparator);\n });\n var complexFieldsGroupAncestors = Object.fromEntries(arrayUniq(complexFields).map(function (f) {\n var parts = f.split(fieldSeparator);\n var ancs = Object.fromEntries(parts.slice(0, -1).map(function (f, i, parts) {\n return [].concat(_toConsumableArray(parts.slice(0, i)), [f]);\n }).map(function (fp) {\n return [fp.join(fieldSeparator), getFieldConfig(config, fp)];\n }).filter(function (_ref) {\n var _ref2 = _slicedToArray(_ref, 2),\n _f = _ref2[0],\n fc = _ref2[1];\n return (fc === null || fc === void 0 ? void 0 : fc.type) == \"!group\";\n }));\n return [f, Object.keys(ancs)];\n }));\n // const childrenInRuleGroup = Object.values(children)\n // .map(v => v?.properties?.fieldSrc == \"field\" && v?.properties?.field)\n // .map(f => complexFieldsGroupAncestors[f])\n // .filter(ancs => ancs && ancs.length);\n // const usedRuleGroups = arrayUniq(Object.values(complexFieldsGroupAncestors).flat());\n // const usedTopRuleGroups = topLevelFieldsFilter(usedRuleGroups);\n\n var properties = {\n conjunction: conjKey,\n not: not\n };\n var id = uuid();\n var children1 = {};\n var groupToId = {};\n Object.entries(children).map(function (_ref3) {\n var _ref4 = _slicedToArray(_ref3, 2),\n k = _ref4[0],\n v = _ref4[1];\n if ((v === null || v === void 0 ? void 0 : v.type) == \"group\" || (v === null || v === void 0 ? void 0 : v.type) == \"rule_group\") {\n // put as-is\n children1[k] = v;\n } else {\n var _v$properties3;\n var field = v === null || v === void 0 || (_v$properties3 = v.properties) === null || _v$properties3 === void 0 ? void 0 : _v$properties3.field;\n var groupAncestors = complexFieldsGroupAncestors[field] || [];\n var groupField = groupAncestors[groupAncestors.length - 1];\n if (!groupField) {\n // not in rule_group (can be simple field or in struct) - put as-is\n if (v) {\n children1[k] = v;\n }\n } else {\n // wrap field in rule_group (with creating hierarchy if need)\n var ch = children1;\n var parentFieldParts = getFieldParts(parentField, config);\n var groupPath = getFieldParts(groupField, config);\n var isInParent = shallowEqual(parentFieldParts, groupPath.slice(0, parentFieldParts.length));\n if (!isInParent) parentFieldParts = []; // should not be\n var traverseGroupFields = groupField.split(fieldSeparator).slice(parentFieldParts.length).map(function (f, i, parts) {\n return [].concat(_toConsumableArray(parentFieldParts), _toConsumableArray(parts.slice(0, i)), [f]).join(fieldSeparator);\n }).map(function (f) {\n return {\n f: f,\n fc: getFieldConfig(config, f) || {}\n };\n }).filter(function (_ref5) {\n var fc = _ref5.fc;\n return fc.type != \"!struct\";\n });\n traverseGroupFields.map(function (_ref6, i) {\n var gf = _ref6.f,\n gfc = _ref6.fc;\n var groupId = groupToId[gf];\n if (!groupId) {\n groupId = uuid();\n groupToId[gf] = groupId;\n ch[groupId] = {\n type: \"rule_group\",\n id: groupId,\n children1: {},\n properties: {\n conjunction: conjKey,\n not: false,\n field: gf,\n fieldSrc: \"field\",\n mode: gfc.mode\n }\n };\n }\n ch = ch[groupId].children1;\n });\n ch[k] = v;\n }\n }\n });\n\n // tip: for isRuleGroup=true correct type and properties will be set out of this func\n\n return {\n type: type,\n id: id,\n children1: children1,\n properties: properties\n };\n }\n return undefined;\n};\n\n// const topLevelFieldsFilter = (fields) => {\n// let arr = [...fields].sort((a, b) => (a.length - b.length));\n// for (let i = 0 ; i < arr.length ; i++) {\n// for (let j = i + 1 ; j < arr.length ; j++) {\n// if (arr[j].indexOf(arr[i]) == 0) {\n// // arr[j] is inside arr[i] (eg. \"a.b\" inside \"a\")\n// arr.splice(j, 1);\n// j--;\n// }\n// }\n// }\n// return arr;\n// };\n\nvar wrapInDefaultConjRuleGroup = function wrapInDefaultConjRuleGroup(rule, groupField, groupFieldConfig, config) {\n var conj = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;\n var not = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n if (!rule) return undefined;\n return {\n type: \"rule_group\",\n id: uuid(),\n children1: _defineProperty({}, rule.id, rule),\n properties: {\n conjunction: conj || defaultGroupConjunction(config, groupFieldConfig),\n not: not,\n field: groupField\n }\n };\n};\nvar wrapInDefaultConj = function wrapInDefaultConj(rule, config) {\n var not = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n return {\n type: \"group\",\n id: uuid(),\n children1: _defineProperty({}, rule.id, rule),\n properties: {\n conjunction: defaultGroupConjunction(config),\n not: not\n }\n };\n};\nvar parseRule = function parseRule(op, arity, vals, parentField, conv, config, meta) {\n var submeta = createMeta(meta);\n var res = _parseRule(op, arity, vals, parentField, conv, config, submeta);\n if (!res) {\n meta.errors.push(Array.from(new Set(submeta.errors)).join(\"; \") || \"Unknown op \".concat(op, \"/\").concat(arity));\n return undefined;\n }\n return res;\n};\nvar _parseRule = function _parseRule(op, arity, vals, parentField, conv, config, meta) {\n var _groupOpConfig$cardin;\n // config.settings.groupOperators are used for group count (cardinality = 0 is exception)\n // but don't confuse with \"all-in\" or \"some-in\" for multiselect\n var isAllOrSomeInForMultiselect = multiselectOps.map(function (opName) {\n var _config$operators$opN;\n return (_config$operators$opN = config.operators[opName]) === null || _config$operators$opN === void 0 ? void 0 : _config$operators$opN.jsonLogic2;\n }).includes(op);\n var groupOp = config.settings.groupOperators.find(function (groupOp) {\n var groupOpConfig = config.operators[groupOp];\n return [groupOp, typeof groupOpConfig.jsonLogic === \"string\" && groupOpConfig.jsonLogic, groupOpConfig.jsonLogic2].includes(op);\n });\n var groupOpConfig = config.operators[groupOp];\n var isGroup0 = groupOp && (groupOpConfig === null || groupOpConfig === void 0 ? void 0 : groupOpConfig.cardinality) == 0 && !isAllOrSomeInForMultiselect;\n var cardinality = (_groupOpConfig$cardin = groupOpConfig === null || groupOpConfig === void 0 ? void 0 : groupOpConfig.cardinality) !== null && _groupOpConfig$cardin !== void 0 ? _groupOpConfig$cardin : arity - 1;\n if (!isGroup0 && jlEqOps.includes(op) && cardinality == 1 && vals[1] === null) {\n arity = 1;\n cardinality = 0;\n vals = [vals[0]];\n }\n var opk = op + \"/\" + cardinality;\n var opKeys = conv.operators[opk];\n if (!opKeys) return;\n var returnVariants = [];\n var _iterator3 = _createForOfIteratorHelper(opKeys),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var _conv$combinationOper, _meta$settings2;\n var opKey = _step3.value;\n var jlField = void 0,\n jlArgs = [];\n if (jlRangeOps.includes(op) && arity == 3) {\n jlField = vals[1];\n jlArgs = [vals[0], vals[2]];\n } else {\n var _vals2 = vals;\n var _vals3 = _toArray(_vals2);\n jlField = _vals3[0];\n jlArgs = _vals3.slice(1);\n }\n if ((_conv$combinationOper = conv.combinationOperators[opKey]) !== null && _conv$combinationOper !== void 0 && _conv$combinationOper.isRevArgs) {\n jlField = vals[vals.length - 1];\n jlArgs = vals.slice(0, vals.length - 1);\n }\n if (!isJsonLogic(jlField)) {\n continue; // try another operator\n }\n var lhs = convertLhs(groupOp, jlField, jlArgs, conv, config, null, null, meta, parentField);\n if (!lhs) {\n continue; // try another operator\n }\n var field = lhs.field,\n fieldSrc = lhs.fieldSrc,\n having = lhs.having,\n isGroup = lhs.isGroup,\n args = lhs.args;\n var fieldConfig = getFieldConfig(config, field);\n if (!fieldConfig && !((_meta$settings2 = meta.settings) !== null && _meta$settings2 !== void 0 && _meta$settings2.allowUnknownFields)) {\n meta.errors.push(\"No config for LHS \".concat(field));\n return;\n }\n var isValidOp = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.operators) && fieldConfig.operators.includes(opKey);\n returnVariants.push({\n field: field,\n fieldSrc: fieldSrc,\n fieldConfig: fieldConfig,\n opKey: opKey,\n args: args,\n having: having,\n isValidOp: isValidOp\n });\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n returnVariants.sort(function (_ref7) {\n var isValidOp = _ref7.isValidOp;\n return isValidOp ? -1 : +1;\n });\n return returnVariants[0];\n};\nvar _convertOp = function convertOp(op, vals, conv, config, not, meta) {\n var _opConfig;\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var _isOneRuleInRuleGroup = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;\n if (!op) return undefined;\n var jlConjs = Object.values(config.conjunctions).map(function (_ref8) {\n var jsonLogicConj = _ref8.jsonLogicConj;\n return jsonLogicConj;\n });\n var arity = vals.length;\n var parseRes = parseRule(op, arity, vals, parentField, conv, config, meta);\n if (!parseRes) return undefined;\n var field = parseRes.field,\n fieldSrc = parseRes.fieldSrc,\n fieldConfig = parseRes.fieldConfig,\n opKey = parseRes.opKey,\n args = parseRes.args,\n having = parseRes.having;\n var parentFieldConfig = getFieldConfig(config, parentField);\n var opConfig = config.operators[opKey];\n var reversedOpConfig = config.operators[(_opConfig = opConfig) === null || _opConfig === void 0 ? void 0 : _opConfig.reversedOp];\n var opNeedsReverse = false;\n var opCanReverse = !!reversedOpConfig;\n\n // Group component in array mode can show NOT checkbox, so do nothing in this case\n // Otherwise try to reverse\n // const showNot = fieldConfig?.showNot !== undefined ? fieldConfig.showNot : config.settings.showNot;\n var isRuleGroup = fieldConfig.type == \"!group\";\n // const isGroupArray = isRuleGroup && fieldConfig.mode == \"array\";\n var isInRuleGroup = (parentFieldConfig === null || parentFieldConfig === void 0 ? void 0 : parentFieldConfig.type) == \"!group\";\n var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse || isRuleGroup && !having // !(count == 2) -> count != 2 // because \"NOT\" is not visible inside rule_group if there are no children\n || !isRuleGroup && isInRuleGroup && !_isOneRuleInRuleGroup // 2+ rules in rule-group should be flat. see inits.with_not_and_in_some in test\n );\n // if (isGroupArray && showNot)\n // canRev = false;\n var needRev = not && canRev || opNeedsReverse;\n var conj;\n var havingVals;\n var havingNot = false;\n var canRevHaving = !!config.settings.reverseOperatorsForNot;\n if ((fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) == \"!group\" && having) {\n conj = Object.keys(having)[0];\n havingVals = having[conj];\n if (!Array.isArray(havingVals)) havingVals = [havingVals];\n\n // Preprocess \"!\": Try to reverse op in single rule in having\n // Eg. use `not_equal` instead of `not` `equal`\n // We look for template matches here to make sure we dont reverse when \"!\" is\n // part of operator\n var match = matchAgainstTemplates(having, conv, meta);\n while (conj == \"!\" && !match) {\n var isEmptyOp = conj == \"!\" && havingVals.length == 1 && havingVals[0] && isJsonLogic(havingVals[0]) && conv.varKeys.includes(Object.keys(havingVals[0])[0]);\n if (isEmptyOp) {\n break;\n }\n havingNot = !havingNot;\n having = having[\"!\"];\n conj = Object.keys(having)[0];\n havingVals = having[conj];\n // Negation group with single rule is to be treated the same as !\n if (canRevHaving && jlConjs.includes(conj) && havingVals.length == 1) {\n having = having[conj][0];\n conj = Object.keys(having)[0];\n havingVals = having[conj];\n }\n // Another template matching\n var matchTemp = matchAgainstTemplates(having, conv, meta);\n match = matchTemp ? matchTemp : match;\n }\n if (!Array.isArray(havingVals)) {\n havingVals = [havingVals];\n }\n // If template match found we act accordingly\n if (match) {\n // We reset vals if match found\n havingVals = [];\n havingVals[0] = match.jlField;\n match.jlArgs.forEach(function (arg) {\n return havingVals.push(arg);\n });\n // We reset op to new op that represents multiple jsonlogic operators\n conj = match.newOp;\n if (jlDualMeaningOps.includes(match.newOp)) {\n // use original order of args\n havingVals = match.vals;\n }\n }\n }\n\n // Use reversed op\n if (needRev) {\n not = !not;\n opKey = opConfig.reversedOp;\n opConfig = config.operators[opKey];\n }\n var widget = getWidgetForFieldOp(config, field, opKey, null);\n var convertedArgs = args.map(function (v) {\n return _convertFromLogic(v, conv, config, [\"val\"], meta, false, fieldConfig, widget, parentField);\n });\n if (convertedArgs.filter(function (v) {\n return v === undefined;\n }).length) {\n //meta.errors.push(`Undefined arg for field ${field} and op ${opKey}`);\n return undefined;\n }\n var res;\n var fieldType = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type;\n if (fieldType === \"!group\" || fieldType === \"!struct\") {\n fieldType = null;\n }\n if ((fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) == \"!group\" && having) {\n if (conv.conjunctions[conj] !== undefined) {\n // group\n res = convertConj(conj, havingVals, conv, config, havingNot, meta, field, true);\n } else {\n // rule, need to be wrapped in `rule_group`\n res = _convertOp(conj, havingVals, conv, config, havingNot, meta, field, true);\n if (res) {\n var _res$properties;\n if (res.type === \"rule_group\" && ((_res$properties = res.properties) === null || _res$properties === void 0 ? void 0 : _res$properties.field) !== field) {\n res = wrapInDefaultConjRuleGroup(res, field, fieldConfig, config);\n }\n Object.assign(res.properties, {\n conjunction: defaultGroupConjunction(config, fieldConfig)\n });\n }\n }\n if (!res) return undefined;\n res.type = \"rule_group\";\n Object.assign(res.properties, {\n field: field,\n mode: fieldConfig.mode,\n operator: opKey\n });\n if (fieldConfig.mode == \"array\") {\n Object.assign(res.properties, {\n value: convertedArgs.map(function (v) {\n return v.value;\n }),\n valueSrc: convertedArgs.map(function (v) {\n return v.valueSrc;\n }),\n valueType: convertedArgs.map(function (v) {\n return v.valueType;\n })\n });\n }\n if (not) {\n // tip: don't set not to properties, only havingNot should affect it\n res = wrapInDefaultConj(res, config, not);\n }\n } else if ((fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) == \"!group\" && !having) {\n res = {\n type: \"rule_group\",\n id: uuid(),\n children1: {},\n properties: {\n conjunction: defaultGroupConjunction(config, fieldConfig),\n // tip: `not: true` have no effect if there are no children! \"NOT\" is hidden in UI and is ignored during export\n // So it's better to reverse group op (see `canRev =`), or wrap in conj with NOT as a last resort\n not: false,\n mode: fieldConfig.mode,\n field: field,\n operator: opKey\n }\n };\n if (fieldConfig.mode === \"array\") {\n Object.assign(res.properties, {\n value: convertedArgs.map(function (v) {\n return v.value;\n }),\n valueSrc: convertedArgs.map(function (v) {\n return v.valueSrc;\n }),\n valueType: convertedArgs.map(function (v) {\n return v.valueType;\n })\n });\n }\n if (not) {\n res = wrapInDefaultConj(res, config, not);\n }\n } else {\n var asyncListValuesArr = convertedArgs.map(function (v) {\n return v.asyncListValues;\n }).filter(function (v) {\n return v != undefined;\n });\n var asyncListValues = asyncListValuesArr.length ? asyncListValuesArr[0] : undefined;\n res = {\n type: \"rule\",\n id: uuid(),\n properties: _objectSpread({\n field: field,\n fieldSrc: fieldSrc,\n operator: opKey,\n value: convertedArgs.map(function (v) {\n return v.value;\n }),\n valueSrc: convertedArgs.map(function (v) {\n return v.valueSrc;\n }),\n valueType: convertedArgs.map(function (v) {\n return v.valueType;\n })\n }, asyncListValues ? {\n asyncListValues: asyncListValues\n } : {})\n };\n if (not || _isOneRuleInRuleGroup) {\n res = wrapInDefaultConj(res, config, not);\n }\n }\n return res;\n};\nvar convertCaseVal = function convertCaseVal(op, vals, conv, config, not, meta) {\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var val = _defineProperty({}, op, vals);\n var defaultCaseVal = buildCaseValProperties(config, meta, conv, val);\n if (defaultCaseVal === undefined) {\n return undefined;\n }\n var defaultCase = wrapInCase(null, defaultCaseVal, config, meta);\n var children1 = [defaultCase];\n var switchI = {\n type: \"switch_group\",\n id: uuid(),\n children1: children1,\n properties: {}\n };\n return switchI;\n};\nvar convertSwitch = function convertSwitch(op, vals, conv, config, not, meta) {\n var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n if ((op === null || op === void 0 ? void 0 : op.toLowerCase()) !== \"if\") return undefined;\n var flat = flatizeTernary(vals);\n var cases = flat.map(function (_ref9) {\n var _ref10 = _slicedToArray(_ref9, 2),\n cond = _ref10[0],\n val = _ref10[1];\n return [cond ? _convertFromLogic(cond, conv, config, [\"rule\", \"group\"], meta, false, null, null, parentField) : null, buildCaseValProperties(config, meta, conv, val)];\n });\n var children1 = cases.map(function (_ref11) {\n var _ref12 = _slicedToArray(_ref11, 2),\n cond = _ref12[0],\n val = _ref12[1];\n return wrapInCase(cond, val, config, meta);\n });\n var switchI = {\n type: \"switch_group\",\n id: uuid(),\n children1: children1,\n properties: {}\n };\n return switchI;\n};\nvar flatizeTernary = function flatizeTernary(children) {\n var flat = [];\n function _processTernaryChildren(tern) {\n var _tern = _slicedToArray(tern, 3),\n cond = _tern[0],\n if_val = _tern[1],\n else_val = _tern[2];\n flat.push([cond, if_val]);\n var else_op = isJsonLogic(else_val) ? Object.keys(else_val)[0] : null;\n if ((else_op === null || else_op === void 0 ? void 0 : else_op.toLowerCase()) === \"if\") {\n _processTernaryChildren(else_val[else_op]);\n } else {\n flat.push([undefined, else_val]);\n }\n }\n _processTernaryChildren(children);\n return flat;\n};\nvar wrapInCase = function wrapInCase(cond, valProperties, config, meta) {\n var caseI;\n if (cond) {\n caseI = _objectSpread({}, cond);\n if (caseI.type) {\n if (caseI.type != \"group\") {\n caseI = wrapInDefaultConj(caseI, config);\n }\n caseI.type = \"case_group\";\n } else {\n meta.errors.push(\"Unexpected case: \".concat(JSON.stringify(caseI)));\n caseI = undefined;\n }\n } else {\n caseI = {\n id: uuid(),\n type: \"case_group\",\n properties: {}\n };\n }\n if (caseI) {\n caseI.properties = _objectSpread(_objectSpread({}, caseI.properties), valProperties);\n }\n return caseI;\n};\nvar buildCaseValProperties = function buildCaseValProperties(config, meta, conv, val) {\n var caseValueFieldConfig = getFieldConfig(config, \"!case_value\");\n if (!caseValueFieldConfig) {\n meta.errors.push(\"Missing caseValueField in settings\");\n return undefined;\n }\n var widget = caseValueFieldConfig.mainWidget;\n var widgetDef = config.widgets[widget];\n if (!widgetDef) {\n meta.errors.push(\"No widget \".concat(widget, \" for case value\"));\n return undefined;\n }\n var convVal = _convertFromLogic(val, conv, config, [\"val\", \"case_val\"], meta, false, caseValueFieldConfig, widget);\n if (convVal == undefined) {\n return undefined;\n }\n var value = convVal.value,\n valueSrc = convVal.valueSrc,\n valueType = convVal.valueType;\n var valProperties = {\n value: [value],\n valueSrc: [valueSrc !== null && valueSrc !== void 0 ? valueSrc : \"value\"],\n valueType: [valueType !== null && valueType !== void 0 ? valueType : widgetDef === null || widgetDef === void 0 ? void 0 : widgetDef.type],\n field: \"!case_value\"\n };\n return valProperties;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nvar _translations;\nimport * as constants from \"./constains\";\nexport var translations = (_translations = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_translations, constants.EMPTY_GROUP, \"Empty group\"), constants.EMPTY_RULE_GROUP, \"No conditions for group field {{field}}\"), constants.EMPTY_QUERY, \"Empty query\"), constants.EMPTY_CASE, \"Empty case\"), constants.NO_CONFIG_FOR_FIELD, \"No config for field {{field}}\"), constants.FIXED_OPERATOR, \"Fixed operator {{from}} to {{to}} for field {{field}}\"), constants.NO_CONFIG_FOR_OPERATOR, \"No config for operator {{operator}}\"), constants.NO_CONFIG_FOR_FUNCTION, \"No config for function {{funcKey}}\"), constants.INVALID_VALUE, \"Invalid value\"), constants.INVALID_FUNC_ARG_VALUE, \"Invalid value of arg {{argName}} for func {{funcName}}: {{argValidationError}}\"), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_translations, constants.UNSUPPORTED_FIELD_TYPE, \"Type of field {{field}} is not supported\"), constants.UNSUPPORTED_OPERATOR_FOR_FIELD, \"Operator {{operator}} is not supported for field {{field}}\"), constants.INCOMPLETE_RULE, \"Incomplete rule\"), constants.INCOMPLETE_LHS, \"Incomplete LHS\"), constants.INCOMPLETE_RHS, \"Incomplete RHS\"), constants.INVALID_VALUE_SRC, \"Invalid value src {{valueSrcs, list}}\"), constants.BAD_MULTISELECT_VALUES + \"_one\", \"Value {{badValues, list}} is not in the list of allowed values\"), constants.BAD_MULTISELECT_VALUES + \"_other\", \"Values {{badValues, list}} are not in the list of allowed values\"), constants.BAD_SELECT_VALUE, \"Value {{value}} is not in the list of allowed values\"), constants.INCORRECT_VALUE_TYPE, \"Value should have type {{wType}}, but got value of type {{valueType}}\"), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_translations, constants.INCORRECT_VALUE_JS_TYPE, \"Value should have JS type {{jsType}}, but got value of type {{valueTypeof}}\"), constants.VALUE_LENGTH_CONSTRAINT_FAIL, \"Value {{value}} should have max length {{fieldSettings.maxLength}} but got {{length}}\"), constants.VALUE_MIN_CONSTRAINT_FAIL, \"Value {{value}} should be greater than or equal to {{fieldSettings.min}}\"), constants.VALUE_MIN_CONSTRAINT_FAIL + \"_\" + constants._CONTEXT_MIN_MAX, \"Value {{value}} should be from {{fieldSettings.min}} to {{fieldSettings.max}}\"), constants.VALUE_MAX_CONSTRAINT_FAIL, \"Value {{value}} should be less than or equal to {{fieldSettings.max}}\"), constants.VALUE_MAX_CONSTRAINT_FAIL + \"_\" + constants._CONTEXT_MIN_MAX, \"Value {{value}} should be from {{fieldSettings.min}} to {{fieldSettings.max}}\"), constants.NO_CONFIG_FOR_FIELD_VALUE, \"No config for field {{field}}\"), constants.CANT_COMPARE_FIELD_WITH_ITSELF, \"Can't compare field {{field}} with itself\"), constants.CANT_COMPARE_FIELD_WITH_FIELD, \"Can't compare field {{leftField}} with {{rightField}}\"), constants.INCORRECT_FIELD_TYPE, \"Field {{field}} is of type {{type}}, but expected {{expected}}\"), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_translations, constants.UNSUPPORTED_FUNCTION_FOR_FIELD, \"Unsupported function {{funcKey}} for field {{field}}\"), constants.REQUIRED_FUNCTION_ARG, \"Value of arg {{argName}} for func {{funcName}} is required\"), constants.INCORRECT_FUNCTION_RETURN_TYPE, \"Function {{funcKey}} should return value of type {{returnType}}, but got {{valueType}}\"), constants.INVALID_RANGE, \"Invalid range\"), constants.ITEM_POSITION_ROOT, \"Root\"), constants.ITEM_POSITION + \"__rule\", \"Leaf #{{globalLeafNo}}\"), constants.ITEM_POSITION + \"__group\", \"Group #{{globalGroupNo}}\"), constants.ITEM_POSITION + \"__rule_group\", \"Rule-group #{{globalNoByType}}\"), constants.ITEM_POSITION + \"__case_group\", \"Case #{{globalNoByType}}\"), constants.ITEM_POSITION + \"__rule__deleted\", \"Deleted leaf #{{globalLeafNo}}\"), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_translations, constants.ITEM_POSITION + \"__group__deleted\", \"Deleted group #{{globalGroupNo}}\"), constants.ITEM_POSITION + \"__rule_group__deleted\", \"Deleted rule-group #{{globalNoByType}}\"), constants.ITEM_POSITION + \"__case_group__deleted\", \"Deleted case #{{globalNoByType}}\"), constants.ITEM_POSITION_IN_CASE, \"{{str}} in case #{{caseNo}}\"), constants.ITEM_POSITION_WITH_INDEX_PATH, \"{{str}} (index path: {{indexPath, list}})\"));","// Note: Don't use \":\" char inside strings, it's reserved as a namespace\n\nexport var EMPTY_GROUP = \"EMPTY_GROUP\";\nexport var EMPTY_RULE_GROUP = \"EMPTY_RULE_GROUP\";\nexport var EMPTY_QUERY = \"EMPTY_QUERY\";\nexport var EMPTY_CASE = \"EMPTY_CASE\";\nexport var NO_CONFIG_FOR_FIELD = \"NO_CONFIG_FOR_FIELD\";\nexport var NO_CONFIG_FOR_OPERATOR = \"NO_CONFIG_FOR_OPERATOR\";\nexport var FIXED_OPERATOR = \"FIXED_OPERATOR\";\nexport var NO_CONFIG_FOR_FUNCTION = \"NO_CONFIG_FOR_FUNCTION\";\nexport var INVALID_VALUE = \"INVALID_VALUE\";\nexport var INVALID_FUNC_ARG_VALUE = \"INVALID_FUNC_ARG_VALUE\";\nexport var UNSUPPORTED_FIELD_TYPE = \"UNSUPPORTED_FIELD_TYPE\";\nexport var UNSUPPORTED_OPERATOR_FOR_FIELD = \"UNSUPPORTED_OPERATOR_FOR_FIELD\";\nexport var INVALID_VALUE_SRC = \"INVALID_VALUE_SRC\";\nexport var INCOMPLETE_RULE = \"INCOMPLETE_RULE\";\nexport var INCOMPLETE_LHS = \"INCOMPLETE_LHS\";\nexport var INCOMPLETE_RHS = \"INCOMPLETE_RHS\";\nexport var BAD_MULTISELECT_VALUES = \"BAD_MULTISELECT_VALUES\";\nexport var BAD_SELECT_VALUE = \"BAD_SELECT_VALUE\";\nexport var INCORRECT_VALUE_TYPE = \"INCORRECT_VALUE_TYPE\";\nexport var INCORRECT_VALUE_JS_TYPE = \"INCORRECT_VALUE_JS_TYPE\";\nexport var VALUE_LENGTH_CONSTRAINT_FAIL = \"VALUE_LENGTH_CONSTRAINT_FAIL\";\nexport var VALUE_MIN_CONSTRAINT_FAIL = \"VALUE_MIN_CONSTRAINT_FAIL\";\nexport var VALUE_MAX_CONSTRAINT_FAIL = \"VALUE_MAX_CONSTRAINT_FAIL\";\nexport var NO_CONFIG_FOR_FIELD_VALUE = \"NO_CONFIG_FOR_FIELD_VALUE\";\nexport var CANT_COMPARE_FIELD_WITH_ITSELF = \"CANT_COMPARE_FIELD_WITH_ITSELF\";\nexport var CANT_COMPARE_FIELD_WITH_FIELD = \"CANT_COMPARE_FIELD_WITH_FIELD\";\nexport var INCORRECT_FIELD_TYPE = \"INCORRECT_FIELD_TYPE\";\nexport var UNSUPPORTED_FUNCTION_FOR_FIELD = \"UNSUPPORTED_FUNCTION_FOR_FIELD\";\nexport var REQUIRED_FUNCTION_ARG = \"REQUIRED_FUNCTION_ARG\";\nexport var INCORRECT_FUNCTION_RETURN_TYPE = \"INCORRECT_FUNCTION_RETURN_TYPE\";\nexport var INVALID_RANGE = \"INVALID_RANGE\";\nexport var ITEM_POSITION = \"ITEM_POSITION\";\nexport var ITEM_POSITION_ROOT = \"ITEM_POSITION_ROOT\";\nexport var ITEM_POSITION_WITH_INDEX_PATH = \"ITEM_POSITION_WITH_INDEX_PATH\";\nexport var ITEM_POSITION_IN_CASE = \"ITEM_POSITION_IN_CASE\";\nexport var _CONTEXT_MIN_MAX = \"range\";","import i18next from \"i18next\";\nimport { translations as validationTranslations } from \"./validation/translations\";\nexport var NSV = \"raqbvalidation\";\nexport var NSVP = \"\".concat(NSV, \":\");\nvar i18n = i18next.createInstance();\ni18n.init({\n fallbackLng: \"en\"\n});\ni18n.addResources(\"en\", NSV, validationTranslations);\nvar _translateValidation = function translateValidation(key, args) {\n if (key !== null && key !== void 0 && key.str) {\n // already translated\n return key.str;\n }\n if (key !== null && key !== void 0 && key.key) {\n return _translateValidation(key.key, key.args);\n }\n if (args === null) {\n return key;\n }\n return i18n.t(key.includes(\":\") ? key : NSVP + key, args);\n};\nexport { _translateValidation as translateValidation };\nexport default i18n;","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport Immutable from \"immutable\";\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getWidgetForFieldOp, getValueSourcesForFieldOp, selectTypes } from \"./configUtils\";\nimport { getOpCardinality, getFirstDefined } from \"./stuff\";\nimport { translateValidation } from \"../i18n\";\nimport { jsToImmutable } from \"./treeUtils\";\n\n/**\n * @param {Immutable.Map} current\n * @param {string} changedProp\n * @param {boolean} canFix (default: false) true - eg. set value to max if it > max or revert or drop\n * @param {boolean} isEndValue (default: false) true - if value is in process of editing by user\n * @param {boolean} canDropArgs (default: false)\n * @return {{canReuseValue, newValue, newValueSrc, newValueType, fixedField, operatorCardinality, newValueError, newFieldError, validationErrors}}\n */\nexport var getNewValueForFieldOp = function getNewValueForFieldOp(_ref, config) {\n var _currentField, _currentField$get, _newField, _newField$get;\n var validateValue = _ref.validateValue,\n validateRange = _ref.validateRange;\n var oldConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var current = arguments.length > 3 ? arguments[3] : undefined;\n var newField = arguments.length > 4 ? arguments[4] : undefined;\n var newOperator = arguments.length > 5 ? arguments[5] : undefined;\n var changedProp = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var canFix = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;\n var isEndValue = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var canDropArgs = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;\n //const isValidatingTree = (changedProp === null);\n if (!oldConfig) oldConfig = config;\n var _config$settings = config.settings,\n keepInputOnChangeFieldSrc = _config$settings.keepInputOnChangeFieldSrc,\n convertableWidgets = _config$settings.convertableWidgets,\n clearValueOnChangeField = _config$settings.clearValueOnChangeField,\n clearValueOnChangeOp = _config$settings.clearValueOnChangeOp;\n var isCase = newField == \"!case_value\";\n var currentField = current.get(\"field\");\n if (!currentField && isCase) {\n currentField = newField;\n }\n var currentFieldType = current.get(\"fieldType\");\n var currentFieldSrc = current.get(\"fieldSrc\");\n var currentOperator = current.get(\"operator\");\n var currentValue = current.get(\"value\");\n var currentValueSrc = current.get(\"valueSrc\", new Immutable.List());\n var currentValueType = current.get(\"valueType\", new Immutable.List());\n var currentValueError = current.get(\"valueError\", new Immutable.List());\n var asyncListValues = current.get(\"asyncListValues\");\n var isOkWithoutOperator = isCase;\n var currentOperatorConfig = getOperatorConfig(oldConfig, currentOperator);\n var newOperatorConfig = getOperatorConfig(config, newOperator, newField);\n var currentOperatorCardinality = isCase ? 1 : currentOperator ? getOpCardinality(currentOperatorConfig) : null;\n var operatorCardinality = isCase ? 1 : newOperator ? getOpCardinality(newOperatorConfig) : null;\n var currentFieldConfig = getFieldConfig(oldConfig, currentField);\n var newFieldConfig = getFieldConfig(config, newField);\n var isOkWithoutField = !currentField && currentFieldType && keepInputOnChangeFieldSrc;\n var currentType = (currentFieldConfig === null || currentFieldConfig === void 0 ? void 0 : currentFieldConfig.type) || currentFieldType;\n var newType = (newFieldConfig === null || newFieldConfig === void 0 ? void 0 : newFieldConfig.type) || !newField && isOkWithoutField && currentType;\n var currentListValuesType = currentFieldConfig === null || currentFieldConfig === void 0 ? void 0 : currentFieldConfig.listValuesType;\n var newListValuesType = newFieldConfig === null || newFieldConfig === void 0 ? void 0 : newFieldConfig.listValuesType;\n var currentFieldSimpleValue = ((_currentField = currentField) === null || _currentField === void 0 || (_currentField$get = _currentField.get) === null || _currentField$get === void 0 ? void 0 : _currentField$get.call(_currentField, \"func\")) || currentField;\n var newFieldSimpleValue = ((_newField = newField) === null || _newField === void 0 || (_newField$get = _newField.get) === null || _newField$get === void 0 ? void 0 : _newField$get.call(_newField, \"func\")) || newField;\n var hasFieldChanged = newFieldSimpleValue != currentFieldSimpleValue;\n var validationErrors = [];\n var canReuseValue = (currentField || isOkWithoutField) && (currentOperator && newOperator || isOkWithoutOperator) && currentValue != undefined;\n if (!(currentType && newType && currentType == newType) || changedProp === \"field\" && hasFieldChanged && clearValueOnChangeField || changedProp === \"operator\" && clearValueOnChangeOp) {\n canReuseValue = false;\n }\n if (hasFieldChanged && selectTypes.includes(newType)) {\n if (newListValuesType && newListValuesType === currentListValuesType) {\n // ok\n } else {\n // different fields of select types has different listValues\n canReuseValue = false;\n }\n }\n if (!isOkWithoutOperator && (!(currentValue !== null && currentValue !== void 0 && currentValue.size) && operatorCardinality || currentValue !== null && currentValue !== void 0 && currentValue.size && !operatorCardinality)) {\n canReuseValue = false;\n }\n\n // validate func LHS\n var newFieldError;\n if (currentFieldSrc === \"func\" && newField) {\n var _validateValue = validateValue(config, null, null, newOperator, newField, newType, currentFieldSrc, asyncListValues, canFix, isEndValue, canDropArgs),\n _validateValue2 = _slicedToArray(_validateValue, 2),\n fixedField = _validateValue2[0],\n fieldErrors = _validateValue2[1];\n var isValid = !(fieldErrors !== null && fieldErrors !== void 0 && fieldErrors.length);\n var willFix = fixedField !== newField;\n var willFixAllErrors = !isValid && willFix && !fieldErrors.find(function (e) {\n return !e.fixed;\n });\n var willRevert = canFix && !isValid && !willFixAllErrors && !!changedProp && newField !== currentField;\n var willDrop = false; //canFix && !isValid && !willFixAllErrors && !willRevert && !changedProp;\n if (willDrop) {\n newField = null;\n } else if (willRevert) {\n newField = currentField;\n } else if (willFix) {\n newField = fixedField;\n }\n if (!isValid) {\n var showError = !isValid && !willFixAllErrors && !willDrop && !willRevert;\n var firstError = fieldErrors.find(function (e) {\n return !e.fixed && !e.ignore;\n });\n if (showError && firstError) {\n newFieldError = translateValidation(firstError);\n }\n // tip: even if we don't show errors, but revert LHS, put the reason of revert\n fieldErrors.map(function (e) {\n return validationErrors.push(_objectSpread(_objectSpread({\n side: \"lhs\"\n }, e), {}, {\n fixed: e.fixed || willRevert || willDrop\n }));\n });\n }\n }\n\n // compare old & new widgets\n for (var i = 0; i < operatorCardinality; i++) {\n var vs = currentValueSrc.get(i) || null;\n var currentWidget = getWidgetForFieldOp(oldConfig, currentField, currentOperator, vs);\n var newWidget = getWidgetForFieldOp(config, newField, newOperator, vs);\n // need to also check value widgets if we changed operator and current value source was 'field'\n // cause for select type op '=' requires single value and op 'in' requires array value\n var currentValueWidget = vs === \"value\" ? currentWidget : getWidgetForFieldOp(oldConfig, currentField, currentOperator, \"value\");\n var newValueWidget = vs === \"value\" ? newWidget : getWidgetForFieldOp(config, newField, newOperator, \"value\");\n var canReuseWidget = newValueWidget == currentValueWidget || (convertableWidgets[currentValueWidget] || []).includes(newValueWidget) || !currentValueWidget && isOkWithoutField;\n if (!canReuseWidget) {\n canReuseValue = false;\n }\n }\n if (currentOperator != newOperator && [currentOperator, newOperator].includes(\"proximity\")) {\n canReuseValue = false;\n }\n var firstValueSrc = currentValueSrc.first();\n var firstWidgetConfig = getFieldWidgetConfig(config, newField, newOperator, null, firstValueSrc);\n var valueSources = getValueSourcesForFieldOp(config, newField, newOperator, null);\n if (!newField && isOkWithoutField) {\n valueSources = Object.keys(config.settings.valueSourcesInfo);\n }\n var defaultValueSrc = valueSources[0];\n var defaultValueType;\n if (operatorCardinality === 1 && firstWidgetConfig && firstWidgetConfig.type !== undefined) {\n defaultValueType = firstWidgetConfig.type;\n } else if (operatorCardinality === 1 && newFieldConfig && newFieldConfig.type !== undefined) {\n defaultValueType = newFieldConfig.type === \"!group\" ? \"number\" : newFieldConfig.type;\n }\n\n // changed operator from '==' to 'between'\n var canExtendValueToRange = canReuseValue && changedProp === \"operator\" && currentOperatorCardinality === 1 && operatorCardinality === 2;\n var valueFixes = [];\n var valueSrcFixes = [];\n var valueTypeFixes = [];\n var valueErrors = Array.from({\n length: operatorCardinality\n }, function () {\n return null;\n });\n if (canReuseValue) {\n var _loop = function _loop(_i) {\n var v = currentValue.get(_i);\n var vType = currentValueType.get(_i) || null;\n var vSrc = currentValueSrc.get(_i) || null;\n if (canExtendValueToRange && _i === 1) {\n v = valueFixes[0] !== undefined ? valueFixes[0] : currentValue.get(0);\n valueFixes[_i] = v;\n vType = currentValueType.get(0) || null;\n vSrc = currentValueSrc.get(0) || null;\n }\n var isValidSrc = vSrc ? valueSources.find(function (v) {\n return v == vSrc;\n }) !== undefined : true;\n var _validateValue3 = validateValue(config, newField, newField, newOperator, v, vType, vSrc, asyncListValues, canFix, isEndValue, canDropArgs),\n _validateValue4 = _slicedToArray(_validateValue3, 2),\n fixedValue = _validateValue4[0],\n allErrors = _validateValue4[1];\n var isValid = !(allErrors !== null && allErrors !== void 0 && allErrors.length);\n // Allow bad value with error message\n // But not on field change - in that case just drop bad value that can't be reused\n // ? Maybe we should also drop bad value on op change?\n // For bad multiselect value we have both error message + fixed value.\n // If we show error message, it will gone on next tree validation\n var willFix = fixedValue !== v;\n var willFixAllErrors = !isValid && willFix && !(allErrors !== null && allErrors !== void 0 && allErrors.find(function (e) {\n return !e.fixed;\n }));\n var allErrorsHandled = !(allErrors !== null && allErrors !== void 0 && allErrors.find(function (e) {\n return !e.fixed && !e.ignore;\n }));\n\n // tip: is value src is invalid, drop ANYWAY\n // tip: Edge case in demo:\n // Given \"login = LOWER(?)\", change config to not show errors -> \"LOWER(?)\" will be dropped\n // We don't want to drop func completely, so need to add `allErrorsAheHandled` or `vSrc !== \"func\"`\n // todo: `hasFieldChanged` is not needed ?\n var willDrop = !isValidSrc || canFix && !isValid && !willFixAllErrors && (!allErrorsHandled || hasFieldChanged);\n if (!isValid) {\n // tip: even if we don't show errors, but drop bad values, put the reason of removal\n allErrors === null || allErrors === void 0 || allErrors.map(function (e) {\n return validationErrors.push(_objectSpread(_objectSpread({\n side: \"rhs\",\n delta: _i\n }, e), {}, {\n fixed: e.fixed || willDrop\n }));\n });\n }\n if (willDrop) {\n valueFixes[_i] = null;\n if (_i === 0) {\n delete valueFixes[1];\n }\n }\n var showError = !isValid && !willFix;\n var firstError = allErrors === null || allErrors === void 0 ? void 0 : allErrors.find(function (e) {\n return !e.fixed && !e.ignore;\n });\n if (showError && firstError) {\n valueErrors[_i] = translateValidation(firstError);\n }\n if (willFix) {\n valueFixes[_i] = fixedValue;\n }\n if (canExtendValueToRange && _i === 0 && !isValid && !willFix) {\n // don't extend bad value to range\n canExtendValueToRange = false;\n }\n if (canExtendValueToRange && _i === 0 && [\"func\", \"field\"].includes(vSrc)) {\n // don't extend func/field value, only primitive value\n canExtendValueToRange = false;\n }\n };\n for (var _i = 0; _i < operatorCardinality; _i++) {\n _loop(_i);\n }\n }\n\n // if can't reuse, get defaultValue\n if (!canReuseValue) {\n for (var _i2 = 0; _i2 < operatorCardinality; _i2++) {\n if (operatorCardinality === 1) {\n var _newFieldConfig$field, _dv$get;\n // tip: default range values (for cardinality > 1) are not supported yet, todo\n var dv = getFirstDefined([newFieldConfig === null || newFieldConfig === void 0 ? void 0 : newFieldConfig.defaultValue, newFieldConfig === null || newFieldConfig === void 0 || (_newFieldConfig$field = newFieldConfig.fieldSettings) === null || _newFieldConfig$field === void 0 ? void 0 : _newFieldConfig$field.defaultValue, firstWidgetConfig === null || firstWidgetConfig === void 0 ? void 0 : firstWidgetConfig.defaultValue]);\n valueFixes[_i2] = dv;\n if (dv !== null && dv !== void 0 && dv.func || dv !== null && dv !== void 0 && (_dv$get = dv.get) !== null && _dv$get !== void 0 && _dv$get.call(dv, \"func\")) {\n valueSrcFixes[_i2] = \"func\";\n //tip: defaultValue of src \"field\" is not supported, todo\n }\n }\n }\n }\n\n // set default valueSrc and valueType\n for (var _i3 = 0; _i3 < operatorCardinality; _i3++) {\n var _vs = canReuseValue && currentValueSrc.get(_i3) || null;\n var vt = canReuseValue && currentValueType.get(_i3) || null;\n var v = valueFixes[_i3] !== undefined ? valueFixes[_i3] : canReuseValue ? currentValue.get(_i3) : undefined;\n if (canReuseValue && canExtendValueToRange && _i3 === 1) {\n var _valueSrcFixes$_i, _valueTypeFixes$_i;\n _vs = (_valueSrcFixes$_i = valueSrcFixes[_i3]) !== null && _valueSrcFixes$_i !== void 0 ? _valueSrcFixes$_i : currentValueSrc.get(0);\n vt = (_valueTypeFixes$_i = valueTypeFixes[_i3]) !== null && _valueTypeFixes$_i !== void 0 ? _valueTypeFixes$_i : currentValueType.get(0);\n valueSrcFixes[_i3] = _vs;\n valueTypeFixes[_i3] = vt;\n }\n var isValidSrc = valueSources.includes(_vs);\n if (!isValidSrc) {\n valueSrcFixes[_i3] = defaultValueSrc;\n }\n if (!vt) {\n valueTypeFixes[_i3] = defaultValueType;\n }\n // Fix if func in LHS has `defaultValue: { func: ..., args: {...} }`\n if (v !== null && v !== void 0 && v.func) {\n valueFixes[_i3] = jsToImmutable(v);\n valueSrcFixes[_i3] = \"func\";\n }\n }\n\n // build new values\n var newValue = currentValue;\n if (valueFixes.length > 0 || !canReuseValue || operatorCardinality < currentOperatorCardinality) {\n newValue = new Immutable.List(Array.from({\n length: operatorCardinality\n }, function (_ignore, i) {\n return valueFixes[i] !== undefined ? valueFixes[i] : canReuseValue ? currentValue.get(i) : undefined;\n }));\n }\n var newValueSrc = currentValueSrc;\n if (valueSrcFixes.length > 0 || !canReuseValue || operatorCardinality < currentOperatorCardinality) {\n newValueSrc = new Immutable.List(Array.from({\n length: operatorCardinality\n }, function (_ignore, i) {\n var _valueSrcFixes$i;\n return (_valueSrcFixes$i = valueSrcFixes[i]) !== null && _valueSrcFixes$i !== void 0 ? _valueSrcFixes$i : canReuseValue && currentValueSrc.get(i) || null;\n }));\n }\n var newValueType = currentValueType;\n if (valueTypeFixes.length > 0 || !canReuseValue || operatorCardinality < currentOperatorCardinality) {\n newValueType = new Immutable.List(Array.from({\n length: operatorCardinality\n }, function (_ignore, i) {\n var _valueTypeFixes$i;\n return (_valueTypeFixes$i = valueTypeFixes[i]) !== null && _valueTypeFixes$i !== void 0 ? _valueTypeFixes$i : canReuseValue && currentValueType.get(i) || null;\n }));\n }\n\n // Validate range\n var rangeErrorObj = validateRange(config, newField, newOperator, newValue, newValueSrc);\n if (rangeErrorObj) {\n // last element in `valueError` list is for range validation error\n var rangeValidationError = translateValidation(rangeErrorObj);\n var _willFix = canFix && operatorCardinality >= 2;\n var badValue = newValue;\n if (_willFix) {\n valueFixes[1] = newValue.get(0);\n newValue = newValue.set(1, valueFixes[1]);\n valueErrors[1] = valueErrors[0];\n }\n var _showError = !_willFix;\n if (_showError) {\n valueErrors.push(rangeValidationError);\n }\n validationErrors.push(_objectSpread(_objectSpread({\n side: \"rhs\",\n delta: -1\n }, rangeErrorObj), {}, {\n fixed: _willFix,\n fixedFrom: _willFix ? [badValue.get(0), badValue.get(1)] : undefined,\n fixedTo: _willFix ? [newValue.get(0), newValue.get(1)] : undefined\n }));\n }\n var newValueError = currentValueError;\n var hasValueErrorChanged = (currentValueError === null || currentValueError === void 0 ? void 0 : currentValueError.size) !== valueErrors.length || valueErrors.filter(function (v, i) {\n return v != currentValueError.get(i);\n }).length > 0;\n if (hasValueErrorChanged) {\n newValueError = new Immutable.List(valueErrors);\n }\n return {\n canReuseValue: canReuseValue,\n newValue: newValue,\n newValueSrc: newValueSrc,\n newValueType: newValueType,\n operatorCardinality: operatorCardinality,\n fixedField: newField,\n newValueError: newValueError,\n newFieldError: newFieldError,\n validationErrors: validationErrors\n };\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { isObject } from \"./stuff\";\nexport var toListValue = function toListValue(v, title) {\n if (v == null || v == \"\") {\n return undefined;\n } else if (isObject(v)) {\n return _objectSpread(_objectSpread({}, v), {}, {\n title: v.title || v.value // fallback to value\n });\n } else {\n return {\n value: v,\n title: title !== undefined ? title : \"\" + v\n };\n }\n};\nexport var makeCustomListValue = function makeCustomListValue(v) {\n var lv = toListValue(v);\n if (isObject(lv)) {\n return _objectSpread(_objectSpread({}, toListValue(v)), {}, {\n isCustom: true\n });\n } else {\n // only if undefined\n return lv;\n }\n};\n\n// convert {<value>: <title>, ..} or [value, ..] to normal [{value, title}, ..]\nexport var listValuesToArray = function listValuesToArray(listValuesObj) {\n if (Array.isArray(listValuesObj)) return listValuesObj.map(function (v) {\n return toListValue(v);\n });\n if (!isObject(listValuesObj)) return listValuesObj;\n var listValuesArr = [];\n for (var v in listValuesObj) {\n var title = listValuesObj[v];\n listValuesArr.push(toListValue(v, title));\n }\n return listValuesArr;\n};\n\n// listValues can be {<value>: <title>, ..} or [{value, title}, ..] or [value, ..]\n// todo: same as getListValue() (but args are switched)\nexport var getItemInListValues = function getItemInListValues(listValues, value) {\n if (Array.isArray(listValues)) {\n var values = listValues.map(function (v) {\n return toListValue(v);\n });\n return values.find(function (v) {\n return \"\" + v.value === \"\" + value;\n });\n } else {\n return listValues[value] !== undefined ? toListValue(value, listValues[value]) : undefined;\n }\n};\nexport var getTitleInListValues = function getTitleInListValues(listValues, value) {\n if (listValues == undefined) return value;\n var it = getItemInListValues(listValues, value);\n return it !== undefined ? it.title : value;\n};\nexport var getValueInListValues = function getValueInListValues(listValues, value) {\n if (listValues == undefined) return value;\n var it = getItemInListValues(listValues, value);\n return it !== undefined ? it.value : value;\n};\nexport var mapListValues = function mapListValues(listValues, mapFn) {\n var ret = [];\n if (Array.isArray(listValues)) {\n var _iterator = _createForOfIteratorHelper(listValues),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var v = _step.value;\n var lv = mapFn(toListValue(v));\n if (lv != null) ret.push(lv);\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n } else {\n for (var value in listValues) {\n var _lv = mapFn(toListValue(value, listValues[value]));\n if (_lv != null) ret.push(_lv);\n }\n }\n return ret;\n};\nexport var searchListValue = function searchListValue(search, listValues) {\n return mapListValues(listValues, function (lv) {\n return \"\".concat(lv.value).indexOf(search) != -1 || lv.title.indexOf(search) != -1 ? lv : null;\n }).filter(function (v) {\n return v !== null;\n }).shift();\n};\nexport var getListValue = function getListValue(selectedValue, listValues) {\n return mapListValues(listValues, function (lv) {\n return \"\" + lv.value === \"\" + selectedValue ? lv : null;\n }).filter(function (v) {\n return v !== null;\n }).shift();\n};","import _typeof from \"@babel/runtime/helpers/typeof\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport omit from \"lodash/omit\";\nimport Immutable from \"immutable\";\nimport { getFieldConfig, getOperatorConfig, getFieldWidgetConfig, getFuncConfig, getFieldSrc, getWidgetForFieldOp, getOperatorsForField } from \"./configUtils\";\nimport { extendConfig } from \"./configExtend\";\nimport { whatRulePropertiesAreCompleted, setFuncDefaultArg } from \"./ruleUtils\";\nimport { getNewValueForFieldOp } from \"./getNewValueForFieldOp\";\nimport { getOpCardinality, deepEqual, isTypeOf, typeOf } from \"./stuff\";\nimport { getItemInListValues } from \"./listValues\";\nimport { defaultOperatorOptions } from \"./defaultUtils\";\nimport { fixPathsInTree, getItemByPath, getFlatTree } from \"./treeUtils\";\nimport { queryString } from \"../export/queryString\";\nimport * as constants from \"../i18n/validation/constains\";\nimport { translateValidation } from \"../i18n\";\nexport { translateValidation };\n\n// tip: If showErrorMessage is false, this function will always return true\nexport var isValidTree = function isValidTree(tree, config) {\n return getTreeBadFields(tree, config).length === 0;\n};\n\n// tip: If showErrorMessage is false, this function will always return []\n// tip: If LHS is func, func key will be used to put in array of bad fields (naive)\nexport var getTreeBadFields = function getTreeBadFields(tree, config) {\n var showErrorMessage = config.settings.showErrorMessage;\n var badFields = [];\n function _processNode(item, path, lev) {\n var _field$get, _field$get2;\n var id = item.get(\"id\");\n var children = item.get(\"children1\");\n var valueError = item.getIn([\"properties\", \"valueError\"]);\n var fieldError = item.getIn([\"properties\", \"fieldError\"]);\n var field = item.getIn([\"properties\", \"field\"]);\n var fieldStr = (_field$get = field === null || field === void 0 || (_field$get2 = field.get) === null || _field$get2 === void 0 ? void 0 : _field$get2.call(field, \"func\")) !== null && _field$get !== void 0 ? _field$get : field;\n var hasValueError = (valueError === null || valueError === void 0 ? void 0 : valueError.size) > 0 && valueError.filter(function (v) {\n return v != null;\n }).size > 0;\n var isBad = hasValueError || !!fieldError;\n if (isBad && showErrorMessage) {\n // for showErrorMessage=false valueError/fieldError is used to hold last error, but actual value is always valid\n badFields.push(fieldStr);\n }\n if (children) {\n children.map(function (child, _childId) {\n if (child) {\n _processNode(child, path.concat(id), lev + 1);\n }\n });\n }\n }\n if (tree) _processNode(tree, [], 0);\n return Array.from(new Set(badFields));\n};\n\n// @deprecated\nexport var checkTree = function checkTree(tree, config) {\n var extendedConfig = extendConfig(config, undefined, true);\n var options = {\n removeEmptyGroups: config.settings.removeEmptyGroupsOnLoad,\n removeIncompleteRules: config.settings.removeIncompleteRulesOnLoad,\n removeEmptyRules: config.settings.removeEmptyRulesOnLoad,\n forceFix: false\n };\n var _validateTree2 = _validateTree(tree, null, extendedConfig, extendedConfig, options),\n fixedTree = _validateTree2.fixedTree,\n allErrors = _validateTree2.allErrors,\n isSanitized = _validateTree2.isSanitized;\n if (isSanitized && allErrors.length) {\n console.warn(\"Tree check errors: \", allErrors);\n }\n return fixedTree;\n};\n\n/**\n * @param {Immutable.Map} tree\n * @param {SanitizeOptions} options\n * @returns {ValidationItemErrors[]}\n*/\nexport var validateTree = function validateTree(tree, config) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var extendedConfig = extendConfig(config, undefined, true);\n var finalOptions = _objectSpread(_objectSpread({}, options), {}, {\n // disbale sanitize options, just validate\n removeEmptyGroups: false,\n removeEmptyRules: false,\n removeIncompleteRules: false,\n forceFix: false\n });\n var _validateTree3 = _validateTree(tree, null, extendedConfig, extendedConfig, finalOptions),\n allErrors = _validateTree3.allErrors;\n return allErrors;\n};\n\n/**\n * @param {Immutable.Map} tree\n * @param {SanitizeOptions} options\n * @returns {{\n * fixedTree: Immutable.Map, \n * fixedErrors: ValidationItemErrors[],\n * nonFixedErrors: ValidationItemErrors[],\n * allErrors: ValidationItemErrors[],\n * }}\n */\nexport var sanitizeTree = function sanitizeTree(tree, config) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var extendedConfig = extendConfig(config, undefined, true);\n var finalOptions = _objectSpread({\n // defaults\n removeEmptyGroups: true,\n removeEmptyRules: true,\n removeIncompleteRules: true,\n forceFix: false\n }, options);\n var _validateTree4 = _validateTree(tree, null, extendedConfig, extendedConfig, finalOptions),\n fixedTree = _validateTree4.fixedTree,\n fixedErrors = _validateTree4.fixedErrors,\n nonFixedErrors = _validateTree4.nonFixedErrors,\n allErrors = _validateTree4.allErrors;\n return {\n fixedTree: fixedTree,\n fixedErrors: fixedErrors,\n nonFixedErrors: nonFixedErrors,\n allErrors: allErrors\n };\n};\n\n// tip: Should be used only internally in createValidationMemo()\nexport var validateAndFixTree = function validateAndFixTree(newTree, _oldTree, newConfig, oldConfig, removeEmptyGroups, removeEmptyRules, removeIncompleteRules) {\n if (removeEmptyGroups === undefined) {\n removeEmptyGroups = newConfig.settings.removeEmptyGroupsOnLoad;\n }\n if (removeEmptyRules === undefined) {\n removeEmptyRules = newConfig.settings.removeEmptyRulesOnLoad;\n }\n if (removeIncompleteRules === undefined) {\n removeIncompleteRules = newConfig.settings.removeIncompleteRulesOnLoad;\n }\n var options = {\n // sanitize options\n removeEmptyGroups: removeEmptyGroups,\n removeEmptyRules: removeEmptyRules,\n removeIncompleteRules: removeIncompleteRules,\n forceFix: false\n };\n var _validateTree5 = _validateTree(newTree, _oldTree, newConfig, oldConfig, options),\n fixedTree = _validateTree5.fixedTree,\n allErrors = _validateTree5.allErrors,\n fixedErrors = _validateTree5.fixedErrors,\n nonFixedErrors = _validateTree5.nonFixedErrors,\n isSanitized = _validateTree5.isSanitized;\n if (isSanitized && fixedErrors.length) {\n console.warn(\"Fixed tree errors: \", fixedErrors);\n }\n // if (nonFixedErrors.length) {\n // console.info(\"Tree validation errors: \", nonFixedErrors);\n // }\n fixedTree = fixPathsInTree(fixedTree);\n return fixedTree;\n};\n\n/**\n * @param {Immutable.Map} tree\n * @param {SanitizeOptions} options\n * @typedef {{\n * removeEmptyGroups?: boolean,\n * removeEmptyRules?: boolean,\n * removeIncompleteRules?: boolean,\n * forceFix?: boolean,\n * translateErrors?: boolean,\n * includeStringifiedItems?: boolean,\n * stringifyFixedItems?: boolean,\n * stringifyItemsUserFriendly?: boolean,\n * includeItemsPositions?: boolean,\n * }} SanitizeOptions\n * @typedef {{\n * path: string[],\n * errors: {\n * key: string, args?: object | null, str?: string,\n * side?: \"lhs\"|\"rhs\"|\"op\", delta?: number, fixed?: boolean, fixedTo?: any, fixedFrom?: any,\n * }[],\n * itemStr?: string,\n * itemPosition?: {\n * caseNo: number | null, globalNoByType: number, indexPath: number[], globalLeafNo?: number, globalGroupNo?: number,\n * isDeleted: boolean, index: number, type: \"rule\"|\"group\"|\"rule_group\"\n * },\n * itemPositionStr?: string,\n * }} ValidationItemErrors\n * @returns {{\n * fixedTree: Immutable.Map, \n * allErrors: ValidationItemErrors[],\n * fixedErrors: ValidationItemErrors[],\n * nonFixedErrors: ValidationItemErrors[],\n * isSanitized: boolean\n * }}\n */\nexport var _validateTree = function _validateTree(tree, _oldTree, config, oldConfig, options) {\n if (!tree) {\n return {\n fixedTree: tree,\n allErrors: [],\n fixedErrors: [],\n nonFixedErrors: [],\n isSanitized: false\n };\n }\n var _ref = options || {},\n removeEmptyGroups = _ref.removeEmptyGroups,\n removeEmptyRules = _ref.removeEmptyRules,\n removeIncompleteRules = _ref.removeIncompleteRules,\n forceFix = _ref.forceFix,\n _ref$translateErrors = _ref.translateErrors,\n translateErrors = _ref$translateErrors === void 0 ? true : _ref$translateErrors,\n _ref$includeStringifi = _ref.includeStringifiedItems,\n includeStringifiedItems = _ref$includeStringifi === void 0 ? true : _ref$includeStringifi,\n _ref$stringifyFixedIt = _ref.stringifyFixedItems,\n stringifyFixedItems = _ref$stringifyFixedIt === void 0 ? false : _ref$stringifyFixedIt,\n _ref$stringifyItemsUs = _ref.stringifyItemsUserFriendly,\n stringifyItemsUserFriendly = _ref$stringifyItemsUs === void 0 ? true : _ref$stringifyItemsUs,\n _ref$includeItemsPosi = _ref.includeItemsPositions,\n includeItemsPositions = _ref$includeItemsPosi === void 0 ? true : _ref$includeItemsPosi;\n var c = {\n config: config,\n oldConfig: oldConfig,\n removeEmptyGroups: removeEmptyGroups,\n removeEmptyRules: removeEmptyRules,\n removeIncompleteRules: removeIncompleteRules,\n forceFix: forceFix\n };\n var meta = {\n errors: {}\n };\n var fixedTree = validateItem(tree, [], null, meta, c);\n var isSanitized = meta.sanitized;\n\n // build allErrors\n var allErrors = [];\n var flatItems, oldFlatItems;\n if (includeItemsPositions) {\n flatItems = getFlatTree(fixedTree, config).items;\n }\n for (var id in meta.errors) {\n var _meta$errors$id = meta.errors[id],\n path = _meta$errors$id.path,\n errors = _meta$errors$id.errors;\n if (translateErrors) {\n errors = errors.map(function (e) {\n return _objectSpread(_objectSpread({}, e), {}, {\n str: translateValidation(e)\n });\n });\n }\n var errorItem = {\n path: path,\n errors: errors\n };\n if (includeStringifiedItems) {\n var item = getItemByPath(stringifyFixedItems ? fixedTree : tree, path);\n var isRoot = path.length === 1;\n if (!isRoot && item.get(\"type\") !== \"group\") {\n var isDebugMode = true;\n var isForDisplay = stringifyItemsUserFriendly;\n var itemStr = queryString(item, config, isForDisplay, isDebugMode);\n errorItem.itemStr = itemStr;\n }\n }\n if (includeItemsPositions) {\n var flatItem = flatItems[id];\n var isDeleted = !flatItem;\n if (isDeleted) {\n // get positions from old tree\n if (!oldFlatItems) {\n oldFlatItems = getFlatTree(tree, config).items;\n }\n flatItem = oldFlatItems[id];\n }\n if (flatItem) {\n // build position object\n var itemPosition = _objectSpread(_objectSpread({}, flatItem.position), {}, {\n index: flatItem.index,\n type: flatItem.type,\n isDeleted: isDeleted\n });\n errorItem.itemPosition = itemPosition;\n // build position string\n var trKey = !flatItem.index ? constants.ITEM_POSITION_ROOT : constants.ITEM_POSITION + \"__\" + flatItem.type + (isDeleted ? \"__deleted\" : \"\");\n var trArgs = _objectSpread({}, itemPosition);\n if (stringifyItemsUserFriendly) {\n var _itemPosition$indexPa;\n // convert indexes from 0-based to 1-based (user friendly)\n for (var _i = 0, _arr = [\"caseNo\", \"globalLeafNo\", \"globalGroupNo\", \"globalNoByType\"]; _i < _arr.length; _i++) {\n var k = _arr[_i];\n if (trArgs[k] != undefined) {\n trArgs[k] = trArgs[k] + 1;\n }\n }\n trArgs.indexPath = (_itemPosition$indexPa = itemPosition.indexPath) === null || _itemPosition$indexPa === void 0 ? void 0 : _itemPosition$indexPa.map(function (ind) {\n return ind + 1;\n });\n }\n errorItem.itemPositionStr = translateValidation(trKey, trArgs);\n if (flatItem.index) {\n // don't extend for root\n if (flatItem.caseId && flatItem.type !== \"case_group\") {\n errorItem.itemPositionStr = translateValidation(constants.ITEM_POSITION_IN_CASE, _objectSpread(_objectSpread({}, trArgs), {}, {\n str: errorItem.itemPositionStr\n }));\n }\n if (flatItem.type !== \"case_group\") {\n errorItem.itemPositionStr = translateValidation(constants.ITEM_POSITION_WITH_INDEX_PATH, _objectSpread(_objectSpread({}, trArgs), {}, {\n str: errorItem.itemPositionStr\n }));\n }\n }\n }\n }\n allErrors.push(errorItem);\n }\n\n // split allErrors to fixedErrors and nonFixedErrors\n var fixedErrors = [];\n var nonFixedErrors = [];\n for (var _i2 = 0, _allErrors = allErrors; _i2 < _allErrors.length; _i2++) {\n var itemErrors = _allErrors[_i2];\n var fixedItemErrors = itemErrors.errors.filter(function (e) {\n return !!e.fixed;\n });\n var nonFixedItemErrors = itemErrors.errors.filter(function (e) {\n return !e.fixed && e.key !== \"EMPTY_QUERY\";\n });\n if (fixedItemErrors.length) {\n fixedErrors.push(_objectSpread(_objectSpread({}, itemErrors), {}, {\n errors: fixedItemErrors\n }));\n }\n if (nonFixedItemErrors.length) {\n nonFixedErrors.push(_objectSpread(_objectSpread({}, itemErrors), {}, {\n errors: nonFixedItemErrors\n }));\n }\n }\n return {\n fixedTree: fixedTree,\n allErrors: allErrors,\n fixedErrors: fixedErrors,\n nonFixedErrors: nonFixedErrors,\n isSanitized: isSanitized\n };\n};\nfunction _addError(meta, item, path, err) {\n var id = item.get(\"id\");\n if (!meta.errors[id]) {\n meta.errors[id] = {\n path: [].concat(_toConsumableArray(path), [id]),\n errors: []\n };\n }\n meta.errors[id].errors.push(err);\n}\nfunction _setErrorsAsFixed(meta, item) {\n var id = item.get(\"id\");\n if (meta.errors[id]) {\n meta.errors[id].errors.map(function (e) {\n e.fixed = true;\n });\n }\n}\nfunction validateItem(item, path, itemId, meta, c) {\n var type = item === null || item === void 0 ? void 0 : item.get(\"type\");\n if (type === \"group\" || type === \"rule_group\" || type == \"case_group\" || type == \"switch_group\") {\n return validateGroup(item, path, itemId, meta, c);\n } else if (type === \"rule\") {\n return validateRule(item, path, itemId, meta, c);\n } else {\n return item;\n }\n}\nfunction validateGroup(item, path, itemId, meta, c) {\n var _properties$get, _config$operators$ope, _config$operators$ope2, _children, _children2, _children3;\n var removeEmptyGroups = c.removeEmptyGroups,\n removeIncompleteRules = c.removeIncompleteRules,\n forceFix = c.forceFix,\n config = c.config;\n var showErrorMessage = config.settings.showErrorMessage;\n var canFix = !showErrorMessage || forceFix;\n var id = item.get(\"id\");\n var children = item.get(\"children1\");\n var isRoot = !path.length;\n var oldChildren = children;\n var type = item.get(\"type\");\n var properties = item.get(\"properties\");\n var field = properties === null || properties === void 0 ? void 0 : properties.get(\"field\");\n var mode = properties === null || properties === void 0 ? void 0 : properties.get(\"mode\");\n var operator = properties === null || properties === void 0 || (_properties$get = properties.get) === null || _properties$get === void 0 ? void 0 : _properties$get.call(properties, \"operator\");\n var isGroupExt = type === \"rule_group\" && mode === \"array\";\n var isCase = type === \"case_group\";\n var isDefaultCase = isCase && children == undefined;\n var cardinality = operator ? (_config$operators$ope = (_config$operators$ope2 = config.operators[operator]) === null || _config$operators$ope2 === void 0 ? void 0 : _config$operators$ope2.cardinality) !== null && _config$operators$ope !== void 0 ? _config$operators$ope : 1 : undefined;\n // tip: for group operators some/none/all children ARE required, for group operator count children are NOT required\n // tip: default case should contain only value\n var childrenAreRequired = isCase ? !isDefaultCase : isGroupExt ? cardinality == 0 : removeEmptyGroups;\n var canHaveValue = isGroupExt || isCase;\n if (!id && itemId) {\n id = itemId;\n item = item.set(\"id\", id);\n meta.sanitized = true;\n }\n if (canHaveValue) {\n item = validateRule(item, path, itemId, meta, c);\n }\n\n //validate children\n var submeta = {\n errors: {}\n };\n children = (_children = children) === null || _children === void 0 ? void 0 : _children.map(function (currentChild, childId) {\n return validateItem(currentChild, path.concat(id), childId, submeta, c);\n });\n var nonEmptyChildren = (_children2 = children) === null || _children2 === void 0 ? void 0 : _children2.filter(function (currentChild) {\n return currentChild != undefined;\n });\n if (removeEmptyGroups) {\n children = nonEmptyChildren;\n }\n var sanitized = submeta.sanitized || (oldChildren === null || oldChildren === void 0 ? void 0 : oldChildren.size) != ((_children3 = children) === null || _children3 === void 0 ? void 0 : _children3.size);\n var isEmptyChildren = !(nonEmptyChildren !== null && nonEmptyChildren !== void 0 && nonEmptyChildren.size);\n var canDrop = removeEmptyGroups && !isRoot;\n if (isGroupExt && field) {\n // to remove rule-group like \"SOME cars\" (with SOME/ALL/NONE, but without filters), we need to rely on removeIncompleteRules\n canDrop = removeIncompleteRules;\n }\n if (isEmptyChildren && childrenAreRequired) {\n _addError(meta, item, path, {\n key: isRoot ? constants.EMPTY_QUERY : isCase ? constants.EMPTY_CASE : isGroupExt ? constants.EMPTY_RULE_GROUP : constants.EMPTY_GROUP,\n args: {\n field: field\n },\n fixed: canDrop\n });\n if (canDrop) {\n _setErrorsAsFixed(meta, item);\n item = undefined;\n }\n }\n if (sanitized) meta.sanitized = true;\n if (sanitized && item) item = item.set(\"children1\", children);\n meta.errors = _objectSpread(_objectSpread({}, meta.errors), (submeta === null || submeta === void 0 ? void 0 : submeta.errors) || {});\n return item;\n}\n\n/**\n * @param {Immutable.Map} item\n * @returns {Immutable.Map}\n */\nfunction validateRule(item, path, itemId, meta, c) {\n var removeIncompleteRules = c.removeIncompleteRules,\n removeEmptyRules = c.removeEmptyRules,\n forceFix = c.forceFix,\n config = c.config,\n oldConfig = c.oldConfig;\n var showErrorMessage = config.settings.showErrorMessage;\n var canFix = !showErrorMessage || forceFix;\n var origItem = item;\n var id = item.get(\"id\");\n var type = item.get(\"type\");\n var isCase = type === \"case_group\";\n var properties = item.get(\"properties\");\n if (!properties) {\n if (isCase) {\n properties = new Immutable.Map();\n } else {\n var err = {\n key: constants.INCOMPLETE_RULE,\n args: {},\n fixed: removeIncompleteRules || removeEmptyRules\n };\n _addError(meta, item, path, err);\n return undefined;\n }\n }\n var field = properties.get(\"field\") || null;\n if (isCase) {\n field = \"!case_value\";\n }\n var fieldSrc = properties.get(\"fieldSrc\") || null;\n var operator = properties.get(\"operator\") || null;\n var operatorOptions = properties.get(\"operatorOptions\");\n var valueSrc = properties.get(\"valueSrc\");\n var value = properties.get(\"value\");\n var valueError = properties.get(\"valueError\");\n var fieldError = properties.get(\"fieldError\");\n var serializeRule = function serializeRule() {\n var _field, _field$toJS;\n return {\n field: ((_field = field) === null || _field === void 0 || (_field$toJS = _field.toJS) === null || _field$toJS === void 0 ? void 0 : _field$toJS.call(_field)) || field,\n fieldSrc: fieldSrc,\n operator: operator,\n operatorOptions: operatorOptions ? operatorOptions.toJS() : {},\n valueSrc: valueSrc ? valueSrc.toJS() : null,\n value: value ? value.toJS() : null,\n valueError: valueError ? valueError.toJS() : null,\n fieldError: fieldError ? fieldError : null\n };\n };\n var oldSerialized = serializeRule();\n //const _wasValid = field && operator && value && !value.includes(undefined);\n\n if (!id && itemId) {\n id = itemId;\n item = item.set(\"id\", id);\n meta.sanitized = true;\n }\n\n //validate field\n var fieldDefinition = field ? getFieldConfig(config, field) : null;\n if (field && !fieldDefinition) {\n _addError(meta, item, path, {\n key: constants.NO_CONFIG_FOR_FIELD,\n args: {\n field: field\n },\n side: \"lhs\",\n fixed: removeIncompleteRules || removeEmptyRules\n });\n field = null;\n }\n if (field == null && !isCase) {\n properties = [\"operator\", \"operatorOptions\", \"valueSrc\", \"value\", \"valueError\", \"fieldError\", \"field\"].reduce(function (map, key) {\n return map[\"delete\"](key);\n }, properties);\n operator = null;\n }\n if (!fieldSrc && field && !isCase) {\n fieldSrc = getFieldSrc(field);\n properties = properties.set(\"fieldSrc\", fieldSrc);\n }\n\n //validate operator\n // Backward compatibility: obsolete operator range_between\n if (operator === \"range_between\" || operator === \"range_not_between\") {\n operator = operator === \"range_between\" ? \"between\" : \"not_between\";\n // _addError(meta, item, path, {\n // type: \"fix\",\n // key: constants.FIXED_OPERATOR,\n // args: { from: properties.get(\"operator\"), to: operator, field }\n // });\n properties = properties.set(\"operator\", operator);\n }\n var operatorDefinition = operator ? getOperatorConfig(config, operator, field) : null;\n if (operator && !operatorDefinition) {\n _addError(meta, item, path, {\n key: constants.NO_CONFIG_FOR_OPERATOR,\n args: {\n operator: operator\n },\n side: \"op\",\n fixed: removeIncompleteRules || removeEmptyRules\n });\n operator = null;\n }\n var availOps = field ? getOperatorsForField(config, field) : [];\n if (field && !isCase) {\n if (!(availOps !== null && availOps !== void 0 && availOps.length)) {\n _addError(meta, item, path, {\n key: constants.UNSUPPORTED_FIELD_TYPE,\n args: {\n field: field\n },\n side: \"lhs\",\n fixed: removeIncompleteRules || removeEmptyRules\n });\n operator = null;\n } else if (operator && availOps.indexOf(operator) == -1) {\n if (operator === \"is_empty\" || operator === \"is_not_empty\") {\n // Backward compatibility: is_empty #494\n operator = operator === \"is_empty\" ? \"is_null\" : \"is_not_null\";\n // _addError(meta, item, path, {\n // type: \"fix\",\n // key: constants.FIXED_OPERATOR,\n // args: { from: properties.get(\"operator\"), to: operator, field }\n // });\n properties = properties.set(\"operator\", operator);\n } else {\n _addError(meta, item, path, {\n key: constants.UNSUPPORTED_OPERATOR_FOR_FIELD,\n args: {\n operator: operator,\n field: field\n },\n side: \"lhs\",\n fixed: removeIncompleteRules || removeEmptyRules\n });\n operator = null;\n }\n }\n }\n if (operator == null && !isCase) {\n // do not unset operator ?\n properties = [\"operatorOptions\", \"valueSrc\", \"value\", \"valueError\"].reduce(function (map, key) {\n return map[\"delete\"](key);\n }, properties);\n }\n\n //validate operator options\n operatorOptions = properties.get(\"operatorOptions\");\n //const _operatorCardinality = operator ? getOpCardinality(operatorDefinition) : null;\n if (!operator || operatorOptions && !operatorDefinition.options) {\n operatorOptions = null;\n properties = properties[\"delete\"](\"operatorOptions\");\n } else if (operator && !operatorOptions && operatorDefinition.options) {\n operatorOptions = defaultOperatorOptions(config, operator, field);\n properties = properties.set(\"operatorOptions\", operatorOptions);\n }\n\n //validate values\n valueSrc = properties.get(\"valueSrc\");\n value = properties.get(\"value\");\n var isEndValue = true;\n var _getNewValueForFieldO = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, oldConfig, properties, field, operator, null, canFix, isEndValue),\n newValue = _getNewValueForFieldO.newValue,\n newValueSrc = _getNewValueForFieldO.newValueSrc,\n newValueError = _getNewValueForFieldO.newValueError,\n validationErrors = _getNewValueForFieldO.validationErrors,\n newFieldError = _getNewValueForFieldO.newFieldError,\n fixedField = _getNewValueForFieldO.fixedField;\n value = newValue;\n valueSrc = newValueSrc;\n valueError = newValueError;\n fieldError = newFieldError;\n field = fixedField;\n properties = properties.set(\"field\", field);\n properties = properties.set(\"value\", value);\n properties = properties.set(\"valueSrc\", valueSrc);\n if (showErrorMessage) {\n properties = properties.set(\"valueError\", valueError).set(\"fieldError\", fieldError);\n } else {\n properties = properties[\"delete\"](\"valueError\")[\"delete\"](\"fieldError\");\n }\n var newSerialized = serializeRule();\n var hasBeenSanitized = !deepEqual(oldSerialized, newSerialized);\n var compl = whatRulePropertiesAreCompleted(properties.toObject(), config);\n var isCompleted = isCase ? compl.parts.value : compl.score >= 3;\n if (hasBeenSanitized) {\n meta.sanitized = true;\n item = item.set(\"properties\", properties);\n }\n validationErrors === null || validationErrors === void 0 || validationErrors.map(function (e) {\n return _addError(meta, item, path, e);\n });\n if (!isCompleted) {\n if (isCase) {\n // todo\n } else {\n var shoudlRemoveRule = !compl.score ? removeEmptyRules : removeIncompleteRules;\n // if (shoudlRemoveRule && showErrorMessage) {\n // // try to be not so rude about removing incomplete rule with functions\n // const complLite = whatRulePropertiesAreCompleted(properties.toObject(), config, true);\n // const isCompletedLite = complLite.score >= 3;\n // if (isCompletedLite) {\n // shoudlRemoveRule = false;\n // }\n // }\n var incError = {\n key: constants.INCOMPLETE_RULE,\n args: {}\n };\n if (!compl.parts.field) {\n incError.key = constants.INCOMPLETE_LHS;\n incError.side = \"lhs\";\n } else if (!compl.parts.value) {\n var _newSerialized$valueS, _newSerialized$valueS2, _oldSerialized$valueS, _newSerialized$value;\n incError.key = constants.INCOMPLETE_RHS;\n incError.side = \"rhs\";\n if ((_newSerialized$valueS = newSerialized.valueSrc) !== null && _newSerialized$valueS !== void 0 && _newSerialized$valueS[0] && ((_newSerialized$valueS2 = newSerialized.valueSrc) === null || _newSerialized$valueS2 === void 0 ? void 0 : _newSerialized$valueS2[0]) != ((_oldSerialized$valueS = oldSerialized.valueSrc) === null || _oldSerialized$valueS === void 0 ? void 0 : _oldSerialized$valueS[0]) && ((_newSerialized$value = newSerialized.value) === null || _newSerialized$value === void 0 ? void 0 : _newSerialized$value[0]) != undefined) {\n // eg. operator `starts_with` supports only valueSrc \"value\"\n incError.key = constants.INVALID_VALUE_SRC;\n incError.args = {\n valueSrcs: newSerialized.valueSrc\n };\n }\n }\n incError.fixed = shoudlRemoveRule;\n _addError(meta, item, path, incError);\n if (shoudlRemoveRule) {\n _setErrorsAsFixed(meta, item);\n item = undefined;\n }\n }\n }\n return item;\n}\n\n/**\n * \n * @param {bool} canFix true is useful for func values to remove bad args\n * @param {bool} isEndValue false if value is in process of editing by user\n * @return {array} [fixedValue, allErrors] - if `allErrors` is empty and `canFix` == true, `fixedValue` can differ from value if was fixed.\n * `allErrors` is an array of {key, args, fixed, fixedFrom, fixedTo}\n * If `args` === null, `key` should not be translated\n */\nexport var validateValue = function validateValue(config, leftField, field, operator, value, valueType, valueSrc, asyncListValues) {\n var canFix = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var isEndValue = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;\n var canDropArgs = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : false;\n var allErrors = [];\n var fixedValue = value;\n if (value != null) {\n var _allErrors2, _allErrors3, _allErrors4, _allErrors5;\n if (valueSrc === \"field\") {\n var _validateFieldValue = validateFieldValue(leftField, field, value, valueSrc, valueType, asyncListValues, config, operator, canFix, isEndValue);\n var _validateFieldValue2 = _slicedToArray(_validateFieldValue, 2);\n fixedValue = _validateFieldValue2[0];\n allErrors = _validateFieldValue2[1];\n } else if (valueSrc === \"func\") {\n var _validateFuncValue = validateFuncValue(leftField, field, value, valueSrc, valueType, asyncListValues, config, operator, canFix, isEndValue, canDropArgs);\n var _validateFuncValue2 = _slicedToArray(_validateFuncValue, 2);\n fixedValue = _validateFuncValue2[0];\n allErrors = _validateFuncValue2[1];\n } else if (valueSrc === \"value\" || !valueSrc) {\n var _validateNormalValue = validateNormalValue(field, value, valueSrc, valueType, asyncListValues, config, operator, canFix, isEndValue);\n var _validateNormalValue2 = _slicedToArray(_validateNormalValue, 2);\n fixedValue = _validateNormalValue2[0];\n allErrors = _validateNormalValue2[1];\n }\n var fixedAllErrors = !((_allErrors2 = allErrors) !== null && _allErrors2 !== void 0 && _allErrors2.find(function (e) {\n return !e.fixed;\n }));\n var shouldCallValidateFn = !!field\n // `validateValue` should not be available for valueSrc === \"func\" or \"field\"\n && ![\"field\", \"func\"].includes(valueSrc)\n // eg. if value was > max, and fixed to max, but max value can not satisfy validateValue() in config\n && (!((_allErrors3 = allErrors) !== null && _allErrors3 !== void 0 && _allErrors3.length) || fixedAllErrors);\n if (shouldCallValidateFn) {\n //todo: why not just take fieldSettings from fieldConfig, why need to use getFieldWidgetConfig() ??\n // const fieldConfig = getFieldConfig(config, field);\n // const fieldSettings = fieldConfig?.fieldSettings;\n var w = getWidgetForFieldOp(config, field, operator, valueSrc);\n var operatorDefinition = operator ? getOperatorConfig(config, operator, field) : null;\n var fieldWidgetDefinition = getFieldWidgetConfig(config, field, operator, w, valueSrc, {\n forExport: true\n });\n var rightFieldDefinition = valueSrc === \"field\" ? getFieldConfig(config, value) : null;\n var fieldSettings = fieldWidgetDefinition; // widget definition merged with fieldSettings\n\n var fn = fieldWidgetDefinition.validateValue;\n if (typeof fn === \"function\") {\n var args = [fixedValue, fieldSettings, operator, operatorDefinition];\n if (valueSrc === \"field\") args.push(rightFieldDefinition);\n var validResult = fn.call.apply(fn, [config.ctx].concat(args));\n if (_typeof(validResult) === \"object\" && validResult !== null && !Array.isArray(validResult)) {\n var _validResult$error;\n var newError;\n if ((_validResult$error = validResult.error) !== null && _validResult$error !== void 0 && _validResult$error.key) {\n newError = _objectSpread({}, validResult.error);\n } else {\n // Note: `null` means it's not translated string!\n newError = {\n key: validResult.error,\n args: null\n };\n }\n if (validResult.fixedValue !== undefined && canFix) {\n newError.fixed = true;\n newError.fixedFrom = fixedValue;\n newError.fixedTo = validResult.fixedValue;\n fixedValue = validResult.fixedValue;\n }\n allErrors.push(newError);\n } else if (typeof validResult === \"boolean\") {\n if (validResult == false) {\n allErrors.push({\n key: constants.INVALID_VALUE,\n args: {}\n });\n }\n } else if (typeof validResult === \"string\") {\n allErrors.push({\n key: validResult,\n args: null\n });\n }\n }\n }\n\n // if can't fix value, use defaultValue\n fixedAllErrors = !((_allErrors4 = allErrors) !== null && _allErrors4 !== void 0 && _allErrors4.find(function (e) {\n return !e.fixed;\n }));\n if ((_allErrors5 = allErrors) !== null && _allErrors5 !== void 0 && _allErrors5.length && !fixedAllErrors && canFix) {\n var fieldConfig = getFieldConfig(config, field);\n var _fieldSettings = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.fieldSettings;\n var defaultValue = _fieldSettings === null || _fieldSettings === void 0 ? void 0 : _fieldSettings.defaultValue;\n if (defaultValue !== undefined) {\n var lastError = allErrors[allErrors.length - 1];\n lastError.fixed = true;\n lastError.fixedFrom = fixedValue;\n lastError.fixedTo = defaultValue;\n fixedValue = defaultValue;\n // mark all errors as fixed\n allErrors.map(function (e) {\n e.fixed = true;\n });\n }\n }\n }\n return [fixedValue, allErrors];\n};\n\n/**\n * \n */\nvar validateValueInList = function validateValueInList(value, listValues, canFix, isEndValue, removeInvalidMultiSelectValuesOnLoad) {\n var values = Immutable.List.isList(value) ? value.toJS() : value instanceof Array ? _toConsumableArray(value) : undefined;\n var fixedValue = value;\n var allErrors = [];\n if (values) {\n var _values$reduce = values.reduce(function (_ref2, val) {\n var _ref3 = _slicedToArray(_ref2, 2),\n goodVals = _ref3[0],\n badVals = _ref3[1];\n var vv = getItemInListValues(listValues, val);\n if (vv == undefined) {\n return [goodVals, [].concat(_toConsumableArray(badVals), [val])];\n } else {\n return [[].concat(_toConsumableArray(goodVals), [vv.value]), badVals];\n }\n }, [[], []]),\n _values$reduce2 = _slicedToArray(_values$reduce, 2),\n goodValues = _values$reduce2[0],\n badValues = _values$reduce2[1];\n var needFix = badValues.length > 0;\n // always remove bad values at tree validation as user can't unselect them (except AntDesign widget)\n canFix = canFix || removeInvalidMultiSelectValuesOnLoad === true;\n fixedValue = canFix && needFix ? goodValues : value;\n if (badValues.length) {\n var fixed = canFix && needFix;\n allErrors.push({\n key: constants.BAD_MULTISELECT_VALUES,\n args: {\n badValues: badValues,\n count: badValues.length\n },\n fixed: fixed,\n fixedFrom: fixed ? values : undefined,\n fixedTo: fixed ? fixedValue : undefined\n });\n }\n return [fixedValue, allErrors];\n } else {\n var vv = getItemInListValues(listValues, value);\n if (vv == undefined) {\n fixedValue = canFix ? null : value;\n allErrors.push({\n key: constants.BAD_SELECT_VALUE,\n args: {\n value: value\n },\n fixed: canFix,\n fixedFrom: canFix ? value : undefined,\n fixedTo: canFix ? fixedValue : undefined\n });\n } else {\n fixedValue = vv.value;\n }\n return [fixedValue, allErrors];\n }\n};\n\n/**\n * \n */\nvar validateNormalValue = function validateNormalValue(field, value, valueSrc, valueType, asyncListValues, config) {\n var operator = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var canFix = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;\n var isEndValue = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var allErrors = [];\n var fixedValue = value;\n if (field) {\n var fieldConfig = getFieldConfig(config, field);\n var w = getWidgetForFieldOp(config, field, operator, valueSrc);\n var wConfig = config.widgets[w];\n var wType = wConfig === null || wConfig === void 0 ? void 0 : wConfig.type;\n var jsType = wConfig === null || wConfig === void 0 ? void 0 : wConfig.jsType;\n var fieldSettings = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.fieldSettings;\n var listValues = (fieldSettings === null || fieldSettings === void 0 ? void 0 : fieldSettings.treeValues) || (fieldSettings === null || fieldSettings === void 0 ? void 0 : fieldSettings.listValues);\n var isAsyncListValues = !!(fieldSettings !== null && fieldSettings !== void 0 && fieldSettings.asyncFetch);\n // todo: for select/multiselect value can be string or number\n var canSkipTypeCheck = listValues || isAsyncListValues;\n\n // validate type\n if (valueType && wType && valueType != wType) {\n allErrors.push({\n key: constants.INCORRECT_VALUE_TYPE,\n args: {\n wType: wType,\n valueType: valueType\n }\n });\n return [value, allErrors];\n }\n if (jsType && !isTypeOf(value, jsType) && !canSkipTypeCheck) {\n allErrors.push({\n key: constants.INCORRECT_VALUE_JS_TYPE,\n args: {\n jsType: jsType,\n valueTypeof: typeOf(value)\n }\n });\n return [value, allErrors];\n }\n if (fieldSettings) {\n // validate against list of values\n var realListValues = asyncListValues || listValues;\n // tip: \"case_value\" is deprecated, don't apply validation based on listValues\n if (realListValues && !fieldSettings.allowCustomValues && w !== \"case_value\") {\n var _validateValueInList = validateValueInList(value, realListValues, canFix, isEndValue, config.settings.removeInvalidMultiSelectValuesOnLoad);\n var _validateValueInList2 = _slicedToArray(_validateValueInList, 2);\n fixedValue = _validateValueInList2[0];\n allErrors = _validateValueInList2[1];\n }\n // validate length\n if (fieldSettings.maxLength > 0 && value != null && String(value).length > fieldSettings.maxLength) {\n fixedValue = canFix ? String(value).substring(0, fieldSettings.maxLength) : value;\n allErrors.push({\n key: constants.VALUE_LENGTH_CONSTRAINT_FAIL,\n args: {\n value: value,\n length: String(value).length,\n fieldSettings: fieldSettings\n },\n fixed: canFix,\n fixedFrom: canFix ? value : undefined,\n fixedTo: canFix ? fixedValue : undefined\n });\n }\n // validate min/max\n var minMaxContext = fieldSettings.min != undefined && fieldSettings.max != undefined ? constants._CONTEXT_MIN_MAX : undefined;\n if (fieldSettings.min != null && value < fieldSettings.min) {\n fixedValue = canFix ? fieldSettings.min : value;\n allErrors.push({\n key: constants.VALUE_MIN_CONSTRAINT_FAIL,\n args: {\n value: value,\n fieldSettings: fieldSettings,\n context: minMaxContext\n },\n fixed: canFix,\n fixedFrom: canFix ? value : undefined,\n fixedTo: canFix ? fixedValue : undefined\n });\n }\n if (fieldSettings.max != null && value > fieldSettings.max) {\n fixedValue = canFix ? fieldSettings.max : value;\n allErrors.push({\n key: constants.VALUE_MAX_CONSTRAINT_FAIL,\n args: {\n value: value,\n fieldSettings: fieldSettings,\n context: minMaxContext\n },\n fixed: canFix,\n fixedFrom: canFix ? value : undefined,\n fixedTo: canFix ? fixedValue : undefined\n });\n }\n }\n }\n return [fixedValue, allErrors];\n};\n\n/**\n * \n */\nvar validateFieldValue = function validateFieldValue(leftField, field, value, _valueSrc, valueType, asyncListValues, config) {\n var operator = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;\n var canFix = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var isEndValue = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;\n var allErrors = [];\n var _config$settings = config.settings,\n fieldSeparator = _config$settings.fieldSeparator,\n canCompareFieldWithField = _config$settings.canCompareFieldWithField;\n var isFuncArg = _typeof(field) == \"object\" && (field === null || field === void 0 ? void 0 : field._isFuncArg);\n var leftFieldStr = Array.isArray(leftField) ? leftField.join(fieldSeparator) : leftField;\n var leftFieldConfig = getFieldConfig(config, leftField);\n var rightFieldStr = Array.isArray(value) ? value.join(fieldSeparator) : value;\n var rightFieldConfig = getFieldConfig(config, value);\n if (!rightFieldConfig) {\n allErrors.push({\n key: constants.NO_CONFIG_FOR_FIELD_VALUE,\n args: {\n field: rightFieldStr\n }\n });\n return [value, allErrors];\n }\n if (leftField && rightFieldStr === leftFieldStr && !isFuncArg) {\n allErrors.push({\n key: constants.CANT_COMPARE_FIELD_WITH_ITSELF,\n args: {\n field: leftFieldStr\n }\n });\n return [value, allErrors];\n }\n if (valueType && valueType != rightFieldConfig.type) {\n allErrors.push({\n key: constants.INCORRECT_FIELD_TYPE,\n args: {\n field: rightFieldStr,\n type: rightFieldConfig.type,\n expected: valueType\n }\n });\n return [value, allErrors];\n }\n if (leftField && !isFuncArg && canCompareFieldWithField) {\n var canUse = canCompareFieldWithField(leftFieldStr, leftFieldConfig, rightFieldStr, rightFieldConfig, operator);\n if (!canUse) {\n allErrors.push({\n key: constants.CANT_COMPARE_FIELD_WITH_FIELD,\n args: {\n leftField: leftFieldStr,\n rightField: rightFieldStr\n }\n });\n return [value, allErrors];\n }\n }\n return [value];\n};\n\n/**\n * @param {bool} canDropArgs true only if user sets new func key\n */\nvar validateFuncValue = function validateFuncValue(leftField, field, value, _valueSrc, valueType, asyncListValues, config) {\n var _value$get, _funcConfig$label;\n var operator = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;\n var canFix = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;\n var isEndValue = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;\n var canDropArgs = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : false;\n var fixedValue = value;\n var allErrors = [];\n if (!value) {\n // empty value\n return [value];\n }\n var funcKey = (_value$get = value.get) === null || _value$get === void 0 ? void 0 : _value$get.call(value, \"func\");\n if (!funcKey) {\n // it's not a function value\n return [value];\n }\n var fieldDef = getFieldConfig(config, field);\n if (fieldDef !== null && fieldDef !== void 0 && fieldDef.funcs && !fieldDef.funcs.includes(funcKey)) {\n allErrors.push({\n key: constants.UNSUPPORTED_FUNCTION_FOR_FIELD,\n args: {\n funcKey: funcKey,\n field: field\n }\n });\n return [value, allErrors];\n }\n var funcConfig = getFuncConfig(config, funcKey);\n if (!funcConfig) {\n allErrors.push({\n key: constants.NO_CONFIG_FOR_FUNCTION,\n args: {\n funcKey: funcKey\n }\n });\n return [value, allErrors];\n }\n var funcName = (_funcConfig$label = funcConfig.label) !== null && _funcConfig$label !== void 0 ? _funcConfig$label : funcKey;\n if (valueType && funcConfig.returnType != valueType) {\n allErrors.push({\n key: constants.INCORRECT_FUNCTION_RETURN_TYPE,\n args: {\n funcKey: funcKey,\n funcName: funcName,\n returnType: funcConfig.returnType,\n valueType: valueType\n }\n });\n return [value, allErrors];\n }\n //tip: Exception for canDropArgs (true only if changing func) - can fix/drop args to fit new func validations\n canFix = canFix || canDropArgs;\n for (var argKey in funcConfig.args) {\n var _argDef$label;\n var argConfig = funcConfig.args[argKey];\n var args = fixedValue.get(\"args\");\n var argVal = args ? args.get(argKey) : undefined;\n var argDef = getFieldConfig(config, argConfig);\n var argName = (_argDef$label = argDef === null || argDef === void 0 ? void 0 : argDef.label) !== null && _argDef$label !== void 0 ? _argDef$label : argKey;\n var argValue = argVal ? argVal.get(\"value\") : undefined;\n var argValueSrc = argVal ? argVal.get(\"valueSrc\") : undefined;\n if (argValue !== undefined) {\n var _validateValue = validateValue(config, leftField, argDef, operator, argValue, argConfig.type, argValueSrc, asyncListValues, canFix, isEndValue, canDropArgs),\n _validateValue2 = _slicedToArray(_validateValue, 2),\n fixedArgVal = _validateValue2[0],\n argErrors = _validateValue2[1];\n var isValid = !(argErrors !== null && argErrors !== void 0 && argErrors.length);\n var willFix = canFix && fixedArgVal !== argValue;\n //const willFixAllErrors = !isValid && willFix && !allErrors?.find(e => !e.fixed);\n //tip: reset to default ONLY if isEndValue==true\n var canDropOrReset = canFix && !isValid && !willFix && (isEndValue || canDropArgs);\n if (willFix) {\n fixedValue = fixedValue.setIn([\"args\", argKey, \"value\"], fixedArgVal);\n }\n if (canDropOrReset) {\n // reset to default\n fixedValue = fixedValue.deleteIn([\"args\", argKey]);\n fixedValue = setFuncDefaultArg(config, fixedValue, funcConfig, argKey);\n }\n if (!isValid) {\n var _ref4, _argErrors$find;\n var firstError = (_ref4 = (_argErrors$find = argErrors.find(function (e) {\n return !e.fixed && !e.ignore;\n })) !== null && _argErrors$find !== void 0 ? _argErrors$find : argErrors.find(function (e) {\n return !e.fixed;\n })) !== null && _ref4 !== void 0 ? _ref4 : argErrors[0];\n var fixed = willFix || canDropOrReset;\n var ignore = argErrors.filter(function (e) {\n return !e.ignore;\n }).length === 0;\n if (firstError) {\n var argValidationError = translateValidation(firstError);\n allErrors.push({\n key: constants.INVALID_FUNC_ARG_VALUE,\n args: {\n funcKey: funcKey,\n funcName: funcName,\n argKey: argKey,\n argName: argName,\n argValidationError: argValidationError,\n // more meta\n argErrors: argErrors\n },\n ignore: ignore,\n fixed: fixed,\n fixedFrom: fixed ? argValue : undefined,\n fixedTo: fixed ? willFix ? fixedArgVal : argConfig.defaultValue : undefined\n });\n }\n }\n } else if (!argConfig.isOptional && (isEndValue || canDropArgs)) {\n var canReset = canFix && argConfig.defaultValue !== undefined && (isEndValue || canDropArgs);\n var canAddError = isEndValue;\n //tip: Exception for canDropArgs (true only if changing func) - don't show error about required args\n if (canAddError) {\n allErrors.push({\n key: constants.REQUIRED_FUNCTION_ARG,\n args: {\n funcKey: funcKey,\n funcName: funcName,\n argKey: argKey,\n argName: argName\n },\n fixed: canReset,\n fixedTo: canReset ? argConfig.defaultValue : undefined,\n ignore: !canReset // tip: don't show error message in UI about missing arg after validation API call\n });\n }\n if (canReset) {\n // set default\n fixedValue = fixedValue.deleteIn([\"args\", argKey]);\n fixedValue = setFuncDefaultArg(config, fixedValue, funcConfig, argKey);\n }\n }\n }\n return [fixedValue, allErrors];\n};\n\n/**\n * \n */\nexport var validateRange = function validateRange(config, field, operator, values, valueSrcs) {\n var operatorConfig = getOperatorConfig(config, operator, field);\n var operatorCardinality = operator ? getOpCardinality(operatorConfig) : null;\n var valueSrcsArr = valueSrcs.toJS ? valueSrcs.toJS() : valueSrcs;\n var valuesArr = values.toJS ? values.toJS() : values;\n var areValueSrcsPureValues = valueSrcsArr.filter(function (vs) {\n return vs == \"value\" || vs == null;\n }).length == operatorCardinality;\n var rangeError;\n if (operatorConfig !== null && operatorConfig !== void 0 && operatorConfig.validateValues && areValueSrcsPureValues) {\n var valueSrc = valueSrcsArr[0];\n var w = getWidgetForFieldOp(config, field, operator, valueSrc);\n var fieldWidgetDefinition = getFieldWidgetConfig(config, field, operator, w, valueSrc);\n var jsValues = fieldWidgetDefinition !== null && fieldWidgetDefinition !== void 0 && fieldWidgetDefinition.toJS ? valuesArr.map(function (v) {\n var jsVal = fieldWidgetDefinition.toJS.call(config.ctx, v, fieldWidgetDefinition);\n if (jsVal instanceof Date) {\n jsVal = jsVal.getTime();\n }\n return jsVal;\n }) : valuesArr;\n var validResult = operatorConfig.validateValues(jsValues);\n if (typeof validResult === \"boolean\") {\n if (validResult == false) {\n rangeError = {\n key: constants.INVALID_RANGE,\n args: {\n jsValues: jsValues,\n values: valuesArr\n }\n };\n }\n }\n }\n return rangeError;\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport { getFieldConfig, getFuncConfig, getFuncSignature, selectTypes } from \"../utils/configUtils\";\nimport { getDefaultArgValue, setArgValue, setFuncDefaultArgs, setFuncDefaultArg } from \"../utils/ruleUtils\";\nimport { validateValue } from \"../utils/validation\";\nimport Immutable from \"immutable\";\nexport { setArgValue, setFuncDefaultArgs, setFuncDefaultArg, getDefaultArgValue };\n\n/**\n * @param {Immutable.Map} value \n * @return {array} - [usedFields, badFields]\n */\n// const getUsedFieldsInFuncValue = (value, config) => {\n// let usedFields = [];\n// let badFields = [];\n\n// const _traverse = (value) => {\n// const args = value && value.get(\"args\");\n// if (!args) return;\n// for (const arg of args.values()) {\n// if (arg.get(\"valueSrc\") == \"field\") {\n// const rightField = arg.get(\"value\");\n// if (rightField) {\n// const rightFieldDefinition = config ? getFieldConfig(config, rightField) : undefined;\n// if (config && !rightFieldDefinition)\n// badFields.push(rightField);\n// else\n// usedFields.push(rightField);\n// }\n// } else if (arg.get(\"valueSrc\") == \"func\") {\n// _traverse(arg.get(\"value\"));\n// }\n// }\n// };\n\n// _traverse(value);\n\n// return [usedFields, badFields];\n// };\n\n/**\n * Used @ FuncWidget\n * @param {Immutable.Map} value \n * @param {string} funcKey \n * @param {object} config \n * @param {boolean} canFixArgs\n */\nexport var setFunc = function setFunc(value, funcKey, config, canFixArgs) {\n var fieldSeparator = config.settings.fieldSeparator;\n value = value || new Immutable.Map();\n if (Array.isArray(funcKey)) {\n // fix for cascader\n funcKey = funcKey.join(fieldSeparator);\n }\n var oldFuncKey = value.get(\"func\");\n var oldArgs = value.get(\"args\");\n value = value.set(\"func\", funcKey);\n var funcConfig = funcKey && getFuncConfig(config, funcKey);\n var newFuncSignature = funcKey && getFuncSignature(config, funcKey);\n var oldFuncSignature = oldFuncKey && getFuncSignature(config, oldFuncKey);\n var keepArgsKeys = getCompatibleArgsOnFuncChange(oldFuncSignature, newFuncSignature, oldArgs, config, canFixArgs);\n if (keepArgsKeys.length) {\n var argsKeys = Object.keys(newFuncSignature.args);\n var deleteArgsKeys = argsKeys.filter(function (k) {\n return !keepArgsKeys.includes(k);\n });\n value = deleteArgsKeys.reduce(function (value, k) {\n return value.deleteIn([\"args\", k]);\n }, value);\n } else {\n value = value.set(\"args\", new Immutable.Map());\n }\n\n // defaults\n value = setFuncDefaultArgs(config, value, funcConfig);\n return value;\n};\n\n/**\n* Used @ FuncWidget\n* @param {Immutable.Map} value \n* @param {string} argKey \n* @param {string} argValSrc \n* @param {object} argConfig \n*/\nexport var setArgValueSrc = function setArgValueSrc(value, argKey, argValSrc, _argConfig, _config) {\n if (value && value.get(\"func\")) {\n value = value.setIn([\"args\", argKey], new Immutable.Map({\n valueSrc: argValSrc\n }));\n }\n return value;\n};\nexport var setArgValueAsyncListValues = function setArgValueAsyncListValues(value, argKey, asyncListValues, _argConfig, _config) {\n if (value && value.get(\"func\")) {\n value = value.setIn([\"args\", argKey, \"asyncListValues\"], asyncListValues);\n }\n return value;\n};\n\n// see getFuncSignature in configUtils\nexport var getCompatibleArgsOnFuncChange = function getCompatibleArgsOnFuncChange(s1, s2, argVals, config) {\n var canFixArgs = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n if ((s1 === null || s1 === void 0 ? void 0 : s1.returnType) != (s2 === null || s2 === void 0 ? void 0 : s2.returnType)) return [];\n var checkIndexes = false;\n var keys = Object.keys(s2.args);\n var compatibleKeys = keys.filter(function (k, i) {\n var arg2 = s2.args[k];\n var arg1 = s1.args[k];\n var oldInd = Object.keys(s1.args).indexOf(k);\n if (!arg1 && (arg2.defaultValue !== undefined || arg2.isOptional)) {\n return true;\n }\n if (checkIndexes && i !== oldInd) {\n return false;\n }\n if ((arg1 === null || arg1 === void 0 ? void 0 : arg1.type) != arg2.type) return false;\n if (selectTypes.includes(arg2.type)) {\n if (!arg1.listValuesType || arg1.listValuesType !== arg2.listValuesType) return false;\n }\n if (argVals) {\n var _argValidErrors$filte;\n var argVal = argVals.get(k);\n var argValue = argVal === null || argVal === void 0 ? void 0 : argVal.get(\"value\");\n var argValueSrc = argVal === null || argVal === void 0 ? void 0 : argVal.get(\"valueSrc\");\n if (argValueSrc && arg2.valueSources && !arg2.valueSources.includes(argValueSrc)) return false;\n var leftField = null,\n operator = null,\n argDef = arg2,\n asyncListValues = null,\n isEndValue = true;\n var _validateValue = validateValue(config, leftField, argDef, operator, argValue, argDef.type, argValueSrc, asyncListValues, canFixArgs, isEndValue),\n _validateValue2 = _slicedToArray(_validateValue, 2),\n _fixedArgVal = _validateValue2[0],\n argValidErrors = _validateValue2[1];\n if (argValidErrors !== null && argValidErrors !== void 0 && (_argValidErrors$filte = argValidErrors.filter(function (e) {\n return !e.fixed;\n })) !== null && _argValidErrors$filte !== void 0 && _argValidErrors$filte.length) return false;\n }\n return true;\n });\n return compatibleKeys;\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport Immutable from \"immutable\";\nimport uuid from \"./uuid\";\nimport { getNewValueForFieldOp } from \"./getNewValueForFieldOp\";\nimport { isImmutable } from \"./stuff\";\nimport { defaultOperatorOptions, defaultGroupProperties, getDefaultField, getDefaultFieldSrc, getDefaultOperator, defaultGroupConjunction } from \"./defaultUtils\";\nimport { validateValue, validateRange } from \"./validation\";\nimport { getFieldConfig } from \"./configUtils\";\nexport * from \"./defaultUtils\";\nexport var defaultRuleProperties = function defaultRuleProperties(config) {\n var parentRuleGroupField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n var item = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var canUseDefaultFieldAndOp = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n var canGetFirst = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n var field = null,\n operator = null,\n fieldSrc = null;\n var showErrorMessage = config.settings.showErrorMessage;\n if (item) {\n var _item$properties, _item$properties2, _item$properties3;\n fieldSrc = item === null || item === void 0 || (_item$properties = item.properties) === null || _item$properties === void 0 ? void 0 : _item$properties.fieldSrc;\n field = item === null || item === void 0 || (_item$properties2 = item.properties) === null || _item$properties2 === void 0 ? void 0 : _item$properties2.field;\n operator = item === null || item === void 0 || (_item$properties3 = item.properties) === null || _item$properties3 === void 0 ? void 0 : _item$properties3.operator;\n } else if (canUseDefaultFieldAndOp) {\n field = getDefaultField(config, canGetFirst, parentRuleGroupField);\n if (field) {\n fieldSrc = isImmutable(field) ? \"func\" : \"field\";\n } else {\n fieldSrc = getDefaultFieldSrc(config);\n }\n operator = getDefaultOperator(config, field, true);\n } else {\n fieldSrc = getDefaultFieldSrc(config);\n }\n var current = new Immutable.Map({\n fieldSrc: fieldSrc,\n field: field,\n operator: operator,\n value: new Immutable.List(),\n valueSrc: new Immutable.List(),\n //used for complex operators like proximity\n operatorOptions: defaultOperatorOptions(config, operator, field)\n });\n if (showErrorMessage) {\n current = current.set(\"valueError\", new Immutable.List());\n }\n if (field && operator) {\n var canFix = false;\n var _getNewValueForFieldO = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, config, current, field, operator, \"operator\", canFix),\n newValue = _getNewValueForFieldO.newValue,\n newValueSrc = _getNewValueForFieldO.newValueSrc,\n newValueType = _getNewValueForFieldO.newValueType,\n newValueError = _getNewValueForFieldO.newValueError,\n newFieldError = _getNewValueForFieldO.newFieldError;\n current = current.set(\"value\", newValue).set(\"valueSrc\", newValueSrc).set(\"valueType\", newValueType);\n if (showErrorMessage) {\n current = current.set(\"valueError\", newValueError).set(\"fieldError\", newFieldError);\n }\n }\n var fieldConfig = getFieldConfig(config, field);\n if ((fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) === \"!group\") {\n var conjunction = defaultGroupConjunction(config, fieldConfig);\n current = current.set(\"conjunction\", conjunction);\n }\n return current;\n};\nexport var defaultItemProperties = function defaultItemProperties(config, item) {\n return (item === null || item === void 0 ? void 0 : item.type) == \"group\" ? defaultGroupProperties(config) : defaultRuleProperties(config, null, item);\n};\nexport var defaultRule = function defaultRule(id, config) {\n return _defineProperty({}, id, new Immutable.Map({\n type: \"rule\",\n id: id,\n properties: defaultRuleProperties(config)\n }));\n};\nexport var defaultRoot = function defaultRoot(config) {\n var canAddDefaultRule = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n return new Immutable.Map({\n type: \"group\",\n id: uuid(),\n children1: new Immutable.OrderedMap(canAddDefaultRule ? _objectSpread({}, defaultRule(uuid(), config)) : {}),\n properties: defaultGroupProperties(config)\n });\n};","function asyncGeneratorStep(n, t, e, r, o, a, c) {\n try {\n var i = n[a](c),\n u = i.value;\n } catch (n) {\n return void e(n);\n }\n i.done ? t(u) : Promise.resolve(u).then(r, o);\n}\nfunction _asyncToGenerator(n) {\n return function () {\n var t = this,\n e = arguments;\n return new Promise(function (r, o) {\n var a = n.apply(t, e);\n function _next(n) {\n asyncGeneratorStep(a, r, o, _next, _throw, \"next\", n);\n }\n function _throw(n) {\n asyncGeneratorStep(a, r, o, _next, _throw, \"throw\", n);\n }\n _next(void 0);\n });\n };\n}\nexport { _asyncToGenerator as default };","import _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _asyncToGenerator from \"@babel/runtime/helpers/asyncToGenerator\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nvar _excluded = [\"title\", \"value\", \"disabled\", \"groupTitle\", \"grouplabel\", \"renderTitle\", \"children\", \"label\", \"isCustom\", \"isHidden\"];\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport _regeneratorRuntime from \"@babel/runtime/regenerator\";\nimport { sleep } from \"./stuff\";\nimport { listValuesToArray, getListValue, makeCustomListValue } from \"./listValues\";\n\n// simple polyfill for Next\nvar findLastIndex = function findLastIndex(arr, fn) {\n if (arr.findLastIndex) {\n return arr.findLastIndex(fn);\n } else {\n var ind = _toConsumableArray(arr).reverse().findIndex(fn);\n return ind == -1 ? -1 : arr.length - 1 - ind;\n }\n};\nexport var simulateAsyncFetch = function simulateAsyncFetch(all) {\n var cPageSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n var delay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;\n return /*#__PURE__*/function () {\n var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(search, offset, meta) {\n var isFetchSelectedValues, _values, pageSize, filtered, pages, currentOffset, currentPage, values, newOffset, hasMore;\n return _regeneratorRuntime.wrap(function _callee$(_context) {\n while (1) switch (_context.prev = _context.next) {\n case 0:\n if (!delay) {\n _context.next = 3;\n break;\n }\n _context.next = 3;\n return sleep(delay);\n case 3:\n isFetchSelectedValues = !!(meta !== null && meta !== void 0 && meta.fetchSelectedValues) && Array.isArray(search);\n if (!isFetchSelectedValues) {\n _context.next = 7;\n break;\n }\n _values = listValuesToArray(all).filter(function (_ref2) {\n var value = _ref2.value;\n return search.includes(value);\n });\n return _context.abrupt(\"return\", {\n values: _values\n });\n case 7:\n pageSize = (meta === null || meta === void 0 ? void 0 : meta.pageSize) != undefined ? meta.pageSize : cPageSize;\n filtered = listValuesToArray(all).filter(function (_ref3) {\n var title = _ref3.title,\n value = _ref3.value;\n return search == null ? true : title.toUpperCase().indexOf(search.toUpperCase()) != -1 || \"\".concat(value).toUpperCase().indexOf(search.toUpperCase()) != -1;\n });\n pages = pageSize ? Math.ceil(filtered.length / pageSize) : 0;\n currentOffset = offset || 0;\n currentPage = pageSize ? Math.ceil(currentOffset / pageSize) : null;\n values = pageSize ? filtered.slice(currentOffset, currentOffset + pageSize) : filtered;\n newOffset = pageSize ? currentOffset + values.length : null;\n hasMore = pageSize ? newOffset < filtered.length : false;\n return _context.abrupt(\"return\", {\n values: values,\n hasMore: hasMore\n });\n case 16:\n case \"end\":\n return _context.stop();\n }\n }, _callee);\n }));\n return function (_x, _x2, _x3) {\n return _ref.apply(this, arguments);\n };\n }();\n};\nexport var mergeListValues = function mergeListValues(values, newValues) {\n var toStart = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var hideNewValues = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n if (!newValues) return values;\n var old = values || [];\n var newFiltered = newValues.filter(function (v) {\n return old.find(function (av) {\n return \"\" + av.value == \"\" + v.value;\n }) == undefined;\n }).map(function (v) {\n return hideNewValues ? _objectSpread(_objectSpread({}, v), {}, {\n isHidden: true\n }) : v;\n });\n var merged = toStart ? [].concat(_toConsumableArray(newFiltered), _toConsumableArray(old)) : [].concat(_toConsumableArray(old), _toConsumableArray(newFiltered));\n return merged;\n};\nexport var optionToListValue = function optionToListValue(val, listValues, allowCustomValues) {\n var _val$value;\n var v = val == null || val == \"\" ? undefined : (_val$value = val === null || val === void 0 ? void 0 : val.value) !== null && _val$value !== void 0 ? _val$value : val;\n var item = getListValue(v, listValues);\n var customItem = allowCustomValues && !item ? makeCustomListValue(v) : undefined;\n var listValue = item || customItem;\n var lvs = listValue ? [listValue] : undefined; //not allow []\n return [v, lvs];\n};\nexport var optionsToListValues = function optionsToListValues(vals, listValues, allowCustomValues) {\n var newSelectedListValues = vals.map(function (val, _i) {\n var _val$value2;\n var v = val == null || val == \"\" ? undefined : (_val$value2 = val === null || val === void 0 ? void 0 : val.value) !== null && _val$value2 !== void 0 ? _val$value2 : val;\n var item = getListValue(v, listValues);\n var customItem = allowCustomValues && !item ? makeCustomListValue(v) : undefined;\n var listValue = item || customItem;\n return listValue;\n }).filter(function (o) {\n return o != undefined;\n });\n var newSelectedValues = newSelectedListValues.map(function (o) {\n var _o$value;\n return (_o$value = o === null || o === void 0 ? void 0 : o.value) !== null && _o$value !== void 0 ? _o$value : o;\n });\n if (!newSelectedValues.length) newSelectedValues = undefined; //not allow []\n return [newSelectedValues, newSelectedListValues];\n};\nexport var listValueToOption = function listValueToOption(lv) {\n if (lv == null) return null;\n var title = lv.title,\n value = lv.value,\n disabled = lv.disabled,\n groupTitle = lv.groupTitle,\n grouplabel = lv.grouplabel,\n renderTitle = lv.renderTitle,\n children = lv.children,\n label = lv.label,\n isCustom = lv.isCustom,\n isHidden = lv.isHidden,\n rest = _objectWithoutProperties(lv, _excluded);\n var option = {\n value: value,\n title: title || label || children // fix issue #930 for AntD\n };\n if (disabled) option.disabled = disabled;\n if (isCustom) option.isCustom = isCustom;\n if (isHidden) option.isHidden = isHidden;\n // group\n if (groupTitle || grouplabel) option.groupTitle = groupTitle || grouplabel;\n // used only for MUI field autocomplete (if matchesType, render as bold)\n if (renderTitle) option.renderTitle = renderTitle;\n option = _objectSpread(_objectSpread({}, option), rest);\n return option;\n};\nexport var fixListValuesGroupOrder = function fixListValuesGroupOrder(listValues) {\n var newValues = [];\n var groupTitles = [];\n var _iterator = _createForOfIteratorHelper(listValues),\n _step;\n try {\n var _loop = function _loop() {\n var lv = _step.value;\n var i = findLastIndex(newValues, function (lv1) {\n var _lv1$groupTitle, _lv$groupTitle;\n return ((_lv1$groupTitle = lv1.groupTitle) !== null && _lv1$groupTitle !== void 0 ? _lv1$groupTitle : \"\") == ((_lv$groupTitle = lv.groupTitle) !== null && _lv$groupTitle !== void 0 ? _lv$groupTitle : \"\");\n });\n if (lv.groupTitle != undefined && !groupTitles.includes(lv.groupTitle)) {\n groupTitles.push(lv.groupTitle);\n if (groupTitles.length === 1) {\n // fix empty groupTitles\n newValues = newValues.map(function (nv) {\n return _objectSpread(_objectSpread({}, nv), {}, {\n groupTitle: \"\"\n });\n });\n }\n }\n if (lv.groupTitle == undefined && groupTitles.length) {\n // fix empty groupTitle\n lv = _objectSpread(_objectSpread({}, lv), {}, {\n groupTitle: \"\"\n });\n }\n if (i != -1) {\n newValues.splice(i + 1, 0, lv);\n } else {\n newValues.push(lv);\n }\n };\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n _loop();\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return newValues;\n};\nexport { getListValue };","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nfunction _objectWithoutProperties(e, t) {\n if (null == e) return {};\n var o,\n r,\n i = objectWithoutPropertiesLoose(e, t);\n if (Object.getOwnPropertySymbols) {\n var n = Object.getOwnPropertySymbols(e);\n for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);\n }\n return i;\n}\nexport { _objectWithoutProperties as default };","function _objectWithoutPropertiesLoose(r, e) {\n if (null == r) return {};\n var t = {};\n for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n if (-1 !== e.indexOf(n)) continue;\n t[n] = r[n];\n }\n return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nimport * as Utils from \"../../utils\";\nimport { compareToSign } from \"../../export/spel\";\nvar iterateFuncs = Utils.ConfigUtils.iterateFuncs;\nvar logger = Utils.OtherUtils.logger;\nvar isFuncableProperty = function isFuncableProperty(p) {\n return [\"length\"].includes(p);\n};\nexport var manuallyImportedOps = [\"between\", \"not_between\", \"is_empty\", \"is_not_empty\", \"is_null\", \"is_not_null\", \"some\", \"all\", \"none\"];\nexport var unsupportedOps = [\"proximity\"];\nexport var buildConv = function buildConv(config) {\n var operators = {};\n var _loop = function _loop(opKey) {\n var opConfig = config.operators[opKey];\n // const isGroupOp = config.settings.groupOperators?.includes(opKey);\n var spelOps = opConfig.spelOps ? opConfig.spelOps : opConfig.spelOp ? [opConfig.spelOp] : undefined;\n if (spelOps) {\n // examples of 2+: \"==\", \"eq\", \".contains\", \"matches\" (can be used for starts_with, ends_with)\n spelOps.forEach(function (spelOp) {\n var opk = spelOp; // + \"/\" + getOpCardinality(opConfig);\n if (!operators[opk]) operators[opk] = [];\n operators[opk].push(opKey);\n });\n } else {\n var _config$operators;\n var revOpConfig = (_config$operators = config.operators) === null || _config$operators === void 0 ? void 0 : _config$operators[opConfig.reversedOp];\n var canUseRev = (revOpConfig === null || revOpConfig === void 0 ? void 0 : revOpConfig.spelOp) || (revOpConfig === null || revOpConfig === void 0 ? void 0 : revOpConfig.spelOps);\n var canIgnore = canUseRev || manuallyImportedOps.includes(opKey) || manuallyImportedOps.includes(opConfig.reversedOp) || unsupportedOps.includes(opKey);\n if (!canIgnore) {\n logger.warn(\"[spel] No spelOp for operator \".concat(opKey));\n }\n }\n };\n for (var opKey in config.operators) {\n _loop(opKey);\n }\n var conjunctions = {};\n for (var conjKey in config.conjunctions) {\n var conjunctionDefinition = config.conjunctions[conjKey];\n var ck = conjunctionDefinition.spelConj || conjKey.toLowerCase();\n conjunctions[ck] = conjKey;\n }\n var funcs = {};\n var _iterator = _createForOfIteratorHelper(iterateFuncs(config)),\n _step;\n try {\n var _loop3 = function _loop3() {\n var _step$value = _slicedToArray(_step.value, 2),\n funcPath = _step$value[0],\n funcConfig = _step$value[1];\n var fks = [];\n var spelFunc = funcConfig.spelFunc;\n if (typeof spelFunc === \"string\") {\n var optionalArgs = Object.keys(funcConfig.args || {}).reverse().filter(function (argKey) {\n return !!funcConfig.args[argKey].isOptional || funcConfig.args[argKey].defaultValue != undefined;\n });\n var funcSignMain = spelFunc\n // Tip: convert \"?.\" to \".\" to support safe navigation operator (issue #1010)\n .replace(/\\?\\./g, \".\").replace(/\\${(\\w+)}/g, function (_, _k) {\n return \"?\";\n });\n var funcSignsOptional = optionalArgs.reduce(function (acc, argKey) {\n return [].concat(_toConsumableArray(acc), [[argKey].concat(_toConsumableArray(acc[acc.length - 1] || []))]);\n }, []).map(function (optionalArgKeys) {\n return spelFunc.replace(/(?:, )?\\${(\\w+)}/g, function (found, a) {\n return optionalArgKeys.includes(a) ? \"\" : found;\n }).replace(/\\?\\./g, \".\").replace(/\\${(\\w+)}/g, function (_, _k) {\n return \"?\";\n });\n });\n fks = [funcSignMain].concat(_toConsumableArray(funcSignsOptional));\n }\n var _iterator3 = _createForOfIteratorHelper(fks),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var _fk = _step3.value;\n if (!funcs[_fk]) funcs[_fk] = [];\n funcs[_fk].push(funcPath);\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n };\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n _loop3();\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n var valueFuncs = {};\n for (var w in config.widgets) {\n var widgetDef = config.widgets[w];\n var spelImportFuncs = widgetDef.spelImportFuncs;\n if (spelImportFuncs) {\n var _iterator2 = _createForOfIteratorHelper(spelImportFuncs),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var fk = _step2.value;\n if (typeof fk === \"string\") {\n var fs = fk.replace(/\\?\\./g, \".\").replace(/\\${(\\w+)}/g, function (_, k) {\n return \"?\";\n });\n var argsOrder = _toConsumableArray(fk.matchAll(/\\${(\\w+)}/g)).map(function (_ref) {\n var _ref2 = _slicedToArray(_ref, 2),\n _ = _ref2[0],\n k = _ref2[1];\n return k;\n });\n if (!valueFuncs[fs]) valueFuncs[fs] = [];\n valueFuncs[fs].push({\n w: w,\n argsOrder: argsOrder\n });\n }\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n }\n }\n var opFuncs = {};\n var _loop2 = function _loop2(op) {\n var opDef = config.operators[op];\n var spelOps = opDef.spelOps ? opDef.spelOps : opDef.spelOp ? [opDef.spelOp] : undefined;\n spelOps === null || spelOps === void 0 || spelOps.forEach(function (spelOp) {\n if (spelOp !== null && spelOp !== void 0 && spelOp.includes(\"${0}\")) {\n var _fs = spelOp.replace(/\\?\\./g, \".\").replace(/\\${(\\w+)}/g, function (_, k) {\n return \"?\";\n });\n var _argsOrder = _toConsumableArray(spelOp.matchAll(/\\${(\\w+)}/g)).map(function (_ref3) {\n var _ref4 = _slicedToArray(_ref3, 2),\n _ = _ref4[0],\n k = _ref4[1];\n return k;\n });\n if (!opFuncs[_fs]) opFuncs[_fs] = [];\n opFuncs[_fs].push({\n op: op,\n argsOrder: _argsOrder\n });\n }\n });\n };\n for (var op in config.operators) {\n _loop2(op);\n }\n // Special .compareTo()\n var compareToSS = compareToSign.replace(/\\?\\./g, \".\").replace(/\\${(\\w+)}/g, function (_, k) {\n return \"?\";\n });\n opFuncs[compareToSS] = [{\n op: \"!compare\",\n argsOrder: [\"0\", \"1\"]\n }];\n return {\n operators: operators,\n conjunctions: conjunctions,\n funcs: funcs,\n valueFuncs: valueFuncs,\n opFuncs: opFuncs\n };\n};\nexport var buildFuncSignatures = function buildFuncSignatures(spel) {\n // branches\n var brns = [{\n s: \"\",\n params: [],\n objs: []\n }];\n _buildFuncSignatures6(spel, brns);\n return brns.map(function (_ref5) {\n var s = _ref5.s,\n params = _ref5.params;\n return {\n s: s,\n params: params\n };\n }).reverse().filter(function (_ref6) {\n var s = _ref6.s;\n return s !== \"\" && s !== \"?\";\n });\n};\n\n// a.toLower().toUpper()\n// ->\n// ?.toLower().toUpper()\n// ?.toUpper()\nvar _buildFuncSignatures6 = function _buildFuncSignatures(spel, brns) {\n var params = [],\n s = \"\";\n var type = spel.type,\n methodName = spel.methodName,\n val = spel.val,\n obj = spel.obj,\n args = spel.args,\n isVar = spel.isVar,\n cls = spel.cls,\n children = spel.children;\n var lastChild = children === null || children === void 0 ? void 0 : children[children.length - 1];\n var currBrn = brns[brns.length - 1];\n if (type === \"!func\") {\n // T(DateTimeFormat).forPattern(?).parseDateTime(?) -- ok\n // T(LocalDateTime).parse(?, T(DateTimeFormatter).ofPattern(?)) -- will not work\n var o = obj;\n while (o) {\n var _currBrn$params;\n var _buildFuncSignatures2 = _buildFuncSignatures6(_objectSpread(_objectSpread({}, o), {}, {\n obj: null\n }), [{}]),\n _buildFuncSignatures3 = _slicedToArray(_buildFuncSignatures2, 2),\n s1 = _buildFuncSignatures3[0],\n params1 = _buildFuncSignatures3[1];\n if (s1 !== \"?\") {\n // start new branch\n var newBrn = {\n s: currBrn.s,\n params: _toConsumableArray(currBrn.params),\n objs: _toConsumableArray(currBrn.objs)\n };\n // finish old branch\n currBrn.objs.unshift(\"?\");\n currBrn.params.unshift(o);\n // switch\n brns.push(newBrn);\n currBrn = brns[brns.length - 1];\n }\n // step\n currBrn.objs.unshift(s1);\n (_currBrn$params = currBrn.params).unshift.apply(_currBrn$params, _toConsumableArray(params1));\n o = o.type === \"!func\" ? o.obj : null;\n }\n var _iterator4 = _createForOfIteratorHelper(brns),\n _step4;\n try {\n for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n var _brn$objs;\n var brn = _step4.value;\n params = [].concat(_toConsumableArray((brn === null || brn === void 0 ? void 0 : brn.params) || []), _toConsumableArray(args || []));\n s = \"\";\n if (brn !== null && brn !== void 0 && (_brn$objs = brn.objs) !== null && _brn$objs !== void 0 && _brn$objs.length) s += brn.objs.join(\".\") + \".\";\n s += (isVar ? \"#\" : \"\") + methodName;\n s += \"(\" + (args || []).map(function (_) {\n return \"?\";\n }).join(\", \") + \")\";\n brn.s = s;\n brn.params = params;\n }\n } catch (err) {\n _iterator4.e(err);\n } finally {\n _iterator4.f();\n }\n } else if (type === \"!new\") {\n // new java.text.SimpleDateFormat('HH:mm:ss').parse('...')\n params = args || [];\n s = \"new \".concat(cls.join(\".\"), \"(\").concat(params.map(function (_) {\n return \"?\";\n }).join(\", \"), \")\");\n } else if (type === \"!type\") {\n // T(java.time.LocalTime).parse('...')\n s = \"T(\".concat(cls.join(\".\"), \")\");\n } else if (type === \"compound\" && lastChild.type === \"property\" && isFuncableProperty(lastChild.val)) {\n // {1,2}.length -- ok\n // 'Hello World'.bytes.length -- will not work\n s = children.map(function (c) {\n var _params;\n if (c === lastChild) return c.val;\n var _buildFuncSignatures4 = _buildFuncSignatures6(_objectSpread(_objectSpread({}, c), {}, {\n obj: null\n }), [{}]),\n _buildFuncSignatures5 = _slicedToArray(_buildFuncSignatures4, 2),\n s1 = _buildFuncSignatures5[0],\n params1 = _buildFuncSignatures5[1];\n (_params = params).push.apply(_params, _toConsumableArray(params1));\n return s1;\n }).join(\".\");\n } else {\n params = [spel];\n s = \"?\";\n }\n if (currBrn) {\n currBrn.s = s;\n currBrn.params = params;\n }\n return [s, params];\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport * as Utils from \"../../utils\";\nvar _Utils$OtherUtils = Utils.OtherUtils,\n isObject = _Utils$OtherUtils.isObject,\n uuid = _Utils$OtherUtils.uuid;\nvar _Utils$DefaultUtils = Utils.DefaultUtils,\n defaultConjunction = _Utils$DefaultUtils.defaultConjunction,\n defaultGroupConjunction = _Utils$DefaultUtils.defaultGroupConjunction;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;\n\n// export const wrapInDefaultConjRuleGroup = (rule, parentField, parentFieldConfig, config, conj) => {\n// if (!rule) return undefined;\n// return {\n// type: \"rule_group\",\n// id: uuid(),\n// children1: { [rule.id]: rule },\n// properties: {\n// conjunction: conj || defaultGroupConjunction(config, parentFieldConfig),\n// not: false,\n// field: parentField,\n// }\n// };\n// };\n\nexport var wrapInDefaultConj = function wrapInDefaultConj(rule, config) {\n var not = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n return {\n type: \"group\",\n id: uuid(),\n children1: _defineProperty({}, rule.id, rule),\n properties: {\n conjunction: defaultConjunction(config),\n not: not || false\n }\n };\n};\nexport var buildCase = function buildCase(convCond, convVal, conv, config, meta) {\n var spel = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n var valProperties = buildCaseValProperties(config, meta, conv, convVal, spel);\n var caseI;\n if (convCond) {\n caseI = convCond;\n if (caseI.type) {\n if (caseI.type != \"group\" && caseI.type != \"case_group\") {\n caseI = wrapInDefaultConj(caseI, config);\n }\n caseI.type = \"case_group\";\n } else {\n meta.errors.push(\"Unexpected case: \".concat(JSON.stringify(caseI)));\n caseI = undefined;\n }\n } else {\n caseI = {\n id: uuid(),\n type: \"case_group\",\n properties: {}\n };\n }\n if (caseI) {\n caseI.properties = _objectSpread(_objectSpread({}, caseI.properties), valProperties);\n }\n return caseI;\n};\nexport var buildSimpleSwitch = function buildSimpleSwitch(convVal, conv, config, meta) {\n var children1 = {};\n var caseI = buildCase(null, convVal, conv, config, meta);\n if (caseI) {\n children1[caseI.id] = caseI;\n }\n var res = {\n type: \"switch_group\",\n id: uuid(),\n children1: children1,\n properties: {}\n };\n return res;\n};\nexport var buildRuleGroup = function buildRuleGroup(_ref, opKey, convertedArgs, config, meta) {\n var groupFilter = _ref.groupFilter,\n groupFieldValue = _ref.groupFieldValue;\n if (groupFieldValue.valueSrc != \"field\") throw \"Bad groupFieldValue: \".concat(JSON.stringify(groupFieldValue));\n var groupField = groupFieldValue.value;\n var groupOpRule = buildRule(config, meta, groupField, opKey, convertedArgs);\n if (!groupOpRule) return undefined;\n var fieldConfig = getFieldConfig(config, groupField);\n var mode = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.mode;\n var res;\n if ((groupFilter === null || groupFilter === void 0 ? void 0 : groupFilter.type) === \"group\") {\n res = _objectSpread(_objectSpread({}, groupFilter || {}), {}, {\n type: \"rule_group\",\n properties: _objectSpread(_objectSpread(_objectSpread({}, groupOpRule.properties), (groupFilter === null || groupFilter === void 0 ? void 0 : groupFilter.properties) || {}), {}, {\n mode: mode\n })\n });\n } else if (groupFilter) {\n // rule_group in rule_group\n res = _objectSpread(_objectSpread({}, groupOpRule || {}), {}, {\n type: \"rule_group\",\n children1: [groupFilter],\n properties: _objectSpread(_objectSpread({}, groupOpRule.properties), {}, {\n mode: mode\n })\n });\n } else {\n res = _objectSpread(_objectSpread({}, groupOpRule || {}), {}, {\n type: \"rule_group\",\n properties: _objectSpread(_objectSpread({}, groupOpRule.properties), {}, {\n mode: mode\n })\n });\n }\n if (!res.id) res.id = uuid();\n return res;\n};\nexport var buildCaseValProperties = function buildCaseValProperties(config, meta, conv, convVal) {\n var spel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var valProperties = {};\n var widget;\n var widgetConfig;\n var caseValueFieldConfig = getFieldConfig(config, \"!case_value\");\n if ((convVal === null || convVal === void 0 ? void 0 : convVal.valueType) === \"case_value\") {\n /**\n * @deprecated\n */\n widget = \"case_value\";\n } else {\n widget = caseValueFieldConfig === null || caseValueFieldConfig === void 0 ? void 0 : caseValueFieldConfig.mainWidget;\n widgetConfig = config.widgets[widget];\n if (convVal && convVal.valueSrc === \"value\") {\n var _widgetConfig;\n convVal.valueType = ((_widgetConfig = widgetConfig) === null || _widgetConfig === void 0 ? void 0 : _widgetConfig.type) || (caseValueFieldConfig === null || caseValueFieldConfig === void 0 ? void 0 : caseValueFieldConfig.type) || convVal.valueType;\n }\n }\n var widgetDef = config.widgets[widget];\n if (widget === \"case_value\") {\n /**\n * @deprecated\n */\n var importCaseValue = widgetDef === null || widgetDef === void 0 ? void 0 : widgetDef.spelImportValue;\n if (importCaseValue) {\n var _importCaseValue$call = importCaseValue.call(config.ctx, convVal),\n _importCaseValue$call2 = _slicedToArray(_importCaseValue$call, 2),\n normVal = _importCaseValue$call2[0],\n normErrors = _importCaseValue$call2[1];\n normErrors.map(function (e) {\n return meta.errors.push(e);\n });\n if (normVal != undefined) {\n var _widgetDef$type;\n valProperties = {\n value: [normVal],\n valueSrc: [\"value\"],\n valueType: [(_widgetDef$type = widgetDef === null || widgetDef === void 0 ? void 0 : widgetDef.type) !== null && _widgetDef$type !== void 0 ? _widgetDef$type : \"case_value\"],\n field: \"!case_value\"\n };\n }\n }\n } else if (convVal != undefined && (convVal === null || convVal === void 0 ? void 0 : convVal.value) != undefined) {\n valProperties = {\n value: [convVal.value],\n valueSrc: [convVal.valueSrc],\n valueType: [convVal.valueType],\n field: \"!case_value\"\n };\n }\n return valProperties;\n};\nexport var buildRule = function buildRule(config, meta, field, opKey, convertedArgs, spel) {\n var _field, _opConfig;\n if (convertedArgs.filter(function (v) {\n return v === undefined;\n }).length) {\n return undefined;\n }\n var fieldSrc = (_field = field) !== null && _field !== void 0 && _field.func ? \"func\" : \"field\";\n if (isObject(field) && field.valueSrc) {\n // if comed from convertFuncToOp()\n fieldSrc = field.valueSrc;\n field = field.value;\n }\n var fieldConfig = getFieldConfig(config, field);\n if (!fieldConfig) {\n meta.errors.push(\"No config for field \".concat(field));\n return undefined;\n }\n var parentFieldConfig = getFieldConfig(config, spel === null || spel === void 0 ? void 0 : spel._groupField);\n var isRuleGroup = fieldConfig.type == \"!group\";\n var isGroupArray = isRuleGroup && fieldConfig.mode == \"array\";\n var isInRuleGroup = (parentFieldConfig === null || parentFieldConfig === void 0 ? void 0 : parentFieldConfig.type) == \"!group\";\n var opConfig = config.operators[opKey];\n var reversedOpConfig = config.operators[(_opConfig = opConfig) === null || _opConfig === void 0 ? void 0 : _opConfig.reversedOp];\n var opNeedsReverse = (spel === null || spel === void 0 ? void 0 : spel.not) && [\"between\"].includes(opKey);\n var opCanReverse = !!reversedOpConfig;\n var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse || !isRuleGroup && isInRuleGroup // 2+ rules in rule-group should be flat. see inits.with_not_and_in_some in test\n );\n var needRev = (spel === null || spel === void 0 ? void 0 : spel.not) && canRev || opNeedsReverse;\n if (needRev) {\n // todo: should be already handled at convertOp ? or there are special cases to handle here, like rule-group ?\n opKey = opConfig.reversedOp;\n opConfig = config.operators[opKey];\n spel.not = !spel.not;\n }\n var needWrapWithNot = !!(spel !== null && spel !== void 0 && spel.not);\n var widget = getWidgetForFieldOp(config, field, opKey);\n var widgetConfig = config.widgets[widget || fieldConfig.mainWidget];\n var asyncListValuesArr = convertedArgs.map(function (v) {\n return v.asyncListValues;\n }).filter(function (v) {\n return v != undefined;\n });\n var asyncListValues = asyncListValuesArr.length ? asyncListValuesArr[0] : undefined;\n var res = {\n type: \"rule\",\n id: uuid(),\n properties: _objectSpread({\n field: field,\n fieldSrc: fieldSrc,\n operator: opKey,\n value: convertedArgs.map(function (v) {\n return v.value;\n }),\n valueSrc: convertedArgs.map(function (v) {\n return v.valueSrc;\n }),\n valueType: convertedArgs.map(function (v) {\n if (v.valueSrc == \"value\") {\n return (widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.type) || (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) || v.valueType;\n }\n return v.valueType;\n })\n }, asyncListValues ? {\n asyncListValues: asyncListValues\n } : {})\n };\n if (needWrapWithNot) {\n res = wrapInDefaultConj(res, config, spel.not);\n // spel.not = !spel.not; // why I added this line?\n }\n return res;\n};","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport * as Utils from \"../../utils\";\nvar logger = Utils.OtherUtils.logger;\nvar _postprocessCompiled = function postprocessCompiled(expr, meta) {\n var parentExpr = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n var type = expr.getType();\n var children = expr.getChildren().map(function (child) {\n return _postprocessCompiled(child, meta, expr);\n });\n\n // flatize OR/AND\n if (type == \"op-or\" || type == \"op-and\") {\n children = children.reduce(function (acc, child) {\n var isBetweenNormal = child.type == \"op-and\" && child.children.length == 2 && child.children[0].type == \"op-ge\" && child.children[1].type == \"op-le\";\n var isBetweenRev = child.type == \"op-or\" && child.children.length == 2 && child.children[0].type == \"op-lt\" && child.children[1].type == \"op-gt\";\n var isBetween = isBetweenNormal || isBetweenRev;\n var canFlatize = child.type == type && !child.not && !isBetween;\n var flat = canFlatize ? child.children : [child];\n return [].concat(_toConsumableArray(acc), _toConsumableArray(flat));\n }, []);\n }\n\n // unwrap NOT\n if (type == \"op-not\") {\n if (children.length != 1) {\n meta.errors.push(\"Operator NOT should have 1 child, but got \".concat(children.length, \"}\"));\n }\n return _objectSpread(_objectSpread({}, children[0]), {}, {\n not: !(children[0].not || false)\n });\n }\n if (type == \"compound\") {\n // remove `.?[true]`\n children = children.filter(function (child) {\n var isListFix = child.type == \"selection\" && child.children.length == 1 && child.children[0].type == \"boolean\" && child.children[0].val == true;\n return !isListFix;\n });\n // aggregation\n // eg. `results.?[product == 'abc'].length`\n var selection = children.find(function (child) {\n return child.type == \"selection\";\n });\n if (selection && selection.children.length != 1) {\n meta.errors.push(\"Selection should have 1 child, but got \".concat(selection.children.length));\n }\n var filter = selection ? selection.children[0] : null;\n var lastChild = children[children.length - 1];\n var isSize = lastChild.type == \"method\" && lastChild.val.methodName == \"size\" || lastChild.type == \"!func\" && lastChild.methodName == \"size\";\n var isLength = lastChild.type == \"property\" && lastChild.val == \"length\";\n var sourceParts = children.filter(function (child) {\n return child !== selection && child !== lastChild;\n });\n var source = {\n type: \"compound\",\n children: sourceParts\n };\n var isAggr = (isSize || isLength) && convertPath(sourceParts) != null;\n if (isAggr) {\n return {\n type: \"!aggr\",\n filter: filter,\n source: source\n };\n }\n // remove `#this`, `#root`\n children = children.filter(function (child) {\n var isThis = child.type == \"variable\" && child.val == \"this\";\n var isRoot = child.type == \"variable\" && child.val == \"root\";\n return !(isThis || isRoot);\n });\n // indexer\n children = children.map(function (child) {\n if (child.type == \"indexer\" && child.children.length == 1) {\n return {\n type: \"indexer\",\n val: child.children[0].val,\n itype: child.children[0].type\n };\n } else {\n return child;\n }\n });\n // method\n // if (lastChild.type == \"method\") {\n // // seems like obsolete code!\n // debugger\n // const obj = children.filter(child => \n // child !== lastChild\n // );\n // return {\n // type: \"!func\",\n // obj,\n // methodName: lastChild.val.methodName,\n // args: lastChild.val.args\n // };\n // }\n // !func\n if (lastChild.type == \"!func\") {\n var ret = {};\n var curr = ret;\n do {\n var _lastChild, _lastChild2;\n Object.assign(curr, lastChild);\n children = children.filter(function (child) {\n return child !== lastChild;\n });\n lastChild = children[children.length - 1];\n if (((_lastChild = lastChild) === null || _lastChild === void 0 ? void 0 : _lastChild.type) == \"!func\") {\n curr.obj = {};\n curr = curr.obj;\n } else {\n if (children.length > 1) {\n curr.obj = {\n type: \"compound\",\n children: children\n };\n } else {\n curr.obj = lastChild;\n }\n }\n } while (((_lastChild2 = lastChild) === null || _lastChild2 === void 0 ? void 0 : _lastChild2.type) == \"!func\");\n return ret;\n }\n }\n\n // getRaw || getValue\n var val;\n try {\n if (expr.getRaw) {\n // use my fork\n val = expr.getRaw();\n } else if (expr.getValue.length == 0) {\n // getValue not requires context arg -> can use\n val = expr.getValue();\n }\n } catch (e) {\n logger.error(\"[spel2js] Error in getValue()\", e);\n }\n\n // ternary\n if (type == \"ternary\") {\n val = flatizeTernary(children);\n }\n\n // convert method/function args\n if (_typeof(val) === \"object\" && val !== null) {\n if (val.methodName || val.functionName) {\n val.args = val.args.map(function (child) {\n return _postprocessCompiled(child, meta, expr);\n });\n }\n }\n // convert list\n if (type == \"list\") {\n val = val.map(function (item) {\n return _postprocessCompiled(item, meta, expr);\n });\n\n // fix whole expression wrapped in `{}`\n if (!parentExpr && val.length == 1) {\n return val[0];\n }\n }\n // convert constructor\n if (type == \"constructorref\") {\n var qid = children.find(function (child) {\n return child.type == \"qualifiedidentifier\";\n });\n var cls = qid === null || qid === void 0 ? void 0 : qid.val;\n if (!cls) {\n meta.errors.push(\"Can't find qualifiedidentifier in constructorref children: \".concat(JSON.stringify(children)));\n return undefined;\n }\n var args = children.filter(function (child) {\n return child.type != \"qualifiedidentifier\";\n });\n return {\n type: \"!new\",\n cls: cls,\n args: args\n };\n }\n // convert type\n if (type == \"typeref\") {\n var _qid = children.find(function (child) {\n return child.type == \"qualifiedidentifier\";\n });\n var _cls = _qid === null || _qid === void 0 ? void 0 : _qid.val;\n if (!_cls) {\n meta.errors.push(\"Can't find qualifiedidentifier in typeref children: \".concat(JSON.stringify(children)));\n return undefined;\n }\n var _args = children.filter(function (child) {\n return child.type != \"qualifiedidentifier\";\n });\n return {\n type: \"!type\",\n cls: _cls\n };\n }\n // convert function/method\n if (type == \"function\" || type == \"method\") {\n // `foo()` is method, `#foo()` is function\n // let's use common property `methodName` and just add `isVar` for function\n var _val = val,\n functionName = _val.functionName,\n methodName = _val.methodName,\n _args2 = _val.args;\n return {\n type: \"!func\",\n methodName: functionName || methodName,\n isVar: type == \"function\",\n args: _args2\n };\n }\n return {\n type: type,\n children: children,\n val: val\n };\n};\nexport { _postprocessCompiled as postprocessCompiled };\nvar flatizeTernary = function flatizeTernary(children) {\n var flat = [];\n function _processTernaryChildren(tern) {\n var _tern = _slicedToArray(tern, 3),\n cond = _tern[0],\n if_val = _tern[1],\n else_val = _tern[2];\n flat.push([cond, if_val]);\n if ((else_val === null || else_val === void 0 ? void 0 : else_val.type) == \"ternary\") {\n _processTernaryChildren(else_val.children);\n } else {\n flat.push([undefined, else_val]);\n }\n }\n _processTernaryChildren(children);\n return flat;\n};\nexport var convertPath = function convertPath(parts) {\n var meta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n var expectingField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var isError = false;\n var res = parts.map(function (c) {\n if (c.type == \"variable\" || c.type == \"property\" || c.type == \"indexer\" && c.itype == \"string\") {\n return c.val;\n } else {\n var _meta$errors, _meta$errors$push;\n isError = true;\n expectingField && (meta === null || meta === void 0 || (_meta$errors = meta.errors) === null || _meta$errors === void 0 || (_meta$errors$push = _meta$errors.push) === null || _meta$errors$push === void 0 ? void 0 : _meta$errors$push.call(_meta$errors, \"Unexpected item in field path compound: \".concat(JSON.stringify(c))));\n }\n });\n return !isError ? res : undefined;\n};","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { wrapInDefaultConj, buildCase, buildSimpleSwitch, buildRuleGroup, buildRule } from \"./builder\";\nimport { convertPath } from \"./postprocess\";\nimport { buildFuncSignatures } from \"./conv\";\nimport * as Utils from \"../../utils\";\nvar _Utils$OtherUtils = Utils.OtherUtils,\n isJsonCompatible = _Utils$OtherUtils.isJsonCompatible,\n isObject = _Utils$OtherUtils.isObject,\n uuid = _Utils$OtherUtils.uuid,\n logger = _Utils$OtherUtils.logger;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getFuncConfig = _Utils$ConfigUtils.getFuncConfig,\n normalizeField = _Utils$ConfigUtils.normalizeField,\n iterateFuncs = _Utils$ConfigUtils.iterateFuncs,\n getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;\n\n// spel type => raqb type\nvar SpelPrimitiveTypes = {\n number: \"number\",\n string: \"text\",\n \"boolean\": \"boolean\",\n \"null\": \"null\" // should not be\n};\n// spel class => raqb type\nvar SpelPrimitiveClasses = {\n String: \"text\"\n};\nvar ListValueType = \"multiselect\";\nvar _convertToTree = function convertToTree(spel, conv, config, meta) {\n var _spel$_groupField;\n var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (!spel) return undefined;\n spel._groupField = (_spel$_groupField = spel._groupField) !== null && _spel$_groupField !== void 0 ? _spel$_groupField : parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;\n var res,\n canParseAsArg = true;\n if (spel.type.indexOf(\"op-\") === 0 || spel.type === \"matches\") {\n res = _convertOp(spel, conv, config, meta, parentSpel);\n } else if (spel.type == \"!aggr\") {\n var _groupFilter;\n var groupFieldValue = _convertToTree(spel.source, conv, config, meta, spel);\n spel._groupField = groupFieldValue === null || groupFieldValue === void 0 ? void 0 : groupFieldValue.value;\n var groupFilter = _convertToTree(spel.filter, conv, config, meta, spel);\n if (((_groupFilter = groupFilter) === null || _groupFilter === void 0 ? void 0 : _groupFilter.type) == \"rule\") {\n groupFilter = wrapInDefaultConj(groupFilter, config, spel.filter.not);\n }\n res = {\n groupFilter: groupFilter,\n groupFieldValue: groupFieldValue\n };\n if (!parentSpel) {\n // !aggr can't be in root, it should be compared with something\n res = undefined;\n meta.errors.push(\"Unexpected !aggr in root\");\n canParseAsArg = false;\n }\n } else if (spel.type == \"ternary\") {\n var children1 = {};\n spel.val.forEach(function (v) {\n var _v = _slicedToArray(v, 2),\n cond = _v[0],\n val = _v[1];\n var convCond = _convertToTree(cond, conv, config, meta, spel);\n var convVal = convertCaseValue(val, conv, config, meta, spel);\n var caseI = buildCase(convCond, convVal, conv, config, meta, spel);\n if (caseI) {\n children1[caseI.id] = caseI;\n }\n });\n res = {\n type: \"switch_group\",\n id: uuid(),\n children1: children1,\n properties: {}\n };\n }\n if (!res && canParseAsArg) {\n res = _convertArg(spel, conv, config, meta, parentSpel);\n }\n if (res && !res.type && !parentSpel) {\n // res is not a rule, it's value at root\n // try to parse whole `\"1\"` as ternary\n var convVal = convertCaseValue(spel, conv, config, meta);\n var sw = buildSimpleSwitch(convVal, conv, config, meta);\n if (sw) {\n res = sw;\n } else {\n res = undefined;\n meta.errors.push(\"Can't convert rule of type \".concat(spel.type, \", it looks like var/literal\"));\n }\n }\n return res;\n};\nexport { _convertToTree as convertToTree };\nvar _convertOp = function convertOp(spel, conv, config, meta) {\n var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var res;\n var op = spel.type.startsWith(\"op-\") ? spel.type.slice(\"op-\".length) : spel.type;\n\n // unary\n var isUnary = (op == \"minus\" || op == \"plus\") && spel.children.length == 1;\n if (isUnary) {\n var negative = spel.negative;\n if (op == \"minus\") {\n negative = !negative;\n }\n spel.children[0].negative = negative;\n return _convertToTree(spel.children[0], conv, config, meta, parentSpel);\n }\n\n // between\n var isBetweenNormal = op == \"and\" && spel.children.length == 2 && spel.children[0].type == \"op-ge\" && spel.children[1].type == \"op-le\";\n var isBetweenRev = op == \"or\" && spel.children.length == 2 && spel.children[0].type == \"op-lt\" && spel.children[1].type == \"op-gt\";\n var isBetween = isBetweenNormal || isBetweenRev;\n if (isBetween) {\n var _spel$children$0$chil = _slicedToArray(spel.children[0].children, 2),\n left = _spel$children$0$chil[0],\n from = _spel$children$0$chil[1];\n var _spel$children$1$chil = _slicedToArray(spel.children[1].children, 2),\n right = _spel$children$1$chil[0],\n to = _spel$children$1$chil[1];\n var isSameSource = compareArgs(left, right, spel, conv, config, meta, parentSpel);\n if (isSameSource) {\n var _fromValue = from.val;\n var _toValue = to.val;\n var oneSpel = {\n type: \"op-between\",\n children: [left, from, to],\n not: isBetweenRev\n };\n oneSpel._groupField = parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;\n return _convertOp(oneSpel, conv, config, meta, parentSpel);\n }\n }\n\n // find op\n var opKeys = conv.operators[op];\n if (op == \"eq\" && spel.children[1].type == \"null\") {\n opKeys = [\"is_null\"];\n } else if (op == \"ne\" && spel.children[1].type == \"null\") {\n opKeys = [\"is_not_null\"];\n } else if (op == \"le\" && spel.children[1].type == \"string\" && spel.children[1].val == \"\") {\n opKeys = [\"is_empty\"];\n } else if (op == \"gt\" && spel.children[1].type == \"string\" && spel.children[1].val == \"\") {\n opKeys = [\"is_not_empty\"];\n } else if (op == \"between\") {\n opKeys = [\"between\"];\n }\n\n // convert children\n var convertChildren = function convertChildren() {\n var _newChildren;\n var newChildren = spel.children.map(function (child) {\n return _convertToTree(child, conv, config, meta, spel);\n });\n if (newChildren.length >= 2 && ((_newChildren = newChildren) === null || _newChildren === void 0 || (_newChildren = _newChildren[0]) === null || _newChildren === void 0 ? void 0 : _newChildren.type) == \"!compare\") {\n newChildren = newChildren[0].children;\n }\n return newChildren;\n };\n if (op == \"and\" || op == \"or\") {\n var children1 = {};\n var vals = convertChildren();\n vals.forEach(function (v) {\n if (v) {\n var id = uuid();\n v.id = id;\n if (v.type != undefined) {\n children1[id] = v;\n } else {\n meta.errors.push(\"Bad item in AND/OR: \".concat(JSON.stringify(v)));\n }\n }\n });\n res = {\n type: \"group\",\n id: uuid(),\n children1: children1,\n properties: {\n conjunction: conv.conjunctions[op],\n not: spel.not\n }\n };\n } else if (opKeys) {\n var _fieldObj$groupFieldV, _convertedArgs, _opConfig;\n var _vals = convertChildren();\n var fieldObj = _vals[0];\n var convertedArgs = _vals.slice(1);\n var groupField = fieldObj === null || fieldObj === void 0 || (_fieldObj$groupFieldV = fieldObj.groupFieldValue) === null || _fieldObj$groupFieldV === void 0 ? void 0 : _fieldObj$groupFieldV.value;\n var opArg = (_convertedArgs = convertedArgs) === null || _convertedArgs === void 0 ? void 0 : _convertedArgs[0];\n var opKey = opKeys[0];\n if (opKeys.length > 1) {\n var _vals$, _vals$2;\n var valueType = ((_vals$ = _vals[0]) === null || _vals$ === void 0 ? void 0 : _vals$.valueType) || ((_vals$2 = _vals[1]) === null || _vals$2 === void 0 ? void 0 : _vals$2.valueType);\n //todo: it's naive, use valueType\n var field = fieldObj === null || fieldObj === void 0 ? void 0 : fieldObj.value;\n var widgets = opKeys.map(function (op) {\n return {\n op: op,\n widget: getWidgetForFieldOp(config, field, op)\n };\n });\n if (op == \"eq\" || op == \"ne\") {\n var ws = widgets.find(function (_ref) {\n var op = _ref.op,\n widget = _ref.widget;\n return widget && widget != \"field\";\n });\n if (ws) {\n opKey = ws.op;\n }\n } else {\n logger.warn(\"[spel] Spel operator \".concat(op, \" can be mapped to \").concat(opKeys, \".\"), \"widgets:\", widgets, \"vals:\", _vals, \"valueType=\", valueType);\n }\n }\n\n // some/all/none\n if (fieldObj !== null && fieldObj !== void 0 && fieldObj.groupFieldValue) {\n if (opArg && opArg.groupFieldValue && opArg.groupFieldValue.valueSrc == \"field\" && opArg.groupFieldValue.value == groupField) {\n // group.?[...].size() == group.size()\n opKey = \"all\";\n convertedArgs = [];\n } else if (opKey == \"equal\" && opArg.valueSrc == \"value\" && opArg.valueType == \"number\" && opArg.value == 0) {\n opKey = \"none\";\n convertedArgs = [];\n } else if (opKey == \"greater\" && opArg.valueSrc == \"value\" && opArg.valueType == \"number\" && opArg.value == 0) {\n opKey = \"some\";\n convertedArgs = [];\n }\n }\n var opConfig = config.operators[opKey];\n var reversedOpConfig = config.operators[(_opConfig = opConfig) === null || _opConfig === void 0 ? void 0 : _opConfig.reversedOp];\n var opNeedsReverse = spel.not && [\"between\"].includes(opKey);\n var opCanReverse = !!reversedOpConfig;\n var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse);\n var needRev = spel.not && canRev || opNeedsReverse;\n if (needRev) {\n opKey = opConfig.reversedOp;\n opConfig = config.operators[opKey];\n spel.not = !spel.not;\n }\n var needWrapWithNot = !!spel.not;\n spel.not = false; // handled with needWrapWithNot\n\n if (!fieldObj) {\n // LHS can't be parsed\n } else if (fieldObj.groupFieldValue) {\n // 1. group\n if (fieldObj.groupFieldValue.valueSrc != \"field\") {\n meta.errors.push(\"Expected group field \".concat(JSON.stringify(fieldObj)));\n }\n res = buildRuleGroup(fieldObj, opKey, convertedArgs, config, meta);\n } else {\n // 2. not group\n if (fieldObj.valueSrc != \"field\" && fieldObj.valueSrc != \"func\") {\n meta.errors.push(\"Expected field/func at LHS, but got \".concat(JSON.stringify(fieldObj)));\n }\n var _field = fieldObj.value;\n res = buildRule(config, meta, _field, opKey, convertedArgs, spel);\n }\n if (needWrapWithNot) {\n if (res.type !== \"group\") {\n res = wrapInDefaultConj(res, config, true);\n } else {\n res.properties.not = !res.properties.not;\n }\n }\n } else {\n if (!parentSpel) {\n // try to parse whole `\"str\" + prop + #var` as ternary\n var convVal = convertCaseValue(spel, conv, config, meta);\n res = buildSimpleSwitch(convVal, conv, config, meta);\n }\n // if (!res) {\n // meta.errors.push(`Can't convert op ${op}`);\n // }\n }\n return res;\n};\nvar _convertArg = function convertArg(spel, conv, config, meta) {\n var _spel$_groupField2, _config$settings$case;\n var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (spel == undefined) return undefined;\n var fieldSeparator = config.settings.fieldSeparator;\n spel._groupField = (_spel$_groupField2 = spel._groupField) !== null && _spel$_groupField2 !== void 0 ? _spel$_groupField2 : parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;\n if (spel.type == \"variable\" || spel.type == \"property\") {\n // normal field\n var field = normalizeField(config, spel.val, spel._groupField);\n var fieldConfig = getFieldConfig(config, field);\n var isVariable = spel.type == \"variable\";\n return {\n valueSrc: \"field\",\n valueType: fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type,\n isVariable: isVariable,\n value: field\n };\n } else if (spel.type == \"compound\") {\n // complex field\n var parts = convertPath(spel.children, meta);\n if (parts) {\n var _spel$children;\n var _field2 = normalizeField(config, parts.join(fieldSeparator), spel._groupField);\n var _fieldConfig = getFieldConfig(config, _field2);\n var _isVariable = ((_spel$children = spel.children) === null || _spel$children === void 0 || (_spel$children = _spel$children[0]) === null || _spel$children === void 0 ? void 0 : _spel$children.type) == \"variable\";\n return {\n valueSrc: \"field\",\n valueType: _fieldConfig === null || _fieldConfig === void 0 ? void 0 : _fieldConfig.type,\n isVariable: _isVariable,\n value: _field2\n };\n } else {\n // it's not complex field\n }\n } else if (SpelPrimitiveTypes[spel.type]) {\n var value = spel.val;\n var valueType = SpelPrimitiveTypes[spel.type];\n if (spel.negative) {\n value = -value;\n }\n return {\n valueSrc: \"value\",\n valueType: valueType,\n value: value\n };\n } else if (spel.type == \"!new\" && SpelPrimitiveClasses[spel.cls.at(-1)]) {\n var args = spel.args.map(function (v) {\n return _convertArg(v, conv, config, meta, spel);\n });\n var _value = args === null || args === void 0 ? void 0 : args[0];\n var _valueType = SpelPrimitiveClasses[spel.cls.at(-1)];\n return _objectSpread(_objectSpread({}, _value), {}, {\n valueType: _valueType\n });\n } else if (spel.type == \"list\") {\n var _values$;\n var values = spel.val.map(function (v) {\n return _convertArg(v, conv, config, meta, spel);\n });\n var _itemType = values.length ? (_values$ = values[0]) === null || _values$ === void 0 ? void 0 : _values$.valueType : null;\n var _value2 = values.map(function (v) {\n return v === null || v === void 0 ? void 0 : v.value;\n });\n var _valueType2 = ListValueType;\n return {\n valueSrc: \"value\",\n valueType: _valueType2,\n value: _value2\n };\n } else if (spel.type === \"op-plus\" && (parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel.type) === \"ternary\" && ((_config$settings$case = config.settings.caseValueField) === null || _config$settings$case === void 0 ? void 0 : _config$settings$case.type) === \"case_value\") {\n /**\n * @deprecated\n */\n return convertCaseValueConcat(spel, conv, config, meta);\n }\n var maybe = convertFunc(spel, conv, config, meta, parentSpel);\n if (maybe !== undefined) {\n return maybe;\n }\n meta.errors.push(\"Can't convert arg of type \".concat(spel.type));\n return undefined;\n};\nexport { _convertArg as convertArg };\nvar convertFunc = function convertFunc(spel, conv, config, meta) {\n var _fsigns$;\n var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n // Build signatures\n var convertFuncArg = function convertFuncArg(v) {\n return _convertToTree(v, conv, config, meta, spel);\n };\n var fsigns = buildFuncSignatures(spel);\n var firstSign = fsigns === null || fsigns === void 0 || (_fsigns$ = fsigns[0]) === null || _fsigns$ === void 0 ? void 0 : _fsigns$.s;\n if (fsigns.length) logger.debug(\"Signatures for \", spel, \":\", firstSign, fsigns);\n\n // 1. Try to parse as value\n var maybeValue = convertFuncToValue(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg);\n if (maybeValue !== undefined) return maybeValue;\n\n // 2. Try to parse as op\n var maybeOp = convertFuncToOp(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg);\n if (maybeOp !== undefined) return maybeOp;\n\n // 3. Try to parse as func\n var funcKey, funcConfig, argsObj;\n // try func signature matching\n var _iterator = _createForOfIteratorHelper(fsigns),\n _step;\n try {\n var _loop = function _loop() {\n var _step$value = _step.value,\n s = _step$value.s,\n params = _step$value.params;\n var funcKeys = conv.funcs[s];\n if (funcKeys) {\n // todo: here we can check arg types, if we have function overloading\n funcKey = funcKeys[0];\n funcConfig = getFuncConfig(config, funcKey);\n var _funcConfig2 = funcConfig,\n spelFunc = _funcConfig2.spelFunc;\n var argsArr = params.map(convertFuncArg);\n var argsOrder = _toConsumableArray(spelFunc.matchAll(/\\${(\\w+)}/g)).map(function (_ref2) {\n var _ref3 = _slicedToArray(_ref2, 2),\n _ = _ref3[0],\n k = _ref3[1];\n return k;\n });\n argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {\n return [argKey, argsArr[i]];\n }));\n return 1; // break\n }\n };\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n if (_loop()) break;\n }\n // try `spelImport`\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n if (!funcKey) {\n var _iterator2 = _createForOfIteratorHelper(iterateFuncs(config)),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _step2$value = _slicedToArray(_step2.value, 2),\n f = _step2$value[0],\n fc = _step2$value[1];\n if (fc.spelImport) {\n var parsed = void 0;\n try {\n parsed = fc.spelImport.call(config.ctx, spel);\n } catch (e) {\n logger.debug(\"Error while using spelImport for \".concat(f), e);\n // can't be parsed\n }\n if (parsed) {\n var _funcConfig;\n funcKey = f;\n funcConfig = getFuncConfig(config, funcKey);\n argsObj = {};\n for (var argKey in parsed) {\n argsObj[argKey] = convertFuncArg(parsed[argKey]);\n }\n\n // Special case to distinct date and datetime\n var isOk = true;\n var funcType = (_funcConfig = funcConfig) === null || _funcConfig === void 0 ? void 0 : _funcConfig.returnType;\n if ([\"date\", \"datetime\"].includes(funcType)) {\n var _funcConfig$args;\n var dateArgsKeys = Object.keys((_funcConfig$args = funcConfig.args) !== null && _funcConfig$args !== void 0 ? _funcConfig$args : []).filter(function (k) {\n return [\"date\", \"datetime\"].includes(funcConfig.args[k].type);\n });\n var _iterator3 = _createForOfIteratorHelper(dateArgsKeys),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var _argsObj$k;\n var k = _step3.value;\n var argConfig = funcConfig.args[k];\n var expectedType = argConfig.type;\n var realType = (_argsObj$k = argsObj[k]) === null || _argsObj$k === void 0 ? void 0 : _argsObj$k.valueType;\n if (realType && realType != expectedType) {\n isOk = false;\n }\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n }\n if (isOk) {\n break;\n }\n }\n }\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n }\n\n // final convert\n if (funcKey) {\n var funcArgs = {};\n for (var _argKey in funcConfig.args) {\n var _argConfig = funcConfig.args[_argKey];\n var argVal = argsObj[_argKey];\n if (argVal === undefined) {\n argVal = _argConfig === null || _argConfig === void 0 ? void 0 : _argConfig.defaultValue;\n if (argVal === undefined) {\n if (_argConfig !== null && _argConfig !== void 0 && _argConfig.isOptional) {\n //ignore\n } else {\n meta.errors.push(\"No value for arg \".concat(_argKey, \" of func \").concat(funcKey));\n return undefined;\n }\n } else {\n var _argVal;\n argVal = {\n value: argVal,\n valueSrc: (_argVal = argVal) !== null && _argVal !== void 0 && _argVal.func ? \"func\" : \"value\",\n valueType: _argConfig.type\n };\n }\n }\n if (argVal) funcArgs[_argKey] = argVal;\n }\n return {\n valueSrc: \"func\",\n value: {\n func: funcKey,\n args: funcArgs\n },\n valueType: funcConfig.returnType\n };\n }\n var methodName = spel.methodName;\n if (methodName) {\n meta.errors.push(\"Signature \".concat(firstSign, \" - failed to convert\"));\n }\n return undefined;\n};\nvar convertFuncToValue = function convertFuncToValue(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg) {\n var errs, foundSign, foundWidget;\n var candidates = [];\n for (var w in config.widgets) {\n var widgetDef = config.widgets[w];\n var spelImportFuncs = widgetDef.spelImportFuncs;\n if (spelImportFuncs) {\n for (var i = 0; i < spelImportFuncs.length; i++) {\n var fj = spelImportFuncs[i];\n if (isObject(fj)) {\n var bag = {};\n if (isJsonCompatible(fj, spel, bag)) {\n for (var k in bag) {\n bag[k] = convertFuncArg(bag[k]);\n }\n candidates.push({\n s: \"widgets.\".concat(w, \".spelImportFuncs[\").concat(i, \"]\"),\n w: w,\n argsObj: bag\n });\n }\n }\n }\n }\n }\n var _iterator4 = _createForOfIteratorHelper(fsigns),\n _step4;\n try {\n for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n var _step4$value = _step4.value,\n _s = _step4$value.s,\n params = _step4$value.params;\n var found = conv.valueFuncs[_s] || [];\n var _iterator5 = _createForOfIteratorHelper(found),\n _step5;\n try {\n var _loop2 = function _loop2() {\n var _step5$value = _step5.value,\n w = _step5$value.w,\n argsOrder = _step5$value.argsOrder;\n var argsArr = params.map(convertFuncArg);\n var argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {\n return [argKey, argsArr[i]];\n }));\n candidates.push({\n s: _s,\n w: w,\n argsObj: argsObj\n });\n };\n for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n _loop2();\n }\n } catch (err) {\n _iterator5.e(err);\n } finally {\n _iterator5.f();\n }\n }\n } catch (err) {\n _iterator4.e(err);\n } finally {\n _iterator4.f();\n }\n for (var _i = 0, _candidates = candidates; _i < _candidates.length; _i++) {\n var _candidates$_i = _candidates[_i],\n s = _candidates$_i.s,\n _w = _candidates$_i.w,\n argsObj = _candidates$_i.argsObj;\n var _widgetDef = config.widgets[_w];\n var spelImportValue = _widgetDef.spelImportValue,\n type = _widgetDef.type;\n foundWidget = _w;\n foundSign = s;\n errs = [];\n for (var _k in argsObj) {\n if (![\"value\"].includes(argsObj[_k].valueSrc)) {\n errs.push(\"\".concat(_k, \" has unsupported value src \").concat(argsObj[_k].valueSrc));\n }\n }\n var value = argsObj.v.value;\n if (spelImportValue && !errs.length) {\n var _spelImportValue$call = spelImportValue.call(config.ctx, argsObj.v, _widgetDef, argsObj);\n var _spelImportValue$call2 = _slicedToArray(_spelImportValue$call, 2);\n value = _spelImportValue$call2[0];\n errs = _spelImportValue$call2[1];\n if (errs && !Array.isArray(errs)) errs = [errs];\n }\n if (!errs.length) {\n return {\n valueSrc: \"value\",\n valueType: type,\n value: value\n };\n }\n }\n if (foundWidget && errs.length) {\n meta.errors.push(\"Signature \".concat(foundSign, \" - looks like convertable to \").concat(foundWidget, \", but: \").concat(errs.join(\"; \")));\n }\n return undefined;\n};\nvar convertFuncToOp = function convertFuncToOp(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg) {\n var candidates = [];\n var _iterator6 = _createForOfIteratorHelper(fsigns),\n _step6;\n try {\n for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n var _step6$value = _step6.value,\n s = _step6$value.s,\n params = _step6$value.params;\n var found = conv.opFuncs[s] || [];\n var _iterator7 = _createForOfIteratorHelper(found),\n _step7;\n try {\n var _loop4 = function _loop4() {\n var _argsArr$filter;\n var _step7$value = _step7.value,\n op = _step7$value.op,\n argsOrder = _step7$value.argsOrder;\n var argsArr = params.map(convertFuncArg);\n var errs = [];\n if (op === \"!compare\") {\n if (parentSpel.type.startsWith(\"op-\") && parentSpel.children.length == 2 && parentSpel.children[1].type == \"number\" && parentSpel.children[1].val === 0) {\n return {\n v: {\n type: \"!compare\",\n children: argsArr\n }\n };\n } else {\n errs.push(\"Result of compareTo() should be compared to 0\");\n }\n }\n var opDef = config.operators[op];\n var valueTypes = opDef.valueTypes;\n var argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {\n return [argKey, argsArr[i]];\n }));\n var field = argsObj[\"0\"];\n var convertedArgs = Object.keys(argsObj).filter(function (k) {\n return parseInt(k) > 0;\n }).map(function (k) {\n return argsObj[k];\n });\n var valueType = (_argsArr$filter = argsArr.filter(function (a) {\n return !!a && a !== field;\n })) === null || _argsArr$filter === void 0 || (_argsArr$filter = _argsArr$filter[0]) === null || _argsArr$filter === void 0 ? void 0 : _argsArr$filter.valueType;\n if (valueTypes && valueType && !valueTypes.includes(valueType)) {\n errs.push(\"Op supports types \".concat(valueTypes, \", but got \").concat(valueType));\n }\n candidates.push({\n opKey: op,\n foundSign: s,\n field: field,\n convertedArgs: convertedArgs,\n errs: errs\n });\n },\n _ret;\n for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {\n _ret = _loop4();\n if (_ret) return _ret.v;\n }\n } catch (err) {\n _iterator7.e(err);\n } finally {\n _iterator7.f();\n }\n }\n } catch (err) {\n _iterator6.e(err);\n } finally {\n _iterator6.f();\n }\n for (var op in config.operators) {\n var opDef = config.operators[op];\n var spelImportFuncs = opDef.spelImportFuncs,\n valueTypes = opDef.valueTypes;\n if (spelImportFuncs) {\n var _loop3 = function _loop3() {\n var fj = spelImportFuncs[i];\n if (isObject(fj)) {\n var argsObj = {};\n if (isJsonCompatible(fj, spel, argsObj)) {\n var _argsObj$;\n var errs = [];\n for (var k in argsObj) {\n argsObj[k] = convertFuncArg(argsObj[k]);\n }\n var field = argsObj[\"0\"];\n var convertedArgs = Object.keys(argsObj).filter(function (k) {\n return parseInt(k) > 0;\n }).map(function (k) {\n return argsObj[k];\n });\n var valueType = (_argsObj$ = argsObj[\"1\"]) === null || _argsObj$ === void 0 ? void 0 : _argsObj$.valueType;\n if (valueTypes && valueType && !valueTypes.includes(valueType)) {\n errs.push(\"Op supports types \".concat(valueTypes, \", but got \").concat(valueType));\n }\n candidates.push({\n opKey: op,\n foundSign: \"spelImportFuncs[\".concat(i, \"]\"),\n field: field,\n convertedArgs: convertedArgs,\n errs: errs\n });\n }\n }\n };\n for (var i = 0; i < spelImportFuncs.length; i++) {\n _loop3();\n }\n }\n }\n var bestCandidate = candidates.find(function (_ref4) {\n var errs = _ref4.errs;\n return !errs.length;\n });\n if (bestCandidate) {\n var opKey = bestCandidate.opKey,\n foundSign = bestCandidate.foundSign,\n field = bestCandidate.field,\n convertedArgs = bestCandidate.convertedArgs,\n errs = bestCandidate.errs;\n return buildRule(config, meta, field, opKey, convertedArgs, spel);\n } else if (candidates.length) {\n var allErrs = candidates.map(function (_ref5) {\n var foundSign = _ref5.foundSign,\n opKey = _ref5.opKey,\n errs = _ref5.errs;\n return \"Looks like convertable to \".concat(opKey, \" with signature \").concat(foundSign, \", but: \").concat(errs.join(\"; \"));\n }).join(\". \");\n meta.errors.push(allErrs);\n }\n return undefined;\n};\nvar compareArgs = function compareArgs(left, right, spel, conv, config, meta) {\n if (left.type == right.type) {\n if (left.type == \"!aggr\") {\n var _map = [left.source, right.source].map(function (v) {\n return _convertArg(v, conv, config, meta, spel);\n }),\n _map2 = _slicedToArray(_map, 2),\n leftSource = _map2[0],\n rightSource = _map2[1];\n //todo: check same filter\n return leftSource.value == rightSource.value;\n } else {\n var _map3 = [left, right].map(function (v) {\n return _convertArg(v, conv, config, meta, spel);\n }),\n _map4 = _slicedToArray(_map3, 2),\n leftVal = _map4[0],\n rightVal = _map4[1];\n return leftVal.value == rightVal.value;\n }\n }\n return false;\n};\nexport var convertCaseValue = function convertCaseValue(val, conv, config, meta) {\n var _config$settings$case2;\n var spel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var convVal;\n if ((val === null || val === void 0 ? void 0 : val.type) === \"op-plus\" && ((_config$settings$case2 = config.settings.caseValueField) === null || _config$settings$case2 === void 0 ? void 0 : _config$settings$case2.type) === \"case_value\") {\n /**\n * @deprecated\n */\n convVal = convertCaseValueConcat(val, conv, config, meta);\n } else {\n convVal = _convertArg(val, conv, config, meta, spel);\n }\n return convVal;\n};\n\n/**\n * @deprecated\n */\nexport var convertCaseValueConcat = function convertCaseValueConcat(spel, conv, config, meta) {\n var flat = [];\n function _processConcatChildren(children) {\n children.map(function (child) {\n if (child.type === \"op-plus\") {\n _processConcatChildren(child.children);\n } else {\n var convertedChild = _convertArg(child, conv, config, meta, spel);\n if (convertedChild) {\n flat.push(convertedChild);\n } else {\n meta.errors.push(\"Can't convert \".concat(child.type, \" in concatenation\"));\n }\n }\n });\n }\n _processConcatChildren(spel.children);\n return {\n valueSrc: \"value\",\n valueType: \"case_value\",\n value: flat\n };\n};","import { SpelExpressionEvaluator } from \"spel2js\";\nimport { loadTree } from \"../tree\";\nimport { buildConv } from \"./conv\";\nimport { convertToTree } from \"./convert\";\nimport { postprocessCompiled } from \"./postprocess\";\nimport { wrapInDefaultConj } from \"./builder\";\nimport * as Utils from \"../../utils\";\nvar logger = Utils.OtherUtils.logger;\nvar extendConfig = Utils.ConfigUtils.extendConfig;\n\n// https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/expressions.html#expressions\n\nexport var loadFromSpel = function loadFromSpel(spelStr, config) {\n return _loadFromSpel(spelStr, config, true);\n};\nexport var _loadFromSpel = function _loadFromSpel(spelStr, config) {\n var returnErrors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n //meta is mutable\n var meta = {\n errors: []\n };\n var extendedConfig = extendConfig(config, undefined, false);\n var conv = buildConv(extendedConfig);\n var compiledExpression;\n var convertedObj;\n var jsTree = undefined;\n try {\n var compileRes = SpelExpressionEvaluator.compile(spelStr);\n compiledExpression = compileRes._compiledExpression;\n } catch (e) {\n meta.errors.push(e);\n }\n if (compiledExpression) {\n //logger.debug(\"compiledExpression:\", compiledExpression);\n convertedObj = postprocessCompiled(compiledExpression, meta);\n logger.debug(\"convertedObj:\", convertedObj, meta);\n jsTree = convertToTree(convertedObj, conv, extendedConfig, meta);\n if (jsTree && jsTree.type != \"group\" && jsTree.type != \"switch_group\") {\n jsTree = wrapInDefaultConj(jsTree, extendedConfig, convertedObj[\"not\"]);\n }\n logger.debug(\"jsTree:\", jsTree);\n }\n var immTree = jsTree ? loadTree(jsTree) : undefined;\n if (returnErrors) {\n return [immTree, meta.errors];\n } else {\n if (meta.errors.length) console.warn(\"Errors while importing from SpEL:\", meta.errors);\n return immTree;\n }\n};","import moment from \"moment\";\nimport { SqlString, sqlEmptyValue, stringifyForDisplay, wrapWithBrackets } from \"../utils/export\";\nimport { mongoEmptyValue, mongoFormatOp1, mongoFormatOp2 } from \"../utils/mongoUtils\";\nimport { spelFixList, spelEscape } from \"../utils/spelUtils\";\nimport { escapeRegExp } from \"../utils/stuff\";\nimport { getTitleInListValues } from \"../utils/listValues\";\nvar ctx = {\n utils: {\n SqlString: SqlString,\n moment: moment,\n mongoFormatOp1: mongoFormatOp1,\n mongoFormatOp2: mongoFormatOp2,\n mongoEmptyValue: mongoEmptyValue,\n escapeRegExp: escapeRegExp,\n sqlEmptyValue: sqlEmptyValue,\n stringifyForDisplay: stringifyForDisplay,\n getTitleInListValues: getTitleInListValues,\n spelEscape: spelEscape,\n spelFixList: spelFixList,\n wrapWithBrackets: wrapWithBrackets\n }\n};\nexport default ctx;","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { settings as defaultSettings } from \"./default\";\nimport ctx from \"./ctx\";\n\n//---------------------------- conjunctions\n\nvar conjunctions = {\n AND: {\n label: \"And\",\n mongoConj: \"$and\",\n jsonLogicConj: \"and\",\n sqlConj: \"AND\",\n spelConj: \"and\",\n spelConjs: [\"and\", \"&&\"],\n reversedConj: \"OR\",\n formatConj: function formatConj(children, conj, not, isForDisplay) {\n var ret = children.size > 1 ? children.join(\" \" + (isForDisplay ? \"AND\" : \"&&\") + \" \") : children.first();\n if (children.size > 1 || not) {\n ret = this.utils.wrapWithBrackets(ret);\n }\n if (not) {\n ret = \"NOT \" + ret;\n }\n return ret;\n },\n sqlFormatConj: function sqlFormatConj(children, conj, not) {\n var ret = children.size > 1 ? children.join(\" \" + \"AND\" + \" \") : children.first();\n if (children.size > 1 || not) {\n ret = this.utils.wrapWithBrackets(ret);\n }\n if (not) {\n ret = \"NOT \" + ret;\n }\n return ret;\n },\n spelFormatConj: function spelFormatConj(children, conj, not, omitBrackets) {\n if (not) omitBrackets = false;\n var ret = children.size > 1 ? children.join(\" \" + \"&&\" + \" \") : children.first();\n if ((children.size > 1 || not) && !omitBrackets) {\n ret = this.utils.wrapWithBrackets(ret);\n }\n if (not) {\n ret = \"!\" + ret;\n }\n return ret;\n }\n },\n OR: {\n label: \"Or\",\n mongoConj: \"$or\",\n jsonLogicConj: \"or\",\n sqlConj: \"OR\",\n spelConj: \"or\",\n spelConjs: [\"or\", \"||\"],\n reversedConj: \"AND\",\n formatConj: function formatConj(children, conj, not, isForDisplay) {\n return children.size > 1 ? (not ? \"NOT \" : \"\") + \"(\" + children.join(\" \" + (isForDisplay ? \"OR\" : \"||\") + \" \") + \")\" : (not ? \"NOT (\" : \"\") + children.first() + (not ? \")\" : \"\");\n },\n sqlFormatConj: function sqlFormatConj(children, conj, not) {\n var ret = children.size > 1 ? children.join(\" \" + \"OR\" + \" \") : children.first();\n if (children.size > 1 || not) {\n ret = this.utils.wrapWithBrackets(ret);\n }\n if (not) {\n ret = \"NOT \" + ret;\n }\n return ret;\n },\n spelFormatConj: function spelFormatConj(children, conj, not, omitBrackets) {\n if (not) omitBrackets = false;\n return children.size > 1 ? (not ? \"!\" : \"\") + (omitBrackets ? \"\" : \"(\") + children.join(\" \" + \"||\" + \" \") + (omitBrackets ? \"\" : \")\") : (not ? \"!(\" : \"\") + children.first() + (not ? \")\" : \"\");\n }\n }\n};\n\n//---------------------------- operators\n\nvar operators = {\n equal: {\n label: \"==\",\n labelForFormat: \"==\",\n sqlOp: \"=\",\n spelOp: \"==\",\n spelOps: [\"==\", \"eq\"],\n reversedOp: \"not_equal\",\n formatOp: function formatOp(field, op, value, valueSrcs, valueTypes, opDef, operatorOptions, isForDisplay, fieldDef) {\n var opStr = isForDisplay ? \"=\" : opDef.label;\n if (valueTypes == \"boolean\" && isForDisplay) return value == \"No\" ? \"NOT \".concat(field) : \"\".concat(field);else return \"\".concat(field, \" \").concat(opStr, \" \").concat(value);\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils;\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n return (_this$utils = this.utils).mongoFormatOp1.apply(_this$utils, [\"$eq\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic2: \"==\",\n jsonLogicOps: [\"==\", \"datetime==\", \"date==\"],\n jsonLogic: function jsonLogic(field, op, val, _opDef, _opOpts, _fieldDef, expectedType, settings) {\n if (settings !== null && settings !== void 0 && settings.fixJsonLogicDateCompareOp && [\"date\", \"datetime\"].includes(expectedType)) {\n return _defineProperty({}, \"\".concat(expectedType, \"==\"), [field, val]);\n }\n return {\n \"==\": [field, val]\n };\n },\n elasticSearchQueryType: \"term\"\n },\n not_equal: {\n isNotOp: true,\n label: \"!=\",\n labelForFormat: \"!=\",\n sqlOp: \"<>\",\n sqlOps: [\"<>\", \"!=\"],\n spelOp: \"!=\",\n spelOps: [\"!=\", \"ne\"],\n reversedOp: \"equal\",\n formatOp: function formatOp(field, op, value, valueSrcs, valueTypes, opDef, operatorOptions, isForDisplay, fieldDef) {\n if (valueTypes == \"boolean\" && isForDisplay) return value == \"No\" ? \"\".concat(field) : \"NOT \".concat(field);else return \"\".concat(field, \" \").concat(opDef.label, \" \").concat(value);\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils2;\n for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n return (_this$utils2 = this.utils).mongoFormatOp1.apply(_this$utils2, [\"$ne\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic2: \"!=\",\n jsonLogicOps: [\"!=\", \"datetime!=\", \"date!=\"],\n jsonLogic: function jsonLogic(field, op, val, _opDef, _opOpts, _fieldDef, expectedType, settings) {\n if (settings !== null && settings !== void 0 && settings.fixJsonLogicDateCompareOp && [\"date\", \"datetime\"].includes(expectedType)) {\n return _defineProperty({}, \"\".concat(expectedType, \"!=\"), [field, val]);\n }\n return {\n \"!=\": [field, val]\n };\n }\n },\n less: {\n label: \"<\",\n labelForFormat: \"<\",\n sqlOp: \"<\",\n spelOp: \"<\",\n spelOps: [\"<\", \"lt\"],\n reversedOp: \"greater_or_equal\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils3;\n for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n args[_key3] = arguments[_key3];\n }\n return (_this$utils3 = this.utils).mongoFormatOp1.apply(_this$utils3, [\"$lt\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic: \"<\",\n elasticSearchQueryType: \"range\"\n },\n less_or_equal: {\n label: \"<=\",\n labelForFormat: \"<=\",\n sqlOp: \"<=\",\n spelOp: \"<=\",\n spelOps: [\"<=\", \"le\"],\n reversedOp: \"greater\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils4;\n for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n args[_key4] = arguments[_key4];\n }\n return (_this$utils4 = this.utils).mongoFormatOp1.apply(_this$utils4, [\"$lte\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic: \"<=\",\n elasticSearchQueryType: \"range\"\n },\n greater: {\n label: \">\",\n labelForFormat: \">\",\n sqlOp: \">\",\n spelOp: \">\",\n spelOps: [\">\", \"gt\"],\n reversedOp: \"less_or_equal\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils5;\n for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n args[_key5] = arguments[_key5];\n }\n return (_this$utils5 = this.utils).mongoFormatOp1.apply(_this$utils5, [\"$gt\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic: \">\",\n elasticSearchQueryType: \"range\"\n },\n greater_or_equal: {\n label: \">=\",\n labelForFormat: \">=\",\n sqlOp: \">=\",\n spelOp: \">=\",\n spelOps: [\">=\", \"ge\"],\n reversedOp: \"less\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils6;\n for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n args[_key6] = arguments[_key6];\n }\n return (_this$utils6 = this.utils).mongoFormatOp1.apply(_this$utils6, [\"$gte\", function (v) {\n return v;\n }, false].concat(args));\n },\n jsonLogic: \">=\",\n elasticSearchQueryType: \"range\"\n },\n like: {\n label: \"Contains\",\n labelForFormat: \"Contains\",\n reversedOp: \"not_like\",\n sqlOp: \"LIKE\",\n // tip: this function covers import of 3 operators\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) == \"LIKE\" || (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) == \"NOT LIKE\") {\n var _right$valueType;\n var not = (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) == \"NOT LIKE\";\n var _ref3 = sqlObj.children || [],\n _ref4 = _slicedToArray(_ref3, 2),\n _left = _ref4[0],\n right = _ref4[1];\n if (right !== null && right !== void 0 && (_right$valueType = right.valueType) !== null && _right$valueType !== void 0 && _right$valueType.endsWith(\"_quote_string\")) {\n if (right !== null && right !== void 0 && right.value.startsWith(\"%\") && right !== null && right !== void 0 && right.value.endsWith(\"%\")) {\n right.value = this.utils.SqlString.unescapeLike(right.value.substring(1, right.value.length - 1), sqlDialect);\n sqlObj.operator = not ? \"not_like\" : \"like\";\n return sqlObj;\n } else if (right !== null && right !== void 0 && right.value.startsWith(\"%\")) {\n right.value = this.utils.SqlString.unescapeLike(right.value.substring(1), sqlDialect);\n sqlObj.operator = \"ends_with\";\n return sqlObj;\n } else if (right !== null && right !== void 0 && right.value.endsWith(\"%\")) {\n right.value = this.utils.SqlString.unescapeLike(right.value.substring(0, right.value.length - 1), sqlDialect);\n sqlObj.operator = \"starts_with\";\n return sqlObj;\n }\n }\n }\n },\n spelOp: \"${0}.contains(${1})\",\n valueTypes: [\"text\"],\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils7,\n _this = this;\n for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {\n args[_key7] = arguments[_key7];\n }\n return (_this$utils7 = this.utils).mongoFormatOp1.apply(_this$utils7, [\"$regex\", function (v) {\n return typeof v == \"string\" ? _this.utils.escapeRegExp(v) : undefined;\n }, false].concat(args));\n },\n jsonLogic: function jsonLogic(field, op, val) {\n return {\n \"in\": [val, field]\n };\n },\n jsonLogic2: \"#in\",\n valueSources: [\"value\"],\n elasticSearchQueryType: \"regexp\"\n },\n not_like: {\n isNotOp: true,\n label: \"Not contains\",\n reversedOp: \"like\",\n labelForFormat: \"Not Contains\",\n sqlOp: \"NOT LIKE\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils8,\n _this2 = this;\n for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {\n args[_key8] = arguments[_key8];\n }\n return (_this$utils8 = this.utils).mongoFormatOp1.apply(_this$utils8, [\"$regex\", function (v) {\n return typeof v == \"string\" ? _this2.utils.escapeRegExp(v) : undefined;\n }, true].concat(args));\n },\n jsonLogic: function jsonLogic(field, op, val) {\n return {\n \"!\": {\n \"in\": [val, field]\n }\n };\n },\n jsonLogic2: \"#!in\",\n _jsonLogicIsExclamationOp: true,\n valueSources: [\"value\"]\n },\n starts_with: {\n label: \"Starts with\",\n labelForFormat: \"Starts with\",\n sqlOp: \"LIKE\",\n spelOp: \"${0}.startsWith(${1})\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils9,\n _this3 = this;\n for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {\n args[_key9] = arguments[_key9];\n }\n return (_this$utils9 = this.utils).mongoFormatOp1.apply(_this$utils9, [\"$regex\", function (v) {\n return typeof v == \"string\" ? \"^\" + _this3.utils.escapeRegExp(v) : undefined;\n }, false].concat(args));\n },\n jsonLogic: undefined,\n // not supported\n valueSources: [\"value\"]\n },\n ends_with: {\n label: \"Ends with\",\n labelForFormat: \"Ends with\",\n sqlOp: \"LIKE\",\n spelOp: \"${0}.endsWith(${1})\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils10,\n _this4 = this;\n for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {\n args[_key10] = arguments[_key10];\n }\n return (_this$utils10 = this.utils).mongoFormatOp1.apply(_this$utils10, [\"$regex\", function (v) {\n return typeof v == \"string\" ? _this4.utils.escapeRegExp(v) + \"$\" : undefined;\n }, false].concat(args));\n },\n jsonLogic: undefined,\n // not supported\n valueSources: [\"value\"]\n },\n between: {\n label: \"Between\",\n labelForFormat: \"BETWEEN\",\n sqlOp: \"BETWEEN\",\n cardinality: 2,\n formatOp: function formatOp(field, op, values, valueSrcs, valueTypes, opDef, operatorOptions, isForDisplay) {\n var valFrom = values.first();\n var valTo = values.get(1);\n if (isForDisplay) return \"\".concat(field, \" BETWEEN \").concat(valFrom, \" AND \").concat(valTo);else return \"\".concat(field, \" >= \").concat(valFrom, \" && \").concat(field, \" <= \").concat(valTo);\n },\n // tip: this op can be imported from SpEL manually without using config\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n var valFrom = values[0];\n var valTo = values[1];\n return \"(\".concat(field, \" >= \").concat(valFrom, \" && \").concat(field, \" <= \").concat(valTo, \")\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils11;\n for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {\n args[_key11] = arguments[_key11];\n }\n return (_this$utils11 = this.utils).mongoFormatOp2.apply(_this$utils11, [[\"$gte\", \"$lte\"], false].concat(args));\n },\n valueLabels: [\"Value from\", \"Value to\"],\n textSeparators: [null, \"and\"],\n reversedOp: \"not_between\",\n jsonLogic: \"<=\",\n validateValues: function validateValues(values) {\n if (values[0] != undefined && values[1] != undefined) {\n return values[0] <= values[1];\n }\n return null;\n },\n elasticSearchQueryType: function elasticSearchQueryType(type) {\n return type === \"time\" ? \"filter\" : \"range\";\n }\n },\n not_between: {\n isNotOp: true,\n label: \"Not between\",\n labelForFormat: \"NOT BETWEEN\",\n sqlOp: \"NOT BETWEEN\",\n cardinality: 2,\n formatOp: function formatOp(field, op, values, valueSrcs, valueTypes, opDef, operatorOptions, isForDisplay) {\n var valFrom = values.first();\n var valTo = values.get(1);\n if (isForDisplay) return \"\".concat(field, \" NOT BETWEEN \").concat(valFrom, \" AND \").concat(valTo);else return \"(\".concat(field, \" < \").concat(valFrom, \" || \").concat(field, \" > \").concat(valTo, \")\");\n },\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n var valFrom = values[0];\n var valTo = values[1];\n return \"(\".concat(field, \" < \").concat(valFrom, \" || \").concat(field, \" > \").concat(valTo, \")\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils12;\n for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {\n args[_key12] = arguments[_key12];\n }\n return (_this$utils12 = this.utils).mongoFormatOp2.apply(_this$utils12, [[\"$gte\", \"$lte\"], true].concat(args));\n },\n valueLabels: [\"Value from\", \"Value to\"],\n textSeparators: [null, \"and\"],\n reversedOp: \"between\",\n jsonLogic: function jsonLogic(field, op, val) {\n return {\n \"!\": {\n \"<=\": [Array.isArray(val) ? val[0] : val, field, Array.isArray(val) ? val[1] : val]\n }\n };\n },\n jsonLogic2: \"!<=\",\n _jsonLogicIsExclamationOp: true,\n validateValues: function validateValues(values) {\n if (values[0] != undefined && values[1] != undefined) {\n return values[0] <= values[1];\n }\n return null;\n }\n },\n is_empty: {\n label: \"Is empty\",\n labelForFormat: \"IS EMPTY\",\n cardinality: 0,\n reversedOp: \"is_not_empty\",\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return isForDisplay ? \"\".concat(field, \" IS EMPTY\") : \"!\".concat(field);\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var empty = this.utils.sqlEmptyValue(fieldDef);\n return \"COALESCE(\".concat(field, \", \").concat(empty, \") = \").concat(empty);\n },\n // tip: this function covers import of 2 operators\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"=\" || (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"<>\") {\n var _left$children;\n var _ref5 = sqlObj.children || [],\n _ref6 = _slicedToArray(_ref5, 2),\n left = _ref6[0],\n right = _ref6[1];\n if ((right === null || right === void 0 ? void 0 : right.value) === \"\" && (left === null || left === void 0 ? void 0 : left.func) === \"COALESCE\" && (left === null || left === void 0 || (_left$children = left.children) === null || _left$children === void 0 || (_left$children = _left$children[1]) === null || _left$children === void 0 ? void 0 : _left$children.value) === \"\") {\n sqlObj.operator = (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"=\" ? \"is_empty\" : \"is_not_empty\";\n sqlObj.children = [left.children[0]];\n return sqlObj;\n }\n }\n },\n // tip: this op can be imported from SpEL manually without using config\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n //tip: is empty or null\n return \"\".concat(field, \" <= ''\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils13,\n _this5 = this;\n for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {\n args[_key13] = arguments[_key13];\n }\n return (_this$utils13 = this.utils).mongoFormatOp1.apply(_this$utils13, [\"$in\", function (v, fieldDef) {\n return [_this5.utils.mongoEmptyValue(fieldDef), null];\n }, false].concat(args));\n },\n jsonLogic: \"!\"\n },\n is_not_empty: {\n isNotOp: true,\n label: \"Is not empty\",\n labelForFormat: \"IS NOT EMPTY\",\n cardinality: 0,\n reversedOp: \"is_empty\",\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return isForDisplay ? \"\".concat(field, \" IS NOT EMPTY\") : \"!!\".concat(field);\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var empty = this.utils.sqlEmptyValue(fieldDef);\n return \"COALESCE(\".concat(field, \", \").concat(empty, \") <> \").concat(empty);\n },\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n //tip: is not empty and not null\n return \"\".concat(field, \" > ''\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils14,\n _this6 = this;\n for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {\n args[_key14] = arguments[_key14];\n }\n return (_this$utils14 = this.utils).mongoFormatOp1.apply(_this$utils14, [\"$nin\", function (v, fieldDef) {\n return [_this6.utils.mongoEmptyValue(fieldDef), null];\n }, false].concat(args));\n },\n jsonLogic: \"!!\",\n elasticSearchQueryType: \"exists\"\n },\n is_null: {\n label: \"Is null\",\n labelForFormat: \"IS NULL\",\n sqlOp: \"IS NULL\",\n // tip: this function covers import of 2 operators\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"IS\" || (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"IS NOT\") {\n var _ref7 = sqlObj.children || [],\n _ref8 = _slicedToArray(_ref7, 2),\n left = _ref8[0],\n right = _ref8[1];\n if ((right === null || right === void 0 ? void 0 : right.valueType) == \"null\") {\n sqlObj.operator = (sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.operator) === \"IS\" ? \"is_null\" : \"is_not_null\";\n sqlObj.value = left;\n return sqlObj;\n }\n }\n },\n cardinality: 0,\n reversedOp: \"is_not_null\",\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return isForDisplay ? \"\".concat(field, \" IS NULL\") : \"!\".concat(field);\n },\n // tip: this op can be imported from SpEL manually without using config\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" == null\");\n },\n // check if value is null OR not exists\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils15;\n for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {\n args[_key15] = arguments[_key15];\n }\n return (_this$utils15 = this.utils).mongoFormatOp1.apply(_this$utils15, [\"$eq\", function (v) {\n return null;\n }, false].concat(args));\n },\n jsonLogic: \"==\"\n },\n is_not_null: {\n label: \"Is not null\",\n labelForFormat: \"IS NOT NULL\",\n sqlOp: \"IS NOT NULL\",\n cardinality: 0,\n reversedOp: \"is_null\",\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return isForDisplay ? \"\".concat(field, \" IS NOT NULL\") : \"!!\".concat(field);\n },\n spelFormatOp: function spelFormatOp(field, op, values, valueSrc, valueTypes, opDef, operatorOptions, fieldDef) {\n return \"\".concat(field, \" != null\");\n },\n // check if value exists and is not null\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils16;\n for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {\n args[_key16] = arguments[_key16];\n }\n return (_this$utils16 = this.utils).mongoFormatOp1.apply(_this$utils16, [\"$ne\", function (v) {\n return null;\n }, false].concat(args));\n },\n jsonLogic: \"!=\",\n elasticSearchQueryType: \"exists\"\n },\n select_equals: {\n label: \"==\",\n labelForFormat: \"==\",\n sqlOp: \"=\",\n // enum/set\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n var opStr = isForDisplay ? \"=\" : \"==\";\n return \"\".concat(field, \" \").concat(opStr, \" \").concat(value);\n },\n spelOp: \"==\",\n spelOps: [\"==\", \"eq\"],\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils17;\n for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {\n args[_key17] = arguments[_key17];\n }\n return (_this$utils17 = this.utils).mongoFormatOp1.apply(_this$utils17, [\"$eq\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"select_not_equals\",\n jsonLogic: \"==\",\n elasticSearchQueryType: \"term\"\n },\n select_not_equals: {\n isNotOp: true,\n label: \"!=\",\n labelForFormat: \"!=\",\n sqlOp: \"<>\",\n // enum/set\n sqlOps: [\"<>\", \"!=\"],\n formatOp: function formatOp(field, op, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n return \"\".concat(field, \" != \").concat(value);\n },\n spelOp: \"!=\",\n spelOps: [\"!=\", \"ne\"],\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils18;\n for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {\n args[_key18] = arguments[_key18];\n }\n return (_this$utils18 = this.utils).mongoFormatOp1.apply(_this$utils18, [\"$ne\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"select_equals\",\n jsonLogic: \"!=\"\n },\n select_any_in: {\n label: \"Any in\",\n labelForFormat: \"IN\",\n sqlOp: \"IN\",\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (valueSrc == \"value\") return \"\".concat(field, \" IN (\").concat(values.join(\", \"), \")\");else return \"\".concat(field, \" IN (\").concat(values, \")\");\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n if (valueSrc == \"value\") {\n return \"\".concat(field, \" IN (\").concat(values.join(\", \"), \")\");\n } else return undefined; // not supported\n },\n valueTypes: [\"multiselect\"],\n spelOp: \"${1}.contains(${0})\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils19;\n for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {\n args[_key19] = arguments[_key19];\n }\n return (_this$utils19 = this.utils).mongoFormatOp1.apply(_this$utils19, [\"$in\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"select_not_any_in\",\n jsonLogic: \"in\",\n elasticSearchQueryType: \"term\"\n },\n select_not_any_in: {\n isNotOp: true,\n label: \"Not in\",\n labelForFormat: \"NOT IN\",\n sqlOp: \"NOT IN\",\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (valueSrc == \"value\") return \"\".concat(field, \" NOT IN (\").concat(values.join(\", \"), \")\");else return \"\".concat(field, \" NOT IN (\").concat(values, \")\");\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n if (valueSrc == \"value\") {\n return \"\".concat(field, \" NOT IN (\").concat(values.join(\", \"), \")\");\n } else return undefined; // not supported\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils20;\n for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {\n args[_key20] = arguments[_key20];\n }\n return (_this$utils20 = this.utils).mongoFormatOp1.apply(_this$utils20, [\"$nin\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"select_any_in\",\n jsonLogic: function jsonLogic(field, op, val) {\n return {\n \"!\": {\n \"in\": [field, val]\n }\n };\n },\n jsonLogic2: \"!in\",\n _jsonLogicIsExclamationOp: true\n },\n // it's not \"contains all\", but \"contains any\" operator\n multiselect_contains: {\n label: \"Contains\",\n labelForFormat: \"CONTAINS\",\n valueTypes: [\"multiselect\"],\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (valueSrc == \"value\") return \"\".concat(field, \" CONTAINS [\").concat(values.join(\", \"), \"]\");else return \"\".concat(field, \" CONTAINS \").concat(values);\n },\n reversedOp: \"multiselect_not_contains\",\n jsonLogic2: \"some-in\",\n jsonLogic: function jsonLogic(field, op, vals) {\n return {\n \"some\": [field, {\n \"in\": [{\n \"var\": \"\"\n }, vals]\n }]\n };\n },\n //spelOp: \"${0}.containsAll(${1})\",\n spelOp: \"T(CollectionUtils).containsAny(${0}, ${1})\",\n spelImportFuncs: [\n // just for backward compatibility (issue #1007)\n {\n obj: {\n type: \"property\",\n val: \"CollectionUtils\"\n },\n methodName: \"containsAny\",\n args: [{\n \"var\": \"0\"\n }, {\n \"var\": \"1\"\n }]\n }],\n elasticSearchQueryType: \"term\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils21;\n for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {\n args[_key21] = arguments[_key21];\n }\n return (_this$utils21 = this.utils).mongoFormatOp1.apply(_this$utils21, [\"$in\", function (v) {\n return v;\n }, false].concat(args));\n }\n },\n multiselect_not_contains: {\n isNotOp: true,\n label: \"Not contains\",\n labelForFormat: \"NOT CONTAINS\",\n valueTypes: [\"multiselect\"],\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (valueSrc == \"value\") return \"\".concat(field, \" NOT CONTAINS [\").concat(values.join(\", \"), \"]\");else return \"\".concat(field, \" NOT CONTAINS \").concat(values);\n },\n reversedOp: \"multiselect_contains\",\n jsonLogic2: \"!some-in\",\n jsonLogic: function jsonLogic(field, op, vals) {\n return {\n \"!\": {\n \"some\": [field, {\n \"in\": [{\n \"var\": \"\"\n }, vals]\n }]\n }\n };\n },\n _jsonLogicIsExclamationOp: true\n },\n multiselect_equals: {\n label: \"Equals\",\n labelForFormat: \"==\",\n sqlOp: \"=\",\n valueTypes: [\"multiselect\"],\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n var opStr = isForDisplay ? \"=\" : \"==\";\n if (valueSrc == \"value\") return \"\".concat(field, \" \").concat(opStr, \" [\").concat(values.join(\", \"), \"]\");else return \"\".concat(field, \" \").concat(opStr, \" \").concat(values);\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var _this7 = this;\n if (valueSrc == \"value\")\n // set\n return \"\".concat(field, \" = '\").concat(values.map(function (v) {\n return _this7.utils.SqlString.trim(v);\n }).join(\",\"), \"'\");else return undefined; //not supported\n },\n spelOp: \"${0}.equals(${1})\",\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils22;\n for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {\n args[_key22] = arguments[_key22];\n }\n return (_this$utils22 = this.utils).mongoFormatOp1.apply(_this$utils22, [\"$eq\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"multiselect_not_equals\",\n jsonLogic2: \"all-in\",\n jsonLogic: function jsonLogic(field, op, vals) {\n return {\n // it's not \"equals\", but \"includes\" operator - just for example\n \"all\": [field, {\n \"in\": [{\n \"var\": \"\"\n }, vals]\n }]\n };\n },\n elasticSearchQueryType: \"term\"\n },\n multiselect_not_equals: {\n isNotOp: true,\n label: \"Not equals\",\n labelForFormat: \"!=\",\n sqlOp: \"<>\",\n sqlOps: [\"<>\", \"!=\"],\n valueTypes: [\"multiselect\"],\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n if (valueSrc == \"value\") return \"\".concat(field, \" != [\").concat(values.join(\", \"), \"]\");else return \"\".concat(field, \" != \").concat(values);\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n var _this8 = this;\n if (valueSrc == \"value\")\n // set\n return \"\".concat(field, \" != '\").concat(values.map(function (v) {\n return _this8.utils.SqlString.trim(v);\n }).join(\",\"), \"'\");else return undefined; //not supported\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils23;\n for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {\n args[_key23] = arguments[_key23];\n }\n return (_this$utils23 = this.utils).mongoFormatOp1.apply(_this$utils23, [\"$ne\", function (v) {\n return v;\n }, false].concat(args));\n },\n reversedOp: \"multiselect_equals\",\n jsonLogic2: \"!all-in\",\n jsonLogic: function jsonLogic(field, op, vals) {\n return {\n // it's not \"equals\", but \"includes\" operator - just for example\n \"!\": {\n \"all\": [field, {\n \"in\": [{\n \"var\": \"\"\n }, vals]\n }]\n }\n };\n },\n _jsonLogicIsExclamationOp: true\n },\n proximity: {\n label: \"Proximity search\",\n cardinality: 2,\n valueLabels: [{\n label: \"Word 1\",\n placeholder: \"Enter first word\"\n }, {\n label: \"Word 2\",\n placeholder: \"Enter second word\"\n }],\n textSeparators: [\n //'Word 1',\n //'Word 2'\n ],\n formatOp: function formatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, isForDisplay) {\n var val1 = values.first();\n var val2 = values.get(1);\n var prox = operatorOptions === null || operatorOptions === void 0 ? void 0 : operatorOptions.get(\"proximity\");\n return \"\".concat(field, \" \").concat(val1, \" NEAR/\").concat(prox, \" \").concat(val2);\n },\n sqlFormatOp: function sqlFormatOp(field, op, values, valueSrc, valueType, opDef, operatorOptions, fieldDef) {\n // https://learn.microsoft.com/en-us/sql/relational-databases/search/search-for-words-close-to-another-word-with-near?view=sql-server-ver16#example-1\n var val1 = values.first();\n var val2 = values.get(1);\n var aVal1 = this.utils.SqlString.trim(val1);\n var aVal2 = this.utils.SqlString.trim(val2);\n var prox = operatorOptions === null || operatorOptions === void 0 ? void 0 : operatorOptions.get(\"proximity\");\n return \"CONTAINS(\".concat(field, \", 'NEAR((\").concat(aVal1, \", \").concat(aVal2, \"), \").concat(prox, \")')\");\n },\n sqlImport: function sqlImport(sqlObj, _, sqlDialect) {\n if ((sqlObj === null || sqlObj === void 0 ? void 0 : sqlObj.func) === \"CONTAINS\") {\n var _right$value;\n var _ref9 = sqlObj.children || [],\n _ref10 = _slicedToArray(_ref9, 2),\n left = _ref10[0],\n right = _ref10[1];\n if (right !== null && right !== void 0 && (_right$value = right.value) !== null && _right$value !== void 0 && _right$value.includes(\"NEAR(\")) {\n var m = right.value.match(/NEAR\\(\\((\\w+), (\\w+)\\), (\\d+)\\)/);\n if (m) {\n delete sqlObj.func;\n sqlObj.operator = \"proximity\";\n sqlObj.children = [left, {\n value: m[1]\n }, {\n value: m[2]\n }];\n sqlObj.operatorOptions = {\n proximity: parseInt(m[3])\n };\n return sqlObj;\n }\n }\n }\n },\n mongoFormatOp: undefined,\n // not supported\n jsonLogic: undefined,\n // not supported\n options: {\n optionLabel: \"Near\",\n // label on top of \"near\" selectbox (for config.settings.showLabels==true)\n optionTextBefore: \"Near\",\n // label before \"near\" selectbox (for config.settings.showLabels==false)\n optionPlaceholder: \"Select words between\",\n // placeholder for \"near\" selectbox\n minProximity: 2,\n maxProximity: 10,\n defaults: {\n proximity: 2\n }\n }\n },\n some: {\n label: \"Some\",\n labelForFormat: \"SOME\",\n cardinality: 0,\n jsonLogic: \"some\",\n spelFormatOp: function spelFormatOp(filteredSize) {\n return \"\".concat(filteredSize, \" > 0\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils24;\n for (var _len24 = arguments.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {\n args[_key24] = arguments[_key24];\n }\n return (_this$utils24 = this.utils).mongoFormatOp1.apply(_this$utils24, [\"$gt\", function (v) {\n return 0;\n }, false].concat(args));\n }\n // reversedOp: undefined,\n },\n all: {\n label: \"All\",\n labelForFormat: \"ALL\",\n cardinality: 0,\n jsonLogic: \"all\",\n spelFormatOp: function spelFormatOp(filteredSize, op, fullSize) {\n return \"\".concat(filteredSize, \" == \").concat(fullSize);\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils25;\n for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {\n args[_key25] = arguments[_key25];\n }\n return (_this$utils25 = this.utils).mongoFormatOp1.apply(_this$utils25, [\"$eq\", function (v) {\n return v;\n }, false].concat(args));\n }\n // reversedOp: \"none\",\n },\n none: {\n label: \"None\",\n labelForFormat: \"NONE\",\n cardinality: 0,\n jsonLogic: \"none\",\n spelFormatOp: function spelFormatOp(filteredSize) {\n return \"\".concat(filteredSize, \" == 0\");\n },\n mongoFormatOp: function mongoFormatOp() {\n var _this$utils26;\n for (var _len26 = arguments.length, args = new Array(_len26), _key26 = 0; _key26 < _len26; _key26++) {\n args[_key26] = arguments[_key26];\n }\n return (_this$utils26 = this.utils).mongoFormatOp1.apply(_this$utils26, [\"$eq\", function (v) {\n return 0;\n }, false].concat(args));\n }\n // reversedOp: \"all\",\n }\n};\n\n//---------------------------- widgets\n\nvar widgets = {\n text: {\n type: \"text\",\n jsType: \"string\",\n valueSrc: \"value\",\n valueLabel: \"String\",\n valuePlaceholder: \"Enter string\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? this.utils.stringifyForDisplay(val) : JSON.stringify(val);\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n return this.utils.spelEscape(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n if (opDef.sqlOp == \"LIKE\" || opDef.sqlOp == \"NOT LIKE\") {\n return this.utils.SqlString.escapeLike(val, op != \"starts_with\", op != \"ends_with\", sqlDialect);\n } else {\n return this.utils.SqlString.escape(val);\n }\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n textarea: {\n type: \"text\",\n jsType: \"string\",\n valueSrc: \"value\",\n valueLabel: \"Text\",\n valuePlaceholder: \"Enter text\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? this.utils.stringifyForDisplay(val) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n if (opDef.sqlOp == \"LIKE\" || opDef.sqlOp == \"NOT LIKE\") {\n return this.utils.SqlString.escapeLike(val, op != \"starts_with\", op != \"ends_with\", sqlDialect);\n } else {\n return this.utils.SqlString.escape(val);\n }\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n },\n fullWidth: true\n },\n number: {\n type: \"number\",\n jsType: \"number\",\n valueSrc: \"value\",\n valueLabel: \"Number\",\n valuePlaceholder: \"Enter number\",\n valueLabels: [{\n label: \"Number from\",\n placeholder: \"Enter number from\"\n }, {\n label: \"Number to\",\n placeholder: \"Enter number to\"\n }],\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? this.utils.stringifyForDisplay(val) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef) {\n var isFloat = wgtDef.step && !Number.isInteger(wgtDef.step);\n return this.utils.spelEscape(val, isFloat);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n slider: {\n type: \"number\",\n jsType: \"number\",\n valueSrc: \"value\",\n valueLabel: \"Number\",\n valuePlaceholder: \"Enter number or move slider\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? this.utils.stringifyForDisplay(val) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n select: {\n type: \"select\",\n jsType: \"string\",\n valueSrc: \"value\",\n valueLabel: \"Value\",\n valuePlaceholder: \"Select value\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n var valLabel = this.utils.getTitleInListValues(fieldDef.fieldSettings.listValues || fieldDef.asyncListValues, val);\n return isForDisplay ? this.utils.stringifyForDisplay(valLabel) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n multiselect: {\n type: \"multiselect\",\n jsType: \"array\",\n valueSrc: \"value\",\n valueLabel: \"Values\",\n valuePlaceholder: \"Select values\",\n formatValue: function formatValue(vals, fieldDef, wgtDef, isForDisplay) {\n var _this9 = this;\n var valsLabels = vals.map(function (v) {\n return _this9.utils.getTitleInListValues(fieldDef.fieldSettings.listValues || fieldDef.asyncListValues, v);\n });\n return isForDisplay ? valsLabels.map(this.utils.stringifyForDisplay) : vals.map(JSON.stringify);\n },\n sqlFormatValue: function sqlFormatValue(vals, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n var _this10 = this;\n return vals.map(function (v) {\n return _this10.utils.SqlString.escape(v);\n });\n },\n spelFormatValue: function spelFormatValue(vals, fieldDef, wgtDef, op, opDef) {\n var isCallable = opDef && opDef.spelOp && opDef.spelOp.startsWith(\"${1}\");\n var res = this.utils.spelEscape(vals); // inline list\n if (isCallable) {\n // `{1,2}.contains(1)` NOT works\n // `{1,2}.?[true].contains(1)` works\n res = this.utils.spelFixList(res);\n }\n return res;\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n date: {\n type: \"date\",\n jsType: \"string\",\n valueSrc: \"value\",\n dateFormat: \"DD.MM.YYYY\",\n valueFormat: \"YYYY-MM-DD\",\n valueLabel: \"Date\",\n valuePlaceholder: \"Enter date\",\n valueLabels: [{\n label: \"Date from\",\n placeholder: \"Enter date from\"\n }, {\n label: \"Date to\",\n placeholder: \"Enter date to\"\n }],\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return isForDisplay ? dateVal.format(wgtDef.dateFormat) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return this.utils.SqlString.escape(dateVal.format(\"YYYY-MM-DD\"));\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n var v = dateVal.format(\"YYYY-MM-DD\");\n var fmt = \"yyyy-MM-dd\";\n //return `new java.text.SimpleDateFormat('${fmt}').parse('${v}')`;\n return \"T(java.time.LocalDate).parse('\".concat(v, \"', T(java.time.format.DateTimeFormatter).ofPattern('\").concat(fmt, \"'))\");\n },\n spelImportFuncs: [\n //\"new java.text.SimpleDateFormat(${fmt}).parse(${v})\",\n {\n obj: {\n cls: [\"java\", \"time\", \"LocalDate\"]\n },\n methodName: \"parse\",\n args: [{\n \"var\": \"v\"\n }, {\n obj: {\n cls: [\"java\", \"time\", \"format\", \"DateTimeFormatter\"]\n },\n methodName: \"ofPattern\",\n args: [{\n \"var\": \"fmt\"\n }]\n }]\n }],\n spelImportValue: function spelImportValue(val, wgtDef, args) {\n var _args$fmt, _args$fmt$includes, _args$fmt2, _args$fmt2$toLowerCas;\n if (!wgtDef) return [undefined, \"No widget def to get value format\"];\n if (args !== null && args !== void 0 && (_args$fmt = args.fmt) !== null && _args$fmt !== void 0 && (_args$fmt = _args$fmt.value) !== null && _args$fmt !== void 0 && (_args$fmt$includes = _args$fmt.includes) !== null && _args$fmt$includes !== void 0 && _args$fmt$includes.call(_args$fmt, \" \") || (_args$fmt2 = args.fmt) !== null && _args$fmt2 !== void 0 && (_args$fmt2 = _args$fmt2.value) !== null && _args$fmt2 !== void 0 && (_args$fmt2$toLowerCas = _args$fmt2.toLowerCase) !== null && _args$fmt2$toLowerCas !== void 0 && _args$fmt2$toLowerCas.call(_args$fmt2).includes(\"hh:mm\")) return [undefined, \"Invalid date format \".concat(JSON.stringify(args.fmt))];\n var dateVal = this.utils.moment(val.value, this.utils.moment.ISO_8601);\n if (dateVal.isValid()) {\n return [dateVal.format(wgtDef === null || wgtDef === void 0 ? void 0 : wgtDef.valueFormat), []];\n } else {\n return [undefined, \"Invalid date\"];\n }\n },\n jsonLogic: function jsonLogic(val, fieldDef, wgtDef) {\n // tip: we use UTC to return same result as new Date(val)\n // new Date(\"2000-01-01\") is now the same as new Date(\"2000-01-01 00:00:00\") (first one in UTC)\n return this.utils.moment.utc(val, wgtDef.valueFormat).toDate();\n },\n toJS: function toJS(val, fieldSettings) {\n var dateVal = this.utils.moment(val, fieldSettings.valueFormat);\n return dateVal.isValid() ? dateVal.toDate() : undefined;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n if (dateVal.isValid()) {\n return {\n \"$dateFromString\": {\n \"dateString\": dateVal.format(\"YYYY-MM-DD\"),\n \"format\": \"%Y-%m-%d\"\n }\n };\n }\n return undefined;\n }\n },\n time: {\n type: \"time\",\n jsType: \"string\",\n valueSrc: \"value\",\n timeFormat: \"HH:mm\",\n valueFormat: \"HH:mm:ss\",\n use12Hours: false,\n valueLabel: \"Time\",\n valuePlaceholder: \"Enter time\",\n valueLabels: [{\n label: \"Time from\",\n placeholder: \"Enter time from\"\n }, {\n label: \"Time to\",\n placeholder: \"Enter time to\"\n }],\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return isForDisplay ? dateVal.format(wgtDef.timeFormat) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return this.utils.SqlString.escape(dateVal.format(\"HH:mm:ss\"));\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n var fmt = \"HH:mm:ss\";\n var v = dateVal.format(\"HH:mm:ss\");\n return \"T(java.time.LocalTime).parse('\".concat(v, \"')\");\n //return `new java.text.SimpleDateFormat('${fmt}').parse('${v}')`;\n },\n spelImportFuncs: [\"T(java.time.LocalTime).parse(${v})\"\n //\"new java.text.SimpleDateFormat(${fmt}).parse(${v})\"\n ],\n spelImportValue: function spelImportValue(val, wgtDef, args) {\n var _args$fmt3, _args$fmt3$toLowerCas, _args$fmt4;\n if (!wgtDef) return [undefined, \"No widget def to get value format\"];\n if (args !== null && args !== void 0 && args.fmt && (!((_args$fmt3 = args.fmt) !== null && _args$fmt3 !== void 0 && (_args$fmt3 = _args$fmt3.value) !== null && _args$fmt3 !== void 0 && (_args$fmt3$toLowerCas = _args$fmt3.toLowerCase) !== null && _args$fmt3$toLowerCas !== void 0 && _args$fmt3$toLowerCas.call(_args$fmt3).includes(\"hh:mm\")) || (_args$fmt4 = args.fmt) !== null && _args$fmt4 !== void 0 && (_args$fmt4 = _args$fmt4.value) !== null && _args$fmt4 !== void 0 && _args$fmt4.includes(\" \"))) return [undefined, \"Invalid time format \".concat(JSON.stringify(args.fmt))];\n var dateVal = this.utils.moment(val.value, \"HH:mm:ss\");\n if (dateVal.isValid()) {\n return [dateVal.format(wgtDef === null || wgtDef === void 0 ? void 0 : wgtDef.valueFormat), []];\n } else {\n return [undefined, \"Invalid date\"];\n }\n },\n jsonLogic: function jsonLogic(val, fieldDef, wgtDef) {\n // return seconds of day\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return dateVal.get(\"hour\") * 60 * 60 + dateVal.get(\"minute\") * 60 + dateVal.get(\"second\");\n },\n toJS: function toJS(val, fieldSettings) {\n // return seconds of day\n var dateVal = this.utils.moment(val, fieldSettings.valueFormat);\n return dateVal.isValid() ? dateVal.get(\"hour\") * 60 * 60 + dateVal.get(\"minute\") * 60 + dateVal.get(\"second\") : undefined;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n // return seconds of day\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return dateVal.get(\"hour\") * 60 * 60 + dateVal.get(\"minute\") * 60 + dateVal.get(\"second\");\n },\n elasticSearchFormatValue: function elasticSearchFormatValue(queryType, value, operator, fieldName) {\n return {\n script: {\n script: {\n source: \"doc[\".concat(fieldName, \"][0].getHour() >== params.min && doc[\").concat(fieldName, \"][0].getHour() <== params.max\"),\n params: {\n min: value[0],\n max: value[1]\n }\n }\n }\n };\n }\n },\n datetime: {\n type: \"datetime\",\n jsType: \"string\",\n valueSrc: \"value\",\n timeFormat: \"HH:mm\",\n dateFormat: \"DD.MM.YYYY\",\n valueFormat: \"YYYY-MM-DD HH:mm:ss\",\n use12Hours: false,\n valueLabel: \"Datetime\",\n valuePlaceholder: \"Enter datetime\",\n valueLabels: [{\n label: \"Datetime from\",\n placeholder: \"Enter datetime from\"\n }, {\n label: \"Datetime to\",\n placeholder: \"Enter datetime to\"\n }],\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return isForDisplay ? dateVal.format(wgtDef.dateFormat + \" \" + wgtDef.timeFormat) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n return this.utils.SqlString.escape(dateVal.toDate());\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n var v = dateVal.format(\"YYYY-MM-DD HH:mm:ss\");\n var fmt = \"yyyy-MM-dd HH:mm:ss\";\n //return `new java.text.SimpleDateFormat('${fmt}').parse('${v}')`;\n return \"T(java.time.LocalDateTime).parse('\".concat(v, \"', T(java.time.format.DateTimeFormatter).ofPattern('\").concat(fmt, \"'))\");\n },\n spelImportFuncs: [\n //\"new java.text.SimpleDateFormat(${fmt}).parse(${v})\",\n {\n obj: {\n cls: [\"java\", \"time\", \"LocalDateTime\"]\n },\n methodName: \"parse\",\n args: [{\n \"var\": \"v\"\n }, {\n obj: {\n cls: [\"java\", \"time\", \"format\", \"DateTimeFormatter\"]\n },\n methodName: \"ofPattern\",\n args: [{\n \"var\": \"fmt\"\n }]\n }]\n }],\n spelImportValue: function spelImportValue(val, wgtDef, args) {\n var _args$fmt5, _args$fmt5$includes;\n if (!wgtDef) return [undefined, \"No widget def to get value format\"];\n if (!(args !== null && args !== void 0 && (_args$fmt5 = args.fmt) !== null && _args$fmt5 !== void 0 && (_args$fmt5 = _args$fmt5.value) !== null && _args$fmt5 !== void 0 && (_args$fmt5$includes = _args$fmt5.includes) !== null && _args$fmt5$includes !== void 0 && _args$fmt5$includes.call(_args$fmt5, \" \"))) return [undefined, \"Invalid datetime format \".concat(JSON.stringify(args.fmt))];\n var dateVal = this.utils.moment(val.value, this.utils.moment.ISO_8601);\n if (dateVal.isValid()) {\n return [dateVal.format(wgtDef === null || wgtDef === void 0 ? void 0 : wgtDef.valueFormat), []];\n } else {\n return [undefined, \"Invalid date\"];\n }\n },\n // Moved to `sqlImportDate` in `packages/sql/modules/import/conv`\n // sqlImport: function (sqlObj, wgtDef, sqlDialect) {\n // if ([\"TO_DATE\"].includes(sqlObj?.func) && sqlObj?.children?.length >= 1) {\n // const [valArg, patternArg] = sqlObj.children;\n // if (valArg?.valueType == \"single_quote_string\") {\n // // tip: moment doesn't support SQL date format, so ignore patternArg\n // const dateVal = this.utils.moment(valArg.value);\n // if (dateVal.isValid()) {\n // return {\n // value: dateVal.format(wgtDef?.valueFormat),\n // };\n // } else {\n // return {\n // value: null,\n // error: \"Invalid date\",\n // };\n // }\n // }\n // }\n // },\n jsonLogic: function jsonLogic(val, fieldDef, wgtDef) {\n return this.utils.moment(val, wgtDef.valueFormat).toDate();\n },\n // Example of importing and exporting to epoch timestamp (in ms) for JsonLogic:\n // jsonLogicImport: function(timestamp, wgtDef) {\n // const momentVal = this.utils.moment(timestamp, \"x\");\n // return momentVal.isValid() ? momentVal.toDate() : undefined;\n // },\n // jsonLogic: function (val, fieldDef, wgtDef) {\n // return this.utils.moment(val, wgtDef.valueFormat).format(\"x\");\n // },\n toJS: function toJS(val, fieldSettings) {\n var dateVal = this.utils.moment(val, fieldSettings.valueFormat);\n return dateVal.isValid() ? dateVal.toDate() : undefined;\n },\n // todo: $toDate (works onliny in $expr)\n // https://www.mongodb.com/docs/manual/reference/operator/aggregation/toDate/\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n var dateVal = this.utils.moment(val, wgtDef.valueFormat);\n if (dateVal.isValid()) {\n return {\n \"$dateFromString\": {\n \"dateString\": dateVal.format(\"YYYY-MM-DD HH:mm:ss\"),\n \"format\": \"%Y-%m-%d %H:%M:%S\"\n }\n };\n }\n }\n },\n \"boolean\": {\n type: \"boolean\",\n jsType: \"boolean\",\n valueSrc: \"value\",\n labelYes: \"Yes\",\n labelNo: \"No\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? val ? \"Yes\" : \"No\" : JSON.stringify(!!val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n return this.utils.spelEscape(val);\n },\n defaultValue: false,\n toJS: function toJS(val, fieldSettings) {\n return val;\n },\n mongoFormatValue: function mongoFormatValue(val, fieldDef, wgtDef) {\n return val;\n }\n },\n field: {\n valueSrc: \"field\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay, op, opDef, rightFieldDef) {\n return isForDisplay ? rightFieldDef.label || val : val;\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, rightFieldDef, sqlDialect) {\n return val;\n },\n spelFormatValue: function spelFormatValue(val, fieldDef, wgtDef, op, opDef) {\n return val;\n },\n valueLabel: \"Field to compare\",\n valuePlaceholder: \"Select field to compare\"\n },\n func: {\n valueSrc: \"func\",\n valueLabel: \"Function\",\n valuePlaceholder: \"Select function\"\n },\n /**\n * @deprecated\n */\n case_value: {\n valueSrc: \"value\",\n type: \"case_value\",\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val === \"\" ? null : val);\n },\n spelImportValue: function spelImportValue(val) {\n return [val.value, []];\n },\n jsonLogic: function jsonLogic(val) {\n return val === \"\" ? null : val;\n }\n }\n};\n\n//---------------------------- types\n\nvar types = {\n text: {\n defaultOperator: \"equal\",\n mainWidget: \"text\",\n widgets: {\n text: {\n operators: [\"equal\", \"not_equal\", \"like\", \"not_like\", \"starts_with\", \"ends_with\", \"proximity\", \"is_empty\", \"is_not_empty\", \"is_null\", \"is_not_null\"],\n widgetProps: {},\n opProps: {}\n },\n textarea: {\n operators: [\"equal\", \"not_equal\", \"like\", \"not_like\", \"starts_with\", \"ends_with\", \"is_empty\", \"is_not_empty\", \"is_null\", \"is_not_null\"],\n widgetProps: {},\n opProps: {}\n },\n field: {\n operators: [\n //unary ops (like `is_empty`) will be excluded anyway, see getWidgetsForFieldOp()\n \"equal\", \"not_equal\", \"proximity\" //can exclude if you want\n ]\n }\n }\n },\n number: {\n defaultOperator: \"equal\",\n mainWidget: \"number\",\n widgets: {\n number: {\n operators: [\"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\", \"between\", \"not_between\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n },\n slider: {\n operators: [\"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n date: {\n defaultOperator: \"equal\",\n widgets: {\n date: {\n operators: [\"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\", \"between\", \"not_between\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n time: {\n defaultOperator: \"equal\",\n widgets: {\n time: {\n operators: [\"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\", \"between\", \"not_between\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n datetime: {\n defaultOperator: \"equal\",\n widgets: {\n datetime: {\n operators: [\"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\", \"between\", \"not_between\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n select: {\n mainWidget: \"select\",\n defaultOperator: \"select_equals\",\n widgets: {\n select: {\n operators: [\"select_equals\", \"select_not_equals\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n },\n multiselect: {\n operators: [\"select_any_in\", \"select_not_any_in\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n multiselect: {\n defaultOperator: \"multiselect_equals\",\n widgets: {\n multiselect: {\n operators: [\"multiselect_contains\", \"multiselect_not_contains\", \"multiselect_equals\", \"multiselect_not_equals\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }\n }\n },\n \"boolean\": {\n defaultOperator: \"equal\",\n widgets: {\n \"boolean\": {\n operators: [\"equal\", \"not_equal\", \"is_null\", \"is_not_null\"],\n widgetProps: {\n //you can enable this if you don't use fields as value sources\n // hideOperator: true,\n // operatorInlineLabel: \"is\",\n }\n },\n field: {\n operators: [\"equal\", \"not_equal\"]\n }\n }\n },\n \"!group\": {\n defaultOperator: \"some\",\n mainWidget: \"number\",\n widgets: {\n number: {\n widgetProps: {\n min: 0\n },\n operators: [\n // w/o operand\n \"some\", \"all\", \"none\",\n // w/ operand - count\n \"equal\", \"not_equal\", \"less\", \"less_or_equal\", \"greater\", \"greater_or_equal\", \"between\", \"not_between\"],\n opProps: {\n equal: {\n label: \"Count ==\"\n },\n not_equal: {\n label: \"Count !=\"\n },\n less: {\n label: \"Count <\"\n },\n less_or_equal: {\n label: \"Count <=\"\n },\n greater: {\n label: \"Count >\"\n },\n greater_or_equal: {\n label: \"Count >=\"\n },\n between: {\n label: \"Count between\"\n },\n not_between: {\n label: \"Count not between\"\n }\n }\n }\n }\n },\n /**\n * @deprecated\n */\n \"case_value\": {\n mainWidget: \"case_value\",\n widgets: {\n case_value: {\n widgetProps: {}\n }\n }\n }\n};\n\n//---------------------------- settings\n\nvar settings = _objectSpread(_objectSpread({}, defaultSettings), {}, {\n convertableWidgets: {\n \"number\": [\"slider\", \"rangeslider\"],\n \"slider\": [\"number\", \"rangeslider\"],\n \"rangeslider\": [\"number\", \"slider\"],\n \"text\": [\"textarea\"],\n \"textarea\": [\"text\"]\n },\n formatSpelField: function formatSpelField(field, parentField, parts, partsExt, fieldDefinition, config) {\n var _this11 = this;\n var fieldName = partsExt.map(function (_ref11, ind) {\n var key = _ref11.key,\n parent = _ref11.parent,\n sep = _ref11.fieldSeparator;\n if (ind == 0) {\n if (parent == \"[map]\") return \"#this[\".concat(_this11.utils.spelEscape(key), \"]\");else if (parent == \"[class]\") return key;else return key;\n } else {\n if (parent == \"map\" || parent == \"[map]\") return \"[\".concat(_this11.utils.spelEscape(key), \"]\");else if (parent == \"class\" || parent == \"[class]\") return \"\".concat(sep).concat(key);else return \"\".concat(sep).concat(key);\n }\n }).join(\"\");\n if (fieldDefinition.fieldName) {\n fieldName = field;\n }\n if (fieldDefinition.isSpelVariable) {\n fieldName = \"#\" + fieldName;\n }\n return fieldName;\n },\n sqlFormatReverse: function sqlFormatReverse(q) {\n if (q == undefined) return undefined;\n return \"NOT\" + this.utils.wrapWithBrackets(q);\n },\n spelFormatReverse: function spelFormatReverse(q) {\n if (q == undefined) return undefined;\n return \"!\" + this.utils.wrapWithBrackets(q);\n },\n formatReverse: function formatReverse(q, operator, reversedOp, operatorDefinition, revOperatorDefinition, isForDisplay) {\n if (q == undefined) return undefined;\n if (isForDisplay) return \"NOT \" + this.utils.wrapWithBrackets(q);else return \"!\" + this.utils.wrapWithBrackets(q);\n },\n formatAggr: function formatAggr(whereStr, aggrField, operator, value, valueSrc, valueType, opDef, operatorOptions, isForDisplay, aggrFieldDef) {\n var labelForFormat = opDef.labelForFormat,\n cardinality = opDef.cardinality;\n if (cardinality == 0) {\n var cond = whereStr ? \" HAVE \".concat(whereStr) : \"\";\n return \"\".concat(labelForFormat, \" OF \").concat(aggrField).concat(cond);\n } else if (cardinality == undefined || cardinality == 1) {\n var _cond = whereStr ? \" WHERE \".concat(whereStr) : \"\";\n return \"COUNT OF \".concat(aggrField).concat(_cond, \" \").concat(labelForFormat, \" \").concat(value);\n } else if (cardinality == 2) {\n var _cond2 = whereStr ? \" WHERE \".concat(whereStr) : \"\";\n var valFrom = value.first();\n var valTo = value.get(1);\n return \"COUNT OF \".concat(aggrField).concat(_cond2, \" \").concat(labelForFormat, \" \").concat(valFrom, \" AND \").concat(valTo);\n }\n },\n jsonLogic: {\n groupVarKey: \"var\",\n altVarKey: \"var\",\n lockedOp: \"locked\"\n },\n canCompareFieldWithField: function canCompareFieldWithField(leftField, leftFieldConfig, rightField, rightFieldConfig) {\n //for type == 'select'/'multiselect' you can check listValues\n return true;\n },\n // enable compare fields\n valueSourcesInfo: {\n value: {\n label: \"Value\"\n },\n field: {\n label: \"Field\",\n widget: \"field\"\n },\n func: {\n label: \"Function\",\n widget: \"func\"\n }\n }\n});\n\n//----------------------------\n\nvar _addMixins = function _addMixins(config, mixins) {\n var doAdd = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n var mixinFuncs = {\n rangeslider: mixinWidgetRangeslider,\n treeselect: mixinWidgetTreeselect,\n treemultiselect: mixinWidgetTreemultiselect,\n rangeable__date: mixinRangeableWidget(\"date\", \"date\")\n };\n var _iterator = _createForOfIteratorHelper(mixins),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var mixName = _step.value;\n var mixinFunc = mixinFuncs[mixName];\n if (mixinFunc) {\n config = mixinFunc(config, doAdd);\n } else {\n throw new Error(\"Can't \".concat(doAdd ? \"add\" : \"remove\", \" mixin \").concat(mixName));\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return config;\n};\nvar addMixins = function addMixins(config, mixins) {\n return _addMixins(config, mixins, true);\n};\nvar removeMixins = function removeMixins(config, mixins) {\n return _addMixins(config, mixins, false);\n};\nvar mixinRangeableWidget = function mixinRangeableWidget(type, widget) {\n return function (config) {\n var addMixin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var types = config.types;\n types = _objectSpread(_objectSpread({}, types), {}, _defineProperty({}, type, _objectSpread(_objectSpread({}, types[type]), {}, {\n widgets: _objectSpread({}, types[type].widgets)\n })));\n if (addMixin) {\n types[type].widgets[widget] = _objectSpread({\n opProps: {\n between: {\n isSpecialRange: true,\n textSeparators: [null, null]\n },\n not_between: {\n isSpecialRange: true,\n textSeparators: [null, null]\n }\n }\n }, types[type].widgets[widget]);\n } else {\n delete types[type].widgets[widget];\n }\n return _objectSpread(_objectSpread({}, config), {}, {\n types: types\n });\n };\n};\nvar mixinWidgetRangeslider = function mixinWidgetRangeslider(config) {\n var addMixin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var widgets = config.widgets,\n types = config.types;\n widgets = _objectSpread({}, widgets);\n if (addMixin) {\n widgets.rangeslider = _objectSpread({\n type: \"number\",\n jsType: \"number\",\n valueSrc: \"value\",\n valueLabel: \"Range\",\n valuePlaceholder: \"Select range\",\n valueLabels: [{\n label: \"Number from\",\n placeholder: \"Enter number from\"\n }, {\n label: \"Number to\",\n placeholder: \"Enter number to\"\n }],\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n return isForDisplay ? this.utils.stringifyForDisplay(val) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n singleWidget: \"slider\",\n toJS: function toJS(val, fieldSettings) {\n return val;\n }\n }, widgets.rangeslider);\n } else {\n delete widgets.rangeslider;\n }\n types = _objectSpread(_objectSpread({}, types), {}, {\n number: _objectSpread(_objectSpread({}, types.number), {}, {\n widgets: _objectSpread({}, types.number.widgets)\n })\n });\n if (addMixin) {\n types.number.widgets.rangeslider = _objectSpread({\n opProps: {\n between: {\n isSpecialRange: true\n },\n not_between: {\n isSpecialRange: true\n }\n },\n operators: [\"between\", \"not_between\",\n // \"is_empty\",\n // \"is_not_empty\",\n \"is_null\", \"is_not_null\"]\n }, types.number.widgets.rangeslider);\n } else {\n delete types.number.widgets.rangeslider;\n }\n return _objectSpread(_objectSpread({}, config), {}, {\n widgets: widgets,\n types: types\n });\n};\nvar mixinWidgetTreeselect = function mixinWidgetTreeselect(config) {\n var addMixin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var widgets = config.widgets,\n types = config.types;\n widgets = _objectSpread({}, widgets);\n if (addMixin) {\n widgets.treeselect = _objectSpread({\n type: \"treeselect\",\n jsType: \"string\",\n valueSrc: \"value\",\n valueLabel: \"Value\",\n valuePlaceholder: \"Select value\",\n formatValue: function formatValue(val, fieldDef, wgtDef, isForDisplay) {\n var treeData = fieldDef.fieldSettings.treeValues || fieldDef.fieldSettings.listValues || fieldDef.asyncListValues;\n var valLabel = this.utils.getTitleInListValues(treeData, val);\n return isForDisplay ? this.utils.stringifyForDisplay(valLabel) : JSON.stringify(val);\n },\n sqlFormatValue: function sqlFormatValue(val, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n return this.utils.SqlString.escape(val);\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n }\n }, widgets.treeselect);\n } else {\n delete widgets.treeselect;\n }\n types = _objectSpread({}, types);\n if (addMixin) {\n types.treeselect = _objectSpread({\n mainWidget: \"treeselect\",\n defaultOperator: \"select_equals\",\n widgets: {\n treeselect: {\n operators: [\"select_equals\", \"select_not_equals\"]\n },\n treemultiselect: {\n operators: [\"select_any_in\", \"select_not_any_in\"]\n }\n }\n }, types.treeselect);\n } else {\n delete types.treeselect;\n }\n return _objectSpread(_objectSpread({}, config), {}, {\n widgets: widgets,\n types: types\n });\n};\nvar mixinWidgetTreemultiselect = function mixinWidgetTreemultiselect(config) {\n var addMixin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var widgets = config.widgets,\n types = config.types;\n widgets = _objectSpread({}, widgets);\n if (addMixin) {\n widgets.treemultiselect = _objectSpread({\n type: \"treemultiselect\",\n jsType: \"array\",\n valueSrc: \"value\",\n valueLabel: \"Values\",\n valuePlaceholder: \"Select values\",\n formatValue: function formatValue(vals, fieldDef, wgtDef, isForDisplay) {\n var _this12 = this;\n var treeData = fieldDef.fieldSettings.treeValues || fieldDef.fieldSettings.listValues || fieldDef.asyncListValues;\n var valsLabels = vals.map(function (v) {\n return _this12.utils.getTitleInListValues(treeData, v);\n });\n return isForDisplay ? valsLabels.map(this.utils.stringifyForDisplay) : vals.map(JSON.stringify);\n },\n sqlFormatValue: function sqlFormatValue(vals, fieldDef, wgtDef, op, opDef, _, sqlDialect) {\n var _this13 = this;\n return vals.map(function (v) {\n return _this13.utils.SqlString.escape(v);\n });\n },\n spelFormatValue: function spelFormatValue(val) {\n return this.utils.spelEscape(val);\n },\n toJS: function toJS(val, fieldSettings) {\n return val;\n }\n }, widgets.treemultiselect);\n } else {\n delete widgets.treemultiselect;\n }\n types = _objectSpread({}, types);\n if (addMixin) {\n types.treemultiselect = _objectSpread({\n defaultOperator: \"multiselect_equals\",\n widgets: {\n treemultiselect: {\n operators: [\"multiselect_equals\", \"multiselect_not_equals\"]\n }\n }\n }, types.treemultiselect);\n } else {\n delete types.treemultiselect;\n }\n return _objectSpread(_objectSpread({}, config), {}, {\n widgets: widgets,\n types: types\n });\n};\nexport var ConfigMixins = {\n addMixins: addMixins,\n removeMixins: removeMixins\n};\n\n//----------------------------\n\nvar config = {\n conjunctions: conjunctions,\n operators: operators,\n widgets: widgets,\n types: types,\n settings: settings,\n ctx: ctx\n};\n// Mixin advanced widgets just to allow using it on server-side eg. for export routines\nconfig = addMixins(config, [\"rangeslider\", \"treeselect\", \"treemultiselect\"]);\nexport default config;","export var ADD_GROUP = \"ADD_GROUP\";\nexport var ADD_CASE_GROUP = \"ADD_CASE_GROUP\";\nexport var REMOVE_GROUP = \"REMOVE_GROUP\";\nexport var SET_CONJUNCTION = \"SET_CONJUNCTION\";\nexport var SET_NOT = \"SET_NOT\";\nexport var ADD_RULE = \"ADD_RULE\";\nexport var REMOVE_RULE = \"REMOVE_RULE\";\nexport var SET_FIELD = \"SET_FIELD\";\nexport var SET_FIELD_SRC = \"SET_FIELD_SRC\";\nexport var SET_OPERATOR = \"SET_OPERATOR\";\nexport var SET_VALUE = \"SET_VALUE\";\nexport var SET_VALUE_SRC = \"SET_VALUE_SRC\";\nexport var SET_FUNC_VALUE = \"SET_FUNC_VALUE\";\nexport var SET_OPERATOR_OPTION = \"SET_OPERATOR_OPTION\";\nexport var SET_LOCK = \"SET_LOCK\";\nexport var SET_TREE = \"SET_TREE\";\nexport var MOVE_ITEM = \"MOVE_ITEM\";\nexport var PLACEMENT_AFTER = \"after\";\nexport var PLACEMENT_BEFORE = \"before\";\nexport var PLACEMENT_APPEND = \"append\";\nexport var PLACEMENT_PREPEND = \"prepend\";\nexport var SET_DRAG_PROGRESS = \"SET_DRAG_PROGRESS\";\nexport var SET_DRAG_START = \"SET_DRAG_START\";\nexport var SET_DRAG_END = \"SET_DRAG_END\";","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nimport Immutable, { fromJS } from \"immutable\";\nimport { expandTreePath, expandTreeSubpath, getItemByPath, getAncestorRuleGroups, fixPathsInTree, getTotalRulesCountInTree, fixEmptyGroupsInTree, isEmptyTree, hasChildren, removeIsLockedInTree } from \"../utils/treeUtils\";\nimport { defaultRuleProperties, defaultGroupProperties, getDefaultOperator, defaultOperatorOptions, defaultItemProperties } from \"../utils/defaultRuleUtils\";\nimport * as constants from \"./constants\";\nimport uuid from \"../utils/uuid\";\nimport { getFuncConfig, getFieldConfig, getOperatorConfig, selectTypes, getOperatorsForType, getOperatorsForField, getFirstOperator } from \"../utils/configUtils\";\nimport { isEmptyItem, calculateValueType } from \"../utils/ruleUtils\";\nimport { deepEqual, getOpCardinality, applyToJS } from \"../utils/stuff\";\nimport { validateValue, validateRange } from \"../utils/validation\";\nimport { getNewValueForFieldOp } from \"../utils/getNewValueForFieldOp\";\nimport { translateValidation } from \"../i18n\";\nimport omit from \"lodash/omit\";\nimport mapValues from \"lodash/mapValues\";\nimport { setFunc, setArgValue, setArgValueSrc, setArgValueAsyncListValues } from \"../utils/funcUtils\";\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nvar addNewGroup = function addNewGroup(state, path, type, generatedId, properties, config) {\n var _properties$get;\n var children = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n var meta = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : {};\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n var groupUuid = (properties === null || properties === void 0 || (_properties$get = properties.get) === null || _properties$get === void 0 ? void 0 : _properties$get.call(properties, \"id\")) || generatedId;\n var shouldCreateEmptyGroup = config.settings.shouldCreateEmptyGroup;\n var groupPath = path.push(groupUuid);\n var canAddNewRule = !shouldCreateEmptyGroup;\n var isDefaultCase = !!(meta !== null && meta !== void 0 && meta.isDefaultCase);\n var origState = state;\n state = addItem(state, path, type, groupUuid, defaultGroupProperties(config).merge(fromJS(properties) || {}), config, children);\n if (state !== origState) {\n if (!children && !isDefaultCase) {\n state = state.setIn(expandTreePath(groupPath, \"children1\"), new Immutable.OrderedMap());\n\n // Add one empty rule into new group\n if (canAddNewRule) {\n state = addItem(state, groupPath, \"rule\", uuid(), defaultRuleProperties(config, meta === null || meta === void 0 ? void 0 : meta.parentRuleGroupField), config);\n }\n }\n state = fixPathsInTree(state);\n }\n return state;\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nvar removeGroup = function removeGroup(state, path, config) {\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n state = removeItem(state, path);\n var canLeaveEmptyGroup = config.settings.canLeaveEmptyGroup;\n var parentPath = path.slice(0, -1);\n var isEmptyParentGroup = !hasChildren(state, parentPath);\n if (isEmptyParentGroup && !canLeaveEmptyGroup) {\n // check ancestors for emptiness (and delete 'em if empty)\n state = fixEmptyGroupsInTree(state);\n if (isEmptyTree(state) && !canLeaveEmptyGroup) {\n // if whole query is empty, add one empty(!) rule to root\n var canUseDefaultFieldAndOp = false;\n var canGetFirst = false;\n state = addItem(state, new Immutable.List(), \"rule\", uuid(), defaultRuleProperties(config, undefined, undefined, canUseDefaultFieldAndOp, canGetFirst), config);\n }\n }\n state = fixPathsInTree(state);\n return state;\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n */\nvar removeRule = function removeRule(state, path, config) {\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n state = removeItem(state, path);\n var canLeaveEmptyGroup = config.settings.canLeaveEmptyGroup;\n var parentPath = path.pop();\n var parent = state.getIn(expandTreePath(parentPath));\n var parentField = parent.getIn([\"properties\", \"field\"]);\n var parentOperator = parent.getIn([\"properties\", \"operator\"]);\n // const parentValue = parent.getIn([\"properties\", \"value\", 0]);\n var parentFieldConfig = parentField ? getFieldConfig(config, parentField) : null;\n var parentOperatorConfig = parentOperator ? getOperatorConfig(config, parentOperator, parentField) : null;\n var hasGroupCountRule = parentField && parentOperator && parentOperatorConfig.cardinality != 0; // && parentValue != undefined;\n\n var isParentRuleGroup = parent.get(\"type\") == \"rule_group\";\n var isEmptyParentGroup = !hasChildren(state, parentPath);\n var canLeaveEmpty = isParentRuleGroup ? hasGroupCountRule && parentFieldConfig.initialEmptyWhere : canLeaveEmptyGroup;\n if (isEmptyParentGroup && !canLeaveEmpty) {\n if (isParentRuleGroup) {\n // deleted last rule from rule_group, so delete whole rule_group\n state = state.deleteIn(expandTreePath(parentPath));\n }\n\n // check ancestors for emptiness (and delete 'em if empty)\n state = fixEmptyGroupsInTree(state);\n if (isEmptyTree(state) && !canLeaveEmptyGroup) {\n // if whole query is empty, add one empty(!) rule to root\n var canUseDefaultFieldAndOp = false;\n var canGetFirst = false;\n state = addItem(state, new Immutable.List(), \"rule\", uuid(), defaultRuleProperties(config, undefined, undefined, canUseDefaultFieldAndOp, canGetFirst), config);\n }\n }\n state = fixPathsInTree(state);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {bool} not\n */\nvar setNot = function setNot(state, path, not) {\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n state = state.setIn(expandTreePath(path, \"properties\", \"not\"), not);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {bool} lock\n */\nvar setLock = function setLock(state, path, lock) {\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n state = removeIsLockedInTree(state.setIn(expandTreePath(path, \"properties\", \"isLocked\"), lock));\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {string} conjunction\n */\nvar setConjunction = function setConjunction(state, path, conjunction) {\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n state = state.setIn(expandTreePath(path, \"properties\", \"conjunction\"), conjunction);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {string} type\n * @param {string} id\n * @param {Immutable.OrderedMap} properties\n * @param {object} config\n */\nvar addItem = function addItem(state, path, type, generatedId, properties, config) {\n var _properties$get2;\n var children = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;\n if (type === \"switch_group\") throw new Error(\"Can't add switch_group programmatically\");\n var targetItem = state.getIn(expandTreePath(path));\n if (!targetItem) {\n // incorrect path\n return state;\n }\n var id = (properties === null || properties === void 0 || (_properties$get2 = properties.get) === null || _properties$get2 === void 0 ? void 0 : _properties$get2.call(properties, \"id\")) || generatedId;\n var _config$settings = config.settings,\n maxNumberOfCases = _config$settings.maxNumberOfCases,\n maxNumberOfRules = _config$settings.maxNumberOfRules,\n maxNesting = _config$settings.maxNesting;\n var rootType = state.get(\"type\");\n var isTernary = rootType === \"switch_group\";\n var caseGroup = isTernary ? state.getIn(expandTreePath(path.take(2))) : null;\n var childrenPath = expandTreePath(path, \"children1\");\n var targetChildren = state.getIn(childrenPath);\n var hasChildren = !!targetChildren && targetChildren.size;\n var targetChildrenSize = hasChildren ? targetChildren.size : null;\n var currentNumber, maxNumber;\n if (type === \"case_group\") {\n currentNumber = targetChildrenSize;\n maxNumber = maxNumberOfCases;\n } else if (type === \"group\") {\n var ruleGroups = getAncestorRuleGroups(state, path);\n if (ruleGroups.length) {\n // closest rule-group\n var _ruleGroups$ = ruleGroups[0],\n ruleGroupPath = _ruleGroups$.path,\n ruleGroupField = _ruleGroups$.field;\n var ruleGroupFieldConfig = getFieldConfig(config, ruleGroupField);\n currentNumber = path.size - ruleGroupPath.length;\n maxNumber = ruleGroupFieldConfig === null || ruleGroupFieldConfig === void 0 ? void 0 : ruleGroupFieldConfig.maxNesting;\n } else {\n currentNumber = path.size;\n maxNumber = maxNesting;\n }\n } else {\n // rule or rule_group\n var _ruleGroups = getAncestorRuleGroups(state, path);\n if (_ruleGroups.length) {\n // closest rule-group\n var _ruleGroups$2 = _ruleGroups[0],\n _ruleGroupPath = _ruleGroups$2.path,\n _ruleGroupField = _ruleGroups$2.field;\n var _ruleGroupFieldConfig = getFieldConfig(config, _ruleGroupField);\n var ruleGroupItem = getItemByPath(state, _ruleGroupPath);\n maxNumber = _ruleGroupFieldConfig === null || _ruleGroupFieldConfig === void 0 ? void 0 : _ruleGroupFieldConfig.maxNumberOfRules;\n currentNumber = getTotalRulesCountInTree(ruleGroupItem);\n } else {\n currentNumber = isTernary ? getTotalRulesCountInTree(caseGroup) : getTotalRulesCountInTree(state);\n maxNumber = maxNumberOfRules;\n }\n }\n var canAdd = maxNumber && currentNumber ? currentNumber < maxNumber : true;\n var item = {\n type: type,\n id: id,\n properties: properties\n };\n _addChildren(config, item, children);\n var isLastDefaultCase = type === \"case_group\" && hasChildren && targetChildren.last().get(\"children1\") == null;\n if (canAdd) {\n var newChildren = new Immutable.OrderedMap(_defineProperty({}, id, new Immutable.Map(item)));\n if (!hasChildren) {\n state = state.setIn(childrenPath, newChildren);\n } else if (isLastDefaultCase) {\n var last = targetChildren.last();\n var newChildrenWithLast = new Immutable.OrderedMap(_defineProperty(_defineProperty({}, id, new Immutable.Map(item)), last.get(\"id\"), last));\n state = state.deleteIn(expandTreePath(childrenPath, \"children1\", last.get(\"id\")));\n state = state.mergeIn(childrenPath, newChildrenWithLast);\n } else {\n state = state.mergeIn(childrenPath, newChildren);\n }\n state = fixPathsInTree(state);\n }\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n */\nvar removeItem = function removeItem(state, path) {\n state = state.deleteIn(expandTreePath(path));\n state = fixPathsInTree(state);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} fromPath\n * @param {Immutable.List} toPath\n * @param {string} placement, see constants PLACEMENT_*: PLACEMENT_AFTER, PLACEMENT_BEFORE, PLACEMENT_APPEND, PLACEMENT_PREPEND\n * @param {object} config\n */\nvar moveItem = function moveItem(state, fromPath, toPath, placement, config) {\n var from = getItemByPath(state, fromPath);\n var sourcePath = fromPath.pop();\n var source = fromPath.size > 1 ? getItemByPath(state, sourcePath) : null;\n var sourceChildren = source ? source.get(\"children1\") : null;\n var to = getItemByPath(state, toPath);\n var targetPath = placement == constants.PLACEMENT_APPEND || placement == constants.PLACEMENT_PREPEND ? toPath : toPath.pop();\n var target = placement == constants.PLACEMENT_APPEND || placement == constants.PLACEMENT_PREPEND ? to : toPath.size > 1 ? getItemByPath(state, targetPath) : null;\n var targetChildren = target ? target.get(\"children1\") : null;\n if (!source || !target || !from) {\n // incorrect path\n return state;\n }\n var isSameParent = source.get(\"id\") == target.get(\"id\");\n var isSourceInsideTarget = targetPath.size < sourcePath.size && deepEqual(targetPath.toArray(), sourcePath.toArray().slice(0, targetPath.size));\n var isTargetInsideSource = targetPath.size > sourcePath.size && deepEqual(sourcePath.toArray(), targetPath.toArray().slice(0, sourcePath.size));\n var sourceSubpathFromTarget = null;\n var targetSubpathFromSource = null;\n if (isSourceInsideTarget) {\n sourceSubpathFromTarget = Immutable.List(sourcePath.toArray().slice(targetPath.size));\n } else if (isTargetInsideSource) {\n targetSubpathFromSource = Immutable.List(targetPath.toArray().slice(sourcePath.size));\n }\n var newTargetChildren = targetChildren,\n newSourceChildren = sourceChildren;\n if (!isTargetInsideSource) newSourceChildren = newSourceChildren[\"delete\"](from.get(\"id\"));\n if (isSameParent) {\n newTargetChildren = newSourceChildren;\n } else if (isSourceInsideTarget) {\n newTargetChildren = newTargetChildren.updateIn(expandTreeSubpath(sourceSubpathFromTarget, \"children1\"), function (_oldChildren) {\n return newSourceChildren;\n });\n }\n if (placement == constants.PLACEMENT_BEFORE || placement == constants.PLACEMENT_AFTER) {\n newTargetChildren = Immutable.OrderedMap().withMutations(function (r) {\n var _iterator = _createForOfIteratorHelper(newTargetChildren.entries()),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var _step$value = _slicedToArray(_step.value, 2),\n itemId = _step$value[0],\n item = _step$value[1];\n if (itemId == (to === null || to === void 0 ? void 0 : to.get(\"id\")) && placement == constants.PLACEMENT_BEFORE) {\n r.set(from.get(\"id\"), from);\n }\n r.set(itemId, item);\n if (itemId == (to === null || to === void 0 ? void 0 : to.get(\"id\")) && placement == constants.PLACEMENT_AFTER) {\n r.set(from.get(\"id\"), from);\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n });\n } else if (placement == constants.PLACEMENT_APPEND) {\n newTargetChildren = newTargetChildren.merge(Immutable.OrderedMap(_defineProperty({}, from.get(\"id\"), from)));\n } else if (placement == constants.PLACEMENT_PREPEND) {\n newTargetChildren = Immutable.OrderedMap(_defineProperty({}, from.get(\"id\"), from)).merge(newTargetChildren);\n }\n if (isTargetInsideSource) {\n newSourceChildren = newSourceChildren.updateIn(expandTreeSubpath(targetSubpathFromSource, \"children1\"), function (_oldChildren) {\n return newTargetChildren;\n });\n newSourceChildren = newSourceChildren[\"delete\"](from.get(\"id\"));\n }\n if (!isSameParent && !isSourceInsideTarget) state = state.updateIn(expandTreePath(sourcePath, \"children1\"), function (_oldChildren) {\n return newSourceChildren;\n });\n if (!isTargetInsideSource) state = state.updateIn(expandTreePath(targetPath, \"children1\"), function (_oldChildren) {\n return newTargetChildren;\n });\n state = fixPathsInTree(state);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {string} srcKey\n */\nvar setFieldSrc = function setFieldSrc(state, path, srcKey, config) {\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return state;\n }\n var keepInputOnChangeFieldSrc = config.settings.keepInputOnChangeFieldSrc;\n var currentProperties = currentRule.get(\"properties\");\n var currentField = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"field\");\n var currentFielType = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"fieldType\");\n var currentFieldConfig = getFieldConfig(config, currentField);\n // const currentType = currentRule.get(\"type\");\n // const currentFieldSrc = currentProperties?.get(\"fieldSrc\");\n\n // get fieldType for \"memory effect\"\n var fieldType = (currentFieldConfig === null || currentFieldConfig === void 0 ? void 0 : currentFieldConfig.type) || currentFielType;\n if (!fieldType || fieldType === \"!group\" || fieldType === \"!struct\") {\n fieldType = null;\n }\n var canReuseValue = !selectTypes.includes(fieldType);\n var keepInput = keepInputOnChangeFieldSrc && !isEmptyItem(currentRule, config) && canReuseValue;\n if (!keepInput) {\n // clear ALL properties\n state = state.setIn(expandTreePath(path, \"properties\"), defaultRuleProperties(config, null, null, false));\n } else {\n // clear non-relevant properties\n state = state.setIn(expandTreePath(path, \"properties\", \"field\"), null);\n state = state.deleteIn(expandTreePath(path, \"properties\", \"fieldError\"));\n // set fieldType for \"memory effect\"\n state = state.setIn(expandTreePath(path, \"properties\", \"fieldType\"), fieldType);\n }\n\n // set fieldSrc\n state = state.setIn(expandTreePath(path, \"properties\", \"fieldSrc\"), srcKey);\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {Array} parentFuncs\n * @param {string | null} argKey\n * @param {*} argValue if argKey is null, it's new func key\n * @param {string | \"!valueSrc\"} valueType\n * @param {*} asyncListValues\n */\nvar setFuncValue = function setFuncValue(config, state, path, delta, parentFuncs, argKey, argValue, valueType, asyncListValues) {\n var _meta = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : {};\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return state;\n }\n var isLHS = delta === -1;\n var currentProperties = currentRule.get(\"properties\");\n var currentField = currentProperties.get(\"field\");\n var currentValue = currentProperties.get(\"value\");\n var currentV = isLHS ? currentField : currentValue.getIn([delta]);\n\n // go inwards\n var funcsPath = [];\n var targetFV = currentV;\n var _iterator2 = _createForOfIteratorHelper(parentFuncs || []),\n _step2;\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var _step2$value = _slicedToArray(_step2.value, 2),\n _funcK = _step2$value[0],\n _argK = _step2$value[1];\n funcsPath.push([_funcK, _argK, targetFV]);\n if (_funcK !== targetFV.get(\"func\")) {\n var funcPath = funcsPath.map(function (_ref) {\n var _ref2 = _slicedToArray(_ref, 2),\n f = _ref2[0],\n a = _ref2[1];\n return \"\".concat(f, \"(\").concat(a, \")\");\n }).join(\"/\") || \"root\";\n throw new Error(\"In \".concat(isLHS ? \"LHS\" : \"RHS\", \" for path \").concat(funcPath, \" expected func key \").concat(_funcK, \" but got \").concat(targetFV.get(\"func\")));\n }\n targetFV = targetFV.getIn([\"args\", _argK, \"value\"]);\n }\n\n // modify\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n if (!argKey) {\n var newFuncKey = argValue;\n var canFixArgs = true; // try to fix args to fit new func validations, otherwise - drop invalid args\n targetFV = setFunc(targetFV, newFuncKey, config, canFixArgs);\n // allow drop invalid args / reset to default, but don't trigger error if some arg is required\n // (not same as setting isEndValue = true)\n _meta.canDropArgs = true;\n } else {\n var funcKey = targetFV.get(\"func\");\n var funcDefinition = getFuncConfig(config, funcKey);\n var args = funcDefinition.args;\n var argDefinition = args[argKey];\n if (valueType === \"!valueSrc\") {\n targetFV = setArgValueSrc(targetFV, argKey, argValue, argDefinition, config);\n } else {\n targetFV = setArgValue(targetFV, argKey, argValue, argDefinition, config);\n if (asyncListValues) {\n targetFV = setArgValueAsyncListValues(targetFV, argKey, asyncListValues, argDefinition, config);\n }\n }\n }\n\n // go outwards\n var newV = targetFV;\n while (funcsPath.length) {\n var _funcsPath$pop = funcsPath.pop(),\n _funcsPath$pop2 = _slicedToArray(_funcsPath$pop, 3),\n funcK = _funcsPath$pop2[0],\n argK = _funcsPath$pop2[1],\n parentFV = _funcsPath$pop2[2];\n var _funcDefinition = getFuncConfig(config, funcK);\n var _args = _funcDefinition.args;\n var _argDefinition = _args[argK];\n newV = setArgValue(parentFV, argK, newV, _argDefinition, config);\n }\n if (isLHS) {\n return setField(state, path, newV, config, undefined, _meta);\n } else {\n return setValue(state, path, delta, newV, undefined, config, undefined, _meta);\n }\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {string | Immutable.OrderedMap} newField\n */\nvar setField = function setField(state, path, newField, config, asyncListValues) {\n var _newFieldConfig$opera, _currentField$get, _newField, _newField$get;\n var _meta = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return {\n state: state\n };\n }\n var isEndValue = _meta.isEndValue,\n canDropArgs = _meta.canDropArgs;\n if (!newField) {\n state = removeItem(state, path);\n return {\n state: state\n };\n }\n var _config$settings2 = config.settings,\n fieldSeparator = _config$settings2.fieldSeparator,\n setOpOnChangeField = _config$settings2.setOpOnChangeField,\n showErrorMessage = _config$settings2.showErrorMessage;\n if (Array.isArray(newField)) newField = newField.join(fieldSeparator);\n var currentType = currentRule.get(\"type\");\n var currentProperties = currentRule.get(\"properties\");\n var wasRuleGroup = currentType == \"rule_group\";\n var currentFieldSrc = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"fieldSrc\");\n // const currentFieldError = currentProperties?.get(\"fieldError\");\n var newFieldConfig = getFieldConfig(config, newField);\n if (!newFieldConfig) {\n console.warn(\"No config for LHS \".concat(newField));\n return {\n state: state\n };\n }\n var fieldType = newFieldConfig.type;\n if (fieldType === \"!group\" || fieldType === \"!struct\") {\n fieldType = null;\n }\n var currentOperator = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"operator\");\n var currentOperatorOptions = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"operatorOptions\");\n var currentField = currentProperties === null || currentProperties === void 0 ? void 0 : currentProperties.get(\"field\");\n // const currentValue = currentProperties?.get(\"value\");\n // const currentValueErrorStr = currentProperties?.get(\"valueError\")?.join?.(\"|\");\n // const _currentValueSrc = currentProperties?.get(\"valueSrc\", new Immutable.List());\n // const _currentValueType = currentProperties?.get(\"valueType\", new Immutable.List());\n\n var isRuleGroup = newFieldConfig.type == \"!group\";\n var isRuleGroupExt = isRuleGroup && newFieldConfig.mode == \"array\";\n var isChangeToAnotherType = wasRuleGroup != isRuleGroup;\n // const wasOkWithoutField = !currentField && currentFieldSrc && currentOperator;\n\n // If the newly selected field supports the same operator the rule currently\n // uses, keep it selected.\n var lastOp = newFieldConfig && ((_newFieldConfig$opera = newFieldConfig.operators) === null || _newFieldConfig$opera === void 0 ? void 0 : _newFieldConfig$opera.indexOf(currentOperator)) !== -1 ? currentOperator : null;\n var isSameFunc = currentFieldSrc === \"func\" && (currentField === null || currentField === void 0 || (_currentField$get = currentField.get) === null || _currentField$get === void 0 ? void 0 : _currentField$get.call(currentField, \"func\")) === ((_newField = newField) === null || _newField === void 0 || (_newField$get = _newField.get) === null || _newField$get === void 0 ? void 0 : _newField$get.call(_newField, \"func\"));\n var forceKeepOp = isSameFunc && !!lastOp;\n var newOperator = null;\n var availOps = currentFieldSrc === \"func\" ? getOperatorsForType(config, fieldType) : getOperatorsForField(config, newField);\n if (availOps && availOps.length == 1) newOperator = availOps[0];else if (forceKeepOp) newOperator = lastOp;else if (availOps && availOps.length > 1) {\n var _iterator3 = _createForOfIteratorHelper(setOpOnChangeField),\n _step3;\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var strategy = _step3.value;\n if (strategy == \"keep\" && !isChangeToAnotherType) newOperator = lastOp;else if (strategy == \"default\") newOperator = getDefaultOperator(config, newField, false);else if (strategy == \"first\") newOperator = getFirstOperator(config, newField);\n if (newOperator)\n //found op for strategy\n break;\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n }\n if (!isRuleGroup && !newFieldConfig.operators) {\n console.warn(\"Type \".concat(newFieldConfig.type, \" is not supported\"));\n return {\n state: state\n };\n }\n if (wasRuleGroup && !isRuleGroup) {\n state = state.setIn(expandTreePath(path, \"type\"), \"rule\");\n state = state.deleteIn(expandTreePath(path, \"children1\"));\n state = state.setIn(expandTreePath(path, \"properties\"), new Immutable.OrderedMap());\n }\n if (!currentProperties) {\n state = state.setIn(expandTreePath(path, \"properties\"), new Immutable.OrderedMap());\n }\n var canFix = !showErrorMessage;\n if (isRuleGroup) {\n state = state.setIn(expandTreePath(path, \"type\"), \"rule_group\");\n var _getNewValueForFieldO = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, config, currentProperties, newField, newOperator, \"field\", canFix, isEndValue, canDropArgs),\n canReuseValue = _getNewValueForFieldO.canReuseValue,\n newValue = _getNewValueForFieldO.newValue,\n newValueSrc = _getNewValueForFieldO.newValueSrc,\n newValueType = _getNewValueForFieldO.newValueType,\n operatorCardinality = _getNewValueForFieldO.operatorCardinality;\n var groupProperties = defaultGroupProperties(config, newFieldConfig, newField).merge({\n field: newField,\n fieldSrc: \"field\",\n mode: newFieldConfig.mode\n });\n if (isRuleGroupExt) {\n groupProperties = groupProperties.merge({\n operator: newOperator,\n value: newValue,\n valueSrc: newValueSrc,\n valueType: newValueType\n });\n }\n state = state.setIn(expandTreePath(path, \"children1\"), new Immutable.OrderedMap());\n state = state.setIn(expandTreePath(path, \"properties\"), groupProperties);\n if (newFieldConfig.initialEmptyWhere && operatorCardinality == 1) {// just `COUNT(grp) > 1` without `HAVING ..`\n // no children\n } else {\n state = addItem(state, path, \"rule\", uuid(), defaultRuleProperties(config, newField), config);\n }\n state = fixPathsInTree(state);\n } else {\n state = state.updateIn(expandTreePath(path, \"properties\"), function (map) {\n return map.withMutations(function (current) {\n var _getNewValueForFieldO2 = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, config, current, newField, newOperator, \"field\", canFix, isEndValue, canDropArgs),\n canReuseValue = _getNewValueForFieldO2.canReuseValue,\n newValue = _getNewValueForFieldO2.newValue,\n newValueSrc = _getNewValueForFieldO2.newValueSrc,\n newValueType = _getNewValueForFieldO2.newValueType,\n newValueError = _getNewValueForFieldO2.newValueError,\n newFieldError = _getNewValueForFieldO2.newFieldError,\n fixedField = _getNewValueForFieldO2.fixedField;\n // const newValueErrorStr = newValueError?.join?.(\"|\");\n var newCorrectField = newField;\n var willFixField = fixedField !== newField;\n if (willFixField) {\n newCorrectField = fixedField;\n }\n // tip: `newCorrectField` is SAFE to set: even if it can't be fixed, it is reverted to previous good field.\n // Unlike logic in `setValue()` action where we need to calc `canUpdValue`\n // const didFieldErrorChanged = showErrorMessage ? currentFieldError != newFieldError : !!currentFieldError != !!newFieldError;\n // const didValueErrorChanged = showErrorMessage ? currentValueErrorStr != newValueErrorStr : !!currentValueErrorStr != !!newValueErrorStr;\n // const didErrorChanged = didFieldErrorChanged || didValueErrorChanged;\n // isInternalValueChange = !didErrorChanged && !willFixField;\n if (showErrorMessage) {\n current = current.set(\"fieldError\", newFieldError);\n current = current.set(\"valueError\", newValueError);\n }\n var newOperatorOptions = canReuseValue ? currentOperatorOptions : defaultOperatorOptions(config, newOperator, newCorrectField);\n current = current.set(\"field\", newCorrectField)[\"delete\"](\"fieldType\") // remove \"memory effect\"\n .set(\"fieldSrc\", currentFieldSrc).set(\"operator\", newOperator).set(\"operatorOptions\", newOperatorOptions).set(\"value\", newValue).set(\"valueSrc\", newValueSrc).set(\"valueType\", newValueType);\n if (!canReuseValue) {\n current = current[\"delete\"](\"asyncListValues\");\n }\n return current;\n });\n });\n }\n return {\n state: state\n };\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {string} operator\n */\nvar setOperator = function setOperator(state, path, newOperator, config) {\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return state;\n }\n var showErrorMessage = config.settings.showErrorMessage;\n var properties = currentRule.get(\"properties\");\n var children = currentRule.get(\"children1\");\n var currentField = properties.get(\"field\");\n var currentFieldSrc = properties.get(\"fieldSrc\");\n var fieldConfig = getFieldConfig(config, currentField);\n var isRuleGroup = (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) == \"!group\";\n var operatorConfig = getOperatorConfig(config, newOperator, currentField);\n var operatorCardinality = operatorConfig ? getOpCardinality(operatorConfig) : null;\n var canFix = true;\n state = state.updateIn(expandTreePath(path, \"properties\"), function (map) {\n return map.withMutations(function (current) {\n var currentField = current.get(\"field\");\n var currentOperatorOptions = current.get(\"operatorOptions\");\n var _currentValue = current.get(\"value\", new Immutable.List());\n var _currentValueSrc = current.get(\"valueSrc\", new Immutable.List());\n var _currentOperator = current.get(\"operator\");\n var _getNewValueForFieldO3 = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, config, current, currentField, newOperator, \"operator\", canFix),\n canReuseValue = _getNewValueForFieldO3.canReuseValue,\n newValue = _getNewValueForFieldO3.newValue,\n newValueSrc = _getNewValueForFieldO3.newValueSrc,\n newValueType = _getNewValueForFieldO3.newValueType,\n newValueError = _getNewValueForFieldO3.newValueError;\n if (showErrorMessage) {\n current = current.set(\"valueError\", newValueError);\n }\n var newOperatorOptions = canReuseValue ? currentOperatorOptions : defaultOperatorOptions(config, newOperator, currentField);\n if (!canReuseValue) {\n current = current[\"delete\"](\"asyncListValues\");\n }\n return current.set(\"operator\", newOperator).set(\"operatorOptions\", newOperatorOptions).set(\"value\", newValue).set(\"valueSrc\", newValueSrc).set(\"valueType\", newValueType);\n });\n });\n if (isRuleGroup) {\n if (operatorCardinality == 0 && children.size == 0) {\n state = addItem(state, path, \"rule\", uuid(), defaultRuleProperties(config, currentField), config);\n }\n }\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {*} value\n * @param {string} valueType\n * @param {*} asyncListValues\n */\nvar setValue = function setValue(state, path, delta, value, valueType, config, asyncListValues) {\n var _meta = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : {};\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return {\n state: state\n };\n }\n var canDropArgs = _meta.canDropArgs,\n isEndValue = _meta.isEndValue;\n var _config$settings3 = config.settings,\n fieldSeparator = _config$settings3.fieldSeparator,\n showErrorMessage = _config$settings3.showErrorMessage;\n var valueSrc = state.getIn(expandTreePath(path, \"properties\", \"valueSrc\", delta + \"\")) || null;\n if (valueSrc === \"field\" && Array.isArray(value)) value = value.join(fieldSeparator);\n var field = state.getIn(expandTreePath(path, \"properties\", \"field\")) || null;\n //const fieldSrc = state.getIn(expandTreePath(path, \"properties\", \"fieldSrc\")) || null;\n var operator = state.getIn(expandTreePath(path, \"properties\", \"operator\")) || null;\n var operatorConfig = getOperatorConfig(config, operator, field);\n var operatorCardinality = operator ? getOpCardinality(operatorConfig) : null;\n var calculatedValueType = valueType || calculateValueType(value, valueSrc, config);\n var canFix = !showErrorMessage;\n var _validateValue = validateValue(config, field, field, operator, value, calculatedValueType, valueSrc, asyncListValues, canFix, isEndValue, canDropArgs),\n _validateValue2 = _slicedToArray(_validateValue, 2),\n fixedValue = _validateValue2[0],\n allErrors = _validateValue2[1];\n var firstError = allErrors === null || allErrors === void 0 ? void 0 : allErrors.find(function (e) {\n return !e.fixed && !e.ignore;\n });\n var validationError = firstError ? translateValidation(firstError) : null;\n // tip: even if canFix == false, use fixedValue, it can SAFELY fix value of select\n // (get exact value from listValues, not string)\n var willFix = fixedValue !== value;\n if (willFix) {\n value = fixedValue;\n }\n\n // init lists\n state = initEmptyValueLists(state, path, config, operatorCardinality);\n\n // Additional validation for range values\n var values = Array.from({\n length: operatorCardinality\n }, function (_, i) {\n return i == delta ? value : state.getIn(expandTreePath(path, \"properties\", \"value\", i + \"\")) || null;\n });\n var valueSrcs = Array.from({\n length: operatorCardinality\n }, function (_, i) {\n return state.getIn(expandTreePath(path, \"properties\", \"valueSrc\", i + \"\")) || null;\n });\n var rangeErrorObj = validateRange(config, field, operator, values, valueSrcs);\n var rangeValidationError = rangeErrorObj ? translateValidation(rangeErrorObj) : null;\n var isValid = !validationError && !rangeValidationError;\n var canUpdValue = showErrorMessage ? true : isValid || willFix; // set only good value\n // const lastValue = state.getIn(expandTreePath(path, \"properties\", \"value\", delta));\n // const lastError = state.getIn(expandTreePath(path, \"properties\", \"valueError\", delta));\n // const lastRangeError = state.getIn(expandTreePath(path, \"properties\", \"valueError\", operatorCardinality));\n // const didDeltaErrorChanged = showErrorMessage ? lastError != validationError : !!lastError != !!validationError;\n // const didRangeErrorChanged = showErrorMessage ? lastRangeError != rangeValidationError : !!lastRangeError != !!rangeValidationError;\n // const didErrorChanged = didDeltaErrorChanged || didRangeErrorChanged;\n // const didEmptinessChanged = !!lastValue != !!value;\n // isInternalValueChange = !didEmptinessChanged && !didErrorChanged && !willFix;\n\n if (canUpdValue) {\n state = state.deleteIn(expandTreePath(path, \"properties\", \"asyncListValues\"));\n if (typeof value === \"undefined\") {\n state = state.setIn(expandTreePath(path, \"properties\", \"value\", delta), undefined);\n state = state.setIn(expandTreePath(path, \"properties\", \"valueType\", delta), null);\n } else {\n if (asyncListValues) {\n state = state.setIn(expandTreePath(path, \"properties\", \"asyncListValues\"), asyncListValues);\n }\n state = state.setIn(expandTreePath(path, \"properties\", \"value\", delta), value);\n state = state.setIn(expandTreePath(path, \"properties\", \"valueType\", delta), calculatedValueType);\n }\n }\n if (showErrorMessage) {\n // check list\n var lastValueErrorArr = state.getIn(expandTreePath(path, \"properties\", \"valueError\"));\n if (!lastValueErrorArr) {\n state = state.setIn(expandTreePath(path, \"properties\", \"valueError\"), new Immutable.List(new Array(operatorCardinality)));\n }\n // set error at delta\n state = state.setIn(expandTreePath(path, \"properties\", \"valueError\", delta), validationError);\n // set range error\n if (operatorCardinality >= 2) {\n state = state.setIn(expandTreePath(path, \"properties\", \"valueError\", operatorCardinality), rangeValidationError);\n }\n }\n return {\n state: state\n };\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {*} srcKey\n */\nvar setValueSrc = function setValueSrc(state, path, delta, srcKey, config) {\n var _meta = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return state;\n }\n var showErrorMessage = config.settings.showErrorMessage;\n var field = state.getIn(expandTreePath(path, \"properties\", \"field\")) || null;\n //const fieldSrc = state.getIn(expandTreePath(path, \"properties\", \"fieldSrc\")) || null;\n var operator = state.getIn(expandTreePath(path, \"properties\", \"operator\")) || null;\n var operatorConfig = getOperatorConfig(config, operator, field);\n var operatorCardinality = operator ? getOpCardinality(operatorConfig) : null;\n\n // init lists\n state = initEmptyValueLists(state, path, config, operatorCardinality);\n state = state.setIn(expandTreePath(path, \"properties\", \"value\", delta + \"\"), undefined);\n state = state.setIn(expandTreePath(path, \"properties\", \"valueType\", delta + \"\"), null);\n state = state.deleteIn(expandTreePath(path, \"properties\", \"asyncListValues\"));\n if (showErrorMessage) {\n // clear value error\n state = state.setIn(expandTreePath(path, \"properties\", \"valueError\", delta), null);\n\n // if current operator is range, clear possible range error\n if (operatorConfig !== null && operatorConfig !== void 0 && operatorConfig.validateValues) {\n state = state.setIn(expandTreePath(path, \"properties\", \"valueError\", operatorCardinality), null);\n }\n }\n\n // set valueSrc\n if (typeof srcKey === \"undefined\") {\n state = state.setIn(expandTreePath(path, \"properties\", \"valueSrc\", delta + \"\"), null);\n } else {\n state = state.setIn(expandTreePath(path, \"properties\", \"valueSrc\", delta + \"\"), srcKey);\n }\n\n // maybe set default value\n if (srcKey) {\n var properties = state.getIn(expandTreePath(path, \"properties\"));\n // this call should return canReuseValue = false and provide default value\n var canFix = true;\n var _getNewValueForFieldO4 = getNewValueForFieldOp({\n validateValue: validateValue,\n validateRange: validateRange\n }, config, config, properties, field, operator, \"valueSrc\", canFix),\n canReuseValue = _getNewValueForFieldO4.canReuseValue,\n newValue = _getNewValueForFieldO4.newValue,\n newValueSrc = _getNewValueForFieldO4.newValueSrc,\n newValueType = _getNewValueForFieldO4.newValueType,\n newValueError = _getNewValueForFieldO4.newValueError;\n if (!canReuseValue && newValueSrc.get(delta) == srcKey) {\n state = state.setIn(expandTreePath(path, \"properties\", \"value\", delta + \"\"), newValue.get(delta));\n state = state.setIn(expandTreePath(path, \"properties\", \"valueType\", delta + \"\"), newValueType.get(delta));\n }\n }\n return state;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {Immutable.List} path\n * @param {string} name\n * @param {*} value\n */\nvar setOperatorOption = function setOperatorOption(state, path, name, value) {\n var currentRule = state.getIn(expandTreePath(path));\n if (!currentRule) {\n // incorrect path\n return state;\n }\n return state.setIn(expandTreePath(path, \"properties\", \"operatorOptions\", name), value);\n};\n\n/**\n * @param {Immutable.Map} state\n */\nvar checkEmptyGroups = function checkEmptyGroups(state, config) {\n var canLeaveEmptyGroup = config.settings.canLeaveEmptyGroup;\n if (!canLeaveEmptyGroup) {\n state = fixEmptyGroupsInTree(state);\n }\n return state;\n};\nvar initEmptyValueLists = function initEmptyValueLists(state, path, config, operatorCardinality) {\n if (!operatorCardinality) {\n var field = state.getIn(expandTreePath(path, \"properties\", \"field\")) || null;\n var operator = state.getIn(expandTreePath(path, \"properties\", \"operator\")) || null;\n var operatorConfig = getOperatorConfig(config, operator, field);\n operatorCardinality = operator ? getOpCardinality(operatorConfig) : null;\n }\n for (var _i = 0, _arr = [\"value\", \"valueType\", \"valueError\", \"valueSrc\"]; _i < _arr.length; _i++) {\n var k = _arr[_i];\n if (!state.getIn(expandTreePath(path, \"properties\", k))) {\n state = state.setIn(expandTreePath(path, \"properties\", k), new Immutable.List(operatorCardinality ? Array.from({\n length: operatorCardinality\n }) : []));\n }\n }\n return state;\n};\n\n// convert children deeply from JS to Immutable\nvar _addChildren = function _addChildren1(config, item, children) {\n if (children && Array.isArray(children)) {\n item.children1 = new Immutable.OrderedMap(children.reduce(function (map, it) {\n var _it$id;\n var id1 = (_it$id = it.id) !== null && _it$id !== void 0 ? _it$id : uuid();\n var it1 = _objectSpread(_objectSpread({}, it), {}, {\n properties: defaultItemProperties(config, it).merge(fromJS(it.properties) || {}),\n id: id1\n });\n _addChildren(config, it1, it1.children1);\n //todo: guarantee order\n return _objectSpread(_objectSpread({}, map), {}, _defineProperty({}, id1, new Immutable.Map(it1)));\n }, {}));\n }\n};\nvar getField = function getField(state, path) {\n var field = state.getIn(expandTreePath(path, \"properties\", \"field\")) || null;\n return field;\n};\nvar emptyDrag = {\n dragging: {\n id: null,\n x: null,\n y: null,\n w: null,\n h: null\n },\n mousePos: {},\n dragStart: {\n id: null\n }\n};\nvar getActionMeta = function getActionMeta(action, state) {\n if (!action || !action.type) return null;\n var actionKeysToOmit = [\"config\", \"asyncListValues\"];\n var actionTypesToIgnore = [constants.SET_TREE, constants.SET_DRAG_START, constants.SET_DRAG_PROGRESS, constants.SET_DRAG_END];\n var meta = mapValues(omit(action, actionKeysToOmit), applyToJS);\n var affectedField = action.path && getField(state.tree, action.path) || action.field;\n if (affectedField) {\n var _affectedField;\n if ((_affectedField = affectedField) !== null && _affectedField !== void 0 && _affectedField.toJS) affectedField = affectedField.toJS();\n meta.affectedField = affectedField;\n }\n if (actionTypesToIgnore.includes(action.type) || action.type.indexOf(\"@@redux\") == 0) meta = null;\n return meta;\n};\n\n/**\n * @param {Immutable.Map} state\n * @param {object} action\n */\nexport default (function (initialConfig, tree, getMemoizedTree, setLastTree, getLastConfig) {\n var initTree = tree;\n var emptyState = _objectSpread({\n tree: initTree\n }, emptyDrag);\n return function () {\n var _ref3, _getLastConfig;\n var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : emptyState;\n var action = arguments.length > 1 ? arguments[1] : undefined;\n var config = (_ref3 = (_getLastConfig = getLastConfig === null || getLastConfig === void 0 ? void 0 : getLastConfig()) !== null && _getLastConfig !== void 0 ? _getLastConfig : action === null || action === void 0 ? void 0 : action.config) !== null && _ref3 !== void 0 ? _ref3 : initialConfig;\n var unset = {\n __lastAction: undefined\n };\n var set = {};\n var actionMeta = getActionMeta(action, state);\n switch (action === null || action === void 0 ? void 0 : action.type) {\n case constants.SET_TREE:\n {\n var validatedTree = getMemoizedTree(config, action.tree);\n set.tree = validatedTree;\n break;\n }\n case constants.ADD_CASE_GROUP:\n {\n set.tree = addNewGroup(state.tree, action.path, \"case_group\", action.id, action.properties, config, action.children, action.meta);\n break;\n }\n case constants.ADD_GROUP:\n {\n set.tree = addNewGroup(state.tree, action.path, \"group\", action.id, action.properties, config, action.children, action.meta);\n break;\n }\n case constants.REMOVE_GROUP:\n {\n set.tree = removeGroup(state.tree, action.path, config);\n break;\n }\n case constants.ADD_RULE:\n {\n set.tree = addItem(state.tree, action.path, action.ruleType, action.id, action.properties, config, action.children);\n break;\n }\n case constants.REMOVE_RULE:\n {\n set.tree = removeRule(state.tree, action.path, config);\n break;\n }\n case constants.SET_CONJUNCTION:\n {\n set.tree = setConjunction(state.tree, action.path, action.conjunction);\n break;\n }\n case constants.SET_NOT:\n {\n set.tree = setNot(state.tree, action.path, action.not);\n break;\n }\n case constants.SET_FIELD:\n {\n var _setField = setField(state.tree, action.path, action.field, config, action.asyncListValues, action._meta),\n newTree = _setField.state;\n set.tree = newTree;\n break;\n }\n case constants.SET_FIELD_SRC:\n {\n set.tree = setFieldSrc(state.tree, action.path, action.srcKey, config);\n break;\n }\n case constants.SET_LOCK:\n {\n set.tree = setLock(state.tree, action.path, action.lock);\n break;\n }\n case constants.SET_OPERATOR:\n {\n set.tree = setOperator(state.tree, action.path, action.operator, config);\n break;\n }\n case constants.SET_VALUE:\n {\n var _setValue = setValue(state.tree, action.path, action.delta, action.value, action.valueType, config, action.asyncListValues, action._meta),\n _newTree = _setValue.state;\n set.tree = _newTree;\n break;\n }\n case constants.SET_FUNC_VALUE:\n {\n var _setFuncValue = setFuncValue(config, state.tree, action.path, action.delta, action.parentFuncs, action.argKey, action.value, action.valueType, action.asyncListValues, action._meta),\n _newTree2 = _setFuncValue.state;\n set.tree = _newTree2;\n break;\n }\n case constants.SET_VALUE_SRC:\n {\n set.tree = setValueSrc(state.tree, action.path, action.delta, action.srcKey, config, action._meta);\n break;\n }\n case constants.SET_OPERATOR_OPTION:\n {\n set.tree = setOperatorOption(state.tree, action.path, action.name, action.value);\n break;\n }\n case constants.MOVE_ITEM:\n {\n set.tree = moveItem(state.tree, action.fromPath, action.toPath, action.placement, config);\n break;\n }\n case constants.SET_DRAG_START:\n {\n set.dragStart = action.dragStart;\n set.dragging = action.dragging;\n set.mousePos = action.mousePos;\n break;\n }\n case constants.SET_DRAG_PROGRESS:\n {\n set.mousePos = action.mousePos;\n set.dragging = action.dragging;\n break;\n }\n case constants.SET_DRAG_END:\n {\n set.tree = checkEmptyGroups(state.tree, config);\n set = _objectSpread(_objectSpread({}, set), emptyDrag);\n break;\n }\n default:\n {\n break;\n }\n }\n if (actionMeta) {\n set.__lastAction = actionMeta;\n }\n if (setLastTree && set.tree && state.tree) {\n setLastTree(state.tree);\n }\n return _objectSpread(_objectSpread(_objectSpread({}, state), unset), set);\n };\n});","import Immutable, { fromJS } from \"immutable\";\nimport { toImmutableList } from \"../utils/stuff\";\nimport * as constants from \"../stores/constants\";\nimport { defaultRuleProperties, defaultGroupProperties } from \"../utils/defaultRuleUtils\";\nimport uuid from \"../utils/uuid\";\n\n/**\n * @param {object} config\n * @param {Immutable.Map} tree\n */\nexport var setTree = function setTree(config, tree) {\n return {\n type: constants.SET_TREE,\n tree: tree,\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nexport var addRule = function addRule(config, path, properties) {\n var ruleType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : \"rule\";\n var children = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var parentRuleGroupField = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n return {\n type: constants.ADD_RULE,\n ruleType: ruleType,\n children: children,\n path: toImmutableList(path),\n id: uuid(),\n properties: defaultRuleProperties(config, parentRuleGroupField).merge(fromJS(properties) || {}),\n config: config,\n meta: {\n parentRuleGroupField: parentRuleGroupField\n }\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n */\nexport var removeRule = function removeRule(config, path) {\n return {\n type: constants.REMOVE_RULE,\n path: toImmutableList(path),\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nexport var addDefaultCaseGroup = function addDefaultCaseGroup(config, path, properties) {\n var children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n return {\n type: constants.ADD_CASE_GROUP,\n path: toImmutableList(path),\n children: children,\n id: uuid(),\n properties: defaultGroupProperties(config).merge(fromJS(properties) || {}),\n config: config,\n meta: {\n isDefaultCase: true\n }\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nexport var addCaseGroup = function addCaseGroup(config, path, properties) {\n var children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n return {\n type: constants.ADD_CASE_GROUP,\n path: toImmutableList(path),\n children: children,\n id: uuid(),\n properties: defaultGroupProperties(config).merge(fromJS(properties) || {}),\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {Immutable.Map} properties\n */\nexport var addGroup = function addGroup(config, path, properties) {\n var children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var parentRuleGroupField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n return {\n type: constants.ADD_GROUP,\n path: toImmutableList(path),\n children: children,\n id: uuid(),\n properties: defaultGroupProperties(config, parentRuleGroupField).merge(fromJS(properties) || {}),\n config: config,\n meta: {\n parentRuleGroupField: parentRuleGroupField\n }\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n */\nexport var removeGroup = function removeGroup(config, path) {\n return {\n type: constants.REMOVE_GROUP,\n path: toImmutableList(path),\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Array} fromPath\n * @param {Array} toPath\n * @param {String} placement, see constants PLACEMENT_*\n */\nexport var moveItem = function moveItem(config, fromPath, toPath, placement) {\n return {\n type: constants.MOVE_ITEM,\n fromPath: toImmutableList(fromPath),\n toPath: toImmutableList(toPath),\n placement: placement,\n config: config\n };\n};","import * as constants from \"../stores/constants\";\nimport { toImmutableList } from \"../utils/stuff\";\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {string} conjunction\n */\nexport var setConjunction = function setConjunction(config, path, conjunction) {\n return {\n type: constants.SET_CONJUNCTION,\n path: toImmutableList(path),\n conjunction: conjunction\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {bool} not\n */\nexport var setNot = function setNot(config, path, not) {\n return {\n type: constants.SET_NOT,\n path: toImmutableList(path),\n not: not\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {bool} lock\n */\nexport var setLock = function setLock(config, path, lock) {\n return {\n type: constants.SET_LOCK,\n path: toImmutableList(path),\n lock: lock\n };\n};","import * as constants from \"../stores/constants\";\nimport { toImmutableList } from \"../utils/stuff\";\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {string} field\n */\nexport var setField = function setField(config, path, field, asyncListValues, _meta) {\n return {\n type: constants.SET_FIELD,\n path: toImmutableList(path),\n field: field,\n config: config,\n asyncListValues: asyncListValues,\n _meta: _meta\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {*} srcKey\n */\nexport var setFieldSrc = function setFieldSrc(config, path, srcKey) {\n return {\n type: constants.SET_FIELD_SRC,\n path: toImmutableList(path),\n srcKey: srcKey,\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {string} operator\n */\nexport var setOperator = function setOperator(config, path, operator) {\n return {\n type: constants.SET_OPERATOR,\n path: toImmutableList(path),\n operator: operator,\n config: config\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {*} value\n * @param {string} valueType\n * @param {*} asyncListValues\n */\nexport var setValue = function setValue(config, path, delta, value, valueType, asyncListValues, _meta) {\n return {\n type: constants.SET_VALUE,\n path: toImmutableList(path),\n delta: delta,\n value: value,\n valueType: valueType,\n asyncListValues: asyncListValues,\n config: config,\n _meta: _meta\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {*} srcKey\n */\nexport var setValueSrc = function setValueSrc(config, path, delta, srcKey, _meta) {\n return {\n type: constants.SET_VALUE_SRC,\n path: toImmutableList(path),\n delta: delta,\n srcKey: srcKey,\n config: config,\n _meta: _meta\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {integer} delta\n * @param {Array} parentFuncs\n * @param {string | null} argKey\n * @param {*} value\n * @param {string | \"!valueSrc\"} valueType\n * @param {*} asyncListValues\n */\nexport var setFuncValue = function setFuncValue(config, path, delta, parentFuncs, argKey, value, valueType, asyncListValues, _meta) {\n return {\n type: constants.SET_FUNC_VALUE,\n path: toImmutableList(path),\n delta: delta,\n parentFuncs: parentFuncs,\n argKey: argKey,\n value: value,\n valueType: valueType,\n asyncListValues: asyncListValues,\n config: config,\n _meta: _meta\n };\n};\n\n/**\n * @param {object} config\n * @param {Immutable.List} path\n * @param {string} name\n * @param {*} value\n */\nexport var setOperatorOption = function setOperatorOption(config, path, name, value) {\n return {\n type: constants.SET_OPERATOR_OPTION,\n path: toImmutableList(path),\n name: name,\n value: value,\n config: config\n };\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport * as Export from \"./export\";\nimport * as Import from \"./import\";\nimport * as BasicUtils from \"./utils\";\nimport * as BasicFuncs from \"./config/funcs\";\nimport CoreConfig, { ConfigMixins } from \"./config\";\nimport TreeStore from \"./stores/tree\";\nimport * as TreeActions from \"./actions\";\nimport Immutable from \"immutable\";\nvar Utils = _objectSpread(_objectSpread(_objectSpread({}, BasicUtils), {}, {\n Export: Export,\n Import: Import,\n // intrenal\n ConfigMixins: ConfigMixins\n}, Export), Import);\nexport { Utils, BasicFuncs, CoreConfig, TreeStore, TreeActions, Immutable };","import { TreeStore } from \"@react-awesome-query-builder/core\";\nexport default TreeStore;","import React from \"react\";\nexport default /*#__PURE__*/React.createContext();","export var ADD_GROUP = \"ADD_GROUP\";\nexport var ADD_CASE_GROUP = \"ADD_CASE_GROUP\";\nexport var REMOVE_GROUP = \"REMOVE_GROUP\";\nexport var SET_CONJUNCTION = \"SET_CONJUNCTION\";\nexport var SET_NOT = \"SET_NOT\";\nexport var ADD_RULE = \"ADD_RULE\";\nexport var REMOVE_RULE = \"REMOVE_RULE\";\nexport var SET_FIELD = \"SET_FIELD\";\nexport var SET_FIELD_SRC = \"SET_FIELD_SRC\";\nexport var SET_OPERATOR = \"SET_OPERATOR\";\nexport var SET_VALUE = \"SET_VALUE\";\nexport var SET_VALUE_SRC = \"SET_VALUE_SRC\";\nexport var SET_OPERATOR_OPTION = \"SET_OPERATOR_OPTION\";\nexport var SET_LOCK = \"SET_LOCK\";\nexport var SET_TREE = \"SET_TREE\";\nexport var MOVE_ITEM = \"MOVE_ITEM\";\nexport var PLACEMENT_AFTER = \"after\";\nexport var PLACEMENT_BEFORE = \"before\";\nexport var PLACEMENT_APPEND = \"append\";\nexport var PLACEMENT_PREPEND = \"prepend\";\nexport var SET_DRAG_PROGRESS = \"SET_DRAG_PROGRESS\";\nexport var SET_DRAG_START = \"SET_DRAG_START\";\nexport var SET_DRAG_END = \"SET_DRAG_END\";","import * as constants from \"../stores/constants\";\n\n/**\n * @param {Object} mousePos\n * @param {Object} dragging\n */\nexport var setDragProgress = function setDragProgress(mousePos, dragging) {\n return {\n type: constants.SET_DRAG_PROGRESS,\n mousePos: mousePos,\n dragging: dragging\n };\n};\n\n/**\n * @param {Object} dragStart\n * @param {Object} dragging\n * @param {Object} mousePos\n */\nexport var setDragStart = function setDragStart(dragStart, dragging, mousePos) {\n return {\n type: constants.SET_DRAG_START,\n dragStart: dragStart,\n dragging: dragging,\n mousePos: mousePos\n };\n};\n\n/**\n *\n */\nexport var setDragEnd = function setDragEnd() {\n return {\n type: constants.SET_DRAG_END\n };\n};","import { TreeActions } from \"@react-awesome-query-builder/core\";\nimport * as drag from \"./drag\";\nvar tree = TreeActions.tree,\n group = TreeActions.group,\n rule = TreeActions.rule;\nexport { tree, group, rule, drag };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n value: t,\n enumerable: !0,\n configurable: !0,\n writable: !0\n }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nexport var getOpCardinality = function getOpCardinality(opDef) {\n var _opDef$cardinality;\n return (_opDef$cardinality = opDef === null || opDef === void 0 ? void 0 : opDef.cardinality) !== null && _opDef$cardinality !== void 0 ? _opDef$cardinality : 1;\n};\nexport var truncateString = function truncateString(str, n, useWordBoundary) {\n if (!n || !str || str.length <= n) {\n return str;\n }\n var subString = str.substr(0, n - 1);\n return (useWordBoundary ? subString.substr(0, subString.lastIndexOf(\" \")) : subString) + \"...\";\n};\nexport var immutableEqual = function immutableEqual(v1, v2) {\n if (v1 === v2) {\n return true;\n } else {\n return v1 === null || v1 === void 0 ? void 0 : v1.equals(v2);\n }\n};\n\n// const deepEqual = function(v1, v2) {\n// if (v1 === v2) {\n// return true;\n// } else if (Map.isMap(v1)) {\n// return v1.equals(v2);\n// } else {\n// return JSON.stringify(v1) == JSON.stringify(v2);\n// }\n// };\n\nexport var shallowEqual = function shallowEqual(a, b) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (a === b) {\n return true;\n } else if (Array.isArray(a)) return shallowEqualArrays(a, b, deep);else if (a && typeof a.equals === \"function\") return a.equals(b);else if (_typeof(a) === \"object\") return shallowEqualObjects(a, b, deep);else return a === b;\n};\nfunction shallowEqualArrays(arrA, arrB) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (arrA === arrB) {\n return true;\n }\n if (!arrA || !arrB) {\n return false;\n }\n var len = arrA.length;\n if (arrB.length !== len) {\n return false;\n }\n for (var i = 0; i < len; i++) {\n var isEqual = deep ? shallowEqual(arrA[i], arrB[i], deep) : arrA[i] === arrB[i];\n if (!isEqual) {\n return false;\n }\n }\n return true;\n}\nfunction shallowEqualObjects(objA, objB) {\n var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (objA === objB) {\n return true;\n }\n if (!objA || !objB) {\n return false;\n }\n var aKeys = Object.keys(objA);\n var bKeys = Object.keys(objB);\n var len = aKeys.length;\n if (bKeys.length !== len) {\n return false;\n }\n for (var i = 0; i < len; i++) {\n var key = aKeys[i];\n var isEqual = deep ? shallowEqual(objA[key], objB[key], deep) : objA[key] === objB[key];\n if (!isEqual) {\n return false;\n }\n }\n return true;\n}\nvar isDev = function isDev() {\n var _process;\n return typeof process !== \"undefined\" && ((_process = process) === null || _process === void 0 || (_process = _process.env) === null || _process === void 0 ? void 0 : _process.NODE_ENV) == \"development\";\n};\nvar isTest = function isTest() {\n var _process2;\n return typeof process !== \"undefined\" && ((_process2 = process) === null || _process2 === void 0 || (_process2 = _process2.env) === null || _process2 === void 0 ? void 0 : _process2.NODE_ENV_TEST) == \"true\";\n};\nexport var getLogger = function getLogger(devMode) {\n if (isTest()) {\n return _objectSpread(_objectSpread({}, console), {}, {\n log: function log() {},\n debug: function debug() {},\n info: function info() {}\n });\n }\n var verbose = devMode != undefined ? devMode : isDev();\n return verbose ? console : {\n error: function error() {},\n log: function log() {},\n warn: function warn() {},\n debug: function debug() {},\n info: function info() {}\n };\n};\nexport var logger = getLogger();","import { immutableEqual } from \"./stuff\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nvar validateAndFixTree = Utils.Validation.validateAndFixTree;\nexport var createValidationMemo = function createValidationMemo() {\n var originalTree;\n var validatedTree;\n var configId;\n return function (config, tree) {\n var oldConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;\n var sanitizeTree = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;\n if (!tree) {\n return null;\n }\n if (config.__configId === configId && (immutableEqual(tree, originalTree) || immutableEqual(tree, validatedTree))) {\n return validatedTree;\n } else {\n configId = config.__configId;\n originalTree = tree;\n if (sanitizeTree === false) {\n validatedTree = validateAndFixTree(tree, null, config, oldConfig || config, false, false, false);\n } else {\n validatedTree = validateAndFixTree(tree, null, config, oldConfig || config);\n }\n return validatedTree;\n }\n };\n};","import React from \"react\";\nimport mapValues from \"lodash/mapValues\";\nimport { shallowEqual } from \"./stuff\";\nvar getReactContainerType = function getReactContainerType(el) {\n if (el._reactRootContainer) {\n return \"root\";\n }\n if (Object.getOwnPropertyNames(el).filter(function (k) {\n return k.startsWith(\"__reactContainer\");\n }).length > 0) {\n return \"container\";\n }\n return undefined;\n};\nvar _getReactRootNodeType = function getReactRootNodeType(node) {\n if (!node) {\n return undefined;\n }\n var type = getReactContainerType(node);\n if (type !== undefined) {\n return type;\n } else {\n return _getReactRootNodeType(node.parentNode);\n }\n};\nexport var isUsingLegacyReactDomRender = function isUsingLegacyReactDomRender(node) {\n return _getReactRootNodeType(node) === \"root\";\n};\nexport var liteShouldComponentUpdate = function liteShouldComponentUpdate(self, config) {\n return function (nextProps, nextState) {\n var prevProps = self.props;\n var prevState = self.state;\n var should = nextProps != prevProps || nextState != prevState;\n if (should) {\n if (prevState == nextState && prevProps != nextProps) {\n var chs = [];\n for (var k in nextProps) {\n var changed = nextProps[k] != prevProps[k];\n if (changed) {\n if (config[k] == \"ignore\") changed = false;else if (config[k] == \"shallow_deep\") changed = !shallowEqual(nextProps[k], prevProps[k], true);else if (config[k] == \"shallow\") changed = !shallowEqual(nextProps[k], prevProps[k]);else if (typeof config[k] == \"function\") changed = config[k](nextProps[k], prevProps[k], nextProps, prevProps);\n }\n if (changed) chs.push(k);\n }\n if (!chs.length) should = false;\n }\n }\n return should;\n };\n};\nexport var pureShouldComponentUpdate = function pureShouldComponentUpdate(self) {\n return function (nextProps, nextState) {\n return !shallowEqual(self.props, nextProps) || !shallowEqual(self.state, nextState);\n };\n};\nvar canUseOldComponentWillReceiveProps = function canUseOldComponentWillReceiveProps() {\n var v = React.version.split(\".\").map(parseInt.bind(null, 10));\n return v[0] == 16 && v[1] < 3 || v[0] < 16;\n};\nexport var useOnPropsChanged = function useOnPropsChanged(obj) {\n // 1. `shouldComponentUpdate` should be called after `componentWillReceiveProps`\n // 2. `shouldComponentUpdate` should not be used for PureComponent\n\n // Because `useOnPropsChanged` can only be applied to `Component` not `PureComponent`, make it pure now\n if (!obj.shouldComponentUpdate) {\n obj.shouldComponentUpdate = pureShouldComponentUpdate(obj);\n }\n if (canUseOldComponentWillReceiveProps()) {\n // Use old method\n obj.componentWillReceiveProps = function (nextProps) {\n obj.onPropsChanged(nextProps);\n };\n } else {\n // Simulate `componentWillReceiveProps` with `shouldComponentUpdate`\n var origShouldComponentUpdate = obj.shouldComponentUpdate;\n var newShouldComponentUpdate = function newShouldComponentUpdate(nextProps, nextState) {\n var shouldNotify = !shallowEqual(obj.props, nextProps);\n if (shouldNotify) {\n obj.onPropsChanged(nextProps);\n }\n var shouldUpdate = origShouldComponentUpdate.call(obj, nextProps, nextState);\n return shouldUpdate;\n };\n obj.shouldComponentUpdate = newShouldComponentUpdate.bind(obj);\n }\n};\nexport var bindActionCreators = function bindActionCreators(actionCreators, config, dispatch) {\n return mapValues(actionCreators, function (actionCreator) {\n return function () {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n return dispatch(actionCreator.apply(void 0, [config].concat(args)));\n };\n });\n};","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport merge from \"lodash/merge\";\nimport { connect } from \"react-redux\";\nimport context from \"../stores/context\";\nimport PropTypes from \"prop-types\";\nimport * as actions from \"../actions\";\nimport { immutableEqual } from \"../utils/stuff\";\nimport { useOnPropsChanged, liteShouldComponentUpdate, bindActionCreators } from \"../utils/reactUtils\";\nvar Query = /*#__PURE__*/function (_Component) {\n function Query(props) {\n var _this;\n _classCallCheck(this, Query);\n _this = _callSuper(this, Query, [props]);\n _this.shouldComponentUpdate = liteShouldComponentUpdate(_this, {\n tree: function tree(nextValue) {\n if (nextValue === _this.oldValidatedTree && _this.oldValidatedTree === _this.validatedTree) {\n // Got value dispatched from QueryContainer\n // Ignore, because we've just rendered it\n return false;\n }\n return true;\n }\n });\n useOnPropsChanged(_this);\n _this._updateActions(props);\n\n // For preventive validation (tree and config consistency)\n // When config has changed from QueryContainer, \n // but new dispatched validated tree value is not in redux store yet (tree prop is old)\n _this.validatedTree = props.getMemoizedTree(props.config, props.tree, undefined, props.sanitizeTree);\n _this.oldValidatedTree = _this.validatedTree;\n var basicConfig = props.getBasicConfig(props.config);\n props.onInit && props.onInit(_this.validatedTree, basicConfig, undefined, _this.actions);\n return _this;\n }\n _inherits(Query, _Component);\n return _createClass(Query, [{\n key: \"_updateActions\",\n value: function _updateActions(props) {\n var config = props.config,\n dispatch = props.dispatch;\n this.actions = bindActionCreators(_objectSpread(_objectSpread(_objectSpread({}, actions.tree), actions.group), actions.rule), config, dispatch);\n }\n }, {\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var onChange = nextProps.onChange;\n var oldConfig = this.props.config;\n var newTree = nextProps.tree;\n var oldTree = this.props.tree;\n var newConfig = nextProps.config;\n this.oldValidatedTree = this.validatedTree;\n this.validatedTree = newTree;\n if (oldConfig !== newConfig) {\n this._updateActions(nextProps);\n this.validatedTree = nextProps.getMemoizedTree(newConfig, newTree, oldConfig);\n }\n var validatedTreeChanged = !immutableEqual(this.validatedTree, this.oldValidatedTree);\n if (validatedTreeChanged) {\n var newBasicConfig = nextProps.getBasicConfig(newConfig);\n onChange && onChange(this.validatedTree, newBasicConfig, nextProps.__lastAction, this.actions);\n }\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n renderBuilder = _this$props.renderBuilder,\n dispatch = _this$props.dispatch;\n var builderProps = {\n tree: this.validatedTree,\n actions: this.actions,\n config: config,\n dispatch: dispatch\n };\n return renderBuilder(builderProps);\n }\n }]);\n}(Component);\nQuery.propTypes = {\n config: PropTypes.object.isRequired,\n onChange: PropTypes.func,\n onInit: PropTypes.func,\n renderBuilder: PropTypes.func,\n tree: PropTypes.any //instanceOf(Immutable.Map)\n //dispatch: PropTypes.func.isRequired,\n //__lastAction\n //getMemoizedTree: PropTypes.func.isRequired,\n //getBasicConfig: PropTypes.func.isRequired,\n //sanitizeTree\n};\nvar ConnectedQuery = connect(function (state) {\n return {\n tree: state.tree,\n __lastAction: state.__lastAction\n };\n}, null, null, {\n context: context\n})(Query);\nConnectedQuery.displayName = \"ConnectedQuery\";\nexport default ConnectedQuery;","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component, PureComponent } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport treeStoreReducer from \"../stores/tree\";\nimport context from \"../stores/context\";\nimport { createStore } from \"redux\";\nimport { Provider } from \"react-redux\";\nimport * as actions from \"../actions\";\nimport { immutableEqual } from \"../utils/stuff\";\nimport { createValidationMemo } from \"../utils/validationMemo\";\nimport { liteShouldComponentUpdate, useOnPropsChanged } from \"../utils/reactUtils\";\nimport ConnectedQuery from \"./Query\";\nvar defaultRoot = Utils.DefaultUtils.defaultRoot;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n createConfigMemo = _Utils$ConfigUtils.createConfigMemo,\n extendConfig = _Utils$ConfigUtils.extendConfig;\nvar QueryContainer = /*#__PURE__*/function (_Component) {\n function QueryContainer(props, context) {\n var _this$_reactInternals, _this$_reactInternals2;\n var _this;\n _classCallCheck(this, QueryContainer);\n _this = _callSuper(this, QueryContainer, [props, context]);\n _this.setLastTree = function (lastTree) {\n if (_this.prevTree) {\n _this.prevprevTree = _this.prevTree;\n }\n _this.prevTree = lastTree;\n };\n _this.getConfig = function () {\n return _this.config;\n };\n _this.shouldComponentUpdate = liteShouldComponentUpdate(_this, {\n value: function value(nextValue, prevValue) {\n return false;\n }\n });\n useOnPropsChanged(_this);\n var _createConfigMemo = createConfigMemo({\n reactIndex: (_this$_reactInternals = (_this$_reactInternals2 = _this._reactInternals) === null || _this$_reactInternals2 === void 0 ? void 0 : _this$_reactInternals2.index) !== null && _this$_reactInternals !== void 0 ? _this$_reactInternals : -1,\n maxSize: 2,\n // current and prev\n canCompile: true,\n extendConfig: extendConfig\n }),\n getExtendedConfig = _createConfigMemo.getExtendedConfig,\n getBasicConfig = _createConfigMemo.getBasicConfig,\n clearConfigMemo = _createConfigMemo.clearConfigMemo;\n _this.getMemoizedConfig = getExtendedConfig;\n _this.getBasicConfig = getBasicConfig;\n _this.clearConfigMemo = clearConfigMemo;\n _this.getMemoizedTree = createValidationMemo();\n var config = _this.getMemoizedConfig(props);\n var shouldCreateEmptyGroup = config.settings.shouldCreateEmptyGroup;\n var canAddDefaultRule = !shouldCreateEmptyGroup; // if prop `value` is not provided, can add default/empty rule?\n var emptyTree = defaultRoot(config, canAddDefaultRule);\n var sanitizeTree = !!props.value;\n var tree = props.value || emptyTree;\n var validatedTree = _this.getMemoizedTree(config, tree, undefined, sanitizeTree);\n var reducer = treeStoreReducer(config, validatedTree, _this.getMemoizedTree, _this.setLastTree, _this.getConfig);\n var store = createStore(reducer);\n _this.config = config;\n _this.state = {\n store: store\n };\n _this.QueryWrapper = function (pr) {\n return config.settings.renderProvider(pr, config.ctx);\n };\n return _this;\n }\n _inherits(QueryContainer, _Component);\n return _createClass(QueryContainer, [{\n key: \"componentWillUnmount\",\n value: function componentWillUnmount() {\n this.clearConfigMemo();\n }\n }, {\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n // compare configs\n var prevProps = this.props;\n var oldConfig = this.config;\n var nextConfig = this.getMemoizedConfig(nextProps);\n var isConfigChanged = oldConfig !== nextConfig;\n\n // compare trees\n var storeValue = this.state.store.getState().tree;\n var isTreeChanged = !immutableEqual(nextProps.value, this.props.value) && !immutableEqual(nextProps.value, storeValue);\n var currentTree = isTreeChanged ? nextProps.value || defaultRoot(nextProps) : storeValue;\n var isTreeTrulyChanged = isTreeChanged && !immutableEqual(nextProps.value, this.prevTree) && !immutableEqual(nextProps.value, this.prevprevTree);\n this.sanitizeTree = isTreeTrulyChanged || isConfigChanged;\n var canUseOldConfig = isConfigChanged && !isTreeChanged;\n if (isConfigChanged) {\n if (prevProps.settings.renderProvider !== nextProps.settings.renderProvider) {\n this.QueryWrapper = function (props) {\n return nextConfig.settings.renderProvider(props, nextConfig.ctx);\n };\n }\n this.config = nextConfig;\n }\n if (isTreeChanged || isConfigChanged) {\n var validatedTree = this.getMemoizedTree(nextConfig, currentTree, canUseOldConfig ? oldConfig : undefined, this.sanitizeTree);\n //return Promise.resolve().then(() => {\n this.state.store.dispatch(actions.tree.setTree(nextConfig, validatedTree));\n //});\n }\n }\n }, {\n key: \"render\",\n value: function render() {\n // `get_children` is deprecated!\n var _this$props = this.props,\n renderBuilder = _this$props.renderBuilder,\n get_children = _this$props.get_children,\n onChange = _this$props.onChange,\n onInit = _this$props.onInit;\n var store = this.state.store;\n var config = this.config;\n var QueryWrapper = this.QueryWrapper;\n return /*#__PURE__*/React.createElement(QueryWrapper, {\n config: config\n }, /*#__PURE__*/React.createElement(Provider, {\n store: store,\n context: context\n }, /*#__PURE__*/React.createElement(ConnectedQuery, {\n config: config,\n getMemoizedTree: this.getMemoizedTree,\n getBasicConfig: this.getBasicConfig,\n sanitizeTree: this.sanitizeTree,\n onChange: onChange,\n onInit: onInit,\n renderBuilder: renderBuilder || get_children\n })));\n }\n }]);\n}(Component);\nQueryContainer.propTypes = {\n //config\n conjunctions: PropTypes.object.isRequired,\n fields: PropTypes.object.isRequired,\n types: PropTypes.object.isRequired,\n operators: PropTypes.object.isRequired,\n widgets: PropTypes.object.isRequired,\n settings: PropTypes.object.isRequired,\n ctx: PropTypes.object.isRequired,\n onChange: PropTypes.func,\n onInit: PropTypes.func,\n renderBuilder: PropTypes.func,\n value: PropTypes.any //instanceOf(Immutable.Map)\n};\nexport { QueryContainer as default };","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nfunction _objectWithoutProperties(e, t) {\n if (null == e) return {};\n var o,\n r,\n i = objectWithoutPropertiesLoose(e, t);\n if (Object.getOwnPropertySymbols) {\n var n = Object.getOwnPropertySymbols(e);\n for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);\n }\n return i;\n}\nexport { _objectWithoutProperties as default };","function _objectWithoutPropertiesLoose(r, e) {\n if (null == r) return {};\n var t = {};\n for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n if (-1 !== e.indexOf(n)) continue;\n t[n] = r[n];\n }\n return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","function _extends() {\n return _extends = Object.assign ? Object.assign.bind() : function (n) {\n for (var e = 1; e < arguments.length; e++) {\n var t = arguments[e];\n for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n }\n return n;\n }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","function _arrayLikeToArray(r, a) {\n (null == a || a > r.length) && (a = r.length);\n for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n return n;\n}\nexport { _arrayLikeToArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n if (r) {\n if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n var t = {}.toString.call(r).slice(8, -1);\n return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n }\n}\nexport { _unsupportedIterableToArray as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport context from \"../../stores/context\";\nimport { pureShouldComponentUpdate } from \"../../utils/reactUtils\";\nimport { connect } from \"react-redux\";\nimport classNames from \"classnames\";\nvar getFieldConfig = Utils.ConfigUtils.getFieldConfig;\nvar createRuleContainer = function createRuleContainer(Rule) {\n var _RuleContainer;\n return _RuleContainer = /*#__PURE__*/function (_Component) {\n function RuleContainer(props) {\n var _this;\n _classCallCheck(this, RuleContainer);\n _this = _callSuper(this, RuleContainer, [props]);\n _this.dummyFn = function () {};\n _this.removeSelf = function () {\n _this.props.actions.removeRule(_this.props.path);\n };\n _this.setLock = function () {\n var lock = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n _this.props.actions.setLock(_this.props.path, lock);\n };\n _this.setField = function (field, asyncListValues, _meta) {\n _this.props.actions.setField(_this.props.path, field, asyncListValues, _meta);\n };\n _this.setFieldSrc = function (srcKey) {\n _this.props.actions.setFieldSrc(_this.props.path, srcKey);\n };\n _this.setOperator = function (operator) {\n _this.props.actions.setOperator(_this.props.path, operator);\n };\n _this.setOperatorOption = function (name, value) {\n _this.props.actions.setOperatorOption(_this.props.path, name, value);\n };\n _this.setValue = function (delta, value, type, asyncListValues, _meta) {\n _this.props.actions.setValue(_this.props.path, delta, value, type, asyncListValues, _meta);\n };\n _this.setValueSrc = function (delta, srcKey, _meta) {\n _this.props.actions.setValueSrc(_this.props.path, delta, srcKey, _meta);\n };\n // can be used for both LHS and LHS\n _this.setFuncValue = function (delta, parentFuncs, argKey, value, type, asyncListValues, _meta) {\n _this.props.actions.setFuncValue(_this.props.path, delta, parentFuncs, argKey, value, type, asyncListValues, _meta);\n };\n _this.pureShouldComponentUpdate = pureShouldComponentUpdate(_this);\n _this.dummyFn.isDummyFn = true;\n return _this;\n }\n _inherits(RuleContainer, _Component);\n return _createClass(RuleContainer, [{\n key: \"shouldComponentUpdate\",\n value: function shouldComponentUpdate(nextProps, nextState) {\n var prevProps = this.props;\n var prevState = this.state;\n var should = this.pureShouldComponentUpdate(nextProps, nextState);\n if (should) {\n if (prevState == nextState && prevProps != nextProps) {\n var draggingId = nextProps.dragging.id || prevProps.dragging.id;\n var isDraggingMe = draggingId == nextProps.id;\n var chs = [];\n for (var k in nextProps) {\n var changed = nextProps[k] != prevProps[k];\n if (k == \"dragging\" && !isDraggingMe) {\n changed = false; //dragging another item -> ignore\n }\n if (changed) {\n chs.push(k);\n }\n }\n if (!chs.length) should = false;\n }\n }\n return should;\n }\n }, {\n key: \"render\",\n value: function render() {\n var isDraggingMe = this.props.dragging.id == this.props.id;\n var fieldConfig = getFieldConfig(this.props.config, this.props.field);\n var fieldType = this.props.fieldType || (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) || null;\n var showErrorMessage = this.props.config.settings.showErrorMessage;\n var _isGroup = fieldConfig && fieldConfig.type == \"!struct\";\n var isInDraggingTempo = !isDraggingMe && this.props.isDraggingTempo;\n var _this$props = this.props,\n valueError = _this$props.valueError,\n fieldError = _this$props.fieldError;\n var oneError = [fieldError].concat(_toConsumableArray((valueError === null || valueError === void 0 ? void 0 : valueError.toArray()) || [])).filter(function (e) {\n return !!e;\n }).shift() || null;\n var hasError = oneError != null && showErrorMessage;\n return /*#__PURE__*/React.createElement(\"div\", {\n className: classNames(\"group-or-rule-container\", \"rule-container\", hasError ? \"rule-with-error\" : null),\n \"data-id\": this.props.id\n }, [isDraggingMe ? /*#__PURE__*/React.createElement(Rule, {\n key: \"dragging\",\n id: this.props.id,\n groupId: this.props.groupId,\n lev: this.props.path.size - 1,\n isDraggingMe: true,\n isDraggingTempo: true,\n dragging: this.props.dragging,\n setField: this.dummyFn,\n setFieldSrc: this.dummyFn,\n setFuncValue: this.dummyFn,\n setOperator: this.dummyFn,\n setOperatorOption: this.dummyFn,\n setLock: this.dummyFn,\n removeSelf: this.dummyFn,\n setValue: this.dummyFn,\n setValueSrc: this.dummyFn,\n selectedField: this.props.field || null,\n selectedFieldSrc: this.props.fieldSrc || \"field\",\n selectedFieldType: fieldType,\n parentField: this.props.parentField || null,\n parentFieldPathSize: this.props.parentFieldPathSize,\n parentFieldCanReorder: this.props.parentFieldCanReorder,\n selectedOperator: this.props.operator || null,\n value: this.props.value || null,\n valueSrc: this.props.valueSrc || null,\n valueType: this.props.valueType || null,\n valueError: this.props.valueError || null,\n fieldError: this.props.fieldError || null,\n operatorOptions: this.props.operatorOptions,\n config: this.props.config,\n reordableNodesCnt: this.props.reordableNodesCnt,\n totalRulesCnt: this.props.totalRulesCnt,\n asyncListValues: this.props.asyncListValues,\n isLocked: this.props.isLocked,\n isTrueLocked: this.props.isTrueLocked,\n parentReordableNodesCnt: this.props.parentReordableNodesCnt\n }) : null, /*#__PURE__*/React.createElement(Rule, {\n key: this.props.id,\n id: this.props.id,\n groupId: this.props.groupId,\n lev: this.props.path.size - 1,\n isDraggingMe: isDraggingMe,\n isDraggingTempo: isInDraggingTempo,\n onDragStart: this.props.onDragStart,\n setLock: isInDraggingTempo ? this.dummyFn : this.setLock,\n removeSelf: isInDraggingTempo ? this.dummyFn : this.removeSelf,\n setField: isInDraggingTempo ? this.dummyFn : this.setField,\n setFieldSrc: isInDraggingTempo ? this.dummyFn : this.setFieldSrc,\n setFuncValue: isInDraggingTempo ? this.dummyFn : this.setFuncValue,\n setOperator: isInDraggingTempo ? this.dummyFn : this.setOperator,\n setOperatorOption: isInDraggingTempo ? this.dummyFn : this.setOperatorOption,\n setValue: isInDraggingTempo ? this.dummyFn : this.setValue,\n setValueSrc: isInDraggingTempo ? this.dummyFn : this.setValueSrc,\n selectedField: this.props.field || null,\n selectedFieldSrc: this.props.fieldSrc || \"field\",\n selectedFieldType: fieldType,\n parentField: this.props.parentField || null,\n parentFieldPathSize: this.props.parentFieldPathSize,\n parentFieldCanReorder: this.props.parentFieldCanReorder,\n selectedOperator: this.props.operator || null,\n value: this.props.value || null,\n valueSrc: this.props.valueSrc || null,\n valueType: this.props.valueType || null,\n valueError: this.props.valueError || null,\n fieldError: this.props.fieldError || null,\n operatorOptions: this.props.operatorOptions,\n config: this.props.config,\n reordableNodesCnt: this.props.reordableNodesCnt,\n totalRulesCnt: this.props.totalRulesCnt,\n asyncListValues: this.props.asyncListValues,\n isLocked: this.props.isLocked,\n isTrueLocked: this.props.isTrueLocked,\n parentReordableNodesCnt: this.props.parentReordableNodesCnt\n })]);\n }\n }]);\n }(Component), _RuleContainer.propTypes = {\n id: PropTypes.string.isRequired,\n groupId: PropTypes.string,\n config: PropTypes.object.isRequired,\n path: PropTypes.any.isRequired,\n //instanceOf(Immutable.List)\n operator: PropTypes.string,\n field: PropTypes.any,\n fieldSrc: PropTypes.string,\n fieldType: PropTypes.string,\n actions: PropTypes.object.isRequired,\n //{removeRule: Function, setField, setFieldSrc, setOperator, setOperatorOption, setValue, setValueSrc, ...}\n onDragStart: PropTypes.func,\n value: PropTypes.any,\n //depends on widget\n valueSrc: PropTypes.any,\n asyncListValues: PropTypes.array,\n valueError: PropTypes.any,\n fieldError: PropTypes.string,\n operatorOptions: PropTypes.object,\n reordableNodesCnt: PropTypes.number,\n parentField: PropTypes.string,\n //from RuleGroup\n isLocked: PropTypes.bool,\n isTrueLocked: PropTypes.bool,\n //connected:\n dragging: PropTypes.object,\n //{id, x, y, w, h}\n isDraggingTempo: PropTypes.bool\n }, _RuleContainer;\n};\nexport default (function (Rule) {\n var ConnectedRuleContainer = connect(function (state) {\n return {\n dragging: state.dragging\n };\n }, null, null, {\n context: context\n })(createRuleContainer(Rule));\n ConnectedRuleContainer.displayName = \"ConnectedRuleContainer\";\n return ConnectedRuleContainer;\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport { connect } from \"react-redux\";\nimport { logger } from \"../../utils/stuff\";\nimport context from \"../../stores/context\";\nimport * as constants from \"../../stores/constants\";\nimport PropTypes from \"prop-types\";\nimport * as actions from \"../../actions\";\nimport { pureShouldComponentUpdate, useOnPropsChanged, isUsingLegacyReactDomRender } from \"../../utils/reactUtils\";\nvar clone = Utils.OtherUtils.clone;\nvar getFlatTree = Utils.TreeUtils.getFlatTree;\nvar _isReorderingTree = false;\nvar createSortableContainer = function createSortableContainer(Builder) {\n var _SortableContainer;\n var CanMoveFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n return _SortableContainer = /*#__PURE__*/function (_Component) {\n function SortableContainer(props) {\n var _this;\n _classCallCheck(this, SortableContainer);\n _this = _callSuper(this, SortableContainer, [props]);\n _this._getEventTarget = function (e, dragStart) {\n return e && e.__mocked_window || document.body || window;\n };\n _this.onDragStart = function (id, dom, e) {\n var treeEl = dom.closest(\".query-builder\");\n if (!treeEl) {\n console.error(\"Please change renderBuilder implementation of <Query>: wrap <Builder> with div.query-builder for drag-n-drop support\");\n return;\n }\n if (_this._isUsingLegacyReactDomRender === undefined) {\n _this._isUsingLegacyReactDomRender = isUsingLegacyReactDomRender(treeEl);\n }\n document.body.classList.add(\"qb-dragging\");\n treeEl.classList.add(\"qb-dragging\");\n var treeElContainer = treeEl.closest(\".query-builder-container\") || treeEl;\n treeElContainer = _this._getScrollParent(treeElContainer) || document.body;\n var scrollTop = treeElContainer.scrollTop;\n var _dragEl = _this._getDraggableNodeEl(treeEl);\n var _plhEl = _this._getPlaceholderNodeEl(treeEl);\n var tmpAllGroups = treeEl.querySelectorAll(\".group--children\");\n var anyGroup = tmpAllGroups.length ? tmpAllGroups[0] : null;\n var groupPadding;\n if (anyGroup) {\n groupPadding = window.getComputedStyle(anyGroup, null).getPropertyValue(\"padding-left\");\n groupPadding = parseInt(groupPadding);\n }\n var dragging = {\n id: id,\n x: dom.offsetLeft,\n y: dom.offsetTop,\n w: dom.offsetWidth,\n h: dom.offsetHeight,\n itemInfo: _this.tree.items[id],\n paddingLeft: groupPadding\n };\n var dragStart = {\n id: id,\n x: dom.offsetLeft,\n y: dom.offsetTop,\n scrollTop: scrollTop,\n clientX: e.clientX,\n clientY: e.clientY,\n itemInfo: clone(_this.tree.items[id]),\n treeEl: treeEl,\n treeElContainer: treeElContainer\n };\n var mousePos = {\n clientX: e.clientX,\n clientY: e.clientY\n };\n var target = _this._getEventTarget(e, dragStart);\n _this.eventTarget = target;\n target.addEventListener(\"mousemove\", _this.onDrag);\n target.addEventListener(\"mouseup\", _this.onDragEnd);\n _this.props.setDragStart(dragStart, dragging, mousePos);\n };\n _this.onDrag = function (e) {\n var doHandleDrag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n var dragging = Object.assign({}, _this.props.dragging);\n var startDragging = _this.props.dragStart;\n var paddingLeft = dragging.paddingLeft; //this.props.paddingLeft;\n var treeElContainer = startDragging.treeElContainer;\n var scrollTop = treeElContainer.scrollTop;\n dragging.itemInfo = _this.tree.items[dragging.id];\n if (!dragging.itemInfo) {\n return;\n }\n var mousePos = {\n clientX: e.clientX,\n clientY: e.clientY\n };\n var startMousePos = {\n clientX: startDragging.clientX,\n clientY: startDragging.clientY\n };\n if (e.__mock_dom) {\n var treeEl = startDragging.treeEl;\n var dragEl = _this._getDraggableNodeEl(treeEl);\n var plhEl = _this._getPlaceholderNodeEl(treeEl);\n e.__mock_dom({\n treeEl: treeEl,\n dragEl: dragEl,\n plhEl: plhEl\n });\n }\n\n //first init plX/plY\n if (!startDragging.plX) {\n var _treeEl = startDragging.treeEl;\n var _plhEl2 = _this._getPlaceholderNodeEl(_treeEl);\n if (_plhEl2) {\n startDragging.plX = _plhEl2.getBoundingClientRect().left + window.scrollX;\n startDragging.plY = _plhEl2.getBoundingClientRect().top + window.scrollY;\n }\n }\n var startX = startDragging.x;\n var startY = startDragging.y;\n var startClientX = startDragging.clientX;\n var startClientY = startDragging.clientY;\n var startScrollTop = startDragging.scrollTop;\n var pos = {\n x: startX + (e.clientX - startClientX),\n y: startY + (e.clientY - startClientY) + (scrollTop - startScrollTop)\n };\n dragging.x = pos.x;\n dragging.y = pos.y;\n dragging.paddingLeft = paddingLeft;\n dragging.mousePos = mousePos;\n dragging.startMousePos = startMousePos;\n _this.props.setDragProgress(mousePos, dragging);\n var moved = doHandleDrag ? _this.handleDrag(dragging, e, CanMoveFn) : false;\n if (!moved) {\n if (e.preventDefault) e.preventDefault();\n }\n };\n _this.onDragEnd = function () {\n var treeEl = _this.props.dragStart.treeEl;\n _this.props.setDragEnd();\n treeEl.classList.remove(\"qb-dragging\");\n document.body.classList.remove(\"qb-dragging\");\n _this._cacheEls = {};\n var target = _this.eventTarget || _this._getEventTarget();\n target.removeEventListener(\"mousemove\", _this.onDrag);\n target.removeEventListener(\"mouseup\", _this.onDragEnd);\n };\n _this.pureShouldComponentUpdate = pureShouldComponentUpdate(_this);\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(SortableContainer, _Component);\n return _createClass(SortableContainer, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n this.tree = getFlatTree(nextProps.tree, nextProps.config);\n }\n }, {\n key: \"shouldComponentUpdate\",\n value: function shouldComponentUpdate(nextProps, nextState) {\n var prevProps = this.props;\n var prevState = this.state;\n var should = this.pureShouldComponentUpdate(nextProps, nextState);\n if (should) {\n if (prevState == nextState && prevProps != nextProps) {\n var chs = [];\n for (var k in nextProps) {\n var changed = nextProps[k] != prevProps[k];\n if (changed) {\n //don't render <Builder> on dragging - appropriate redux-connected components will do it\n if (k != \"dragging\" && k != \"mousePos\") chs.push(k);\n }\n }\n if (!chs.length) should = false;\n }\n }\n return should;\n }\n }, {\n key: \"componentDidUpdate\",\n value: function componentDidUpdate(_prevProps, _prevState) {\n var dragging = this.props.dragging;\n var startDragging = this.props.dragStart;\n _isReorderingTree = false;\n if (startDragging && startDragging.id) {\n dragging.itemInfo = this.tree.items[dragging.id];\n if (dragging.itemInfo) {\n if (dragging.itemInfo.index != startDragging.itemInfo.index || dragging.itemInfo.parent != startDragging.itemInfo.parent) {\n var treeEl = startDragging.treeEl;\n var treeElContainer = startDragging.treeElContainer;\n var plhEl = this._getPlaceholderNodeEl(treeEl, true);\n if (plhEl) {\n var plX = plhEl.getBoundingClientRect().left + window.scrollX;\n var plY = plhEl.getBoundingClientRect().top + window.scrollY;\n var oldPlX = startDragging.plX;\n var oldPlY = startDragging.plY;\n var scrollTop = treeElContainer.scrollTop;\n startDragging.plX = plX;\n startDragging.plY = plY;\n startDragging.itemInfo = clone(dragging.itemInfo);\n startDragging.y = plhEl.offsetTop;\n startDragging.x = plhEl.offsetLeft;\n startDragging.clientY += plY - oldPlY;\n startDragging.clientX += plX - oldPlX;\n if (treeElContainer != document.body) startDragging.scrollTop = scrollTop;\n this.onDrag(this.props.mousePos, false);\n }\n }\n }\n }\n }\n }, {\n key: \"_getNodeElById\",\n value: function _getNodeElById(treeEl, indexId) {\n var ignoreCache = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n if (indexId == null) return null;\n if (!this._cacheEls) this._cacheEls = {};\n var el = this._cacheEls[indexId];\n if (el && document.contains(el) && !ignoreCache) return el;\n el = treeEl.querySelector('.group-or-rule-container[data-id=\"' + indexId + '\"]');\n this._cacheEls[indexId] = el;\n return el;\n }\n }, {\n key: \"_getDraggableNodeEl\",\n value: function _getDraggableNodeEl(treeEl) {\n var ignoreCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n if (!this._cacheEls) this._cacheEls = {};\n var el = this._cacheEls[\"draggable\"];\n if (el && document.contains(el) && !ignoreCache) return el;\n var els = treeEl.getElementsByClassName(\"qb-draggable\");\n el = els.length ? els[0] : null;\n this._cacheEls[\"draggable\"] = el;\n return el;\n }\n }, {\n key: \"_getPlaceholderNodeEl\",\n value: function _getPlaceholderNodeEl(treeEl) {\n var ignoreCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n if (!this._cacheEls) this._cacheEls = {};\n var el = this._cacheEls[\"placeholder\"];\n if (el && document.contains(el) && !ignoreCache) return el;\n var els = treeEl.getElementsByClassName(\"qb-placeholder\");\n el = els.length ? els[0] : null;\n this._cacheEls[\"placeholder\"] = el;\n return el;\n }\n }, {\n key: \"_isScrollable\",\n value: function _isScrollable(node) {\n var overflowY = window.getComputedStyle(node)[\"overflow-y\"];\n return (overflowY === \"scroll\" || overflowY === \"auto\") && node.scrollHeight > node.offsetHeight;\n }\n }, {\n key: \"_getScrollParent\",\n value: function _getScrollParent(node) {\n if (node == null) return null;\n if (node === document.body || this._isScrollable(node)) {\n return node;\n } else {\n return this._getScrollParent(node.parentNode);\n }\n }\n }, {\n key: \"handleDrag\",\n value: function handleDrag(dragInfo, e, canMoveFn) {\n var _this2 = this;\n var canMoveBeforeAfterGroup = true;\n var itemInfo = dragInfo.itemInfo;\n var paddingLeft = dragInfo.paddingLeft;\n var moveInfo = null;\n var treeEl = this.props.dragStart.treeEl;\n var dragId = dragInfo.id;\n var dragEl = this._getDraggableNodeEl(treeEl);\n var plhEl = this._getPlaceholderNodeEl(treeEl);\n var dragRect, plhRect, hovRect, treeRect;\n if (dragEl && plhEl) {\n dragRect = dragEl.getBoundingClientRect();\n plhRect = plhEl.getBoundingClientRect();\n if (!plhRect.width) {\n return;\n }\n var dragDirs = {\n hrz: 0,\n vrt: 0\n };\n if (dragRect.top < plhRect.top) dragDirs.vrt = -1; //up\n else if (dragRect.bottom > plhRect.bottom) dragDirs.vrt = +1; //down\n if (dragRect.left > plhRect.left) dragDirs.hrz = +1; //right\n else if (dragRect.left < plhRect.left) dragDirs.hrz = -1; //left\n\n treeRect = treeEl.getBoundingClientRect();\n var trgCoord = {\n x: treeRect.left + (treeRect.right - treeRect.left) / 2,\n y: dragDirs.vrt >= 0 ? dragRect.bottom : dragRect.top\n };\n var hovCNodeEl;\n if (e.__mocked_hov_container) {\n hovCNodeEl = e.__mocked_hov_container;\n } else {\n var hovNodeEl = document.elementFromPoint(trgCoord.x, trgCoord.y - 1);\n hovCNodeEl = hovNodeEl ? hovNodeEl.closest(\".group-or-rule-container\") : null;\n if (!hovCNodeEl && hovNodeEl && hovNodeEl.classList.contains(\"query-builder-container\")) {\n var _hovNodeEl$firstChild;\n // fix 2022-01-24 - get root .group-or-rule-container\n var rootGroupContainer = hovNodeEl === null || hovNodeEl === void 0 || (_hovNodeEl$firstChild = hovNodeEl.firstChild) === null || _hovNodeEl$firstChild === void 0 ? void 0 : _hovNodeEl$firstChild.firstChild;\n if (rootGroupContainer && rootGroupContainer.classList.contains(\"group-or-rule-container\")) {\n hovCNodeEl = rootGroupContainer;\n }\n }\n }\n if (!hovCNodeEl) {\n logger.log(\"out of tree bounds!\");\n } else {\n var isGroup = hovCNodeEl.classList.contains(\"group-container\");\n var hovNodeId = hovCNodeEl.getAttribute(\"data-id\");\n var hovEl = hovCNodeEl;\n var doAppend = false;\n var doPrepend = false;\n if (hovEl) {\n hovRect = hovEl.getBoundingClientRect();\n var hovHeight = hovRect.bottom - hovRect.top;\n var hovII = this.tree.items[hovNodeId];\n if (!hovII) {\n throw new Error(\"There is an issue with rendering. If you use Next.js, please check getServerSideProps() method.\");\n }\n var trgRect = null,\n trgEl = null,\n trgII = null,\n altII = null; //for canMoveBeforeAfterGroup\n\n if (dragDirs.vrt == 0) {\n trgII = itemInfo;\n trgEl = plhEl;\n if (trgEl) trgRect = trgEl.getBoundingClientRect();\n } else {\n if (isGroup) {\n if (dragDirs.vrt > 0) {\n //down\n //take group header (for prepend only)\n var hovInnerEl = hovCNodeEl.getElementsByClassName(\"group--header\");\n var hovEl2 = hovInnerEl.length ? hovInnerEl[0] : null;\n if (hovEl2) {\n var hovRect2 = hovEl2.getBoundingClientRect();\n var hovHeight2 = hovRect2.bottom - hovRect2.top;\n var isOverHover = dragRect.bottom - hovRect2.top > hovHeight2 * 3 / 4;\n if (isOverHover && hovII.top > dragInfo.itemInfo.top) {\n trgII = hovII;\n trgRect = hovRect2;\n trgEl = hovEl2;\n doPrepend = true;\n }\n }\n } else if (dragDirs.vrt < 0) {\n //up\n if (hovII.lev >= itemInfo.lev) {\n //take whole group\n var isClimbToHover = hovRect.bottom - dragRect.top >= 2;\n if (isClimbToHover && hovII.top < dragInfo.itemInfo.top) {\n trgII = hovII;\n trgRect = hovRect;\n trgEl = hovEl;\n doAppend = true;\n }\n }\n }\n if (!doPrepend && !doAppend || canMoveBeforeAfterGroup) {\n //take whole group and check if we can move before/after group\n var _isOverHover = dragDirs.vrt < 0 //up\n ? hovRect.bottom - dragRect.top > hovHeight - 5 : dragRect.bottom - hovRect.top > hovHeight - 5;\n if (_isOverHover) {\n if (!doPrepend && !doAppend) {\n trgII = hovII;\n trgRect = hovRect;\n trgEl = hovEl;\n }\n if (canMoveBeforeAfterGroup) {\n altII = hovII;\n }\n }\n }\n } else {\n //check if we can move before/after group\n var _isOverHover2 = dragDirs.vrt < 0 //up\n ? hovRect.bottom - dragRect.top > hovHeight / 2 : dragRect.bottom - hovRect.top > hovHeight / 2;\n if (_isOverHover2) {\n trgII = hovII;\n trgRect = hovRect;\n trgEl = hovEl;\n }\n }\n }\n var isSamePos = trgII && trgII.id == dragId;\n if (trgRect) {\n var dragLeftOffset = dragRect.left - treeRect.left;\n var trgLeftOffset = trgRect.left - treeRect.left;\n var _trgLev = trgLeftOffset / paddingLeft;\n var dragLev = Math.max(0, Math.round(dragLeftOffset / paddingLeft));\n\n //find all possible moves\n var availMoves = [];\n var altMoves = []; //alternatively can move after/before group, if can't move into it\n if (isSamePos) {\n //do nothing\n } else {\n if (isGroup) {\n if (doAppend) {\n availMoves.push([constants.PLACEMENT_APPEND, trgII, trgII.lev + 1]);\n } else if (doPrepend) {\n availMoves.push([constants.PLACEMENT_PREPEND, trgII, trgII.lev + 1]);\n }\n //alt\n if (canMoveBeforeAfterGroup && altII) {\n // fix 2022-01-24: do prepend/append instead of before/after for root\n var isToRoot = altII.lev == 0;\n // fix 2022-01-25: fix prepend/append instead of before/after for case_group\n var isToCase = altII.type == \"case_group\" && itemInfo.type != \"case_group\";\n var prevCaseId = altII.prev && this.tree.items[altII.prev].caseId;\n var nextCaseId = altII.next && this.tree.items[altII.next].caseId;\n if (itemInfo.caseId == prevCaseId) prevCaseId = null;\n if (itemInfo.caseId == nextCaseId) nextCaseId = null;\n var prevCase = prevCaseId && this.tree.items[prevCaseId];\n var nextCase = nextCaseId && this.tree.items[nextCaseId];\n if (dragDirs.vrt > 0) {\n //down\n if (isToRoot) {\n altMoves.push([constants.PLACEMENT_APPEND, altII, altII.lev + 1]);\n } else if (isToCase && nextCase) {\n altMoves.push([constants.PLACEMENT_PREPEND, nextCase, nextCase.lev + 1]);\n } else {\n altMoves.push([constants.PLACEMENT_AFTER, altII, altII.lev]);\n }\n } else if (dragDirs.vrt < 0) {\n //up\n if (isToRoot) {\n altMoves.push([constants.PLACEMENT_PREPEND, altII, altII.lev + 1]);\n } else if (isToCase && prevCase) {\n altMoves.push([constants.PLACEMENT_APPEND, prevCase, prevCase.lev + 1]);\n } else {\n altMoves.push([constants.PLACEMENT_BEFORE, altII, altII.lev]);\n }\n }\n }\n }\n if (!doAppend && !doPrepend) {\n if (dragDirs.vrt < 0) {\n //up\n availMoves.push([constants.PLACEMENT_BEFORE, trgII, trgII.lev]);\n } else if (dragDirs.vrt > 0) {\n //down\n availMoves.push([constants.PLACEMENT_AFTER, trgII, trgII.lev]);\n }\n }\n }\n\n //add case\n var addCaseII = function addCaseII(am) {\n var toII = am[1];\n var fromCaseII = itemInfo.caseId ? _this2.tree.items[itemInfo.caseId] : null;\n var toCaseII = toII.caseId ? _this2.tree.items[toII.caseId] : null;\n return [].concat(_toConsumableArray(am), [fromCaseII, toCaseII]);\n };\n availMoves = availMoves.map(addCaseII);\n altMoves = altMoves.map(addCaseII);\n\n //sanitize\n availMoves = availMoves.filter(function (am) {\n var placement = am[0];\n var trg = am[1];\n if ((placement == constants.PLACEMENT_BEFORE || placement == constants.PLACEMENT_AFTER) && trg.parent == null) return false;\n if (trg.collapsed && (placement == constants.PLACEMENT_APPEND || placement == constants.PLACEMENT_PREPEND)) return false;\n var isInside = trg.id == itemInfo.id;\n if (!isInside) {\n var tmp = trg;\n while (tmp.parent) {\n tmp = _this2.tree.items[tmp.parent];\n if (tmp.id == itemInfo.id) {\n isInside = true;\n break;\n }\n }\n }\n return !isInside;\n }).map(function (am) {\n var placement = am[0],\n toII = am[1],\n _lev = am[2],\n _fromCaseII = am[3],\n _toCaseII = am[4];\n var toParentII = null;\n if (placement == constants.PLACEMENT_APPEND || placement == constants.PLACEMENT_PREPEND) toParentII = toII;else toParentII = _this2.tree.items[toII.parent];\n if (toParentII && toParentII.parent == null) toParentII = null;\n am[5] = toParentII;\n return am;\n });\n var bestMode = null;\n var filteredMoves = availMoves.filter(function (am) {\n return _this2.canMove(itemInfo, am[1], am[0], am[3], am[4], am[5], canMoveFn);\n });\n if (canMoveBeforeAfterGroup && filteredMoves.length == 0 && altMoves.length > 0) {\n filteredMoves = altMoves.filter(function (am) {\n return _this2.canMove(itemInfo, am[1], am[0], am[3], am[4], am[5], canMoveFn);\n });\n }\n var levs = filteredMoves.map(function (am) {\n return am[2];\n });\n var curLev = itemInfo.lev;\n var allLevs = levs.concat(curLev);\n var closestDragLev = null;\n if (allLevs.indexOf(dragLev) != -1) closestDragLev = dragLev;else if (dragLev > Math.max.apply(Math, _toConsumableArray(allLevs))) closestDragLev = Math.max.apply(Math, _toConsumableArray(allLevs));else if (dragLev < Math.min.apply(Math, _toConsumableArray(allLevs))) closestDragLev = Math.min.apply(Math, _toConsumableArray(allLevs));\n bestMode = filteredMoves.find(function (am) {\n return am[2] == closestDragLev;\n });\n if (!isSamePos && !bestMode && filteredMoves.length) bestMode = filteredMoves[0];\n moveInfo = bestMode;\n }\n }\n }\n }\n if (moveInfo) {\n this.move(itemInfo, moveInfo[1], moveInfo[0], moveInfo[3]);\n\n // logger.log(\"DRAG-N-DROP\", JSON.stringify({\n // dragRect,\n // plhRect,\n // treeRect,\n // hovRect,\n // startMousePos: dragInfo.startMousePos,\n // mousePos: dragInfo.mousePos,\n // }));\n return true;\n }\n return false;\n }\n }, {\n key: \"canMove\",\n value: function canMove(fromII, toII, placement, fromCaseII, toCaseII, toParentII, canMoveFn) {\n if (!fromII || !toII) return false;\n if (fromII.id === toII.id) return false;\n var _this$props$config$se = this.props.config.settings,\n canRegroup = _this$props$config$se.canRegroup,\n canRegroupCases = _this$props$config$se.canRegroupCases,\n maxNesting = _this$props$config$se.maxNesting,\n maxNumberOfRules = _this$props$config$se.maxNumberOfRules,\n canLeaveEmptyCase = _this$props$config$se.canLeaveEmptyCase;\n var newAtomicLev = toParentII ? toParentII.nextAtomicLev : toII.atomicLev;\n // tip: if group is empty, we still should use 1 (not 0) as depth because we could potentially add a rule inside it\n // tip: don't use fepth inside rule-group\n var newDepthLev = newAtomicLev + (fromII.closestRuleGroupId ? 0 : fromII.depth || (fromII.type == \"group\" ? 1 : 0));\n var isBeforeAfter = placement == constants.PLACEMENT_BEFORE || placement == constants.PLACEMENT_AFTER;\n var isPend = placement == constants.PLACEMENT_PREPEND || placement == constants.PLACEMENT_APPEND;\n var isLev1 = isBeforeAfter && toII.lev == 1 || isPend && toII.lev == 0;\n var isParentChange = fromII.parent != toII.parent;\n var isStructChange = isPend || isParentChange;\n // can't restruct `rule_group`\n var isRuleGroupAffected = fromII.type == \"rule_group\" || !!fromII.closestRuleGroupId || toII.type == \"rule_group\" || !!toII.closestRuleGroupId;\n var targetRuleGroupId = isPend && toII.type == \"rule_group\" ? toII.id : toII.closestRuleGroupId;\n var targetRuleGroupMaxNesting = isPend && toII.type == \"rule_group\" ? toII.maxNesting : toII.closestRuleGroupMaxNesting;\n var targetRuleGroupCanRegroup = (isPend && toII.type == \"rule_group\" ? toII.canRegroup : toII.closestRuleGroupCanRegroup) != false;\n var closestRuleGroupLev = isPend && toII.type == \"rule_group\" ? toII.lev : toII.closestRuleGroupLev;\n var newDepthLevInRuleGroup = (toParentII ? toParentII.lev + 1 : toII.lev) + (fromII.depth || (fromII.type == \"group\" ? 1 : 0)) - (closestRuleGroupLev || 0);\n var isForbiddenRuleGroupChange = isRuleGroupAffected && fromII.closestRuleGroupId != targetRuleGroupId;\n var isForbiddenCaseChange\n // can't move `case_group` anywhere but before/after anoter `case_group`\n = fromII.type == \"case_group\" && !isLev1\n // only `case_group` can be placed under `switch_group`\n || fromII.type != \"case_group\" && toII.type == \"case_group\" && isBeforeAfter || fromII.type != \"case_group\" && toII.type == \"switch_group\"\n // can't move rule/group to another case\n || !canRegroupCases && fromII.caseId != toII.caseId;\n var isForbiddenStructChange = isForbiddenCaseChange || isForbiddenRuleGroupChange;\n var isLockedChange = toII.isLocked || fromII.isLocked || toParentII && toParentII.isLocked;\n if (maxNesting && newDepthLev > maxNesting) {\n return false;\n }\n if (targetRuleGroupMaxNesting && newDepthLevInRuleGroup > targetRuleGroupMaxNesting) {\n return false;\n }\n if (isStructChange && (!canRegroup || isForbiddenStructChange || isLockedChange)) {\n return false;\n }\n if (isRuleGroupAffected && isStructChange && !targetRuleGroupCanRegroup) {\n return false;\n }\n if (fromII.type != \"case_group\" && fromII.caseId != toII.caseId) {\n var isLastFromCase = fromCaseII ? fromCaseII._height == 2 : false;\n var newRulesInTargetCase = toCaseII ? toCaseII.atomicRulesCountInCase + 1 : 0;\n if (maxNumberOfRules && newRulesInTargetCase > maxNumberOfRules) return false;\n if (isLastFromCase && !canLeaveEmptyCase) return false;\n }\n if (fromII.type == \"case_group\" && (fromII.isDefaultCase || toII.isDefaultCase || toII.type == \"switch_group\" && placement == constants.PLACEMENT_APPEND)) {\n // leave default case alone\n return false;\n }\n var res = true;\n if (canMoveFn) {\n res = canMoveFn(fromII.node.toJS(), toII.node.toJS(), placement, toParentII ? toParentII.node.toJS() : null);\n }\n return res;\n }\n }, {\n key: \"move\",\n value: function move(fromII, toII, placement, toParentII) {\n if (!this._isUsingLegacyReactDomRender) {\n _isReorderingTree = true;\n }\n //logger.log(\"move\", fromII, toII, placement, toParentII);\n this.props.actions.moveItem(fromII.path, toII.path, placement);\n }\n }, {\n key: \"render\",\n value: function render() {\n return /*#__PURE__*/React.createElement(Builder, _extends({}, this.props, {\n onDragStart: this.onDragStart\n }));\n }\n }]);\n }(Component), _SortableContainer.propTypes = {\n tree: PropTypes.any.isRequired,\n //instanceOf(Immutable.Map)\n actions: PropTypes.object.isRequired // {moveItem: Function, ..}\n //... see Builder\n }, _SortableContainer;\n};\nexport default (function (Builder) {\n var CanMoveFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n var ConnectedSortableContainer = connect(function (state) {\n return {\n dragging: state.dragging,\n dragStart: state.dragStart,\n mousePos: state.mousePos\n };\n }, {\n setDragStart: actions.drag.setDragStart,\n setDragProgress: actions.drag.setDragProgress,\n setDragEnd: actions.drag.setDragEnd\n }, null, {\n context: context\n })(createSortableContainer(Builder, CanMoveFn));\n ConnectedSortableContainer.displayName = \"ConnectedSortableContainer\";\n return ConnectedSortableContainer;\n});\nexport { _isReorderingTree };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nvar _excluded = [\"isDraggingTempo\", \"isDraggingMe\", \"dragging\"];\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nimport PropTypes from \"prop-types\";\nimport { _isReorderingTree } from \"./SortableContainer\";\nimport classNames from \"classnames\";\nexport default (function (className) {\n return function (GroupOrRule) {\n var _Draggable;\n return _Draggable = /*#__PURE__*/function (_PureComponent) {\n function Draggable(props) {\n var _this;\n _classCallCheck(this, Draggable);\n _this = _callSuper(this, Draggable, [props]);\n _this.handleDraggerMouseDown = function (e) {\n var nodeId = _this.props.id;\n var dom = _this.wrapper.current;\n if (_this.props.onDragStart) {\n _this.props.onDragStart(nodeId, dom, e);\n }\n };\n _this.wrapper = /*#__PURE__*/React.createRef();\n return _this;\n }\n _inherits(Draggable, _PureComponent);\n return _createClass(Draggable, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n isDraggingTempo = _this$props.isDraggingTempo,\n isDraggingMe = _this$props.isDraggingMe,\n dragging = _this$props.dragging,\n otherProps = _objectWithoutProperties(_this$props, _excluded);\n var isTrueLocked = otherProps.isTrueLocked;\n var styles = {};\n if (isDraggingMe && isDraggingTempo) {\n if (_isReorderingTree) {\n // don't apply old styles for dragging tempo during reorder\n } else {\n styles = {\n top: dragging.y,\n left: dragging.x,\n width: dragging.w\n };\n }\n }\n var cn = classNames(className, \"group-or-rule\", isDraggingMe && isDraggingTempo ? \"qb-draggable\" : null, isDraggingMe && !isDraggingTempo ? \"qb-placeholder\" : null, isTrueLocked ? \"locked\" : null);\n return /*#__PURE__*/React.createElement(\"div\", {\n className: cn,\n style: styles,\n ref: this.wrapper,\n \"data-id\": this.props.id\n }, /*#__PURE__*/React.createElement(GroupOrRule, _extends({\n handleDraggerMouseDown: this.handleDraggerMouseDown,\n isDraggingMe: isDraggingMe,\n isDraggingTempo: isDraggingTempo\n }, otherProps)));\n }\n }]);\n }(PureComponent), _Draggable.propTypes = {\n isDraggingTempo: PropTypes.bool,\n isDraggingMe: PropTypes.bool,\n onDragStart: PropTypes.func,\n dragging: PropTypes.object,\n //{id, x, y, w, h}\n isLocked: PropTypes.bool,\n isTrueLocked: PropTypes.bool\n }, _Draggable;\n };\n});","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport keys from \"lodash/keys\";\nimport pickBy from \"lodash/pickBy\";\nimport mapValues from \"lodash/mapValues\";\nimport { useOnPropsChanged, pureShouldComponentUpdate, liteShouldComponentUpdate } from \"../../utils/reactUtils\";\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getOperatorConfig = _Utils$ConfigUtils.getOperatorConfig;\nvar Operator = /*#__PURE__*/function (_Component) {\n function Operator(props) {\n var _this;\n _classCallCheck(this, Operator);\n _this = _callSuper(this, Operator, [props]);\n _this.shouldComponentUpdate = liteShouldComponentUpdate(_this, {\n // tip: rely on selectedFieldId instead\n selectedField: function selectedField(nextValue, prevValue) {\n return false;\n }\n });\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(Operator, _Component);\n return _createClass(Operator, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForMeta = [\"config\", \"selectedField\", \"selectedFieldSrc\", \"selectedFieldType\", \"selectedOperator\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref) {\n var _config$types$selecte;\n var config = _ref.config,\n selectedField = _ref.selectedField,\n selectedFieldType = _ref.selectedFieldType,\n selectedOperator = _ref.selectedOperator;\n var fieldConfig = getFieldConfig(config, selectedField);\n var operators = _toConsumableArray((fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.operators) || ((_config$types$selecte = config.types[selectedFieldType]) === null || _config$types$selecte === void 0 ? void 0 : _config$types$selecte.operators) || []);\n if (!selectedField && !operators.includes(selectedOperator)) {\n // eg. `prox` field was selected, then `fieldSrc` changed to `func`\n // But `text` type excludes `proximity` operator in config, so add manually\n operators.push(selectedOperator);\n }\n var operatorsOptions = mapValues(pickBy(config.operators, function (item, key) {\n return (operators === null || operators === void 0 ? void 0 : operators.indexOf(key)) !== -1;\n }), function (_opts, op) {\n return getOperatorConfig(config, op, selectedField);\n });\n var items = this.buildOptions(config, operatorsOptions, operators);\n var selectedOpts = operatorsOptions[selectedOperator] || {};\n var placeholder = this.props.config.settings.operatorPlaceholder;\n var selectedKey = selectedOperator;\n var selectedKeys = selectedKey ? [selectedKey] : null;\n var selectedPath = selectedKeys;\n var selectedLabel = selectedOpts.label;\n // tip: label2 is not documented for operators\n var selectedAltLabel = selectedOpts.label2 || selectedOpts.tooltip;\n return {\n placeholder: placeholder,\n items: items,\n selectedKey: selectedKey,\n selectedKeys: selectedKeys,\n selectedPath: selectedPath,\n selectedLabel: selectedLabel,\n selectedAltLabel: selectedAltLabel,\n selectedOpts: selectedOpts,\n fieldConfig: fieldConfig\n };\n }\n }, {\n key: \"buildOptions\",\n value: function buildOptions(config, fields, ops) {\n if (!fields || !ops) return null;\n return keys(fields).sort(function (a, b) {\n return ops.indexOf(a) - ops.indexOf(b);\n }).map(function (fieldKey) {\n var field = fields[fieldKey];\n var label = field.label;\n var altLabel = field.label2;\n var tooltip = field.tooltip;\n return {\n key: fieldKey,\n path: fieldKey,\n label: label,\n altLabel: altLabel,\n tooltip: tooltip\n };\n });\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n customProps = _this$props.customProps,\n setOperator = _this$props.setOperator,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId;\n var renderOperator = config.settings.renderOperator;\n var renderProps = _objectSpread({\n id: id,\n groupId: groupId,\n config: config,\n customProps: customProps,\n readonly: readonly,\n setField: setOperator\n }, this.meta);\n if (!renderProps.items) return null;\n return renderOperator(renderProps, config.ctx);\n }\n }]);\n}(Component);\nOperator.propTypes = {\n id: PropTypes.string,\n groupId: PropTypes.string,\n config: PropTypes.object.isRequired,\n selectedField: PropTypes.any,\n selectedFieldId: PropTypes.string,\n selectedFieldType: PropTypes.string,\n selectedFieldSrc: PropTypes.string,\n selectedOperator: PropTypes.string,\n readonly: PropTypes.bool,\n customProps: PropTypes.object,\n //actions\n setOperator: PropTypes.func.isRequired\n};\nexport { Operator as default };","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _slicedToArray(r, e) {\n return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();\n}\nexport { _slicedToArray as default };","function _arrayWithHoles(r) {\n if (Array.isArray(r)) return r;\n}\nexport { _arrayWithHoles as default };","function _iterableToArrayLimit(r, l) {\n var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n if (null != t) {\n var e,\n n,\n i,\n u,\n a = [],\n f = !0,\n o = !1;\n try {\n if (i = (t = t.call(r)).next, 0 === l) {\n if (Object(t) !== t) return;\n f = !1;\n } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n } catch (r) {\n o = !0, n = r;\n } finally {\n try {\n if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n } finally {\n if (o) throw n;\n }\n }\n return a;\n }\n}\nexport { _iterableToArrayLimit as default };","function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableRest as default };","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nvar _excluded = [\"children\"];\nimport React from \"react\";\nvar Col = function Col(_ref) {\n var children = _ref.children,\n props = _objectWithoutProperties(_ref, _excluded);\n return /*#__PURE__*/React.createElement(\"div\", props, children);\n};\nvar dummyFn = function dummyFn() {};\nvar DragIcon = function DragIcon() {\n return /*#__PURE__*/React.createElement(\"svg\", {\n xmlns: \"http://www.w3.org/2000/svg\",\n viewBox: \"0 0 24 24\",\n fill: \"gray\",\n width: \"18px\",\n height: \"18px\"\n }, /*#__PURE__*/React.createElement(\"path\", {\n d: \"M0 0h24v24H0V0z\",\n fill: \"none\"\n }), /*#__PURE__*/React.createElement(\"path\", {\n d: \"M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z\"\n }));\n};\nvar WithConfirmFn = function WithConfirmFn(Cmp) {\n return function (props) {\n var useConfirm = props.config.settings.useConfirm;\n var confirmFn = useConfirm ? useConfirm.call(props.config.ctx, props.config.ctx) : null;\n return /*#__PURE__*/React.createElement(Cmp, _extends({}, props, {\n confirmFn: confirmFn\n }));\n };\n};\nvar getWidgetId = function getWidgetId(_ref2) {\n var id = _ref2.id,\n isLHS = _ref2.isLHS,\n delta = _ref2.delta,\n parentFuncs = _ref2.parentFuncs;\n return [id, isLHS ? \"L\" : \"R\", isLHS ? -1 : delta || 0, (parentFuncs || []).map(function (_ref3) {\n var _ref4 = _slicedToArray(_ref3, 2),\n f = _ref4[0],\n a = _ref4[1];\n return \"\".concat(f, \"(\").concat(a, \")\");\n }).join(\"/\")].join(\":\");\n};\nvar getRenderFromConfig = function getRenderFromConfig(config, renderFn) {\n var Cmp;\n if (typeof renderFn === \"function\") {\n Cmp = function Cmp(pr) {\n return renderFn === null || renderFn === void 0 ? void 0 : renderFn(pr, config.ctx);\n };\n Cmp.displayName = renderFn.name;\n } else {\n Cmp = renderFn;\n }\n return Cmp;\n};\nexport { Col, dummyFn, DragIcon, WithConfirmFn, getWidgetId, getRenderFromConfig };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nimport Operator from \"./Operator\";\nimport { Col } from \"../utils\";\nvar OperatorWrapper = /*#__PURE__*/function (_PureComponent) {\n function OperatorWrapper() {\n _classCallCheck(this, OperatorWrapper);\n return _callSuper(this, OperatorWrapper, arguments);\n }\n _inherits(OperatorWrapper, _PureComponent);\n return _createClass(OperatorWrapper, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n selectedField = _this$props.selectedField,\n selectedFieldSrc = _this$props.selectedFieldSrc,\n selectedFieldType = _this$props.selectedFieldType,\n selectedOperator = _this$props.selectedOperator,\n setOperator = _this$props.setOperator,\n selectedFieldId = _this$props.selectedFieldId,\n showOperator = _this$props.showOperator,\n showOperatorLabel = _this$props.showOperatorLabel,\n selectedFieldWidgetConfig = _this$props.selectedFieldWidgetConfig,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId;\n var operator = showOperator && /*#__PURE__*/React.createElement(Col, {\n key: \"operators-for-\" + selectedFieldId,\n className: \"rule--operator\"\n }, config.settings.showLabels && /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, config.settings.operatorLabel), /*#__PURE__*/React.createElement(Operator, {\n key: \"operator\",\n config: config,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedFieldType: selectedFieldType,\n selectedFieldId: selectedFieldId,\n selectedOperator: selectedOperator,\n setOperator: setOperator,\n customProps: config.settings.customOperatorSelectProps,\n readonly: readonly,\n id: id,\n groupId: groupId\n }));\n var hiddenOperator = showOperatorLabel && /*#__PURE__*/React.createElement(Col, {\n key: \"operators-for-\" + selectedFieldId,\n className: \"rule--operator\"\n }, /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule--operator-wrapper\"\n }, config.settings.showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, \"\\xA0\") : null, /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule--operator-text-wrapper\"\n }, /*#__PURE__*/React.createElement(\"span\", {\n className: \"rule--operator-text\"\n }, selectedFieldWidgetConfig.operatorInlineLabel))));\n return [operator, hiddenOperator];\n }\n }]);\n}(PureComponent);\nexport { OperatorWrapper as default };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport { truncateString } from \"../../utils/stuff\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport last from \"lodash/last\";\nimport keys from \"lodash/keys\";\nvar getFieldPathLabels = Utils.RuleUtils.getFieldPathLabels;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getFieldParts = _Utils$ConfigUtils.getFieldParts,\n getFieldPathParts = _Utils$ConfigUtils.getFieldPathParts;\nvar Field = /*#__PURE__*/function (_Component) {\n function Field(props) {\n var _this;\n _classCallCheck(this, Field);\n _this = _callSuper(this, Field, [props]);\n _this.setField = function (field, asyncListValues) {\n var _meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var id = _this.props.id;\n if (!_meta.widgetId) {\n var widgetId = [id, \"L\", -1].join(\":\");\n _meta.widgetId = widgetId;\n }\n _this.props.setField(field, asyncListValues, _meta);\n };\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(Field, _Component);\n return _createClass(Field, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForMeta = [\"selectedField\", \"selectedFieldSrc\", \"selectedFieldType\", \"config\", \"parentField\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref) {\n var selectedField = _ref.selectedField,\n selectedFieldType = _ref.selectedFieldType,\n config = _ref.config,\n parentField = _ref.parentField;\n var selectedKey = selectedField;\n var _config$settings = config.settings,\n maxLabelsLength = _config$settings.maxLabelsLength,\n fieldSeparatorDisplay = _config$settings.fieldSeparatorDisplay,\n fieldPlaceholder = _config$settings.fieldPlaceholder,\n fieldSeparator = _config$settings.fieldSeparator;\n var isFieldSelected = !!selectedField;\n var placeholder = !isFieldSelected ? truncateString(fieldPlaceholder, maxLabelsLength) : null;\n var currField = isFieldSelected ? getFieldConfig(config, selectedKey) : null;\n var selectedOpts = currField || {};\n var selectedKeys = getFieldPathParts(selectedKey, config);\n var selectedPath = getFieldPathParts(selectedKey, config, true);\n var selectedLabel = this.getFieldLabel(currField, selectedKey, config);\n var partsLabels = getFieldPathLabels(selectedKey, config);\n var selectedFullLabel = partsLabels ? partsLabels.join(fieldSeparatorDisplay) : null;\n if (selectedFullLabel == selectedLabel || parentField) selectedFullLabel = null;\n var selectedAltLabel = selectedOpts.label2 || selectedOpts.tooltip;\n var parentFieldPath = getFieldParts(parentField, config);\n var parentFieldConfig = parentField ? getFieldConfig(config, parentField) : null;\n var sourceFields = parentField ? parentFieldConfig && parentFieldConfig.subfields : config.fields;\n var lookingForFieldType = !isFieldSelected && selectedFieldType;\n var items = this.buildOptions(parentFieldPath, config, sourceFields, lookingForFieldType, parentFieldPath);\n\n // Field source has been chnaged, no new field selected, but op & value remains\n var errorText = lookingForFieldType ? \"Please select field\" : null;\n if (selectedKey && _typeof(selectedKey) === \"object\") {\n // can happen due to incorrect rule state: field is Map{func, args} but fieldSrc is not \"func\"\n selectedKey = undefined;\n }\n return {\n placeholder: placeholder,\n items: items,\n parentField: parentField,\n selectedKey: selectedKey,\n selectedKeys: selectedKeys,\n selectedPath: selectedPath,\n selectedLabel: selectedLabel,\n selectedOpts: selectedOpts,\n selectedAltLabel: selectedAltLabel,\n selectedFullLabel: selectedFullLabel,\n errorText: errorText\n };\n }\n }, {\n key: \"getFieldLabel\",\n value: function getFieldLabel(fieldOpts, fieldKey, config) {\n if (!fieldKey) return null;\n var maxLabelsLength = config.settings.maxLabelsLength;\n var fieldParts = getFieldParts(fieldKey, config);\n var label = (fieldOpts === null || fieldOpts === void 0 ? void 0 : fieldOpts.label) || last(fieldParts);\n label = truncateString(label, maxLabelsLength);\n return label;\n }\n }, {\n key: \"buildOptions\",\n value: function buildOptions(parentFieldPath, config, fields) {\n var _this2 = this;\n var fieldType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n var path = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n var optGroup = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n if (!fields) return null;\n var _config$settings2 = config.settings,\n fieldSeparator = _config$settings2.fieldSeparator,\n fieldSeparatorDisplay = _config$settings2.fieldSeparatorDisplay;\n var prefix = path !== null && path !== void 0 && path.length ? path.join(fieldSeparator) + fieldSeparator : \"\";\n var _countFieldsMatchesType = function countFieldsMatchesType(fields) {\n return Object.keys(fields || {}).reduce(function (acc, fieldKey) {\n var field = fields[fieldKey];\n if (field.type === \"!struct\") {\n return acc + _countFieldsMatchesType(field.subfields);\n } else {\n return acc + (field.type === fieldType ? 1 : 0);\n }\n }, 0);\n };\n return keys(fields).map(function (fieldKey) {\n var fullFieldPath = [].concat(_toConsumableArray(path !== null && path !== void 0 ? path : []), [fieldKey]);\n var field = fields[fieldKey];\n var label = _this2.getFieldLabel(field, fullFieldPath, config);\n var partsLabels = getFieldPathLabels(fullFieldPath, config);\n var fullLabel = partsLabels.join(fieldSeparatorDisplay);\n if (fullLabel == label || parentFieldPath !== null && parentFieldPath !== void 0 && parentFieldPath.length) fullLabel = null;\n var altLabel = field.label2;\n var tooltip = field.tooltip;\n var disabled = field.disabled;\n if (field.hideForSelect) return undefined;\n if (field.type == \"!struct\") {\n var items = _this2.buildOptions(parentFieldPath, config, field.subfields, fieldType, fullFieldPath, {\n label: label,\n tooltip: tooltip\n });\n var hasItemsMatchesType = _countFieldsMatchesType(field.subfields) > 0;\n return {\n disabled: disabled,\n key: fieldKey,\n path: prefix + fieldKey,\n label: label,\n fullLabel: fullLabel,\n altLabel: altLabel,\n tooltip: tooltip,\n items: items,\n matchesType: hasItemsMatchesType\n };\n } else {\n var matchesType = fieldType !== undefined ? field.type === fieldType : undefined;\n return {\n disabled: disabled,\n key: fieldKey,\n path: prefix + fieldKey,\n label: label,\n fullLabel: fullLabel,\n altLabel: altLabel,\n tooltip: tooltip,\n grouplabel: optGroup === null || optGroup === void 0 ? void 0 : optGroup.label,\n group: optGroup,\n matchesType: matchesType\n };\n }\n }).filter(function (o) {\n return !!o;\n });\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n customProps = _this$props.customProps,\n setFieldSrc = _this$props.setFieldSrc,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId;\n var renderField = config.settings.renderField;\n if (!this.meta.items) {\n return null;\n }\n var renderProps = _objectSpread({\n id: id,\n groupId: groupId,\n config: config,\n customProps: customProps,\n readonly: readonly,\n setField: this.setField,\n setFieldSrc: setFieldSrc\n }, this.meta);\n return renderField(renderProps, config.ctx);\n }\n }]);\n}(Component);\nField.propTypes = {\n id: PropTypes.string,\n groupId: PropTypes.string,\n config: PropTypes.object.isRequired,\n selectedField: PropTypes.any,\n selectedFieldSrc: PropTypes.string,\n selectedFieldType: PropTypes.string,\n parentField: PropTypes.string,\n customProps: PropTypes.object,\n readonly: PropTypes.bool,\n //actions\n setField: PropTypes.func.isRequired,\n setFieldSrc: PropTypes.func\n};\nexport { Field as default };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport { truncateString } from \"../../utils/stuff\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport last from \"lodash/last\";\nimport keys from \"lodash/keys\";\nvar clone = Utils.clone;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getFuncConfig = _Utils$ConfigUtils.getFuncConfig,\n getFieldParts = _Utils$ConfigUtils.getFieldParts,\n getFieldPathParts = _Utils$ConfigUtils.getFieldPathParts,\n getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;\nvar getFuncPathLabels = Utils.RuleUtils.getFuncPathLabels;\nvar shallowEqual = Utils.OtherUtils.shallowEqual;\n\n//tip: this.props.value - right value, this.props.field - left value\nvar FuncSelect = /*#__PURE__*/function (_Component) {\n function FuncSelect(props) {\n var _this;\n _classCallCheck(this, FuncSelect);\n _this = _callSuper(this, FuncSelect, [props]);\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(FuncSelect, _Component);\n return _createClass(FuncSelect, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForItems = [\"config\", \"field\", \"fieldType\", \"fieldSrc\", \"operator\", \"isFuncArg\", \"isLHS\", \"parentFuncs\"];\n var keysForMeta = [\"config\", \"field\", \"fieldType\", \"fieldSrc\", \"value\", \"isLHS\"];\n var needUpdateItems = !this.items || keysForItems.map(function (k) {\n return k === \"parentFuncs\" ? !shallowEqual(nextProps[k], prevProps[k], true) : nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n if (needUpdateItems) {\n this.items = this.getItems(nextProps, this.meta);\n }\n }\n }, {\n key: \"getItems\",\n value: function getItems(_ref, _ref2) {\n var config = _ref.config,\n field = _ref.field,\n fieldType = _ref.fieldType,\n isLHS = _ref.isLHS,\n operator = _ref.operator,\n parentFuncs = _ref.parentFuncs,\n fieldDefinition = _ref.fieldDefinition,\n isFuncArg = _ref.isFuncArg;\n var lookingForFieldType = _ref2.lookingForFieldType;\n var canUseFuncForField = config.settings.canUseFuncForField;\n var filteredFuncs = this.filterFuncs(config, config.funcs, field, fieldType, isLHS, operator, canUseFuncForField, parentFuncs, isFuncArg, fieldDefinition);\n var items = this.buildOptions(config, filteredFuncs, lookingForFieldType);\n return items;\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref3) {\n var config = _ref3.config,\n _field = _ref3._field,\n fieldType = _ref3.fieldType,\n value = _ref3.value,\n isLHS = _ref3.isLHS,\n isFuncArg = _ref3.isFuncArg;\n var _config$settings = config.settings,\n funcPlaceholder = _config$settings.funcPlaceholder,\n fieldSeparatorDisplay = _config$settings.fieldSeparatorDisplay;\n var selectedFuncKey = value;\n var isFuncSelected = !!value;\n\n // const leftFieldConfig = getFieldConfig(config, field);\n // const leftFieldWidgetField = leftFieldConfig?.widgets?.field;\n // const leftFieldWidgetFieldProps = leftFieldWidgetField && leftFieldWidgetField.widgetProps || {};\n var placeholder = !isFuncSelected ? funcPlaceholder : null;\n var currFunc = isFuncSelected ? getFuncConfig(config, selectedFuncKey) : null;\n var selectedOpts = currFunc || {};\n var selectedKeys = getFieldPathParts(selectedFuncKey, config);\n var selectedPath = getFieldPathParts(selectedFuncKey, config, true);\n var selectedLabel = this.getFuncLabel(currFunc, selectedFuncKey, config);\n var partsLabels = getFuncPathLabels(selectedFuncKey, config);\n var selectedFullLabel = partsLabels ? partsLabels.join(fieldSeparatorDisplay) : null;\n if (selectedFullLabel == selectedLabel) selectedFullLabel = null;\n var isRootFuncAtLHS = isLHS && !isFuncArg;\n var lookingForFieldType = isRootFuncAtLHS && !isFuncSelected && fieldType;\n // Field source has been chnaged, no new func selected, but op & value remains\n var errorText = lookingForFieldType ? \"Please select function\" : null;\n return {\n placeholder: placeholder,\n selectedKey: selectedFuncKey,\n selectedKeys: selectedKeys,\n selectedPath: selectedPath,\n selectedLabel: selectedLabel,\n selectedOpts: selectedOpts,\n selectedFullLabel: selectedFullLabel,\n errorText: errorText,\n lookingForFieldType: lookingForFieldType\n };\n }\n }, {\n key: \"filterFuncs\",\n value: function filterFuncs(config, funcs, leftFieldFullkey, fieldType, isLHS, operator, canUseFuncForField, parentFuncs, isFuncArg, fieldDefinition) {\n funcs = clone(funcs);\n var fieldSeparator = config.settings.fieldSeparator;\n var leftFieldConfig = getFieldConfig(config, leftFieldFullkey);\n var _relyOnWidgetType = false; //TODO: remove this, see issue #758\n var expectedType;\n var targetDefinition = leftFieldConfig;\n var widget = getWidgetForFieldOp(config, leftFieldFullkey, operator, \"value\");\n var widgetConfig = widget && config.widgets[widget];\n if (isFuncArg) {\n targetDefinition = fieldDefinition;\n expectedType = fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type;\n } else if (_relyOnWidgetType && widgetConfig) {\n expectedType = widgetConfig.type;\n } else if (leftFieldConfig) {\n expectedType = leftFieldConfig.type;\n } else if (!isLHS) {\n // no field at LHS, but can use type from \"memory effect\"\n expectedType = fieldType;\n }\n function _filter(list, path) {\n for (var funcKey in list) {\n var subfields = list[funcKey].subfields;\n var subpath = (path ? path : []).concat(funcKey);\n var funcFullkey = subpath.join(fieldSeparator);\n var funcConfig = getFuncConfig(config, funcFullkey);\n if (funcConfig.type == \"!struct\") {\n if (_filter(subfields, subpath) == 0) delete list[funcKey];\n } else {\n var _targetDefinition;\n var canUse = !expectedType || funcConfig.returnType == expectedType;\n if ((_targetDefinition = targetDefinition) !== null && _targetDefinition !== void 0 && _targetDefinition.funcs) canUse = canUse && targetDefinition.funcs.includes(funcFullkey);\n if (canUseFuncForField) canUse = canUse && canUseFuncForField(leftFieldFullkey, leftFieldConfig, funcFullkey, funcConfig, operator);\n // don't use func in func (can be configurable, but usually users don't need this)\n if (!funcConfig.allowSelfNesting && parentFuncs && parentFuncs.map(function (_ref4) {\n var _ref5 = _slicedToArray(_ref4, 2),\n func = _ref5[0],\n _arg = _ref5[1];\n return func;\n }).includes(funcFullkey)) canUse = false;\n if (!canUse) delete list[funcKey];\n }\n }\n return keys(list).length;\n }\n _filter(funcs, []);\n return funcs;\n }\n }, {\n key: \"buildOptions\",\n value: function buildOptions(config, funcs) {\n var _this2 = this;\n var fieldType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;\n var path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var optGroup = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (!funcs) return null;\n var _config$settings2 = config.settings,\n fieldSeparator = _config$settings2.fieldSeparator,\n fieldSeparatorDisplay = _config$settings2.fieldSeparatorDisplay;\n var prefix = path !== null && path !== void 0 && path.length ? path.join(fieldSeparator) + fieldSeparator : \"\";\n var _countFieldsMatchesType = function countFieldsMatchesType(fields) {\n return Object.keys(fields || {}).reduce(function (acc, fieldKey) {\n var field = fields[fieldKey];\n if (field.type === \"!struct\") {\n return acc + _countFieldsMatchesType(field.subfields);\n } else {\n return acc + (field.type === fieldType ? 1 : 0);\n }\n }, 0);\n };\n return keys(funcs).map(function (funcKey) {\n var fullFuncPath = [].concat(_toConsumableArray(path !== null && path !== void 0 ? path : []), [funcKey]);\n var func = funcs[funcKey];\n var label = _this2.getFuncLabel(func, fullFuncPath, config);\n var partsLabels = getFuncPathLabels(fullFuncPath, config);\n var fullLabel = partsLabels.join(fieldSeparatorDisplay);\n if (fullLabel == label) fullLabel = null;\n var tooltip = func.tooltip;\n if (func.type == \"!struct\") {\n var items = _this2.buildOptions(config, func.subfields, fieldType, fullFuncPath, {\n label: label,\n tooltip: tooltip\n });\n var hasItemsMatchesType = _countFieldsMatchesType(func.subfields) > 0;\n return {\n key: funcKey,\n path: prefix + funcKey,\n label: label,\n fullLabel: fullLabel,\n tooltip: tooltip,\n items: items,\n matchesType: hasItemsMatchesType\n };\n } else {\n var matchesType = fieldType !== undefined ? func.returnType === fieldType : undefined;\n return {\n key: funcKey,\n path: prefix + funcKey,\n label: label,\n fullLabel: fullLabel,\n tooltip: tooltip,\n grouplabel: optGroup === null || optGroup === void 0 ? void 0 : optGroup.label,\n group: optGroup,\n matchesType: matchesType\n };\n }\n });\n }\n }, {\n key: \"getFuncLabel\",\n value: function getFuncLabel(funcOpts, funcKey, config) {\n if (!funcKey) return null;\n var maxLabelsLength = config.settings.maxLabelsLength;\n var funcParts = getFieldParts(funcKey, config);\n var label = (funcOpts === null || funcOpts === void 0 ? void 0 : funcOpts.label) || last(funcParts);\n label = truncateString(label, maxLabelsLength);\n return label;\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n customProps = _this$props.customProps,\n setValue = _this$props.setValue,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId;\n var renderFunc = config.settings.renderFunc;\n var renderProps = _objectSpread({\n config: config,\n customProps: customProps,\n readonly: readonly,\n setField: setValue,\n items: this.items,\n id: id,\n groupId: groupId\n }, this.meta);\n return renderFunc(renderProps, config.ctx);\n }\n }]);\n}(Component);\nFuncSelect.propTypes = {\n id: PropTypes.string,\n groupId: PropTypes.string,\n config: PropTypes.object.isRequired,\n field: PropTypes.any,\n fieldType: PropTypes.string,\n fieldSrc: PropTypes.string,\n operator: PropTypes.string,\n customProps: PropTypes.object,\n value: PropTypes.string,\n setValue: PropTypes.func.isRequired,\n readonly: PropTypes.bool,\n parentFuncs: PropTypes.array,\n fieldDefinition: PropTypes.object,\n isFuncArg: PropTypes.bool,\n isLHS: PropTypes.bool\n};\nexport { FuncSelect as default };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nvar _excluded = [\"widgetFactory\"],\n _excluded2 = [\"factory\"];\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport React, { useMemo, memo } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport omit from \"lodash/omit\";\nvar getTitleInListValues = Utils.ListUtils.getTitleInListValues;\nvar _widgetDefKeysToOmit = Utils.ConfigUtils._widgetDefKeysToOmit;\nvar _Utils$TreeUtils = Utils.TreeUtils,\n _fixImmutableValue = _Utils$TreeUtils._fixImmutableValue,\n isImmutable = _Utils$TreeUtils.isImmutable;\nvar WidgetFactoryMemo = /*#__PURE__*/memo(function (_ref) {\n var widgetFactory = _ref.widgetFactory,\n widgetProps = _objectWithoutProperties(_ref, _excluded);\n var config = widgetProps.config,\n isFuncArg = widgetProps.isFuncArg,\n fieldDefinition = widgetProps.fieldDefinition;\n var _ref2 = fieldDefinition || {},\n fieldSettings = _ref2.fieldSettings,\n defaultValue = _ref2.defaultValue,\n valueSources = _ref2.valueSources;\n var isConst = isFuncArg && (valueSources === null || valueSources === void 0 ? void 0 : valueSources.length) == 1 && (valueSources === null || valueSources === void 0 ? void 0 : valueSources[0]) === \"const\";\n var listValues = (fieldSettings === null || fieldSettings === void 0 ? void 0 : fieldSettings.treeValues) || (fieldSettings === null || fieldSettings === void 0 ? void 0 : fieldSettings.listValues);\n if (isConst && defaultValue) {\n if (typeof defaultValue === \"boolean\") {\n return defaultValue ? widgetProps.labelYes || \"YES\" : widgetProps.labelNo || \"NO\";\n } else if (listValues) {\n if (Array.isArray(defaultValue)) return defaultValue.map(function (v) {\n return getTitleInListValues(listValues, v) || v;\n }).join(\", \");else return getTitleInListValues(listValues, defaultValue) || defaultValue;\n }\n return \"\" + defaultValue;\n }\n if (!widgetFactory) {\n return \"?\";\n }\n return widgetFactory(widgetProps, config.ctx);\n});\nWidgetFactoryMemo.displayName = \"WidgetFactoryMemo\";\nvar WidgetFactory = function WidgetFactory(_ref3) {\n var delta = _ref3.delta,\n parentDelta = _ref3.parentDelta,\n isFuncArg = _ref3.isFuncArg,\n valueSrc = _ref3.valueSrc,\n immValue = _ref3.value,\n immValueError = _ref3.valueError,\n fieldError = _ref3.fieldError,\n asyncListValues = _ref3.asyncListValues,\n isSpecialRange = _ref3.isSpecialRange,\n fieldDefinition = _ref3.fieldDefinition,\n widget = _ref3.widget,\n widgetDefinition = _ref3.widgetDefinition,\n widgetValueLabel = _ref3.widgetValueLabel,\n valueLabels = _ref3.valueLabels,\n textSeparators = _ref3.textSeparators,\n setValue = _ref3.setValue,\n setFuncValue = _ref3.setFuncValue,\n config = _ref3.config,\n field = _ref3.field,\n fieldSrc = _ref3.fieldSrc,\n fieldPath = _ref3.fieldPath,\n fieldType = _ref3.fieldType,\n isLHS = _ref3.isLHS,\n operator = _ref3.operator,\n readonly = _ref3.readonly,\n parentField = _ref3.parentField,\n parentFuncs = _ref3.parentFuncs,\n id = _ref3.id,\n groupId = _ref3.groupId,\n widgetId = _ref3.widgetId;\n var widgetFactory = widgetDefinition.factory,\n fieldWidgetProps = _objectWithoutProperties(widgetDefinition, _excluded2);\n\n // Widget value (if it's not a func with args) should NOT be Immutable\n // Eg. for multiselect value should be a JS Array, not Immutable List\n var fixedImmValue = immValue ? immValue.map(function (v) {\n return _fixImmutableValue(v);\n }) : undefined;\n var value = useMemo(function () {\n if (isSpecialRange) {\n var _value = [fixedImmValue === null || fixedImmValue === void 0 ? void 0 : fixedImmValue.get(0), fixedImmValue === null || fixedImmValue === void 0 ? void 0 : fixedImmValue.get(1)];\n if (_value[0] === undefined && _value[1] === undefined) _value = undefined;\n return _value;\n }\n return fixedImmValue === null || fixedImmValue === void 0 ? void 0 : fixedImmValue.get(delta);\n }, [isSpecialRange, immValue]);\n var valueError = useMemo(function () {\n var _immValueError$get;\n if (!immValueError) {\n return null;\n }\n if (isSpecialRange) {\n return [immValueError.get(0), immValueError.get(1), immValueError.get(2)];\n }\n return immValueError === null || immValueError === void 0 || (_immValueError$get = immValueError.get) === null || _immValueError$get === void 0 ? void 0 : _immValueError$get.call(immValueError, delta);\n }, [isSpecialRange, immValue]);\n var errorMessage = isLHS ? fieldError : valueError;\n var _ref4 = fieldDefinition || {},\n fieldSettings = _ref4.fieldSettings;\n var label = widgetValueLabel.label,\n placeholder = widgetValueLabel.placeholder;\n var placeholders = valueLabels ? valueLabels.placeholder : null;\n var simpleField = isImmutable(field) ? null : field;\n var widgetProps = omit(_objectSpread(_objectSpread(_objectSpread({}, fieldWidgetProps), fieldSettings), {}, {\n config: config,\n field: simpleField,\n // !!! using of field prop in widget is strongly discouraged\n fieldPath: fieldPath,\n fieldSrc: fieldSrc,\n fieldType: fieldType,\n isLHS: isLHS,\n parentField: parentField,\n parentFuncs: parentFuncs,\n fieldDefinition: fieldDefinition,\n operator: operator,\n delta: delta,\n parentDelta: parentDelta,\n isSpecialRange: isSpecialRange,\n isFuncArg: isFuncArg,\n value: value,\n valueSrc: valueSrc,\n valueError: valueError,\n fieldError: fieldError,\n errorMessage: errorMessage,\n label: label,\n placeholder: placeholder,\n placeholders: placeholders,\n textSeparators: textSeparators,\n setValue: setValue,\n setFuncValue: setFuncValue,\n readonly: readonly,\n asyncListValues: asyncListValues,\n id: id,\n groupId: groupId,\n widgetId: widgetId,\n widgetFactory: widgetFactory,\n widget: widget\n }), [].concat(_toConsumableArray(_widgetDefKeysToOmit), [\"toJS\"]));\n return /*#__PURE__*/React.createElement(WidgetFactoryMemo, _extends({\n widgetFactory: widgetFactory\n }, widgetProps));\n};\nWidgetFactory.displayName = \"WidgetFactory\";\nexport default WidgetFactory;","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport range from \"lodash/range\";\nimport { getOpCardinality } from \"../../utils/stuff\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport pick from \"lodash/pick\";\nimport WidgetFactory from \"./WidgetFactory\";\nimport classNames from \"classnames\";\nimport { Col, getWidgetId, getRenderFromConfig } from \"../utils\";\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getOperatorConfig = _Utils$ConfigUtils.getOperatorConfig,\n getFieldWidgetConfig = _Utils$ConfigUtils.getFieldWidgetConfig,\n getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp,\n getValueSourcesForFieldOp = _Utils$ConfigUtils.getValueSourcesForFieldOp;\nvar getValueLabel = Utils.RuleUtils.getValueLabel;\nvar createListWithOneElement = Utils.DefaultUtils.createListWithOneElement;\nvar shallowEqual = Utils.OtherUtils.shallowEqual;\nvar isImmutable = Utils.TreeUtils.isImmutable;\nvar funcArgDummyOpDef = {\n cardinality: 1\n};\nvar Widget = /*#__PURE__*/function (_Component) {\n function Widget(_props) {\n var _this;\n _classCallCheck(this, Widget);\n _this = _callSuper(this, Widget, [_props]);\n _this._setValue = function (isSpecialRange, delta, widgetType, widgetId,\n // bound!\n value, asyncListValues) {\n var _meta = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {};\n if (!_meta.widgetId) {\n _meta.widgetId = widgetId;\n }\n if (isSpecialRange && Array.isArray(value)) {\n var oldRange = [_this.props.value.get(0), _this.props.value.get(1)];\n if (oldRange[0] != value[0]) _this.props.setValue(0, value[0], widgetType, asyncListValues, _meta);\n if (oldRange[1] != value[1]) _this.props.setValue(1, value[1], widgetType, asyncListValues, _meta);\n } else {\n _this.props.setValue(delta, value, widgetType, asyncListValues, _meta);\n }\n };\n _this._setValueSrc = function (delta, widgetId,\n // bound!\n srcKey) {\n var _meta = {\n widgetId: widgetId\n };\n _this.props.setValueSrc(delta, srcKey, _meta);\n };\n _this.renderWidget = function (delta, meta, props) {\n var config = props.config,\n isFuncArg = props.isFuncArg,\n leftField = props.leftField,\n operator = props.operator,\n values = props.value,\n valueError = props.valueError,\n fieldError = props.fieldError,\n readonly = props.readonly,\n parentField = props.parentField,\n parentFuncs = props.parentFuncs,\n id = props.id,\n groupId = props.groupId,\n fieldSrc = props.fieldSrc,\n fieldType = props.fieldType,\n isLHS = props.isLHS,\n setFuncValue = props.setFuncValue,\n parentDelta = props.parentDelta;\n var settings = config.settings;\n var widgets = meta.widgets,\n iValues = meta.iValues,\n aField = meta.aField,\n valueSources = meta.valueSources;\n var value = isFuncArg ? iValues : values;\n var field = isFuncArg ? leftField : aField;\n var _widgets$delta = widgets[delta],\n valueSrc = _widgets$delta.valueSrc,\n valueLabel = _widgets$delta.valueLabel,\n widgetId = _widgets$delta.widgetId;\n var hasValueSources = valueSources.length > 1 && !readonly;\n var widgetLabel = settings.showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n key: \"label-\" + widgetId,\n className: \"rule--label\"\n }, valueLabel.label) : null;\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"wrapper-\" + widgetId,\n className: classNames(valueSrc === \"func\" ? \"widget--func\" : \"widget--widget\", hasValueSources ? \"widget--has-valuesrcs\" : \"widget--has-no-valuesrcs\")\n }, valueSrc === \"func\" ? null : widgetLabel, /*#__PURE__*/React.createElement(WidgetFactory, _extends({\n key: widgetId,\n id: id // id of rule\n ,\n groupId: groupId,\n widgetId: widgetId,\n valueSrc: valueSrc,\n delta: delta,\n value: value,\n valueError: valueError,\n fieldError: fieldError,\n isFuncArg: isFuncArg,\n isLHS: isLHS\n }, pick(meta, [\"isSpecialRange\", \"fieldDefinition\", \"asyncListValues\"]), pick(widgets[delta], [\"widget\", \"widgetDefinition\", \"widgetValueLabel\", \"valueLabels\", \"textSeparators\", \"setValue\"]), {\n setFuncValue: setFuncValue,\n config: config,\n field: field,\n fieldSrc: fieldSrc,\n fieldType: fieldType,\n parentField: parentField,\n parentFuncs: parentFuncs,\n parentDelta: parentDelta !== null && parentDelta !== void 0 ? parentDelta : delta,\n operator: operator,\n readonly: readonly\n })));\n };\n _this.renderValueSources = function (delta, meta, props) {\n var config = props.config,\n isFuncArg = props.isFuncArg,\n leftField = props.leftField,\n operator = props.operator,\n readonly = props.readonly;\n var settings = config.settings;\n var valueSources = meta.valueSources,\n widgets = meta.widgets,\n aField = meta.aField,\n valueSourcesOptions = meta.valueSourcesOptions;\n var field = isFuncArg ? leftField : aField;\n var _widgets$delta2 = widgets[delta],\n valueSrc = _widgets$delta2.valueSrc,\n setValueSrc = _widgets$delta2.setValueSrc;\n var ValueSources = _this.ValueSources;\n var sourceLabel = settings.showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, \"\\xA0\") : null;\n return valueSources.length > 1 && !readonly && /*#__PURE__*/React.createElement(\"div\", {\n key: \"wrapper-\" + \"valuesrc-\" + delta,\n className: \"widget--valuesrc\"\n }, sourceLabel, /*#__PURE__*/React.createElement(ValueSources, {\n key: \"valuesrc-\" + delta,\n delta: delta,\n valueSources: valueSourcesOptions,\n valueSrc: valueSrc,\n config: config,\n field: field,\n operator: operator,\n setValueSrc: setValueSrc,\n readonly: readonly,\n title: settings.valueSourcesPopupTitle\n }));\n };\n _this.renderSep = function (delta, meta, props) {\n var config = props.config;\n var widgets = meta.widgets;\n var settings = config.settings;\n var sepText = widgets[delta].sepText;\n var sepLabel = settings.showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, \"\\xA0\") : null;\n return sepText && /*#__PURE__*/React.createElement(\"div\", {\n key: \"widget-separators-\" + delta,\n className: classNames(\"widget--sep\", delta == 0 && \"widget--sep-first\")\n }, sepLabel, /*#__PURE__*/React.createElement(\"span\", null, sepText));\n };\n _this.renderWidgetDelta = function (delta) {\n var sep = _this.renderSep(delta, _this.meta, _this.props);\n var sources = _this.renderValueSources(delta, _this.meta, _this.props);\n var widgetCmp = _this.renderWidget(delta, _this.meta, _this.props);\n return [sep, sources, widgetCmp];\n };\n useOnPropsChanged(_this);\n _this.onPropsChanged(_props);\n return _this;\n }\n _inherits(Widget, _Component);\n return _createClass(Widget, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var configChanged = !this.ValueSources || (prevProps === null || prevProps === void 0 ? void 0 : prevProps.config) !== (nextProps === null || nextProps === void 0 ? void 0 : nextProps.config);\n var keysForMeta = [\"config\", \"id\", \"parentFuncs\", \"field\", \"fieldId\", \"fieldSrc\", \"fieldType\", \"fieldFunc\", \"fieldArg\", \"leftField\", \"operator\", \"valueSrc\", \"asyncListValues\", \"isLHS\", \"isFuncArg\", \"isForRuleGroup\", \"isCaseValue\", \"value\", \"parentDelta\"];\n var changedKeys = keysForMeta.filter(function (k) {\n if (k === \"parentFuncs\") {\n return !shallowEqual(nextProps[k], prevProps[k], true);\n }\n // if (k === \"value\") {\n // if (nextProps[\"value\"] !== prevProps[\"value\"] && isImmutable(nextProps[\"value\"])) {\n // }\n // }\n if (k === \"field\") {\n //tip: if `fieldId` has not changed, but `field` changed -> ignore\n // (because we are in RHS and field is LHS)\n return nextProps[\"fieldId\"] !== prevProps[\"fieldId\"];\n }\n return nextProps[k] !== prevProps[k];\n });\n var needUpdateMeta = !this.meta || changedKeys.length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps, changedKeys);\n }\n if (configChanged) {\n var config = nextProps.config;\n var renderValueSources = config.settings.renderValueSources;\n this.ValueSources = getRenderFromConfig(config, renderValueSources);\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref) {\n var _iValueSrcs,\n _iValueSrcs2,\n _this$meta,\n _this$meta2,\n _this2 = this;\n var config = _ref.config,\n simpleField = _ref.field,\n fieldSrc = _ref.fieldSrc,\n fieldType = _ref.fieldType,\n fieldFunc = _ref.fieldFunc,\n fieldArg = _ref.fieldArg,\n operator = _ref.operator,\n valueSrcs = _ref.valueSrc,\n values = _ref.value,\n isForRuleGroup = _ref.isForRuleGroup,\n isCaseValue = _ref.isCaseValue,\n isFuncArg = _ref.isFuncArg,\n leftField = _ref.leftField,\n asyncListValues = _ref.asyncListValues,\n parentFuncs = _ref.parentFuncs,\n isLHS = _ref.isLHS,\n id = _ref.id,\n parentDelta = _ref.parentDelta;\n var changedKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n var valueSourcesInfo = config.settings.valueSourcesInfo;\n var field = isFuncArg ? {\n func: fieldFunc,\n arg: fieldArg\n } : simpleField;\n var isOkWithoutField = !simpleField && fieldType;\n var iValueSrcs = valueSrcs;\n var iValues = values;\n if (isFuncArg || isForRuleGroup || isCaseValue) {\n iValueSrcs = createListWithOneElement(valueSrcs);\n iValues = createListWithOneElement(values);\n }\n var fieldDefinition = getFieldConfig(config, field);\n if (!fieldDefinition && isOkWithoutField) {\n fieldDefinition = config.types[fieldType];\n }\n var defaultWidget = getWidgetForFieldOp(config, field, operator);\n if (!defaultWidget && isOkWithoutField) {\n var _config$types$fieldTy;\n defaultWidget = (_config$types$fieldTy = config.types[fieldType]) === null || _config$types$fieldTy === void 0 ? void 0 : _config$types$fieldTy.mainWidget;\n }\n var operatorDefinition = isFuncArg ? funcArgDummyOpDef : getOperatorConfig(config, operator, field);\n if ((fieldDefinition == null || operatorDefinition == null) && !isCaseValue) {\n return null;\n }\n var isSpecialRange = operatorDefinition === null || operatorDefinition === void 0 ? void 0 : operatorDefinition.isSpecialRange;\n var isSpecialRangeForSrcField = isSpecialRange && (((_iValueSrcs = iValueSrcs) === null || _iValueSrcs === void 0 ? void 0 : _iValueSrcs.get(0)) === \"field\" || ((_iValueSrcs2 = iValueSrcs) === null || _iValueSrcs2 === void 0 ? void 0 : _iValueSrcs2.get(1)) === \"field\");\n var isTrueSpecialRange = isSpecialRange && !isSpecialRangeForSrcField;\n var cardinality = isTrueSpecialRange ? 1 : getOpCardinality(operatorDefinition);\n if (cardinality === 0) {\n return null;\n }\n var valueSources = (_this$meta = this.meta) === null || _this$meta === void 0 ? void 0 : _this$meta.valueSources;\n var valueSourcesOptions = (_this$meta2 = this.meta) === null || _this$meta2 === void 0 ? void 0 : _this$meta2.valueSourcesOptions;\n var defaultValueSourcesLabels = {\n value: \"Value\",\n field: \"Field\",\n func: \"Function\"\n };\n if (!valueSources || [\"field\", \"operator\", \"config\", \"fieldDefinition\", \"isForRuleGroup\"].filter(function (k) {\n return changedKeys.includes(k);\n }).length) {\n valueSources = getValueSourcesForFieldOp(config, field, operator, fieldDefinition);\n if (isForRuleGroup) {\n // todo: aggregation can be not only number?\n valueSources = [\"value\"];\n }\n if (!field) {\n valueSources = Object.keys(valueSourcesInfo);\n }\n valueSourcesOptions = valueSources.map(function (srcKey) {\n var _ref2, _valueSourcesInfo$src, _valueSourcesInfo$src2;\n return [srcKey, {\n label: (_ref2 = (_valueSourcesInfo$src = (_valueSourcesInfo$src2 = valueSourcesInfo[srcKey]) === null || _valueSourcesInfo$src2 === void 0 ? void 0 : _valueSourcesInfo$src2.label) !== null && _valueSourcesInfo$src !== void 0 ? _valueSourcesInfo$src : defaultValueSourcesLabels[srcKey]) !== null && _ref2 !== void 0 ? _ref2 : srcKey\n }];\n });\n }\n var widgets = (isFuncArg ? [0] : range(0, cardinality)).map(function (delta) {\n var _this2$meta, _iValueSrcs3, _widgetDefinition, _this2$meta2;\n var oldWidgetMeta = (_this2$meta = _this2.meta) === null || _this2$meta === void 0 || (_this2$meta = _this2$meta.widgets) === null || _this2$meta === void 0 ? void 0 : _this2$meta[delta];\n var valueSrc = ((_iValueSrcs3 = iValueSrcs) === null || _iValueSrcs3 === void 0 ? void 0 : _iValueSrcs3.get(delta)) || null;\n var widget = getWidgetForFieldOp(config, field, operator, valueSrc);\n var widgetDefinition = getFieldWidgetConfig(config, field, operator, widget, valueSrc);\n if (isSpecialRangeForSrcField) {\n widget = widgetDefinition.singleWidget;\n widgetDefinition = getFieldWidgetConfig(config, field, operator, widget, valueSrc);\n }\n if (!widgetDefinition && isOkWithoutField) {\n widget = [\"func\", \"field\"].includes(valueSrc) ? valueSrc : defaultWidget;\n widgetDefinition = config.widgets[widget];\n }\n var widgetType = (_widgetDefinition = widgetDefinition) === null || _widgetDefinition === void 0 ? void 0 : _widgetDefinition.type;\n var valueLabel = getValueLabel(config, field, operator, delta, valueSrc, isTrueSpecialRange);\n var widgetValueLabel = getValueLabel(config, field, operator, delta, null, isTrueSpecialRange);\n var sepText = operatorDefinition !== null && operatorDefinition !== void 0 && operatorDefinition.textSeparators ? operatorDefinition === null || operatorDefinition === void 0 ? void 0 : operatorDefinition.textSeparators[delta] : null;\n var valueLabels = null;\n var textSeparators = null;\n if (isSpecialRange) {\n valueLabels = [getValueLabel(config, field, operator, 0), getValueLabel(config, field, operator, 1)];\n valueLabels = {\n placeholder: [valueLabels[0].placeholder, valueLabels[1].placeholder],\n label: [valueLabels[0].label, valueLabels[1].label]\n };\n textSeparators = operatorDefinition === null || operatorDefinition === void 0 ? void 0 : operatorDefinition.textSeparators;\n }\n var widgetId = getWidgetId({\n id: id,\n isLHS: isLHS,\n delta: parentDelta !== null && parentDelta !== void 0 ? parentDelta : delta,\n parentFuncs: parentFuncs\n });\n var vsId = widgetId + \":\" + \"VS\";\n var setValueSrc = oldWidgetMeta === null || oldWidgetMeta === void 0 ? void 0 : oldWidgetMeta.setValueSrc;\n if (!setValueSrc || (oldWidgetMeta === null || oldWidgetMeta === void 0 ? void 0 : oldWidgetMeta.widgetId) !== widgetId) {\n setValueSrc = _this2._setValueSrc.bind(_this2, delta, vsId);\n }\n var setValue = oldWidgetMeta === null || oldWidgetMeta === void 0 ? void 0 : oldWidgetMeta.setValue;\n if (!setValue || (oldWidgetMeta === null || oldWidgetMeta === void 0 ? void 0 : oldWidgetMeta.widgetId) !== widgetId || (oldWidgetMeta === null || oldWidgetMeta === void 0 ? void 0 : oldWidgetMeta.widgetType) !== widgetType || ((_this2$meta2 = _this2.meta) === null || _this2$meta2 === void 0 ? void 0 : _this2$meta2.isSpecialRange) !== isSpecialRange) {\n setValue = _this2._setValue.bind(_this2, isSpecialRange, delta, widgetType, widgetId);\n }\n return {\n valueSrc: valueSrc,\n valueLabel: valueLabel,\n widget: widget,\n sepText: sepText,\n widgetDefinition: widgetDefinition,\n widgetValueLabel: widgetValueLabel,\n valueLabels: valueLabels,\n textSeparators: textSeparators,\n setValueSrc: setValueSrc,\n setValue: setValue,\n widgetId: widgetId,\n widgetType: widgetType\n };\n });\n return {\n defaultWidget: defaultWidget,\n fieldDefinition: fieldDefinition,\n operatorDefinition: operatorDefinition,\n isSpecialRange: isTrueSpecialRange,\n cardinality: cardinality,\n valueSources: valueSources,\n valueSourcesOptions: valueSourcesOptions,\n widgets: widgets,\n iValues: iValues,\n //correct for isFuncArg\n aField: field,\n //correct for isFuncArg\n asyncListValues: asyncListValues\n };\n }\n }, {\n key: \"render\",\n value: function render() {\n if (!this.meta) return null;\n var _this$meta3 = this.meta,\n defaultWidget = _this$meta3.defaultWidget,\n cardinality = _this$meta3.cardinality;\n var isFuncArg = this.meta.isFuncArg;\n if (!defaultWidget) return null;\n var name = defaultWidget;\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--widget rule--widget--\".concat(name.toUpperCase()),\n key: \"widget-col-\" + name\n }, (isFuncArg ? [0] : range(0, cardinality)).map(this.renderWidgetDelta));\n }\n }]);\n}(Component);\nWidget.propTypes = {\n config: PropTypes.object.isRequired,\n value: PropTypes.any,\n //instanceOf(Immutable.List)\n valueSrc: PropTypes.any,\n //instanceOf(Immutable.List)\n valueError: PropTypes.any,\n //instanceOf(Immutable.List)\n fieldError: PropTypes.string,\n field: PropTypes.any,\n fieldSrc: PropTypes.string,\n fieldType: PropTypes.string,\n fieldId: PropTypes.string,\n operator: PropTypes.string,\n readonly: PropTypes.bool,\n asyncListValues: PropTypes.array,\n id: PropTypes.string,\n groupId: PropTypes.string,\n //actions\n setValue: PropTypes.func,\n setValueSrc: PropTypes.func,\n setFuncValue: PropTypes.func,\n // for isFuncArg\n isFuncArg: PropTypes.bool,\n fieldFunc: PropTypes.string,\n fieldArg: PropTypes.string,\n leftField: PropTypes.any,\n // for RuleGroupExt\n isForRuleGroup: PropTypes.bool,\n parentField: PropTypes.string,\n // for func in func\n parentFuncs: PropTypes.array,\n isLHS: PropTypes.bool,\n parentDelta: PropTypes.number,\n // for case_value\n isCaseValue: PropTypes.bool\n};\nexport { Widget as default };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component, PureComponent } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport FuncSelect from \"./FuncSelect\";\nimport Widget from \"./Widget\";\nimport { Col, getWidgetId } from \"../utils\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nvar getFuncConfig = Utils.ConfigUtils.getFuncConfig;\nvar shallowEqual = Utils.OtherUtils.shallowEqual;\nvar FuncWidget = /*#__PURE__*/function (_Component) {\n function FuncWidget(props) {\n var _this;\n _classCallCheck(this, FuncWidget);\n _this = _callSuper(this, FuncWidget, [props]);\n _this.setFunc = function (funcKey) {\n var _meta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n var _this$props = _this.props,\n isLHS = _this$props.isLHS,\n parentDelta = _this$props.parentDelta,\n parentFuncs = _this$props.parentFuncs,\n id = _this$props.id;\n if (!_meta.widgetId) {\n var widgetId = getWidgetId({\n id: id,\n isLHS: isLHS,\n delta: parentDelta,\n parentFuncs: parentFuncs\n });\n _meta.widgetId = widgetId;\n }\n _this.props.setFuncValue(isLHS ? -1 : parentDelta || 0, parentFuncs, null, funcKey, \"!func\", undefined, _meta);\n };\n _this.setArgValue = function (argKey, argVal, widgetType, asyncListValues, _meta) {\n var _this$props2 = _this.props,\n config = _this$props2.config,\n parentDelta = _this$props2.parentDelta,\n isLHS = _this$props2.isLHS,\n parentFuncs = _this$props2.parentFuncs;\n _this.props.setFuncValue(isLHS ? -1 : parentDelta || 0, parentFuncs, argKey, argVal, widgetType, asyncListValues, _meta);\n };\n _this.setArgValueSrc = function (argKey, argValSrc, _meta) {\n var _this$props3 = _this.props,\n config = _this$props3.config,\n parentDelta = _this$props3.parentDelta,\n isLHS = _this$props3.isLHS,\n parentFuncs = _this$props3.parentFuncs;\n _this.props.setFuncValue(isLHS ? -1 : parentDelta || 0, parentFuncs, argKey, argValSrc, \"!valueSrc\", undefined, _meta);\n };\n _this.renderFuncSelect = function () {\n var _value$get, _value$get2;\n var _this$props4 = _this.props,\n config = _this$props4.config,\n field = _this$props4.field,\n fieldType = _this$props4.fieldType,\n fieldSrc = _this$props4.fieldSrc,\n isLHS = _this$props4.isLHS,\n operator = _this$props4.operator,\n customProps = _this$props4.customProps,\n value = _this$props4.value,\n readonly = _this$props4.readonly,\n parentFuncs = _this$props4.parentFuncs,\n id = _this$props4.id,\n groupId = _this$props4.groupId,\n isFuncArg = _this$props4.isFuncArg,\n fieldDefinition = _this$props4.fieldDefinition,\n parentDelta = _this$props4.parentDelta;\n var funcKey = (_value$get = value === null || value === void 0 || (_value$get2 = value.get) === null || _value$get2 === void 0 ? void 0 : _value$get2.call(value, \"func\")) !== null && _value$get !== void 0 ? _value$get : null;\n var selectProps = {\n value: funcKey,\n setValue: _this.setFunc,\n config: config,\n field: field,\n fieldType: fieldType,\n fieldSrc: fieldSrc,\n isLHS: isLHS,\n operator: operator,\n customProps: customProps,\n readonly: readonly,\n parentFuncs: parentFuncs,\n isFuncArg: isFuncArg,\n fieldDefinition: fieldDefinition,\n id: id,\n groupId: groupId\n };\n var _config$settings = config.settings,\n showLabels = _config$settings.showLabels,\n funcLabel = _config$settings.funcLabel;\n var widgetLabel = showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, funcLabel) : null;\n return /*#__PURE__*/React.createElement(Col, {\n key: \"func\",\n className: \"rule--func\"\n }, widgetLabel, /*#__PURE__*/React.createElement(FuncSelect, selectProps));\n };\n _this.renderArgLabel = function (argKey, argDefinition) {\n var valueSources = argDefinition.valueSources,\n type = argDefinition.type,\n showPrefix = argDefinition.showPrefix,\n label = argDefinition.label;\n var config = _this.props.config;\n var isConst = valueSources && valueSources.length == 1 && valueSources[0] == \"const\";\n var forceShow = !config.settings.showLabels && (type == \"boolean\" || isConst) && showPrefix;\n if (!forceShow) return null;\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--func--arg-label\"\n }, label || argKey);\n };\n _this.renderArgLabelSep = function (argKey, argDefinition) {\n var valueSources = argDefinition.valueSources,\n type = argDefinition.type,\n showPrefix = argDefinition.showPrefix;\n var config = _this.props.config;\n var isConst = valueSources && valueSources.length == 1 && valueSources[0] == \"const\";\n var forceShow = !config.settings.showLabels && (type == \"boolean\" || isConst) && showPrefix;\n if (!forceShow) return null;\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--func--arg-label-sep\"\n }, \":\");\n };\n _this.renderArgVal = function (funcKey, argKey, argDefinition) {\n var _this$props5 = _this.props,\n config = _this$props5.config,\n field = _this$props5.field,\n fieldType = _this$props5.fieldType,\n fieldSrc = _this$props5.fieldSrc,\n isLHS = _this$props5.isLHS,\n operator = _this$props5.operator,\n value = _this$props5.value,\n readonly = _this$props5.readonly,\n parentFuncs = _this$props5.parentFuncs,\n id = _this$props5.id,\n groupId = _this$props5.groupId,\n fieldError = _this$props5.fieldError,\n valueError = _this$props5.valueError,\n setFuncValue = _this$props5.setFuncValue,\n parentDelta = _this$props5.parentDelta;\n var arg = value ? value.getIn([\"args\", argKey]) : null;\n var argVal = arg ? arg.get(\"value\") : undefined;\n var defaultValueSource = argDefinition.valueSources.length == 1 ? argDefinition.valueSources[0] : undefined;\n var argValSrc = arg ? arg.get(\"valueSrc\") || defaultValueSource || \"value\" : defaultValueSource;\n var asyncListValues = arg === null || arg === void 0 ? void 0 : arg.get(\"asyncListValues\");\n var widgetProps = {\n config: config,\n fieldFunc: funcKey,\n fieldArg: argKey,\n leftField: field,\n fieldType: fieldType,\n // type of leftField\n fieldSrc: fieldSrc,\n // src of leftField\n fieldError: fieldError,\n // error in LHS\n valueError: valueError,\n // error in RHS\n isLHS: isLHS,\n operator: null,\n value: argVal,\n valueSrc: argValSrc,\n asyncListValues: asyncListValues,\n setValue: _this.setArgValue,\n setValueSrc: _this.setArgValueSrc,\n setFuncValue: setFuncValue,\n funcKey: funcKey,\n argKey: argKey,\n argDefinition: argDefinition,\n readonly: readonly,\n parentFuncs: parentFuncs,\n id: id,\n groupId: groupId,\n parentDelta: parentDelta\n };\n //tip: value & valueSrc will be converted to Immutable.List at <Widget>\n\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--func--arg-value\"\n }, /*#__PURE__*/React.createElement(ArgWidget, widgetProps));\n };\n _this.renderArgSep = function (argKey, argDefinition, argIndex, _ref) {\n var renderSeps = _ref.renderSeps;\n if (!argIndex) return null;\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--func--arg-sep\"\n }, renderSeps ? renderSeps[argIndex - 1] : \", \");\n };\n _this.renderBracketBefore = function (_ref2) {\n var renderBrackets = _ref2.renderBrackets;\n return /*#__PURE__*/React.createElement(Col, {\n key: \"before_args\",\n className: \"rule--func--bracket-before\"\n }, renderBrackets ? renderBrackets[0] : \"(\");\n };\n _this.renderBracketAfter = function (_ref3) {\n var renderBrackets = _ref3.renderBrackets;\n return /*#__PURE__*/React.createElement(Col, {\n key: \"after_args\",\n className: \"rule--func--bracket-after\"\n }, renderBrackets ? renderBrackets[1] : \")\");\n };\n _this.renderFuncArgs = function () {\n var _this$meta = _this.meta,\n funcDefinition = _this$meta.funcDefinition,\n funcKey = _this$meta.funcKey;\n if (!funcKey) return null;\n var _ref4 = funcDefinition || {},\n args = _ref4.args;\n if (!args) return null;\n return /*#__PURE__*/React.createElement(React.Fragment, null, _this.renderBracketBefore(funcDefinition), /*#__PURE__*/React.createElement(Col, {\n key: \"args-\".concat(funcKey),\n className: \"rule--func--args rule--func--\".concat(funcKey, \"--args\")\n }, Object.keys(args).map(function (argKey, argIndex) {\n return /*#__PURE__*/React.createElement(Col, {\n key: \"arg-\".concat(argKey, \"-\").concat(argIndex),\n className: \"rule--func--arg rule--func--\".concat(funcKey, \"--arg--\").concat(argKey)\n }, _this.renderArgSep(argKey, args[argKey], argIndex, funcDefinition), _this.renderArgLabel(argKey, args[argKey]), _this.renderArgLabelSep(argKey, args[argKey]), _this.renderArgVal(funcKey, argKey, args[argKey]));\n })), _this.renderBracketAfter(funcDefinition));\n };\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(FuncWidget, _Component);\n return _createClass(FuncWidget, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForMeta = [\"config\", \"field\", \"operator\", \"value\", \"fieldSrc\", \"fieldType\", \"isLHS\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return k === \"parentFuncs\" ? !shallowEqual(nextProps[k], prevProps[k], true) : nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref5) {\n var _value$get3, _value$get4;\n var config = _ref5.config,\n field = _ref5.field,\n operator = _ref5.operator,\n value = _ref5.value;\n var funcKey = (_value$get3 = value === null || value === void 0 || (_value$get4 = value.get) === null || _value$get4 === void 0 ? void 0 : _value$get4.call(value, \"func\")) !== null && _value$get3 !== void 0 ? _value$get3 : null;\n var funcDefinition = funcKey ? getFuncConfig(config, funcKey) : null;\n return {\n funcDefinition: funcDefinition,\n funcKey: funcKey\n };\n }\n }, {\n key: \"render\",\n value: function render() {\n var parentFuncs = this.props.parentFuncs;\n var funcPath = parentFuncs ? parentFuncs.map(function (_ref6) {\n var _ref7 = _slicedToArray(_ref6, 2),\n f = _ref7[0],\n a = _ref7[1];\n return \"\".concat(f, \"_\").concat(a);\n }).join(\"-\") : \"root\";\n var funcLevel = (parentFuncs === null || parentFuncs === void 0 ? void 0 : parentFuncs.length) || 0;\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--func--wrapper rule--func--wrapper--under-\".concat(funcPath, \" rule--func--wrapper--lev-\").concat(funcLevel)\n }, this.renderFuncSelect(), this.renderFuncArgs());\n }\n }]);\n}(Component);\nFuncWidget.propTypes = {\n id: PropTypes.string,\n groupId: PropTypes.string,\n config: PropTypes.object.isRequired,\n field: PropTypes.any,\n fieldSrc: PropTypes.string,\n fieldType: PropTypes.string,\n fieldError: PropTypes.string,\n operator: PropTypes.string,\n customProps: PropTypes.object,\n value: PropTypes.object,\n //instanceOf(Immutable.Map) //with keys 'func' and `args`\n setValue: PropTypes.func.isRequired,\n setFuncValue: PropTypes.func,\n readonly: PropTypes.bool,\n parentFuncs: PropTypes.array,\n parentDelta: PropTypes.number,\n fieldDefinition: PropTypes.object,\n isFuncArg: PropTypes.bool,\n isLHS: PropTypes.bool,\n valueError: PropTypes.string\n};\nexport { FuncWidget as default };\nvar ArgWidget = /*#__PURE__*/function (_Component2) {\n function ArgWidget(props) {\n var _this2;\n _classCallCheck(this, ArgWidget);\n _this2 = _callSuper(this, ArgWidget, [props]);\n _this2.setValue = function (_delta, value, widgetType, asyncListValues, _meta) {\n var _this2$props = _this2.props,\n setValue = _this2$props.setValue,\n argKey = _this2$props.argKey;\n setValue(argKey, value, widgetType, asyncListValues, _meta);\n };\n _this2.setValueSrc = function (_delta, valueSrc, _meta) {\n var _this2$props2 = _this2.props,\n setValueSrc = _this2$props2.setValueSrc,\n argKey = _this2$props2.argKey;\n setValueSrc(argKey, valueSrc, _meta);\n };\n useOnPropsChanged(_this2);\n _this2.onPropsChanged(props);\n return _this2;\n }\n _inherits(ArgWidget, _Component2);\n return _createClass(ArgWidget, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForMeta = [\"parentFuncs\", \"funcKey\", \"argKey\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return k === \"parentFuncs\" ? !shallowEqual(nextProps[k], prevProps[k], true) : nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref8) {\n var parentFuncs = _ref8.parentFuncs,\n funcKey = _ref8.funcKey,\n argKey = _ref8.argKey;\n var newParentFuncs = [].concat(_toConsumableArray(parentFuncs || []), [[funcKey, argKey]]);\n return {\n parentFuncs: newParentFuncs\n };\n }\n }, {\n key: \"render\",\n value: function render() {\n var parentFuncs = this.meta.parentFuncs;\n return /*#__PURE__*/React.createElement(Widget, _extends({}, this.props, {\n parentDelta: this.props.parentDelta,\n setValue: this.setValue,\n setValueSrc: this.setValueSrc,\n isFuncArg: true,\n parentFuncs: parentFuncs\n }));\n }\n }]);\n}(Component);\nArgWidget.propTypes = {\n funcKey: PropTypes.string.isRequired,\n argKey: PropTypes.string.isRequired,\n setValue: PropTypes.func.isRequired,\n setValueSrc: PropTypes.func.isRequired,\n readonly: PropTypes.bool,\n isLHS: PropTypes.bool,\n parentFuncs: PropTypes.array,\n id: PropTypes.string,\n groupId: PropTypes.string\n};","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport Field from \"./Field\";\nimport { Col } from \"../utils\";\nimport FuncWidget from \"./FuncWidget\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nvar FieldWrapper = /*#__PURE__*/function (_Component) {\n function FieldWrapper(props) {\n var _this;\n _classCallCheck(this, FieldWrapper);\n _this = _callSuper(this, FieldWrapper, [props]);\n _this.renderField = function () {\n var _this$props = _this.props,\n config = _this$props.config,\n classname = _this$props.classname,\n selectedField = _this$props.selectedField,\n selectedFieldSrc = _this$props.selectedFieldSrc,\n selectedFieldType = _this$props.selectedFieldType,\n setField = _this$props.setField,\n setFuncValue = _this$props.setFuncValue,\n parentField = _this$props.parentField,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId,\n fieldError = _this$props.fieldError,\n valueError = _this$props.valueError;\n var supportedFieldSrcs = [\"func\", \"field\"];\n if (!supportedFieldSrcs.includes(selectedFieldSrc)) {\n return \"?\";\n }\n var field = selectedFieldSrc === \"func\" ? /*#__PURE__*/React.createElement(FuncWidget, {\n isLHS: true,\n config: config,\n value: selectedField,\n fieldSrc: selectedFieldSrc,\n fieldType: selectedFieldType,\n fieldError: fieldError,\n valueError: valueError,\n parentField: parentField,\n setValue: setField,\n setFuncValue: setFuncValue,\n readonly: readonly,\n id: id,\n groupId: groupId,\n key: \"field-func-\" + id\n }) : /*#__PURE__*/React.createElement(Field, {\n config: config,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedFieldType: selectedFieldType,\n parentField: parentField,\n setField: setField,\n customProps: config.settings.customFieldSelectProps,\n readonly: readonly,\n id: id,\n groupId: groupId,\n key: \"field-\" + id\n });\n var fieldLabel = selectedFieldSrc === \"func\" ? config.settings.funcLabel : config.settings.fieldLabel;\n var label = config.settings.showLabels && selectedFieldSrc !== \"func\" && /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, fieldLabel);\n return /*#__PURE__*/React.createElement(\"div\", {\n key: selectedFieldSrc,\n className: classname\n }, label, field);\n };\n _this.renderFieldSources = function () {\n if (!_this.meta) return null;\n var _this$props2 = _this.props,\n config = _this$props2.config,\n readonly = _this$props2.readonly,\n selectedFieldSrc = _this$props2.selectedFieldSrc,\n setFieldSrc = _this$props2.setFieldSrc,\n id = _this$props2.id;\n var fieldSourcesOptions = _this.meta.fieldSourcesOptions;\n var settings = config.settings;\n var ValueSources = _this.ValueSources;\n var sourceLabel = settings.showLabels ? /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, \"\\xA0\") : null;\n return fieldSourcesOptions.length > 1 && !readonly && /*#__PURE__*/React.createElement(\"div\", {\n key: \"fieldsrc\",\n className: \"rule--fieldsrc\"\n }, sourceLabel, /*#__PURE__*/React.createElement(ValueSources, {\n key: \"fieldsrc-\" + id,\n valueSources: fieldSourcesOptions,\n valueSrc: selectedFieldSrc,\n config: config,\n setValueSrc: setFieldSrc,\n readonly: readonly,\n title: settings.fieldSourcesPopupTitle\n }));\n };\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(FieldWrapper, _Component);\n return _createClass(FieldWrapper, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var configChanged = !this.ValueSources || (prevProps === null || prevProps === void 0 ? void 0 : prevProps.config) !== (nextProps === null || nextProps === void 0 ? void 0 : nextProps.config);\n var keysForMeta = [\"config\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n if (configChanged) {\n var config = nextProps.config;\n var renderValueSources = config.settings.renderValueSources;\n this.ValueSources = function (pr) {\n return renderValueSources(pr, config.ctx);\n };\n }\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref) {\n var config = _ref.config;\n var defaultValueSourcesLabels = {\n value: \"Value\",\n field: \"Field\",\n func: \"Function\"\n };\n var _config$settings = config.settings,\n valueSourcesInfo = _config$settings.valueSourcesInfo,\n fieldSources = _config$settings.fieldSources;\n var fieldSourcesOptions = fieldSources.map(function (srcKey) {\n var _ref2, _valueSourcesInfo$src, _valueSourcesInfo$src2;\n return [srcKey, {\n label: (_ref2 = (_valueSourcesInfo$src = (_valueSourcesInfo$src2 = valueSourcesInfo[srcKey]) === null || _valueSourcesInfo$src2 === void 0 ? void 0 : _valueSourcesInfo$src2.label) !== null && _valueSourcesInfo$src !== void 0 ? _valueSourcesInfo$src : defaultValueSourcesLabels[srcKey]) !== null && _ref2 !== void 0 ? _ref2 : srcKey\n }];\n });\n return {\n fieldSourcesOptions: fieldSourcesOptions\n };\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props3 = this.props,\n classname = _this$props3.classname,\n canSelectFieldSource = _this$props3.canSelectFieldSource;\n var fieldSources = canSelectFieldSource && this.renderFieldSources();\n var field = this.renderField();\n if (!canSelectFieldSource) {\n return field;\n } else {\n return /*#__PURE__*/React.createElement(Col, {\n className: \"rule--field-wrapper\"\n }, fieldSources, field);\n }\n }\n }]);\n}(Component);\nexport { FieldWrapper as default };","import _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nvar _excluded = [\"factory\"];\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nvar getOperatorConfig = Utils.ConfigUtils.getOperatorConfig;\nvar OperatorOptions = /*#__PURE__*/function (_PureComponent) {\n function OperatorOptions() {\n _classCallCheck(this, OperatorOptions);\n return _callSuper(this, OperatorOptions, arguments);\n }\n _inherits(OperatorOptions, _PureComponent);\n return _createClass(OperatorOptions, [{\n key: \"render\",\n value: function render() {\n if (!this.props.selectedOperator) return null;\n var operatorDefinitions = getOperatorConfig(this.props.config, this.props.selectedOperator, this.props.selectedField);\n if (typeof operatorDefinitions.options === \"undefined\") {\n return null;\n }\n var _operatorDefinitions$ = operatorDefinitions.options,\n optionsFactory = _operatorDefinitions$.factory,\n basicOptionsProps = _objectWithoutProperties(_operatorDefinitions$, _excluded);\n var optionsProps = Object.assign({}, basicOptionsProps, {\n config: this.props.config,\n field: this.props.selectedField,\n fieldSrc: this.props.selectedFieldSrc,\n operator: this.props.selectedOperator,\n options: this.props.operatorOptions,\n setOption: this.props.setOperatorOption,\n readonly: this.props.readonly\n });\n var optionsCmp = optionsFactory(optionsProps, this.props.config.ctx);\n var name = this.props.selectedOperator;\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule--operator rule--operator--\".concat(name.toUpperCase())\n }, optionsCmp);\n }\n }]);\n}(PureComponent);\nOperatorOptions.propTypes = {\n config: PropTypes.object.isRequired,\n operatorOptions: PropTypes.any.isRequired,\n //instanceOf(Immutable.Map)\n selectedField: PropTypes.any,\n selectedFieldSrc: PropTypes.string,\n selectedOperator: PropTypes.string.isRequired,\n readonly: PropTypes.bool,\n //actions\n setOperatorOption: PropTypes.func.isRequired\n};\nexport { OperatorOptions as default };","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport RuleContainer from \"../containers/RuleContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport OperatorWrapper from \"../rule/OperatorWrapper\";\nimport FieldWrapper from \"../rule/FieldWrapper\";\nimport Widget from \"../rule/Widget\";\nimport OperatorOptions from \"../rule/OperatorOptions\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport { Col, dummyFn, WithConfirmFn, getRenderFromConfig } from \"../utils\";\nimport classNames from \"classnames\";\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getOperatorConfig = _Utils$ConfigUtils.getOperatorConfig,\n getFieldWidgetConfig = _Utils$ConfigUtils.getFieldWidgetConfig,\n getFieldId = _Utils$ConfigUtils.getFieldId;\nvar isEmptyRuleProperties = Utils.RuleUtils.isEmptyRuleProperties;\nvar Rule = /*#__PURE__*/function (_Component) {\n function Rule(props) {\n var _this;\n _classCallCheck(this, Rule);\n _this = _callSuper(this, Rule, [props]);\n useOnPropsChanged(_this);\n _this.removeSelf = _this.removeSelf.bind(_this);\n _this.setLock = _this.setLock.bind(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(Rule, _Component);\n return _createClass(Rule, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var _this2 = this;\n var prevProps = this.props;\n var configChanged = !this.Icon || (prevProps === null || prevProps === void 0 ? void 0 : prevProps.config) !== (nextProps === null || nextProps === void 0 ? void 0 : nextProps.config);\n var keysForMeta = [\"selectedField\", \"selectedFieldSrc\", \"selectedFieldType\", \"selectedOperator\", \"config\", \"reordableNodesCnt\", \"isLocked\", \"parentField\", \"parentFieldCanReorder\"];\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n if (configChanged) {\n var config = nextProps.config;\n var _config$settings = config.settings,\n renderIcon = _config$settings.renderIcon,\n renderButton = _config$settings.renderButton,\n renderButtonGroup = _config$settings.renderButtonGroup,\n renderSwitch = _config$settings.renderSwitch,\n renderBeforeWidget = _config$settings.renderBeforeWidget,\n renderAfterWidget = _config$settings.renderAfterWidget,\n renderRuleError = _config$settings.renderRuleError;\n this.Icon = getRenderFromConfig(config, renderIcon);\n this.Btn = getRenderFromConfig(config, renderButton);\n this.BtnGrp = getRenderFromConfig(config, renderButtonGroup);\n this.Switch = getRenderFromConfig(config, renderSwitch);\n this.BeforeWidget = getRenderFromConfig(config, renderBeforeWidget);\n this.AfterWidget = getRenderFromConfig(config, renderAfterWidget);\n this.RuleError = getRenderFromConfig(config, renderRuleError);\n }\n this.doRemove = function () {\n _this2.props.removeSelf();\n };\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref) {\n var selectedField = _ref.selectedField,\n selectedFieldType = _ref.selectedFieldType,\n selectedOperator = _ref.selectedOperator,\n config = _ref.config,\n reordableNodesCnt = _ref.reordableNodesCnt,\n isLocked = _ref.isLocked,\n parentField = _ref.parentField,\n parentFieldCanReorder = _ref.parentFieldCanReorder;\n var keepInputOnChangeFieldSrc = config.settings.keepInputOnChangeFieldSrc;\n var selectedFieldId = getFieldId(selectedField, config);\n var selectedFieldConfig = getFieldConfig(config, selectedField);\n var isSelectedGroup = selectedFieldConfig && selectedFieldConfig.type === \"!struct\";\n var isOkWithoutField = keepInputOnChangeFieldSrc && selectedFieldType;\n var isFieldSelected = !!selectedField || isOkWithoutField;\n var isFieldAndOpSelected = isFieldSelected && selectedOperator;\n var selectedOperatorConfig = getOperatorConfig(config, selectedOperator, selectedField);\n var selectedOperatorHasOptions = selectedOperatorConfig && selectedOperatorConfig.options != null;\n var selectedFieldWidgetConfig = getFieldWidgetConfig(config, selectedField, selectedOperator, null, null) || {};\n var hideOperator = selectedFieldWidgetConfig.hideOperator;\n var showDragIcon = config.settings.canReorder && reordableNodesCnt > 1 && !isLocked;\n if (parentField) {\n showDragIcon = showDragIcon && parentFieldCanReorder;\n }\n var showOperator = isFieldSelected && !hideOperator;\n var showOperatorLabel = isFieldSelected && hideOperator && selectedFieldWidgetConfig.operatorInlineLabel;\n var showWidget = isFieldAndOpSelected && !isSelectedGroup;\n var showOperatorOptions = isFieldAndOpSelected && selectedOperatorHasOptions;\n return {\n selectedFieldId: selectedFieldId,\n selectedFieldWidgetConfig: selectedFieldWidgetConfig,\n showDragIcon: showDragIcon,\n showOperator: showOperator,\n showOperatorLabel: showOperatorLabel,\n showWidget: showWidget,\n showOperatorOptions: showOperatorOptions\n };\n }\n }, {\n key: \"setLock\",\n value: function setLock(lock) {\n this.props.setLock(lock);\n }\n }, {\n key: \"removeSelf\",\n value: function removeSelf() {\n var _this$props = this.props,\n confirmFn = _this$props.confirmFn,\n config = _this$props.config;\n var _config$settings2 = config.settings,\n renderConfirm = _config$settings2.renderConfirm,\n confirmOptions = _config$settings2.removeRuleConfirmOptions;\n if (confirmOptions && !this.isEmptyCurrentRule()) {\n renderConfirm.call(config.ctx, _objectSpread(_objectSpread({}, confirmOptions), {}, {\n onOk: this.doRemove,\n onCancel: null,\n confirmFn: confirmFn\n }), config.ctx);\n } else {\n this.doRemove();\n }\n }\n }, {\n key: \"_buildWidgetProps\",\n value: function _buildWidgetProps(_ref2, _ref3) {\n var selectedField = _ref2.selectedField,\n selectedFieldSrc = _ref2.selectedFieldSrc,\n selectedFieldType = _ref2.selectedFieldType,\n selectedOperator = _ref2.selectedOperator,\n operatorOptions = _ref2.operatorOptions,\n value = _ref2.value,\n valueType = _ref2.valueType,\n valueSrc = _ref2.valueSrc,\n asyncListValues = _ref2.asyncListValues,\n valueError = _ref2.valueError,\n fieldError = _ref2.fieldError,\n parentField = _ref2.parentField;\n var selectedFieldId = _ref3.selectedFieldId;\n return {\n field: selectedField,\n fieldSrc: selectedFieldSrc,\n fieldType: selectedFieldType,\n fieldId: selectedFieldId,\n operator: selectedOperator,\n operatorOptions: operatorOptions,\n value: value,\n valueType: valueType,\n valueSrc: valueSrc,\n asyncListValues: asyncListValues,\n valueError: valueError,\n fieldError: fieldError,\n parentField: parentField\n };\n }\n }, {\n key: \"isEmptyCurrentRule\",\n value: function isEmptyCurrentRule() {\n var config = this.props.config;\n var ruleData = this._buildWidgetProps(this.props, this.meta);\n return isEmptyRuleProperties(ruleData, config);\n }\n }, {\n key: \"renderField\",\n value: function renderField() {\n var _this$props2 = this.props,\n config = _this$props2.config,\n isLocked = _this$props2.isLocked,\n parentField = _this$props2.parentField,\n groupId = _this$props2.groupId,\n id = _this$props2.id,\n selectedFieldSrc = _this$props2.selectedFieldSrc,\n selectedField = _this$props2.selectedField,\n selectedFieldType = _this$props2.selectedFieldType,\n setField = _this$props2.setField,\n setFuncValue = _this$props2.setFuncValue,\n setFieldSrc = _this$props2.setFieldSrc,\n fieldError = _this$props2.fieldError;\n var immutableFieldsMode = config.settings.immutableFieldsMode;\n var selectedFieldId = this.meta.selectedFieldId;\n // tip: don't allow function inside !group (yet)\n\n return /*#__PURE__*/React.createElement(FieldWrapper, {\n key: \"field\",\n classname: classNames(selectedFieldSrc == \"func\" ? \"rule--field--func\" : \"rule--field\"),\n config: config,\n canSelectFieldSource: !parentField,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedFieldType: selectedFieldType,\n selectedFieldId: selectedFieldId,\n fieldError: fieldError,\n setField: !immutableFieldsMode ? setField : dummyFn,\n setFuncValue: !immutableFieldsMode ? setFuncValue : dummyFn,\n setFieldSrc: !immutableFieldsMode ? setFieldSrc : dummyFn,\n parentField: parentField,\n readonly: immutableFieldsMode || isLocked,\n id: id,\n groupId: groupId\n });\n }\n }, {\n key: \"renderOperator\",\n value: function renderOperator() {\n var _this$props3 = this.props,\n config = _this$props3.config,\n isLocked = _this$props3.isLocked;\n var _this$meta = this.meta,\n selectedFieldId = _this$meta.selectedFieldId,\n selectedFieldWidgetConfig = _this$meta.selectedFieldWidgetConfig,\n showOperator = _this$meta.showOperator,\n showOperatorLabel = _this$meta.showOperatorLabel;\n var immutableOpsMode = config.settings.immutableOpsMode;\n return /*#__PURE__*/React.createElement(OperatorWrapper, {\n key: \"operator\",\n config: config,\n selectedField: this.props.selectedField,\n selectedFieldSrc: this.props.selectedFieldSrc,\n selectedFieldType: this.props.selectedFieldType,\n selectedFieldId: selectedFieldId,\n selectedOperator: this.props.selectedOperator,\n setOperator: !immutableOpsMode ? this.props.setOperator : dummyFn,\n showOperator: showOperator,\n showOperatorLabel: showOperatorLabel,\n selectedFieldWidgetConfig: selectedFieldWidgetConfig,\n readonly: immutableOpsMode || isLocked,\n id: this.props.id,\n groupId: this.props.groupId\n });\n }\n }, {\n key: \"renderWidget\",\n value: function renderWidget() {\n var _this$props4 = this.props,\n config = _this$props4.config,\n isLocked = _this$props4.isLocked;\n var showWidget = this.meta.showWidget;\n var immutableValuesMode = config.settings.immutableValuesMode;\n if (!showWidget) return null;\n var widget = /*#__PURE__*/React.createElement(Widget, _extends({\n key: \"values\"\n }, this._buildWidgetProps(this.props, this.meta), {\n config: config,\n setValue: !immutableValuesMode ? this.props.setValue : dummyFn,\n setValueSrc: !immutableValuesMode ? this.props.setValueSrc : dummyFn,\n setFuncValue: !immutableValuesMode ? this.props.setFuncValue : dummyFn,\n readonly: immutableValuesMode || isLocked,\n id: this.props.id,\n groupId: this.props.groupId\n }));\n return /*#__PURE__*/React.createElement(Col, {\n key: \"widget-for-\" + this.props.selectedOperator,\n className: \"rule--value\"\n }, widget);\n }\n }, {\n key: \"renderOperatorOptions\",\n value: function renderOperatorOptions() {\n var config = this.props.config;\n var showOperatorOptions = this.meta.showOperatorOptions;\n var _config$settings3 = config.settings,\n immutableOpsMode = _config$settings3.immutableOpsMode,\n immutableValuesMode = _config$settings3.immutableValuesMode;\n if (!showOperatorOptions) return null;\n var opOpts = /*#__PURE__*/React.createElement(OperatorOptions, {\n key: \"operatorOptions\",\n selectedField: this.props.selectedField,\n selectedOperator: this.props.selectedOperator,\n operatorOptions: this.props.operatorOptions,\n setOperatorOption: !immutableOpsMode ? this.props.setOperatorOption : dummyFn,\n config: config,\n readonly: immutableValuesMode\n });\n return /*#__PURE__*/React.createElement(Col, {\n key: \"op-options-for-\" + this.props.selectedOperator,\n className: \"rule--operator-options\"\n }, opOpts);\n }\n }, {\n key: \"renderBeforeWidget\",\n value: function renderBeforeWidget() {\n var BeforeWidget = this.BeforeWidget;\n if (!BeforeWidget) return null;\n return /*#__PURE__*/React.createElement(Col, {\n key: \"before-widget-for-\" + this.props.selectedOperator,\n className: \"rule--before-widget\"\n }, /*#__PURE__*/React.createElement(BeforeWidget, this.props));\n }\n }, {\n key: \"renderAfterWidget\",\n value: function renderAfterWidget() {\n var AfterWidget = this.AfterWidget;\n if (!AfterWidget) return null;\n return /*#__PURE__*/React.createElement(Col, {\n key: \"after-widget-for-\" + this.props.selectedOperator,\n className: \"rule--after-widget\"\n }, /*#__PURE__*/React.createElement(AfterWidget, this.props));\n }\n }, {\n key: \"renderError\",\n value: function renderError() {\n var _this$props5 = this.props,\n config = _this$props5.config,\n valueError = _this$props5.valueError,\n fieldError = _this$props5.fieldError;\n var showErrorMessage = config.settings.showErrorMessage;\n var RuleError = this.RuleError;\n var oneError = [fieldError].concat(_toConsumableArray((valueError === null || valueError === void 0 ? void 0 : valueError.toArray()) || [])).filter(function (e) {\n return !!e;\n }).shift() || null;\n return showErrorMessage && oneError && /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule--error\"\n }, RuleError ? /*#__PURE__*/React.createElement(RuleError, {\n error: oneError\n }) : oneError);\n }\n }, {\n key: \"renderDrag\",\n value: function renderDrag() {\n var handleDraggerMouseDown = this.props.handleDraggerMouseDown;\n var showDragIcon = this.meta.showDragIcon;\n var Icon = this.Icon;\n var icon = /*#__PURE__*/React.createElement(Icon, {\n type: \"drag\"\n });\n return showDragIcon && /*#__PURE__*/React.createElement(\"div\", {\n key: \"rule-drag-icon\",\n onMouseDown: handleDraggerMouseDown,\n className: \"qb-drag-handler rule--drag-handler\"\n }, icon);\n }\n }, {\n key: \"renderDel\",\n value: function renderDel() {\n var _this$props6 = this.props,\n config = _this$props6.config,\n isLocked = _this$props6.isLocked;\n var _config$settings4 = config.settings,\n deleteLabel = _config$settings4.deleteLabel,\n immutableGroupsMode = _config$settings4.immutableGroupsMode,\n canDeleteLocked = _config$settings4.canDeleteLocked;\n var Icon = this.Icon;\n var Btn = this.Btn;\n return !immutableGroupsMode && (!isLocked || isLocked && canDeleteLocked) && /*#__PURE__*/React.createElement(Btn, {\n key: \"rule-del\",\n type: \"delRule\",\n onClick: this.removeSelf,\n label: deleteLabel,\n config: config,\n renderIcon: Icon\n });\n }\n }, {\n key: \"renderLock\",\n value: function renderLock() {\n var _this$props7 = this.props,\n config = _this$props7.config,\n isLocked = _this$props7.isLocked,\n isTrueLocked = _this$props7.isTrueLocked,\n id = _this$props7.id;\n var _config$settings5 = config.settings,\n lockLabel = _config$settings5.lockLabel,\n lockedLabel = _config$settings5.lockedLabel,\n showLock = _config$settings5.showLock;\n var Switch = this.Switch;\n return showLock && !(isLocked && !isTrueLocked) && /*#__PURE__*/React.createElement(Switch, {\n key: \"rule-lock\",\n type: \"lock\",\n id: id,\n value: isLocked,\n setValue: this.setLock,\n label: lockLabel,\n checkedLabel: lockedLabel,\n hideLabel: true,\n config: config\n });\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$meta2 = this.meta,\n showOperatorOptions = _this$meta2.showOperatorOptions,\n selectedFieldWidgetConfig = _this$meta2.selectedFieldWidgetConfig;\n var _this$props8 = this.props,\n valueSrc = _this$props8.valueSrc,\n value = _this$props8.value,\n config = _this$props8.config;\n var canShrinkValue = (valueSrc === null || valueSrc === void 0 ? void 0 : valueSrc.first()) == \"value\" && !showOperatorOptions && value.size == 1 && selectedFieldWidgetConfig.fullWidth;\n var BtnGrp = this.BtnGrp;\n var parts = [this.renderField(), this.renderOperator(), this.renderBeforeWidget(), this.renderWidget(), this.renderAfterWidget(), this.renderOperatorOptions()];\n var body = /*#__PURE__*/React.createElement(\"div\", {\n key: \"rule-body\",\n className: classNames(\"rule--body\", canShrinkValue && \"can--shrink--value\")\n }, parts);\n var error = this.renderError();\n var drag = this.renderDrag();\n var lock = this.renderLock();\n var del = this.renderDel();\n return /*#__PURE__*/React.createElement(React.Fragment, null, drag, /*#__PURE__*/React.createElement(\"div\", {\n key: \"rule-body-wrapper\",\n className: \"rule--body--wrapper\"\n }, body, error), /*#__PURE__*/React.createElement(\"div\", {\n key: \"rule-header-wrapper\",\n className: \"rule--header\"\n }, /*#__PURE__*/React.createElement(BtnGrp, {\n key: \"rule-header-group\",\n config: config\n }, lock, del)));\n }\n }]);\n}(Component);\nRule.propTypes = {\n id: PropTypes.string.isRequired,\n groupId: PropTypes.string,\n selectedField: PropTypes.any,\n selectedFieldSrc: PropTypes.string,\n selectedFieldType: PropTypes.string,\n selectedOperator: PropTypes.string,\n operatorOptions: PropTypes.object,\n config: PropTypes.object.isRequired,\n value: PropTypes.any,\n //depends on widget\n valueSrc: PropTypes.any,\n valueType: PropTypes.any,\n asyncListValues: PropTypes.array,\n isDraggingMe: PropTypes.bool,\n isDraggingTempo: PropTypes.bool,\n parentField: PropTypes.string,\n //from RuleGroup\n valueError: PropTypes.any,\n fieldError: PropTypes.string,\n isLocked: PropTypes.bool,\n isTrueLocked: PropTypes.bool,\n //path: PropTypes.instanceOf(Immutable.List),\n //actions\n handleDraggerMouseDown: PropTypes.func,\n setField: PropTypes.func,\n setFieldSrc: PropTypes.func,\n setOperator: PropTypes.func,\n setOperatorOption: PropTypes.func,\n setLock: PropTypes.func,\n removeSelf: PropTypes.func,\n setValue: PropTypes.func,\n setValueSrc: PropTypes.func,\n setFuncValue: PropTypes.func,\n reordableNodesCnt: PropTypes.number,\n totalRulesCnt: PropTypes.number,\n parentReordableNodesCnt: PropTypes.number,\n parentFieldCanReorder: PropTypes.bool\n};\nexport default RuleContainer(Draggable(\"rule\")(WithConfirmFn(Rule)));","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport mapValues from \"lodash/mapValues\";\nimport context from \"../../stores/context\";\nimport { pureShouldComponentUpdate, useOnPropsChanged } from \"../../utils/reactUtils\";\nimport classNames from \"classnames\";\nimport { connect } from \"react-redux\";\nvar defaultGroupConjunction = Utils.DefaultUtils.defaultGroupConjunction;\nvar getFieldConfig = Utils.ConfigUtils.getFieldConfig;\nvar createGroupContainer = function createGroupContainer(Group, itemType) {\n var _GroupContainer;\n return _GroupContainer = /*#__PURE__*/function (_Component) {\n function GroupContainer(_props) {\n var _this;\n _classCallCheck(this, GroupContainer);\n _this = _callSuper(this, GroupContainer, [_props]);\n _this._selectedConjunction = function (props) {\n props = props || _this.props;\n return props.conjunction || defaultGroupConjunction(props.config, props.field);\n };\n _this.setConjunction = function () {\n var conj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n _this.props.actions.setConjunction(_this.props.path, conj);\n };\n _this.setNot = function () {\n var not = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n _this.props.actions.setNot(_this.props.path, not);\n };\n _this.setLock = function () {\n var lock = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n _this.props.actions.setLock(_this.props.path, lock);\n };\n _this.dummyFn = function () {};\n _this.removeSelf = function () {\n _this.props.actions.removeGroup(_this.props.path);\n };\n _this.addGroup = function () {\n var parentRuleGroupField = itemType == \"rule_group\" ? _this.props.field : _this.props.parentField;\n _this.props.actions.addGroup(_this.props.path, undefined, undefined, parentRuleGroupField);\n };\n _this.addCaseGroup = function () {\n _this.props.actions.addCaseGroup(_this.props.path);\n };\n _this.addDefaultCaseGroup = function () {\n _this.props.actions.addDefaultCaseGroup(_this.props.path);\n };\n _this.addRule = function () {\n var parentRuleGroupField = itemType == \"rule_group\" ? _this.props.field : _this.props.parentField;\n _this.props.actions.addRule(_this.props.path, undefined, undefined, undefined, parentRuleGroupField);\n };\n // for RuleGroup\n _this.setField = function (field, asyncListValues, _meta) {\n _this.props.actions.setField(_this.props.path, field, asyncListValues, _meta);\n };\n // for RuleGroupExt\n _this.setOperator = function (operator) {\n _this.props.actions.setOperator(_this.props.path, operator);\n };\n // for RuleGroupExt, CaseGroup\n _this.setValue = function (delta, value, type, asyncListValues, _meta) {\n _this.props.actions.setValue(_this.props.path, delta, value, type, asyncListValues, _meta);\n };\n _this.setValueSrc = function (delta, srcKey, _meta) {\n _this.props.actions.setValueSrc(_this.props.path, delta, srcKey, _meta);\n };\n // can be used for both LHS and LHS\n _this.setFuncValue = function (delta, parentFuncs, argKey, value, type, asyncListValues, _meta) {\n _this.props.actions.setFuncValue(_this.props.path, delta, parentFuncs, argKey, value, type, asyncListValues, _meta);\n };\n _this.pureShouldComponentUpdate = pureShouldComponentUpdate(_this);\n useOnPropsChanged(_this);\n _this.selectedConjunction = _this._selectedConjunction(_props);\n _this.conjunctionOptions = _this._getConjunctionOptions(_props);\n _this.dummyFn.isDummyFn = true;\n return _this;\n }\n _inherits(GroupContainer, _Component);\n return _createClass(GroupContainer, [{\n key: \"shouldComponentUpdate\",\n value: function shouldComponentUpdate(nextProps, nextState) {\n var prevProps = this.props;\n var prevState = this.state;\n var should = this.pureShouldComponentUpdate(nextProps, nextState);\n if (should) {\n if (prevState == nextState && prevProps != nextProps) {\n var draggingId = nextProps.dragging.id || prevProps.dragging.id;\n var isDraggingMe = draggingId == nextProps.id;\n var chs = [];\n for (var k in nextProps) {\n var changed = nextProps[k] != prevProps[k];\n if (k == \"dragging\" && !isDraggingMe) {\n changed = false; //dragging another item -> ignore\n }\n if (changed) {\n chs.push(k);\n }\n }\n if (!chs.length) should = false;\n }\n }\n return should;\n }\n }, {\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var config = nextProps.config,\n id = nextProps.id,\n conjunction = nextProps.conjunction;\n var oldConfig = this.props.config;\n var oldConjunction = this.props.conjunction;\n if (oldConfig != config || oldConjunction != conjunction) {\n this.selectedConjunction = this._selectedConjunction(nextProps);\n this.conjunctionOptions = this._getConjunctionOptions(nextProps);\n }\n }\n }, {\n key: \"_getConjunctionOptions\",\n value: function _getConjunctionOptions(props) {\n var _this2 = this;\n return mapValues(props.config.conjunctions, function (item, index) {\n return {\n id: \"conjunction-\".concat(props.id, \"-\").concat(index),\n name: \"conjunction[\".concat(props.id, \"]\"),\n key: index,\n label: item.label,\n checked: index === _this2._selectedConjunction(props)\n };\n });\n }\n }, {\n key: \"render\",\n value: function render() {\n var showErrorMessage = this.props.config.settings.showErrorMessage;\n var isDraggingMe = this.props.dragging.id == this.props.id;\n var currentNesting = this.props.path.size;\n var maxNesting = this.props.config.settings.maxNesting;\n var isRoot = currentNesting == 1;\n if (this.props.parentField && this.props.parentFieldPathSize) {\n // inside rule-group\n var ruleGroupFieldConfig = getFieldConfig(this.props.config, this.props.parentField);\n currentNesting = this.props.path.size - this.props.parentFieldPathSize + 1;\n maxNesting = ruleGroupFieldConfig === null || ruleGroupFieldConfig === void 0 ? void 0 : ruleGroupFieldConfig.maxNesting;\n isRoot = false;\n } else if (this.props.field) {\n // it is rule-group\n var _ruleGroupFieldConfig = getFieldConfig(this.props.config, this.props.field);\n currentNesting = 1;\n maxNesting = _ruleGroupFieldConfig === null || _ruleGroupFieldConfig === void 0 ? void 0 : _ruleGroupFieldConfig.maxNesting;\n isRoot = false;\n }\n var isInDraggingTempo = !isDraggingMe && this.props.isDraggingTempo;\n var fieldType = this.props.fieldType || null;\n var valueError = this.props.valueError;\n var oneError = _toConsumableArray((valueError === null || valueError === void 0 ? void 0 : valueError.toArray()) || []).filter(function (e) {\n return !!e;\n }).shift() || null;\n var hasError = oneError != null && showErrorMessage;\n\n // Don't allow nesting further than the maximum configured depth and don't\n // allow removal of the root group.\n var allowFurtherNesting = typeof maxNesting === \"undefined\" || currentNesting < maxNesting;\n var isMaxNestingExceeded = maxNesting && currentNesting > maxNesting;\n return /*#__PURE__*/React.createElement(\"div\", {\n className: classNames(\"group-or-rule-container\", \"group-container\", hasError ? \"group-with-error\" : null),\n \"data-id\": this.props.id\n }, [isDraggingMe ? /*#__PURE__*/React.createElement(Group, {\n key: \"dragging\",\n id: this.props.id,\n groupId: this.props.groupId,\n isDraggingMe: true,\n isDraggingTempo: true,\n dragging: this.props.dragging,\n isRoot: isRoot,\n lev: this.props.path.size - 1,\n allowFurtherNesting: allowFurtherNesting,\n isMaxNestingExceeded: isMaxNestingExceeded,\n conjunctionOptions: this.conjunctionOptions,\n not: this.props.not,\n selectedConjunction: this.selectedConjunction,\n setConjunction: this.dummyFn,\n setNot: this.dummyFn,\n setLock: this.dummyFn,\n removeSelf: this.dummyFn,\n addGroup: this.dummyFn,\n addCaseGroup: this.dummyFn,\n addDefaultCaseGroup: this.dummyFn,\n addRule: this.dummyFn,\n setField: this.dummyFn,\n setFuncValue: this.dummyFn,\n setOperator: this.dummyFn,\n setValue: this.dummyFn,\n setValueSrc: this.dummyFn,\n value: this.props.value || null,\n valueError: this.props.valueError || null,\n valueSrc: this.props.valueSrc || null,\n config: this.props.config,\n children1: this.props.children1,\n actions: this.props.actions,\n reordableNodesCnt: this.props.reordableNodesCnt,\n totalRulesCnt: this.props.totalRulesCnt,\n selectedField: this.props.field || null,\n selectedFieldSrc: this.props.fieldSrc || \"field\",\n selectedFieldType: fieldType,\n parentField: this.props.parentField || null,\n parentFieldPathSize: this.props.parentFieldPathSize,\n parentFieldCanReorder: this.props.parentFieldCanReorder,\n selectedOperator: this.props.operator || null,\n isLocked: this.props.isLocked,\n isTrueLocked: this.props.isTrueLocked,\n parentReordableNodesCnt: this.props.parentReordableNodesCnt\n }) : null, /*#__PURE__*/React.createElement(Group, {\n key: this.props.id,\n id: this.props.id,\n groupId: this.props.groupId,\n isDraggingMe: isDraggingMe,\n isDraggingTempo: isInDraggingTempo,\n onDragStart: this.props.onDragStart,\n isRoot: isRoot,\n lev: this.props.path.size - 1,\n allowFurtherNesting: allowFurtherNesting,\n isMaxNestingExceeded: isMaxNestingExceeded,\n conjunctionOptions: this.conjunctionOptions,\n not: this.props.not,\n selectedConjunction: this.selectedConjunction,\n setConjunction: isInDraggingTempo ? this.dummyFn : this.setConjunction,\n setNot: isInDraggingTempo ? this.dummyFn : this.setNot,\n setLock: isInDraggingTempo ? this.dummyFn : this.setLock,\n removeSelf: isInDraggingTempo ? this.dummyFn : this.removeSelf,\n addGroup: isInDraggingTempo ? this.dummyFn : this.addGroup,\n addCaseGroup: isInDraggingTempo ? this.dummyFn : this.addCaseGroup,\n addDefaultCaseGroup: isInDraggingTempo ? this.dummyFn : this.addDefaultCaseGroup,\n addRule: isInDraggingTempo ? this.dummyFn : this.addRule,\n setField: isInDraggingTempo ? this.dummyFn : this.setField,\n setFuncValue: isInDraggingTempo ? this.dummyFn : this.setFuncValue,\n setOperator: isInDraggingTempo ? this.dummyFn : this.setOperator,\n setValue: isInDraggingTempo ? this.dummyFn : this.setValue,\n setValueSrc: isInDraggingTempo ? this.dummyFn : this.setValueSrc,\n value: this.props.value || null,\n valueError: this.props.valueError || null,\n valueSrc: this.props.valueSrc || null,\n config: this.props.config,\n children1: this.props.children1,\n actions: this.props.actions,\n reordableNodesCnt: this.props.reordableNodesCnt,\n totalRulesCnt: this.props.totalRulesCnt,\n selectedField: this.props.field || null,\n selectedFieldSrc: this.props.fieldSrc || \"field\",\n selectedFieldType: fieldType,\n parentField: this.props.parentField || null,\n parentFieldPathSize: this.props.parentFieldPathSize,\n parentFieldCanReorder: this.props.parentFieldCanReorder,\n selectedOperator: this.props.operator || null,\n isLocked: this.props.isLocked,\n isTrueLocked: this.props.isTrueLocked,\n parentReordableNodesCnt: this.props.parentReordableNodesCnt\n })]);\n }\n }]);\n }(Component), _GroupContainer.propTypes = {\n config: PropTypes.object.isRequired,\n actions: PropTypes.object.isRequired,\n //{setConjunction: Function, removeGroup, addGroup, addRule, ...}\n path: PropTypes.any.isRequired,\n //instanceOf(Immutable.List)\n id: PropTypes.string.isRequired,\n groupId: PropTypes.string,\n not: PropTypes.bool,\n conjunction: PropTypes.string,\n children1: PropTypes.any,\n //instanceOf(Immutable.OrderedMap)\n onDragStart: PropTypes.func,\n reordableNodesCnt: PropTypes.number,\n field: PropTypes.any,\n // for RuleGroup\n fieldSrc: PropTypes.string,\n // for RuleGroup\n fieldType: PropTypes.string,\n // for RuleGroup\n parentField: PropTypes.string,\n //from RuleGroup\n value: PropTypes.any,\n // for RuleGroup, CaseGroup\n valueSrc: PropTypes.any,\n valueError: PropTypes.any,\n isLocked: PropTypes.bool,\n isTrueLocked: PropTypes.bool,\n //connected:\n dragging: PropTypes.object,\n //{id, x, y, w, h}\n isDraggingTempo: PropTypes.bool\n }, _GroupContainer;\n};\nexport default (function (Group, itemType) {\n var ConnectedGroupContainer = connect(function (state) {\n return {\n dragging: state.dragging\n };\n }, null, null, {\n context: context\n })(createGroupContainer(Group, itemType));\n ConnectedGroupContainer.displayName = \"ConnectedGroupContainer\";\n return ConnectedGroupContainer;\n});","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nvar groupActionsPositionList = {\n topLeft: \"group--actions--tl\",\n topCenter: \"group--actions--tc\",\n topRight: \"group--actions--tr\",\n bottomLeft: \"group--actions--bl\",\n bottomCenter: \"group--actions--bc\",\n bottomRight: \"group--actions--br\"\n};\nvar defaultPosition = \"topRight\";\nexport var GroupActions = /*#__PURE__*/function (_PureComponent) {\n function GroupActions() {\n _classCallCheck(this, GroupActions);\n return _callSuper(this, GroupActions, arguments);\n }\n _inherits(GroupActions, _PureComponent);\n return _createClass(GroupActions, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n addRule = _this$props.addRule,\n addGroup = _this$props.addGroup,\n removeSelf = _this$props.removeSelf,\n setLock = _this$props.setLock,\n isLocked = _this$props.isLocked,\n isTrueLocked = _this$props.isTrueLocked,\n id = _this$props.id,\n parentField = _this$props.parentField,\n canAddGroup = _this$props.canAddGroup,\n canAddRule = _this$props.canAddRule,\n canDeleteGroup = _this$props.canDeleteGroup;\n var _config$settings = config.settings,\n immutableGroupsMode = _config$settings.immutableGroupsMode,\n addRuleLabel = _config$settings.addRuleLabel,\n addGroupLabel = _config$settings.addGroupLabel,\n addSubRuleLabel = _config$settings.addSubRuleLabel,\n addSubGroupLabel = _config$settings.addSubGroupLabel,\n delGroupLabel = _config$settings.delGroupLabel,\n groupActionsPosition = _config$settings.groupActionsPosition,\n renderButton = _config$settings.renderButton,\n renderIcon = _config$settings.renderIcon,\n renderSwitch = _config$settings.renderSwitch,\n renderButtonGroup = _config$settings.renderButtonGroup,\n lockLabel = _config$settings.lockLabel,\n lockedLabel = _config$settings.lockedLabel,\n showLock = _config$settings.showLock,\n canDeleteLocked = _config$settings.canDeleteLocked;\n var Icon = function Icon(pr) {\n return renderIcon(pr, config.ctx);\n };\n var Btn = function Btn(pr) {\n return renderButton(pr, config.ctx);\n };\n var Switch = function Switch(pr) {\n return renderSwitch(pr, config.ctx);\n };\n var BtnGrp = function BtnGrp(pr) {\n return renderButtonGroup(pr, config.ctx);\n };\n var position = groupActionsPositionList[groupActionsPosition || defaultPosition];\n var setLockSwitch = showLock && !(isLocked && !isTrueLocked) && /*#__PURE__*/React.createElement(Switch, {\n type: \"lock\",\n id: id,\n value: isLocked,\n setValue: setLock,\n label: lockLabel,\n checkedLabel: lockedLabel,\n config: config\n });\n var addRuleBtn = !immutableGroupsMode && canAddRule && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: parentField ? \"addSubRule\" : \"addRule\",\n onClick: addRule,\n label: parentField ? addSubRuleLabel : addRuleLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var addGroupBtn = !immutableGroupsMode && canAddGroup && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: parentField ? \"addSubGroup\" : \"addGroup\",\n onClick: addGroup,\n label: parentField ? addSubGroupLabel : addGroupLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var delGroupBtn = !immutableGroupsMode && canDeleteGroup && (!isLocked || isLocked && canDeleteLocked) && /*#__PURE__*/React.createElement(Btn, {\n type: \"delGroup\",\n onClick: removeSelf,\n label: delGroupLabel,\n config: config,\n renderIcon: Icon\n });\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--actions \".concat(position)\n }, /*#__PURE__*/React.createElement(BtnGrp, {\n config: config\n }, setLockSwitch, addRuleBtn, addGroupBtn, delGroupBtn));\n }\n }]);\n}(PureComponent);","import _readOnlyError from \"@babel/runtime/helpers/readOnlyError\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _createForOfIteratorHelper(r, e) { var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t[\"return\"] || t[\"return\"](); } finally { if (u) throw o; } } }; }\nfunction _unsupportedIterableToArray(r, a) { if (r) { if (\"string\" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }\nfunction _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport startsWith from \"lodash/startsWith\";\nimport GroupContainer from \"../containers/GroupContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport classNames from \"classnames\";\nimport { Item } from \"./Item\";\nimport { GroupActions } from \"./GroupActions\";\nimport { WithConfirmFn, dummyFn, getRenderFromConfig } from \"../utils\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nvar getFieldConfig = Utils.ConfigUtils.getFieldConfig;\nvar isEmptyGroupChildren = Utils.RuleUtils.isEmptyGroupChildren;\nvar _Utils$TreeUtils = Utils.TreeUtils,\n getTotalReordableNodesCountInTree = _Utils$TreeUtils.getTotalReordableNodesCountInTree,\n getTotalRulesCountInTree = _Utils$TreeUtils.getTotalRulesCountInTree;\nvar defaultPosition = \"topRight\";\nexport var BasicGroup = /*#__PURE__*/function (_Component) {\n function BasicGroup(props) {\n var _this;\n _classCallCheck(this, BasicGroup);\n _this = _callSuper(this, BasicGroup, [props]);\n _this.childrenClassName = function () {\n return \"\";\n };\n _this.renderBeforeActions = function () {\n var BeforeActions = _this.BeforeActions;\n if (BeforeActions == undefined) return null;\n return /*#__PURE__*/React.createElement(BeforeActions, _extends({\n key: \"group-actions-before\"\n }, _this.props));\n };\n _this.renderAfterActions = function () {\n var AfterActions = _this.AfterActions;\n if (AfterActions == undefined) return null;\n return /*#__PURE__*/React.createElement(AfterActions, _extends({\n key: \"group-actions-after\"\n }, _this.props));\n };\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n _this.removeSelf = _this.removeSelf.bind(_this);\n _this.setLock = _this.setLock.bind(_this);\n _this.renderItem = _this.renderItem.bind(_this);\n return _this;\n }\n _inherits(BasicGroup, _Component);\n return _createClass(BasicGroup, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var _this2 = this;\n var prevProps = this.props;\n var configChanged = !this.Icon || (prevProps === null || prevProps === void 0 ? void 0 : prevProps.config) !== (nextProps === null || nextProps === void 0 ? void 0 : nextProps.config);\n if (configChanged) {\n var config = nextProps.config;\n var _config$settings = config.settings,\n renderIcon = _config$settings.renderIcon,\n renderConjs = _config$settings.renderConjs,\n renderBeforeActions = _config$settings.renderBeforeActions,\n renderAfterActions = _config$settings.renderAfterActions;\n this.Icon = getRenderFromConfig(config, renderIcon);\n this.Conjs = getRenderFromConfig(config, renderConjs);\n this.BeforeActions = getRenderFromConfig(config, renderBeforeActions);\n this.AfterActions = getRenderFromConfig(config, renderAfterActions);\n }\n this.doRemove = function () {\n _this2.props.removeSelf();\n };\n }\n }, {\n key: \"isGroupTopPosition\",\n value: function isGroupTopPosition() {\n return startsWith(this.props.config.settings.groupActionsPosition || defaultPosition, \"top\");\n }\n }, {\n key: \"setLock\",\n value: function setLock(lock) {\n this.props.setLock(lock);\n }\n }, {\n key: \"removeSelf\",\n value: function removeSelf() {\n var _this$props = this.props,\n confirmFn = _this$props.confirmFn,\n config = _this$props.config;\n var _config$settings2 = config.settings,\n renderConfirm = _config$settings2.renderConfirm,\n confirmOptions = _config$settings2.removeGroupConfirmOptions;\n if (confirmOptions && !this.isEmptyCurrentGroup()) {\n renderConfirm.call(config.ctx, _objectSpread(_objectSpread({}, confirmOptions), {}, {\n onOk: this.doRemove,\n onCancel: null,\n confirmFn: confirmFn\n }), config.ctx);\n } else {\n this.doRemove();\n }\n }\n }, {\n key: \"isEmptyCurrentGroup\",\n value: function isEmptyCurrentGroup() {\n var _this$props2 = this.props,\n children1 = _this$props2.children1,\n config = _this$props2.config;\n return isEmptyGroupChildren(children1, config);\n }\n }, {\n key: \"showNot\",\n value: function showNot() {\n var _this$props3 = this.props,\n config = _this$props3.config,\n parentField = _this$props3.parentField;\n var showNot = config.settings.showNot;\n if (parentField) {\n var _ruleGroupFieldConfig;\n var ruleGroupFieldConfig = getFieldConfig(config, parentField);\n showNot = showNot && ((_ruleGroupFieldConfig = ruleGroupFieldConfig === null || ruleGroupFieldConfig === void 0 ? void 0 : ruleGroupFieldConfig.showNot) !== null && _ruleGroupFieldConfig !== void 0 ? _ruleGroupFieldConfig : true);\n }\n return showNot;\n }\n\n // show conjs for 2+ children?\n }, {\n key: \"showConjs\",\n value: function showConjs() {\n var config = this.props.config;\n var forceShowConj = config.settings.forceShowConj;\n var conjunctionOptions = this.conjunctionOptions();\n var conjunctionCount = Object.keys(conjunctionOptions).length;\n return conjunctionCount > 1 && !this.isOneChild() || this.showNot() || forceShowConj;\n }\n }, {\n key: \"isNoChildren\",\n value: function isNoChildren() {\n var children1 = this.props.children1;\n return children1 ? children1.size == 0 : true;\n }\n }, {\n key: \"isOneChild\",\n value: function isOneChild() {\n var children1 = this.props.children1;\n return children1 ? children1.size < 2 : true;\n }\n }, {\n key: \"renderChildrenWrapper\",\n value: function renderChildrenWrapper() {\n var children1 = this.props.children1;\n return children1 && /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-children\",\n className: classNames(\"group--children\", !this.showConjs() ? \"hide--conjs\" : \"\", this.isOneChild() ? \"hide--line\" : \"\", this.isOneChild() ? \"one--child\" : \"\", this.childrenClassName())\n }, this.renderChildren());\n }\n }, {\n key: \"renderHeaderWrapper\",\n value: function renderHeaderWrapper() {\n var isGroupTopPosition = this.isGroupTopPosition();\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-header\",\n className: classNames(\"group--header\", this.isOneChild() ? \"one--child\" : \"\", !this.showConjs() ? \"hide--conjs\" : \"\", this.isOneChild() ? \"hide--line\" : \"\", this.isNoChildren() ? \"no--children\" : \"\")\n }, this.renderHeader(), isGroupTopPosition && this.renderBeforeActions(), isGroupTopPosition && this.renderActions(), isGroupTopPosition && this.renderAfterActions());\n }\n }, {\n key: \"renderFooterWrapper\",\n value: function renderFooterWrapper() {\n var isGroupTopPosition = this.isGroupTopPosition();\n return !isGroupTopPosition && /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-footer\",\n className: \"group--footer\"\n }, this.renderBeforeActions(), this.renderActions(), this.renderAfterActions());\n }\n }, {\n key: \"renderActions\",\n value: function renderActions() {\n var _this$props4 = this.props,\n config = _this$props4.config,\n addRule = _this$props4.addRule,\n addGroup = _this$props4.addGroup,\n isLocked = _this$props4.isLocked,\n isTrueLocked = _this$props4.isTrueLocked,\n id = _this$props4.id,\n parentField = _this$props4.parentField;\n return /*#__PURE__*/React.createElement(GroupActions, {\n key: \"group-actions\",\n config: config,\n addRule: addRule,\n addGroup: addGroup,\n canAddGroup: this.canAddGroup(),\n canAddRule: this.canAddRule(),\n canDeleteGroup: this.canDeleteGroup(),\n removeSelf: this.removeSelf,\n setLock: this.setLock,\n isLocked: isLocked,\n isTrueLocked: isTrueLocked,\n id: id,\n parentField: parentField\n });\n }\n }, {\n key: \"canAddGroup\",\n value: function canAddGroup() {\n return this.props.allowFurtherNesting;\n }\n }, {\n key: \"canAddRule\",\n value: function canAddRule() {\n var _this$props5 = this.props,\n totalRulesCnt = _this$props5.totalRulesCnt,\n isMaxNestingExceeded = _this$props5.isMaxNestingExceeded,\n parentField = _this$props5.parentField;\n var maxNumberOfRules = this.props.config.settings.maxNumberOfRules;\n if (parentField) {\n var ruleGroupFieldConfig = getFieldConfig(this.props.config, parentField);\n maxNumberOfRules = ruleGroupFieldConfig.maxNumberOfRules;\n }\n if (isMaxNestingExceeded) {\n return false;\n }\n if (maxNumberOfRules) {\n return totalRulesCnt < maxNumberOfRules;\n }\n return true;\n }\n }, {\n key: \"canDeleteGroup\",\n value: function canDeleteGroup() {\n return !this.props.isRoot;\n }\n }, {\n key: \"renderChildren\",\n value: function renderChildren() {\n var children1 = this.props.children1;\n return children1 ? children1.valueSeq().toArray().map(this.renderItem) : null;\n }\n }, {\n key: \"renderItem\",\n value: function renderItem(item) {\n if (!item) {\n return undefined;\n }\n var props = this.props;\n var config = props.config,\n actions = props.actions,\n onDragStart = props.onDragStart,\n isLocked = props.isLocked,\n parentField = props.parentField,\n parentFieldPathSize = props.parentFieldPathSize,\n parentFieldCanReorder = props.parentFieldCanReorder;\n var isRuleGroup = item.get(\"type\") == \"group\" && item.getIn([\"properties\", \"field\"]) != null;\n var type = isRuleGroup ? \"rule_group\" : item.get(\"type\");\n return /*#__PURE__*/React.createElement(Item, _extends({\n key: item.get(\"id\"),\n id: item.get(\"id\"),\n groupId: props.id,\n path: item.get(\"path\"),\n type: type,\n properties: item.get(\"properties\"),\n config: config,\n actions: actions,\n children1: item.get(\"children1\"),\n parentField: parentField,\n parentFieldPathSize: parentFieldPathSize,\n parentFieldCanReorder: parentFieldCanReorder,\n reordableNodesCnt: this.reordableNodesCntForItem(item),\n totalRulesCnt: this.totalRulesCntForItem(item),\n parentReordableNodesCnt: this.reordableNodesCnt(),\n onDragStart: onDragStart,\n isDraggingTempo: this.props.isDraggingTempo,\n isParentLocked: isLocked\n }, this.extraPropsForItem(item)));\n }\n }, {\n key: \"extraPropsForItem\",\n value: function extraPropsForItem(_item) {\n return {};\n }\n }, {\n key: \"reordableNodesCnt\",\n value: function reordableNodesCnt() {\n if (this.props.isLocked) return 0;\n return this.props.reordableNodesCnt;\n }\n }, {\n key: \"totalRulesCntForItem\",\n value: function totalRulesCntForItem(item) {\n if (item.get(\"type\") === \"rule_group\") {\n return getTotalRulesCountInTree(item);\n }\n return this.props.totalRulesCnt;\n }\n }, {\n key: \"reordableNodesCntForItem\",\n value: function reordableNodesCntForItem(_item) {\n if (this.props.isLocked) return 0;\n return this.reordableNodesCnt();\n }\n }, {\n key: \"showDragIcon\",\n value: function showDragIcon() {\n var _this$props6 = this.props,\n config = _this$props6.config,\n isRoot = _this$props6.isRoot,\n isLocked = _this$props6.isLocked,\n parentField = _this$props6.parentField,\n parentFieldCanReorder = _this$props6.parentFieldCanReorder;\n var reordableNodesCnt = this.reordableNodesCnt();\n var canReorder = config.settings.canReorder && !isRoot && reordableNodesCnt > 1 && !isLocked;\n if (parentField) {\n canReorder = canReorder && parentFieldCanReorder;\n }\n return canReorder;\n }\n }, {\n key: \"renderDrag\",\n value: function renderDrag() {\n var handleDraggerMouseDown = this.props.handleDraggerMouseDown;\n var Icon = this.Icon;\n var icon = /*#__PURE__*/React.createElement(Icon, {\n type: \"drag\"\n });\n return this.showDragIcon() && /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-drag-icon\",\n onMouseDown: handleDraggerMouseDown,\n className: \"qb-drag-handler group--drag-handler\"\n }, icon);\n }\n }, {\n key: \"conjunctionOptions\",\n value: function conjunctionOptions() {\n var _this$props7 = this.props,\n parentField = _this$props7.parentField,\n conjunctionOptions = _this$props7.conjunctionOptions;\n // Note: if current group is a group inside rule-group, we should respect config of parent rule-group\n return parentField ? this.conjunctionOptionsForGroupField(parentField) : conjunctionOptions;\n }\n }, {\n key: \"conjunctionOptionsForGroupField\",\n value: function conjunctionOptionsForGroupField() {\n var groupField = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n var _this$props8 = this.props,\n config = _this$props8.config,\n conjunctionOptions = _this$props8.conjunctionOptions;\n var groupFieldConfig = getFieldConfig(config, groupField);\n if (groupFieldConfig !== null && groupFieldConfig !== void 0 && groupFieldConfig.conjunctions) {\n var filtered = {};\n var _iterator = _createForOfIteratorHelper(groupFieldConfig.conjunctions),\n _step;\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var k = _step.value;\n var options = conjunctionOptions[k];\n if (options) {\n filtered[k] = options;\n }\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n return filtered;\n }\n return conjunctionOptions;\n }\n }, {\n key: \"renderConjs\",\n value: function renderConjs() {\n var _this$props9 = this.props,\n config = _this$props9.config,\n children1 = _this$props9.children1,\n id = _this$props9.id,\n selectedConjunction = _this$props9.selectedConjunction,\n setConjunction = _this$props9.setConjunction,\n not = _this$props9.not,\n setNot = _this$props9.setNot,\n isLocked = _this$props9.isLocked;\n var _config$settings3 = config.settings,\n immutableGroupsMode = _config$settings3.immutableGroupsMode,\n notLabel = _config$settings3.notLabel;\n var conjunctionOptions = this.conjunctionOptions();\n if (!this.showConjs()) return null;\n if (!children1 || !children1.size) return null;\n var renderProps = {\n disabled: this.isOneChild(),\n readonly: immutableGroupsMode || isLocked,\n selectedConjunction: selectedConjunction,\n setConjunction: immutableGroupsMode ? dummyFn : setConjunction,\n conjunctionOptions: conjunctionOptions,\n config: config,\n not: not || false,\n id: id,\n setNot: immutableGroupsMode ? dummyFn : setNot,\n notLabel: notLabel,\n showNot: this.showNot(),\n isLocked: isLocked\n };\n var Conjs = this.Conjs;\n return /*#__PURE__*/React.createElement(Conjs, _extends({\n key: \"group-conjs\"\n }, renderProps));\n }\n }, {\n key: \"renderHeader\",\n value: function renderHeader() {\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-conjunctions\",\n className: \"group--conjunctions\"\n }, this.renderConjs(), this.renderDrag());\n }\n }, {\n key: \"render\",\n value: function render() {\n return /*#__PURE__*/React.createElement(React.Fragment, null, this.renderHeaderWrapper(), this.renderChildrenWrapper(), this.renderFooterWrapper());\n }\n }]);\n}(Component);\nBasicGroup.propTypes = {\n reordableNodesCnt: PropTypes.number,\n conjunctionOptions: PropTypes.object.isRequired,\n allowFurtherNesting: PropTypes.bool.isRequired,\n isMaxNestingExceeded: PropTypes.bool,\n isRoot: PropTypes.bool.isRequired,\n not: PropTypes.bool,\n selectedConjunction: PropTypes.string,\n config: PropTypes.object.isRequired,\n id: PropTypes.string.isRequired,\n groupId: PropTypes.string,\n path: PropTypes.any,\n //instanceOf(Immutable.List)\n children1: PropTypes.any,\n //instanceOf(Immutable.OrderedMap)\n isDraggingMe: PropTypes.bool,\n isDraggingTempo: PropTypes.bool,\n isLocked: PropTypes.bool,\n isTrueLocked: PropTypes.bool,\n parentField: PropTypes.string,\n //from RuleGroup\n //actions\n handleDraggerMouseDown: PropTypes.func,\n onDragStart: PropTypes.func,\n addRule: PropTypes.func.isRequired,\n addGroup: PropTypes.func.isRequired,\n removeSelf: PropTypes.func.isRequired,\n setConjunction: PropTypes.func.isRequired,\n setNot: PropTypes.func.isRequired,\n setLock: PropTypes.func.isRequired,\n actions: PropTypes.object.isRequired\n};\nexport default GroupContainer(Draggable(\"group\")(WithConfirmFn(BasicGroup)), \"group\");","import superPropBase from \"./superPropBase.js\";\nfunction _get() {\n return _get = \"undefined\" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {\n var p = superPropBase(e, t);\n if (p) {\n var n = Object.getOwnPropertyDescriptor(p, t);\n return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;\n }\n }, _get.apply(null, arguments);\n}\nexport { _get as default };","import getPrototypeOf from \"./getPrototypeOf.js\";\nfunction _superPropBase(t, o) {\n for (; !{}.hasOwnProperty.call(t, o) && null !== (t = getPrototypeOf(t)););\n return t;\n}\nexport { _superPropBase as default };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nexport var RuleGroupActions = /*#__PURE__*/function (_PureComponent) {\n function RuleGroupActions() {\n _classCallCheck(this, RuleGroupActions);\n return _callSuper(this, RuleGroupActions, arguments);\n }\n _inherits(RuleGroupActions, _PureComponent);\n return _createClass(RuleGroupActions, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n addRule = _this$props.addRule,\n canAddRule = _this$props.canAddRule,\n canDeleteGroup = _this$props.canDeleteGroup,\n removeSelf = _this$props.removeSelf,\n setLock = _this$props.setLock,\n isLocked = _this$props.isLocked,\n isTrueLocked = _this$props.isTrueLocked,\n id = _this$props.id;\n var _config$settings = config.settings,\n immutableGroupsMode = _config$settings.immutableGroupsMode,\n addRuleLabel = _config$settings.addRuleLabel,\n delGroupLabel = _config$settings.delGroupLabel,\n renderButton = _config$settings.renderButton,\n renderIcon = _config$settings.renderIcon,\n renderSwitch = _config$settings.renderSwitch,\n renderButtonGroup = _config$settings.renderButtonGroup,\n lockLabel = _config$settings.lockLabel,\n lockedLabel = _config$settings.lockedLabel,\n showLock = _config$settings.showLock,\n canDeleteLocked = _config$settings.canDeleteLocked;\n var Icon = function Icon(pr) {\n return renderIcon(pr, config.ctx);\n };\n var Btn = function Btn(pr) {\n return renderButton(pr, config.ctx);\n };\n var Switch = function Switch(pr) {\n return renderSwitch(pr, config.ctx);\n };\n var BtnGrp = function BtnGrp(pr) {\n return renderButtonGroup(pr, config.ctx);\n };\n var setLockSwitch = showLock && !(isLocked && !isTrueLocked) && /*#__PURE__*/React.createElement(Switch, {\n type: \"lock\",\n id: id,\n value: isLocked,\n setValue: setLock,\n label: lockLabel,\n checkedLabel: lockedLabel,\n hideLabel: true,\n config: config\n });\n var addSubRuleBtn = !immutableGroupsMode && canAddRule && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: \"addSubRuleSimple\",\n onClick: addRule,\n label: addRuleLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var delGroupBtn = !immutableGroupsMode && canDeleteGroup && (!isLocked || isLocked && canDeleteLocked) && /*#__PURE__*/React.createElement(Btn, {\n type: \"delRuleGroup\",\n onClick: removeSelf,\n label: delGroupLabel,\n config: config,\n renderIcon: Icon\n });\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--actions\"\n }, /*#__PURE__*/React.createElement(BtnGrp, {\n config: config\n }, setLockSwitch, addSubRuleBtn, delGroupBtn));\n }\n }]);\n}(PureComponent);","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _get from \"@babel/runtime/helpers/get\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nfunction _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && \"function\" == typeof p ? function (t) { return p.apply(e, t); } : p; }\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport GroupContainer from \"../containers/GroupContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport { BasicGroup } from \"./Group\";\nimport { RuleGroupActions } from \"./RuleGroupActions\";\nimport FieldWrapper from \"../rule/FieldWrapper\";\nimport { WithConfirmFn } from \"../utils\";\nvar getFieldConfig = Utils.ConfigUtils.getFieldConfig;\nvar RuleGroup = /*#__PURE__*/function (_BasicGroup) {\n function RuleGroup(props) {\n var _this;\n _classCallCheck(this, RuleGroup);\n _this = _callSuper(this, RuleGroup, [props]);\n _this.childrenClassName = function () {\n return \"rule_group--children\";\n };\n _this.renderHeaderWrapper = function () {\n return null;\n };\n _this.renderFooterWrapper = function () {\n return null;\n };\n _this.renderConjs = function () {\n return null;\n };\n _this.canAddGroup = function () {\n return false;\n };\n _this.canAddRule = function () {\n return true;\n };\n _this.canDeleteGroup = function () {\n return false;\n };\n return _this;\n }\n _inherits(RuleGroup, _BasicGroup);\n return _createClass(RuleGroup, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n _superPropGet(RuleGroup, \"onPropsChanged\", this, 3)([nextProps]);\n }\n }, {\n key: \"reordableNodesCntForItem\",\n value: function reordableNodesCntForItem(_item) {\n if (this.props.isLocked) return 0;\n var children1 = this.props.children1;\n return (children1 === null || children1 === void 0 ? void 0 : children1.size) || 0;\n }\n }, {\n key: \"renderChildrenWrapper\",\n value: function renderChildrenWrapper() {\n return /*#__PURE__*/React.createElement(React.Fragment, null, this.renderDrag(), this.renderField(), this.renderActions(), _superPropGet(RuleGroup, \"renderChildrenWrapper\", this, 3)([]));\n }\n }, {\n key: \"renderField\",\n value: function renderField() {\n var _this$props = this.props,\n config = _this$props.config,\n selectedField = _this$props.selectedField,\n selectedFieldSrc = _this$props.selectedFieldSrc,\n selectedFieldType = _this$props.selectedFieldType,\n setField = _this$props.setField,\n setFuncValue = _this$props.setFuncValue,\n setFieldSrc = _this$props.setFieldSrc,\n parentField = _this$props.parentField,\n id = _this$props.id,\n groupId = _this$props.groupId,\n isLocked = _this$props.isLocked;\n var immutableFieldsMode = config.settings.immutableFieldsMode;\n return /*#__PURE__*/React.createElement(FieldWrapper, {\n key: \"field\",\n classname: \"group--field\",\n config: config,\n canSelectFieldSource: false,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedFieldType: selectedFieldType,\n setField: setField,\n setFuncValue: setFuncValue,\n setFieldSrc: setFieldSrc,\n parentField: parentField,\n readonly: immutableFieldsMode || isLocked,\n id: id,\n groupId: groupId\n });\n }\n }, {\n key: \"renderActions\",\n value: function renderActions() {\n var _this$props2 = this.props,\n config = _this$props2.config,\n addRule = _this$props2.addRule,\n isLocked = _this$props2.isLocked,\n isTrueLocked = _this$props2.isTrueLocked,\n id = _this$props2.id;\n return /*#__PURE__*/React.createElement(RuleGroupActions, {\n config: config,\n addRule: addRule,\n canAddRule: this.canAddRule(),\n canDeleteGroup: this.canDeleteGroup(),\n removeSelf: this.removeSelf,\n setLock: this.setLock,\n isLocked: isLocked,\n isTrueLocked: isTrueLocked,\n id: id\n });\n }\n }, {\n key: \"extraPropsForItem\",\n value: function extraPropsForItem(_item) {\n var _selectedFieldConfig$;\n var _this$props3 = this.props,\n selectedField = _this$props3.selectedField,\n lev = _this$props3.lev,\n config = _this$props3.config;\n var selectedFieldConfig = getFieldConfig(config, selectedField);\n return {\n parentField: selectedField,\n parentFieldPathSize: lev + 1,\n parentFieldCanReorder: (_selectedFieldConfig$ = selectedFieldConfig === null || selectedFieldConfig === void 0 ? void 0 : selectedFieldConfig.canReorder) !== null && _selectedFieldConfig$ !== void 0 ? _selectedFieldConfig$ : config.settings.canReorder\n };\n }\n }]);\n}(BasicGroup);\nRuleGroup.propTypes = _objectSpread(_objectSpread({}, BasicGroup.propTypes), {}, {\n selectedField: PropTypes.any,\n selectedFieldSrc: PropTypes.string,\n parentField: PropTypes.string,\n setField: PropTypes.func,\n setFieldSrc: PropTypes.func,\n lev: PropTypes.number // from GroupContainer\n});\nexport default GroupContainer(Draggable(\"group rule_group\")(WithConfirmFn(RuleGroup)), \"rule_group\");","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nexport var RuleGroupExtActions = /*#__PURE__*/function (_PureComponent) {\n function RuleGroupExtActions() {\n _classCallCheck(this, RuleGroupExtActions);\n return _callSuper(this, RuleGroupExtActions, arguments);\n }\n _inherits(RuleGroupExtActions, _PureComponent);\n return _createClass(RuleGroupExtActions, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n addRule = _this$props.addRule,\n addGroup = _this$props.addGroup,\n canAddRule = _this$props.canAddRule,\n canAddGroup = _this$props.canAddGroup,\n canDeleteGroup = _this$props.canDeleteGroup,\n removeSelf = _this$props.removeSelf,\n setLock = _this$props.setLock,\n isLocked = _this$props.isLocked,\n isTrueLocked = _this$props.isTrueLocked,\n id = _this$props.id;\n var _config$settings = config.settings,\n immutableGroupsMode = _config$settings.immutableGroupsMode,\n addSubRuleLabel = _config$settings.addSubRuleLabel,\n addSubGroupLabel = _config$settings.addSubGroupLabel,\n delGroupLabel = _config$settings.delGroupLabel,\n renderButton = _config$settings.renderButton,\n renderIcon = _config$settings.renderIcon,\n renderSwitch = _config$settings.renderSwitch,\n renderButtonGroup = _config$settings.renderButtonGroup,\n lockLabel = _config$settings.lockLabel,\n lockedLabel = _config$settings.lockedLabel,\n showLock = _config$settings.showLock,\n canDeleteLocked = _config$settings.canDeleteLocked;\n var Icon = function Icon(pr) {\n return renderIcon(pr, config.ctx);\n };\n var Btn = function Btn(pr) {\n return renderButton(pr, config.ctx);\n };\n var Switch = function Switch(pr) {\n return renderSwitch(pr, config.ctx);\n };\n var BtnGrp = function BtnGrp(pr) {\n return renderButtonGroup(pr, config.ctx);\n };\n var setLockSwitch = showLock && !(isLocked && !isTrueLocked) && /*#__PURE__*/React.createElement(Switch, {\n type: \"lock\",\n id: id,\n value: isLocked,\n setValue: setLock,\n label: lockLabel,\n checkedLabel: lockedLabel,\n config: config\n });\n var addSubRuleBtn = !immutableGroupsMode && canAddRule && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: \"addSubRule\",\n onClick: addRule,\n label: addSubRuleLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var addSubGroupBtn = !immutableGroupsMode && canAddGroup && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: \"addSubGroup\",\n onClick: addGroup,\n label: addSubGroupLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var delGroupBtn = !immutableGroupsMode && canDeleteGroup && (!isLocked || isLocked && canDeleteLocked) && /*#__PURE__*/React.createElement(Btn, {\n type: \"delRuleGroup\",\n onClick: removeSelf,\n label: delGroupLabel,\n config: config,\n renderIcon: Icon\n });\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--actions group--actions--tr\"\n }, /*#__PURE__*/React.createElement(BtnGrp, {\n config: config\n }, setLockSwitch, addSubRuleBtn, addSubGroupBtn, delGroupBtn));\n }\n }]);\n}(PureComponent);","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _get from \"@babel/runtime/helpers/get\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nfunction _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && \"function\" == typeof p ? function (t) { return p.apply(e, t); } : p; }\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport GroupContainer from \"../containers/GroupContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport { BasicGroup } from \"./Group\";\nimport { RuleGroupExtActions } from \"./RuleGroupExtActions\";\nimport FieldWrapper from \"../rule/FieldWrapper\";\nimport OperatorWrapper from \"../rule/OperatorWrapper\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport { Col, dummyFn, WithConfirmFn } from \"../utils\";\nimport Widget from \"../rule/Widget\";\nimport classNames from \"classnames\";\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getFieldWidgetConfig = _Utils$ConfigUtils.getFieldWidgetConfig;\nvar isEmptyRuleGroupExtPropertiesAndChildren = Utils.RuleUtils.isEmptyRuleGroupExtPropertiesAndChildren;\nvar getTotalReordableNodesCountInTree = Utils.TreeUtils.getTotalReordableNodesCountInTree;\nvar RuleGroupExt = /*#__PURE__*/function (_BasicGroup) {\n function RuleGroupExt(props) {\n var _this;\n _classCallCheck(this, RuleGroupExt);\n _this = _callSuper(this, RuleGroupExt, [props]);\n _this.childrenClassName = function () {\n return \"rule_group_ext--children\";\n };\n _this.renderFooterWrapper = function () {\n return null;\n };\n _this.canDeleteGroup = function () {\n return true;\n };\n return _this;\n }\n _inherits(RuleGroupExt, _BasicGroup);\n return _createClass(RuleGroupExt, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n _superPropGet(RuleGroupExt, \"onPropsChanged\", this, 3)([nextProps]);\n }\n }, {\n key: \"canAddGroup\",\n value: function canAddGroup() {\n return this.props.allowFurtherNesting;\n }\n }, {\n key: \"canAddRule\",\n value: function canAddRule() {\n var _this$props = this.props,\n config = _this$props.config,\n selectedField = _this$props.selectedField;\n var selectedFieldConfig = getFieldConfig(config, selectedField);\n var maxNumberOfRules = selectedFieldConfig === null || selectedFieldConfig === void 0 ? void 0 : selectedFieldConfig.maxNumberOfRules;\n var totalRulesCnt = this.props.totalRulesCnt;\n if (maxNumberOfRules) {\n return totalRulesCnt < maxNumberOfRules;\n }\n return true;\n }\n }, {\n key: \"renderHeaderWrapper\",\n value: function renderHeaderWrapper() {\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-header\",\n className: classNames(\"group--header\", this.isOneChild() ? \"one--child\" : \"\", this.isOneChild() ? \"hide--line\" : \"\", this.isNoChildren() ? \"no--children\" : \"\", this.showDragIcon() ? \"with--drag\" : \"hide--drag\", this.showConjs() ? \"with--conjs\" : \"hide--conjs\")\n }, this.renderHeader(), this.renderGroupField(), this.renderActions());\n }\n }, {\n key: \"renderHeader\",\n value: function renderHeader() {\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--conjunctions\"\n }, this.renderConjs(), this.renderDrag());\n }\n }, {\n key: \"renderGroupField\",\n value: function renderGroupField() {\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--field--count--rule\"\n }, this.renderField(), this.renderOperator(), this.renderWidget(), this.renderError());\n }\n }, {\n key: \"renderError\",\n value: function renderError() {\n var _this$props2 = this.props,\n config = _this$props2.config,\n valueError = _this$props2.valueError;\n var _config$settings = config.settings,\n renderRuleError = _config$settings.renderRuleError,\n showErrorMessage = _config$settings.showErrorMessage;\n var oneError = _toConsumableArray((valueError === null || valueError === void 0 ? void 0 : valueError.toArray()) || []).filter(function (e) {\n return !!e;\n }).shift() || null;\n return showErrorMessage && oneError && /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule_group--error\"\n }, renderRuleError ? renderRuleError({\n error: oneError\n }, config.ctx) : oneError);\n }\n }, {\n key: \"showNot\",\n value: function showNot() {\n var _selectedFieldConfig$;\n var _this$props3 = this.props,\n config = _this$props3.config,\n selectedField = _this$props3.selectedField;\n var selectedFieldConfig = getFieldConfig(config, selectedField);\n return (_selectedFieldConfig$ = selectedFieldConfig === null || selectedFieldConfig === void 0 ? void 0 : selectedFieldConfig.showNot) !== null && _selectedFieldConfig$ !== void 0 ? _selectedFieldConfig$ : config.settings.showNot;\n }\n }, {\n key: \"conjunctionOptions\",\n value: function conjunctionOptions() {\n var selectedField = this.props.selectedField;\n return this.conjunctionOptionsForGroupField(selectedField);\n }\n }, {\n key: \"renderField\",\n value: function renderField() {\n var _this$props4 = this.props,\n config = _this$props4.config,\n selectedField = _this$props4.selectedField,\n selectedFieldSrc = _this$props4.selectedFieldSrc,\n selectedFieldType = _this$props4.selectedFieldType,\n setField = _this$props4.setField,\n setFieldSrc = _this$props4.setFieldSrc,\n setFuncValue = _this$props4.setFuncValue,\n parentField = _this$props4.parentField,\n id = _this$props4.id,\n groupId = _this$props4.groupId,\n isLocked = _this$props4.isLocked;\n var immutableFieldsMode = config.settings.immutableFieldsMode;\n return /*#__PURE__*/React.createElement(FieldWrapper, {\n key: \"field\",\n classname: \"rule--field\",\n config: config,\n canSelectFieldSource: false,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedFieldType: selectedFieldType,\n setField: setField,\n setFuncValue: setFuncValue,\n setFieldSrc: setFieldSrc,\n parentField: parentField,\n readonly: immutableFieldsMode || isLocked,\n id: id,\n groupId: groupId\n });\n }\n }, {\n key: \"renderOperator\",\n value: function renderOperator() {\n var _this$props5 = this.props,\n config = _this$props5.config,\n selectedField = _this$props5.selectedField,\n selectedFieldSrc = _this$props5.selectedFieldSrc,\n selectedOperator = _this$props5.selectedOperator,\n setField = _this$props5.setField,\n setOperator = _this$props5.setOperator,\n isLocked = _this$props5.isLocked;\n var immutableFieldsMode = config.settings.immutableFieldsMode;\n var selectedFieldWidgetConfig = getFieldWidgetConfig(config, selectedField, selectedOperator) || {};\n var hideOperator = selectedFieldWidgetConfig.hideOperator;\n var showOperatorLabel = selectedField && hideOperator && selectedFieldWidgetConfig.operatorInlineLabel;\n var showOperator = selectedField && !hideOperator;\n return /*#__PURE__*/React.createElement(OperatorWrapper, {\n key: \"operator\",\n classname: \"group--operator\",\n config: config,\n selectedField: selectedField,\n selectedFieldSrc: selectedFieldSrc,\n selectedOperator: selectedOperator,\n setOperator: setOperator,\n showOperator: showOperator,\n showOperatorLabel: showOperatorLabel,\n selectedFieldWidgetConfig: selectedFieldWidgetConfig,\n readonly: immutableFieldsMode || isLocked,\n id: this.props.id,\n groupId: this.props.groupId\n });\n }\n }, {\n key: \"isEmptyCurrentGroup\",\n value: function isEmptyCurrentGroup() {\n var _this$props6 = this.props,\n children1 = _this$props6.children1,\n config = _this$props6.config;\n var ruleData = this._buildWidgetProps(this.props);\n return isEmptyRuleGroupExtPropertiesAndChildren(ruleData, children1, config);\n }\n }, {\n key: \"_buildWidgetProps\",\n value: function _buildWidgetProps(_ref) {\n var selectedField = _ref.selectedField,\n selectedFieldSrc = _ref.selectedFieldSrc,\n selectedFieldType = _ref.selectedFieldType,\n selectedOperator = _ref.selectedOperator,\n operatorOptions = _ref.operatorOptions,\n value = _ref.value,\n valueType = _ref.valueType,\n valueSrc = _ref.valueSrc,\n asyncListValues = _ref.asyncListValues,\n valueError = _ref.valueError,\n fieldError = _ref.fieldError,\n parentField = _ref.parentField;\n return {\n field: selectedField,\n fieldSrc: selectedFieldSrc,\n fieldType: selectedFieldType,\n operator: selectedOperator,\n operatorOptions: operatorOptions,\n value: value,\n valueType: valueType,\n // new Immutable.List([\"number\"])\n // todo: aggregation can be not only number?\n valueSrc: [\"value\"],\n //new Immutable.List([\"value\"]), // should be fixed in isEmptyRuleGroupExtPropertiesAndChildren\n //asyncListValues,\n valueError: valueError,\n fieldError: null,\n parentField: parentField\n };\n }\n }, {\n key: \"renderWidget\",\n value: function renderWidget() {\n var _this$props7 = this.props,\n config = _this$props7.config,\n selectedField = _this$props7.selectedField,\n selectedOperator = _this$props7.selectedOperator,\n isLocked = _this$props7.isLocked;\n var immutableValuesMode = config.settings.immutableValuesMode;\n var isFieldAndOpSelected = selectedField && selectedOperator;\n var showWidget = isFieldAndOpSelected;\n if (!showWidget) return null;\n var widget = /*#__PURE__*/React.createElement(Widget, _extends({\n key: \"values\",\n isForRuleGroup: true\n }, this._buildWidgetProps(this.props), {\n config: config,\n setValue: !immutableValuesMode ? this.props.setValue : dummyFn\n // todo: aggregation can be not only number?\n ,\n setValueSrc: dummyFn,\n readonly: immutableValuesMode || isLocked,\n id: this.props.id,\n groupId: this.props.groupId\n }));\n return /*#__PURE__*/React.createElement(Col, {\n key: \"widget-for-\" + this.props.selectedOperator,\n className: \"rule--value\"\n }, widget);\n }\n }, {\n key: \"renderActions\",\n value: function renderActions() {\n var _this$props8 = this.props,\n config = _this$props8.config,\n addRule = _this$props8.addRule,\n addGroup = _this$props8.addGroup,\n isLocked = _this$props8.isLocked,\n isTrueLocked = _this$props8.isTrueLocked,\n id = _this$props8.id;\n return /*#__PURE__*/React.createElement(RuleGroupExtActions, {\n config: config,\n addRule: addRule,\n addGroup: addGroup,\n canAddRule: this.canAddRule(),\n canAddGroup: this.canAddGroup(),\n canDeleteGroup: this.canDeleteGroup(),\n removeSelf: this.removeSelf,\n setLock: this.setLock,\n isLocked: isLocked,\n isTrueLocked: isTrueLocked,\n id: id\n });\n }\n }, {\n key: \"reordableNodesCntForItem\",\n value: function reordableNodesCntForItem(_item) {\n if (this.props.isLocked) return 0;\n var _this$props9 = this.props,\n children1 = _this$props9.children1,\n id = _this$props9.id;\n return getTotalReordableNodesCountInTree({\n id: id,\n type: \"rule_group\",\n children1: children1\n });\n }\n }, {\n key: \"extraPropsForItem\",\n value: function extraPropsForItem(_item) {\n var _selectedFieldConfig$2;\n var _this$props10 = this.props,\n selectedField = _this$props10.selectedField,\n lev = _this$props10.lev,\n config = _this$props10.config;\n var selectedFieldConfig = getFieldConfig(config, selectedField);\n return {\n parentField: selectedField,\n parentFieldPathSize: lev + 1,\n parentFieldCanReorder: (_selectedFieldConfig$2 = selectedFieldConfig === null || selectedFieldConfig === void 0 ? void 0 : selectedFieldConfig.canReorder) !== null && _selectedFieldConfig$2 !== void 0 ? _selectedFieldConfig$2 : config.settings.canReorder\n };\n }\n }]);\n}(BasicGroup);\nRuleGroupExt.propTypes = _objectSpread(_objectSpread({}, BasicGroup.propTypes), {}, {\n selectedField: PropTypes.any,\n selectedFieldSrc: PropTypes.string,\n selectedOperator: PropTypes.string,\n value: PropTypes.any,\n parentField: PropTypes.string,\n setField: PropTypes.func,\n setFieldSrc: PropTypes.func,\n setOperator: PropTypes.func,\n setValue: PropTypes.func,\n valueError: PropTypes.any,\n lev: PropTypes.number // from GroupContainer\n});\nexport default GroupContainer(Draggable(\"group rule_group_ext\")(WithConfirmFn(RuleGroupExt)), \"rule_group\");","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nvar groupActionsPositionList = {\n topLeft: \"group--actions--tl\",\n topCenter: \"group--actions--tc\",\n topRight: \"group--actions--tr\",\n bottomLeft: \"group--actions--bl\",\n bottomCenter: \"group--actions--bc\",\n bottomRight: \"group--actions--br\"\n};\nvar defaultPosition = \"topRight\";\nexport var SwitchGroupActions = /*#__PURE__*/function (_PureComponent) {\n function SwitchGroupActions() {\n _classCallCheck(this, SwitchGroupActions);\n return _callSuper(this, SwitchGroupActions, arguments);\n }\n _inherits(SwitchGroupActions, _PureComponent);\n return _createClass(SwitchGroupActions, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n addCaseGroup = _this$props.addCaseGroup,\n addDefaultCaseGroup = _this$props.addDefaultCaseGroup,\n setLock = _this$props.setLock,\n isLocked = _this$props.isLocked,\n isTrueLocked = _this$props.isTrueLocked,\n id = _this$props.id,\n canAddGroup = _this$props.canAddGroup,\n canAddDefault = _this$props.canAddDefault;\n var _config$settings = config.settings,\n immutableGroupsMode = _config$settings.immutableGroupsMode,\n addCaseLabel = _config$settings.addCaseLabel,\n addDefaultCaseLabel = _config$settings.addDefaultCaseLabel,\n groupActionsPosition = _config$settings.groupActionsPosition,\n renderButton = _config$settings.renderButton,\n renderIcon = _config$settings.renderIcon,\n renderSwitch = _config$settings.renderSwitch,\n renderButtonGroup = _config$settings.renderButtonGroup,\n lockLabel = _config$settings.lockLabel,\n lockedLabel = _config$settings.lockedLabel,\n showLock = _config$settings.showLock;\n var Icon = function Icon(pr) {\n return renderIcon(pr, config.ctx);\n };\n var Btn = function Btn(pr) {\n return renderButton(pr, config.ctx);\n };\n var Switch = function Switch(pr) {\n return renderSwitch(pr, config.ctx);\n };\n var BtnGrp = function BtnGrp(pr) {\n return renderButtonGroup(pr, config.ctx);\n };\n var position = groupActionsPositionList[groupActionsPosition || defaultPosition];\n var setLockSwitch = showLock && !(isLocked && !isTrueLocked) && /*#__PURE__*/React.createElement(Switch, {\n type: \"lock\",\n id: id,\n value: isLocked,\n setValue: setLock,\n label: lockLabel,\n checkedLabel: lockedLabel,\n config: config\n });\n var addCaseGroupBtn = !immutableGroupsMode && canAddGroup && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: \"addCaseGroup\",\n onClick: addCaseGroup,\n label: addCaseLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n var addDefaultCaseGroupBtn = !immutableGroupsMode && canAddDefault && !isLocked && /*#__PURE__*/React.createElement(Btn, {\n type: \"addDefaultCaseGroup\",\n onClick: addDefaultCaseGroup,\n label: addDefaultCaseLabel,\n readonly: isLocked,\n config: config,\n renderIcon: Icon\n });\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--actions \".concat(position)\n }, /*#__PURE__*/React.createElement(BtnGrp, {\n config: config\n }, setLockSwitch, addCaseGroupBtn, addDefaultCaseGroupBtn));\n }\n }]);\n}(PureComponent);","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _get from \"@babel/runtime/helpers/get\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nfunction _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && \"function\" == typeof p ? function (t) { return p.apply(e, t); } : p; }\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport GroupContainer from \"../containers/GroupContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport { BasicGroup } from \"./Group\";\nimport { SwitchGroupActions } from \"./SwitchGroupActions\";\nimport { Col, dummyFn, WithConfirmFn } from \"../utils\";\nimport classNames from \"classnames\";\nvar _Utils$TreeUtils = Utils.TreeUtils,\n getTotalReordableNodesCountInTree = _Utils$TreeUtils.getTotalReordableNodesCountInTree,\n getTotalRulesCountInTree = _Utils$TreeUtils.getTotalRulesCountInTree;\nvar SwitchGroup = /*#__PURE__*/function (_BasicGroup) {\n function SwitchGroup(props) {\n var _this;\n _classCallCheck(this, SwitchGroup);\n _this = _callSuper(this, SwitchGroup, [props]);\n _this.childrenClassName = function () {\n return \"switch_group--children\";\n };\n _this.renderFooterWrapper = function () {\n return null;\n };\n _this.hasDefaultCase = function () {\n var _this$props$children;\n return ((_this$props$children = _this.props.children1) === null || _this$props$children === void 0 ? void 0 : _this$props$children.size) && _this.props.children1.filter(function (c) {\n return c.get(\"children1\") == null;\n }).size > 0;\n };\n return _this;\n }\n _inherits(SwitchGroup, _BasicGroup);\n return _createClass(SwitchGroup, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n _superPropGet(SwitchGroup, \"onPropsChanged\", this, 3)([nextProps]);\n }\n }, {\n key: \"canAddGroup\",\n value: function canAddGroup() {\n var _this$props$children2;\n var maxNumberOfCases = this.props.config.settings.maxNumberOfCases;\n var totalCasesCnt = ((_this$props$children2 = this.props.children1) === null || _this$props$children2 === void 0 ? void 0 : _this$props$children2.size) || 0;\n if (maxNumberOfCases) {\n return totalCasesCnt < maxNumberOfCases;\n }\n return true;\n }\n }, {\n key: \"canAddRule\",\n value: function canAddRule() {\n return false;\n }\n }, {\n key: \"reordableNodesCnt\",\n value: function reordableNodesCnt() {\n var _this$props$children3;\n // result will be passed to each case's `parentReordableNodesCnt` prop\n var totalCasesCnt = ((_this$props$children3 = this.props.children1) === null || _this$props$children3 === void 0 ? void 0 : _this$props$children3.size) || 0;\n var casesToReorder = totalCasesCnt;\n if (this.hasDefaultCase()) {\n casesToReorder--;\n }\n return casesToReorder;\n }\n }, {\n key: \"totalRulesCntForItem\",\n value: function totalRulesCntForItem(item) {\n return getTotalRulesCountInTree(item);\n }\n }, {\n key: \"reordableNodesCntForItem\",\n value: function reordableNodesCntForItem(item) {\n var _this$props$children4;\n if (this.props.isLocked) return 0;\n var _this$props$config$se = this.props.config.settings,\n canLeaveEmptyCase = _this$props$config$se.canLeaveEmptyCase,\n canRegroupCases = _this$props$config$se.canRegroupCases;\n var totalCasesCnt = ((_this$props$children4 = this.props.children1) === null || _this$props$children4 === void 0 ? void 0 : _this$props$children4.size) || 0;\n var casesToReorder = totalCasesCnt;\n if (this.hasDefaultCase()) {\n casesToReorder--;\n }\n var nodesInCase = getTotalReordableNodesCountInTree(item);\n var cnt = nodesInCase;\n if (cnt == 1 && canRegroupCases && canLeaveEmptyCase && casesToReorder > 1) cnt = 111;\n return cnt;\n }\n }, {\n key: \"showConjs\",\n value: function showConjs() {\n // always show line from \"If\"\n return true;\n }\n }, {\n key: \"renderHeaderWrapper\",\n value: function renderHeaderWrapper() {\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-header\",\n className: classNames(\"group--header\", this.isOneChild() ? \"one--child\" : \"\", this.isOneChild() ? \"hide--line\" : \"\", this.isNoChildren() ? \"no--children\" : \"\", this.showDragIcon() ? \"with--drag\" : \"hide--drag\", this.showConjs() ? \"with--conjs\" : \"hide--conjs\")\n }, this.renderHeader(), this.renderActions());\n }\n }, {\n key: \"renderHeader\",\n value: function renderHeader() {\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--conjunctions\"\n }, this.renderConjs(), this.renderDrag());\n }\n }, {\n key: \"renderConjs\",\n value: function renderConjs() {\n var config = this.props.config;\n var renderSwitchPrefix = config.settings.renderSwitchPrefix;\n return renderSwitchPrefix || null;\n }\n }, {\n key: \"showNot\",\n value: function showNot() {\n return false;\n }\n }, {\n key: \"renderActions\",\n value: function renderActions() {\n var _this$props = this.props,\n config = _this$props.config,\n addCaseGroup = _this$props.addCaseGroup,\n addDefaultCaseGroup = _this$props.addDefaultCaseGroup,\n isLocked = _this$props.isLocked,\n isTrueLocked = _this$props.isTrueLocked,\n id = _this$props.id;\n return /*#__PURE__*/React.createElement(SwitchGroupActions, {\n config: config,\n addCaseGroup: addCaseGroup,\n addDefaultCaseGroup: addDefaultCaseGroup,\n canAddDefault: !this.hasDefaultCase(),\n canAddGroup: this.canAddGroup(),\n setLock: this.setLock,\n isLocked: isLocked,\n isTrueLocked: isTrueLocked,\n id: id\n });\n }\n }]);\n}(BasicGroup);\nSwitchGroup.propTypes = _objectSpread({}, BasicGroup.propTypes);\nexport default GroupContainer(Draggable(\"group switch_group\")(WithConfirmFn(SwitchGroup)), \"switch_group\");","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _get from \"@babel/runtime/helpers/get\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nfunction _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && \"function\" == typeof p ? function (t) { return p.apply(e, t); } : p; }\nimport React from \"react\";\nimport PropTypes from \"prop-types\";\nimport GroupContainer from \"../containers/GroupContainer\";\nimport Draggable from \"../containers/Draggable\";\nimport { BasicGroup } from \"./Group\";\nimport { GroupActions } from \"./GroupActions\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport { Col, dummyFn, WithConfirmFn, getRenderFromConfig } from \"../utils\";\nimport Widget from \"../rule/Widget\";\nimport classNames from \"classnames\";\nvar CaseGroup = /*#__PURE__*/function (_BasicGroup) {\n function CaseGroup(props) {\n var _this;\n _classCallCheck(this, CaseGroup);\n _this = _callSuper(this, CaseGroup, [props]);\n _this.childrenClassName = function () {\n return \"case_group--children\";\n };\n _this.renderFooterWrapper = function () {\n return null;\n };\n return _this;\n }\n _inherits(CaseGroup, _BasicGroup);\n return _createClass(CaseGroup, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var configChanged = !this.renderBeforeCaseValue || (prevProps === null || prevProps === void 0 ? void 0 : prevProps.config) !== (nextProps === null || nextProps === void 0 ? void 0 : nextProps.config);\n _superPropGet(CaseGroup, \"onPropsChanged\", this, 3)([nextProps]);\n if (configChanged) {\n var config = nextProps.config;\n var _config$settings = config.settings,\n renderBeforeCaseValue = _config$settings.renderBeforeCaseValue,\n renderAfterCaseValue = _config$settings.renderAfterCaseValue,\n renderRuleError = _config$settings.renderRuleError;\n this.BeforeCaseValue = getRenderFromConfig(config, renderBeforeCaseValue);\n this.AfterCaseValue = getRenderFromConfig(config, renderAfterCaseValue);\n this.RuleError = getRenderFromConfig(config, renderRuleError);\n }\n }\n }, {\n key: \"isDefaultCase\",\n value: function isDefaultCase() {\n return this.props.children1 == undefined;\n }\n }, {\n key: \"reordableNodesCnt\",\n value: function reordableNodesCnt() {\n // `parentReordableNodesCnt` is number of cases to reorder\n return this.props.parentReordableNodesCnt;\n }\n }, {\n key: \"reordableNodesCntForItem\",\n value: function reordableNodesCntForItem(_item) {\n // `reordableNodesCnt` is number of nodes is current case\n if (this.props.isLocked) return 0;\n return this.props.reordableNodesCnt;\n }\n }, {\n key: \"totalRulesCntForItem\",\n value: function totalRulesCntForItem(_item) {\n // `totalRulesCnt` is number of nodes is current case\n return this.props.totalRulesCnt;\n }\n }, {\n key: \"showDragIcon\",\n value: function showDragIcon() {\n // default impl of `showDragIcon()` uses `this.reordableNodesCnt()`\n if (this.isDefaultCase()) return false;\n return _superPropGet(CaseGroup, \"showDragIcon\", this, 3)([]);\n }\n }, {\n key: \"renderHeaderWrapper\",\n value: function renderHeaderWrapper() {\n return /*#__PURE__*/React.createElement(\"div\", {\n key: \"group-header\",\n className: classNames(\"group--header\", this.isOneChild() ? \"one--child\" : \"\", this.isOneChild() ? \"hide--line\" : \"\", this.isNoChildren() ? \"no--children\" : \"\", this.showDragIcon() ? \"with--drag\" : \"hide--drag\", this.showConjs() && (!this.isOneChild() || this.showNot()) ? \"with--conjs\" : \"hide--conjs\")\n }, this.renderHeaderLeft(), this.renderHeaderCenter(), this.renderActions());\n }\n }, {\n key: \"renderChildrenWrapper\",\n value: function renderChildrenWrapper() {\n if (this.isDefaultCase()) return null;\n // body has 2 columns: condition & value\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"case_group--body\"\n }, this.renderCondition(), this.renderBeforeValue(), this.renderValue(), this.renderAfterValue());\n }\n }, {\n key: \"renderHeaderLeft\",\n value: function renderHeaderLeft() {\n if (this.isDefaultCase()) {\n var defaultCaseLabel = this.props.config.settings.defaultCaseLabel;\n return defaultCaseLabel || \"\";\n }\n // default impl:\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"group--conjunctions\"\n }, this.renderConjs(), this.renderDrag(), this.renderError());\n }\n }, {\n key: \"renderCondition\",\n value: function renderCondition() {\n if (this.isDefaultCase()) return null;\n return _superPropGet(CaseGroup, \"renderChildrenWrapper\", this, 3)([]);\n }\n }, {\n key: \"renderHeaderCenter\",\n value: function renderHeaderCenter() {\n if (this.isDefaultCase()) {\n return /*#__PURE__*/React.createElement(\"div\", null, this.renderValue(), this.renderError());\n }\n return null;\n }\n }, {\n key: \"canAddGroup\",\n value: function canAddGroup() {\n if (this.isDefaultCase()) return false;\n return _superPropGet(CaseGroup, \"canAddGroup\", this, 3)([]);\n }\n }, {\n key: \"canAddRule\",\n value: function canAddRule() {\n if (this.isDefaultCase()) return false;\n return _superPropGet(CaseGroup, \"canAddRule\", this, 3)([]);\n }\n }, {\n key: \"renderBeforeValue\",\n value: function renderBeforeValue() {\n var BeforeCaseValue = this.BeforeCaseValue;\n if (BeforeCaseValue == undefined) return null;\n return /*#__PURE__*/React.createElement(BeforeCaseValue, _extends({\n key: \"values-before\"\n }, this.props));\n }\n }, {\n key: \"renderAfterValue\",\n value: function renderAfterValue() {\n var AfterCaseValue = this.AfterCaseValue;\n if (AfterCaseValue == undefined) return null;\n return /*#__PURE__*/React.createElement(AfterCaseValue, _extends({\n key: \"values-after\"\n }, this.props));\n }\n }, {\n key: \"renderError\",\n value: function renderError() {\n var _this$props = this.props,\n config = _this$props.config,\n valueError = _this$props.valueError;\n var showErrorMessage = config.settings.showErrorMessage;\n var RuleError = this.RuleError;\n var oneError = _toConsumableArray((valueError === null || valueError === void 0 ? void 0 : valueError.toArray()) || []).filter(function (e) {\n return !!e;\n }).shift() || null;\n return showErrorMessage && oneError && /*#__PURE__*/React.createElement(\"div\", {\n className: \"rule--error\"\n }, RuleError ? /*#__PURE__*/React.createElement(RuleError, {\n error: oneError\n }) : oneError);\n }\n }, {\n key: \"renderValue\",\n value: function renderValue() {\n var _this$props2 = this.props,\n config = _this$props2.config,\n isLocked = _this$props2.isLocked,\n value = _this$props2.value,\n valueSrc = _this$props2.valueSrc,\n valueError = _this$props2.valueError,\n setValue = _this$props2.setValue,\n setValueSrc = _this$props2.setValueSrc,\n setFuncValue = _this$props2.setFuncValue,\n id = _this$props2.id;\n var immutableValuesMode = config.settings.immutableValuesMode;\n var widget = /*#__PURE__*/React.createElement(Widget, {\n key: \"values\",\n isCaseValue: true,\n field: \"!case_value\",\n operator: null,\n value: value,\n valueSrc: valueSrc !== null && valueSrc !== void 0 ? valueSrc : \"value\",\n valueError: valueError,\n fieldError: null,\n config: config,\n setValue: !immutableValuesMode ? setValue : dummyFn,\n setValueSrc: !immutableValuesMode ? setValueSrc : dummyFn,\n setFuncValue: !immutableValuesMode ? setFuncValue : dummyFn,\n readonly: immutableValuesMode || isLocked,\n id: id,\n groupId: null\n });\n return /*#__PURE__*/React.createElement(Col, {\n className: \"case_group--value\"\n }, widget);\n }\n }, {\n key: \"renderActions\",\n value: function renderActions() {\n var _this$props3 = this.props,\n config = _this$props3.config,\n addGroup = _this$props3.addGroup,\n addRule = _this$props3.addRule,\n isLocked = _this$props3.isLocked,\n isTrueLocked = _this$props3.isTrueLocked,\n id = _this$props3.id;\n return /*#__PURE__*/React.createElement(GroupActions, {\n config: config,\n addGroup: addGroup,\n addRule: addRule,\n canAddRule: this.canAddRule(),\n canAddGroup: this.canAddGroup(),\n canDeleteGroup: this.canDeleteGroup(),\n removeSelf: this.removeSelf,\n setLock: this.setLock,\n isLocked: isLocked,\n isTrueLocked: isTrueLocked,\n id: id\n });\n }\n }, {\n key: \"isEmptyCurrentGroup\",\n value: function isEmptyCurrentGroup() {\n // used to confirm self-deletion\n var value = this.props.value;\n var oneValue = value && value.size ? value.get(0) : null;\n var hasValue = oneValue != null && (Array.isArray(oneValue) ? oneValue.length > 0 : true);\n return _superPropGet(CaseGroup, \"isEmptyCurrentGroup\", this, 3)([]) && !hasValue;\n }\n }]);\n}(BasicGroup);\nCaseGroup.propTypes = _objectSpread(_objectSpread({}, BasicGroup.propTypes), {}, {\n parentReordableNodesCnt: PropTypes.number,\n value: PropTypes.any,\n setValue: PropTypes.func\n});\nexport default GroupContainer(Draggable(\"group case_group\")(WithConfirmFn(CaseGroup)), \"case_group\");","import _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _extends from \"@babel/runtime/helpers/extends\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nvar _excluded = [\"type\"];\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport React, { PureComponent } from \"react\";\nimport PropTypes from \"prop-types\";\nimport Rule from \"./Rule\";\nimport Group from \"./Group\";\nimport RuleGroup from \"./RuleGroup\";\nimport RuleGroupExt from \"./RuleGroupExt\";\nimport SwitchGroup from \"./SwitchGroup\";\nimport CaseGroup from \"./CaseGroup\";\nvar types = [\"rule\", \"group\", \"rule_group\", \"switch_group\", \"case_group\"];\nvar getProperties = function getProperties(props) {\n var _props$properties;\n var properties = ((_props$properties = props.properties) === null || _props$properties === void 0 ? void 0 : _props$properties.toObject()) || {};\n var result = _objectSpread({}, properties);\n if (props.isParentLocked) {\n result.isLocked = true;\n }\n if (properties.isLocked) {\n result.isTrueLocked = true;\n }\n return result;\n};\nvar typeMap = {\n rule: function rule(props) {\n return /*#__PURE__*/React.createElement(Rule, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n config: props.config,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n parentField: props.parentField,\n parentFieldPathSize: props.parentFieldPathSize,\n parentReordableNodesCnt: props.parentReordableNodesCnt,\n parentFieldCanReorder: props.parentFieldCanReorder\n }));\n },\n group: function group(props) {\n return /*#__PURE__*/React.createElement(Group, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n config: props.config,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n children1: props.children1,\n parentField: props.parentField,\n parentFieldPathSize: props.parentFieldPathSize,\n parentReordableNodesCnt: props.parentReordableNodesCnt,\n parentFieldCanReorder: props.parentFieldCanReorder\n }));\n },\n rule_group: function rule_group(props) {\n return /*#__PURE__*/React.createElement(RuleGroup, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n config: props.config,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n children1: props.children1,\n parentField: props.parentField,\n parentFieldPathSize: props.parentFieldPathSize,\n parentReordableNodesCnt: props.parentReordableNodesCnt,\n parentFieldCanReorder: props.parentFieldCanReorder\n }));\n },\n rule_group_ext: function rule_group_ext(props) {\n return /*#__PURE__*/React.createElement(RuleGroupExt, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n config: props.config,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n children1: props.children1,\n parentField: props.parentField,\n parentFieldPathSize: props.parentFieldPathSize,\n parentReordableNodesCnt: props.parentReordableNodesCnt,\n parentFieldCanReorder: props.parentFieldCanReorder\n }));\n },\n switch_group: function switch_group(props) {\n return /*#__PURE__*/React.createElement(SwitchGroup, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n config: props.config,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n children1: props.children1,\n parentField: null,\n parentReordableNodesCnt: props.parentReordableNodesCnt\n }));\n },\n case_group: function case_group(props) {\n return /*#__PURE__*/React.createElement(CaseGroup, _extends({}, getProperties(props), {\n id: props.id,\n groupId: props.groupId,\n path: props.path,\n actions: props.actions,\n config: props.config,\n reordableNodesCnt: props.reordableNodesCnt,\n totalRulesCnt: props.totalRulesCnt,\n onDragStart: props.onDragStart,\n isDraggingTempo: props.isDraggingTempo,\n children1: props.children1,\n parentField: null,\n parentReordableNodesCnt: props.parentReordableNodesCnt\n }));\n }\n};\nvar Item = /*#__PURE__*/function (_PureComponent) {\n function Item() {\n _classCallCheck(this, Item);\n return _callSuper(this, Item, arguments);\n }\n _inherits(Item, _PureComponent);\n return _createClass(Item, [{\n key: \"render\",\n value: function render() {\n var _props$properties2;\n var _this$props = this.props,\n type = _this$props.type,\n props = _objectWithoutProperties(_this$props, _excluded);\n var mode = (_props$properties2 = props.properties) === null || _props$properties2 === void 0 ? void 0 : _props$properties2.get(\"mode\");\n var postfix = mode == \"array\" ? \"_ext\" : \"\";\n var renderItem = props.config.settings.renderItem;\n var Cmp = typeMap[type + postfix];\n if (renderItem) {\n return renderItem(_objectSpread(_objectSpread({}, props), {}, {\n type: type,\n itemComponent: Cmp\n }), props.config.ctx);\n }\n if (!Cmp) return null;\n return Cmp(props);\n }\n }]);\n}(PureComponent);\nItem.propTypes = {\n config: PropTypes.object.isRequired,\n id: PropTypes.string.isRequired,\n groupId: PropTypes.string,\n type: PropTypes.oneOf(types).isRequired,\n path: PropTypes.any.isRequired,\n //instanceOf(Immutable.List)\n properties: PropTypes.any,\n //instanceOf(Immutable.Map)\n children1: PropTypes.any,\n //instanceOf(Immutable.OrderedMap)\n actions: PropTypes.object.isRequired,\n reordableNodesCnt: PropTypes.number,\n onDragStart: PropTypes.func,\n parentField: PropTypes.string,\n //from RuleGroup\n isDraggingTempo: PropTypes.bool,\n isParentLocked: PropTypes.bool\n};\nexport { Item };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport React, { Component } from \"react\";\nimport PropTypes from \"prop-types\";\nimport { Item } from \"./item/Item\";\nimport SortableContainer from \"./containers/SortableContainer\";\nimport { pureShouldComponentUpdate } from \"../utils/reactUtils\";\nvar _Utils$TreeUtils = Utils.TreeUtils,\n getTotalReordableNodesCountInTree = _Utils$TreeUtils.getTotalReordableNodesCountInTree,\n getTotalRulesCountInTree = _Utils$TreeUtils.getTotalRulesCountInTree;\nvar _Utils$DefaultUtils = Utils.DefaultUtils,\n createListWithOneElement = _Utils$DefaultUtils.createListWithOneElement,\n emptyProperties = _Utils$DefaultUtils.emptyProperties;\nvar Builder = /*#__PURE__*/function (_Component) {\n function Builder(props) {\n var _this;\n _classCallCheck(this, Builder);\n _this = _callSuper(this, Builder, [props]);\n _this.pureShouldComponentUpdate = pureShouldComponentUpdate(_this);\n _this._updPath(props);\n return _this;\n }\n _inherits(Builder, _Component);\n return _createClass(Builder, [{\n key: \"shouldComponentUpdate\",\n value: function shouldComponentUpdate(nextProps, nextState) {\n var should = this.pureShouldComponentUpdate(nextProps, nextState);\n return should;\n }\n }, {\n key: \"_updPath\",\n value: function _updPath(props) {\n var id = props.tree.get(\"id\");\n this.path = createListWithOneElement(id);\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n tree = _this$props.tree,\n config = _this$props.config,\n actions = _this$props.actions,\n onDragStart = _this$props.onDragStart;\n var rootType = tree.get(\"type\");\n var isTernary = rootType == \"switch_group\";\n var reordableNodesCnt = isTernary ? null : getTotalReordableNodesCountInTree(tree);\n var totalRulesCnt = isTernary ? null : getTotalRulesCountInTree(tree);\n var id = tree.get(\"id\");\n return /*#__PURE__*/React.createElement(Item, {\n key: id,\n id: id,\n path: this.path,\n type: rootType,\n properties: tree.get(\"properties\") || emptyProperties(),\n config: config,\n actions: actions,\n children1: tree.get(\"children1\") || emptyProperties(),\n reordableNodesCnt: reordableNodesCnt,\n totalRulesCnt: totalRulesCnt,\n parentReordableNodesCnt: 0,\n onDragStart: onDragStart\n });\n }\n }]);\n}(Component);\nBuilder.propTypes = {\n tree: PropTypes.any.isRequired,\n //instanceOf(Immutable.Map)\n config: PropTypes.object.isRequired,\n actions: PropTypes.object.isRequired,\n onDragStart: PropTypes.func\n};\nexport default SortableContainer(Builder);","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { Component } from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport PropTypes from \"prop-types\";\nimport { truncateString } from \"../../utils/stuff\";\nimport { useOnPropsChanged } from \"../../utils/reactUtils\";\nimport last from \"lodash/last\";\nimport keys from \"lodash/keys\";\nvar clone = Utils.OtherUtils.clone;\nvar _Utils$ConfigUtils = Utils.ConfigUtils,\n getFieldConfig = _Utils$ConfigUtils.getFieldConfig,\n getFieldParts = _Utils$ConfigUtils.getFieldParts,\n getFieldPathParts = _Utils$ConfigUtils.getFieldPathParts,\n getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;\nvar getFieldPathLabels = Utils.RuleUtils.getFieldPathLabels;\n\n//tip: this.props.value - right value, this.props.field - left value\nvar ValueField = /*#__PURE__*/function (_Component) {\n function ValueField(props) {\n var _this;\n _classCallCheck(this, ValueField);\n _this = _callSuper(this, ValueField, [props]);\n useOnPropsChanged(_this);\n _this.onPropsChanged(props);\n return _this;\n }\n _inherits(ValueField, _Component);\n return _createClass(ValueField, [{\n key: \"onPropsChanged\",\n value: function onPropsChanged(nextProps) {\n var prevProps = this.props;\n var keysForItems = [\"config\", \"field\", \"fieldSrc\", \"fieldType\", \"operator\", \"isFuncArg\", \"parentField\"];\n var keysForMeta = [\"config\", \"field\", \"fieldSrc\", \"fieldType\", \"operator\", \"value\", \"placeholder\", \"isFuncArg\", \"parentField\"];\n var needUpdateItems = !this.items || keysForItems.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n var needUpdateMeta = !this.meta || keysForMeta.map(function (k) {\n return nextProps[k] !== prevProps[k];\n }).filter(function (ch) {\n return ch;\n }).length > 0;\n if (needUpdateItems) {\n this.items = this.getItems(nextProps);\n }\n if (needUpdateMeta) {\n this.meta = this.getMeta(nextProps);\n }\n }\n }, {\n key: \"getItems\",\n value: function getItems(_ref) {\n var config = _ref.config,\n field = _ref.field,\n fieldType = _ref.fieldType,\n operator = _ref.operator,\n parentField = _ref.parentField,\n isFuncArg = _ref.isFuncArg,\n fieldDefinition = _ref.fieldDefinition;\n var canCompareFieldWithField = config.settings.canCompareFieldWithField;\n // const fieldSeparator = config.settings.fieldSeparator;\n var parentFieldPath = getFieldParts(parentField, config);\n var parentFieldConfig = parentField ? getFieldConfig(config, parentField) : null;\n var sourceFields = parentField ? parentFieldConfig === null || parentFieldConfig === void 0 ? void 0 : parentFieldConfig.subfields : config.fields;\n var filteredFields = this.filterFields(config, sourceFields, field, parentField, parentFieldPath, operator, canCompareFieldWithField, isFuncArg, fieldDefinition, fieldType);\n var items = this.buildOptions(parentFieldPath, config, filteredFields, parentFieldPath);\n return items;\n }\n }, {\n key: \"getMeta\",\n value: function getMeta(_ref2) {\n var _leftFieldConfig$widg;\n var config = _ref2.config,\n field = _ref2.field,\n fieldType = _ref2.fieldType,\n operator = _ref2.operator,\n value = _ref2.value,\n customPlaceholder = _ref2.placeholder,\n isFuncArg = _ref2.isFuncArg,\n parentField = _ref2.parentField;\n var _config$settings = config.settings,\n fieldPlaceholder = _config$settings.fieldPlaceholder,\n fieldSeparatorDisplay = _config$settings.fieldSeparatorDisplay;\n var selectedKey = value;\n var isFieldSelected = !!value;\n var leftFieldConfig = field ? getFieldConfig(config, field) : {};\n var leftFieldWidgetField = leftFieldConfig === null || leftFieldConfig === void 0 || (_leftFieldConfig$widg = leftFieldConfig.widgets) === null || _leftFieldConfig$widg === void 0 ? void 0 : _leftFieldConfig$widg.field;\n var leftFieldWidgetFieldProps = (leftFieldWidgetField === null || leftFieldWidgetField === void 0 ? void 0 : leftFieldWidgetField.widgetProps) || {};\n var placeholder = isFieldSelected ? null : isFuncArg && customPlaceholder || leftFieldWidgetFieldProps.valuePlaceholder || fieldPlaceholder;\n var currField = isFieldSelected ? getFieldConfig(config, selectedKey) : null;\n var selectedOpts = currField || {};\n var selectedKeys = getFieldPathParts(selectedKey, config);\n var selectedPath = getFieldPathParts(selectedKey, config, true);\n var selectedLabel = this.getFieldLabel(currField, selectedKey, config);\n var partsLabels = getFieldPathLabels(selectedKey, config);\n var selectedFullLabel = partsLabels ? partsLabels.join(fieldSeparatorDisplay) : null;\n if (selectedFullLabel == selectedLabel || parentField) selectedFullLabel = null;\n var selectedAltLabel = selectedOpts.label2 || selectedOpts.tooltip;\n return {\n placeholder: placeholder,\n selectedKey: selectedKey,\n selectedKeys: selectedKeys,\n selectedPath: selectedPath,\n selectedLabel: selectedLabel,\n selectedOpts: selectedOpts,\n selectedAltLabel: selectedAltLabel,\n selectedFullLabel: selectedFullLabel\n };\n }\n }, {\n key: \"filterFields\",\n value: function filterFields(config, fields, leftFieldFullkey, parentField, parentFieldPath, operator, canCompareFieldWithField, isFuncArg, fieldDefinition, fieldType) {\n fields = clone(fields);\n var fieldSeparator = config.settings.fieldSeparator;\n var leftFieldConfig = getFieldConfig(config, leftFieldFullkey);\n var _relyOnWidgetType = false; //TODO: remove this, see issue #758\n var widget = getWidgetForFieldOp(config, leftFieldFullkey, operator, \"value\");\n var widgetConfig = config.widgets[widget];\n var opConfig = config.operators[operator];\n var expectedType;\n if (isFuncArg) {\n expectedType = fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type;\n } else if (opConfig !== null && opConfig !== void 0 && opConfig.valueTypes) {\n expectedType = opConfig === null || opConfig === void 0 ? void 0 : opConfig.valueTypes[0];\n } else if (_relyOnWidgetType && widgetConfig) {\n expectedType = widgetConfig.type;\n } else if (leftFieldConfig) {\n expectedType = leftFieldConfig.type;\n } else {\n // no field at LHS, but can use type from \"memory effect\"\n expectedType = fieldType;\n }\n function _filter(list, path) {\n for (var rightFieldKey in list) {\n var subfields = list[rightFieldKey].subfields;\n var subpath = (path ? path : []).concat(rightFieldKey);\n var rightFieldFullkey = subpath.join(fieldSeparator);\n var rightFieldConfig = getFieldConfig(config, rightFieldFullkey);\n if (!rightFieldConfig) {\n delete list[rightFieldKey];\n } else if (rightFieldConfig.type == \"!struct\" || rightFieldConfig.type == \"!group\") {\n if (_filter(subfields, subpath) == 0) delete list[rightFieldKey];\n } else {\n // tip: LHS field can be used as arg in RHS function\n var canUse = (!expectedType || rightFieldConfig.type == expectedType) && (isFuncArg ? true : rightFieldFullkey != leftFieldFullkey);\n var fn = canCompareFieldWithField || config.settings.canCompareFieldWithField;\n if (fn) canUse = canUse && fn(leftFieldFullkey, leftFieldConfig, rightFieldFullkey, rightFieldConfig, operator);\n if (!canUse) delete list[rightFieldKey];\n }\n }\n return keys(list).length;\n }\n _filter(fields, parentFieldPath || []);\n return fields;\n }\n }, {\n key: \"buildOptions\",\n value: function buildOptions(parentFieldPath, config, fields) {\n var _this2 = this;\n var path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n var optGroup = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n if (!fields) return null;\n var _config$settings2 = config.settings,\n fieldSeparator = _config$settings2.fieldSeparator,\n fieldSeparatorDisplay = _config$settings2.fieldSeparatorDisplay;\n var prefix = path !== null && path !== void 0 && path.length ? path.join(fieldSeparator) + fieldSeparator : \"\";\n return keys(fields).map(function (fieldKey) {\n var fullFieldPath = [].concat(_toConsumableArray(path !== null && path !== void 0 ? path : []), [fieldKey]);\n var field = fields[fieldKey];\n var label = _this2.getFieldLabel(field, fullFieldPath, config);\n var partsLabels = getFieldPathLabels(fullFieldPath, config);\n var fullLabel = partsLabels.join(fieldSeparatorDisplay);\n if (fullLabel == label || parentFieldPath) fullLabel = null;\n var altLabel = field.label2;\n var tooltip = field.tooltip;\n if (field.hideForCompare) return undefined;\n if (field.type == \"!struct\" || field.type == \"!group\") {\n return {\n key: fieldKey,\n path: prefix + fieldKey,\n label: label,\n fullLabel: fullLabel,\n altLabel: altLabel,\n tooltip: tooltip,\n items: _this2.buildOptions(parentFieldPath, config, field.subfields, fullFieldPath, {\n label: label,\n tooltip: tooltip\n })\n };\n } else {\n return {\n key: fieldKey,\n path: prefix + fieldKey,\n label: label,\n fullLabel: fullLabel,\n altLabel: altLabel,\n tooltip: tooltip,\n grouplabel: optGroup === null || optGroup === void 0 ? void 0 : optGroup.label,\n group: optGroup\n };\n }\n }).filter(function (o) {\n return !!o;\n });\n }\n }, {\n key: \"getFieldLabel\",\n value: function getFieldLabel(fieldOpts, fieldKey, config) {\n if (!fieldKey) return null;\n var maxLabelsLength = config.settings.maxLabelsLength;\n var fieldParts = getFieldParts(fieldKey, config);\n var label = (fieldOpts === null || fieldOpts === void 0 ? void 0 : fieldOpts.label) || last(fieldParts);\n label = truncateString(label, maxLabelsLength);\n return label;\n }\n }, {\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n config = _this$props.config,\n customProps = _this$props.customProps,\n setValue = _this$props.setValue,\n readonly = _this$props.readonly,\n id = _this$props.id,\n groupId = _this$props.groupId;\n var renderField = config.settings.renderField;\n var renderProps = _objectSpread({\n isValueField: true,\n config: config,\n customProps: customProps,\n setField: setValue,\n readonly: readonly,\n items: this.items,\n id: id,\n groupId: groupId\n }, this.meta);\n return renderField(renderProps, config.ctx);\n }\n }]);\n}(Component);\nValueField.propTypes = {\n id: PropTypes.string,\n groupId: PropTypes.string,\n setValue: PropTypes.func.isRequired,\n config: PropTypes.object.isRequired,\n field: PropTypes.any,\n fieldSrc: PropTypes.string,\n fieldType: PropTypes.string,\n value: PropTypes.string,\n operator: PropTypes.string,\n customProps: PropTypes.object,\n readonly: PropTypes.bool,\n parentField: PropTypes.string,\n fieldDefinition: PropTypes.object,\n isFuncArg: PropTypes.bool\n};\nexport { ValueField as default };","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n labelYes = props.labelYes,\n labelNo = props.labelNo,\n readonly = props.readonly,\n widgetId = props.widgetId,\n _props$customProps = props.customProps,\n customProps = _props$customProps === void 0 ? {} : _props$customProps;\n var customRadioYesProps = customProps.radioYes || {};\n var customRadioNoProps = customProps.radioNo || {};\n var onCheckboxChange = function onCheckboxChange(e) {\n return setValue(e.target.checked);\n };\n var onRadioChange = function onRadioChange(e) {\n return setValue(e.target.value == \"true\");\n };\n\n // return <>\n // <input key={widgetId} type=\"checkbox\" id={widgetId} checked={!!value} disabled={readonly} onChange={onCheckboxChange} />\n // <label style={{display: \"inline\"}} key={id+\"label\"} htmlFor={widgetId}>{value ? labelYes : labelNo}</label>\n // </>;\n\n return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"radio\",\n value: true,\n checked: !!value,\n disabled: readonly,\n onChange: onRadioChange\n }, customRadioYesProps)), \" \", labelYes, /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"radio\",\n value: false,\n checked: !value,\n disabled: readonly,\n onChange: onRadioChange\n }, customRadioNoProps)), \" \", labelNo);\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n readonly = props.readonly,\n placeholder = props.placeholder,\n maxLength = props.maxLength,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var val = e.target.value;\n if (val === \"\") val = undefined; // don't allow empty value\n setValue(val);\n };\n var textValue = value || \"\";\n return /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"text\",\n value: textValue,\n placeholder: placeholder,\n disabled: readonly,\n onChange: onChange,\n maxLength: maxLength\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n readonly = props.readonly,\n placeholder = props.placeholder,\n maxLength = props.maxLength,\n maxRows = props.maxRows,\n fullWidth = props.fullWidth,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var val = e.target.value;\n if (val === \"\") val = undefined; // don't allow empty value\n setValue(val);\n };\n var textValue = value || \"\";\n return /*#__PURE__*/React.createElement(\"textarea\", _extends({\n value: textValue,\n placeholder: placeholder,\n disabled: readonly,\n onChange: onChange,\n maxLength: maxLength,\n style: {\n width: fullWidth ? \"100%\" : undefined\n }\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nvar moment = Utils.moment;\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n valueFormat = props.valueFormat,\n readonly = props.readonly,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var value = e.target.value;\n if (value == \"\") value = undefined;\n setValue(value);\n };\n return /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"date\",\n value: value || \"\",\n disabled: readonly,\n onChange: onChange\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n valueFormat = props.valueFormat,\n use12Hours = props.use12Hours,\n readonly = props.readonly,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var value = e.target.value;\n if (value == \"\") value = undefined;\n setValue(value);\n };\n return /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"time\",\n value: value || \"\",\n disabled: readonly,\n onChange: onChange\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nvar moment = Utils.moment;\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n valueFormat = props.valueFormat,\n use12Hours = props.use12Hours,\n readonly = props.readonly,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var value = e.target.value;\n if (value == \"\") value = undefined;else value = moment(new Date(value)).format(valueFormat);\n setValue(value);\n };\n var dtValue = value;\n if (!value) dtValue = \"\";else dtValue = moment(value).format(\"YYYY-MM-DDTHH:mm\");\n return /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"datetime-local\",\n value: dtValue,\n disabled: readonly,\n onChange: onChange\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport omit from \"lodash/omit\";\nvar mapListValues = Utils.ListUtils.mapListValues;\nexport default (function (_ref) {\n var listValues = _ref.listValues,\n value = _ref.value,\n setValue = _ref.setValue,\n allowCustomValues = _ref.allowCustomValues,\n readonly = _ref.readonly,\n customProps = _ref.customProps;\n var renderOptions = function renderOptions() {\n return mapListValues(listValues, function (_ref2) {\n var title = _ref2.title,\n value = _ref2.value;\n return /*#__PURE__*/React.createElement(\"option\", {\n key: value,\n value: value\n }, title);\n });\n };\n var getMultiSelectValues = function getMultiSelectValues(multiselect) {\n var values = [];\n var options = multiselect.options;\n for (var i = 0; i < options.length; i++) {\n var opt = options[i];\n if (opt.selected) {\n values.push(opt.value);\n }\n }\n if (!values.length) values = undefined; //not allow []\n return values;\n };\n var onChange = function onChange(e) {\n return setValue(getMultiSelectValues(e.target));\n };\n return /*#__PURE__*/React.createElement(\"select\", _extends({\n multiple: true,\n onChange: onChange,\n value: value,\n disabled: readonly\n }, omit(customProps, [\"showSearch\", \"input\", \"showCheckboxes\"])), renderOptions());\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport omit from \"lodash/omit\";\nvar mapListValues = Utils.ListUtils.mapListValues;\nexport default (function (_ref) {\n var listValues = _ref.listValues,\n value = _ref.value,\n setValue = _ref.setValue,\n allowCustomValues = _ref.allowCustomValues,\n readonly = _ref.readonly,\n customProps = _ref.customProps;\n var renderOptions = function renderOptions() {\n return mapListValues(listValues, function (_ref2) {\n var title = _ref2.title,\n value = _ref2.value;\n return /*#__PURE__*/React.createElement(\"option\", {\n key: value,\n value: value\n }, title);\n });\n };\n var onChange = function onChange(e) {\n return setValue(e.target.value);\n };\n var hasValue = value != null;\n return /*#__PURE__*/React.createElement(\"select\", _extends({\n onChange: onChange,\n value: hasValue ? value : \"\",\n disabled: readonly\n }, omit(customProps, [\"showSearch\", \"input\"])), !hasValue && /*#__PURE__*/React.createElement(\"option\", {\n disabled: true,\n value: \"\"\n }), renderOptions());\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n readonly = props.readonly,\n min = props.min,\n max = props.max,\n step = props.step,\n placeholder = props.placeholder,\n customProps = props.customProps;\n var onChange = function onChange(e) {\n var val = e.target.value;\n if (val === \"\" || val === null) val = undefined;else val = Number(val);\n setValue(val);\n };\n var numberValue = value == undefined ? \"\" : value;\n return /*#__PURE__*/React.createElement(\"input\", _extends({\n type: \"number\",\n value: numberValue,\n placeholder: placeholder,\n disabled: readonly,\n min: min,\n max: max,\n step: step,\n onChange: onChange\n }, customProps));\n});","import _extends from \"@babel/runtime/helpers/extends\";\nimport React from \"react\";\nexport default (function (props) {\n var value = props.value,\n setValue = props.setValue,\n config = props.config,\n readonly = props.readonly,\n min = props.min,\n max = props.max,\n step = props.step,\n placeholder = props.placeholder,\n _props$customProps = props.customProps,\n customProps = _props$customProps === void 0 ? {} : _props$customProps;\n var customInputProps = customProps.input || {};\n var customSliderProps = customProps.slider || customProps;\n var onChange = function onChange(e) {\n var val = e.target.value;\n if (val === \"\" || val === null) val = undefined;else val = Number(val);\n setValue(val);\n };\n var numberValue = value == undefined ? \"\" : value;\n return /*#__PURE__*/React.createElement(\"div\", {\n style: {\n display: \"inline-flex\"\n }\n }, /*#__PURE__*/React.createElement(\"input\", _extends({\n key: \"number\",\n type: \"number\",\n value: numberValue,\n placeholder: placeholder,\n disabled: readonly,\n min: min,\n max: max,\n step: step,\n onChange: onChange\n }, customInputProps)), /*#__PURE__*/React.createElement(\"input\", _extends({\n key: \"range\",\n type: \"range\",\n value: numberValue,\n disabled: readonly,\n min: min,\n max: max,\n step: step,\n onChange: onChange\n }, customSliderProps)));\n});","import React from \"react\";\nexport default (function (_ref) {\n var items = _ref.items,\n setField = _ref.setField,\n selectedKey = _ref.selectedKey,\n readonly = _ref.readonly,\n errorText = _ref.errorText;\n var _renderOptions = function renderOptions(fields) {\n return fields.map(function (field) {\n var items = field.items,\n path = field.path,\n label = field.label,\n disabled = field.disabled,\n matchesType = field.matchesType;\n if (items) {\n return /*#__PURE__*/React.createElement(\"optgroup\", {\n disabled: disabled,\n key: path,\n label: label\n }, _renderOptions(items));\n } else {\n var style = matchesType ? {\n fontWeight: \"bold\"\n } : {};\n return /*#__PURE__*/React.createElement(\"option\", {\n disabled: disabled,\n key: path,\n value: path,\n style: style\n }, label);\n }\n });\n };\n var onChange = function onChange(e) {\n return setField(e.target.value);\n };\n var hasValue = selectedKey != null;\n return /*#__PURE__*/React.createElement(\"select\", {\n onChange: onChange,\n value: hasValue ? selectedKey : \"\",\n disabled: readonly,\n style: {\n color: errorText ? \"red\" : null\n }\n }, !hasValue && /*#__PURE__*/React.createElement(\"option\", {\n disabled: true,\n value: \"\"\n }), _renderOptions(items));\n});","import React from \"react\";\nexport default (function (_ref) {\n var id = _ref.id,\n not = _ref.not,\n setNot = _ref.setNot,\n conjunctionOptions = _ref.conjunctionOptions,\n setConjunction = _ref.setConjunction,\n disabled = _ref.disabled,\n readonly = _ref.readonly,\n config = _ref.config,\n showNot = _ref.showNot,\n notLabel = _ref.notLabel;\n var conjsCount = Object.keys(conjunctionOptions).length;\n var lessThenTwo = disabled;\n var forceShowConj = config.settings.forceShowConj;\n var showConj = forceShowConj || conjsCount > 1 && !lessThenTwo;\n var renderOptions = function renderOptions() {\n return Object.keys(conjunctionOptions).map(function (key) {\n var _conjunctionOptions$k = conjunctionOptions[key],\n id = _conjunctionOptions$k.id,\n name = _conjunctionOptions$k.name,\n label = _conjunctionOptions$k.label,\n checked = _conjunctionOptions$k.checked;\n var postfix = setConjunction.isDummyFn ? \"__dummy\" : \"\";\n if ((readonly || disabled) && !checked) return null;\n return [/*#__PURE__*/React.createElement(\"input\", {\n key: id + postfix,\n type: \"radio\",\n id: id + postfix,\n name: name + postfix,\n checked: checked,\n disabled: readonly || disabled,\n value: key,\n onChange: onChange\n }), /*#__PURE__*/React.createElement(\"label\", {\n key: id + postfix + \"label\",\n htmlFor: id + postfix\n }, label)];\n });\n };\n var renderNot = function renderNot() {\n var postfix = \"not\";\n return [/*#__PURE__*/React.createElement(\"input\", {\n key: id + postfix,\n type: \"checkbox\",\n id: id + postfix,\n checked: not,\n disabled: readonly,\n onChange: onNotChange\n }), /*#__PURE__*/React.createElement(\"label\", {\n key: id + postfix + \"label\",\n htmlFor: id + postfix\n }, notLabel || \"NOT\")];\n };\n var onChange = function onChange(e) {\n return setConjunction(e.target.value);\n };\n var onNotChange = function onNotChange(e) {\n return setNot(e.target.checked);\n };\n return [showNot && renderNot(), showConj && renderOptions()];\n});","import React from \"react\";\nvar typeToLabel = {\n \"addSubRuleSimple\": \"+\",\n \"addSubRule\": \"+\",\n \"addSubGroup\": \"+\",\n \"delGroup\": \"x\",\n \"delRuleGroup\": \"x\",\n \"delRule\": \"x\"\n};\nexport default (function (_ref) {\n var type = _ref.type,\n label = _ref.label,\n onClick = _ref.onClick,\n readonly = _ref.readonly;\n var btnLabel = label || typeToLabel[type];\n return /*#__PURE__*/React.createElement(\"button\", {\n onClick: onClick,\n type: \"button\",\n disabled: readonly\n }, btnLabel);\n});","import React from \"react\";\nimport { DragIcon } from \"../../../utils\";\nexport default (function (_ref) {\n var type = _ref.type;\n var typeToIcon = {};\n var icon = typeToIcon[type] || null;\n if (!icon && type === \"drag\") {\n icon = /*#__PURE__*/React.createElement(DragIcon, null);\n }\n return icon;\n});","import React from \"react\";\nexport default (function (_ref) {\n var children = _ref.children,\n config = _ref.config;\n return /*#__PURE__*/React.createElement(React.Fragment, null, children);\n});","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport React from \"react\";\nexport default (function (_ref) {\n var config = _ref.config,\n valueSources = _ref.valueSources,\n valueSrc = _ref.valueSrc,\n title = _ref.title,\n setValueSrc = _ref.setValueSrc,\n readonly = _ref.readonly;\n var renderOptions = function renderOptions(valueSources) {\n return valueSources.map(function (_ref2) {\n var _ref3 = _slicedToArray(_ref2, 2),\n srcKey = _ref3[0],\n info = _ref3[1];\n return /*#__PURE__*/React.createElement(\"option\", {\n key: srcKey,\n value: srcKey\n }, info.label);\n });\n };\n var onChange = function onChange(e) {\n return setValueSrc(e.target.value);\n };\n return /*#__PURE__*/React.createElement(\"select\", {\n onChange: onChange,\n value: valueSrc || \"\",\n disabled: readonly\n }, renderOptions(valueSources));\n});","import React from \"react\";\nexport default (function (_ref) {\n var value = _ref.value,\n setValue = _ref.setValue,\n label = _ref.label,\n id = _ref.id,\n config = _ref.config,\n type = _ref.type;\n var onChange = function onChange(e) {\n return setValue(e.target.checked);\n };\n var postfix = type;\n return [/*#__PURE__*/React.createElement(\"input\", {\n key: id + postfix,\n type: \"checkbox\",\n id: id + postfix,\n checked: !!value,\n onChange: onChange\n }), /*#__PURE__*/React.createElement(\"label\", {\n key: id + postfix + \"label\",\n htmlFor: id + postfix\n }, label)];\n});","export default (function (_ref) {\n var onOk = _ref.onOk,\n okText = _ref.okText,\n cancelText = _ref.cancelText,\n title = _ref.title;\n if (confirm(title)) {\n onOk();\n }\n});","import React from \"react\";\n\n// value widgets\nexport { default as VanillaBooleanWidget } from \"./value/VanillaBoolean\";\nexport { default as VanillaTextWidget } from \"./value/VanillaText\";\nexport { default as VanillaTextAreaWidget } from \"./value/VanillaTextArea\";\nexport { default as VanillaDateWidget } from \"./value/VanillaDate\";\nexport { default as VanillaTimeWidget } from \"./value/VanillaTime\";\nexport { default as VanillaDateTimeWidget } from \"./value/VanillaDateTime\";\nexport { default as VanillaMultiSelectWidget } from \"./value/VanillaMultiSelect\";\nexport { default as VanillaSelectWidget } from \"./value/VanillaSelect\";\nexport { default as VanillaNumberWidget } from \"./value/VanillaNumber\";\nexport { default as VanillaSliderWidget } from \"./value/VanillaSlider\";\n\n// field select widget\nexport { default as VanillaFieldSelect } from \"./core/VanillaFieldSelect\";\n\n// core components\nexport { default as VanillaConjs } from \"./core/VanillaConjs\";\nexport { default as VanillaButton } from \"./core/VanillaButton\";\nexport { default as VanillaIcon } from \"./core/VanillaIcon\";\nexport { default as VanillaButtonGroup } from \"./core/VanillaButtonGroup\";\nexport { default as VanillaValueSources } from \"./core/VanillaValueSources\";\nexport { default as VanillaSwitch } from \"./core/VanillaSwitch\";\nexport { default as vanillaConfirm } from \"./core/vanillaConfirm\";\nexport var VanillaProvider = function VanillaProvider(_ref) {\n var config = _ref.config,\n children = _ref.children;\n return children;\n};","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nfunction _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }\nfunction _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }\nimport React, { PureComponent } from \"react\";\nimport PropTypes from \"prop-types\";\nimport range from \"lodash/range\";\nvar Proximity = /*#__PURE__*/function (_PureComponent) {\n function Proximity() {\n var _this;\n _classCallCheck(this, Proximity);\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n _this = _callSuper(this, Proximity, [].concat(args));\n _this.handleChange = function (value) {\n _this.props.setOption(\"proximity\", parseInt(value));\n };\n return _this;\n }\n _inherits(Proximity, _PureComponent);\n return _createClass(Proximity, [{\n key: \"render\",\n value: function render() {\n var _this$props = this.props,\n defaults = _this$props.defaults,\n options = _this$props.options,\n config = _this$props.config,\n optionLabel = _this$props.optionLabel,\n optionPlaceholder = _this$props.optionPlaceholder,\n customProps = _this$props.customProps,\n minProximity = _this$props.minProximity,\n maxProximity = _this$props.maxProximity,\n optionTextBefore = _this$props.optionTextBefore,\n readonly = _this$props.readonly;\n var settings = config.settings,\n widgets = config.widgets,\n ctx = config.ctx;\n var defaultProximity = defaults ? defaults.proximity : undefined;\n var showLabels = settings.showLabels;\n var selectedProximity = options.get(\"proximity\", defaultProximity);\n var proxValues = range(minProximity, maxProximity + 1).map(function (item) {\n return {\n title: item,\n value: item\n };\n });\n var factory = widgets.select.factory;\n var Select = function Select(props) {\n return factory(props, ctx);\n };\n return /*#__PURE__*/React.createElement(\"div\", {\n className: \"operator--PROXIMITY\"\n }, /*#__PURE__*/React.createElement(\"div\", {\n className: \"operator--options\"\n }, showLabels && /*#__PURE__*/React.createElement(\"label\", {\n className: \"rule--label\"\n }, optionLabel), !showLabels && optionTextBefore && /*#__PURE__*/React.createElement(\"div\", {\n className: \"operator--options--sep\"\n }, /*#__PURE__*/React.createElement(\"span\", null, optionTextBefore)), /*#__PURE__*/React.createElement(Select, _extends({\n config: config,\n value: selectedProximity,\n listValues: proxValues,\n setValue: this.handleChange,\n readonly: readonly,\n placeholder: optionPlaceholder\n }, customProps))), /*#__PURE__*/React.createElement(\"div\", {\n className: \"operator--widgets\"\n }, this.props.children));\n }\n }]);\n}(PureComponent);\nProximity.propTypes = {\n config: PropTypes.object.isRequired,\n setOption: PropTypes.func.isRequired,\n options: PropTypes.any.isRequired,\n //instanceOf(Immutable.Map)\n minProximity: PropTypes.number,\n maxProximity: PropTypes.number,\n optionPlaceholder: PropTypes.string,\n optionTextBefore: PropTypes.string,\n optionLabel: PropTypes.string,\n customProps: PropTypes.object,\n readonly: PropTypes.bool\n //children\n};\nProximity.defaultProps = {\n customProps: {},\n minProximity: 2,\n maxProximity: 10,\n optionPlaceholder: \"Select words between\",\n optionLabel: \"Words between\",\n optionTextBefore: null\n};\nexport { Proximity as default };","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport React from \"react\";\nimport * as Widgets from \"../components/widgets\";\nimport * as CustomOperators from \"../components/operators\";\nimport { CoreConfig, Utils } from \"@react-awesome-query-builder/core\";\n\n//---------------------------- conjunctions\n\nvar conjunctions = _objectSpread({}, CoreConfig.conjunctions);\n\n//---------------------------- operators\n\nvar operators = _objectSpread(_objectSpread({}, CoreConfig.operators), {}, {\n proximity: _objectSpread(_objectSpread({}, CoreConfig.operators.proximity), {}, {\n options: _objectSpread(_objectSpread({}, CoreConfig.operators.proximity.options), {}, {\n factory: function factory(props, _ref) {\n var RCE = _ref.RCE,\n ProximityOperator = _ref.O.ProximityOperator;\n return RCE(ProximityOperator, props);\n }\n })\n })\n});\n\n//---------------------------- widgets\n\nvar widgets = {\n text: _objectSpread(_objectSpread({}, CoreConfig.widgets.text), {}, {\n factory: function factory(props, _ref2) {\n var RCE = _ref2.RCE,\n VanillaTextWidget = _ref2.W.VanillaTextWidget;\n return RCE(VanillaTextWidget, props);\n }\n }),\n textarea: _objectSpread(_objectSpread({}, CoreConfig.widgets.textarea), {}, {\n factory: function factory(props, _ref3) {\n var RCE = _ref3.RCE,\n VanillaTextAreaWidget = _ref3.W.VanillaTextAreaWidget;\n return RCE(VanillaTextAreaWidget, props);\n }\n }),\n number: _objectSpread(_objectSpread({}, CoreConfig.widgets.number), {}, {\n factory: function factory(props, _ref4) {\n var RCE = _ref4.RCE,\n VanillaNumberWidget = _ref4.W.VanillaNumberWidget;\n return RCE(VanillaNumberWidget, props);\n }\n }),\n slider: _objectSpread(_objectSpread({}, CoreConfig.widgets.slider), {}, {\n factory: function factory(props, _ref5) {\n var RCE = _ref5.RCE,\n VanillaSliderWidget = _ref5.W.VanillaSliderWidget;\n return RCE(VanillaSliderWidget, props);\n }\n }),\n select: _objectSpread(_objectSpread({}, CoreConfig.widgets.select), {}, {\n factory: function factory(props, _ref6) {\n var RCE = _ref6.RCE,\n VanillaSelectWidget = _ref6.W.VanillaSelectWidget;\n return RCE(VanillaSelectWidget, props);\n }\n }),\n multiselect: _objectSpread(_objectSpread({}, CoreConfig.widgets.multiselect), {}, {\n factory: function factory(props, _ref7) {\n var RCE = _ref7.RCE,\n VanillaMultiSelectWidget = _ref7.W.VanillaMultiSelectWidget;\n return RCE(VanillaMultiSelectWidget, props);\n }\n }),\n date: _objectSpread(_objectSpread({}, CoreConfig.widgets.date), {}, {\n factory: function factory(props, _ref8) {\n var RCE = _ref8.RCE,\n VanillaDateWidget = _ref8.W.VanillaDateWidget;\n return RCE(VanillaDateWidget, props);\n }\n }),\n time: _objectSpread(_objectSpread({}, CoreConfig.widgets.time), {}, {\n factory: function factory(props, _ref9) {\n var RCE = _ref9.RCE,\n VanillaTimeWidget = _ref9.W.VanillaTimeWidget;\n return RCE(VanillaTimeWidget, props);\n }\n }),\n datetime: _objectSpread(_objectSpread({}, CoreConfig.widgets.datetime), {}, {\n factory: function factory(props, _ref10) {\n var RCE = _ref10.RCE,\n VanillaDateTimeWidget = _ref10.W.VanillaDateTimeWidget;\n return RCE(VanillaDateTimeWidget, props);\n }\n }),\n \"boolean\": _objectSpread(_objectSpread({}, CoreConfig.widgets[\"boolean\"]), {}, {\n factory: function factory(props, _ref11) {\n var RCE = _ref11.RCE,\n VanillaBooleanWidget = _ref11.W.VanillaBooleanWidget;\n return RCE(VanillaBooleanWidget, props);\n }\n }),\n field: _objectSpread(_objectSpread({}, CoreConfig.widgets.field), {}, {\n factory: function factory(props, _ref12) {\n var RCE = _ref12.RCE,\n ValueFieldWidget = _ref12.W.ValueFieldWidget;\n return RCE(ValueFieldWidget, props);\n },\n customProps: {\n showSearch: true\n }\n }),\n func: _objectSpread(_objectSpread({}, CoreConfig.widgets.func), {}, {\n factory: function factory(props, _ref13) {\n var RCE = _ref13.RCE,\n FuncWidget = _ref13.W.FuncWidget;\n return RCE(FuncWidget, props);\n },\n customProps: {\n //showSearch: true\n }\n }),\n /**\n * @deprecated\n */\n case_value: _objectSpread(_objectSpread({}, CoreConfig.widgets.case_value), {}, {\n // simple text value\n factory: function factory(props, _ref14) {\n var RCE = _ref14.RCE,\n VanillaTextWidget = _ref14.W.VanillaTextWidget;\n return RCE(VanillaTextWidget, props);\n }\n })\n};\n\n//---------------------------- types\n\nvar types = _objectSpread(_objectSpread({}, CoreConfig.types), {}, {\n select: _objectSpread(_objectSpread({}, CoreConfig.types.select), {}, {\n widgets: _objectSpread(_objectSpread({}, CoreConfig.types.select.widgets), {}, {\n select: _objectSpread(_objectSpread({}, CoreConfig.types.select.widgets.select), {}, {\n widgetProps: {\n customProps: {\n showSearch: true\n }\n }\n })\n })\n })\n});\n\n//---------------------------- settings\n\nvar settings = _objectSpread(_objectSpread({}, CoreConfig.settings), {}, {\n renderField: function renderField(props, _ref15) {\n var RCE = _ref15.RCE,\n VanillaFieldSelect = _ref15.W.VanillaFieldSelect;\n return RCE(VanillaFieldSelect, props);\n },\n renderOperator: function renderOperator(props, _ref16) {\n var RCE = _ref16.RCE,\n VanillaFieldSelect = _ref16.W.VanillaFieldSelect;\n return RCE(VanillaFieldSelect, props);\n },\n renderFunc: function renderFunc(props, _ref17) {\n var RCE = _ref17.RCE,\n VanillaFieldSelect = _ref17.W.VanillaFieldSelect;\n return RCE(VanillaFieldSelect, props);\n },\n renderConjs: function renderConjs(props, _ref18) {\n var RCE = _ref18.RCE,\n VanillaConjs = _ref18.W.VanillaConjs;\n return RCE(VanillaConjs, props);\n },\n renderSwitch: function renderSwitch(props, _ref19) {\n var RCE = _ref19.RCE,\n VanillaSwitch = _ref19.W.VanillaSwitch;\n return RCE(VanillaSwitch, props);\n },\n renderButton: function renderButton(props, _ref20) {\n var RCE = _ref20.RCE,\n VanillaButton = _ref20.W.VanillaButton;\n return RCE(VanillaButton, props);\n },\n renderIcon: function renderIcon(props, _ref21) {\n var RCE = _ref21.RCE,\n VanillaIcon = _ref21.W.VanillaIcon;\n return RCE(VanillaIcon, props);\n },\n renderButtonGroup: function renderButtonGroup(props, _ref22) {\n var RCE = _ref22.RCE,\n VanillaButtonGroup = _ref22.W.VanillaButtonGroup;\n return RCE(VanillaButtonGroup, props);\n },\n renderProvider: function renderProvider(props, _ref23) {\n var RCE = _ref23.RCE,\n VanillaProvider = _ref23.W.VanillaProvider;\n return RCE(VanillaProvider, props);\n },\n renderValueSources: function renderValueSources(props, _ref24) {\n var RCE = _ref24.RCE,\n VanillaValueSources = _ref24.W.VanillaValueSources;\n return RCE(VanillaValueSources, props);\n },\n renderFieldSources: function renderFieldSources(props, _ref25) {\n var RCE = _ref25.RCE,\n VanillaValueSources = _ref25.W.VanillaValueSources;\n return RCE(VanillaValueSources, props);\n },\n renderConfirm: function renderConfirm(props, _ref26) {\n var vanillaConfirm = _ref26.W.vanillaConfirm;\n return vanillaConfirm(props);\n },\n renderSwitchPrefix: \"IF\",\n renderBeforeCaseValue: function renderBeforeCaseValue(props, _ref27) {\n var RCE = _ref27.RCE;\n return RCE(\"span\", {\n children: [\" then \"]\n });\n },\n customFieldSelectProps: {\n showSearch: true\n },\n customOperatorSelectProps: {\n // showSearch: false\n },\n defaultSliderWidth: \"200px\",\n defaultSelectWidth: \"200px\",\n defaultSearchWidth: \"100px\",\n defaultMaxRows: 5,\n renderSize: \"small\",\n maxLabelsLength: 100,\n showLock: false,\n showNot: true,\n forceShowConj: false,\n groupActionsPosition: \"topRight\" // oneOf [topLeft, topCenter, topRight, bottomLeft, bottomCenter, bottomRight]\n});\n\n//----------------------------\n\nvar ctx = _objectSpread(_objectSpread({}, CoreConfig.ctx), {}, {\n W: _objectSpread({}, Widgets),\n O: _objectSpread({}, CustomOperators),\n RCE: function RCE(C, P) {\n return /*#__PURE__*/React.createElement(C, P);\n }\n});\n\n//----------------------------\n\nvar config = {\n conjunctions: conjunctions,\n operators: operators,\n widgets: widgets,\n types: types,\n settings: settings,\n ctx: ctx\n};\nconfig = Utils.ConfigMixins.removeMixins(config, [\"rangeslider\", \"treeselect\", \"treemultiselect\"]);\nexport default config;","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport _asyncToGenerator from \"@babel/runtime/helpers/asyncToGenerator\";\nimport _typeof from \"@babel/runtime/helpers/typeof\";\nimport _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _regeneratorRuntime from \"@babel/runtime/regenerator\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport React from \"react\";\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport debounce from \"lodash/debounce\";\nvar _Utils$Autocomplete = Utils.Autocomplete,\n mergeListValues = _Utils$Autocomplete.mergeListValues,\n listValueToOption = _Utils$Autocomplete.listValueToOption,\n optionToListValue = _Utils$Autocomplete.optionToListValue,\n optionsToListValues = _Utils$Autocomplete.optionsToListValues,\n fixListValuesGroupOrder = _Utils$Autocomplete.fixListValuesGroupOrder;\nvar _Utils$ListUtils = Utils.ListUtils,\n mapListValues = _Utils$ListUtils.mapListValues,\n listValuesToArray = _Utils$ListUtils.listValuesToArray,\n getListValue = _Utils$ListUtils.getListValue,\n makeCustomListValue = _Utils$ListUtils.makeCustomListValue,\n searchListValue = _Utils$ListUtils.searchListValue,\n getItemInListValues = _Utils$ListUtils.getItemInListValues;\nfunction sleep(delay) {\n return new Promise(function (resolve) {\n setTimeout(resolve, delay);\n });\n}\nvar useListValuesAutocomplete = function useListValuesAutocomplete(_ref, _ref2) {\n var _config$settings$load, _config$settings$load2, _config$settings$type;\n var asyncFetch = _ref.asyncFetch,\n useLoadMore = _ref.useLoadMore,\n useAsyncSearch = _ref.useAsyncSearch,\n forceAsyncSearch = _ref.forceAsyncSearch,\n fetchSelectedValuesOnInit = _ref.fetchSelectedValuesOnInit,\n selectedAsyncListValues = _ref.asyncListValues,\n staticListValues = _ref.listValues,\n allowCustomValues = _ref.allowCustomValues,\n selectedValue = _ref.value,\n setValue = _ref.setValue,\n placeholder = _ref.placeholder,\n config = _ref.config,\n field = _ref.field;\n var debounceTimeout = _ref2.debounceTimeout,\n multiple = _ref2.multiple,\n uif = _ref2.uif,\n isFieldAutocomplete = _ref2.isFieldAutocomplete;\n var knownSpecialValues = [\"LOAD_MORE\", \"LOADING_MORE\"];\n var loadMoreTitle = (_config$settings$load = config.settings.loadMoreLabel) !== null && _config$settings$load !== void 0 ? _config$settings$load : \"Load more...\";\n var loadingMoreTitle = (_config$settings$load2 = config.settings.loadingMoreLabel) !== null && _config$settings$load2 !== void 0 ? _config$settings$load2 : \"Loading more...\";\n var aPlaceholder = forceAsyncSearch ? (_config$settings$type = config.settings.typeToSearchLabel) !== null && _config$settings$type !== void 0 ? _config$settings$type : \"Type to search\" : placeholder;\n\n // Import from JsonLogic fills `asyncListValues`, but import from SQL/SpEL does not. It's workaround\n if (asyncFetch && fetchSelectedValuesOnInit && !selectedAsyncListValues && selectedValue != undefined) {\n selectedAsyncListValues = Array.isArray(selectedValue) ? selectedValue : [selectedValue];\n }\n\n // state\n var _React$useState = React.useState(false),\n _React$useState2 = _slicedToArray(_React$useState, 2),\n open = _React$useState2[0],\n setOpen = _React$useState2[1];\n var _React$useState3 = React.useState(undefined),\n _React$useState4 = _slicedToArray(_React$useState3, 2),\n asyncFetchMeta = _React$useState4[0],\n setAsyncFetchMeta = _React$useState4[1];\n var _React$useState5 = React.useState(0),\n _React$useState6 = _slicedToArray(_React$useState5, 2),\n loadingCnt = _React$useState6[0],\n setLoadingCnt = _React$useState6[1];\n var _React$useState7 = React.useState(false),\n _React$useState8 = _slicedToArray(_React$useState7, 2),\n isLoadingMore = _React$useState8[0],\n setIsLoadingMore = _React$useState8[1];\n var _React$useState9 = React.useState(\"\"),\n _React$useState10 = _slicedToArray(_React$useState9, 2),\n inputValue = _React$useState10[0],\n setInputValue = _React$useState10[1];\n var _React$useState11 = React.useState(undefined),\n _React$useState12 = _slicedToArray(_React$useState11, 2),\n asyncListValues = _React$useState12[0],\n setAsyncListValues = _React$useState12[1];\n\n // ref\n var asyncFectchCnt = React.useRef(0);\n var componentIsMounted = React.useRef(0);\n var isSelectedLoadMore = React.useRef(false);\n var latestSelectedValue = React.useRef();\n latestSelectedValue.current = selectedValue;\n var latestInputValue = React.useRef();\n latestInputValue.current = inputValue;\n\n // compute\n var nSelectedAsyncListValues = React.useMemo(function () {\n return listValuesToArray(selectedAsyncListValues);\n }, [selectedAsyncListValues]);\n // if selectedAsyncListValues is array of strings/numbers => needs to be resolved\n var areSelectedAsyncListValuesNotResolved = selectedAsyncListValues && Array.isArray(selectedAsyncListValues) && selectedAsyncListValues.filter(function (v) {\n return v !== null && _typeof(v) !== \"object\";\n }).length > 0;\n var listValues = React.useMemo(function () {\n return asyncFetch ? selectedAsyncListValues ? mergeListValues(asyncListValues, nSelectedAsyncListValues, true) : asyncListValues : listValuesToArray(staticListValues);\n }, [asyncFetch, selectedAsyncListValues, asyncListValues, staticListValues]);\n // todo: useMemo for calcing listValuesToDisplay ?\n var listValuesToDisplay = asyncFetch ? asyncListValues : listValuesToArray(staticListValues);\n if (allowCustomValues && inputValue && !searchListValue(inputValue, asyncListValues)) {\n listValuesToDisplay = mergeListValues(listValuesToDisplay, [makeCustomListValue(inputValue)], true);\n }\n if (asyncFetch && !asyncListValues && selectedAsyncListValues && !inputValue && !open && uif === \"antd\") {\n // for initial loading, to resolve \"a\" -> \"A\"\n listValuesToDisplay = listValues;\n }\n if (asyncFetch && !allowCustomValues && selectedAsyncListValues && uif === \"mui\") {\n // to prevent warning, when select A, search E -> A is missing in options\n // MUI: The value provided to Autocomplete is invalid.\n // None of the options match with `\"a\"`.\n // You can use the `isOptionEqualToValue` prop to customize the equality test.\n listValuesToDisplay = mergeListValues(listValuesToDisplay, nSelectedAsyncListValues, true, true);\n }\n //const isDirtyInitialListValues = asyncListValues == undefined && selectedAsyncListValues && selectedAsyncListValues.length && typeof selectedAsyncListValues[0] != \"object\";\n var isLoading = loadingCnt > 0;\n var canInitialLoadSelected = fetchSelectedValuesOnInit && !open && asyncFetch && areSelectedAsyncListValuesNotResolved && selectedValue != null;\n var canFirstLoadOnOpened = open && asyncFetch && asyncListValues === undefined && (forceAsyncSearch ? inputValue : true);\n var isInitialLoading = (canFirstLoadOnOpened || canInitialLoadSelected) && isLoading;\n var canLoadMore = !isInitialLoading && listValues && listValues.length > 0 && asyncFetchMeta && asyncFetchMeta.hasMore && (asyncFetchMeta.filter || \"\") === inputValue;\n var canShowLoadMore = !isLoading && canLoadMore;\n var options = mapListValues(listValuesToDisplay, listValueToOption);\n var hasValue = selectedValue != null;\n var selectedListValue = !multiple && hasValue ? getListValue(selectedValue, listValues) : null;\n // const selectedListValues = multiple && hasValue ? selectedValue.map(v => getItemInListValues(listValues, v)) : [];\n\n // fetch - search\n var fetchListValues = /*#__PURE__*/function () {\n var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n var filter,\n isLoadMore,\n offset,\n meta,\n newAsyncFetchCnt,\n res,\n isFetchCancelled,\n _ref4,\n values,\n hasMore,\n newMeta,\n nValues,\n assumeHasMore,\n newValues,\n realNewMeta,\n _args = arguments;\n return _regeneratorRuntime.wrap(function _callee$(_context) {\n while (1) switch (_context.prev = _context.next) {\n case 0:\n filter = _args.length > 0 && _args[0] !== undefined ? _args[0] : null;\n isLoadMore = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;\n // clear obsolete meta\n if (!isLoadMore && asyncFetchMeta) {\n setAsyncFetchMeta(undefined);\n }\n offset = isLoadMore && asyncListValues ? asyncListValues.length : 0;\n meta = isLoadMore && asyncFetchMeta || !useLoadMore && {\n pageSize: 0\n };\n newAsyncFetchCnt = ++asyncFectchCnt.current;\n _context.next = 8;\n return asyncFetch.call(config === null || config === void 0 ? void 0 : config.ctx, filter, offset, meta);\n case 8:\n res = _context.sent;\n isFetchCancelled = asyncFectchCnt.current != newAsyncFetchCnt;\n if (!(isFetchCancelled || !componentIsMounted.current)) {\n _context.next = 12;\n break;\n }\n return _context.abrupt(\"return\", null);\n case 12:\n _ref4 = res !== null && res !== void 0 && res.values ? res : {\n values: res\n }, values = _ref4.values, hasMore = _ref4.hasMore, newMeta = _ref4.meta;\n nValues = listValuesToArray(values);\n if (isLoadMore) {\n newValues = mergeListValues(asyncListValues, nValues, false);\n assumeHasMore = newValues.length > asyncListValues.length;\n } else {\n newValues = nValues;\n if (useLoadMore) {\n assumeHasMore = newValues.length > 0;\n }\n }\n\n // save new meta\n realNewMeta = hasMore != null || newMeta != null || assumeHasMore != null ? _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, assumeHasMore != null ? {\n hasMore: assumeHasMore\n } : {}), hasMore != null ? {\n hasMore: hasMore\n } : {}), newMeta != null ? newMeta : {}), {}, {\n filter: filter\n }) : undefined;\n if (realNewMeta) {\n setAsyncFetchMeta(realNewMeta);\n }\n return _context.abrupt(\"return\", newValues);\n case 18:\n case \"end\":\n return _context.stop();\n }\n }, _callee);\n }));\n return function fetchListValues() {\n return _ref3.apply(this, arguments);\n };\n }();\n\n // fetch - selected values only\n var fetchSelectedListValues = /*#__PURE__*/function () {\n var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n var selectedValues, meta, newAsyncFetchCnt, res, isFetchCancelled, _ref6, selectedListValues, latestSelectedValues, nValues;\n return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n while (1) switch (_context2.prev = _context2.next) {\n case 0:\n selectedValues = latestSelectedValue.current == null ? [] : multiple ? latestSelectedValue.current : [latestSelectedValue.current];\n if (selectedValues.length) {\n _context2.next = 3;\n break;\n }\n return _context2.abrupt(\"return\", null);\n case 3:\n meta = {\n fetchSelectedValues: true\n };\n newAsyncFetchCnt = ++asyncFectchCnt.current;\n _context2.next = 7;\n return asyncFetch.call(config === null || config === void 0 ? void 0 : config.ctx, selectedValues, -1, meta);\n case 7:\n res = _context2.sent;\n isFetchCancelled = asyncFectchCnt.current != newAsyncFetchCnt;\n if (!(isFetchCancelled || !componentIsMounted.current)) {\n _context2.next = 11;\n break;\n }\n return _context2.abrupt(\"return\", null);\n case 11:\n _ref6 = res !== null && res !== void 0 && res.values ? res : {\n values: res\n }, selectedListValues = _ref6.values;\n latestSelectedValues = latestSelectedValue.current == null ? [] : multiple ? latestSelectedValue.current : [latestSelectedValue.current];\n nValues = latestSelectedValues.map(function (v) {\n var _getItemInListValues;\n return (_getItemInListValues = getItemInListValues(selectedListValues, v)) !== null && _getItemInListValues !== void 0 ? _getItemInListValues : makeCustomListValue(v);\n });\n return _context2.abrupt(\"return\", nValues.length ? nValues : null);\n case 15:\n case \"end\":\n return _context2.stop();\n }\n }, _callee2);\n }));\n return function fetchSelectedListValues() {\n return _ref5.apply(this, arguments);\n };\n }();\n var loadSelectedListValues = /*#__PURE__*/function () {\n var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {\n var list;\n return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n while (1) switch (_context3.prev = _context3.next) {\n case 0:\n setLoadingCnt(function (x) {\n return x + 1;\n });\n _context3.next = 3;\n return fetchSelectedListValues();\n case 3:\n list = _context3.sent;\n if (componentIsMounted.current) {\n _context3.next = 6;\n break;\n }\n return _context3.abrupt(\"return\");\n case 6:\n if (list != null) {\n setValue(latestSelectedValue.current, list);\n }\n setLoadingCnt(function (x) {\n return x - 1;\n });\n case 8:\n case \"end\":\n return _context3.stop();\n }\n }, _callee3);\n }));\n return function loadSelectedListValues() {\n return _ref7.apply(this, arguments);\n };\n }();\n var loadListValues = /*#__PURE__*/function () {\n var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {\n var filter,\n isLoadMore,\n list,\n _args4 = arguments;\n return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n while (1) switch (_context4.prev = _context4.next) {\n case 0:\n filter = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : null;\n isLoadMore = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : false;\n setLoadingCnt(function (x) {\n return x + 1;\n });\n setIsLoadingMore(isLoadMore);\n _context4.next = 6;\n return fetchListValues(filter, isLoadMore);\n case 6:\n list = _context4.sent;\n if (componentIsMounted.current) {\n _context4.next = 9;\n break;\n }\n return _context4.abrupt(\"return\");\n case 9:\n if (list != null) {\n // tip: null can be used for reject (eg, if user don't want to filter by input)\n setAsyncListValues(list);\n }\n setLoadingCnt(function (x) {\n return x - 1;\n });\n setIsLoadingMore(false);\n case 12:\n case \"end\":\n return _context4.stop();\n }\n }, _callee4);\n }));\n return function loadListValues() {\n return _ref8.apply(this, arguments);\n };\n }();\n var loadListValuesDebounced = React.useCallback(debounce(loadListValues, debounceTimeout), []);\n React.useEffect(function () {\n componentIsMounted.current++;\n // Unmount\n return function () {\n componentIsMounted.current--;\n // if (!componentIsMounted.current && field) {\n // console.log(`Autocomplete for ${field} has been unmounted`)\n // }\n };\n }, []);\n React.useEffect(function () {\n // Initial loading\n if (canFirstLoadOnOpened && loadingCnt == 0) {\n _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n while (1) switch (_context5.prev = _context5.next) {\n case 0:\n _context5.next = 2;\n return loadListValues();\n case 2:\n case \"end\":\n return _context5.stop();\n }\n }, _callee5);\n }))();\n }\n if (canInitialLoadSelected && loadingCnt == 0) {\n _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {\n return _regeneratorRuntime.wrap(function _callee6$(_context6) {\n while (1) switch (_context6.prev = _context6.next) {\n case 0:\n _context6.next = 2;\n return loadSelectedListValues();\n case 2:\n case \"end\":\n return _context6.stop();\n }\n }, _callee6);\n }))();\n }\n }, [canFirstLoadOnOpened, canInitialLoadSelected, loadingCnt]);\n\n // Event handlers\n var onOpen = function onOpen() {\n setOpen(true);\n };\n var onClose = /*#__PURE__*/function () {\n var _ref11 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(_e) {\n var isLoadMoreClick, resetValue;\n return _regeneratorRuntime.wrap(function _callee7$(_context7) {\n while (1) switch (_context7.prev = _context7.next) {\n case 0:\n isLoadMoreClick = isSelectedLoadMore.current;\n if (isLoadMoreClick) {\n isSelectedLoadMore.current = false;\n if (multiple) {\n // required for MUI\n setOpen(false);\n }\n } else {\n setOpen(false);\n }\n if (!(uif === \"mui\" && !isLoadMoreClick)) {\n _context7.next = 6;\n break;\n }\n // parity with Antd\n resetValue = \"\";\n _context7.next = 6;\n return onInputChange(null, resetValue, \"my-reset\");\n case 6:\n case \"end\":\n return _context7.stop();\n }\n }, _callee7);\n }));\n return function onClose(_x) {\n return _ref11.apply(this, arguments);\n };\n }();\n var onDropdownVisibleChange = function onDropdownVisibleChange(open) {\n if (open) {\n onOpen();\n } else {\n onClose();\n }\n };\n var isSpecialValue = function isSpecialValue(option) {\n var specialValue = (option === null || option === void 0 ? void 0 : option.specialValue) || (option === null || option === void 0 ? void 0 : option.value);\n return knownSpecialValues.includes(specialValue);\n };\n var onChange = /*#__PURE__*/function () {\n var _ref12 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(e, val, option) {\n var _option2, _val;\n var isClearingAll, isClearingInput, isClearingSingle, _option$value, _option, specialValue, valHasDuplicates, isBadCallAfterTokenization, shouldIgnore, isAddingCustomOptionFromSearch, _optionsToListValues, _optionsToListValues2, newSelectedValues, newSelectedListValues, _optionToListValue, _optionToListValue2, v, lvs;\n return _regeneratorRuntime.wrap(function _callee8$(_context8) {\n while (1) switch (_context8.prev = _context8.next) {\n case 0:\n // todo: don't rely on 3rd param. check MUI 6\n isClearingAll = multiple && uif === \"mui\" && option === \"clear\"; // if user removes all chars in search, don't clear selected value\n isClearingInput = !multiple && uif === \"mui\" && option === \"clear\" && (e === null || e === void 0 ? void 0 : e.type) === \"change\";\n isClearingSingle = !multiple && uif === \"mui\" && option === \"clear\" && (e === null || e === void 0 ? void 0 : e.type) !== \"change\";\n if (uif === \"mui\") {\n option = val;\n if (multiple) {\n val = option.map(function (o) {\n var _o$value;\n return (_o$value = o === null || o === void 0 ? void 0 : o.value) !== null && _o$value !== void 0 ? _o$value : o;\n });\n } else {\n val = (_option$value = (_option = option) === null || _option === void 0 ? void 0 : _option.value) !== null && _option$value !== void 0 ? _option$value : option;\n }\n }\n specialValue = multiple && Array.isArray(option) && option.map(function (opt) {\n return opt === null || opt === void 0 ? void 0 : opt.specialValue;\n }).find(function (v) {\n return !!v;\n }) || ((_option2 = option) === null || _option2 === void 0 ? void 0 : _option2.specialValue);\n if (multiple && val && !Array.isArray(val)) {\n val = [].concat(_toConsumableArray(selectedValue || []), [val]);\n option = null;\n }\n valHasDuplicates = multiple && ((_val = val) === null || _val === void 0 ? void 0 : _val.length) && new Set(val).size !== val.length;\n isBadCallAfterTokenization = multiple && uif === \"antd\" && e === null && option === null && valHasDuplicates; // if there are tags AND input and select is opened, clear input first\n shouldIgnore = isClearingAll && val.length === 0 && inputValue && open || isClearingInput || isBadCallAfterTokenization;\n if (!shouldIgnore) {\n _context8.next = 11;\n break;\n }\n return _context8.abrupt(\"return\");\n case 11:\n isAddingCustomOptionFromSearch = multiple && val.length && val.length > (selectedValue || []).length && val[val.length - 1] == inputValue && !getListValue(inputValue, asyncListValues);\n if (!(specialValue == \"LOAD_MORE\")) {\n _context8.next = 19;\n break;\n }\n setInputValue(inputValue);\n isSelectedLoadMore.current = true;\n _context8.next = 17;\n return loadListValues(inputValue, true);\n case 17:\n _context8.next = 39;\n break;\n case 19:\n if (!(specialValue == \"LOADING_MORE\")) {\n _context8.next = 23;\n break;\n }\n isSelectedLoadMore.current = true;\n _context8.next = 39;\n break;\n case 23:\n if (!multiple) {\n _context8.next = 33;\n break;\n }\n _optionsToListValues = optionsToListValues(val, listValues, allowCustomValues), _optionsToListValues2 = _slicedToArray(_optionsToListValues, 2), newSelectedValues = _optionsToListValues2[0], newSelectedListValues = _optionsToListValues2[1];\n setValue(newSelectedValues, asyncFetch ? newSelectedListValues : undefined);\n if (!isAddingCustomOptionFromSearch) {\n _context8.next = 31;\n break;\n }\n _context8.next = 29;\n return sleep(0);\n case 29:\n _context8.next = 31;\n return onInputChange(null, \"\", \"my-reset\");\n case 31:\n _context8.next = 39;\n break;\n case 33:\n _optionToListValue = optionToListValue(val, listValues, allowCustomValues), _optionToListValue2 = _slicedToArray(_optionToListValue, 2), v = _optionToListValue2[0], lvs = _optionToListValue2[1];\n setValue(v, asyncFetch ? lvs : undefined);\n if (!(isClearingSingle && isFieldAutocomplete)) {\n _context8.next = 39;\n break;\n }\n _context8.next = 38;\n return sleep(0);\n case 38:\n setOpen(false);\n case 39:\n case \"end\":\n return _context8.stop();\n }\n }, _callee8);\n }));\n return function onChange(_x2, _x3, _x4) {\n return _ref12.apply(this, arguments);\n };\n }();\n var onInputChange = /*#__PURE__*/function () {\n var _ref13 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(e, newInputValue, eventType) {\n var isRemoveOption, isSelectOption, isIgnoredBlur, shouldIgnore, val, canSearchAsync;\n return _regeneratorRuntime.wrap(function _callee9$(_context9) {\n while (1) switch (_context9.prev = _context9.next) {\n case 0:\n // eventType=reset used by MUI on:\n // - (single) initial set, select option - e = null, newInputValue = selected (+1 call before with e != null)\n // - (single/multi, -ACV) blur - e != null, newInputValue = ''\n // - (multiple v5, -ACV) blur - e = null, newInputValue = '' # unwanted\n // - (multiple) select option - e != null, newInputValue = ''\n // - (multiple v4) delete tag while searching - e = null, newInputValue = '' # unwanted\n // - (multiple v4) select option while searching - e = null, newInputValue = '' # unwanted\n isRemoveOption = uif === \"mui\" && eventType === \"removeOption\" && newInputValue === \"\" && multiple;\n isSelectOption = uif === \"mui\" && eventType === \"selectOption\" && newInputValue === \"\" && multiple;\n isIgnoredBlur = uif === \"mui\" && !multiple && eventType === \"blur\" && newInputValue === (selectedListValue === null || selectedListValue === void 0 ? void 0 : selectedListValue.title);\n shouldIgnore = uif === \"mui\" && eventType === \"reset\"\n // && (\n // e != null\n // // for MUI 4 if search \"A\" and select any option -> should NOT reset search\n // // for MUI 5 if search \"A\" and close -> let's hold search but hide, as it's done in antd\n // || e === null && inputValue && multiple\n // )\n || isSelectOption || isRemoveOption || isIgnoredBlur;\n val = newInputValue;\n if (!(val === loadMoreTitle || val === loadingMoreTitle || shouldIgnore)) {\n _context9.next = 7;\n break;\n }\n return _context9.abrupt(\"return\");\n case 7:\n if (!(uif === \"mui\" && !multiple && eventType === \"selectOption\" && newInputValue !== \"\")) {\n _context9.next = 9;\n break;\n }\n return _context9.abrupt(\"return\");\n case 9:\n if (!(newInputValue != inputValue)) {\n _context9.next = 18;\n break;\n }\n setInputValue(val);\n canSearchAsync = useAsyncSearch && (forceAsyncSearch ? !!val : true);\n if (!canSearchAsync) {\n _context9.next = 17;\n break;\n }\n _context9.next = 15;\n return loadListValuesDebounced(val);\n case 15:\n _context9.next = 18;\n break;\n case 17:\n if (useAsyncSearch && forceAsyncSearch) {\n setAsyncListValues([]);\n }\n case 18:\n case \"end\":\n return _context9.stop();\n }\n }, _callee9);\n }));\n return function onInputChange(_x5, _x6, _x7) {\n return _ref13.apply(this, arguments);\n };\n }();\n\n // Options\n var extendOptions = function extendOptions(options) {\n var filtered = _toConsumableArray(options);\n if (useLoadMore) {\n if (canShowLoadMore) {\n filtered.push({\n specialValue: \"LOAD_MORE\",\n title: loadMoreTitle\n });\n } else if (isLoadingMore) {\n filtered.push({\n specialValue: \"LOADING_MORE\",\n title: loadingMoreTitle,\n disabled: true\n });\n }\n }\n return filtered;\n };\n var getOptionSelected = function getOptionSelected(option, valueOrOption) {\n if (valueOrOption == null) return null;\n var selectedValue = valueOrOption.value != undefined ? valueOrOption.value : valueOrOption;\n return option.value === selectedValue;\n };\n var getOptionDisabled = function getOptionDisabled(valueOrOption) {\n return valueOrOption && valueOrOption.disabled;\n };\n var getOptionIsCustom = function getOptionIsCustom(valueOrOption) {\n var _valueOrOption$value;\n if (valueOrOption !== null && valueOrOption !== void 0 && valueOrOption.isCustom) return true;\n var val = (_valueOrOption$value = valueOrOption === null || valueOrOption === void 0 ? void 0 : valueOrOption.value) !== null && _valueOrOption$value !== void 0 ? _valueOrOption$value : valueOrOption;\n var lv = getListValue(val, listValues);\n return (lv === null || lv === void 0 ? void 0 : lv.isCustom) || lv == null;\n };\n var getOptionLabel = function getOptionLabel(valueOrOption) {\n if (valueOrOption == null) return null;\n var option = valueOrOption.value != undefined ? valueOrOption : listValueToOption(getListValue(valueOrOption, listValues));\n if (!option && valueOrOption.specialValue) {\n // special last 'Load more...' item\n return valueOrOption.title;\n }\n if (!option && allowCustomValues) {\n // there is just string value, it's not item from list\n return valueOrOption.toString();\n }\n if (!option) {\n // weird\n return valueOrOption.toString();\n }\n return option.title || option.label || option.value.toString(); // fallback to value\n };\n var fixedOptions = uif === \"mui\" ? fixListValuesGroupOrder(options) : options;\n return {\n options: fixedOptions,\n listValues: listValues,\n hasValue: hasValue,\n selectedListValue: selectedListValue,\n open: open,\n onOpen: onOpen,\n onClose: onClose,\n onDropdownVisibleChange: onDropdownVisibleChange,\n onChange: onChange,\n inputValue: inputValue,\n onInputChange: onInputChange,\n canShowLoadMore: canShowLoadMore,\n isInitialLoading: isInitialLoading,\n isLoading: isLoading,\n isLoadingMore: isLoadingMore,\n isSpecialValue: isSpecialValue,\n extendOptions: extendOptions,\n getOptionSelected: getOptionSelected,\n getOptionDisabled: getOptionDisabled,\n getOptionIsCustom: getOptionIsCustom,\n getOptionLabel: getOptionLabel,\n aPlaceholder: aPlaceholder\n };\n};\nexport default useListValuesAutocomplete;","import _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nimport { Utils } from \"@react-awesome-query-builder/core\";\nimport * as ReactUtils from \"./reactUtils\";\nimport { DragIcon } from \"../components/utils\";\nexport default _objectSpread(_objectSpread({}, Utils), {}, {\n ReactUtils: ReactUtils,\n DragIcon: DragIcon\n});","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nmodule.exports = hashSet;\n","function _regeneratorDefine(e, r, n, t) {\n var i = Object.defineProperty;\n try {\n i({}, \"\", {});\n } catch (e) {\n i = 0;\n }\n module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {\n function o(r, n) {\n _regeneratorDefine(e, r, function (e) {\n return this._invoke(r, n, e);\n });\n }\n r ? i ? i(e, r, {\n value: n,\n enumerable: !t,\n configurable: !t,\n writable: !t\n }) : e[r] = n : (o(\"next\", 0), o(\"throw\", 1), o(\"return\", 2));\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _regeneratorDefine(e, r, n, t);\n}\nmodule.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var identity = require('./identity'),\n overRest = require('./_overRest'),\n setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n","var toNumber = require('./toNumber');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n}\n\nmodule.exports = toFinite;\n","var baseCreate = require('./_baseCreate'),\n getPrototype = require('./_getPrototype'),\n isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\nmodule.exports = initCloneObject;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\nmodule.exports = copyArray;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__1269__;","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n var index = string.length;\n\n while (index-- && reWhitespace.test(string.charAt(index))) {}\n return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var arrayMap = require('./_arrayMap');\n\n/**\n * The base implementation of `_.values` and `_.valuesIn` which creates an\n * array of `object` property values corresponding to the property names\n * of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the array of property values.\n */\nfunction baseValues(object, props) {\n return arrayMap(props, function(key) {\n return object[key];\n });\n}\n\nmodule.exports = baseValues;\n","var baseIndexOf = require('./_baseIndexOf'),\n isArrayLike = require('./isArrayLike'),\n isString = require('./isString'),\n toInteger = require('./toInteger'),\n values = require('./values');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\nfunction includes(collection, value, fromIndex, guard) {\n collection = isArrayLike(collection) ? collection : values(collection);\n fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n var length = collection.length;\n if (fromIndex < 0) {\n fromIndex = nativeMax(length + fromIndex, 0);\n }\n return isString(collection)\n ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n}\n\nmodule.exports = includes;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__1308__;","var cloneArrayBuffer = require('./_cloneArrayBuffer'),\n cloneDataView = require('./_cloneDataView'),\n cloneRegExp = require('./_cloneRegExp'),\n cloneSymbol = require('./_cloneSymbol'),\n cloneTypedArray = require('./_cloneTypedArray');\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return new Ctor;\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return new Ctor;\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\nmodule.exports = initCloneByTag;\n","var arrayPush = require('./_arrayPush'),\n isFlattenable = require('./_isFlattenable');\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n var index = -1,\n length = array.length;\n\n predicate || (predicate = isFlattenable);\n result || (result = []);\n\n while (++index < length) {\n var value = array[index];\n if (depth > 0 && predicate(value)) {\n if (depth > 1) {\n // Recursively flatten arrays (susceptible to call stack limits).\n baseFlatten(value, depth - 1, predicate, isStrict, result);\n } else {\n arrayPush(result, value);\n }\n } else if (!isStrict) {\n result[result.length] = value;\n }\n }\n return result;\n}\n\nmodule.exports = baseFlatten;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nmodule.exports = arrayMap;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _Formatter = _interopRequireDefault(require(\"../core/Formatter\"));\n\nvar _Tokenizer = _interopRequireDefault(require(\"../core/Tokenizer\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar reservedWords = ['ACCESSIBLE', 'ACTION', 'AGAINST', 'AGGREGATE', 'ALGORITHM', 'ALL', 'ALTER', 'ANALYSE', 'ANALYZE', 'AS', 'ASC', 'AUTOCOMMIT', 'AUTO_INCREMENT', 'BACKUP', 'BEGIN', 'BETWEEN', 'BINLOG', 'BOTH', 'CASCADE', 'CASE', 'CHANGE', 'CHANGED', 'CHARACTER SET', 'CHARSET', 'CHECK', 'CHECKSUM', 'COLLATE', 'COLLATION', 'COLUMN', 'COLUMNS', 'COMMENT', 'COMMIT', 'COMMITTED', 'COMPRESSED', 'CONCURRENT', 'CONSTRAINT', 'CONTAINS', 'CONVERT', 'CREATE', 'CROSS', 'CURRENT_TIMESTAMP', 'DATABASE', 'DATABASES', 'DAY', 'DAY_HOUR', 'DAY_MINUTE', 'DAY_SECOND', 'DEFAULT', 'DEFINER', 'DELAYED', 'DELETE', 'DESC', 'DESCRIBE', 'DETERMINISTIC', 'DISTINCT', 'DISTINCTROW', 'DIV', 'DO', 'DROP', 'DUMPFILE', 'DUPLICATE', 'DYNAMIC', 'ELSE', 'ENCLOSED', 'END', 'ENGINE', 'ENGINES', 'ENGINE_TYPE', 'ESCAPE', 'ESCAPED', 'EVENTS', 'EXEC', 'EXECUTE', 'EXISTS', 'EXPLAIN', 'EXTENDED', 'FAST', 'FETCH', 'FIELDS', 'FILE', 'FIRST', 'FIXED', 'FLUSH', 'FOR', 'FORCE', 'FOREIGN', 'FULL', 'FULLTEXT', 'FUNCTION', 'GLOBAL', 'GRANT', 'GRANTS', 'GROUP_CONCAT', 'HEAP', 'HIGH_PRIORITY', 'HOSTS', 'HOUR', 'HOUR_MINUTE', 'HOUR_SECOND', 'IDENTIFIED', 'IF', 'IFNULL', 'IGNORE', 'IN', 'INDEX', 'INDEXES', 'INFILE', 'INSERT', 'INSERT_ID', 'INSERT_METHOD', 'INTERVAL', 'INTO', 'INVOKER', 'IS', 'ISOLATION', 'KEY', 'KEYS', 'KILL', 'LAST_INSERT_ID', 'LEADING', 'LEVEL', 'LIKE', 'LINEAR', 'LINES', 'LOAD', 'LOCAL', 'LOCK', 'LOCKS', 'LOGS', 'LOW_PRIORITY', 'MARIA', 'MASTER', 'MASTER_CONNECT_RETRY', 'MASTER_HOST', 'MASTER_LOG_FILE', 'MATCH', 'MAX_CONNECTIONS_PER_HOUR', 'MAX_QUERIES_PER_HOUR', 'MAX_ROWS', 'MAX_UPDATES_PER_HOUR', 'MAX_USER_CONNECTIONS', 'MEDIUM', 'MERGE', 'MINUTE', 'MINUTE_SECOND', 'MIN_ROWS', 'MODE', 'MODIFY', 'MONTH', 'MRG_MYISAM', 'MYISAM', 'NAMES', 'NATURAL', 'NOT', 'NOW()', 'NULL', 'OFFSET', 'ON DELETE', 'ON UPDATE', 'ON', 'ONLY', 'OPEN', 'OPTIMIZE', 'OPTION', 'OPTIONALLY', 'OUTFILE', 'PACK_KEYS', 'PAGE', 'PARTIAL', 'PARTITION', 'PARTITIONS', 'PASSWORD', 'PRIMARY', 'PRIVILEGES', 'PROCEDURE', 'PROCESS', 'PROCESSLIST', 'PURGE', 'QUICK', 'RAID0', 'RAID_CHUNKS', 'RAID_CHUNKSIZE', 'RAID_TYPE', 'RANGE', 'READ', 'READ_ONLY', 'READ_WRITE', 'REFERENCES', 'REGEXP', 'RELOAD', 'RENAME', 'REPAIR', 'REPEATABLE', 'REPLACE', 'REPLICATION', 'RESET', 'RESTORE', 'RESTRICT', 'RETURN', 'RETURNS', 'REVOKE', 'RLIKE', 'ROLLBACK', 'ROW', 'ROWS', 'ROW_FORMAT', 'SECOND', 'SECURITY', 'SEPARATOR', 'SERIALIZABLE', 'SESSION', 'SHARE', 'SHOW', 'SHUTDOWN', 'SLAVE', 'SONAME', 'SOUNDS', 'SQL', 'SQL_AUTO_IS_NULL', 'SQL_BIG_RESULT', 'SQL_BIG_SELECTS', 'SQL_BIG_TABLES', 'SQL_BUFFER_RESULT', 'SQL_CACHE', 'SQL_CALC_FOUND_ROWS', 'SQL_LOG_BIN', 'SQL_LOG_OFF', 'SQL_LOG_UPDATE', 'SQL_LOW_PRIORITY_UPDATES', 'SQL_MAX_JOIN_SIZE', 'SQL_NO_CACHE', 'SQL_QUOTE_SHOW_CREATE', 'SQL_SAFE_UPDATES', 'SQL_SELECT_LIMIT', 'SQL_SLAVE_SKIP_COUNTER', 'SQL_SMALL_RESULT', 'SQL_WARNINGS', 'START', 'STARTING', 'STATUS', 'STOP', 'STORAGE', 'STRAIGHT_JOIN', 'STRING', 'STRIPED', 'SUPER', 'TABLE', 'TABLES', 'TEMPORARY', 'TERMINATED', 'THEN', 'TO', 'TRAILING', 'TRANSACTIONAL', 'TRUE', 'TRUNCATE', 'TYPE', 'TYPES', 'UNCOMMITTED', 'UNIQUE', 'UNLOCK', 'UNSIGNED', 'USAGE', 'USE', 'USING', 'VARIABLES', 'VIEW', 'WHEN', 'WITH', 'WORK', 'WRITE', 'YEAR_MONTH'];\nvar reservedTopLevelWords = ['ADD', 'AFTER', 'ALTER COLUMN', 'ALTER TABLE', 'DELETE FROM', 'EXCEPT', 'FETCH FIRST', 'FROM', 'GROUP BY', 'GO', 'HAVING', 'INSERT INTO', 'INSERT', 'LIMIT', 'MODIFY', 'ORDER BY', 'SELECT', 'SET CURRENT SCHEMA', 'SET SCHEMA', 'SET', 'UPDATE', 'VALUES', 'WHERE'];\nvar reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];\nvar reservedNewlineWords = ['AND', 'CROSS APPLY', 'CROSS JOIN', 'ELSE', 'INNER JOIN', 'JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'OR', 'OUTER APPLY', 'OUTER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN', 'WHEN', 'XOR'];\nvar tokenizer;\n\nvar StandardSqlFormatter =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg Different set of configurations\r\n */\n function StandardSqlFormatter(cfg) {\n _classCallCheck(this, StandardSqlFormatter);\n\n this.cfg = cfg;\n }\n /**\r\n * Format the whitespace in a Standard SQL string to make it easier to read\r\n *\r\n * @param {String} query The Standard SQL string\r\n * @return {String} formatted string\r\n */\n\n\n _createClass(StandardSqlFormatter, [{\n key: \"format\",\n value: function format(query) {\n if (!tokenizer) {\n tokenizer = new _Tokenizer[\"default\"]({\n reservedWords: reservedWords,\n reservedTopLevelWords: reservedTopLevelWords,\n reservedNewlineWords: reservedNewlineWords,\n reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,\n stringTypes: [\"\\\"\\\"\", \"N''\", \"''\", '``', '[]'],\n openParens: ['(', 'CASE'],\n closeParens: [')', 'END'],\n indexedPlaceholderTypes: ['?'],\n namedPlaceholderTypes: ['@', ':'],\n lineCommentTypes: ['#', '--']\n });\n }\n\n return new _Formatter[\"default\"](this.cfg, tokenizer).format(query);\n }\n }]);\n\n return StandardSqlFormatter;\n}();\n\nexports[\"default\"] = StandardSqlFormatter;\nmodule.exports = exports.default;","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var copyObject = require('./_copyObject'),\n getSymbolsIn = require('./_getSymbolsIn');\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n return copyObject(source, getSymbolsIn(source), object);\n}\n\nmodule.exports = copySymbolsIn;\n","var castPath = require('./_castPath'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isIndex = require('./_isIndex'),\n isLength = require('./isLength'),\n toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n","var mapCacheClear = require('./_mapCacheClear'),\n mapCacheDelete = require('./_mapCacheDelete'),\n mapCacheGet = require('./_mapCacheGet'),\n mapCacheHas = require('./_mapCacheHas'),\n mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var baseAssignValue = require('./_baseAssignValue'),\n baseForOwn = require('./_baseForOwn'),\n baseIteratee = require('./_baseIteratee');\n\n/**\n * Creates an object with the same keys as `object` and values generated\n * by running each own enumerable string keyed property of `object` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, key, object).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns the new mapped object.\n * @see _.mapKeys\n * @example\n *\n * var users = {\n * 'fred': { 'user': 'fred', 'age': 40 },\n * 'pebbles': { 'user': 'pebbles', 'age': 1 }\n * };\n *\n * _.mapValues(users, function(o) { return o.age; });\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n *\n * // The `_.property` iteratee shorthand.\n * _.mapValues(users, 'age');\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n */\nfunction mapValues(object, iteratee) {\n var result = {};\n iteratee = baseIteratee(iteratee, 3);\n\n baseForOwn(object, function(value, key, object) {\n baseAssignValue(result, key, iteratee(value, key, object));\n });\n return result;\n}\n\nmodule.exports = mapValues;\n","var baseValues = require('./_baseValues'),\n keys = require('./keys');\n\n/**\n * Creates an array of the own enumerable string keyed property values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.values(new Foo);\n * // => [1, 2] (iteration order is not guaranteed)\n *\n * _.values('hi');\n * // => ['h', 'i']\n */\nfunction values(object) {\n return object == null ? [] : baseValues(object, keys(object));\n}\n\nmodule.exports = values;\n","var copyObject = require('./_copyObject'),\n getSymbols = require('./_getSymbols');\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\nmodule.exports = copySymbols;\n","function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","export enum QueryEditorPropertyType {\n String = 'string',\n}\n\nexport interface QueryEditorProperty {\n type: QueryEditorPropertyType;\n name?: string;\n}\n\nexport type QueryEditorOperatorType = string | boolean | number;\ntype QueryEditorOperatorValueType = QueryEditorOperatorType | QueryEditorOperatorType[];\n\nexport interface QueryEditorOperator<T extends QueryEditorOperatorValueType> {\n name?: string;\n value?: T;\n}\n\nexport interface QueryEditorOperatorExpression {\n type: QueryEditorExpressionType.Operator;\n property: QueryEditorProperty;\n operator: QueryEditorOperator<QueryEditorOperatorValueType>;\n}\n\nexport interface QueryEditorArrayExpression {\n type: QueryEditorExpressionType.And | QueryEditorExpressionType.Or;\n expressions: QueryEditorExpression[] | QueryEditorArrayExpression[];\n}\n\nexport interface QueryEditorPropertyExpression {\n type: QueryEditorExpressionType.Property;\n property: QueryEditorProperty;\n}\n\nexport enum QueryEditorExpressionType {\n Property = 'property',\n Operator = 'operator',\n Or = 'or',\n And = 'and',\n GroupBy = 'groupBy',\n Function = 'function',\n FunctionParameter = 'functionParameter',\n}\n\nexport type QueryEditorExpression =\n | QueryEditorArrayExpression\n | QueryEditorPropertyExpression\n | QueryEditorGroupByExpression\n | QueryEditorFunctionExpression\n | QueryEditorFunctionParameterExpression\n | QueryEditorOperatorExpression;\n\nexport interface QueryEditorGroupByExpression {\n type: QueryEditorExpressionType.GroupBy;\n property: QueryEditorProperty;\n}\n\nexport interface QueryEditorFunctionExpression {\n type: QueryEditorExpressionType.Function;\n name?: string;\n alias?: string;\n parameters?: QueryEditorFunctionParameterExpression[];\n}\n\nexport interface QueryEditorFunctionParameterExpression {\n type: QueryEditorExpressionType.FunctionParameter;\n name?: string;\n}\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var OverloadYield = require(\"./OverloadYield.js\");\nvar regeneratorDefine = require(\"./regeneratorDefine.js\");\nfunction AsyncIterator(t, e) {\n function n(r, o, i, f) {\n try {\n var c = t[r](o),\n u = c.value;\n return u instanceof OverloadYield ? e.resolve(u.v).then(function (t) {\n n(\"next\", t, i, f);\n }, function (t) {\n n(\"throw\", t, i, f);\n }) : e.resolve(u).then(function (t) {\n c.value = t, i(c);\n }, function (t) {\n return n(\"throw\", t, i, f);\n });\n } catch (t) {\n f(t);\n }\n }\n var r;\n this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, \"function\" == typeof Symbol && Symbol.asyncIterator || \"@asyncIterator\", function () {\n return this;\n })), regeneratorDefine(this, \"_invoke\", function (t, o, i) {\n function f() {\n return new e(function (e, r) {\n n(t, i, e, r);\n });\n }\n return r = r ? r.then(f, f) : f();\n }, !0);\n}\nmodule.exports = AsyncIterator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var baseGetTag = require('./_baseGetTag'),\n isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","var listCacheClear = require('./_listCacheClear'),\n listCacheDelete = require('./_listCacheDelete'),\n listCacheGet = require('./_listCacheGet'),\n listCacheHas = require('./_listCacheHas'),\n listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__2007__;","var isPlainObject = require('./isPlainObject');\n\n/**\n * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n * objects.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {string} key The key of the property to inspect.\n * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n */\nfunction customOmitClone(value) {\n return isPlainObject(value) ? undefined : value;\n}\n\nmodule.exports = customOmitClone;\n","var getTag = require('./_getTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nmodule.exports = baseIsMap;\n","var baseIsNative = require('./_baseIsNative'),\n getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n return root.Date.now();\n};\n\nmodule.exports = now;\n","var createRange = require('./_createRange');\n\n/**\n * Creates an array of numbers (positive and/or negative) progressing from\n * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n * `start` is specified without an `end` or `step`. If `end` is not specified,\n * it's set to `start` with `start` then set to `0`.\n *\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\n * floating-point values which can produce unexpected results.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @param {number} [step=1] The value to increment or decrement by.\n * @returns {Array} Returns the range of numbers.\n * @see _.inRange, _.rangeRight\n * @example\n *\n * _.range(4);\n * // => [0, 1, 2, 3]\n *\n * _.range(-4);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 5);\n * // => [1, 2, 3, 4]\n *\n * _.range(0, 20, 5);\n * // => [0, 5, 10, 15]\n *\n * _.range(0, -4, -1);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 4, 0);\n * // => [1, 1, 1]\n *\n * _.range(0);\n * // => []\n */\nvar range = createRange();\n\nmodule.exports = range;\n","var isObject = require('./isObject');\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n * equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n return value === value && !isObject(value);\n}\n\nmodule.exports = isStrictComparable;\n","var isArray = require('./isArray'),\n isKey = require('./_isKey'),\n stringToPath = require('./_stringToPath'),\n toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\nmodule.exports = baseAssignValue;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__2468__;","var baseGet = require('./_baseGet'),\n baseSlice = require('./_baseSlice');\n\n/**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\nfunction parent(object, path) {\n return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n}\n\nmodule.exports = parent;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _repeat = _interopRequireDefault(require(\"lodash/repeat\"));\n\nvar _last = _interopRequireDefault(require(\"lodash/last\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar INDENT_TYPE_TOP_LEVEL = 'top-level';\nvar INDENT_TYPE_BLOCK_LEVEL = 'block-level';\n/**\r\n * Manages indentation levels.\r\n *\r\n * There are two types of indentation levels:\r\n *\r\n * - BLOCK_LEVEL : increased by open-parenthesis\r\n * - TOP_LEVEL : increased by RESERVED_TOP_LEVEL words\r\n */\n\nvar Indentation =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {String} indent Indent value, default is \" \" (2 spaces)\r\n */\n function Indentation(indent) {\n _classCallCheck(this, Indentation);\n\n this.indent = indent || ' ';\n this.indentTypes = [];\n }\n /**\r\n * Returns current indentation string.\r\n * @return {String}\r\n */\n\n\n _createClass(Indentation, [{\n key: \"getIndent\",\n value: function getIndent() {\n return (0, _repeat[\"default\"])(this.indent, this.indentTypes.length);\n }\n /**\r\n * Increases indentation by one top-level indent.\r\n */\n\n }, {\n key: \"increaseTopLevel\",\n value: function increaseTopLevel() {\n this.indentTypes.push(INDENT_TYPE_TOP_LEVEL);\n }\n /**\r\n * Increases indentation by one block-level indent.\r\n */\n\n }, {\n key: \"increaseBlockLevel\",\n value: function increaseBlockLevel() {\n this.indentTypes.push(INDENT_TYPE_BLOCK_LEVEL);\n }\n /**\r\n * Decreases indentation by one top-level indent.\r\n * Does nothing when the previous indent is not top-level.\r\n */\n\n }, {\n key: \"decreaseTopLevel\",\n value: function decreaseTopLevel() {\n if ((0, _last[\"default\"])(this.indentTypes) === INDENT_TYPE_TOP_LEVEL) {\n this.indentTypes.pop();\n }\n }\n /**\r\n * Decreases indentation by one block-level indent.\r\n * If there are top-level indents within the block-level indent,\r\n * throws away these as well.\r\n */\n\n }, {\n key: \"decreaseBlockLevel\",\n value: function decreaseBlockLevel() {\n while (this.indentTypes.length > 0) {\n var type = this.indentTypes.pop();\n\n if (type !== INDENT_TYPE_TOP_LEVEL) {\n break;\n }\n }\n }\n }, {\n key: \"resetIndentation\",\n value: function resetIndentation() {\n this.indentTypes = [];\n }\n }]);\n\n return Indentation;\n}();\n\nexports[\"default\"] = Indentation;\nmodule.exports = exports.default;","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var castPath = require('./_castPath'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nmodule.exports = baseTimes;\n","var baseMerge = require('./_baseMerge'),\n createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n * if (_.isArray(objValue)) {\n * return objValue.concat(srcValue);\n * }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n baseMerge(object, source, srcIndex, customizer);\n});\n\nmodule.exports = mergeWith;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nmodule.exports = memoizeCapped;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","const {\n slice,\n forEach\n} = [];\nfunction defaults(obj) {\n forEach.call(slice.call(arguments, 1), source => {\n if (source) {\n for (const prop in source) {\n if (obj[prop] === undefined) obj[prop] = source[prop];\n }\n }\n });\n return obj;\n}\nfunction hasXSS(input) {\n if (typeof input !== 'string') return false;\n\n // Common XSS attack patterns\n const xssPatterns = [/<\\s*script.*?>/i, /<\\s*\\/\\s*script\\s*>/i, /<\\s*img.*?on\\w+\\s*=/i, /<\\s*\\w+\\s*on\\w+\\s*=.*?>/i, /javascript\\s*:/i, /vbscript\\s*:/i, /expression\\s*\\(/i, /eval\\s*\\(/i, /alert\\s*\\(/i, /document\\.cookie/i, /document\\.write\\s*\\(/i, /window\\.location/i, /innerHTML/i];\n return xssPatterns.some(pattern => pattern.test(input));\n}\n\n// eslint-disable-next-line no-control-regex\nconst fieldContentRegExp = /^[\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+$/;\nconst serializeCookie = function (name, val) {\n let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n path: '/'\n };\n const opt = options;\n const value = encodeURIComponent(val);\n let str = `${name}=${value}`;\n if (opt.maxAge > 0) {\n const maxAge = opt.maxAge - 0;\n if (Number.isNaN(maxAge)) throw new Error('maxAge should be a Number');\n str += `; Max-Age=${Math.floor(maxAge)}`;\n }\n if (opt.domain) {\n if (!fieldContentRegExp.test(opt.domain)) {\n throw new TypeError('option domain is invalid');\n }\n str += `; Domain=${opt.domain}`;\n }\n if (opt.path) {\n if (!fieldContentRegExp.test(opt.path)) {\n throw new TypeError('option path is invalid');\n }\n str += `; Path=${opt.path}`;\n }\n if (opt.expires) {\n if (typeof opt.expires.toUTCString !== 'function') {\n throw new TypeError('option expires is invalid');\n }\n str += `; Expires=${opt.expires.toUTCString()}`;\n }\n if (opt.httpOnly) str += '; HttpOnly';\n if (opt.secure) str += '; Secure';\n if (opt.sameSite) {\n const sameSite = typeof opt.sameSite === 'string' ? opt.sameSite.toLowerCase() : opt.sameSite;\n switch (sameSite) {\n case true:\n str += '; SameSite=Strict';\n break;\n case 'lax':\n str += '; SameSite=Lax';\n break;\n case 'strict':\n str += '; SameSite=Strict';\n break;\n case 'none':\n str += '; SameSite=None';\n break;\n default:\n throw new TypeError('option sameSite is invalid');\n }\n }\n if (opt.partitioned) str += '; Partitioned';\n return str;\n};\nconst cookie = {\n create(name, value, minutes, domain) {\n let cookieOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {\n path: '/',\n sameSite: 'strict'\n };\n if (minutes) {\n cookieOptions.expires = new Date();\n cookieOptions.expires.setTime(cookieOptions.expires.getTime() + minutes * 60 * 1000);\n }\n if (domain) cookieOptions.domain = domain;\n document.cookie = serializeCookie(name, value, cookieOptions);\n },\n read(name) {\n const nameEQ = `${name}=`;\n const ca = document.cookie.split(';');\n for (let i = 0; i < ca.length; i++) {\n let c = ca[i];\n while (c.charAt(0) === ' ') c = c.substring(1, c.length);\n if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);\n }\n return null;\n },\n remove(name, domain) {\n this.create(name, '', -1, domain);\n }\n};\nvar cookie$1 = {\n name: 'cookie',\n // Deconstruct the options object and extract the lookupCookie property\n lookup(_ref) {\n let {\n lookupCookie\n } = _ref;\n if (lookupCookie && typeof document !== 'undefined') {\n return cookie.read(lookupCookie) || undefined;\n }\n return undefined;\n },\n // Deconstruct the options object and extract the lookupCookie, cookieMinutes, cookieDomain, and cookieOptions properties\n cacheUserLanguage(lng, _ref2) {\n let {\n lookupCookie,\n cookieMinutes,\n cookieDomain,\n cookieOptions\n } = _ref2;\n if (lookupCookie && typeof document !== 'undefined') {\n cookie.create(lookupCookie, lng, cookieMinutes, cookieDomain, cookieOptions);\n }\n }\n};\n\nvar querystring = {\n name: 'querystring',\n // Deconstruct the options object and extract the lookupQuerystring property\n lookup(_ref) {\n let {\n lookupQuerystring\n } = _ref;\n let found;\n if (typeof window !== 'undefined') {\n let {\n search\n } = window.location;\n if (!window.location.search && window.location.hash?.indexOf('?') > -1) {\n search = window.location.hash.substring(window.location.hash.indexOf('?'));\n }\n const query = search.substring(1);\n const params = query.split('&');\n for (let i = 0; i < params.length; i++) {\n const pos = params[i].indexOf('=');\n if (pos > 0) {\n const key = params[i].substring(0, pos);\n if (key === lookupQuerystring) {\n found = params[i].substring(pos + 1);\n }\n }\n }\n }\n return found;\n }\n};\n\nvar hash = {\n name: 'hash',\n // Deconstruct the options object and extract the lookupHash property and the lookupFromHashIndex property\n lookup(_ref) {\n let {\n lookupHash,\n lookupFromHashIndex\n } = _ref;\n let found;\n if (typeof window !== 'undefined') {\n const {\n hash\n } = window.location;\n if (hash && hash.length > 2) {\n const query = hash.substring(1);\n if (lookupHash) {\n const params = query.split('&');\n for (let i = 0; i < params.length; i++) {\n const pos = params[i].indexOf('=');\n if (pos > 0) {\n const key = params[i].substring(0, pos);\n if (key === lookupHash) {\n found = params[i].substring(pos + 1);\n }\n }\n }\n }\n if (found) return found;\n if (!found && lookupFromHashIndex > -1) {\n const language = hash.match(/\\/([a-zA-Z-]*)/g);\n if (!Array.isArray(language)) return undefined;\n const index = typeof lookupFromHashIndex === 'number' ? lookupFromHashIndex : 0;\n return language[index]?.replace('/', '');\n }\n }\n }\n return found;\n }\n};\n\nlet hasLocalStorageSupport = null;\nconst localStorageAvailable = () => {\n if (hasLocalStorageSupport !== null) return hasLocalStorageSupport;\n try {\n hasLocalStorageSupport = typeof window !== 'undefined' && window.localStorage !== null;\n if (!hasLocalStorageSupport) {\n return false;\n }\n const testKey = 'i18next.translate.boo';\n window.localStorage.setItem(testKey, 'foo');\n window.localStorage.removeItem(testKey);\n } catch (e) {\n hasLocalStorageSupport = false;\n }\n return hasLocalStorageSupport;\n};\nvar localStorage = {\n name: 'localStorage',\n // Deconstruct the options object and extract the lookupLocalStorage property\n lookup(_ref) {\n let {\n lookupLocalStorage\n } = _ref;\n if (lookupLocalStorage && localStorageAvailable()) {\n return window.localStorage.getItem(lookupLocalStorage) || undefined; // Undefined ensures type consistency with the previous version of this function\n }\n return undefined;\n },\n // Deconstruct the options object and extract the lookupLocalStorage property\n cacheUserLanguage(lng, _ref2) {\n let {\n lookupLocalStorage\n } = _ref2;\n if (lookupLocalStorage && localStorageAvailable()) {\n window.localStorage.setItem(lookupLocalStorage, lng);\n }\n }\n};\n\nlet hasSessionStorageSupport = null;\nconst sessionStorageAvailable = () => {\n if (hasSessionStorageSupport !== null) return hasSessionStorageSupport;\n try {\n hasSessionStorageSupport = typeof window !== 'undefined' && window.sessionStorage !== null;\n if (!hasSessionStorageSupport) {\n return false;\n }\n const testKey = 'i18next.translate.boo';\n window.sessionStorage.setItem(testKey, 'foo');\n window.sessionStorage.removeItem(testKey);\n } catch (e) {\n hasSessionStorageSupport = false;\n }\n return hasSessionStorageSupport;\n};\nvar sessionStorage = {\n name: 'sessionStorage',\n lookup(_ref) {\n let {\n lookupSessionStorage\n } = _ref;\n if (lookupSessionStorage && sessionStorageAvailable()) {\n return window.sessionStorage.getItem(lookupSessionStorage) || undefined;\n }\n return undefined;\n },\n cacheUserLanguage(lng, _ref2) {\n let {\n lookupSessionStorage\n } = _ref2;\n if (lookupSessionStorage && sessionStorageAvailable()) {\n window.sessionStorage.setItem(lookupSessionStorage, lng);\n }\n }\n};\n\nvar navigator$1 = {\n name: 'navigator',\n lookup(options) {\n const found = [];\n if (typeof navigator !== 'undefined') {\n const {\n languages,\n userLanguage,\n language\n } = navigator;\n if (languages) {\n // chrome only; not an array, so can't use .push.apply instead of iterating\n for (let i = 0; i < languages.length; i++) {\n found.push(languages[i]);\n }\n }\n if (userLanguage) {\n found.push(userLanguage);\n }\n if (language) {\n found.push(language);\n }\n }\n return found.length > 0 ? found : undefined;\n }\n};\n\nvar htmlTag = {\n name: 'htmlTag',\n // Deconstruct the options object and extract the htmlTag property\n lookup(_ref) {\n let {\n htmlTag\n } = _ref;\n let found;\n const internalHtmlTag = htmlTag || (typeof document !== 'undefined' ? document.documentElement : null);\n if (internalHtmlTag && typeof internalHtmlTag.getAttribute === 'function') {\n found = internalHtmlTag.getAttribute('lang');\n }\n return found;\n }\n};\n\nvar path = {\n name: 'path',\n // Deconstruct the options object and extract the lookupFromPathIndex property\n lookup(_ref) {\n let {\n lookupFromPathIndex\n } = _ref;\n if (typeof window === 'undefined') return undefined;\n const language = window.location.pathname.match(/\\/([a-zA-Z-]*)/g);\n if (!Array.isArray(language)) return undefined;\n const index = typeof lookupFromPathIndex === 'number' ? lookupFromPathIndex : 0;\n return language[index]?.replace('/', '');\n }\n};\n\nvar subdomain = {\n name: 'subdomain',\n lookup(_ref) {\n let {\n lookupFromSubdomainIndex\n } = _ref;\n // If given get the subdomain index else 1\n const internalLookupFromSubdomainIndex = typeof lookupFromSubdomainIndex === 'number' ? lookupFromSubdomainIndex + 1 : 1;\n // get all matches if window.location. is existing\n // first item of match is the match itself and the second is the first group match which should be the first subdomain match\n // is the hostname no public domain get the or option of localhost\n const language = typeof window !== 'undefined' && window.location?.hostname?.match(/^(\\w{2,5})\\.(([a-z0-9-]{1,63}\\.[a-z]{2,6})|localhost)/i);\n\n // if there is no match (null) return undefined\n if (!language) return undefined;\n // return the given group match\n return language[internalLookupFromSubdomainIndex];\n }\n};\n\n// some environments, throws when accessing document.cookie\nlet canCookies = false;\ntry {\n // eslint-disable-next-line no-unused-expressions\n document.cookie;\n canCookies = true;\n // eslint-disable-next-line no-empty\n} catch (e) {}\nconst order = ['querystring', 'cookie', 'localStorage', 'sessionStorage', 'navigator', 'htmlTag'];\nif (!canCookies) order.splice(1, 1);\nconst getDefaults = () => ({\n order,\n lookupQuerystring: 'lng',\n lookupCookie: 'i18next',\n lookupLocalStorage: 'i18nextLng',\n lookupSessionStorage: 'i18nextLng',\n // cache user language\n caches: ['localStorage'],\n excludeCacheFor: ['cimode'],\n // cookieMinutes: 10,\n // cookieDomain: 'myDomain'\n\n convertDetectedLanguage: l => l\n});\nclass Browser {\n constructor(services) {\n let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n this.type = 'languageDetector';\n this.detectors = {};\n this.init(services, options);\n }\n init() {\n let services = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {\n languageUtils: {}\n };\n let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n let i18nOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n this.services = services;\n this.options = defaults(options, this.options || {}, getDefaults());\n if (typeof this.options.convertDetectedLanguage === 'string' && this.options.convertDetectedLanguage.indexOf('15897') > -1) {\n this.options.convertDetectedLanguage = l => l.replace('-', '_');\n }\n\n // backwards compatibility\n if (this.options.lookupFromUrlIndex) this.options.lookupFromPathIndex = this.options.lookupFromUrlIndex;\n this.i18nOptions = i18nOptions;\n this.addDetector(cookie$1);\n this.addDetector(querystring);\n this.addDetector(localStorage);\n this.addDetector(sessionStorage);\n this.addDetector(navigator$1);\n this.addDetector(htmlTag);\n this.addDetector(path);\n this.addDetector(subdomain);\n this.addDetector(hash);\n }\n addDetector(detector) {\n this.detectors[detector.name] = detector;\n return this;\n }\n detect() {\n let detectionOrder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.options.order;\n let detected = [];\n detectionOrder.forEach(detectorName => {\n if (this.detectors[detectorName]) {\n let lookup = this.detectors[detectorName].lookup(this.options);\n if (lookup && typeof lookup === 'string') lookup = [lookup];\n if (lookup) detected = detected.concat(lookup);\n }\n });\n detected = detected.filter(d => d !== undefined && d !== null && !hasXSS(d)).map(d => this.options.convertDetectedLanguage(d));\n if (this.services && this.services.languageUtils && this.services.languageUtils.getBestMatchFromCodes) return detected; // new i18next v19.5.0\n return detected.length > 0 ? detected[0] : null; // a little backward compatibility\n }\n cacheUserLanguage(lng) {\n let caches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.options.caches;\n if (!caches) return;\n if (this.options.excludeCacheFor && this.options.excludeCacheFor.indexOf(lng) > -1) return;\n caches.forEach(cacheName => {\n if (this.detectors[cacheName]) this.detectors[cacheName].cacheUserLanguage(lng, this.options);\n });\n }\n}\nBrowser.type = 'languageDetector';\n\nexport { Browser as default };\n","import e from\"void-elements\";var t=/\\s([^'\"/\\s><]+?)[\\s/>]|([^\\s=]+)=\\s?(\".*?\"|'.*?')/g;function n(n){var r={type:\"tag\",name:\"\",voidElement:!1,attrs:{},children:[]},i=n.match(/<\\/?([^\\s]+?)[/\\s>]/);if(i&&(r.name=i[1],(e[i[1]]||\"/\"===n.charAt(n.length-2))&&(r.voidElement=!0),r.name.startsWith(\"!--\"))){var s=n.indexOf(\"--\\x3e\");return{type:\"comment\",comment:-1!==s?n.slice(4,s):\"\"}}for(var a=new RegExp(t),c=null;null!==(c=a.exec(n));)if(c[0].trim())if(c[1]){var o=c[1].trim(),l=[o,\"\"];o.indexOf(\"=\")>-1&&(l=o.split(\"=\")),r.attrs[l[0]]=l[1],a.lastIndex--}else c[2]&&(r.attrs[c[2]]=c[3].trim().substring(1,c[3].length-1));return r}var r=/<[a-zA-Z0-9\\-\\!\\/](?:\"[^\"]*\"|'[^']*'|[^'\">])*>/g,i=/^\\s*$/,s=Object.create(null);function a(e,t){switch(t.type){case\"text\":return e+t.content;case\"tag\":return e+=\"<\"+t.name+(t.attrs?function(e){var t=[];for(var n in e)t.push(n+'=\"'+e[n]+'\"');return t.length?\" \"+t.join(\" \"):\"\"}(t.attrs):\"\")+(t.voidElement?\"/>\":\">\"),t.voidElement?e:e+t.children.reduce(a,\"\")+\"</\"+t.name+\">\";case\"comment\":return e+\"\\x3c!--\"+t.comment+\"--\\x3e\"}}var c={parse:function(e,t){t||(t={}),t.components||(t.components=s);var a,c=[],o=[],l=-1,m=!1;if(0!==e.indexOf(\"<\")){var u=e.indexOf(\"<\");c.push({type:\"text\",content:-1===u?e:e.substring(0,u)})}return e.replace(r,function(r,s){if(m){if(r!==\"</\"+a.name+\">\")return;m=!1}var u,f=\"/\"!==r.charAt(1),h=r.startsWith(\"\\x3c!--\"),p=s+r.length,d=e.charAt(p);if(h){var v=n(r);return l<0?(c.push(v),c):((u=o[l]).children.push(v),c)}if(f&&(l++,\"tag\"===(a=n(r)).type&&t.components[a.name]&&(a.type=\"component\",m=!0),a.voidElement||m||!d||\"<\"===d||a.children.push({type:\"text\",content:e.slice(p,e.indexOf(\"<\",p))}),0===l&&c.push(a),(u=o[l-1])&&u.children.push(a),o[l]=a),(!f||a.voidElement)&&(l>-1&&(a.voidElement||a.name===r.slice(2,-1))&&(l--,a=-1===l?c:o[l]),!m&&\"<\"!==d&&d)){u=-1===l?c:o[l].children;var x=e.indexOf(\"<\",p),g=e.slice(p,-1===x?void 0:x);i.test(g)&&(g=\" \"),(x>-1&&l+u.length>=0||\" \"!==g)&&u.push({type:\"text\",content:g})}}),c},stringify:function(e){return e.reduce(function(e,t){return e+a(\"\",t)},\"\")}};export default c;\n//# sourceMappingURL=html-parse-stringify.module.js.map\n","export const warn = (i18n, code, msg, rest) => {\n const args = [msg, {\n code,\n ...(rest || {})\n }];\n if (i18n?.services?.logger?.forward) {\n return i18n.services.logger.forward(args, 'warn', 'react-i18next::', true);\n }\n if (isString(args[0])) args[0] = `react-i18next:: ${args[0]}`;\n if (i18n?.services?.logger?.warn) {\n i18n.services.logger.warn(...args);\n } else if (console?.warn) {\n console.warn(...args);\n }\n};\nconst alreadyWarned = {};\nexport const warnOnce = (i18n, code, msg, rest) => {\n if (isString(msg) && alreadyWarned[msg]) return;\n if (isString(msg)) alreadyWarned[msg] = new Date();\n warn(i18n, code, msg, rest);\n};\nconst loadedClb = (i18n, cb) => () => {\n if (i18n.isInitialized) {\n cb();\n } else {\n const initialized = () => {\n setTimeout(() => {\n i18n.off('initialized', initialized);\n }, 0);\n cb();\n };\n i18n.on('initialized', initialized);\n }\n};\nexport const loadNamespaces = (i18n, ns, cb) => {\n i18n.loadNamespaces(ns, loadedClb(i18n, cb));\n};\nexport const loadLanguages = (i18n, lng, ns, cb) => {\n if (isString(ns)) ns = [ns];\n if (i18n.options.preload && i18n.options.preload.indexOf(lng) > -1) return loadNamespaces(i18n, ns, cb);\n ns.forEach(n => {\n if (i18n.options.ns.indexOf(n) < 0) i18n.options.ns.push(n);\n });\n i18n.loadLanguages(lng, loadedClb(i18n, cb));\n};\nexport const hasLoadedNamespace = (ns, i18n, options = {}) => {\n if (!i18n.languages || !i18n.languages.length) {\n warnOnce(i18n, 'NO_LANGUAGES', 'i18n.languages were undefined or empty', {\n languages: i18n.languages\n });\n return true;\n }\n return i18n.hasLoadedNamespace(ns, {\n lng: options.lng,\n precheck: (i18nInstance, loadNotPending) => {\n if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18nInstance.services.backendConnector.backend && i18nInstance.isLanguageChangingTo && !loadNotPending(i18nInstance.isLanguageChangingTo, ns)) return false;\n }\n });\n};\nexport const getDisplayName = Component => Component.displayName || Component.name || (isString(Component) && Component.length > 0 ? Component : 'Unknown');\nexport const isString = obj => typeof obj === 'string';\nexport const isObject = obj => typeof obj === 'object' && obj !== null;","const matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230|#x2F|#47);/g;\nconst htmlEntities = {\n '&amp;': '&',\n '&#38;': '&',\n '&lt;': '<',\n '&#60;': '<',\n '&gt;': '>',\n '&#62;': '>',\n '&apos;': \"'\",\n '&#39;': \"'\",\n '&quot;': '\"',\n '&#34;': '\"',\n '&nbsp;': ' ',\n '&#160;': ' ',\n '&copy;': '©',\n '&#169;': '©',\n '&reg;': '®',\n '&#174;': '®',\n '&hellip;': '…',\n '&#8230;': '…',\n '&#x2F;': '/',\n '&#47;': '/'\n};\nconst unescapeHtmlEntity = m => htmlEntities[m];\nexport const unescape = text => text.replace(matchHtmlEntity, unescapeHtmlEntity);","import { unescape } from './unescape.js';\nlet defaultOptions = {\n bindI18n: 'languageChanged',\n bindI18nStore: '',\n transEmptyNodeValue: '',\n transSupportBasicHtmlNodes: true,\n transWrapTextNodes: '',\n transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],\n useSuspense: true,\n unescape\n};\nexport const setDefaults = (options = {}) => {\n defaultOptions = {\n ...defaultOptions,\n ...options\n };\n};\nexport const getDefaults = () => defaultOptions;","let i18nInstance;\nexport const setI18n = instance => {\n i18nInstance = instance;\n};\nexport const getI18n = () => i18nInstance;","import { Fragment, isValidElement, cloneElement, createElement, Children } from 'react';\nimport HTML from 'html-parse-stringify';\nimport { isObject, isString, warn, warnOnce } from './utils.js';\nimport { getDefaults } from './defaults.js';\nimport { getI18n } from './i18nInstance.js';\nconst hasChildren = (node, checkLength) => {\n if (!node) return false;\n const base = node.props?.children ?? node.children;\n if (checkLength) return base.length > 0;\n return !!base;\n};\nconst getChildren = node => {\n if (!node) return [];\n const children = node.props?.children ?? node.children;\n return node.props?.i18nIsDynamicList ? getAsArray(children) : children;\n};\nconst hasValidReactChildren = children => Array.isArray(children) && children.every(isValidElement);\nconst getAsArray = data => Array.isArray(data) ? data : [data];\nconst mergeProps = (source, target) => {\n const newTarget = {\n ...target\n };\n newTarget.props = Object.assign(source.props, target.props);\n return newTarget;\n};\nexport const nodesToString = (children, i18nOptions, i18n, i18nKey) => {\n if (!children) return '';\n let stringNode = '';\n const childrenArray = getAsArray(children);\n const keepArray = i18nOptions?.transSupportBasicHtmlNodes ? i18nOptions.transKeepBasicHtmlNodesFor ?? [] : [];\n childrenArray.forEach((child, childIndex) => {\n if (isString(child)) {\n stringNode += `${child}`;\n return;\n }\n if (isValidElement(child)) {\n const {\n props,\n type\n } = child;\n const childPropsCount = Object.keys(props).length;\n const shouldKeepChild = keepArray.indexOf(type) > -1;\n const childChildren = props.children;\n if (!childChildren && shouldKeepChild && !childPropsCount) {\n stringNode += `<${type}/>`;\n return;\n }\n if (!childChildren && (!shouldKeepChild || childPropsCount) || props.i18nIsDynamicList) {\n stringNode += `<${childIndex}></${childIndex}>`;\n return;\n }\n if (shouldKeepChild && childPropsCount === 1 && isString(childChildren)) {\n stringNode += `<${type}>${childChildren}</${type}>`;\n return;\n }\n const content = nodesToString(childChildren, i18nOptions, i18n, i18nKey);\n stringNode += `<${childIndex}>${content}</${childIndex}>`;\n return;\n }\n if (child === null) {\n warn(i18n, 'TRANS_NULL_VALUE', `Passed in a null value as child`, {\n i18nKey\n });\n return;\n }\n if (isObject(child)) {\n const {\n format,\n ...clone\n } = child;\n const keys = Object.keys(clone);\n if (keys.length === 1) {\n const value = format ? `${keys[0]}, ${format}` : keys[0];\n stringNode += `{{${value}}}`;\n return;\n }\n warn(i18n, 'TRANS_INVALID_OBJ', `Invalid child - Object should only have keys {{ value, format }} (format is optional).`, {\n i18nKey,\n child\n });\n return;\n }\n warn(i18n, 'TRANS_INVALID_VAR', `Passed in a variable like {number} - pass variables for interpolation as full objects like {{number}}.`, {\n i18nKey,\n child\n });\n });\n return stringNode;\n};\nconst renderNodes = (children, knownComponentsMap, targetString, i18n, i18nOptions, combinedTOpts, shouldUnescape) => {\n if (targetString === '') return [];\n const keepArray = i18nOptions.transKeepBasicHtmlNodesFor || [];\n const emptyChildrenButNeedsHandling = targetString && new RegExp(keepArray.map(keep => `<${keep}`).join('|')).test(targetString);\n if (!children && !knownComponentsMap && !emptyChildrenButNeedsHandling && !shouldUnescape) return [targetString];\n const data = knownComponentsMap ?? {};\n const getData = childs => {\n const childrenArray = getAsArray(childs);\n childrenArray.forEach(child => {\n if (isString(child)) return;\n if (hasChildren(child)) getData(getChildren(child));else if (isObject(child) && !isValidElement(child)) Object.assign(data, child);\n });\n };\n getData(children);\n const ast = HTML.parse(`<0>${targetString}</0>`);\n const opts = {\n ...data,\n ...combinedTOpts\n };\n const renderInner = (child, node, rootReactNode) => {\n const childs = getChildren(child);\n const mappedChildren = mapAST(childs, node.children, rootReactNode);\n return hasValidReactChildren(childs) && mappedChildren.length === 0 || child.props?.i18nIsDynamicList ? childs : mappedChildren;\n };\n const pushTranslatedJSX = (child, inner, mem, i, isVoid) => {\n if (child.dummy) {\n child.children = inner;\n mem.push(cloneElement(child, {\n key: i\n }, isVoid ? undefined : inner));\n } else {\n mem.push(...Children.map([child], c => {\n const props = {\n ...c.props\n };\n delete props.i18nIsDynamicList;\n return createElement(c.type, {\n ...props,\n key: i,\n ref: c.props.ref ?? c.ref\n }, isVoid ? null : inner);\n }));\n }\n };\n const mapAST = (reactNode, astNode, rootReactNode) => {\n const reactNodes = getAsArray(reactNode);\n const astNodes = getAsArray(astNode);\n return astNodes.reduce((mem, node, i) => {\n const translationContent = node.children?.[0]?.content && i18n.services.interpolator.interpolate(node.children[0].content, opts, i18n.language);\n if (node.type === 'tag') {\n let tmp = reactNodes[parseInt(node.name, 10)];\n if (!tmp && knownComponentsMap) tmp = knownComponentsMap[node.name];\n if (rootReactNode.length === 1 && !tmp) tmp = rootReactNode[0][node.name];\n if (!tmp) tmp = {};\n const child = Object.keys(node.attrs).length !== 0 ? mergeProps({\n props: node.attrs\n }, tmp) : tmp;\n const isElement = isValidElement(child);\n const isValidTranslationWithChildren = isElement && hasChildren(node, true) && !node.voidElement;\n const isEmptyTransWithHTML = emptyChildrenButNeedsHandling && isObject(child) && child.dummy && !isElement;\n const isKnownComponent = isObject(knownComponentsMap) && Object.hasOwnProperty.call(knownComponentsMap, node.name);\n if (isString(child)) {\n const value = i18n.services.interpolator.interpolate(child, opts, i18n.language);\n mem.push(value);\n } else if (hasChildren(child) || isValidTranslationWithChildren) {\n const inner = renderInner(child, node, rootReactNode);\n pushTranslatedJSX(child, inner, mem, i);\n } else if (isEmptyTransWithHTML) {\n const inner = mapAST(reactNodes, node.children, rootReactNode);\n pushTranslatedJSX(child, inner, mem, i);\n } else if (Number.isNaN(parseFloat(node.name))) {\n if (isKnownComponent) {\n const inner = renderInner(child, node, rootReactNode);\n pushTranslatedJSX(child, inner, mem, i, node.voidElement);\n } else if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {\n if (node.voidElement) {\n mem.push(createElement(node.name, {\n key: `${node.name}-${i}`\n }));\n } else {\n const inner = mapAST(reactNodes, node.children, rootReactNode);\n mem.push(createElement(node.name, {\n key: `${node.name}-${i}`\n }, inner));\n }\n } else if (node.voidElement) {\n mem.push(`<${node.name} />`);\n } else {\n const inner = mapAST(reactNodes, node.children, rootReactNode);\n mem.push(`<${node.name}>${inner}</${node.name}>`);\n }\n } else if (isObject(child) && !isElement) {\n const content = node.children[0] ? translationContent : null;\n if (content) mem.push(content);\n } else {\n pushTranslatedJSX(child, translationContent, mem, i, node.children.length !== 1 || !translationContent);\n }\n } else if (node.type === 'text') {\n const wrapTextNodes = i18nOptions.transWrapTextNodes;\n const content = shouldUnescape ? i18nOptions.unescape(i18n.services.interpolator.interpolate(node.content, opts, i18n.language)) : i18n.services.interpolator.interpolate(node.content, opts, i18n.language);\n if (wrapTextNodes) {\n mem.push(createElement(wrapTextNodes, {\n key: `${node.name}-${i}`\n }, content));\n } else {\n mem.push(content);\n }\n }\n return mem;\n }, []);\n };\n const result = mapAST([{\n dummy: true,\n children: children || []\n }], ast, getAsArray(children || []));\n return getChildren(result[0]);\n};\nconst fixComponentProps = (component, index, translation) => {\n const componentKey = component.key || index;\n const comp = cloneElement(component, {\n key: componentKey\n });\n if (!comp.props || !comp.props.children || translation.indexOf(`${index}/>`) < 0 && translation.indexOf(`${index} />`) < 0) {\n return comp;\n }\n function Componentized() {\n return createElement(Fragment, null, comp);\n }\n return createElement(Componentized, {\n key: componentKey\n });\n};\nconst generateArrayComponents = (components, translation) => components.map((c, index) => fixComponentProps(c, index, translation));\nconst generateObjectComponents = (components, translation) => {\n const componentMap = {};\n Object.keys(components).forEach(c => {\n Object.assign(componentMap, {\n [c]: fixComponentProps(components[c], c, translation)\n });\n });\n return componentMap;\n};\nconst generateComponents = (components, translation, i18n, i18nKey) => {\n if (!components) return null;\n if (Array.isArray(components)) {\n return generateArrayComponents(components, translation);\n }\n if (isObject(components)) {\n return generateObjectComponents(components, translation);\n }\n warnOnce(i18n, 'TRANS_INVALID_COMPONENTS', `<Trans /> \"components\" prop expects an object or array`, {\n i18nKey\n });\n return null;\n};\nconst isComponentsMap = object => {\n if (!isObject(object)) return false;\n if (Array.isArray(object)) return false;\n return Object.keys(object).reduce((acc, key) => acc && Number.isNaN(Number.parseFloat(key)), true);\n};\nexport function Trans({\n children,\n count,\n parent,\n i18nKey,\n context,\n tOptions = {},\n values,\n defaults,\n components,\n ns,\n i18n: i18nFromProps,\n t: tFromProps,\n shouldUnescape,\n ...additionalProps\n}) {\n const i18n = i18nFromProps || getI18n();\n if (!i18n) {\n warnOnce(i18n, 'NO_I18NEXT_INSTANCE', `Trans: You need to pass in an i18next instance using i18nextReactModule`, {\n i18nKey\n });\n return children;\n }\n const t = tFromProps || i18n.t.bind(i18n) || (k => k);\n const reactI18nextOptions = {\n ...getDefaults(),\n ...i18n.options?.react\n };\n let namespaces = ns || t.ns || i18n.options?.defaultNS;\n namespaces = isString(namespaces) ? [namespaces] : namespaces || ['translation'];\n const nodeAsString = nodesToString(children, reactI18nextOptions, i18n, i18nKey);\n const defaultValue = defaults || nodeAsString || reactI18nextOptions.transEmptyNodeValue || i18nKey;\n const {\n hashTransKey\n } = reactI18nextOptions;\n const key = i18nKey || (hashTransKey ? hashTransKey(nodeAsString || defaultValue) : nodeAsString || defaultValue);\n if (i18n.options?.interpolation?.defaultVariables) {\n values = values && Object.keys(values).length > 0 ? {\n ...values,\n ...i18n.options.interpolation.defaultVariables\n } : {\n ...i18n.options.interpolation.defaultVariables\n };\n }\n const interpolationOverride = values || count !== undefined && !i18n.options?.interpolation?.alwaysFormat || !children ? tOptions.interpolation : {\n interpolation: {\n ...tOptions.interpolation,\n prefix: '#$?',\n suffix: '?$#'\n }\n };\n const combinedTOpts = {\n ...tOptions,\n context: context || tOptions.context,\n count,\n ...values,\n ...interpolationOverride,\n defaultValue,\n ns: namespaces\n };\n const translation = key ? t(key, combinedTOpts) : defaultValue;\n const generatedComponents = generateComponents(components, translation, i18n, i18nKey);\n let indexedChildren = generatedComponents || children;\n let componentsMap = null;\n if (isComponentsMap(generatedComponents)) {\n componentsMap = generatedComponents;\n indexedChildren = children;\n }\n const content = renderNodes(indexedChildren, componentsMap, translation, i18n, reactI18nextOptions, combinedTOpts, shouldUnescape);\n const useAsParent = parent ?? reactI18nextOptions.defaultTransParent;\n return useAsParent ? createElement(useAsParent, additionalProps, content) : content;\n}","import { setDefaults } from './defaults.js';\nimport { setI18n } from './i18nInstance.js';\nexport const initReactI18next = {\n type: '3rdParty',\n init(instance) {\n setDefaults(instance.options.react);\n setI18n(instance);\n }\n};","import { createContext } from 'react';\nimport { getDefaults, setDefaults } from './defaults.js';\nimport { getI18n, setI18n } from './i18nInstance.js';\nimport { initReactI18next } from './initReactI18next.js';\nexport { getDefaults, setDefaults, getI18n, setI18n, initReactI18next };\nexport const I18nContext = createContext();\nexport class ReportNamespaces {\n constructor() {\n this.usedNamespaces = {};\n }\n addUsedNamespaces(namespaces) {\n namespaces.forEach(ns => {\n if (!this.usedNamespaces[ns]) this.usedNamespaces[ns] = true;\n });\n }\n getUsedNamespaces() {\n return Object.keys(this.usedNamespaces);\n }\n}\nexport const composeInitialProps = ForComponent => async ctx => {\n const componentsInitialProps = (await ForComponent.getInitialProps?.(ctx)) ?? {};\n const i18nInitialProps = getInitialProps();\n return {\n ...componentsInitialProps,\n ...i18nInitialProps\n };\n};\nexport const getInitialProps = () => {\n const i18n = getI18n();\n const namespaces = i18n.reportNamespaces?.getUsedNamespaces() ?? [];\n const ret = {};\n const initialI18nStore = {};\n i18n.languages.forEach(l => {\n initialI18nStore[l] = {};\n namespaces.forEach(ns => {\n initialI18nStore[l][ns] = i18n.getResourceBundle(l, ns) || {};\n });\n });\n ret.initialI18nStore = initialI18nStore;\n ret.initialLanguage = i18n.language;\n return ret;\n};","import { useContext } from 'react';\nimport { nodesToString, Trans as TransWithoutContext } from './TransWithoutContext.js';\nimport { getI18n, I18nContext } from './context.js';\nexport { nodesToString };\nexport function Trans({\n children,\n count,\n parent,\n i18nKey,\n context,\n tOptions = {},\n values,\n defaults,\n components,\n ns,\n i18n: i18nFromProps,\n t: tFromProps,\n shouldUnescape,\n ...additionalProps\n}) {\n const {\n i18n: i18nFromContext,\n defaultNS: defaultNSFromContext\n } = useContext(I18nContext) || {};\n const i18n = i18nFromProps || i18nFromContext || getI18n();\n const t = tFromProps || i18n?.t.bind(i18n);\n return TransWithoutContext({\n children,\n count,\n parent,\n i18nKey,\n context,\n tOptions,\n values,\n defaults,\n components,\n ns: ns || t?.ns || defaultNSFromContext || i18n?.options?.defaultNS,\n i18n,\n t: tFromProps,\n shouldUnescape,\n ...additionalProps\n });\n}","import i18n, { InitOptions, ReactOptions, TFunction as I18NextTFunction } from 'i18next';\nimport LanguageDetector, { DetectorOptions } from 'i18next-browser-languagedetector';\n// eslint-disable-next-line no-restricted-imports\nimport { initReactI18next, setDefaults, setI18n, Trans as I18NextTrans, getI18n } from 'react-i18next';\n\nimport { DEFAULT_LANGUAGE, PSEUDO_LOCALE } from './constants';\nimport { initRegionalFormat } from './dates';\nimport { LANGUAGES } from './languages';\nimport { ResourceLoader, Resources, TFunction, TransProps, TransType } from './types';\n\nlet tFunc: I18NextTFunction<string[], undefined> | undefined;\nlet transComponent: TransType;\n\nconst VALID_LANGUAGES = [\n ...LANGUAGES,\n {\n name: 'Pseudo',\n code: PSEUDO_LOCALE,\n },\n];\n\nfunction initTFuncAndTransComponent({ id, ns }: { id?: string; ns?: string[] } = {}) {\n if (id) {\n tFunc = getI18nInstance().getFixedT(null, id);\n transComponent = (props: TransProps) => <I18NextTrans shouldUnescape ns={id} {...props} />;\n return;\n }\n\n tFunc = getI18nInstance().t;\n transComponent = (props: TransProps) => <I18NextTrans shouldUnescape ns={ns} {...props} />;\n}\n\nexport async function loadNamespacedResources(namespace: string, language: string, loaders?: ResourceLoader[]) {\n if (!loaders?.length) {\n return;\n }\n\n const resolvedLanguage = language === PSEUDO_LOCALE ? DEFAULT_LANGUAGE : language;\n\n return Promise.all(\n loaders.map(async (loader) => {\n try {\n const resources = await loader(resolvedLanguage);\n addResourceBundle(resolvedLanguage, namespace, resources);\n } catch (error) {\n console.error(`Error loading resources for namespace ${namespace} and language: ${resolvedLanguage}`, error);\n }\n })\n );\n}\n\n// exported for testing\nexport function initDefaultI18nInstance() {\n // If the resources are not an object, we need to initialize the plugin translations\n if (getI18nInstance().options?.resources && typeof getI18nInstance().options.resources === 'object') {\n return;\n }\n\n const initPromise = getI18nInstance().use(initReactI18next).init({\n resources: {},\n returnEmptyString: false,\n lng: DEFAULT_LANGUAGE, // this should be the locale of the phrases in our source JSX\n });\n initTFuncAndTransComponent();\n return initPromise;\n}\n\n// exported for testing\nexport function initDefaultReactI18nInstance() {\n // If the initReactI18next is not set, we need to set them\n if (getI18n()?.options?.react) {\n return;\n }\n\n const options: ReactOptions = {};\n setDefaults(options);\n setI18n(getI18nInstance());\n}\n\nexport async function initPluginTranslations(id: string, loaders?: ResourceLoader[]) {\n await initDefaultI18nInstance();\n initDefaultReactI18nInstance();\n\n const language = getResolvedLanguage();\n initTFuncAndTransComponent({ id });\n\n await loadNamespacedResources(id, language, loaders);\n\n return { language };\n}\n\nexport function getI18nInstance(): typeof i18n {\n // in Grafana versions < 12.1.0 the i18n instance is exposed through the default export\n // used by plugins that support translations from Grafana >= 11.0.0\n const instance: typeof i18n & { default?: typeof i18n } = i18n;\n if (instance && instance.default) {\n return instance.default;\n }\n\n return instance;\n}\n\ninterface Module {\n type: 'backend';\n}\n\ninterface InitializeI18nOptions {\n ns?: string[];\n language?: string;\n module?: Module;\n}\n\nasync function initTranslations({\n ns,\n language = DEFAULT_LANGUAGE,\n module,\n}: InitializeI18nOptions): Promise<{ language: string | undefined }> {\n const options: InitOptions = {\n // We don't bundle any translations, we load them async\n partialBundledLanguages: true,\n resources: {},\n\n // If translations are empty strings (no translation), fall back to the default value in source code\n returnEmptyString: false,\n\n // Required to ensure that `resolvedLanguage` is set property when an invalid language is passed (such as through 'detect')\n supportedLngs: VALID_LANGUAGES.map((lang) => lang.code),\n fallbackLng: DEFAULT_LANGUAGE,\n\n ns,\n postProcess: [\n // Add pseudo processing even if we aren't necessarily going to use it\n PSEUDO_LOCALE,\n ],\n };\n\n if (language === 'detect') {\n getI18nInstance().use(LanguageDetector);\n const detection: DetectorOptions = { order: ['navigator'], caches: [] };\n options.detection = detection;\n } else {\n options.lng = VALID_LANGUAGES.find((lang) => lang.code === language)?.code ?? undefined;\n }\n\n if (module) {\n getI18nInstance().use(module).use(initReactI18next); // passes i18n down to react-i18next\n } else {\n getI18nInstance().use(initReactI18next); // passes i18n down to react-i18next\n }\n\n if (language === PSEUDO_LOCALE) {\n const { default: Pseudo } = await import('i18next-pseudo');\n getI18nInstance().use(\n new Pseudo({\n languageToPseudo: PSEUDO_LOCALE,\n enabled: true,\n wrapped: true,\n })\n );\n }\n\n await getI18nInstance().init(options);\n\n initTFuncAndTransComponent({ ns });\n\n return {\n language: getResolvedLanguage(),\n };\n}\n\nexport function getLanguage() {\n return getI18nInstance()?.language || DEFAULT_LANGUAGE;\n}\n\nexport function getResolvedLanguage() {\n return getI18nInstance()?.resolvedLanguage || DEFAULT_LANGUAGE;\n}\n\nexport function getNamespaces() {\n return getI18nInstance()?.options.ns;\n}\n\nexport async function changeLanguage(language?: string) {\n const validLanguage = VALID_LANGUAGES.find((lang) => lang.code === language)?.code ?? DEFAULT_LANGUAGE;\n await getI18nInstance().changeLanguage(validLanguage);\n}\n\nexport async function initializeI18n(\n { language, ns, module }: InitializeI18nOptions,\n regionalFormat: string\n): Promise<{ language: string | undefined }> {\n initRegionalFormat(regionalFormat);\n return initTranslations({ language, ns, module });\n}\n\nexport function addResourceBundle(language: string, namespace: string, resources: Resources) {\n getI18nInstance().addResourceBundle(language, namespace, resources, true, false);\n}\n\nexport const t: TFunction = (id: string, defaultMessage: string, values?: Record<string, unknown>) => {\n initDefaultI18nInstance();\n if (!tFunc) {\n if (process.env.NODE_ENV !== 'test') {\n console.warn(\n 't() was called before i18n was initialized. This is probably caused by calling t() in the root module scope, instead of lazily on render'\n );\n }\n\n if (process.env.NODE_ENV === 'development') {\n throw new Error('t() was called before i18n was initialized');\n }\n\n tFunc = getI18nInstance().t;\n }\n\n return tFunc(id, defaultMessage, values);\n};\n\nexport function Trans(props: TransProps) {\n initDefaultI18nInstance();\n const Component = transComponent ?? I18NextTrans;\n return <Component shouldUnescape {...props} />;\n}\n","function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = __WEBPACK_EXTERNAL_MODULE__3059__;","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nmodule.exports = cloneDataView;\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n}());\n\nmodule.exports = baseCreate;\n","import { JsonTree } from '@react-awesome-query-builder/ui';\n\nimport {\n DataFrame,\n DataQuery,\n DataSourceJsonData,\n MetricFindValue,\n SelectableValue,\n TimeRange,\n toOption as toOptionFromData,\n} from '@grafana/data';\nimport { CompletionItemKind, EditorMode, LanguageDefinition } from '@grafana/plugin-ui';\n\nimport { QueryWithDefaults } from './defaults';\nimport {\n QueryEditorFunctionExpression,\n QueryEditorGroupByExpression,\n QueryEditorPropertyExpression,\n} from './expressions';\n\nexport interface SqlQueryForInterpolation {\n dataset?: string;\n alias?: string;\n format?: QueryFormat;\n rawSql?: string;\n refId: string;\n hide?: boolean;\n}\n\nexport interface SQLConnectionLimits {\n maxOpenConns: number;\n maxIdleConns: number;\n maxIdleConnsAuto: boolean;\n connMaxLifetime: number;\n}\n\nexport interface SQLOptions extends SQLConnectionLimits, DataSourceJsonData {\n tlsAuth: boolean;\n tlsAuthWithCACert: boolean;\n timezone: string;\n tlsSkipVerify: boolean;\n user: string;\n database: string;\n url: string;\n timeInterval: string;\n}\n\nexport enum QueryFormat {\n Timeseries = 'time_series',\n Table = 'table',\n}\n\nexport interface SQLQuery extends DataQuery {\n alias?: string;\n format?: QueryFormat;\n rawSql?: string;\n dataset?: string;\n table?: string;\n sql?: SQLExpression;\n editorMode?: EditorMode;\n rawQuery?: boolean;\n}\n\nexport interface NameValue {\n name: string;\n value: string;\n}\n\nexport type SQLFilters = NameValue[];\n\nexport interface SQLExpression {\n columns?: QueryEditorFunctionExpression[];\n whereJsonTree?: JsonTree;\n whereString?: string;\n filters?: SQLFilters;\n groupBy?: QueryEditorGroupByExpression[];\n orderBy?: QueryEditorPropertyExpression;\n orderByDirection?: 'ASC' | 'DESC';\n limit?: number;\n offset?: number;\n}\n\nexport interface TableSchema {\n name?: string;\n schema?: TableFieldSchema[];\n}\n\nexport interface TableFieldSchema {\n name: string;\n description?: string;\n type: string;\n repeated: boolean;\n schema: TableFieldSchema[];\n}\n\nexport interface QueryRowFilter {\n filter: boolean;\n group: boolean;\n order: boolean;\n preview: boolean;\n}\n\nexport const QUERY_FORMAT_OPTIONS = [\n { label: 'Time series', value: QueryFormat.Timeseries },\n { label: 'Table', value: QueryFormat.Table },\n];\n\nconst backWardToOption = (value: string) => ({ label: value, value });\n\nexport const toOption = toOptionFromData ?? backWardToOption;\n\nexport interface ResourceSelectorProps {\n disabled?: boolean;\n className?: string;\n applyDefault?: boolean;\n}\n// React Awesome Query builder field types.\n// These are responsible for rendering the correct UI for the field.\nexport type RAQBFieldTypes = 'text' | 'number' | 'boolean' | 'datetime' | 'date' | 'time';\n\nexport interface SQLSelectableValue extends SelectableValue {\n type?: string;\n raqbFieldType?: RAQBFieldTypes;\n}\n\nexport interface DB {\n init?: (datasourceId?: string) => Promise<boolean>;\n datasets: () => Promise<string[]>;\n tables: (dataset?: string) => Promise<string[]>;\n fields: (query: SQLQuery, order?: boolean) => Promise<SQLSelectableValue[]>;\n validateQuery: (query: SQLQuery, range?: TimeRange) => Promise<ValidationResults>;\n dsID: () => number;\n dispose?: (dsID?: string) => void;\n lookup?: (path?: string) => Promise<Array<{ name: string; completion: string }>>;\n getEditorLanguageDefinition: () => LanguageDefinition;\n toRawSql: (query: SQLQuery) => string;\n functions: () => Func[];\n}\n\nexport interface FuncParameter {\n name: string;\n required?: boolean;\n options?: (query: SQLQuery) => Promise<SelectableValue[]>;\n}\nexport interface Func {\n name: string;\n parameters?: FuncParameter[];\n description?: string;\n}\n\nexport interface QueryEditorProps {\n db: DB;\n query: QueryWithDefaults;\n onChange: (query: SQLQuery) => void;\n range?: TimeRange;\n}\n\nexport interface ValidationResults {\n query: SQLQuery;\n rawSql?: string;\n error: string;\n isError: boolean;\n isValid: boolean;\n statistics?: {\n TotalBytesProcessed: number;\n } | null;\n}\n\nexport interface SqlQueryModel {\n quoteLiteral: (v: string) => string;\n}\n\nexport interface ResponseParser {\n transformMetricFindResponse: (frame: DataFrame) => MetricFindValue[];\n}\n\nexport interface MetaDefinition {\n name: string;\n completion?: string;\n kind: CompletionItemKind;\n}\n\nexport type SQLDialect = 'postgres' | 'influx' | 'other';\n","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _isEmpty = _interopRequireDefault(require(\"lodash/isEmpty\"));\n\nvar _escapeRegExp = _interopRequireDefault(require(\"lodash/escapeRegExp\"));\n\nvar _tokenTypes = _interopRequireDefault(require(\"./tokenTypes\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar Tokenizer =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg\r\n * @param {String[]} cfg.reservedWords Reserved words in SQL\r\n * @param {String[]} cfg.reservedTopLevelWords Words that are set to new line separately\r\n * @param {String[]} cfg.reservedNewlineWords Words that are set to newline\r\n * @param {String[]} cfg.reservedTopLevelWordsNoIndent Words that are top level but have no indentation\r\n * @param {String[]} cfg.stringTypes String types to enable: \"\", '', ``, [], N''\r\n * @param {String[]} cfg.openParens Opening parentheses to enable, like (, [\r\n * @param {String[]} cfg.closeParens Closing parentheses to enable, like ), ]\r\n * @param {String[]} cfg.indexedPlaceholderTypes Prefixes for indexed placeholders, like ?\r\n * @param {String[]} cfg.namedPlaceholderTypes Prefixes for named placeholders, like @ and :\r\n * @param {String[]} cfg.lineCommentTypes Line comments to enable, like # and --\r\n * @param {String[]} cfg.specialWordChars Special chars that can be found inside of words, like @ and #\r\n */\n function Tokenizer(cfg) {\n _classCallCheck(this, Tokenizer);\n\n this.WHITESPACE_REGEX = /^([\\t-\\r \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]+)/;\n this.NUMBER_REGEX = /^((\\x2D[\\t-\\r \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]*)?[0-9]+(\\.[0-9]+)?|0x[0-9A-Fa-f]+|0b[01]+)\\b/;\n this.OPERATOR_REGEX = /^(!=|<>|==|<=|>=|!<|!>|\\|\\||::|\\x2D>>|\\x2D>|~~\\*|~~|!~~\\*|!~~|~\\*|!~\\*|!~|:=|(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]))/;\n this.BLOCK_COMMENT_REGEX = /^(\\/\\*(?:[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?(?:\\*\\/|$))/;\n this.LINE_COMMENT_REGEX = this.createLineCommentRegex(cfg.lineCommentTypes);\n this.RESERVED_TOP_LEVEL_REGEX = this.createReservedWordRegex(cfg.reservedTopLevelWords);\n this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX = this.createReservedWordRegex(cfg.reservedTopLevelWordsNoIndent);\n this.RESERVED_NEWLINE_REGEX = this.createReservedWordRegex(cfg.reservedNewlineWords);\n this.RESERVED_PLAIN_REGEX = this.createReservedWordRegex(cfg.reservedWords);\n this.WORD_REGEX = this.createWordRegex(cfg.specialWordChars);\n this.STRING_REGEX = this.createStringRegex(cfg.stringTypes);\n this.OPEN_PAREN_REGEX = this.createParenRegex(cfg.openParens);\n this.CLOSE_PAREN_REGEX = this.createParenRegex(cfg.closeParens);\n this.INDEXED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.indexedPlaceholderTypes, '[0-9]*');\n this.IDENT_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.namedPlaceholderTypes, '[a-zA-Z0-9._$]+');\n this.STRING_NAMED_PLACEHOLDER_REGEX = this.createPlaceholderRegex(cfg.namedPlaceholderTypes, this.createStringPattern(cfg.stringTypes));\n }\n\n _createClass(Tokenizer, [{\n key: \"createLineCommentRegex\",\n value: function createLineCommentRegex(lineCommentTypes) {\n return new RegExp(\"^((?:\".concat(lineCommentTypes.map(function (c) {\n return (0, _escapeRegExp[\"default\"])(c);\n }).join('|'), \").*?(?:\\r\\n|\\r|\\n|$))\"), 'u');\n }\n }, {\n key: \"createReservedWordRegex\",\n value: function createReservedWordRegex(reservedWords) {\n var reservedWordsPattern = reservedWords.join('|').replace(/ /g, '\\\\s+');\n return new RegExp(\"^(\".concat(reservedWordsPattern, \")\\\\b\"), 'iu');\n }\n }, {\n key: \"createWordRegex\",\n value: function createWordRegex() {\n var specialChars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n return new RegExp(\"^([\\\\p{Alphabetic}\\\\p{Mark}\\\\p{Decimal_Number}\\\\p{Connector_Punctuation}\\\\p{Join_Control}\".concat(specialChars.join(''), \"]+)\"), 'u');\n }\n }, {\n key: \"createStringRegex\",\n value: function createStringRegex(stringTypes) {\n return new RegExp('^(' + this.createStringPattern(stringTypes) + ')', 'u');\n } // This enables the following string patterns:\n // 1. backtick quoted string using `` to escape\n // 2. square bracket quoted string (SQL Server) using ]] to escape\n // 3. double quoted string using \"\" or \\\" to escape\n // 4. single quoted string using '' or \\' to escape\n // 5. national character quoted string using N'' or N\\' to escape\n\n }, {\n key: \"createStringPattern\",\n value: function createStringPattern(stringTypes) {\n var patterns = {\n '``': '((`[^`]*($|`))+)',\n '[]': '((\\\\[[^\\\\]]*($|\\\\]))(\\\\][^\\\\]]*($|\\\\]))*)',\n '\"\"': '((\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*(\"|$))+)',\n \"''\": \"(('[^'\\\\\\\\]*(?:\\\\\\\\.[^'\\\\\\\\]*)*('|$))+)\",\n \"N''\": \"((N'[^N'\\\\\\\\]*(?:\\\\\\\\.[^N'\\\\\\\\]*)*('|$))+)\"\n };\n return stringTypes.map(function (t) {\n return patterns[t];\n }).join('|');\n }\n }, {\n key: \"createParenRegex\",\n value: function createParenRegex(parens) {\n var _this = this;\n\n return new RegExp('^(' + parens.map(function (p) {\n return _this.escapeParen(p);\n }).join('|') + ')', 'iu');\n }\n }, {\n key: \"escapeParen\",\n value: function escapeParen(paren) {\n if (paren.length === 1) {\n // A single punctuation character\n return (0, _escapeRegExp[\"default\"])(paren);\n } else {\n // longer word\n return '\\\\b' + paren + '\\\\b';\n }\n }\n }, {\n key: \"createPlaceholderRegex\",\n value: function createPlaceholderRegex(types, pattern) {\n if ((0, _isEmpty[\"default\"])(types)) {\n return false;\n }\n\n var typesRegex = types.map(_escapeRegExp[\"default\"]).join('|');\n return new RegExp(\"^((?:\".concat(typesRegex, \")(?:\").concat(pattern, \"))\"), 'u');\n }\n /**\r\n * Takes a SQL string and breaks it into tokens.\r\n * Each token is an object with type and value.\r\n *\r\n * @param {String} input The SQL string\r\n * @return {Object[]} tokens An array of tokens.\r\n * @return {String} token.type\r\n * @return {String} token.value\r\n */\n\n }, {\n key: \"tokenize\",\n value: function tokenize(input) {\n if (!input) return [];\n var tokens = [];\n var token; // Keep processing the string until it is empty\n\n while (input.length) {\n // Get the next token and the token type\n token = this.getNextToken(input, token); // Advance the string\n\n input = input.substring(token.value.length);\n tokens.push(token);\n }\n\n return tokens;\n }\n }, {\n key: \"getNextToken\",\n value: function getNextToken(input, previousToken) {\n return this.getWhitespaceToken(input) || this.getCommentToken(input) || this.getStringToken(input) || this.getOpenParenToken(input) || this.getCloseParenToken(input) || this.getPlaceholderToken(input) || this.getNumberToken(input) || this.getReservedWordToken(input, previousToken) || this.getWordToken(input) || this.getOperatorToken(input);\n }\n }, {\n key: \"getWhitespaceToken\",\n value: function getWhitespaceToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].WHITESPACE,\n regex: this.WHITESPACE_REGEX\n });\n }\n }, {\n key: \"getCommentToken\",\n value: function getCommentToken(input) {\n return this.getLineCommentToken(input) || this.getBlockCommentToken(input);\n }\n }, {\n key: \"getLineCommentToken\",\n value: function getLineCommentToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].LINE_COMMENT,\n regex: this.LINE_COMMENT_REGEX\n });\n }\n }, {\n key: \"getBlockCommentToken\",\n value: function getBlockCommentToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].BLOCK_COMMENT,\n regex: this.BLOCK_COMMENT_REGEX\n });\n }\n }, {\n key: \"getStringToken\",\n value: function getStringToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].STRING,\n regex: this.STRING_REGEX\n });\n }\n }, {\n key: \"getOpenParenToken\",\n value: function getOpenParenToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].OPEN_PAREN,\n regex: this.OPEN_PAREN_REGEX\n });\n }\n }, {\n key: \"getCloseParenToken\",\n value: function getCloseParenToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].CLOSE_PAREN,\n regex: this.CLOSE_PAREN_REGEX\n });\n }\n }, {\n key: \"getPlaceholderToken\",\n value: function getPlaceholderToken(input) {\n return this.getIdentNamedPlaceholderToken(input) || this.getStringNamedPlaceholderToken(input) || this.getIndexedPlaceholderToken(input);\n }\n }, {\n key: \"getIdentNamedPlaceholderToken\",\n value: function getIdentNamedPlaceholderToken(input) {\n return this.getPlaceholderTokenWithKey({\n input: input,\n regex: this.IDENT_NAMED_PLACEHOLDER_REGEX,\n parseKey: function parseKey(v) {\n return v.slice(1);\n }\n });\n }\n }, {\n key: \"getStringNamedPlaceholderToken\",\n value: function getStringNamedPlaceholderToken(input) {\n var _this2 = this;\n\n return this.getPlaceholderTokenWithKey({\n input: input,\n regex: this.STRING_NAMED_PLACEHOLDER_REGEX,\n parseKey: function parseKey(v) {\n return _this2.getEscapedPlaceholderKey({\n key: v.slice(2, -1),\n quoteChar: v.slice(-1)\n });\n }\n });\n }\n }, {\n key: \"getIndexedPlaceholderToken\",\n value: function getIndexedPlaceholderToken(input) {\n return this.getPlaceholderTokenWithKey({\n input: input,\n regex: this.INDEXED_PLACEHOLDER_REGEX,\n parseKey: function parseKey(v) {\n return v.slice(1);\n }\n });\n }\n }, {\n key: \"getPlaceholderTokenWithKey\",\n value: function getPlaceholderTokenWithKey(_ref) {\n var input = _ref.input,\n regex = _ref.regex,\n parseKey = _ref.parseKey;\n var token = this.getTokenOnFirstMatch({\n input: input,\n regex: regex,\n type: _tokenTypes[\"default\"].PLACEHOLDER\n });\n\n if (token) {\n token.key = parseKey(token.value);\n }\n\n return token;\n }\n }, {\n key: \"getEscapedPlaceholderKey\",\n value: function getEscapedPlaceholderKey(_ref2) {\n var key = _ref2.key,\n quoteChar = _ref2.quoteChar;\n return key.replace(new RegExp((0, _escapeRegExp[\"default\"])('\\\\' + quoteChar), 'gu'), quoteChar);\n } // Decimal, binary, or hex numbers\n\n }, {\n key: \"getNumberToken\",\n value: function getNumberToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].NUMBER,\n regex: this.NUMBER_REGEX\n });\n } // Punctuation and symbols\n\n }, {\n key: \"getOperatorToken\",\n value: function getOperatorToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].OPERATOR,\n regex: this.OPERATOR_REGEX\n });\n }\n }, {\n key: \"getReservedWordToken\",\n value: function getReservedWordToken(input, previousToken) {\n // A reserved word cannot be preceded by a \".\"\n // this makes it so in \"my_table.from\", \"from\" is not considered a reserved word\n if (previousToken && previousToken.value && previousToken.value === '.') {\n return;\n }\n\n return this.getTopLevelReservedToken(input) || this.getNewlineReservedToken(input) || this.getTopLevelReservedTokenNoIndent(input) || this.getPlainReservedToken(input);\n }\n }, {\n key: \"getTopLevelReservedToken\",\n value: function getTopLevelReservedToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].RESERVED_TOP_LEVEL,\n regex: this.RESERVED_TOP_LEVEL_REGEX\n });\n }\n }, {\n key: \"getNewlineReservedToken\",\n value: function getNewlineReservedToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].RESERVED_NEWLINE,\n regex: this.RESERVED_NEWLINE_REGEX\n });\n }\n }, {\n key: \"getTopLevelReservedTokenNoIndent\",\n value: function getTopLevelReservedTokenNoIndent(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].RESERVED_TOP_LEVEL_NO_INDENT,\n regex: this.RESERVED_TOP_LEVEL_NO_INDENT_REGEX\n });\n }\n }, {\n key: \"getPlainReservedToken\",\n value: function getPlainReservedToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].RESERVED,\n regex: this.RESERVED_PLAIN_REGEX\n });\n }\n }, {\n key: \"getWordToken\",\n value: function getWordToken(input) {\n return this.getTokenOnFirstMatch({\n input: input,\n type: _tokenTypes[\"default\"].WORD,\n regex: this.WORD_REGEX\n });\n }\n }, {\n key: \"getTokenOnFirstMatch\",\n value: function getTokenOnFirstMatch(_ref3) {\n var input = _ref3.input,\n type = _ref3.type,\n regex = _ref3.regex;\n var matches = input.match(regex);\n\n if (matches) {\n return {\n type: type,\n value: matches[1]\n };\n }\n }\n }]);\n\n return Tokenizer;\n}();\n\nexports[\"default\"] = Tokenizer;\nmodule.exports = exports.default;","var SqlString = exports;\n\nvar ID_GLOBAL_REGEXP = /`/g;\nvar QUAL_GLOBAL_REGEXP = /\\./g;\nvar CHARS_GLOBAL_REGEXP = /[\\0\\b\\t\\n\\r\\x1a\\\"\\'\\\\]/g; // eslint-disable-line no-control-regex\nvar CHARS_ESCAPE_MAP = {\n '\\0' : '\\\\0',\n '\\b' : '\\\\b',\n '\\t' : '\\\\t',\n '\\n' : '\\\\n',\n '\\r' : '\\\\r',\n '\\x1a' : '\\\\Z',\n '\"' : '\\\\\"',\n '\\'' : '\\\\\\'',\n '\\\\' : '\\\\\\\\'\n};\n\nSqlString.escapeId = function escapeId(val, forbidQualified) {\n if (Array.isArray(val)) {\n var sql = '';\n\n for (var i = 0; i < val.length; i++) {\n sql += (i === 0 ? '' : ', ') + SqlString.escapeId(val[i], forbidQualified);\n }\n\n return sql;\n } else if (forbidQualified) {\n return '`' + String(val).replace(ID_GLOBAL_REGEXP, '``') + '`';\n } else {\n return '`' + String(val).replace(ID_GLOBAL_REGEXP, '``').replace(QUAL_GLOBAL_REGEXP, '`.`') + '`';\n }\n};\n\nSqlString.escape = function escape(val, stringifyObjects, timeZone) {\n if (val === undefined || val === null) {\n return 'NULL';\n }\n\n switch (typeof val) {\n case 'boolean': return (val) ? 'true' : 'false';\n case 'number': return val + '';\n case 'object':\n if (Object.prototype.toString.call(val) === '[object Date]') {\n return SqlString.dateToString(val, timeZone || 'local');\n } else if (Array.isArray(val)) {\n return SqlString.arrayToList(val, timeZone);\n } else if (Buffer.isBuffer(val)) {\n return SqlString.bufferToString(val);\n } else if (typeof val.toSqlString === 'function') {\n return String(val.toSqlString());\n } else if (stringifyObjects) {\n return escapeString(val.toString());\n } else {\n return SqlString.objectToValues(val, timeZone);\n }\n default: return escapeString(val);\n }\n};\n\nSqlString.arrayToList = function arrayToList(array, timeZone) {\n var sql = '';\n\n for (var i = 0; i < array.length; i++) {\n var val = array[i];\n\n if (Array.isArray(val)) {\n sql += (i === 0 ? '' : ', ') + '(' + SqlString.arrayToList(val, timeZone) + ')';\n } else {\n sql += (i === 0 ? '' : ', ') + SqlString.escape(val, true, timeZone);\n }\n }\n\n return sql;\n};\n\nSqlString.format = function format(sql, values, stringifyObjects, timeZone) {\n if (values == null) {\n return sql;\n }\n\n if (!Array.isArray(values)) {\n values = [values];\n }\n\n var chunkIndex = 0;\n var placeholdersRegex = /\\?+/g;\n var result = '';\n var valuesIndex = 0;\n var match;\n\n while (valuesIndex < values.length && (match = placeholdersRegex.exec(sql))) {\n var len = match[0].length;\n\n if (len > 2) {\n continue;\n }\n\n var value = len === 2\n ? SqlString.escapeId(values[valuesIndex])\n : SqlString.escape(values[valuesIndex], stringifyObjects, timeZone);\n\n result += sql.slice(chunkIndex, match.index) + value;\n chunkIndex = placeholdersRegex.lastIndex;\n valuesIndex++;\n }\n\n if (chunkIndex === 0) {\n // Nothing was replaced\n return sql;\n }\n\n if (chunkIndex < sql.length) {\n return result + sql.slice(chunkIndex);\n }\n\n return result;\n};\n\nSqlString.dateToString = function dateToString(date, timeZone) {\n var dt = new Date(date);\n\n if (isNaN(dt.getTime())) {\n return 'NULL';\n }\n\n var year;\n var month;\n var day;\n var hour;\n var minute;\n var second;\n var millisecond;\n\n if (timeZone === 'local') {\n year = dt.getFullYear();\n month = dt.getMonth() + 1;\n day = dt.getDate();\n hour = dt.getHours();\n minute = dt.getMinutes();\n second = dt.getSeconds();\n millisecond = dt.getMilliseconds();\n } else {\n var tz = convertTimezone(timeZone);\n\n if (tz !== false && tz !== 0) {\n dt.setTime(dt.getTime() + (tz * 60000));\n }\n\n year = dt.getUTCFullYear();\n month = dt.getUTCMonth() + 1;\n day = dt.getUTCDate();\n hour = dt.getUTCHours();\n minute = dt.getUTCMinutes();\n second = dt.getUTCSeconds();\n millisecond = dt.getUTCMilliseconds();\n }\n\n // YYYY-MM-DD HH:mm:ss.mmm\n var str = zeroPad(year, 4) + '-' + zeroPad(month, 2) + '-' + zeroPad(day, 2) + ' ' +\n zeroPad(hour, 2) + ':' + zeroPad(minute, 2) + ':' + zeroPad(second, 2) + '.' +\n zeroPad(millisecond, 3);\n\n return escapeString(str);\n};\n\nSqlString.bufferToString = function bufferToString(buffer) {\n return 'X' + escapeString(buffer.toString('hex'));\n};\n\nSqlString.objectToValues = function objectToValues(object, timeZone) {\n var sql = '';\n\n for (var key in object) {\n var val = object[key];\n\n if (typeof val === 'function') {\n continue;\n }\n\n sql += (sql.length === 0 ? '' : ', ') + SqlString.escapeId(key) + ' = ' + SqlString.escape(val, true, timeZone);\n }\n\n return sql;\n};\n\nSqlString.raw = function raw(sql) {\n if (typeof sql !== 'string') {\n throw new TypeError('argument sql must be a string');\n }\n\n return {\n toSqlString: function toSqlString() { return sql; }\n };\n};\n\nfunction escapeString(val) {\n var chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex = 0;\n var escapedVal = '';\n var match;\n\n while ((match = CHARS_GLOBAL_REGEXP.exec(val))) {\n escapedVal += val.slice(chunkIndex, match.index) + CHARS_ESCAPE_MAP[match[0]];\n chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex;\n }\n\n if (chunkIndex === 0) {\n // Nothing was escaped\n return \"'\" + val + \"'\";\n }\n\n if (chunkIndex < val.length) {\n return \"'\" + escapedVal + val.slice(chunkIndex) + \"'\";\n }\n\n return \"'\" + escapedVal + \"'\";\n}\n\nfunction zeroPad(number, length) {\n number = number.toString();\n while (number.length < length) {\n number = '0' + number;\n }\n\n return number;\n}\n\nfunction convertTimezone(tz) {\n if (tz === 'Z') {\n return 0;\n }\n\n var m = tz.match(/([\\+\\-\\s])(\\d\\d):?(\\d\\d)?/);\n if (m) {\n return (m[1] === '-' ? -1 : 1) * (parseInt(m[2], 10) + ((m[3] ? parseInt(m[3], 10) : 0) / 60)) * 60;\n }\n return false;\n}\n","module.exports = __WEBPACK_EXTERNAL_MODULE__3241__;","var baseMatches = require('./_baseMatches'),\n baseMatchesProperty = require('./_baseMatchesProperty'),\n identity = require('./identity'),\n isArray = require('./isArray'),\n property = require('./property');\n\n/**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\nfunction baseIteratee(value) {\n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n if (typeof value == 'function') {\n return value;\n }\n if (value == null) {\n return identity;\n }\n if (typeof value == 'object') {\n return isArray(value)\n ? baseMatchesProperty(value[0], value[1])\n : baseMatches(value);\n }\n return property(value);\n}\n\nmodule.exports = baseIteratee;\n","import { MacroType } from '../types.js';\nimport '@grafana/data';\nimport '@grafana/ui';\n\nconst COLUMN = \"column\", RELATIVE_TIME_STRING = \"'5m'\";\nconst MACROS = [\n {\n id: \"$__timeFilter(dateColumn)\",\n name: \"$__timeFilter(dateColumn)\",\n text: \"$__timeFilter\",\n args: [COLUMN],\n type: MacroType.Filter,\n description: \"Will be replaced by a time range filter using the specified column name. For example, dateColumn BETWEEN FROM_UNIXTIME(1494410783) AND FROM_UNIXTIME(1494410983)\"\n },\n {\n id: \"$__timeFrom()\",\n name: \"$__timeFrom()\",\n text: \"$__timeFrom\",\n args: [],\n type: MacroType.Filter,\n description: \"Will be replaced by the start of the currently active time selection. For example, FROM_UNIXTIME(1494410783)\"\n },\n {\n id: \"$__timeTo()\",\n name: \"$__timeTo()\",\n text: \"$__timeTo\",\n args: [],\n type: MacroType.Filter,\n description: \"Will be replaced by the end of the currently active time selection. For example, FROM_UNIXTIME(1494410983)\"\n },\n {\n id: \"$__timeGroup(dateColumn, '5m')\",\n name: \"$__timeGroup(dateColumn, '5m')\",\n text: \"$__timeGroup\",\n args: [COLUMN, RELATIVE_TIME_STRING],\n type: MacroType.Value,\n description: \"Will be replaced by an expression usable in GROUP BY clause. For example, *cast(cast(UNIX_TIMESTAMP(dateColumn)/(300) as signed)*300 as signed),*\"\n },\n {\n id: \"$__table\",\n name: \"$__table\",\n text: \"$__table\",\n args: [],\n type: MacroType.Table,\n description: \"Will be replaced by the query table.\"\n },\n {\n id: \"$__column\",\n name: \"$__column\",\n text: \"$__column\",\n args: [],\n type: MacroType.Column,\n description: \"Will be replaced by the query column.\"\n }\n];\n\nexport { MACROS };\n//# sourceMappingURL=macros.js.map\n","import '@grafana/ui';\nimport { OperatorType } from '../types.js';\nimport { MACROS } from './macros.js';\nimport '@grafana/data';\n\nfunction getStandardSQLCompletionProvider(monaco, language) {\n var _a, _b, _c;\n const provider = { triggerCharacters: [\".\", \" \", \"$\", \",\", \"(\", \"'\"] };\n if (language && Array.isArray(language.builtinFunctions)) {\n provider.supportedFunctions = () => language.builtinFunctions.map((f) => ({ id: f, name: f }));\n }\n const operators = [];\n if ((_a = language == null ? undefined : language.comparisonOperators) == null ? undefined : _a.length) {\n operators.push(\n ...language.comparisonOperators.map((f) => ({\n id: f.toLocaleLowerCase(),\n operator: f,\n type: OperatorType.Comparison\n }))\n );\n }\n language.logicalOperators = (_b = language.logicalOperators) != null ? _b : language.operators;\n if ((_c = language == null ? undefined : language.logicalOperators) == null ? undefined : _c.length) {\n operators.push(\n ...language.logicalOperators.map((f) => ({ id: f.toLocaleLowerCase(), operator: f, type: OperatorType.Logical }))\n );\n }\n provider.supportedOperators = () => operators;\n provider.supportedMacros = () => MACROS;\n return provider;\n}\n\nexport { getStandardSQLCompletionProvider };\n//# sourceMappingURL=standardSQLCompletionItemProvider.js.map\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n var length = array.length,\n index = fromIndex + (fromRight ? 1 : -1);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (predicate(array[index], index, array)) {\n return index;\n }\n }\n return -1;\n}\n\nmodule.exports = baseFindIndex;\n","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n}\n\nmodule.exports = equalObjects;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nmodule.exports = assocIndexOf;\n","function _OverloadYield(e, d) {\n this.v = e, this.k = d;\n}\nmodule.exports = _OverloadYield, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import { SelectableValue, toOption } from '@grafana/data';\n\nimport {\n QueryEditorExpressionType,\n QueryEditorFunctionExpression,\n QueryEditorFunctionParameterExpression,\n QueryEditorGroupByExpression,\n QueryEditorPropertyExpression,\n QueryEditorPropertyType,\n} from '../expressions';\nimport { SQLExpression } from '../types';\n\nexport function createSelectClause(sqlColumns: NonNullable<SQLExpression['columns']>): string {\n const columns = sqlColumns.map((c) => {\n let rawColumn = '';\n if (c.name && c.alias) {\n rawColumn += `${c.name}(${c.parameters?.map((p) => `${p.name}`)}) AS ${c.alias}`;\n } else if (c.name) {\n rawColumn += `${c.name}(${c.parameters?.map((p) => `${p.name}`)})`;\n } else if (c.alias) {\n rawColumn += `${c.parameters?.map((p) => `${p.name}`)} AS ${c.alias}`;\n } else {\n rawColumn += `${c.parameters?.map((p) => `${p.name}`)}`;\n }\n return rawColumn;\n });\n return `SELECT ${columns.join(', ')} `;\n}\n\nexport const haveColumns = (columns: SQLExpression['columns']): columns is NonNullable<SQLExpression['columns']> => {\n if (!columns) {\n return false;\n }\n\n const haveColumn = columns.some((c) => c.parameters?.length || c.parameters?.some((p) => p.name));\n const haveFunction = columns.some((c) => c.name);\n return haveColumn || haveFunction;\n};\n\n/**\n * Creates a GroupByExpression for a specified field\n */\nexport function setGroupByField(field?: string): QueryEditorGroupByExpression {\n return {\n type: QueryEditorExpressionType.GroupBy,\n property: {\n type: QueryEditorPropertyType.String,\n name: field,\n },\n };\n}\n\n/**\n * Creates a PropertyExpression for a specified field\n */\nexport function setPropertyField(field?: string): QueryEditorPropertyExpression {\n return {\n type: QueryEditorExpressionType.Property,\n property: {\n type: QueryEditorPropertyType.String,\n name: field,\n },\n };\n}\n\nexport function createFunctionField(functionName?: string): QueryEditorFunctionExpression {\n return {\n type: QueryEditorExpressionType.Function,\n name: functionName,\n parameters: [],\n };\n}\n\n/**\n * Retrieves the column value from a QueryEditorFunctionParameterExpression object.\n *\n * @param column - The QueryEditorFunctionParameterExpression object representing the column.\n * @returns The column value as a SelectableValue<string> or null if the column is undefined or null.\n */\nexport function getColumnValue(\n column?: QueryEditorFunctionParameterExpression | QueryEditorFunctionExpression\n): SelectableValue<string> | null {\n if (column?.name) {\n return toOption(column.name);\n }\n return null;\n}\n","var clone = (function() {\n'use strict';\n\nfunction _instanceof(obj, type) {\n return type != null && obj instanceof type;\n}\n\nvar nativeMap;\ntry {\n nativeMap = Map;\n} catch(_) {\n // maybe a reference error because no `Map`. Give it a dummy value that no\n // value will ever be an instanceof.\n nativeMap = function() {};\n}\n\nvar nativeSet;\ntry {\n nativeSet = Set;\n} catch(_) {\n nativeSet = function() {};\n}\n\nvar nativePromise;\ntry {\n nativePromise = Promise;\n} catch(_) {\n nativePromise = function() {};\n}\n\n/**\n * Clones (copies) an Object using deep copying.\n *\n * This function supports circular references by default, but if you are certain\n * there are no circular references in your object, you can save some CPU time\n * by calling clone(obj, false).\n *\n * Caution: if `circular` is false and `parent` contains circular references,\n * your program may enter an infinite loop and crash.\n *\n * @param `parent` - the object to be cloned\n * @param `circular` - set to true if the object to be cloned may contain\n * circular references. (optional - true by default)\n * @param `depth` - set to a number if the object is only to be cloned to\n * a particular depth. (optional - defaults to Infinity)\n * @param `prototype` - sets the prototype to be used when cloning an object.\n * (optional - defaults to parent prototype).\n * @param `includeNonEnumerable` - set to true if the non-enumerable properties\n * should be cloned as well. Non-enumerable properties on the prototype\n * chain will be ignored. (optional - false by default)\n*/\nfunction clone(parent, circular, depth, prototype, includeNonEnumerable) {\n if (typeof circular === 'object') {\n depth = circular.depth;\n prototype = circular.prototype;\n includeNonEnumerable = circular.includeNonEnumerable;\n circular = circular.circular;\n }\n // maintain two arrays for circular references, where corresponding parents\n // and children have the same index\n var allParents = [];\n var allChildren = [];\n\n var useBuffer = typeof Buffer != 'undefined';\n\n if (typeof circular == 'undefined')\n circular = true;\n\n if (typeof depth == 'undefined')\n depth = Infinity;\n\n // recurse this function so we don't reset allParents and allChildren\n function _clone(parent, depth) {\n // cloning null always returns null\n if (parent === null)\n return null;\n\n if (depth === 0)\n return parent;\n\n var child;\n var proto;\n if (typeof parent != 'object') {\n return parent;\n }\n\n if (_instanceof(parent, nativeMap)) {\n child = new nativeMap();\n } else if (_instanceof(parent, nativeSet)) {\n child = new nativeSet();\n } else if (_instanceof(parent, nativePromise)) {\n child = new nativePromise(function (resolve, reject) {\n parent.then(function(value) {\n resolve(_clone(value, depth - 1));\n }, function(err) {\n reject(_clone(err, depth - 1));\n });\n });\n } else if (clone.__isArray(parent)) {\n child = [];\n } else if (clone.__isRegExp(parent)) {\n child = new RegExp(parent.source, __getRegExpFlags(parent));\n if (parent.lastIndex) child.lastIndex = parent.lastIndex;\n } else if (clone.__isDate(parent)) {\n child = new Date(parent.getTime());\n } else if (useBuffer && Buffer.isBuffer(parent)) {\n if (Buffer.allocUnsafe) {\n // Node.js >= 4.5.0\n child = Buffer.allocUnsafe(parent.length);\n } else {\n // Older Node.js versions\n child = new Buffer(parent.length);\n }\n parent.copy(child);\n return child;\n } else if (_instanceof(parent, Error)) {\n child = Object.create(parent);\n } else {\n if (typeof prototype == 'undefined') {\n proto = Object.getPrototypeOf(parent);\n child = Object.create(proto);\n }\n else {\n child = Object.create(prototype);\n proto = prototype;\n }\n }\n\n if (circular) {\n var index = allParents.indexOf(parent);\n\n if (index != -1) {\n return allChildren[index];\n }\n allParents.push(parent);\n allChildren.push(child);\n }\n\n if (_instanceof(parent, nativeMap)) {\n parent.forEach(function(value, key) {\n var keyChild = _clone(key, depth - 1);\n var valueChild = _clone(value, depth - 1);\n child.set(keyChild, valueChild);\n });\n }\n if (_instanceof(parent, nativeSet)) {\n parent.forEach(function(value) {\n var entryChild = _clone(value, depth - 1);\n child.add(entryChild);\n });\n }\n\n for (var i in parent) {\n var attrs;\n if (proto) {\n attrs = Object.getOwnPropertyDescriptor(proto, i);\n }\n\n if (attrs && attrs.set == null) {\n continue;\n }\n child[i] = _clone(parent[i], depth - 1);\n }\n\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(parent);\n for (var i = 0; i < symbols.length; i++) {\n // Don't need to worry about cloning a symbol because it is a primitive,\n // like a number or string.\n var symbol = symbols[i];\n var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);\n if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {\n continue;\n }\n child[symbol] = _clone(parent[symbol], depth - 1);\n if (!descriptor.enumerable) {\n Object.defineProperty(child, symbol, {\n enumerable: false\n });\n }\n }\n }\n\n if (includeNonEnumerable) {\n var allPropertyNames = Object.getOwnPropertyNames(parent);\n for (var i = 0; i < allPropertyNames.length; i++) {\n var propertyName = allPropertyNames[i];\n var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);\n if (descriptor && descriptor.enumerable) {\n continue;\n }\n child[propertyName] = _clone(parent[propertyName], depth - 1);\n Object.defineProperty(child, propertyName, {\n enumerable: false\n });\n }\n }\n\n return child;\n }\n\n return _clone(parent, depth);\n}\n\n/**\n * Simple flat clone using prototype, accepts only objects, usefull for property\n * override on FLAT configuration object (no nested props).\n *\n * USE WITH CAUTION! This may not behave as you wish if you do not know how this\n * works.\n */\nclone.clonePrototype = function clonePrototype(parent) {\n if (parent === null)\n return null;\n\n var c = function () {};\n c.prototype = parent;\n return new c();\n};\n\n// private utility functions\n\nfunction __objToStr(o) {\n return Object.prototype.toString.call(o);\n}\nclone.__objToStr = __objToStr;\n\nfunction __isDate(o) {\n return typeof o === 'object' && __objToStr(o) === '[object Date]';\n}\nclone.__isDate = __isDate;\n\nfunction __isArray(o) {\n return typeof o === 'object' && __objToStr(o) === '[object Array]';\n}\nclone.__isArray = __isArray;\n\nfunction __isRegExp(o) {\n return typeof o === 'object' && __objToStr(o) === '[object RegExp]';\n}\nclone.__isRegExp = __isRegExp;\n\nfunction __getRegExpFlags(re) {\n var flags = '';\n if (re.global) flags += 'g';\n if (re.ignoreCase) flags += 'i';\n if (re.multiline) flags += 'm';\n return flags;\n}\nclone.__getRegExpFlags = __getRegExpFlags;\n\nreturn clone;\n})();\n\nif (typeof module === 'object' && module.exports) {\n module.exports = clone;\n}\n","var baseClamp = require('./_baseClamp'),\n baseToString = require('./_baseToString'),\n toInteger = require('./toInteger'),\n toString = require('./toString');\n\n/**\n * Checks if `string` starts with the given target string.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {string} [target] The string to search for.\n * @param {number} [position=0] The position to search from.\n * @returns {boolean} Returns `true` if `string` starts with `target`,\n * else `false`.\n * @example\n *\n * _.startsWith('abc', 'a');\n * // => true\n *\n * _.startsWith('abc', 'b');\n * // => false\n *\n * _.startsWith('abc', 'b', 1);\n * // => true\n */\nfunction startsWith(string, target, position) {\n string = toString(string);\n position = position == null\n ? 0\n : baseClamp(toInteger(position), 0, string.length);\n\n target = baseToString(target);\n return string.slice(position, position + target.length) == target;\n}\n\nmodule.exports = startsWith;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n","var eq = require('./eq'),\n isArrayLike = require('./isArrayLike'),\n isIndex = require('./_isIndex'),\n isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\nmodule.exports = isIterateeCall;\n","var regenerator = require(\"./regenerator.js\");\nvar regeneratorAsyncIterator = require(\"./regeneratorAsyncIterator.js\");\nfunction _regeneratorAsyncGen(r, e, t, o, n) {\n return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise);\n}\nmodule.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var baseTrim = require('./_baseTrim'),\n isObject = require('./isObject'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = baseTrim(value);\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","function _OverloadYield(e, d) {\n this.v = e, this.k = d;\n}\nmodule.exports = _OverloadYield, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nmodule.exports = getMapData;\n","var assignValue = require('./_assignValue'),\n castPath = require('./_castPath'),\n isIndex = require('./_isIndex'),\n isObject = require('./isObject'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n}\n\nmodule.exports = baseSet;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nmodule.exports = toSource;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeys = require('./_baseKeys'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeFloor = Math.floor;\n\n/**\n * The base implementation of `_.repeat` which doesn't coerce arguments.\n *\n * @private\n * @param {string} string The string to repeat.\n * @param {number} n The number of times to repeat the string.\n * @returns {string} Returns the repeated string.\n */\nfunction baseRepeat(string, n) {\n var result = '';\n if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n return result;\n }\n // Leverage the exponentiation by squaring algorithm for a faster repeat.\n // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n do {\n if (n % 2) {\n result += string;\n }\n n = nativeFloor(n / 2);\n if (n) {\n string += string;\n }\n } while (n);\n\n return result;\n}\n\nmodule.exports = baseRepeat;\n","import { DataSourcePlugin } from '@grafana/data';\nimport { initPluginTranslations } from '@grafana/i18n';\nimport { SQLQuery, SqlQueryEditorLazy, loadResources as loadSQLResources } from '@grafana/sql';\n\nimport { CheatSheet } from './CheatSheet';\nimport { ConfigurationEditor } from './configuration/ConfigurationEditor';\nimport { MssqlDatasource } from './datasource';\nimport pluginJson from './plugin.json';\nimport { MssqlOptions } from './types';\n\n// don't load plugin translations in test environments\n// we don't use them anyway, and top-level await won't work currently in jest\nif (process.env.NODE_ENV !== 'test') {\n await initPluginTranslations(pluginJson.id, [loadSQLResources]);\n}\n\nexport const plugin = new DataSourcePlugin<MssqlDatasource, SQLQuery, MssqlOptions>(MssqlDatasource)\n .setQueryEditor(SqlQueryEditorLazy)\n .setQueryEditorHelp(CheatSheet)\n .setConfigEditor(ConfigurationEditor);\n","var baseHasIn = require('./_baseHasIn'),\n hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n","var OverloadYield = require(\"./OverloadYield.js\");\nvar regenerator = require(\"./regenerator.js\");\nvar regeneratorAsync = require(\"./regeneratorAsync.js\");\nvar regeneratorAsyncGen = require(\"./regeneratorAsyncGen.js\");\nvar regeneratorAsyncIterator = require(\"./regeneratorAsyncIterator.js\");\nvar regeneratorKeys = require(\"./regeneratorKeys.js\");\nvar regeneratorValues = require(\"./regeneratorValues.js\");\nfunction _regeneratorRuntime() {\n \"use strict\";\n\n var r = regenerator(),\n e = r.m(_regeneratorRuntime),\n t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;\n function n(r) {\n var e = \"function\" == typeof r && r.constructor;\n return !!e && (e === t || \"GeneratorFunction\" === (e.displayName || e.name));\n }\n var o = {\n \"throw\": 1,\n \"return\": 2,\n \"break\": 3,\n \"continue\": 3\n };\n function a(r) {\n var e, t;\n return function (n) {\n e || (e = {\n stop: function stop() {\n return t(n.a, 2);\n },\n \"catch\": function _catch() {\n return n.v;\n },\n abrupt: function abrupt(r, e) {\n return t(n.a, o[r], e);\n },\n delegateYield: function delegateYield(r, o, a) {\n return e.resultName = o, t(n.d, regeneratorValues(r), a);\n },\n finish: function finish(r) {\n return t(n.f, r);\n }\n }, t = function t(r, _t, o) {\n n.p = e.prev, n.n = e.next;\n try {\n return r(_t, o);\n } finally {\n e.next = n.n;\n }\n }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;\n try {\n return r.call(this, e);\n } finally {\n n.p = e.prev, n.n = e.next;\n }\n };\n }\n return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n return {\n wrap: function wrap(e, t, n, o) {\n return r.w(a(e), t, n, o && o.reverse());\n },\n isGeneratorFunction: n,\n mark: r.m,\n awrap: function awrap(r, e) {\n return new OverloadYield(r, e);\n },\n AsyncIterator: regeneratorAsyncIterator,\n async: function async(r, e, t, o, u) {\n return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u);\n },\n keys: regeneratorKeys,\n values: regeneratorValues\n };\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports)();\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import { useState } from 'react';\n\nimport { Input } from '@grafana/ui';\n\ntype NumberInputProps = {\n value: number;\n defaultValue: number;\n onChange: (value: number) => void;\n width: number;\n};\n\nexport function NumberInput({ value, defaultValue, onChange, width }: NumberInputProps) {\n const [isEmpty, setIsEmpty] = useState(false);\n return (\n <Input\n type=\"number\"\n placeholder={String(defaultValue)}\n value={isEmpty ? '' : value}\n onChange={(e) => {\n if (e.currentTarget.value?.trim() === '') {\n setIsEmpty(true);\n onChange(defaultValue);\n } else {\n setIsEmpty(false);\n const newVal = Number(e.currentTarget.value);\n if (!Number.isNaN(newVal)) {\n onChange(newVal);\n }\n }\n }}\n width={width}\n />\n );\n}\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\nmodule.exports = stackDelete;\n","var root = require('./_root'),\n stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nmodule.exports = listCacheDelete;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n}\n\nmodule.exports = safeGet;\n","var baseMerge = require('./_baseMerge'),\n createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n * 'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n * 'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n","var isFunction = require('./isFunction'),\n isMasked = require('./_isMasked'),\n isObject = require('./isObject'),\n toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _Formatter = _interopRequireDefault(require(\"../core/Formatter\"));\n\nvar _Tokenizer = _interopRequireDefault(require(\"../core/Tokenizer\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar reservedWords = ['ABS', 'ACTIVATE', 'ALIAS', 'ALL', 'ALLOCATE', 'ALLOW', 'ALTER', 'ANY', 'ARE', 'ARRAY', 'AS', 'ASC', 'ASENSITIVE', 'ASSOCIATE', 'ASUTIME', 'ASYMMETRIC', 'AT', 'ATOMIC', 'ATTRIBUTES', 'AUDIT', 'AUTHORIZATION', 'AUX', 'AUXILIARY', 'AVG', 'BEFORE', 'BEGIN', 'BETWEEN', 'BIGINT', 'BINARY', 'BLOB', 'BOOLEAN', 'BOTH', 'BUFFERPOOL', 'BY', 'CACHE', 'CALL', 'CALLED', 'CAPTURE', 'CARDINALITY', 'CASCADED', 'CASE', 'CAST', 'CCSID', 'CEIL', 'CEILING', 'CHAR', 'CHARACTER', 'CHARACTER_LENGTH', 'CHAR_LENGTH', 'CHECK', 'CLOB', 'CLONE', 'CLOSE', 'CLUSTER', 'COALESCE', 'COLLATE', 'COLLECT', 'COLLECTION', 'COLLID', 'COLUMN', 'COMMENT', 'COMMIT', 'CONCAT', 'CONDITION', 'CONNECT', 'CONNECTION', 'CONSTRAINT', 'CONTAINS', 'CONTINUE', 'CONVERT', 'CORR', 'CORRESPONDING', 'COUNT', 'COUNT_BIG', 'COVAR_POP', 'COVAR_SAMP', 'CREATE', 'CROSS', 'CUBE', 'CUME_DIST', 'CURRENT', 'CURRENT_DATE', 'CURRENT_DEFAULT_TRANSFORM_GROUP', 'CURRENT_LC_CTYPE', 'CURRENT_PATH', 'CURRENT_ROLE', 'CURRENT_SCHEMA', 'CURRENT_SERVER', 'CURRENT_TIME', 'CURRENT_TIMESTAMP', 'CURRENT_TIMEZONE', 'CURRENT_TRANSFORM_GROUP_FOR_TYPE', 'CURRENT_USER', 'CURSOR', 'CYCLE', 'DATA', 'DATABASE', 'DATAPARTITIONNAME', 'DATAPARTITIONNUM', 'DATE', 'DAY', 'DAYS', 'DB2GENERAL', 'DB2GENRL', 'DB2SQL', 'DBINFO', 'DBPARTITIONNAME', 'DBPARTITIONNUM', 'DEALLOCATE', 'DEC', 'DECIMAL', 'DECLARE', 'DEFAULT', 'DEFAULTS', 'DEFINITION', 'DELETE', 'DENSERANK', 'DENSE_RANK', 'DEREF', 'DESCRIBE', 'DESCRIPTOR', 'DETERMINISTIC', 'DIAGNOSTICS', 'DISABLE', 'DISALLOW', 'DISCONNECT', 'DISTINCT', 'DO', 'DOCUMENT', 'DOUBLE', 'DROP', 'DSSIZE', 'DYNAMIC', 'EACH', 'EDITPROC', 'ELEMENT', 'ELSE', 'ELSEIF', 'ENABLE', 'ENCODING', 'ENCRYPTION', 'END', 'END-EXEC', 'ENDING', 'ERASE', 'ESCAPE', 'EVERY', 'EXCEPTION', 'EXCLUDING', 'EXCLUSIVE', 'EXEC', 'EXECUTE', 'EXISTS', 'EXIT', 'EXP', 'EXPLAIN', 'EXTENDED', 'EXTERNAL', 'EXTRACT', 'FALSE', 'FENCED', 'FETCH', 'FIELDPROC', 'FILE', 'FILTER', 'FINAL', 'FIRST', 'FLOAT', 'FLOOR', 'FOR', 'FOREIGN', 'FREE', 'FULL', 'FUNCTION', 'FUSION', 'GENERAL', 'GENERATED', 'GET', 'GLOBAL', 'GOTO', 'GRANT', 'GRAPHIC', 'GROUP', 'GROUPING', 'HANDLER', 'HASH', 'HASHED_VALUE', 'HINT', 'HOLD', 'HOUR', 'HOURS', 'IDENTITY', 'IF', 'IMMEDIATE', 'IN', 'INCLUDING', 'INCLUSIVE', 'INCREMENT', 'INDEX', 'INDICATOR', 'INDICATORS', 'INF', 'INFINITY', 'INHERIT', 'INNER', 'INOUT', 'INSENSITIVE', 'INSERT', 'INT', 'INTEGER', 'INTEGRITY', 'INTERSECTION', 'INTERVAL', 'INTO', 'IS', 'ISOBID', 'ISOLATION', 'ITERATE', 'JAR', 'JAVA', 'KEEP', 'KEY', 'LABEL', 'LANGUAGE', 'LARGE', 'LATERAL', 'LC_CTYPE', 'LEADING', 'LEAVE', 'LEFT', 'LIKE', 'LINKTYPE', 'LN', 'LOCAL', 'LOCALDATE', 'LOCALE', 'LOCALTIME', 'LOCALTIMESTAMP', 'LOCATOR', 'LOCATORS', 'LOCK', 'LOCKMAX', 'LOCKSIZE', 'LONG', 'LOOP', 'LOWER', 'MAINTAINED', 'MATCH', 'MATERIALIZED', 'MAX', 'MAXVALUE', 'MEMBER', 'MERGE', 'METHOD', 'MICROSECOND', 'MICROSECONDS', 'MIN', 'MINUTE', 'MINUTES', 'MINVALUE', 'MOD', 'MODE', 'MODIFIES', 'MODULE', 'MONTH', 'MONTHS', 'MULTISET', 'NAN', 'NATIONAL', 'NATURAL', 'NCHAR', 'NCLOB', 'NEW', 'NEW_TABLE', 'NEXTVAL', 'NO', 'NOCACHE', 'NOCYCLE', 'NODENAME', 'NODENUMBER', 'NOMAXVALUE', 'NOMINVALUE', 'NONE', 'NOORDER', 'NORMALIZE', 'NORMALIZED', 'NOT', 'NULL', 'NULLIF', 'NULLS', 'NUMERIC', 'NUMPARTS', 'OBID', 'OCTET_LENGTH', 'OF', 'OFFSET', 'OLD', 'OLD_TABLE', 'ON', 'ONLY', 'OPEN', 'OPTIMIZATION', 'OPTIMIZE', 'OPTION', 'ORDER', 'OUT', 'OUTER', 'OVER', 'OVERLAPS', 'OVERLAY', 'OVERRIDING', 'PACKAGE', 'PADDED', 'PAGESIZE', 'PARAMETER', 'PART', 'PARTITION', 'PARTITIONED', 'PARTITIONING', 'PARTITIONS', 'PASSWORD', 'PATH', 'PERCENTILE_CONT', 'PERCENTILE_DISC', 'PERCENT_RANK', 'PIECESIZE', 'PLAN', 'POSITION', 'POWER', 'PRECISION', 'PREPARE', 'PREVVAL', 'PRIMARY', 'PRIQTY', 'PRIVILEGES', 'PROCEDURE', 'PROGRAM', 'PSID', 'PUBLIC', 'QUERY', 'QUERYNO', 'RANGE', 'RANK', 'READ', 'READS', 'REAL', 'RECOVERY', 'RECURSIVE', 'REF', 'REFERENCES', 'REFERENCING', 'REFRESH', 'REGR_AVGX', 'REGR_AVGY', 'REGR_COUNT', 'REGR_INTERCEPT', 'REGR_R2', 'REGR_SLOPE', 'REGR_SXX', 'REGR_SXY', 'REGR_SYY', 'RELEASE', 'RENAME', 'REPEAT', 'RESET', 'RESIGNAL', 'RESTART', 'RESTRICT', 'RESULT', 'RESULT_SET_LOCATOR', 'RETURN', 'RETURNS', 'REVOKE', 'RIGHT', 'ROLE', 'ROLLBACK', 'ROLLUP', 'ROUND_CEILING', 'ROUND_DOWN', 'ROUND_FLOOR', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN', 'ROUND_HALF_UP', 'ROUND_UP', 'ROUTINE', 'ROW', 'ROWNUMBER', 'ROWS', 'ROWSET', 'ROW_NUMBER', 'RRN', 'RUN', 'SAVEPOINT', 'SCHEMA', 'SCOPE', 'SCRATCHPAD', 'SCROLL', 'SEARCH', 'SECOND', 'SECONDS', 'SECQTY', 'SECURITY', 'SENSITIVE', 'SEQUENCE', 'SESSION', 'SESSION_USER', 'SIGNAL', 'SIMILAR', 'SIMPLE', 'SMALLINT', 'SNAN', 'SOME', 'SOURCE', 'SPECIFIC', 'SPECIFICTYPE', 'SQL', 'SQLEXCEPTION', 'SQLID', 'SQLSTATE', 'SQLWARNING', 'SQRT', 'STACKED', 'STANDARD', 'START', 'STARTING', 'STATEMENT', 'STATIC', 'STATMENT', 'STAY', 'STDDEV_POP', 'STDDEV_SAMP', 'STOGROUP', 'STORES', 'STYLE', 'SUBMULTISET', 'SUBSTRING', 'SUM', 'SUMMARY', 'SYMMETRIC', 'SYNONYM', 'SYSFUN', 'SYSIBM', 'SYSPROC', 'SYSTEM', 'SYSTEM_USER', 'TABLE', 'TABLESAMPLE', 'TABLESPACE', 'THEN', 'TIME', 'TIMESTAMP', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE', 'TO', 'TRAILING', 'TRANSACTION', 'TRANSLATE', 'TRANSLATION', 'TREAT', 'TRIGGER', 'TRIM', 'TRUE', 'TRUNCATE', 'TYPE', 'UESCAPE', 'UNDO', 'UNIQUE', 'UNKNOWN', 'UNNEST', 'UNTIL', 'UPPER', 'USAGE', 'USER', 'USING', 'VALIDPROC', 'VALUE', 'VARCHAR', 'VARIABLE', 'VARIANT', 'VARYING', 'VAR_POP', 'VAR_SAMP', 'VCAT', 'VERSION', 'VIEW', 'VOLATILE', 'VOLUMES', 'WHEN', 'WHENEVER', 'WHILE', 'WIDTH_BUCKET', 'WINDOW', 'WITH', 'WITHIN', 'WITHOUT', 'WLM', 'WRITE', 'XMLELEMENT', 'XMLEXISTS', 'XMLNAMESPACES', 'YEAR', 'YEARS'];\nvar reservedTopLevelWords = ['ADD', 'AFTER', 'ALTER COLUMN', 'ALTER TABLE', 'DELETE FROM', 'EXCEPT', 'FETCH FIRST', 'FROM', 'GROUP BY', 'GO', 'HAVING', 'INSERT INTO', 'INTERSECT', 'LIMIT', 'ORDER BY', 'SELECT', 'SET CURRENT SCHEMA', 'SET SCHEMA', 'SET', 'UPDATE', 'VALUES', 'WHERE'];\nvar reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];\nvar reservedNewlineWords = ['AND', 'CROSS JOIN', 'INNER JOIN', 'JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'OR', 'OUTER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN'];\nvar tokenizer;\n\nvar Db2Formatter =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg Different set of configurations\r\n */\n function Db2Formatter(cfg) {\n _classCallCheck(this, Db2Formatter);\n\n this.cfg = cfg;\n }\n /**\r\n * Formats DB2 query to make it easier to read\r\n *\r\n * @param {String} query The DB2 query string\r\n * @return {String} formatted string\r\n */\n\n\n _createClass(Db2Formatter, [{\n key: \"format\",\n value: function format(query) {\n if (!tokenizer) {\n tokenizer = new _Tokenizer[\"default\"]({\n reservedWords: reservedWords,\n reservedTopLevelWords: reservedTopLevelWords,\n reservedNewlineWords: reservedNewlineWords,\n reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,\n stringTypes: [\"\\\"\\\"\", \"''\", '``', '[]'],\n openParens: ['('],\n closeParens: [')'],\n indexedPlaceholderTypes: ['?'],\n namedPlaceholderTypes: [':'],\n lineCommentTypes: ['--'],\n specialWordChars: ['#', '@']\n });\n }\n\n return new _Formatter[\"default\"](this.cfg, tokenizer).format(query);\n }\n }]);\n\n return Db2Formatter;\n}();\n\nexports[\"default\"] = Db2Formatter;\nmodule.exports = exports.default;","var constant = require('./constant'),\n defineProperty = require('./_defineProperty'),\n identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n};\n\nmodule.exports = baseSetToString;\n","var baseIsEqual = require('./_baseIsEqual'),\n get = require('./get'),\n hasIn = require('./hasIn'),\n isKey = require('./_isKey'),\n isStrictComparable = require('./_isStrictComparable'),\n matchesStrictComparable = require('./_matchesStrictComparable'),\n toKey = require('./_toKey');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n if (isKey(path) && isStrictComparable(srcValue)) {\n return matchesStrictComparable(toKey(path), srcValue);\n }\n return function(object) {\n var objValue = get(object, path);\n return (objValue === undefined && objValue === srcValue)\n ? hasIn(object, path)\n : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n };\n}\n\nmodule.exports = baseMatchesProperty;\n","// @ts-ignore\nimport sqlFormatter from 'sql-formatter-plus';\n\nexport function formatSQL(q: string) {\n return sqlFormatter.format(q).replace(/(\\$ \\{ .* \\})|(\\$ __)|(\\$ \\w+)/g, (m: string) => {\n return m.replace(/\\s/g, '');\n });\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","function _regeneratorKeys(e) {\n var n = Object(e),\n r = [];\n for (var t in n) r.unshift(t);\n return function e() {\n for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e;\n return e.done = !0, e;\n };\n}\nmodule.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nmodule.exports = listCacheSet;\n","import React__default from 'react';\nimport { css, cx } from '@emotion/css';\nimport { useTheme2 } from '@grafana/ui';\n\nconst DataSourceDescription = ({ dataSourceName, docsLink, hasRequiredFields = true, className }) => {\n const theme = useTheme2();\n const styles = {\n container: css({\n p: {\n margin: 0\n },\n \"p + p\": {\n marginTop: theme.spacing(2)\n }\n }),\n text: css({\n ...theme.typography.body,\n color: theme.colors.text.secondary,\n a: css({\n color: theme.colors.text.link,\n textDecoration: \"underline\",\n \"&:hover\": {\n textDecoration: \"none\"\n }\n })\n })\n };\n return /* @__PURE__ */ React__default.createElement(\"div\", { className: cx(styles.container, className) }, /* @__PURE__ */ React__default.createElement(\"p\", { className: styles.text }, \"Before you can use the \", dataSourceName, \" data source, you must configure it below or in the config file. For detailed instructions,\", \" \", /* @__PURE__ */ React__default.createElement(\"a\", { href: docsLink, target: \"_blank\", rel: \"noreferrer\" }, \"view the documentation\"), \".\"), hasRequiredFields && /* @__PURE__ */ React__default.createElement(\"p\", { className: styles.text }, /* @__PURE__ */ React__default.createElement(\"i\", null, \"Fields marked with * are required\")));\n};\n\nexport { DataSourceDescription };\n//# sourceMappingURL=DataSourceDescription.js.map\n","import React__default from 'react';\nimport { GenericConfigSection } from './GenericConfigSection.js';\n\nconst ConfigSection = ({ children, ...props }) => {\n return /* @__PURE__ */ React__default.createElement(GenericConfigSection, { ...props, kind: \"section\" }, children);\n};\n\nexport { ConfigSection };\n//# sourceMappingURL=ConfigSection.js.map\n","import { useEffect } from 'react';\nvar useEffectOnce = function (effect) {\n useEffect(effect, []);\n};\nexport default useEffectOnce;\n","import { config } from '@grafana/runtime';\n\nvar AzureCloud = /* @__PURE__ */ ((AzureCloud2) => {\n AzureCloud2[\"Public\"] = \"AzureCloud\";\n AzureCloud2[\"China\"] = \"AzureChinaCloud\";\n AzureCloud2[\"USGovernment\"] = \"AzureUSGovernment\";\n AzureCloud2[\"None\"] = \"\";\n return AzureCloud2;\n})(AzureCloud || {});\nconst predefinedClouds = [\n { name: \"AzureCloud\", displayName: \"Azure\" },\n { name: \"AzureChinaCloud\", displayName: \"Azure China\" },\n { name: \"AzureUSGovernment\", displayName: \"Azure US Government\" }\n];\nfunction getAzureClouds() {\n const settingsEx = config.azure;\n if (Array.isArray(settingsEx.clouds) && settingsEx.clouds.length > 0) {\n return settingsEx.clouds;\n }\n return predefinedClouds;\n}\nfunction getDefaultAzureCloud() {\n return config.azure.cloud || \"AzureCloud\" /* Public */;\n}\nfunction resolveLegacyCloudName(cloudName) {\n if (!cloudName) {\n return void 0;\n }\n switch (cloudName) {\n case \"azuremonitor\":\n return \"AzureCloud\" /* Public */;\n case \"chinaazuremonitor\":\n return \"AzureChinaCloud\" /* China */;\n case \"govazuremonitor\":\n return \"AzureUSGovernment\" /* USGovernment */;\n default:\n throw new Error(`Azure cloud '${cloudName}' is not recognized by datasource.`);\n }\n}\n\nexport { AzureCloud, getAzureClouds, getDefaultAzureCloud, resolveLegacyCloudName };\n//# sourceMappingURL=clouds.js.map\n","function instanceOfAzureCredential(authType, object) {\n if (!object) {\n return false;\n }\n return object.authType === authType;\n}\n\nexport { instanceOfAzureCredential };\n//# sourceMappingURL=AzureCredentials.js.map\n","import { config } from '@grafana/runtime';\nimport { getDefaultAzureCloud } from '../clouds.js';\nimport { instanceOfAzureCredential } from './AzureCredentials.js';\n\nconst concealed = Symbol(\"Concealed client secret\");\nconst concealedLegacy = Symbol(\"Concealed legacy client secret\");\nfunction isCredentialsComplete(credentials, ignoreSecret = false) {\n const authType = credentials.authType;\n switch (authType) {\n case \"msi\":\n case \"workloadidentity\":\n case \"currentuser\":\n return true;\n case \"clientsecret\":\n case \"clientsecret-obo\":\n return !!(credentials.azureCloud && credentials.tenantId && credentials.clientId && // When ignoreSecret is set we consider the credentials complete without checking the secret\n !!(ignoreSecret || credentials.clientSecret));\n case \"ad-password\":\n return !!(credentials.clientId && credentials.password && credentials.userId);\n default:\n throw new Error(`The auth type '${authType}' not supported.`);\n }\n}\nfunction getClientSecret(options) {\n if (!(\"secureJsonFields\" in options) || !options.hasOwnProperty(\"secureJsonFields\")) {\n return void 0;\n }\n if (options.secureJsonFields.azureClientSecret) {\n return concealed;\n } else if (options.secureJsonFields.clientSecret) {\n return concealedLegacy;\n } else {\n const secret = options.secureJsonData?.azureClientSecret;\n return typeof secret === \"string\" && secret.length > 0 ? secret : void 0;\n }\n}\nfunction getAdPassword(options) {\n if (!(\"secureJsonFields\" in options) || !options.hasOwnProperty(\"secureJsonFields\")) {\n return void 0;\n }\n if (options.secureJsonFields.password) {\n return concealed;\n } else {\n const secret = options.secureJsonData?.password;\n return typeof secret === \"string\" && secret.length > 0 ? secret : void 0;\n }\n}\nfunction getDatasourceCredentials(options, oboEnabled) {\n const credentials = options.jsonData.azureCredentials;\n if (!credentials) {\n return void 0;\n }\n const authType = credentials.authType;\n switch (authType) {\n case \"msi\":\n case \"workloadidentity\":\n if (authType === \"msi\" && config.azure.managedIdentityEnabled || authType === \"workloadidentity\" && config.azure.workloadIdentityEnabled) {\n return {\n authType\n };\n } else {\n return void 0;\n }\n case \"clientsecret\":\n case \"clientsecret-obo\":\n if (authType === \"clientsecret-obo\" && !oboEnabled) {\n return void 0;\n }\n return {\n authType,\n azureCloud: credentials.azureCloud || getDefaultAzureCloud(),\n tenantId: credentials.tenantId,\n clientId: credentials.clientId,\n clientSecret: getClientSecret(options)\n };\n case \"ad-password\":\n return {\n authType,\n userId: credentials.userId,\n clientId: credentials.clientId,\n password: getAdPassword(options)\n };\n }\n if (instanceOfAzureCredential(authType, credentials)) {\n if (!config.azure.userIdentityEnabled) {\n return void 0;\n }\n if (instanceOfAzureCredential(\"clientsecret\", credentials.serviceCredentials)) {\n const serviceCredentials = { ...credentials.serviceCredentials, clientSecret: getClientSecret(options) };\n return {\n authType,\n serviceCredentialsEnabled: credentials.serviceCredentialsEnabled,\n serviceCredentials\n };\n }\n return {\n authType,\n serviceCredentialsEnabled: credentials.serviceCredentialsEnabled,\n serviceCredentials: credentials.serviceCredentials\n };\n }\n throw new Error(`The auth type '${authType}' is not supported.`);\n}\nfunction updateDatasourceCredentials(options, credentials, oboEnabled) {\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n azureAuthType: void 0,\n cloudName: void 0,\n tenantId: void 0,\n clientId: void 0\n }\n };\n const authType = credentials.authType;\n switch (authType) {\n case \"msi\":\n case \"workloadidentity\":\n if (authType === \"msi\" && !config.azure.managedIdentityEnabled) {\n throw new Error(\"Managed Identity authentication is not enabled in Grafana config.\");\n }\n if (authType === \"workloadidentity\" && !config.azure.workloadIdentityEnabled) {\n throw new Error(\"Workload Identity authentication is not enabled in Grafana config.\");\n }\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n azureCredentials: {\n authType\n }\n }\n };\n return options;\n case \"clientsecret\":\n case \"clientsecret-obo\":\n if (authType === \"clientsecret-obo\" && !oboEnabled) {\n throw new Error(\"Client Secret OBO authentication is not enabled in Grafana config.\");\n }\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n azureCredentials: {\n authType,\n azureCloud: credentials.azureCloud || getDefaultAzureCloud(),\n tenantId: credentials.tenantId,\n clientId: credentials.clientId\n }\n },\n secureJsonData: {\n ...options.secureJsonData,\n azureClientSecret: typeof credentials.clientSecret === \"string\" && credentials.clientSecret.length > 0 ? credentials.clientSecret : void 0\n },\n secureJsonFields: {\n ...options.secureJsonFields,\n azureClientSecret: credentials.clientSecret === concealed,\n clientSecret: credentials.clientSecret === concealedLegacy\n }\n };\n if (authType === \"clientsecret-obo\") {\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n oauthPassThru: true\n }\n };\n }\n return options;\n case \"ad-password\":\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n azureCredentials: {\n authType: \"ad-password\",\n userId: credentials.userId,\n clientId: credentials.clientId\n }\n },\n secureJsonData: {\n ...options.secureJsonData,\n password: typeof credentials.password === \"string\" && credentials.password.length > 0 ? credentials.password : void 0\n },\n secureJsonFields: {\n ...options.secureJsonFields,\n password: typeof credentials.password === \"symbol\"\n }\n };\n return options;\n }\n if (instanceOfAzureCredential(\"currentuser\", credentials)) {\n if (!config.azure.userIdentityEnabled) {\n throw new Error(\"User Identity authentication is not enabled in Grafana config.\");\n }\n const serviceCredentials = credentials.serviceCredentials;\n let clientSecret;\n if (instanceOfAzureCredential(\"clientsecret\", serviceCredentials)) {\n clientSecret = serviceCredentials.clientSecret;\n delete serviceCredentials.clientSecret;\n }\n options = {\n ...options,\n jsonData: {\n ...options.jsonData,\n azureCredentials: {\n authType: \"currentuser\",\n serviceCredentialsEnabled: credentials.serviceCredentialsEnabled,\n serviceCredentials\n },\n oauthPassThru: true,\n disableGrafanaCache: true\n },\n secureJsonData: {\n ...options.secureJsonData,\n azureClientSecret: typeof clientSecret === \"string\" && clientSecret.length > 0 ? clientSecret : void 0\n },\n secureJsonFields: {\n ...options.secureJsonFields,\n azureClientSecret: clientSecret === concealed,\n clientSecret: clientSecret === concealedLegacy\n }\n };\n return options;\n }\n throw new Error(`The auth type '${authType}' is not supported.`);\n}\nfunction hasCredentials(options) {\n return !!options.jsonData.azureCredentials;\n}\n\nexport { concealed, concealedLegacy, getAdPassword, getClientSecret, getDatasourceCredentials, hasCredentials, isCredentialsComplete, updateDatasourceCredentials };\n//# sourceMappingURL=AzureCredentialsConfig.js.map\n","const ResourceTypes = {\n AnalysisServices: \"microsoft.analysisservices/servers\",\n ApiManagementService: \"microsoft.apimanagement/service\",\n ApplicationGateways: \"microsoft.network/applicationgateways\",\n ApplicationGatewayforContainers: \"microsoft.servicenetworking/trafficcontrollers\",\n ApplicationInsights: \"microsoft.insights/components\",\n AppServiceEnvironments: \"microsoft.web/hostingenvironments\",\n AppServicePlans: \"microsoft.web/serverfarms\",\n AppServices: \"microsoft.web/sites\",\n ArcMachines: \"microsoft.hybridcompute/machines\",\n AutomationAccounts: \"microsoft.automation/automationaccounts\",\n AutonomousDatabases: \"oracle.database/autonomousdatabases\",\n AutoscaleSettings: \"microsoft.insights/autoscalesettings\",\n AzureAD: \"microsoft.aadiam/azureadmetrics\",\n AzureADDomainServices: \"microsoft.aad/domainservices\",\n AzureDatabricks: \"microsoft.databricks/workspaces\",\n AzureBotService: \"microsoft.botservice/botservices\",\n AzureElasticSAN: \"microsoft.elasticsan/elasticsans\",\n AzureResourceManager: \"microsoft.resources/subscriptions\",\n AzureSpringCloud: \"microsoft.appplatform/spring\",\n AzureStackHCI: \"microsoft.azurestackhci/clusters\",\n AzureVMWarePrivateClouds: \"microsoft.avs/privateclouds\",\n AzsResourceMonitor: \"microsoft.azurestackresourcemonitor/storageaccountmonitor\",\n // AzureStack Resource\n BackupVaults: \"microsoft.dataprotection/backupvaults\",\n BareMetalMachine: \"microsoft.networkcloud/baremetalmachines\",\n Bastion: \"microsoft.network/bastionhosts\",\n BatchAccounts: \"microsoft.batch/batchaccounts\",\n BatchAi: \"microsoft.batchai/workspaces\",\n CdnProfile: \"microsoft.cdn/profiles\",\n CdnWafPolicy: \"microsoft.cdn/cdnwebapplicationfirewallpolicies\",\n ClassicCloudServices: \"microsoft.classiccompute/domainnames\",\n CloudServiceExtendedSupport: \"microsoft.compute/cloudservices\",\n ClassicComputeVirtualMachines: \"microsoft.classiccompute/virtualmachines\",\n CloudSimple: \"microsoft.vmwarecloudsimple/virtualmachines\",\n // 3rd party resource\n Cluster: \"microsoft.networkcloud/clusters\",\n ClusterManagers: \"microsoft.networkcloud/clustermanagers\",\n CognitiveServices: \"microsoft.cognitiveservices/accounts\",\n CommunicationsGateways: \"microsoft.voiceservices/communicationsgateways\",\n CodeSigningAccounts: \"microsoft.codesigning/codesigningaccounts\",\n ConfigurationStores: \"microsoft.appconfiguration/configurationstores\",\n Connections: \"microsoft.network/connections\",\n ConnectedVehicle: \"microsoft.connectedvehicle/platformaccounts\",\n ContactProfiles: \"microsoft.orbital/contactprofiles\",\n ContainerApps: \"microsoft.app/containerapps\",\n ContainerAppsEnvironment: \"microsoft.app/managedenvironments\",\n ContainerGroups: \"microsoft.containerinstance/containergroups\",\n ContainerRegistries: \"microsoft.containerregistry/registries\",\n ContainerServicesManaged: \"microsoft.containerservice/managedclusters\",\n CosmosDB: \"microsoft.documentdb/databaseaccounts\",\n CosmosCassandra: \"microsoft.documentdb/cassandraClusters\",\n CosmosMongo: \"microsoft.documentdb/mongoClusters\",\n CustomerInsights: \"microsoft.customerinsights/hubs\",\n CustomMetricUsage: \"microsoft.insights/qos\",\n DataboxEdge: \"microsoft.databoxedge/databoxedgedevices\",\n DataFactories: \"microsoft.datafactory/datafactories\",\n DataFactoriesv2: \"microsoft.datafactory/factories\",\n DataCollectionRules: \"microsoft.insights/datacollectionrules\",\n DataLakeAnalytics: \"microsoft.datalakeanalytics/accounts\",\n DataLakeStore: \"microsoft.datalakestore/accounts\",\n DataShare: \"microsoft.datashare/accounts\",\n DBForMySql: \"microsoft.dbformysql/servers\",\n DeviceProvisioningServices: \"microsoft.devices/provisioningservices\",\n DevCenters: \"microsoft.devcenter/devcenters\",\n Disks: \"microsoft.compute/disks\",\n DNSZones: \"microsoft.network/dnszones\",\n DNSPrivateResolver: \"microsoft.network/dnsresolvers\",\n DNSForwardingRuleset: \"microsoft.network/dnsforwardingrulesets\",\n EnterpriseGraph: \"microsoft.enterpriseknowledgegraph/services\",\n EventGridDomains: \"microsoft.eventgrid/domains\",\n EventGridTopics: \"microsoft.eventgrid/topics\",\n EventGridSystemTopics: \"microsoft.eventgrid/systemtopics\",\n EventHubs: \"microsoft.eventhub/namespaces\",\n EventHubsClusters: \"microsoft.eventhub/clusters\",\n ExpressRouteCircuits: \"microsoft.network/expressroutecircuits\",\n ExpressRouteGateways: \"microsoft.network/expressroutegateways\",\n ExpressRoutePorts: \"microsoft.network/expressrouteports\",\n FabricLocations: \"microsoft.fabric.admin/fabriclocations\",\n // AzureStack Resource\n Firewall: \"microsoft.network/azurefirewalls\",\n FrontDoor: \"microsoft.network/frontdoors\",\n Grafana: \"microsoft.dashboard/grafana\",\n HDInsights: \"microsoft.hdinsight/clusters\",\n IoTCentralApplications: \"microsoft.iotcentral/iotapps\",\n IoTHub: \"microsoft.devices/iothubs\",\n IotSpaces: \"microsoft.iotspaces/graph\",\n KeyVault: \"microsoft.keyvault/vaults\",\n KubernetesArc: \"microsoft.kubernetes/connectedclusters\",\n KustoClusters: \"microsoft.kusto/clusters\",\n Layer2IsolationDomain: \"microsoft.managednetworkfabric/l2isolationdomains\",\n Layer3IsolationDomain: \"microsoft.managednetworkfabric/l3isolationdomains\",\n LoadBalancers: \"microsoft.network/loadbalancers\",\n LogAnalytics: \"microsoft.operationalinsights/workspaces\",\n LogicApps: \"microsoft.logic/workflows\",\n LogicIntegrationServiceEnvironment: \"microsoft.logic/integrationserviceenvironments\",\n MachineLearningServiceWorkspace: \"microsoft.machinelearningservices/workspaces\",\n MariaDB: \"microsoft.dbformariadb/servers\",\n ManagedHsms: \"microsoft.keyvault/managedhsms\",\n ManagedLustre: \"microsoft.storagecache/amlfilesystems\",\n ManagedNetworkFabricNetworkDevices: \"microsoft.managednetworkfabric/networkdevices\",\n MediaServices: \"microsoft.media/mediaservices\",\n MonitorAccounts: \"microsoft.monitor/accounts\",\n MySQLFlexibleServers: \"microsoft.dbformysql/flexibleservers\",\n NatGateway: \"microsoft.network/natgateways\",\n NetworkInterfaces: \"microsoft.network/networkinterfaces\",\n NetworkVirtualAppliances: \"microsoft.network/networkvirtualappliances\",\n NetAppCapacityPools: \"microsoft.netapp/netappaccounts/capacitypools\",\n NetworkWatcher: \"microsoft.network/networkwatchers\",\n NGINXaaS: \"nginx.nginxplus/nginxdeployments\",\n ConnectionMonitor: \"microsoft.network/networkwatchers/connectionmonitors\",\n NotificationHubs: \"microsoft.notificationhubs/namespaces/notificationhubs\",\n OracleExadataVMCluster: \"oracle.database/cloudvmclusters\",\n OracleExadbVMCluster: \"oracle.database/exadbVmClusters\",\n OrbitalL2Connections: \"microsoft.orbital/l2connections\",\n MobileNetworkSite: \"microsoft.mobilenetwork/mobilenetworks/sites\",\n RadioAccessNetwork: \"microsoft.mobilenetwork/radioaccessnetworks\",\n PacketCoreControlPlane: \"microsoft.mobilenetwork/packetcorecontrolplanes\",\n PacketCoreDataPlane: \"microsoft.mobilenetwork/packetcorecontrolplanes/packetcoredataplanes\",\n PeeringServices: \"microsoft.peering/peeringservices\",\n PlayFabTitles: \"microsoft.playfab/titles\",\n PointToSiteVPN: \"microsoft.network/p2svpngateways\",\n PostgreSQLFlexibleServers: \"microsoft.dbforpostgresql/flexibleservers\",\n PostgreSQLServers: \"microsoft.dbforpostgresql/servers\",\n PostgreSQLServersV2: \"microsoft.dbforpostgresql/serversv2\",\n PowerBIDedicatedCapacities: \"microsoft.powerbidedicated/capacities\",\n PrivateEndpoint: \"microsoft.network/privateendpoints\",\n PrivateLinkService: \"microsoft.network/privatelinkservices\",\n ProviderMonitorSettings: \"Microsoft.ProviderHub/providerMonitorSettings\",\n ProvisionedClusters: \"microsoft.hybridcontainerservice/provisionedclusters\",\n PublicIPAddresses: \"microsoft.network/publicipaddresses\",\n PublicIPPrefixes: \"microsoft.network/publicipprefixes\",\n RecoveryServicesVault: \"microsoft.recoveryservices/vaults\",\n RedisCaches: \"microsoft.cache/redis\",\n RedisEnterprise: \"microsoft.cache/redisenterprise\",\n Relay: \"microsoft.relay/namespaces\",\n SearchServices: \"microsoft.search/searchservices\",\n ServerGroups: \"microsoft.dbforpostgresql/servergroupsv2\",\n ServiceBus: \"microsoft.servicebus/namespaces\",\n ServiceFabricMesh: \"microsoft.servicefabricmesh/applications\",\n SignalRService: \"microsoft.signalrservice/signalr\",\n SignalRServiceWebPubSub: \"microsoft.signalrservice/webpubsub\",\n Solutions: \"microsoft.operationsmanagement/solutions\",\n Spacecrafts: \"microsoft.orbital/spacecrafts\",\n SqlManaged: \"microsoft.sql/managedinstances\",\n SqlServersDatabases: \"microsoft.sql/servers/databases\",\n SqlServersElasticPools: \"microsoft.sql/servers/elasticpools\",\n SqlServersElasticJobAgents: \"microsoft.sql/servers/jobagents\",\n StaticSites: \"Microsoft.web/staticSites\",\n Storage: \"microsoft.storage/storageaccounts\",\n StorageAppliance: \"microsoft.networkcloud/storageappliances\",\n StorageCaches: \"microsoft.storagecache/caches\",\n StorageMover: \"microsoft.storagemover/storagemovers\",\n StorageClassic: \"microsoft.classicstorage/storageaccounts\",\n StorageSync: \"microsoft.storagesync/storagesyncservices\",\n StreamAnalyticsJobs: \"microsoft.streamanalytics/streamingjobs\",\n SynapseWorkspace: \"microsoft.synapse/workspaces\",\n TimeseriesInsightsEnvironments: \"microsoft.timeseriesinsights/environments\",\n TrafficManagerProfiles: \"microsoft.network/trafficmanagerprofiles\",\n VirtualHubs: \"microsoft.network/virtualhubs\",\n VirtualMachines: \"microsoft.compute/virtualmachines\",\n VirtualMachinesScaleSets: \"microsoft.compute/virtualmachinescalesets\",\n VirtualNetworkFunctions: \"microsoft.hybridnetwork/virtualnetworkfunctions\",\n VirtualNetworkGateWays: \"microsoft.network/virtualnetworkgateways\",\n VirtualWANs: \"microsoft.network/virtualwans\",\n VPNGateways: \"microsoft.network/vpngateways\",\n WebsitesSlots: \"microsoft.web/sites/slots\",\n WorkerPools: \"microsoft.web/hostingenvironments/workerpools\",\n ActivityLogAlertRules: \"microsoft.insights/activitylogalerts\",\n MetricAlertRules: \"microsoft.insights/metricalerts\",\n LogAlertRules: \"microsoft.insights/scheduledqueryrules\",\n ActionGroups: \"microsoft.insights/actiongroups\",\n AlertProcessingRules: \"microsoft.alertsmanagement/actionrules\",\n SmartAlertRules: \"microsoft.alertsmanagement/smartdetectoralertrules\",\n PrometheusRuleGroups: \"microsoft.alertsmanagement/prometheusrulegroups\"\n};\n\nexport { ResourceTypes };\n//# sourceMappingURL=ResourceTypes.js.map\n","import {\n AzureCredentials,\n AzureDataSourceSettings,\n getDatasourceCredentials,\n getDefaultAzureCloud,\n} from '@grafana/azure-sdk';\nimport { config } from '@grafana/runtime';\n\nexport const getDefaultCredentials = (): AzureCredentials => {\n if (config.azure.managedIdentityEnabled) {\n return { authType: 'msi' };\n } else {\n return { authType: 'clientsecret', azureCloud: getDefaultAzureCloud() };\n }\n};\n\nexport const getCredentials = (dsSettings: AzureDataSourceSettings): AzureCredentials => {\n const credentials = getDatasourceCredentials(dsSettings);\n if (credentials) {\n return credentials;\n }\n\n // If no credentials saved, then return empty credentials\n // of type based on whether the managed identity enabled\n return getDefaultCredentials();\n};\n","import { ChangeEvent } from 'react';\n\nimport { AzureCredentials, AzureAuthType } from '@grafana/azure-sdk';\nimport { SelectableValue } from '@grafana/data';\nimport { Trans, t } from '@grafana/i18n';\nimport { Button, Field, Select, Input } from '@grafana/ui';\n\nexport interface Props {\n managedIdentityEnabled: boolean;\n azureEntraPasswordCredentialsEnabled: boolean;\n credentials: AzureCredentials;\n azureCloudOptions?: SelectableValue[];\n onCredentialsChange: (updatedCredentials: AzureCredentials) => void;\n disabled?: boolean;\n}\n\nexport const AzureCredentialsForm = (props: Props) => {\n const {\n managedIdentityEnabled,\n azureEntraPasswordCredentialsEnabled,\n credentials,\n azureCloudOptions,\n onCredentialsChange,\n disabled,\n } = props;\n\n const onAuthTypeChange = (selected: SelectableValue<AzureAuthType>) => {\n if (onCredentialsChange) {\n const updated: AzureCredentials = {\n ...credentials,\n authType: selected.value || 'msi',\n };\n onCredentialsChange(updated);\n }\n };\n\n const onAzureCloudChange = (selected: SelectableValue<string>) => {\n if (credentials.authType === 'clientsecret') {\n const updated: AzureCredentials = {\n ...credentials,\n azureCloud: selected.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onTenantIdChange = (event: ChangeEvent<HTMLInputElement>) => {\n if (credentials.authType === 'clientsecret') {\n const updated: AzureCredentials = {\n ...credentials,\n tenantId: event.target.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onClientIdChange = (event: ChangeEvent<HTMLInputElement>) => {\n if (credentials.authType === 'clientsecret' || credentials.authType === 'ad-password') {\n const updated: AzureCredentials = {\n ...credentials,\n clientId: event.target.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onClientSecretChange = (event: ChangeEvent<HTMLInputElement>) => {\n if (credentials.authType === 'clientsecret') {\n const updated: AzureCredentials = {\n ...credentials,\n clientSecret: event.target.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onClientSecretReset = () => {\n if (credentials.authType === 'clientsecret') {\n const updated: AzureCredentials = {\n ...credentials,\n clientSecret: '',\n };\n onCredentialsChange(updated);\n }\n };\n\n const onUserIdChange = (event: ChangeEvent<HTMLInputElement>) => {\n if (credentials.authType === 'ad-password') {\n const updated: AzureCredentials = {\n ...credentials,\n userId: event.target.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onPasswordChange = (event: ChangeEvent<HTMLInputElement>) => {\n if (credentials.authType === 'ad-password') {\n const updated: AzureCredentials = {\n ...credentials,\n password: event.target.value,\n };\n onCredentialsChange(updated);\n }\n };\n\n const onPasswordReset = () => {\n if (credentials.authType === 'ad-password') {\n const updated: AzureCredentials = {\n ...credentials,\n password: '',\n };\n onCredentialsChange(updated);\n }\n };\n\n const authTypeOptions: Array<SelectableValue<AzureAuthType>> = [\n {\n value: 'clientsecret',\n label: t('azureauth.azure-credentials-form.auth-options-app-registration', 'App Registration'),\n },\n ];\n if (managedIdentityEnabled) {\n authTypeOptions.push({\n value: 'msi',\n label: t('azureauth.azure-credentials-form.auth-options-managed-identity', 'Managed Identity'),\n });\n }\n if (azureEntraPasswordCredentialsEnabled) {\n authTypeOptions.push({\n value: 'ad-password',\n label: t('azureauth.azure-credentials-form.auth-options-azure-entra', 'Azure Entra Password'),\n });\n }\n\n return (\n <div>\n <Field\n label={t('azureauth.azure-credentials-form.label-authentication', 'Authentication')}\n description={t(\n 'azureauth.azure-credentials-form.description-authentication',\n 'Choose the type of authentication to Azure services'\n )}\n htmlFor=\"authentication-type\"\n >\n <Select\n width={20}\n value={authTypeOptions.find((opt) => opt.value === credentials.authType)}\n options={authTypeOptions}\n onChange={onAuthTypeChange}\n disabled={disabled}\n />\n </Field>\n {credentials.authType === 'clientsecret' && (\n <>\n {azureCloudOptions && (\n <Field\n label={t('azureauth.azure-credentials-form.label-azure-cloud', 'Azure Cloud')}\n htmlFor=\"azure-cloud-type\"\n disabled={disabled}\n >\n <Select\n value={azureCloudOptions.find((opt) => opt.value === credentials.azureCloud)}\n options={azureCloudOptions}\n onChange={onAzureCloudChange}\n isDisabled={disabled}\n inputId=\"azure-cloud-type\"\n aria-label={t('azureauth.azure-credentials-form.aria-label-azure-cloud', 'Azure Cloud')}\n width={20}\n />\n </Field>\n )}\n <Field\n label={t('azureauth.azure-credentials-form.label-tenant-id', 'Directory (tenant) ID')}\n required\n htmlFor=\"tenant-id\"\n invalid={!credentials.tenantId}\n error={t('azureauth.azure-credentials-form.required-tenant-id', 'Tenant ID is required')}\n >\n <Input\n width={45}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\"\n value={credentials.tenantId || ''}\n onChange={onTenantIdChange}\n disabled={disabled}\n aria-label={t('azureauth.azure-credentials-form.aria-label-tenant-id', 'Tenant ID')}\n />\n </Field>\n <Field\n label={t('azureauth.azure-credentials-form.label-client-id', 'Application (client) ID')}\n required\n htmlFor=\"client-id\"\n invalid={!credentials.clientId}\n error={t('azureauth.azure-credentials-form.required-client-id', 'Client ID is required')}\n >\n <Input\n width={45}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\"\n value={credentials.clientId || ''}\n onChange={onClientIdChange}\n disabled={disabled}\n aria-label={t('azureauth.azure-credentials-form.arialabel-client-id', 'Client ID')}\n />\n </Field>\n {!disabled &&\n (typeof credentials.clientSecret === 'symbol' ? (\n <Field\n label={t('azureauth.azure-credentials-form.label-configured-client-secret', 'Client Secret')}\n htmlFor=\"client-secret\"\n required\n >\n <div className=\"width-30\" style={{ display: 'flex', gap: '4px' }}>\n <Input\n aria-label={t(\n 'azureauth.azure-credentials-form.aria-label-configured-client-secret',\n 'Client Secret'\n )}\n placeholder={t(\n 'azureauth.azure-credentials-form.placeholder-configured-client-secret',\n 'configured'\n )}\n disabled={true}\n data-testid={'client-secret'}\n width={45}\n />\n <Button variant=\"secondary\" type=\"button\" onClick={onClientSecretReset} disabled={disabled}>\n <Trans i18nKey=\"azureauth.azure-credentials-form.client-secret-reset\">Reset</Trans>\n </Button>\n </div>\n </Field>\n ) : (\n <Field\n label={t('azureauth.azure-credentials-form.label-client-secret', 'Client Secret')}\n required\n htmlFor=\"client-secret\"\n invalid={!credentials.clientSecret}\n error={t('azureauth.azure-credentials-form.required-client-secret', 'Client secret is required')}\n >\n <Input\n width={45}\n aria-label={t('azureauth.azure-credentials-form.aria-label-client-secret', 'Client Secret')}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\"\n value={credentials.clientSecret || ''}\n onChange={onClientSecretChange}\n id=\"client-secret\"\n disabled={disabled}\n />\n </Field>\n ))}\n </>\n )}\n {credentials.authType === 'ad-password' && azureEntraPasswordCredentialsEnabled && (\n <>\n <Field\n label={t('azureauth.azure-credentials-form.label-user-id', 'User Id')}\n required\n htmlFor=\"user-id\"\n invalid={!credentials.userId}\n error={'User ID is required'}\n >\n <Input\n width={45}\n value={credentials.userId || ''}\n onChange={onUserIdChange}\n disabled={disabled}\n aria-label={t('azureauth.azure-credentials-form.aria-label-user-id', 'User ID')}\n />\n </Field>\n <Field\n label={t('azureauth.azure-credentials-form.label-application-client-id', 'Application Client ID')}\n required\n htmlFor=\"application-client-id\"\n invalid={!credentials.clientId}\n error={t(\n 'azureauth.azure-credentials-form.required-application-client-id',\n 'Application Client ID is required'\n )}\n >\n <Input\n width={45}\n value={credentials.clientId || ''}\n onChange={onClientIdChange}\n disabled={disabled}\n aria-label={t(\n 'azureauth.azure-credentials-form.aria-label-application-client-id',\n 'Application Client ID'\n )}\n />\n </Field>\n {!disabled &&\n (typeof credentials.password === 'symbol' ? (\n <Field\n label={t('azureauth.azure-credentials-form.label-password-configured', 'Password')}\n htmlFor=\"password\"\n required\n >\n <div className=\"width-30\" style={{ display: 'flex', gap: '4px' }}>\n <Input\n aria-label={t('azureauth.azure-credentials-form.aria-label-password-configured', 'Password')}\n placeholder={t('azureauth.azure-credentials-form.placeholder-password-configured', 'configured')}\n disabled={true}\n data-testid={'password'}\n width={45}\n />\n <Button variant=\"secondary\" type=\"button\" onClick={onPasswordReset} disabled={disabled}>\n <Trans i18nKey=\"azureauth.azure-credentials-form.password-reset\">Reset</Trans>\n </Button>\n </div>\n </Field>\n ) : (\n <Field\n label={t('azureauth.azure-credentials-form.label-password', 'Password')}\n required\n htmlFor=\"password\"\n invalid={!credentials.password}\n error={t('azureauth.azure-credentials-form.required-password', 'Password is required')}\n >\n <Input\n width={45}\n aria-label={t('azureauth.azure-credentials-form.aria-label-password', 'Password')}\n value={credentials.password || ''}\n onChange={onPasswordChange}\n id=\"password\"\n disabled={disabled}\n />\n </Field>\n ))}\n </>\n )}\n </div>\n );\n};\n\nexport default AzureCredentialsForm;\n","import { useMemo } from 'react';\nimport { useEffectOnce } from 'react-use';\n\nimport { AzureCredentials, AzureCloud, updateDatasourceCredentials } from '@grafana/azure-sdk';\nimport { SelectableValue } from '@grafana/data';\nimport { config } from '@grafana/runtime';\nimport { HttpSettingsBaseProps } from '@grafana/ui/internal';\n\nimport { getCredentials } from './AzureCredentialsConfig';\nimport { AzureCredentialsForm } from './AzureCredentialsForm';\n\nexport const KnownAzureClouds: Array<SelectableValue<AzureCloud>> = [{ value: AzureCloud.Public, label: 'Azure' }];\n\nexport const AzureAuthSettings = (props: HttpSettingsBaseProps) => {\n const { dataSourceConfig: dsSettings, onChange } = props;\n const managedIdentityEnabled = config.azure.managedIdentityEnabled;\n const azureEntraPasswordCredentialsEnabled = config.azure.azureEntraPasswordCredentialsEnabled;\n\n const credentials = useMemo(() => getCredentials(dsSettings), [dsSettings]);\n\n const onCredentialsChange = (credentials: AzureCredentials): void => {\n onChange(updateDatasourceCredentials(dsSettings, credentials));\n };\n\n // The auth type needs to be set on the first load of the data source\n useEffectOnce(() => {\n if (!dsSettings.jsonData.authType) {\n onCredentialsChange(credentials);\n }\n });\n\n return (\n <AzureCredentialsForm\n managedIdentityEnabled={managedIdentityEnabled}\n azureEntraPasswordCredentialsEnabled={azureEntraPasswordCredentialsEnabled}\n credentials={credentials}\n azureCloudOptions={KnownAzureClouds}\n onCredentialsChange={onCredentialsChange}\n disabled={dsSettings.readOnly}\n />\n );\n};\n\nexport default AzureAuthSettings;\n","import { AzureCredentials } from '@grafana/azure-sdk';\nimport { SQLOptions } from '@grafana/sql';\nimport { HttpSettingsBaseProps } from '@grafana/ui/internal';\n\nexport enum MSSQLAuthenticationType {\n sqlAuth = 'SQL Server Authentication',\n windowsAuth = 'Windows Authentication',\n azureAuth = 'Azure AD Authentication',\n kerberosRaw = 'Windows AD: Username + password',\n kerberosKeytab = 'Windows AD: Keytab',\n kerberosCredentialCache = 'Windows AD: Credential cache',\n kerberosCredentialCacheLookupFile = 'Windows AD: Credential cache file',\n}\n\nexport enum MSSQLEncryptOptions {\n disable = 'disable',\n false = 'false',\n true = 'true',\n}\nexport interface MssqlOptions extends SQLOptions {\n authenticationType?: MSSQLAuthenticationType;\n encrypt?: MSSQLEncryptOptions;\n sslRootCertFile?: string;\n serverName?: string;\n connectionTimeout?: number;\n azureCredentials?: AzureCredentials;\n keytabFilePath?: string;\n credentialCache?: string;\n credentialCacheLookupFile?: string;\n configFilePath?: string;\n UDPConnectionLimit?: number;\n enableDNSLookupKDC?: string;\n}\n\nexport interface MssqlSecureOptions {\n password?: string;\n}\n\nexport type AzureAuthConfigType = {\n azureAuthIsSupported: boolean;\n azureAuthSettingsUI: (props: HttpSettingsBaseProps) => JSX.Element;\n};\n","import { SyntheticEvent } from 'react';\n\nimport { DataSourcePluginOptionsEditorProps, updateDatasourcePluginJsonDataOption } from '@grafana/data';\nimport { Trans, t } from '@grafana/i18n';\nimport { ConfigSubSection } from '@grafana/plugin-ui';\nimport { FieldSet, Input, Field, TextLink } from '@grafana/ui';\n\nimport { MSSQLAuthenticationType, MssqlOptions } from '../types';\n\nexport const UsernameMessage = (\n <span>\n <Trans i18nKey=\"configuration.kerberos.username-message\">\n Use the format <code>user@EXAMPLE.COM</code>. Realm is derived from the username.\n </Trans>\n </span>\n);\n\nexport const KerberosConfig = (props: DataSourcePluginOptionsEditorProps<MssqlOptions>) => {\n const { options: settings, onOptionsChange } = props;\n\n const jsonData = settings.jsonData;\n const LONG_WIDTH = 40;\n\n const keytabFilePath = jsonData?.keytabFilePath;\n const credentialCache = jsonData?.credentialCache;\n const credentialCacheLookupFile = jsonData?.credentialCacheLookupFile;\n\n const onKeytabFileChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'keytabFilePath', event.currentTarget.value);\n };\n\n const onCredentialCacheChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'credentialCache', event.currentTarget.value);\n };\n\n const onCredentialCacheFileChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'credentialCacheLookupFile', event.currentTarget.value);\n };\n\n return (\n <>\n {jsonData.authenticationType === MSSQLAuthenticationType.kerberosKeytab && (\n <FieldSet label={t('configuration.kerberos-config.label-keytab', 'Windows AD: Keytab')}>\n <Field\n label={t('configuration.kerberos-config.label-username', 'Username')}\n required\n invalid={!settings.user}\n error={t('configuration.kerberos-config.required-username', 'Username is required')}\n description={UsernameMessage}\n >\n <Input\n value={settings.user || ''}\n placeholder={t('configuration.kerberos-config.placeholder-username', 'name@EXAMPLE.COM')}\n onChange={(e) => onOptionsChange({ ...settings, ...{ ['user']: e.currentTarget.value } })}\n width={LONG_WIDTH}\n />\n </Field>\n <Field\n label={t('configuration.kerberos-config.label-keytab-file-path', 'Keytab file path')}\n required\n invalid={!keytabFilePath}\n error={'Keytab file path is required'}\n >\n <Input\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"/home/grot/grot.keytab\"\n onChange={onKeytabFileChanged}\n width={LONG_WIDTH}\n required\n value={keytabFilePath || ''}\n />\n </Field>\n </FieldSet>\n )}\n\n {jsonData.authenticationType === MSSQLAuthenticationType.kerberosCredentialCache && (\n <FieldSet label={t('configuration.kerberos-config.label-credential-cache', 'Windows AD: Credential cache')}>\n <Field\n label={t('configuration.kerberos-config.label-credential-cache-path', 'Credential cache path')}\n required\n invalid={!credentialCache}\n error={t(\n 'configuration.kerberos-config.required-credential-cache-path',\n 'Credential cache path is required'\n )}\n >\n <Input\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"/tmp/krb5cc_1000\"\n onChange={onCredentialCacheChanged}\n width={LONG_WIDTH}\n value={credentialCache || ''}\n required\n />\n </Field>\n </FieldSet>\n )}\n\n {jsonData.authenticationType === MSSQLAuthenticationType.kerberosCredentialCacheLookupFile && (\n <FieldSet\n label={t('configuration.kerberos-config.label-credential-cache-file', 'Windows AD: Credential cache file')}\n >\n <Field\n label={t('configuration.kerberos-config.label-username', 'Username')}\n required\n invalid={!settings.user}\n error={t('configuration.kerberos-config.required-username', 'Username is required')}\n description={UsernameMessage}\n >\n <Input\n value={settings.user || ''}\n placeholder={t('configuration.kerberos-config.placeholder-username', 'name@EXAMPLE.COM')}\n onChange={(e) => onOptionsChange({ ...settings, ...{ ['user']: e.currentTarget.value } })}\n width={LONG_WIDTH}\n />\n </Field>\n <Field\n label={t('configuration.kerberos-config.label-credential-cache-file-path', 'Credential cache file path')}\n required\n invalid={!credentialCacheLookupFile}\n error={t(\n 'configuration.kerberos-config.required-credential-cache-file-path',\n 'Credential cache file path is required'\n )}\n >\n <Input\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"/home/grot/cache.json\"\n onChange={onCredentialCacheFileChanged}\n width={LONG_WIDTH}\n value={credentialCacheLookupFile || ''}\n required\n />\n </Field>\n </FieldSet>\n )}\n </>\n );\n};\n\nexport const KerberosAdvancedSettings = (props: DataSourcePluginOptionsEditorProps<MssqlOptions>) => {\n const { options: settings } = props;\n\n const jsonData = settings.jsonData;\n const configFilePath = jsonData?.configFilePath;\n const LONG_WIDTH = 40;\n const onUDPLimitChanged = (val: number) => {\n updateDatasourcePluginJsonDataOption(props, 'UDPConnectionLimit', val);\n };\n\n const onDNSLookupKDCChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'enableDNSLookupKDC', event.currentTarget.value);\n };\n\n const onKrbConfigChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'configFilePath', event.currentTarget.value);\n };\n\n return (\n <>\n <ConfigSubSection\n title={t('configuration.kerberos-advanced-settings.title-advanced-settings', 'Windows AD: Advanced Settings')}\n >\n <FieldSet>\n <Field\n label={t('configuration.kerberos-advanced-settings.label-udp-preference-limit', 'UDP Preference Limit')}\n // TODO\n description={\n <span>\n <Trans\n i18nKey=\"configuration.kerberos-advanced-settings.description-udp-preference-limit\"\n values={{ default: '1' }}\n >\n The default is <code>{'{{default}}'}</code> and means always use TCP and is optional.\n </Trans>\n </span>\n }\n >\n <Input\n type=\"text\"\n width={LONG_WIDTH}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"0\"\n defaultValue={jsonData.UDPConnectionLimit}\n onChange={(e) => {\n const val = Number(e.currentTarget.value);\n if (!Number.isNaN(val)) {\n onUDPLimitChanged(val);\n }\n }}\n />\n </Field>\n <Field\n label={t('configuration.kerberos-advanced-settings.label-dns-lookup-kdc', 'DNS Lookup KDC')}\n description={\n <span>\n <Trans\n i18nKey=\"configuration.kerberos-advanced-settings.description-dns-lookup-kdc\"\n values={{ default: 'true' }}\n >\n Indicate whether DNS `SRV` records should be used to locate the KDCs and other servers for a realm.\n The default is <code>{'{{default}}'}</code>.\n </Trans>\n </span>\n }\n >\n <Input\n type=\"text\"\n width={LONG_WIDTH}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"true\"\n defaultValue={jsonData.enableDNSLookupKDC}\n onChange={onDNSLookupKDCChanged}\n />\n </Field>\n <Field\n label={t('configuration.kerberos-advanced-settings.label-krb5-config-file-path', 'krb5 config file path')}\n description={\n <span>\n <Trans\n i18nKey=\"configuration.kerberos-advanced-settings.description-krb5-config-file-path\"\n values={{ default: '/etc/krb5.conf' }}\n >\n The path to the configuration file for the{' '}\n <TextLink external href=\"https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html\">\n MIT krb5 package\n </TextLink>\n . The default is <code>{'{{default}}'}</code>.\n </Trans>\n </span>\n }\n >\n <Input\n onChange={onKrbConfigChanged}\n width={LONG_WIDTH}\n required\n value={configFilePath || '/etc/krb5.conf'}\n />\n </Field>\n </FieldSet>\n </ConfigSubSection>\n </>\n );\n};\n","import { css } from '@emotion/css';\nimport { SyntheticEvent } from 'react';\n\nimport {\n DataSourcePluginOptionsEditorProps,\n GrafanaTheme2,\n onUpdateDatasourceJsonDataOption,\n onUpdateDatasourceSecureJsonDataOption,\n SelectableValue,\n updateDatasourcePluginJsonDataOption,\n updateDatasourcePluginResetOption,\n} from '@grafana/data';\nimport { Trans, t } from '@grafana/i18n';\nimport { ConfigSection, ConfigSubSection, DataSourceDescription } from '@grafana/plugin-ui';\nimport { config } from '@grafana/runtime';\nimport { ConnectionLimits, useMigrateDatabaseFields } from '@grafana/sql';\nimport { NumberInput } from '@grafana/sql/src/components/configuration/NumberInput';\nimport {\n Alert,\n FieldSet,\n Input,\n TextLink,\n SecretInput,\n Select,\n useStyles2,\n SecureSocksProxySettings,\n Divider,\n Field,\n Switch,\n} from '@grafana/ui';\n\nimport { AzureAuthSettings } from '../azureauth/AzureAuthSettings';\nimport {\n MSSQLAuthenticationType,\n MSSQLEncryptOptions,\n MssqlOptions,\n AzureAuthConfigType,\n MssqlSecureOptions,\n} from '../types';\n\nimport { KerberosConfig, KerberosAdvancedSettings, UsernameMessage } from './Kerberos';\n\nconst LONG_WIDTH = 40;\n\nexport const ConfigurationEditor = (props: DataSourcePluginOptionsEditorProps<MssqlOptions, MssqlSecureOptions>) => {\n useMigrateDatabaseFields(props);\n\n const { options: dsSettings, onOptionsChange } = props;\n\n const styles = useStyles2(getStyles);\n const jsonData = dsSettings.jsonData;\n const azureAuthIsSupported = config.azureAuthEnabled;\n\n const azureAuthSettings: AzureAuthConfigType = {\n azureAuthIsSupported,\n azureAuthSettingsUI: AzureAuthSettings,\n };\n\n const onResetPassword = () => {\n updateDatasourcePluginResetOption(props, 'password');\n };\n\n const onDSOptionChanged = (property: keyof MssqlOptions) => {\n return (event: SyntheticEvent<HTMLInputElement>) => {\n onOptionsChange({ ...dsSettings, ...{ [property]: event.currentTarget.value } });\n };\n };\n\n const onSkipTLSVerifyChanged = (event: SyntheticEvent<HTMLInputElement>) => {\n updateDatasourcePluginJsonDataOption(props, 'tlsSkipVerify', event.currentTarget.checked);\n };\n\n const onEncryptChanged = (value: SelectableValue) => {\n updateDatasourcePluginJsonDataOption(props, 'encrypt', value.value);\n };\n\n const onAuthenticationMethodChanged = (value: SelectableValue) => {\n onOptionsChange({\n ...dsSettings,\n ...{\n jsonData: {\n ...jsonData,\n ...{ authenticationType: value.value },\n azureCredentials: undefined,\n keytabFilePath: undefined,\n credentialCache: undefined,\n credentialCacheLookupFile: undefined,\n },\n secureJsonData: { ...dsSettings.secureJsonData, ...{ password: '' } },\n secureJsonFields: { ...dsSettings.secureJsonFields, ...{ password: false } },\n user: '',\n },\n });\n };\n\n const onConnectionTimeoutChanged = (connectionTimeout?: number) => {\n if (connectionTimeout && connectionTimeout < 0) {\n connectionTimeout = 0;\n }\n updateDatasourcePluginJsonDataOption(props, 'connectionTimeout', connectionTimeout);\n };\n\n const buildAuthenticationOptions = (): Array<SelectableValue<MSSQLAuthenticationType>> => {\n const basicAuthenticationOptions: Array<SelectableValue<MSSQLAuthenticationType>> = [\n { value: MSSQLAuthenticationType.sqlAuth, label: 'SQL Server Authentication' },\n { value: MSSQLAuthenticationType.windowsAuth, label: 'Windows Authentication' },\n { value: MSSQLAuthenticationType.kerberosRaw, label: 'Windows AD: Username + password' },\n { value: MSSQLAuthenticationType.kerberosKeytab, label: 'Windows AD: Keytab file' },\n { value: MSSQLAuthenticationType.kerberosCredentialCache, label: 'Windows AD: Credential cache' },\n { value: MSSQLAuthenticationType.kerberosCredentialCacheLookupFile, label: 'Windows AD: Credential cache file' },\n ];\n\n if (azureAuthIsSupported) {\n return [\n ...basicAuthenticationOptions,\n { value: MSSQLAuthenticationType.azureAuth, label: MSSQLAuthenticationType.azureAuth },\n ];\n }\n\n return basicAuthenticationOptions;\n };\n\n const encryptOptions: Array<SelectableValue<string>> = [\n { value: MSSQLEncryptOptions.disable, label: 'disable' },\n { value: MSSQLEncryptOptions.false, label: 'false' },\n { value: MSSQLEncryptOptions.true, label: 'true' },\n ];\n\n return (\n <>\n <DataSourceDescription\n dataSourceName=\"Microsoft SQL Server\"\n docsLink=\"https://grafana.com/docs/grafana/latest/datasources/mssql/\"\n hasRequiredFields\n />\n <Alert title={t('configuration.configuration-editor.title-user-permission', 'User Permission')} severity=\"info\">\n <Trans\n i18nKey=\"configuration.configuration-editor.body-user-permission\"\n values={{ permissionType: 'SELECT', example1: 'USE otherdb;', example2: 'DROP TABLE user;' }}\n >\n The database user should only be granted {'{{permissionType}}'} permissions on the specified database and\n tables you want to query. Grafana does not validate that queries are safe so queries can contain any SQL\n statement. For example, statements like <code>{'{{example1}}'}</code> and <code>{'{{example2}}'}</code> would\n be executed. To protect against this we <em>highly</em> recommend you create a specific MS SQL user with\n restricted permissions. Check out the{' '}\n <TextLink external href=\"http://docs.grafana.org/features/datasources/mssql/\">\n Microsoft SQL Server Data Source Docs\n </TextLink>{' '}\n for more information.\n </Trans>\n </Alert>\n <Divider />\n <ConfigSection title={t('configuration.configuration-editor.title-connection', 'Connection')}>\n <Field\n label={t('configuration.configuration-editor.title-host', 'Host')}\n required\n invalid={!dsSettings.url}\n error={t('configuration.configuration-editor.required-host', 'Host is required')}\n >\n <Input\n width={LONG_WIDTH}\n name=\"host\"\n type=\"text\"\n value={dsSettings.url || ''}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"localhost:1433\"\n onChange={onDSOptionChanged('url')}\n />\n </Field>\n <Field\n label={t('configuration.configuration-editor.title-database', 'Database')}\n required\n invalid={!jsonData.database}\n error={t('configuration.configuration-editor.required-database', 'Database is required')}\n >\n <Input\n width={LONG_WIDTH}\n name=\"database\"\n value={jsonData.database || ''}\n placeholder={t('configuration.configuration-editor.placeholder-database', 'database name')}\n onChange={onUpdateDatasourceJsonDataOption(props, 'database')}\n />\n </Field>\n </ConfigSection>\n\n <ConfigSection title={t('configuration.configuration-editor.title-tls-auth', 'TLS/SSL Auth')}>\n <Field\n htmlFor=\"encrypt\"\n description={\n <>\n <Trans i18nKey=\"configuration.configuration-editor.description-encrypt\">\n Determines whether or to which extent a secure SSL TCP/IP connection will be negotiated with the server.\n </Trans>\n <ul className={styles.ulPadding}>\n <li>\n <Trans\n i18nKey=\"configuration.configuration-editor.description-encrypt-disable\"\n values={{ encryptionValue: 'disable' }}\n >\n <i>{'{{encryptionValue}}'}</i> - Data sent between client and server is not encrypted.\n </Trans>\n </li>\n <li>\n <Trans\n i18nKey=\"configuration.configuration-editor.description-encrypt-false\"\n values={{ encryptionValue: 'false' }}\n >\n <i>{'{{encryptionValue}}'}</i> - Data sent between client and server is not encrypted beyond the\n login packet. (default)\n </Trans>\n </li>\n <li>\n <Trans\n i18nKey=\"configuration.configuration-editor.description-encrypt-true\"\n values={{ encryptionValue: 'true' }}\n >\n <i>{'{{encryptionValue}}'}</i> - Data sent between client and server is encrypted.\n </Trans>\n </li>\n </ul>\n <Trans i18nKey=\"configuration.configuration-editor.description-encrypt-older-version\">\n If you&apos;re using an older version of Microsoft SQL Server like 2008 and 2008R2 you may need to\n disable encryption to be able to connect.\n </Trans>\n </>\n }\n label={t('configuration.configuration-editor.label-encrypt', 'Encrypt')}\n >\n <Select\n options={encryptOptions}\n value={jsonData.encrypt || MSSQLEncryptOptions.false}\n inputId=\"encrypt\"\n onChange={onEncryptChanged}\n width={LONG_WIDTH}\n />\n </Field>\n\n {jsonData.encrypt === MSSQLEncryptOptions.true ? (\n <>\n <Field\n htmlFor=\"skipTlsVerify\"\n label={t('configuration.configuration-editor.label-skip-tls', 'Skip TLS Verify')}\n >\n <Switch id=\"skipTlsVerify\" onChange={onSkipTLSVerifyChanged} value={jsonData.tlsSkipVerify || false} />\n </Field>\n {jsonData.tlsSkipVerify ? null : (\n <>\n <Field\n description={\n <span>\n <Trans i18nKey=\"configuration.configuration-editor.description-tls-cert\">\n Path to file containing the public key certificate of the CA that signed the SQL Server\n certificate. Needed when the server certificate is self signed.\n </Trans>\n </span>\n }\n label={t('configuration.configuration-editor.label-tls-cert', 'TLS/SSL Root Certificate')}\n >\n <Input\n value={jsonData.sslRootCertFile || ''}\n onChange={onUpdateDatasourceJsonDataOption(props, 'sslRootCertFile')}\n placeholder={t(\n 'configuration.configuration-editor.placeholder-tls-cert',\n 'TLS/SSL root certificate file path'\n )}\n width={LONG_WIDTH}\n />\n </Field>\n <Field\n label={t('configuration.configuration-editor.label-common-name', 'Hostname in server certificate')}\n >\n <Input\n placeholder={t(\n 'configuration.configuration-editor.placeholder-common-name',\n 'Common Name (CN) in server certificate'\n )}\n value={jsonData.serverName || ''}\n onChange={onUpdateDatasourceJsonDataOption(props, 'serverName')}\n width={LONG_WIDTH}\n />\n </Field>\n </>\n )}\n </>\n ) : null}\n </ConfigSection>\n\n <ConfigSection title={t('configuration.configuration-editor.title-authentication', 'Authentication')}>\n <Field\n label={t('configuration.configuration-editor.label-auth-type', 'Authentication Type')}\n htmlFor=\"authenticationType\"\n description={\n <ul className={styles.ulPadding}>\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-sql-server\">\n <i>SQL Server Authentication</i> This is the default mechanism to connect to MS SQL Server. Enter the\n SQL Server Authentication login or the Windows Authentication login in the DOMAIN\\User format.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-windows-auth\">\n <i>Windows Authentication</i> Windows Integrated Security - single sign on for users who are already\n logged onto Windows and have enabled this option for MS SQL Server.\n </Trans>\n </li>\n {azureAuthIsSupported && (\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-azure-auth\">\n <i>Azure Authentication</i> Securely authenticate and access Azure resources and applications using\n Azure AD credentials - Managed Service Identity and Client Secret Credentials are supported.\n </Trans>\n </li>\n )}\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-username-password\">\n <i>Windows AD: Username + password</i> Windows Active Directory - Sign on for domain user via\n username/password.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-keytab\">\n <i>Windows AD: Keytab</i> Windows Active Directory - Sign on for domain user via keytab file.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-credential-cache\">\n <i>Windows AD: Credential cache</i> Windows Active Directory - Sign on for domain user via credential\n cache.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"configuration.configuration-editor.description-auth-type-credential-cache-file\">\n <i>Windows AD: Credential cache file</i> Windows Active Directory - Sign on for domain user via\n credential cache file.\n </Trans>\n </li>\n </ul>\n }\n >\n <Select\n // Default to basic authentication of none is set\n value={jsonData.authenticationType || MSSQLAuthenticationType.sqlAuth}\n inputId=\"authenticationType\"\n options={buildAuthenticationOptions()}\n onChange={onAuthenticationMethodChanged}\n width={LONG_WIDTH}\n />\n </Field>\n\n <KerberosConfig {...props} />\n\n {/* Basic SQL auth. Render if authType === MSSQLAuthenticationType.sqlAuth OR\n authType === MSSQLAuthenticationType.kerberosRaw OR\n if no authType exists, which will be the case when creating a new data source */}\n {(jsonData.authenticationType === MSSQLAuthenticationType.sqlAuth ||\n jsonData.authenticationType === MSSQLAuthenticationType.kerberosRaw ||\n !jsonData.authenticationType) && (\n <>\n <Field\n label={t('configuration.configuration-editor.label-username', 'Username')}\n required\n invalid={!dsSettings.user}\n error={t('configuration.configuration-editor.required-username', 'Username is required')}\n description={jsonData.authenticationType === MSSQLAuthenticationType.kerberosRaw ? UsernameMessage : ''}\n >\n <Input\n value={dsSettings.user || ''}\n placeholder={\n jsonData.authenticationType === MSSQLAuthenticationType.kerberosRaw\n ? // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n 'name@EXAMPLE.COM'\n : t('configuration.configuration-editor.placeholder-user', 'user')\n }\n onChange={onDSOptionChanged('user')}\n width={LONG_WIDTH}\n />\n </Field>\n <Field\n label={t('configuration.configuration-editor.label-password', 'Password')}\n required\n invalid={!dsSettings.secureJsonFields.password && !dsSettings.secureJsonData?.password}\n error={t('configuration.configuration-editor.required-password', 'Password is required')}\n >\n <SecretInput\n width={LONG_WIDTH}\n placeholder={t('configuration.configuration-editor.placeholder-password', 'Password')}\n isConfigured={dsSettings.secureJsonFields && dsSettings.secureJsonFields.password}\n onReset={onResetPassword}\n onChange={onUpdateDatasourceSecureJsonDataOption(props, 'password')}\n required\n />\n </Field>\n </>\n )}\n\n {azureAuthIsSupported && jsonData.authenticationType === MSSQLAuthenticationType.azureAuth && (\n <FieldSet\n label={t('configuration.configuration-editor.label-auth-settings', 'Azure Authentication Settings')}\n >\n <azureAuthSettings.azureAuthSettingsUI dataSourceConfig={dsSettings} onChange={onOptionsChange} />\n </FieldSet>\n )}\n </ConfigSection>\n\n <Divider />\n <ConfigSection\n title={t('configuration.configuration-editor.title-additional-settings', 'Additional settings')}\n description={t(\n 'configuration.configuration-editor.description-additional-settings',\n 'Additional settings are optional settings that can be configured for more control over your data source. This includes connection limits, connection timeout, group-by time interval, and Secure Socks Proxy.'\n )}\n isCollapsible={true}\n isInitiallyOpen={true}\n >\n <ConnectionLimits options={dsSettings} onOptionsChange={onOptionsChange} />\n\n <ConfigSubSection\n title={t('configuration.configuration-editor.title-connection-details', 'Connection details')}\n >\n <Field\n description={\n <span>\n <Trans\n i18nKey=\"configuration.configuration-editor.description-min-interval\"\n values={{ exampleInterval: '1m' }}\n >\n A lower limit for the auto group by time interval. Recommended to be set to write frequency, for\n example\n <code>{'{{exampleInterval}}'}</code> if your data is written every minute.\n </Trans>\n </span>\n }\n label={t('configuration.configuration-editor.label-min-interval', 'Min time interval')}\n >\n <Input\n width={LONG_WIDTH}\n // eslint-disable-next-line @grafana/i18n/no-untranslated-strings\n placeholder=\"1m\"\n value={jsonData.timeInterval || ''}\n onChange={onUpdateDatasourceJsonDataOption(props, 'timeInterval')}\n />\n </Field>\n <Field\n description={\n <span>\n <Trans\n i18nKey=\"configuration.configuration-editor.description-connection-timeout\"\n values={{ defaultTimeout: '0' }}\n >\n The number of seconds to wait before canceling the request when connecting to the database. The\n default is <code>{'{{defaultTimeout}}'}</code>, meaning no timeout.\n </Trans>\n </span>\n }\n label={t('configuration.configuration-editor.label-connection-timeout', 'Connection timeout')}\n >\n <NumberInput\n width={LONG_WIDTH}\n defaultValue={60}\n value={jsonData.connectionTimeout || 0}\n onChange={onConnectionTimeoutChanged}\n />\n </Field>\n </ConfigSubSection>\n {config.secureSocksDSProxyEnabled && (\n <SecureSocksProxySettings options={dsSettings} onOptionsChange={onOptionsChange} />\n )}\n <KerberosAdvancedSettings {...props} />\n </ConfigSection>\n </>\n );\n};\n\nfunction getStyles(theme: GrafanaTheme2) {\n return {\n ulPadding: css({\n margin: theme.spacing(1, 0),\n paddingLeft: theme.spacing(5),\n }),\n };\n}\n","var assignValue = require('./_assignValue'),\n baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n}\n\nmodule.exports = copyObject;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n var err = new Error(\n 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n 'Use PropTypes.checkPropTypes() to call them. ' +\n 'Read more at http://fb.me/use-check-prop-types'\n );\n err.name = 'Invariant Violation';\n throw err;\n };\n shim.isRequired = shim;\n function getShim() {\n return shim;\n };\n // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bigint: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n elementType: shim,\n instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim,\n exact: getShim,\n\n checkPropTypes: emptyFunctionWithReset,\n resetWarningCache: emptyFunction\n };\n\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n","var SetCache = require('./_SetCache'),\n arraySome = require('./_arraySome'),\n cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n}\n\nmodule.exports = equalArrays;\n","var hashClear = require('./_hashClear'),\n hashDelete = require('./_hashDelete'),\n hashGet = require('./_hashGet'),\n hashHas = require('./_hashHas'),\n hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var copyObject = require('./_copyObject'),\n keys = require('./keys');\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var Symbol = require('./_Symbol'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray');\n\n/** Built-in value references. */\nvar spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n return isArray(value) || isArguments(value) ||\n !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\nmodule.exports = isFlattenable;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\nmodule.exports = stackClear;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","function _regeneratorKeys(e) {\n var n = Object(e),\n r = [];\n for (var t in n) r.unshift(t);\n return function e() {\n for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e;\n return e.done = !0, e;\n };\n}\nmodule.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var copyObject = require('./_copyObject'),\n keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n","var baseIsArguments = require('./_baseIsArguments'),\n isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","var getTag = require('./_getTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n return isObjectLike(value) && getTag(value) == setTag;\n}\n\nmodule.exports = baseIsSet;\n","var baseGetTag = require('./_baseGetTag'),\n getPrototype = require('./_getPrototype'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = hashDelete;\n","var baseGet = require('./_baseGet');\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyDeep(path) {\n return function(object) {\n return baseGet(object, path);\n };\n}\n\nmodule.exports = basePropertyDeep;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var baseFor = require('./_baseFor'),\n keys = require('./keys');\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n return object && baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nmodule.exports = hashClear;\n","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n if (typeof globalThis === \"object\") {\n globalThis.regeneratorRuntime = runtime;\n } else {\n Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n }\n}\n","var baseGet = require('./_baseGet');\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","/**\n * The base implementation of `_.clamp` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n */\nfunction baseClamp(number, lower, upper) {\n if (number === number) {\n if (upper !== undefined) {\n number = number <= upper ? number : upper;\n }\n if (lower !== undefined) {\n number = number >= lower ? number : lower;\n }\n }\n return number;\n}\n\nmodule.exports = baseClamp;\n","var toFinite = require('./toFinite');\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nmodule.exports = toInteger;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nmodule.exports = isPrototype;\n","var ListCache = require('./_ListCache'),\n Map = require('./_Map'),\n MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\nmodule.exports = stackSet;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\nmodule.exports = createBaseFor;\n","import { EditorMode } from '@grafana/plugin-ui';\n\nimport { QueryFormat, SQLQuery } from './types';\nimport { createFunctionField, setGroupByField } from './utils/sql.utils';\n\nexport function applyQueryDefaults(q?: SQLQuery): SQLQuery {\n let editorMode = q?.editorMode || EditorMode.Builder;\n\n // Switching to code editor if the query was created before visual query builder was introduced.\n if (q?.editorMode === undefined && q?.rawSql !== undefined) {\n editorMode = EditorMode.Code;\n }\n\n const result: SQLQuery = {\n ...q,\n refId: q?.refId || 'A',\n format: q?.format !== undefined ? q.format : QueryFormat.Table,\n rawSql: q?.rawSql || '',\n editorMode,\n sql: q?.sql ?? {\n columns: [createFunctionField()],\n groupBy: [setGroupByField()],\n limit: 50,\n },\n };\n\n return result;\n}\n\nexport type QueryWithDefaults = ReturnType<typeof applyQueryDefaults>;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n","/**\n * A specialized version of `_.indexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction strictIndexOf(array, value, fromIndex) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (array[index] === value) {\n return index;\n }\n }\n return -1;\n}\n\nmodule.exports = strictIndexOf;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__5959__;","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeysIn = require('./_baseKeysIn'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","var DataView = require('./_DataView'),\n Map = require('./_Map'),\n Promise = require('./_Promise'),\n Set = require('./_Set'),\n WeakMap = require('./_WeakMap'),\n baseGetTag = require('./_baseGetTag'),\n toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n setTag = '[object Set]',\n weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\nmodule.exports = getTag;\n","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__6089__;","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\nmodule.exports = setToArray;\n","const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);\nexport default { randomUUID };\n","let getRandomValues;\nconst rnds8 = new Uint8Array(16);\nexport default function rng() {\n if (!getRandomValues) {\n if (typeof crypto === 'undefined' || !crypto.getRandomValues) {\n throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n }\n getRandomValues = crypto.getRandomValues.bind(crypto);\n }\n return getRandomValues(rnds8);\n}\n","import validate from './validate.js';\nconst byteToHex = [];\nfor (let i = 0; i < 256; ++i) {\n byteToHex.push((i + 0x100).toString(16).slice(1));\n}\nexport function unsafeStringify(arr, offset = 0) {\n return (byteToHex[arr[offset + 0]] +\n byteToHex[arr[offset + 1]] +\n byteToHex[arr[offset + 2]] +\n byteToHex[arr[offset + 3]] +\n '-' +\n byteToHex[arr[offset + 4]] +\n byteToHex[arr[offset + 5]] +\n '-' +\n byteToHex[arr[offset + 6]] +\n byteToHex[arr[offset + 7]] +\n '-' +\n byteToHex[arr[offset + 8]] +\n byteToHex[arr[offset + 9]] +\n '-' +\n byteToHex[arr[offset + 10]] +\n byteToHex[arr[offset + 11]] +\n byteToHex[arr[offset + 12]] +\n byteToHex[arr[offset + 13]] +\n byteToHex[arr[offset + 14]] +\n byteToHex[arr[offset + 15]]).toLowerCase();\n}\nfunction stringify(arr, offset = 0) {\n const uuid = unsafeStringify(arr, offset);\n if (!validate(uuid)) {\n throw TypeError('Stringified UUID is invalid');\n }\n return uuid;\n}\nexport default stringify;\n","import native from './native.js';\nimport rng from './rng.js';\nimport { unsafeStringify } from './stringify.js';\nfunction v4(options, buf, offset) {\n if (native.randomUUID && !buf && !options) {\n return native.randomUUID();\n }\n options = options || {};\n const rnds = options.random ?? options.rng?.() ?? rng();\n if (rnds.length < 16) {\n throw new Error('Random bytes length must be >= 16');\n }\n rnds[6] = (rnds[6] & 0x0f) | 0x40;\n rnds[8] = (rnds[8] & 0x3f) | 0x80;\n if (buf) {\n offset = offset || 0;\n if (offset < 0 || offset + 16 > buf.length) {\n throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);\n }\n for (let i = 0; i < 16; ++i) {\n buf[offset + i] = rnds[i];\n }\n return buf;\n }\n return unsafeStringify(rnds);\n}\nexport default v4;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n","var Hash = require('./_Hash'),\n ListCache = require('./_ListCache'),\n Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nmodule.exports = mapCacheClear;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\nmodule.exports = arrayEach;\n","var regeneratorAsyncGen = require(\"./regeneratorAsyncGen.js\");\nfunction _regeneratorAsync(n, e, r, t, o) {\n var a = regeneratorAsyncGen(n, e, r, t, o);\n return a.next().then(function (n) {\n return n.done ? n.value : a.next();\n });\n}\nmodule.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var isPrototype = require('./_isPrototype'),\n nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeys;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nmodule.exports = constant;\n","var Stack = require('./_Stack'),\n arrayEach = require('./_arrayEach'),\n assignValue = require('./_assignValue'),\n baseAssign = require('./_baseAssign'),\n baseAssignIn = require('./_baseAssignIn'),\n cloneBuffer = require('./_cloneBuffer'),\n copyArray = require('./_copyArray'),\n copySymbols = require('./_copySymbols'),\n copySymbolsIn = require('./_copySymbolsIn'),\n getAllKeys = require('./_getAllKeys'),\n getAllKeysIn = require('./_getAllKeysIn'),\n getTag = require('./_getTag'),\n initCloneArray = require('./_initCloneArray'),\n initCloneByTag = require('./_initCloneByTag'),\n initCloneObject = require('./_initCloneObject'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isMap = require('./isMap'),\n isObject = require('./isObject'),\n isSet = require('./isSet'),\n keys = require('./keys'),\n keysIn = require('./keysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n CLONE_FLAT_FLAG = 2,\n CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Deep clone\n * 2 - Flatten inherited properties\n * 4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n var result,\n isDeep = bitmask & CLONE_DEEP_FLAG,\n isFlat = bitmask & CLONE_FLAT_FLAG,\n isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag || tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n result = (isFlat || isFunc) ? {} : initCloneObject(value);\n if (!isDeep) {\n return isFlat\n ? copySymbolsIn(value, baseAssignIn(result, value))\n : copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack || (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (isSet(value)) {\n value.forEach(function(subValue) {\n result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n });\n } else if (isMap(value)) {\n value.forEach(function(subValue, key) {\n result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n }\n\n var keysFunc = isFull\n ? (isFlat ? getAllKeysIn : getAllKeys)\n : (isFlat ? keysIn : keys);\n\n var props = isArr ? undefined : keysFunc(value);\n arrayEach(props || value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n return result;\n}\n\nmodule.exports = baseClone;\n","var arrayFilter = require('./_arrayFilter'),\n stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n};\n\nmodule.exports = getSymbols;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","var baseProperty = require('./_baseProperty'),\n basePropertyDeep = require('./_basePropertyDeep'),\n isKey = require('./_isKey'),\n toKey = require('./_toKey');\n\n/**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': 2 } },\n * { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\nfunction property(path) {\n return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n}\n\nmodule.exports = property;\n","var castPath = require('./_castPath'),\n last = require('./last'),\n parent = require('./_parent'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.unset`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The property path to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n */\nfunction baseUnset(object, path) {\n path = castPath(path, object);\n object = parent(object, path);\n return object == null || delete object[toKey(last(path))];\n}\n\nmodule.exports = baseUnset;\n","var baseTimes = require('./_baseTimes'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isIndex = require('./_isIndex'),\n isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","import React__default, { useState } from 'react';\nimport { css } from '@emotion/css';\nimport { useTheme2, IconButton } from '@grafana/ui';\n\nconst GenericConfigSection = ({\n children,\n title,\n description,\n isCollapsible = false,\n isInitiallyOpen = true,\n kind = \"section\",\n className\n}) => {\n const { colors, typography, spacing } = useTheme2();\n const [isOpen, setIsOpen] = useState(isCollapsible ? isInitiallyOpen : true);\n const iconName = isOpen ? \"angle-up\" : \"angle-down\";\n const isSubSection = kind === \"sub-section\";\n const collapsibleButtonAriaLabel = `${isOpen ? \"Collapse\" : \"Expand\"} section ${title}`;\n const styles = {\n header: css({\n display: \"flex\",\n justifyContent: \"space-between\",\n alignItems: \"center\"\n }),\n title: css({\n margin: 0\n }),\n subtitle: css({\n margin: 0,\n fontWeight: typography.fontWeightRegular\n }),\n descriptionText: css({\n marginTop: spacing(isSubSection ? 0.25 : 0.5),\n marginBottom: 0,\n ...typography.bodySmall,\n color: colors.text.secondary\n }),\n content: css({\n marginTop: spacing(2)\n })\n };\n return /* @__PURE__ */ React__default.createElement(\"div\", { className }, /* @__PURE__ */ React__default.createElement(\"div\", { className: styles.header }, kind === \"section\" ? /* @__PURE__ */ React__default.createElement(\"h3\", { className: styles.title }, title) : /* @__PURE__ */ React__default.createElement(\"h6\", { className: styles.subtitle }, title), isCollapsible && /* @__PURE__ */ React__default.createElement(\n IconButton,\n {\n name: iconName,\n onClick: () => setIsOpen(!isOpen),\n type: \"button\",\n size: \"xl\",\n \"aria-label\": collapsibleButtonAriaLabel\n }\n )), description && /* @__PURE__ */ React__default.createElement(\"p\", { className: styles.descriptionText }, description), isOpen && /* @__PURE__ */ React__default.createElement(\"div\", { className: styles.content }, children));\n};\n\nexport { GenericConfigSection };\n//# sourceMappingURL=GenericConfigSection.js.map\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\nmodule.exports = cloneRegExp;\n","import { css } from '@emotion/css';\n\nimport { GrafanaTheme2 } from '@grafana/data';\nimport { Trans } from '@grafana/i18n';\nimport { useStyles2 } from '@grafana/ui';\n\nexport function CheatSheet() {\n const styles = useStyles2(getStyles);\n\n return (\n <div>\n <h2>\n <Trans i18nKey=\"cheat-sheet.title\">MSSQL cheat sheet</Trans>\n </h2>\n <Trans i18nKey=\"cheat-sheet.time-series\">Time series:</Trans>\n <ul className={styles.ulPadding}>\n <li>\n <Trans i18nKey=\"cheat-sheet.time-series-tip\">\n return column named time (in UTC), as a unix time stamp or any sql native date data type. You can use the\n macros below.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"cheat-sheet.time-series-tip-2\">\n any other columns returned will be the time point values.\n </Trans>\n </li>\n </ul>\n <Trans i18nKey=\"cheat-sheet.optional\">Optional:</Trans>\n <ul className={styles.ulPadding}>\n <li>\n <Trans i18nKey=\"cheat-sheet.optional-tip\" values={{ columnName: 'metric' }}>\n return column named <i>{'{{columnName}}'}</i> to represent the series name.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"cheat-sheet.optional-tip-2\" values={{ columnName: 'metric' }}>\n If multiple value columns are returned the {'{{columnName}}'} column is used as prefix.\n </Trans>\n </li>\n <li>\n <Trans i18nKey=\"cheat-sheet.optional-tip-3\" values={{ columnName: 'metric' }}>\n If no column named {'{{columnName}}'} is found the column name of the value column is used as series name\n </Trans>\n </li>\n </ul>\n <p>\n <Trans i18nKey=\"cheat-sheet.resultsets-time-sorted\">\n Resultsets of time series queries need to be sorted by time.\n </Trans>\n </p>\n <Trans i18nKey=\"cheat-sheet.table\">Table:</Trans>\n <ul className={styles.ulPadding}>\n <li>\n <Trans i18nKey=\"cheat-sheet.table-tip\">return any set of columns</Trans>\n </li>\n </ul>\n <Trans i18nKey=\"cheat-sheet.macros\">Macros:</Trans>\n {/* eslint-disable @grafana/i18n/no-untranslated-strings */}\n <ul className={styles.ulPadding}>\n <li>$__time(column) -&gt; column AS time</li>\n <li>$__timeEpoch(column) -&gt; DATEDIFF(second, &apos;1970-01-01&apos;, column) AS time</li>\n <li>\n $__timeFilter(column) -&gt; column BETWEEN &apos;2017-04-21T05:01:17Z&apos; AND\n &apos;2017-04-21T05:01:17Z&apos;\n </li>\n <li>$__unixEpochFilter(column) -&gt; column &gt;= 1492750877 AND column &lt;= 1492750877</li>\n <li>\n $__unixEpochNanoFilter(column) -&gt; column &gt;= 1494410783152415214 AND column &lt;= 1494497183142514872\n </li>\n <li>\n $__timeGroup(column, &apos;5m&apos;[, fillvalue]) -&gt; CAST(ROUND(DATEDIFF(second, &apos;1970-01-01&apos;,\n column)/300.0, 0) as bigint)*300{' '}\n <Trans i18nKey=\"cheat-sheet.fillvalue\" values={{ null: 'NULL', previous: 'previous' }}>\n by setting fillvalue Grafana will fill in missing values according to the interval. fillvalue can be either\n a literal value, {'{{null}}'} or {'{{previous}}'}; {'{{previous}}'} will fill in the previous seen value or{' '}\n {'{{null}}'} if none has been seen yet\n </Trans>\n </li>\n <li>\n $__timeGroupAlias(column, &apos;5m&apos;[, fillvalue]) -&gt; CAST(ROUND(DATEDIFF(second,\n &apos;1970-01-01&apos;, column)/300.0, 0) as bigint)*300 AS [time]\n </li>\n <li>$__unixEpochGroup(column,&apos;5m&apos;) -&gt; FLOOR(column/300)*300</li>\n <li>$__unixEpochGroupAlias(column,&apos;5m&apos;) -&gt; FLOOR(column/300)*300 AS [time]</li>\n </ul>\n {/* eslint-enable @grafana/i18n/no-untranslated-strings */}\n <p>\n <Trans i18nKey=\"cheat-sheet.example-time-group\" values={{ timeGroupMacro: '$__timeGroup' }}>\n Example of group by and order by with {'{{timeGroupMacro}}'}:\n </Trans>\n </p>\n {/* eslint-disable @grafana/i18n/no-untranslated-strings */}\n <pre>\n <code>\n SELECT $__timeGroup(date_time_col, &apos;1h&apos;) AS time, sum(value) as value <br />\n FROM yourtable\n <br />\n GROUP BY $__timeGroup(date_time_col, &apos;1h&apos;)\n <br />\n ORDER BY 1\n <br />\n </code>\n </pre>\n {/* eslint-enable @grafana/i18n/no-untranslated-strings */}\n <Trans i18nKey=\"cheat-sheet.condtional-macros\">\n Or build your own conditionals using these macros which just return the values:\n </Trans>\n {/* eslint-disable @grafana/i18n/no-untranslated-strings */}\n <ul className={styles.ulPadding}>\n <li>$__timeFrom() -&gt; &apos;2017-04-21T05:01:17Z&apos;</li>\n <li>$__timeTo() -&gt; &apos;2017-04-21T05:01:17Z&apos;</li>\n <li>$__unixEpochFrom() -&gt; 1492750877</li>\n <li>$__unixEpochTo() -&gt; 1492750877</li>\n <li>$__unixEpochNanoFrom() -&gt; 1494410783152415214</li>\n <li>$__unixEpochNanoTo() -&gt; 1494497183142514872</li>\n </ul>\n {/* eslint-enable @grafana/i18n/no-untranslated-strings */}\n </div>\n );\n}\n\nfunction getStyles(theme: GrafanaTheme2) {\n return {\n ulPadding: css({\n margin: theme.spacing(1, 0),\n paddingLeft: theme.spacing(5),\n }),\n };\n}\n","var Symbol = require('./_Symbol');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nmodule.exports = cloneSymbol;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var arrayMap = require('./_arrayMap'),\n baseClone = require('./_baseClone'),\n baseUnset = require('./_baseUnset'),\n castPath = require('./_castPath'),\n copyObject = require('./_copyObject'),\n customOmitClone = require('./_customOmitClone'),\n flatRest = require('./_flatRest'),\n getAllKeysIn = require('./_getAllKeysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n CLONE_FLAT_FLAG = 2,\n CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable property paths of `object` that are not omitted.\n *\n * **Note:** This method is considerably slower than `_.pick`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\nvar omit = flatRest(function(object, paths) {\n var result = {};\n if (object == null) {\n return result;\n }\n var isDeep = false;\n paths = arrayMap(paths, function(path) {\n path = castPath(path, object);\n isDeep || (isDeep = path.length > 1);\n return path;\n });\n copyObject(object, getAllKeysIn(object), result);\n if (isDeep) {\n result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n }\n var length = paths.length;\n while (length--) {\n baseUnset(result, paths[length]);\n }\n return result;\n});\n\nmodule.exports = omit;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n var ReactIs = require('react-is');\n\n // By explicitly using `prop-types` you are opting into new development behavior.\n // http://fb.me/prop-types-in-prod\n var throwOnDirectAccess = true;\n module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n // By explicitly using `prop-types` you are opting into new production behavior.\n // http://fb.me/prop-types-in-prod\n module.exports = require('./factoryWithThrowingShims')();\n}\n","var isFunction = require('./isFunction'),\n isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n return string\n ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n : string;\n}\n\nmodule.exports = baseTrim;\n","var baseSetToString = require('./_baseSetToString'),\n shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction matchesStrictComparable(key, srcValue) {\n return function(object) {\n if (object == null) {\n return false;\n }\n return object[key] === srcValue &&\n (srcValue !== undefined || (key in Object(object)));\n };\n}\n\nmodule.exports = matchesStrictComparable;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = exports.format = void 0;\n\nvar _Db2Formatter = _interopRequireDefault(require(\"./languages/Db2Formatter\"));\n\nvar _N1qlFormatter = _interopRequireDefault(require(\"./languages/N1qlFormatter\"));\n\nvar _PlSqlFormatter = _interopRequireDefault(require(\"./languages/PlSqlFormatter\"));\n\nvar _StandardSqlFormatter = _interopRequireDefault(require(\"./languages/StandardSqlFormatter\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\n/**\r\n * Format whitespace in a query to make it easier to read.\r\n *\r\n * @param {String} query\r\n * @param {Object} cfg\r\n * @param {String} cfg.language Query language, default is Standard SQL\r\n * @param {String} cfg.indent Characters used for indentation, default is \" \" (2 spaces)\r\n * @param {Bool} cfg.uppercase Converts keywords to uppercase\r\n * @param {Integer} cfg.linesBetweenQueries How many line breaks between queries\r\n * @param {Object} cfg.params Collection of params for placeholder replacement\r\n * @return {String}\r\n */\nvar format = function format(query) {\n var cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n switch (cfg.language) {\n case 'db2':\n return new _Db2Formatter[\"default\"](cfg).format(query);\n\n case 'n1ql':\n return new _N1qlFormatter[\"default\"](cfg).format(query);\n\n case 'pl/sql':\n return new _PlSqlFormatter[\"default\"](cfg).format(query);\n\n case 'sql':\n case undefined:\n return new _StandardSqlFormatter[\"default\"](cfg).format(query);\n\n default:\n throw Error(\"Unsupported SQL dialect: \".concat(cfg.language));\n }\n};\n\nexports.format = format;\nvar _default = {\n format: format\n};\nexports[\"default\"] = _default;","var regenerator = require(\"./regenerator.js\");\nvar regeneratorAsyncIterator = require(\"./regeneratorAsyncIterator.js\");\nfunction _regeneratorAsyncGen(r, e, t, o, n) {\n return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise);\n}\nmodule.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorValues(e) {\n if (null != e) {\n var t = e[\"function\" == typeof Symbol && Symbol.iterator || \"@@iterator\"],\n r = 0;\n if (t) return t.call(e);\n if (\"function\" == typeof e.next) return e;\n if (!isNaN(e.length)) return {\n next: function next() {\n return e && r >= e.length && (e = void 0), {\n value: e && e[r++],\n done: !e\n };\n }\n };\n }\n throw new TypeError(_typeof(e) + \" is not iterable\");\n}\nmodule.exports = _regeneratorValues, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = __WEBPACK_EXTERNAL_MODULE__7694__;","var OverloadYield = require(\"./OverloadYield.js\");\nvar regenerator = require(\"./regenerator.js\");\nvar regeneratorAsync = require(\"./regeneratorAsync.js\");\nvar regeneratorAsyncGen = require(\"./regeneratorAsyncGen.js\");\nvar regeneratorAsyncIterator = require(\"./regeneratorAsyncIterator.js\");\nvar regeneratorKeys = require(\"./regeneratorKeys.js\");\nvar regeneratorValues = require(\"./regeneratorValues.js\");\nfunction _regeneratorRuntime() {\n \"use strict\";\n\n var r = regenerator(),\n e = r.m(_regeneratorRuntime),\n t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;\n function n(r) {\n var e = \"function\" == typeof r && r.constructor;\n return !!e && (e === t || \"GeneratorFunction\" === (e.displayName || e.name));\n }\n var o = {\n \"throw\": 1,\n \"return\": 2,\n \"break\": 3,\n \"continue\": 3\n };\n function a(r) {\n var e, t;\n return function (n) {\n e || (e = {\n stop: function stop() {\n return t(n.a, 2);\n },\n \"catch\": function _catch() {\n return n.v;\n },\n abrupt: function abrupt(r, e) {\n return t(n.a, o[r], e);\n },\n delegateYield: function delegateYield(r, o, a) {\n return e.resultName = o, t(n.d, regeneratorValues(r), a);\n },\n finish: function finish(r) {\n return t(n.f, r);\n }\n }, t = function t(r, _t, o) {\n n.p = e.prev, n.n = e.next;\n try {\n return r(_t, o);\n } finally {\n e.next = n.n;\n }\n }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;\n try {\n return r.call(this, e);\n } finally {\n n.p = e.prev, n.n = e.next;\n }\n };\n }\n return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n return {\n wrap: function wrap(e, t, n, o) {\n return r.w(a(e), t, n, o && o.reverse());\n },\n isGeneratorFunction: n,\n mark: r.m,\n awrap: function awrap(r, e) {\n return new OverloadYield(r, e);\n },\n AsyncIterator: regeneratorAsyncIterator,\n async: function async(r, e, t, o, u) {\n return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u);\n },\n keys: regeneratorKeys,\n values: regeneratorValues\n };\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports)();\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__7781__;","var regeneratorAsyncGen = require(\"./regeneratorAsyncGen.js\");\nfunction _regeneratorAsync(n, e, r, t, o) {\n var a = regeneratorAsyncGen(n, e, r, t, o);\n return a.next().then(function (n) {\n return n.done ? n.value : a.next();\n });\n}\nmodule.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var Stack = require('./_Stack'),\n baseIsEqual = require('./_baseIsEqual');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, source, matchData, customizer) {\n var index = matchData.length,\n length = index,\n noCustomizer = !customizer;\n\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (index--) {\n var data = matchData[index];\n if ((noCustomizer && data[2])\n ? data[1] !== object[data[0]]\n : !(data[0] in object)\n ) {\n return false;\n }\n }\n while (++index < length) {\n data = matchData[index];\n var key = data[0],\n objValue = object[key],\n srcValue = data[1];\n\n if (noCustomizer && data[2]) {\n if (objValue === undefined && !(key in object)) {\n return false;\n }\n } else {\n var stack = new Stack;\n if (customizer) {\n var result = customizer(objValue, srcValue, key, object, source, stack);\n }\n if (!(result === undefined\n ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n : result\n )) {\n return false;\n }\n }\n }\n return true;\n}\n\nmodule.exports = baseIsMatch;\n","var copyObject = require('./_copyObject'),\n keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n return object && copyObject(source, keysIn(source), object);\n}\n\nmodule.exports = baseAssignIn;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _Formatter = _interopRequireDefault(require(\"../core/Formatter\"));\n\nvar _Tokenizer = _interopRequireDefault(require(\"../core/Tokenizer\"));\n\nvar _tokenTypes = _interopRequireDefault(require(\"../core/tokenTypes\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar reservedWords = ['A', 'ACCESSIBLE', 'AGENT', 'AGGREGATE', 'ALL', 'ALTER', 'ANY', 'ARRAY', 'AS', 'ASC', 'AT', 'ATTRIBUTE', 'AUTHID', 'AVG', 'BETWEEN', 'BFILE_BASE', 'BINARY_INTEGER', 'BINARY', 'BLOB_BASE', 'BLOCK', 'BODY', 'BOOLEAN', 'BOTH', 'BOUND', 'BREADTH', 'BULK', 'BY', 'BYTE', 'C', 'CALL', 'CALLING', 'CASCADE', 'CASE', 'CHAR_BASE', 'CHAR', 'CHARACTER', 'CHARSET', 'CHARSETFORM', 'CHARSETID', 'CHECK', 'CLOB_BASE', 'CLONE', 'CLOSE', 'CLUSTER', 'CLUSTERS', 'COALESCE', 'COLAUTH', 'COLLECT', 'COLUMNS', 'COMMENT', 'COMMIT', 'COMMITTED', 'COMPILED', 'COMPRESS', 'CONNECT', 'CONSTANT', 'CONSTRUCTOR', 'CONTEXT', 'CONTINUE', 'CONVERT', 'COUNT', 'CRASH', 'CREATE', 'CREDENTIAL', 'CURRENT', 'CURRVAL', 'CURSOR', 'CUSTOMDATUM', 'DANGLING', 'DATA', 'DATE_BASE', 'DATE', 'DAY', 'DECIMAL', 'DEFAULT', 'DEFINE', 'DELETE', 'DEPTH', 'DESC', 'DETERMINISTIC', 'DIRECTORY', 'DISTINCT', 'DO', 'DOUBLE', 'DROP', 'DURATION', 'ELEMENT', 'ELSIF', 'EMPTY', 'END', 'ESCAPE', 'EXCEPTIONS', 'EXCLUSIVE', 'EXECUTE', 'EXISTS', 'EXIT', 'EXTENDS', 'EXTERNAL', 'EXTRACT', 'FALSE', 'FETCH', 'FINAL', 'FIRST', 'FIXED', 'FLOAT', 'FOR', 'FORALL', 'FORCE', 'FROM', 'FUNCTION', 'GENERAL', 'GOTO', 'GRANT', 'GROUP', 'HASH', 'HEAP', 'HIDDEN', 'HOUR', 'IDENTIFIED', 'IF', 'IMMEDIATE', 'IN', 'INCLUDING', 'INDEX', 'INDEXES', 'INDICATOR', 'INDICES', 'INFINITE', 'INSTANTIABLE', 'INT', 'INTEGER', 'INTERFACE', 'INTERVAL', 'INTO', 'INVALIDATE', 'IS', 'ISOLATION', 'JAVA', 'LANGUAGE', 'LARGE', 'LEADING', 'LENGTH', 'LEVEL', 'LIBRARY', 'LIKE', 'LIKE2', 'LIKE4', 'LIKEC', 'LIMITED', 'LOCAL', 'LOCK', 'LONG', 'MAP', 'MAX', 'MAXLEN', 'MEMBER', 'MERGE', 'MIN', 'MINUTE', 'MLSLABEL', 'MOD', 'MODE', 'MONTH', 'MULTISET', 'NAME', 'NAN', 'NATIONAL', 'NATIVE', 'NATURAL', 'NATURALN', 'NCHAR', 'NEW', 'NEXTVAL', 'NOCOMPRESS', 'NOCOPY', 'NOT', 'NOWAIT', 'NULL', 'NULLIF', 'NUMBER_BASE', 'NUMBER', 'OBJECT', 'OCICOLL', 'OCIDATE', 'OCIDATETIME', 'OCIDURATION', 'OCIINTERVAL', 'OCILOBLOCATOR', 'OCINUMBER', 'OCIRAW', 'OCIREF', 'OCIREFCURSOR', 'OCIROWID', 'OCISTRING', 'OCITYPE', 'OF', 'OLD', 'ON', 'ONLY', 'OPAQUE', 'OPEN', 'OPERATOR', 'OPTION', 'ORACLE', 'ORADATA', 'ORDER', 'ORGANIZATION', 'ORLANY', 'ORLVARY', 'OTHERS', 'OUT', 'OVERLAPS', 'OVERRIDING', 'PACKAGE', 'PARALLEL_ENABLE', 'PARAMETER', 'PARAMETERS', 'PARENT', 'PARTITION', 'PASCAL', 'PCTFREE', 'PIPE', 'PIPELINED', 'PLS_INTEGER', 'PLUGGABLE', 'POSITIVE', 'POSITIVEN', 'PRAGMA', 'PRECISION', 'PRIOR', 'PRIVATE', 'PROCEDURE', 'PUBLIC', 'RAISE', 'RANGE', 'RAW', 'READ', 'REAL', 'RECORD', 'REF', 'REFERENCE', 'RELEASE', 'RELIES_ON', 'REM', 'REMAINDER', 'RENAME', 'RESOURCE', 'RESULT_CACHE', 'RESULT', 'RETURN', 'RETURNING', 'REVERSE', 'REVOKE', 'ROLLBACK', 'ROW', 'ROWID', 'ROWNUM', 'ROWTYPE', 'SAMPLE', 'SAVE', 'SAVEPOINT', 'SB1', 'SB2', 'SB4', 'SEARCH', 'SECOND', 'SEGMENT', 'SELF', 'SEPARATE', 'SEQUENCE', 'SERIALIZABLE', 'SHARE', 'SHORT', 'SIZE_T', 'SIZE', 'SMALLINT', 'SOME', 'SPACE', 'SPARSE', 'SQL', 'SQLCODE', 'SQLDATA', 'SQLERRM', 'SQLNAME', 'SQLSTATE', 'STANDARD', 'START', 'STATIC', 'STDDEV', 'STORED', 'STRING', 'STRUCT', 'STYLE', 'SUBMULTISET', 'SUBPARTITION', 'SUBSTITUTABLE', 'SUBTYPE', 'SUCCESSFUL', 'SUM', 'SYNONYM', 'SYSDATE', 'TABAUTH', 'TABLE', 'TDO', 'THE', 'THEN', 'TIME', 'TIMESTAMP', 'TIMEZONE_ABBR', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE', 'TIMEZONE_REGION', 'TO', 'TRAILING', 'TRANSACTION', 'TRANSACTIONAL', 'TRIGGER', 'TRUE', 'TRUSTED', 'TYPE', 'UB1', 'UB2', 'UB4', 'UID', 'UNDER', 'UNIQUE', 'UNPLUG', 'UNSIGNED', 'UNTRUSTED', 'USE', 'USER', 'USING', 'VALIDATE', 'VALIST', 'VALUE', 'VARCHAR', 'VARCHAR2', 'VARIABLE', 'VARIANCE', 'VARRAY', 'VARYING', 'VIEW', 'VIEWS', 'VOID', 'WHENEVER', 'WHILE', 'WITH', 'WORK', 'WRAPPED', 'WRITE', 'YEAR', 'ZONE'];\nvar reservedTopLevelWords = ['ADD', 'ALTER COLUMN', 'ALTER TABLE', 'BEGIN', 'CONNECT BY', 'DECLARE', 'DELETE FROM', 'DELETE', 'END', 'EXCEPT', 'EXCEPTION', 'FETCH FIRST', 'FROM', 'GROUP BY', 'HAVING', 'INSERT INTO', 'INSERT', 'LIMIT', 'LOOP', 'MODIFY', 'ORDER BY', 'SELECT', 'SET CURRENT SCHEMA', 'SET SCHEMA', 'SET', 'START WITH', 'UPDATE', 'VALUES', 'WHERE'];\nvar reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];\nvar reservedNewlineWords = ['AND', 'CROSS APPLY', 'CROSS JOIN', 'ELSE', 'END', 'INNER JOIN', 'JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'OR', 'OUTER APPLY', 'OUTER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN', 'WHEN', 'XOR'];\n\nvar tokenOverride = function tokenOverride(token, previousReservedToken) {\n if (token.type === _tokenTypes[\"default\"].RESERVED_TOP_LEVEL && token.value === 'SET' && previousReservedToken.value === 'BY') {\n token.type = _tokenTypes[\"default\"].RESERVED;\n return token;\n }\n};\n\nvar tokenizer;\n\nvar PlSqlFormatter =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg Different set of configurations\r\n */\n function PlSqlFormatter(cfg) {\n _classCallCheck(this, PlSqlFormatter);\n\n this.cfg = cfg;\n }\n /**\r\n * Format the whitespace in a PL/SQL string to make it easier to read\r\n *\r\n * @param {String} query The PL/SQL string\r\n * @return {String} formatted string\r\n */\n\n\n _createClass(PlSqlFormatter, [{\n key: \"format\",\n value: function format(query) {\n if (!tokenizer) {\n tokenizer = new _Tokenizer[\"default\"]({\n reservedWords: reservedWords,\n reservedTopLevelWords: reservedTopLevelWords,\n reservedNewlineWords: reservedNewlineWords,\n reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,\n stringTypes: [\"\\\"\\\"\", \"N''\", \"''\", '``'],\n openParens: ['(', 'CASE', 'BEGIN'],\n closeParens: [')', 'END'],\n indexedPlaceholderTypes: ['?'],\n namedPlaceholderTypes: [':'],\n lineCommentTypes: ['--'],\n specialWordChars: ['_', '$', '#', '.', '@']\n });\n }\n\n return new _Formatter[\"default\"](this.cfg, tokenizer, tokenOverride).format(query);\n }\n }]);\n\n return PlSqlFormatter;\n}();\n\nexports[\"default\"] = PlSqlFormatter;\nmodule.exports = exports.default;","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","var isArrayLike = require('./isArrayLike'),\n isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n","var baseKeys = require('./_baseKeys'),\n getTag = require('./_getTag'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isArrayLike = require('./isArrayLike'),\n isBuffer = require('./isBuffer'),\n isPrototype = require('./_isPrototype'),\n isTypedArray = require('./isTypedArray');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n setTag = '[object Set]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if `value` is an empty object, collection, map, or set.\n *\n * Objects are considered empty if they have no own enumerable string keyed\n * properties.\n *\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n * jQuery-like collections are considered empty if they have a `length` of `0`.\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n *\n * _.isEmpty(null);\n * // => true\n *\n * _.isEmpty(true);\n * // => true\n *\n * _.isEmpty(1);\n * // => true\n *\n * _.isEmpty([1, 2, 3]);\n * // => false\n *\n * _.isEmpty({ 'a': 1 });\n * // => false\n */\nfunction isEmpty(value) {\n if (value == null) {\n return true;\n }\n if (isArrayLike(value) &&\n (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n return !value.length;\n }\n var tag = getTag(value);\n if (tag == mapTag || tag == setTag) {\n return !value.size;\n }\n if (isPrototype(value)) {\n return !baseKeys(value).length;\n }\n for (var key in value) {\n if (hasOwnProperty.call(value, key)) {\n return false;\n }\n }\n return true;\n}\n\nmodule.exports = isEmpty;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","import '@grafana/ui';\nimport '@grafana/data';\n\nvar OperatorType = /* @__PURE__ */ ((OperatorType2) => {\n OperatorType2[OperatorType2[\"Comparison\"] = 0] = \"Comparison\";\n OperatorType2[OperatorType2[\"Logical\"] = 1] = \"Logical\";\n return OperatorType2;\n})(OperatorType || {});\nvar MacroType = /* @__PURE__ */ ((MacroType2) => {\n MacroType2[MacroType2[\"Value\"] = 0] = \"Value\";\n MacroType2[MacroType2[\"Filter\"] = 1] = \"Filter\";\n MacroType2[MacroType2[\"Group\"] = 2] = \"Group\";\n MacroType2[MacroType2[\"Column\"] = 3] = \"Column\";\n MacroType2[MacroType2[\"Table\"] = 4] = \"Table\";\n return MacroType2;\n})(MacroType || {});\nvar TokenType = /* @__PURE__ */ ((TokenType2) => {\n TokenType2[\"Parenthesis\"] = \"delimiter.parenthesis.sql\";\n TokenType2[\"Whitespace\"] = \"white.sql\";\n TokenType2[\"Keyword\"] = \"keyword.sql\";\n TokenType2[\"Delimiter\"] = \"delimiter.sql\";\n TokenType2[\"Operator\"] = \"operator.sql\";\n TokenType2[\"Identifier\"] = \"identifier.sql\";\n TokenType2[\"IdentifierQuote\"] = \"identifier.quote.sql\";\n TokenType2[\"Type\"] = \"type.sql\";\n TokenType2[\"Function\"] = \"predefined.sql\";\n TokenType2[\"Number\"] = \"number.sql\";\n TokenType2[\"String\"] = \"string.sql\";\n TokenType2[\"Variable\"] = \"variable.sql\";\n return TokenType2;\n})(TokenType || {});\nvar StatementPosition = /* @__PURE__ */ ((StatementPosition2) => {\n StatementPosition2[\"Unknown\"] = \"unknown\";\n StatementPosition2[\"SelectKeyword\"] = \"selectKeyword\";\n StatementPosition2[\"WithKeyword\"] = \"withKeyword\";\n StatementPosition2[\"AfterSelectKeyword\"] = \"afterSelectKeyword\";\n StatementPosition2[\"AfterSelectArguments\"] = \"afterSelectArguments\";\n StatementPosition2[\"AfterSelectFuncFirstArgument\"] = \"afterSelectFuncFirstArgument\";\n StatementPosition2[\"SelectAlias\"] = \"selectAlias\";\n StatementPosition2[\"AfterFromKeyword\"] = \"afterFromKeyword\";\n StatementPosition2[\"AfterTable\"] = \"afterTable\";\n StatementPosition2[\"SchemaFuncFirstArgument\"] = \"schemaFuncFirstArgument\";\n StatementPosition2[\"SchemaFuncExtraArgument\"] = \"schemaFuncExtraArgument\";\n StatementPosition2[\"FromKeyword\"] = \"fromKeyword\";\n StatementPosition2[\"AfterFrom\"] = \"afterFrom\";\n StatementPosition2[\"WhereKeyword\"] = \"whereKeyword\";\n StatementPosition2[\"WhereComparisonOperator\"] = \"whereComparisonOperator\";\n StatementPosition2[\"WhereValue\"] = \"whereValue\";\n StatementPosition2[\"AfterWhereFunctionArgument\"] = \"afterWhereFunctionArgument\";\n StatementPosition2[\"AfterGroupByFunctionArgument\"] = \"afterGroupByFunctionArgument\";\n StatementPosition2[\"AfterWhereValue\"] = \"afterWhereValue\";\n StatementPosition2[\"AfterGroupByKeywords\"] = \"afterGroupByKeywords\";\n StatementPosition2[\"AfterGroupBy\"] = \"afterGroupBy\";\n StatementPosition2[\"AfterOrderByKeywords\"] = \"afterOrderByKeywords\";\n StatementPosition2[\"AfterOrderByFunction\"] = \"afterOrderByFunction\";\n StatementPosition2[\"AfterOrderByDirection\"] = \"afterOrderByDirection\";\n StatementPosition2[\"AfterIsOperator\"] = \"afterIsOperator\";\n StatementPosition2[\"AfterIsNotOperator\"] = \"afterIsNotOperator\";\n StatementPosition2[\"AfterSchema\"] = \"afterSchema\";\n return StatementPosition2;\n})(StatementPosition || {});\nvar SuggestionKind = /* @__PURE__ */ ((SuggestionKind2) => {\n SuggestionKind2[\"Schemas\"] = \"schemas\";\n SuggestionKind2[\"Tables\"] = \"tables\";\n SuggestionKind2[\"Columns\"] = \"columns\";\n SuggestionKind2[\"SelectKeyword\"] = \"selectKeyword\";\n SuggestionKind2[\"WithKeyword\"] = \"withKeyword\";\n SuggestionKind2[\"FunctionsWithArguments\"] = \"functionsWithArguments\";\n SuggestionKind2[\"FromKeyword\"] = \"fromKeyword\";\n SuggestionKind2[\"WhereKeyword\"] = \"whereKeyword\";\n SuggestionKind2[\"GroupByKeywords\"] = \"groupByKeywords\";\n SuggestionKind2[\"OrderByKeywords\"] = \"orderByKeywords\";\n SuggestionKind2[\"FunctionsWithoutArguments\"] = \"functionsWithoutArguments\";\n SuggestionKind2[\"LimitKeyword\"] = \"limitKeyword\";\n SuggestionKind2[\"SortOrderDirectionKeyword\"] = \"sortOrderDirectionKeyword\";\n SuggestionKind2[\"ComparisonOperators\"] = \"comparisonOperators\";\n SuggestionKind2[\"LogicalOperators\"] = \"logicalOperators\";\n SuggestionKind2[\"SelectMacro\"] = \"selectMacro\";\n SuggestionKind2[\"TableMacro\"] = \"tableMacro\";\n SuggestionKind2[\"FilterMacro\"] = \"filterMacro\";\n SuggestionKind2[\"GroupMacro\"] = \"groupMacro\";\n SuggestionKind2[\"BoolValues\"] = \"boolValues\";\n SuggestionKind2[\"NullValue\"] = \"nullValue\";\n SuggestionKind2[\"NotKeyword\"] = \"notKeyword\";\n SuggestionKind2[\"TemplateVariables\"] = \"templateVariables\";\n SuggestionKind2[\"StarWildCard\"] = \"starWildCard\";\n return SuggestionKind2;\n})(SuggestionKind || {});\nvar CompletionItemPriority = /* @__PURE__ */ ((CompletionItemPriority2) => {\n CompletionItemPriority2[\"High\"] = \"a\";\n CompletionItemPriority2[\"MediumHigh\"] = \"d\";\n CompletionItemPriority2[\"Medium\"] = \"g\";\n CompletionItemPriority2[\"MediumLow\"] = \"k\";\n CompletionItemPriority2[\"Low\"] = \"q\";\n return CompletionItemPriority2;\n})(CompletionItemPriority || {});\nvar CompletionItemKind = /* @__PURE__ */ ((CompletionItemKind2) => {\n CompletionItemKind2[CompletionItemKind2[\"Method\"] = 0] = \"Method\";\n CompletionItemKind2[CompletionItemKind2[\"Function\"] = 1] = \"Function\";\n CompletionItemKind2[CompletionItemKind2[\"Constructor\"] = 2] = \"Constructor\";\n CompletionItemKind2[CompletionItemKind2[\"Field\"] = 3] = \"Field\";\n CompletionItemKind2[CompletionItemKind2[\"Variable\"] = 4] = \"Variable\";\n CompletionItemKind2[CompletionItemKind2[\"Class\"] = 5] = \"Class\";\n CompletionItemKind2[CompletionItemKind2[\"Struct\"] = 6] = \"Struct\";\n CompletionItemKind2[CompletionItemKind2[\"Interface\"] = 7] = \"Interface\";\n CompletionItemKind2[CompletionItemKind2[\"Module\"] = 8] = \"Module\";\n CompletionItemKind2[CompletionItemKind2[\"Property\"] = 9] = \"Property\";\n CompletionItemKind2[CompletionItemKind2[\"Event\"] = 10] = \"Event\";\n CompletionItemKind2[CompletionItemKind2[\"Operator\"] = 11] = \"Operator\";\n CompletionItemKind2[CompletionItemKind2[\"Unit\"] = 12] = \"Unit\";\n CompletionItemKind2[CompletionItemKind2[\"Value\"] = 13] = \"Value\";\n CompletionItemKind2[CompletionItemKind2[\"Constant\"] = 14] = \"Constant\";\n CompletionItemKind2[CompletionItemKind2[\"Enum\"] = 15] = \"Enum\";\n CompletionItemKind2[CompletionItemKind2[\"EnumMember\"] = 16] = \"EnumMember\";\n CompletionItemKind2[CompletionItemKind2[\"Keyword\"] = 17] = \"Keyword\";\n CompletionItemKind2[CompletionItemKind2[\"Text\"] = 18] = \"Text\";\n CompletionItemKind2[CompletionItemKind2[\"Color\"] = 19] = \"Color\";\n CompletionItemKind2[CompletionItemKind2[\"File\"] = 20] = \"File\";\n CompletionItemKind2[CompletionItemKind2[\"Reference\"] = 21] = \"Reference\";\n CompletionItemKind2[CompletionItemKind2[\"Customcolor\"] = 22] = \"Customcolor\";\n CompletionItemKind2[CompletionItemKind2[\"Folder\"] = 23] = \"Folder\";\n CompletionItemKind2[CompletionItemKind2[\"TypeParameter\"] = 24] = \"TypeParameter\";\n CompletionItemKind2[CompletionItemKind2[\"User\"] = 25] = \"User\";\n CompletionItemKind2[CompletionItemKind2[\"Issue\"] = 26] = \"Issue\";\n CompletionItemKind2[CompletionItemKind2[\"Snippet\"] = 27] = \"Snippet\";\n return CompletionItemKind2;\n})(CompletionItemKind || {});\nvar CompletionItemInsertTextRule = /* @__PURE__ */ ((CompletionItemInsertTextRule2) => {\n CompletionItemInsertTextRule2[CompletionItemInsertTextRule2[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\n CompletionItemInsertTextRule2[CompletionItemInsertTextRule2[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\n return CompletionItemInsertTextRule2;\n})(CompletionItemInsertTextRule || {});\nvar SQLEditorMode = /* @__PURE__ */ ((SQLEditorMode2) => {\n SQLEditorMode2[\"Builder\"] = \"builder\";\n SQLEditorMode2[\"Code\"] = \"code\";\n return SQLEditorMode2;\n})(SQLEditorMode || {});\n\nexport { CompletionItemInsertTextRule, CompletionItemKind, CompletionItemPriority, MacroType, OperatorType, SQLEditorMode, StatementPosition, SuggestionKind, TokenType };\n//# sourceMappingURL=types.js.map\n","var assignMergeValue = require('./_assignMergeValue'),\n cloneBuffer = require('./_cloneBuffer'),\n cloneTypedArray = require('./_cloneTypedArray'),\n copyArray = require('./_copyArray'),\n initCloneObject = require('./_initCloneObject'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isArrayLikeObject = require('./isArrayLikeObject'),\n isBuffer = require('./isBuffer'),\n isFunction = require('./isFunction'),\n isObject = require('./isObject'),\n isPlainObject = require('./isPlainObject'),\n isTypedArray = require('./isTypedArray'),\n safeGet = require('./_safeGet'),\n toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n","var baseAssignValue = require('./_baseAssignValue'),\n eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nmodule.exports = assignValue;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\nmodule.exports = arrayPush;\n","var baseIsMatch = require('./_baseIsMatch'),\n getMatchData = require('./_getMatchData'),\n matchesStrictComparable = require('./_matchesStrictComparable');\n\n/**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatches(source) {\n var matchData = getMatchData(source);\n if (matchData.length == 1 && matchData[0][2]) {\n return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n }\n return function(object) {\n return object === source || baseIsMatch(object, source, matchData);\n };\n}\n\nmodule.exports = baseMatches;\n","var MapCache = require('./_MapCache'),\n setCacheAdd = require('./_setCacheAdd'),\n setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","var map = {\n\t\"./cs-CZ/grafana-sql.json\": [\n\t\t6685,\n\t\t685\n\t],\n\t\"./de-DE/grafana-sql.json\": [\n\t\t3172,\n\t\t172\n\t],\n\t\"./en-US/grafana-sql.json\": [\n\t\t6343,\n\t\t343\n\t],\n\t\"./es-ES/grafana-sql.json\": [\n\t\t2654,\n\t\t654\n\t],\n\t\"./fr-FR/grafana-sql.json\": [\n\t\t5450,\n\t\t450\n\t],\n\t\"./hu-HU/grafana-sql.json\": [\n\t\t4852,\n\t\t852\n\t],\n\t\"./id-ID/grafana-sql.json\": [\n\t\t9236,\n\t\t855\n\t],\n\t\"./it-IT/grafana-sql.json\": [\n\t\t7236,\n\t\t236\n\t],\n\t\"./ja-JP/grafana-sql.json\": [\n\t\t5447,\n\t\t447\n\t],\n\t\"./ko-KR/grafana-sql.json\": [\n\t\t6961,\n\t\t961\n\t],\n\t\"./nl-NL/grafana-sql.json\": [\n\t\t290,\n\t\t290\n\t],\n\t\"./pl-PL/grafana-sql.json\": [\n\t\t30,\n\t\t30\n\t],\n\t\"./pt-BR/grafana-sql.json\": [\n\t\t2454,\n\t\t454\n\t],\n\t\"./pt-PT/grafana-sql.json\": [\n\t\t3166,\n\t\t166\n\t],\n\t\"./ru-RU/grafana-sql.json\": [\n\t\t880,\n\t\t880\n\t],\n\t\"./sv-SE/grafana-sql.json\": [\n\t\t1809,\n\t\t809\n\t],\n\t\"./tr-TR/grafana-sql.json\": [\n\t\t3630,\n\t\t630\n\t],\n\t\"./zh-Hans/grafana-sql.json\": [\n\t\t1540,\n\t\t540\n\t],\n\t\"./zh-Hant/grafana-sql.json\": [\n\t\t2501,\n\t\t501\n\t]\n};\nfunction webpackAsyncContext(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\treturn Promise.resolve().then(() => {\n\t\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\t\te.code = 'MODULE_NOT_FOUND';\n\t\t\tthrow e;\n\t\t});\n\t}\n\n\tvar ids = map[req], id = ids[0];\n\treturn __webpack_require__.e(ids[1]).then(() => {\n\t\treturn __webpack_require__.t(id, 3 | 16);\n\t});\n}\nwebpackAsyncContext.keys = () => (Object.keys(map));\nwebpackAsyncContext.id = 8300;\nmodule.exports = webpackAsyncContext;","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nmodule.exports = overArg;\n","var regeneratorDefine = require(\"./regeneratorDefine.js\");\nfunction _regenerator() {\n /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */\n var e,\n t,\n r = \"function\" == typeof Symbol ? Symbol : {},\n n = r.iterator || \"@@iterator\",\n o = r.toStringTag || \"@@toStringTag\";\n function i(r, n, o, i) {\n var c = n && n.prototype instanceof Generator ? n : Generator,\n u = Object.create(c.prototype);\n return regeneratorDefine(u, \"_invoke\", function (r, n, o) {\n var i,\n c,\n u,\n f = 0,\n p = o || [],\n y = !1,\n G = {\n p: 0,\n n: 0,\n v: e,\n a: d,\n f: d.bind(e, 4),\n d: function d(t, r) {\n return i = t, c = 0, u = e, G.n = r, a;\n }\n };\n function d(r, n) {\n for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {\n var o,\n i = p[t],\n d = G.p,\n l = i[2];\n r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));\n }\n if (o || r > 1) return a;\n throw y = !0, n;\n }\n return function (o, p, l) {\n if (f > 1) throw TypeError(\"Generator is already running\");\n for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {\n i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);\n try {\n if (f = 2, i) {\n if (c || (o = \"next\"), t = i[o]) {\n if (!(t = t.call(i, u))) throw TypeError(\"iterator result is not an object\");\n if (!t.done) return t;\n u = t.value, c < 2 && (c = 0);\n } else 1 === c && (t = i[\"return\"]) && t.call(i), c < 2 && (u = TypeError(\"The iterator does not provide a '\" + o + \"' method\"), c = 1);\n i = e;\n } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;\n } catch (t) {\n i = e, c = 1, u = t;\n } finally {\n f = 1;\n }\n }\n return {\n value: t,\n done: y\n };\n };\n }(r, o, i), !0), u;\n }\n var a = {};\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n t = Object.getPrototypeOf;\n var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function () {\n return this;\n }), t),\n u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);\n function f(e) {\n return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, \"GeneratorFunction\")), e.prototype = Object.create(u), e;\n }\n return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, \"constructor\", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction), GeneratorFunction.displayName = \"GeneratorFunction\", regeneratorDefine(GeneratorFunctionPrototype, o, \"GeneratorFunction\"), regeneratorDefine(u), regeneratorDefine(u, o, \"Generator\"), regeneratorDefine(u, n, function () {\n return this;\n }), regeneratorDefine(u, \"toString\", function () {\n return \"[object Generator]\";\n }), (module.exports = _regenerator = function _regenerator() {\n return {\n w: i,\n m: f\n };\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports)();\n}\nmodule.exports = _regenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayPush = require('./_arrayPush'),\n isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n","var arrayPush = require('./_arrayPush'),\n getPrototype = require('./_getPrototype'),\n getSymbols = require('./_getSymbols'),\n stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n var result = [];\n while (object) {\n arrayPush(result, getSymbols(object));\n object = getPrototype(object);\n }\n return result;\n};\n\nmodule.exports = getSymbolsIn;\n","var toString = require('./toString');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n reHasRegExpChar = RegExp(reRegExpChar.source);\n\n/**\n * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escapeRegExp('[lodash](https://lodash.com/)');\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n */\nfunction escapeRegExp(string) {\n string = toString(string);\n return (string && reHasRegExpChar.test(string))\n ? string.replace(reRegExpChar, '\\\\$&')\n : string;\n}\n\nmodule.exports = escapeRegExp;\n","var flatten = require('./flatten'),\n overRest = require('./_overRest'),\n setToString = require('./_setToString');\n\n/**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\nfunction flatRest(func) {\n return setToString(overRest(func, undefined, flatten), func + '');\n}\n\nmodule.exports = flatRest;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__8531__;","var ListCache = require('./_ListCache'),\n stackClear = require('./_stackClear'),\n stackDelete = require('./_stackDelete'),\n stackGet = require('./_stackGet'),\n stackHas = require('./_stackHas'),\n stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var baseRange = require('./_baseRange'),\n isIterateeCall = require('./_isIterateeCall'),\n toFinite = require('./toFinite');\n\n/**\n * Creates a `_.range` or `_.rangeRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new range function.\n */\nfunction createRange(fromRight) {\n return function(start, end, step) {\n if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n end = step = undefined;\n }\n // Ensure the sign of `-0` is preserved.\n start = toFinite(start);\n if (end === undefined) {\n end = start;\n start = 0;\n } else {\n end = toFinite(end);\n }\n step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n return baseRange(start, end, step, fromRight);\n };\n}\n\nmodule.exports = createRange;\n","function _regeneratorDefine(e, r, n, t) {\n var i = Object.defineProperty;\n try {\n i({}, \"\", {});\n } catch (e) {\n i = 0;\n }\n module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {\n function o(r, n) {\n _regeneratorDefine(e, r, function (e) {\n return this._invoke(r, n, e);\n });\n }\n r ? i ? i(e, r, {\n value: n,\n enumerable: !t,\n configurable: !t,\n writable: !t\n }) : e[r] = n : (o(\"next\", 0), o(\"throw\", 1), o(\"return\", 2));\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _regeneratorDefine(e, r, n, t);\n}\nmodule.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var baseIsSet = require('./_baseIsSet'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nmodule.exports = isSet;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\nmodule.exports = stubArray;\n","var basePick = require('./_basePick'),\n flatRest = require('./_flatRest');\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = flatRest(function(object, paths) {\n return object == null ? {} : basePick(object, paths);\n});\n\nmodule.exports = pick;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n var length = array == null ? 0 : array.length;\n return length ? array[length - 1] : undefined;\n}\n\nmodule.exports = last;\n","var baseGetTag = require('./_baseGetTag'),\n isArray = require('./isArray'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nmodule.exports = isString;\n","import { Func, FuncParameter } from './types';\n\nexport const COMMON_FNS: Func[] = [\n { name: 'AVG' },\n { name: 'COUNT' },\n { name: 'MAX' },\n { name: 'MIN' },\n { name: 'SUM' },\n];\n\nconst intervalParam: FuncParameter = {\n name: 'Interval',\n required: true,\n options: () => {\n return Promise.resolve([{ label: '$__interval', value: '$__interval' }]);\n },\n};\nconst fillParam: FuncParameter = {\n name: 'Fill',\n required: false,\n options: () =>\n Promise.resolve([\n { label: '0', value: '0' },\n { label: 'NULL', value: 'NULL' },\n { label: 'previous', value: 'previous' },\n ]),\n};\n\nexport const MACRO_FUNCTIONS = (columnParam: FuncParameter) => [\n {\n name: '$__timeGroup',\n description: 'Time grouping function',\n parameters: [columnParam, intervalParam, fillParam],\n },\n {\n name: '$__timeGroupAlias',\n description: 'Time grouping function with time as alias',\n parameters: [columnParam, intervalParam, fillParam],\n },\n {\n name: '$__time',\n description: 'An expression to rename the column to time',\n parameters: [columnParam],\n },\n {\n name: '$__timeEpoch',\n parameters: [columnParam],\n },\n {\n name: '$__unixEpochGroup',\n parameters: [columnParam, intervalParam, fillParam],\n },\n {\n name: '$__unixEpochGroupAlias',\n parameters: [columnParam, intervalParam, fillParam],\n },\n];\n\nexport const MACRO_NAMES = [\n '$__time',\n '$__timeEpoch',\n '$__timeFilter',\n '$__timeFrom',\n '$__timeTo',\n '$__timeGroup',\n '$__timeGroupAlias',\n '$__unixEpochFilter',\n '$__unixEpochNanoFilter',\n '$__unixEpochNanoFrom',\n '$__unixEpochNanoTo',\n '$__unixEpochGroup',\n '$__unixEpochGroupAlias',\n];\n","import { uniqBy } from 'lodash';\n\nimport { DataFrame, MetricFindValue } from '@grafana/data';\n\nimport type { ResponseParser as ResponseParserType } from './types';\n\nexport class ResponseParser implements ResponseParserType {\n transformMetricFindResponse(frame: DataFrame): MetricFindValue[] {\n const values: MetricFindValue[] = [];\n const textField = frame.fields.find((f) => f.name === '__text');\n const valueField = frame.fields.find((f) => f.name === '__value');\n\n if (textField && valueField) {\n for (let i = 0; i < textField.values.length; i++) {\n values.push({ text: '' + textField.values[i], value: '' + valueField.values[i] });\n }\n } else {\n for (const field of frame.fields) {\n for (const value of field.values) {\n values.push({ text: value });\n }\n }\n }\n\n return uniqBy(values, 'text');\n }\n}\n","import { css } from '@emotion/css';\nimport { lazy, Suspense } from 'react';\n\nimport { GrafanaTheme2 } from '@grafana/data';\nimport { t } from '@grafana/i18n';\nimport { LoadingPlaceholder, useStyles2 } from '@grafana/ui';\n\nimport type { SqlQueryEditorProps } from './QueryEditor';\nconst QueryEditor = lazy(() => import(/* webpackChunkName: \"sql-query-editor\" */ './QueryEditor'));\n\nexport function SqlQueryEditorLazy(props: SqlQueryEditorProps) {\n const styles = useStyles2(getStyles);\n\n return (\n <Suspense\n fallback={\n <LoadingPlaceholder\n text={t('grafana-sql.components.sql-query-editor-lazy.text-loading-editor', 'Loading editor')}\n className={styles.container}\n />\n }\n >\n <QueryEditor {...props} />\n </Suspense>\n );\n}\n\nconst getStyles = (theme: GrafanaTheme2) => {\n return {\n container: css({\n marginBottom: 'unset',\n marginLeft: theme.spacing(1),\n }),\n };\n};\n","import { AnnotationQuery } from '@grafana/data';\n\nimport { applyQueryDefaults } from '../defaults';\nimport { SQLQuery } from '../types';\n\nexport default function migrateAnnotation(annotation: AnnotationQuery<SQLQuery>) {\n const oldQuery = typeof annotation.rawQuery === 'string' ? annotation.rawQuery : null;\n\n if (!oldQuery) {\n return annotation;\n }\n\n const newQuery = applyQueryDefaults({ refId: 'Annotation', ...(annotation.target ?? {}), rawSql: oldQuery });\n\n return {\n ...annotation,\n rawQuery: undefined,\n workspace: undefined,\n subscription: undefined,\n queryType: undefined,\n target: newQuery,\n };\n}\n","import { lastValueFrom, Observable, throwError } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport {\n getDefaultTimeRange,\n DataFrame,\n DataFrameView,\n DataQuery,\n DataQueryRequest,\n DataQueryResponse,\n DataSourceInstanceSettings,\n MetricFindValue,\n ScopedVars,\n CoreApp,\n getSearchFilterScopedVar,\n LegacyMetricFindQueryOptions,\n VariableWithMultiSupport,\n TimeRange,\n} from '@grafana/data';\nimport { EditorMode } from '@grafana/plugin-ui';\nimport {\n BackendDataSourceResponse,\n DataSourceWithBackend,\n FetchResponse,\n getBackendSrv,\n getTemplateSrv,\n toDataQueryResponse,\n TemplateSrv,\n reportInteraction,\n} from '@grafana/runtime';\n\nimport { ResponseParser } from '../ResponseParser';\nimport { SqlQueryEditorLazy } from '../components/QueryEditorLazy';\nimport { MACRO_NAMES } from '../constants';\nimport { DB, SQLQuery, SQLOptions, SqlQueryModel, QueryFormat } from '../types';\nimport migrateAnnotation from '../utils/migration';\n\nexport abstract class SqlDatasource extends DataSourceWithBackend<SQLQuery, SQLOptions> {\n id: number;\n responseParser: ResponseParser;\n name: string;\n interval: string;\n db: DB;\n preconfiguredDatabase: string;\n\n constructor(\n instanceSettings: DataSourceInstanceSettings<SQLOptions>,\n protected readonly templateSrv: TemplateSrv = getTemplateSrv()\n ) {\n super(instanceSettings);\n this.name = instanceSettings.name;\n this.responseParser = new ResponseParser();\n this.id = instanceSettings.id;\n const settingsData = instanceSettings.jsonData || {};\n this.interval = settingsData.timeInterval || '1m';\n this.db = this.getDB();\n /*\n The `settingsData.database` will be defined if a default database has been defined in either\n 1) the ConfigurationEditor.tsx, OR 2) the provisioning config file, either under `jsondata.database`, or simply `database`.\n */\n this.preconfiguredDatabase = settingsData.database ?? '';\n this.annotations = {\n prepareAnnotation: migrateAnnotation,\n QueryEditor: SqlQueryEditorLazy,\n };\n }\n\n abstract getDB(dsID?: number): DB;\n\n abstract getQueryModel(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars): SqlQueryModel;\n\n getResponseParser() {\n return this.responseParser;\n }\n\n interpolateVariable = (value: string | string[] | number, variable: VariableWithMultiSupport) => {\n if (typeof value === 'string') {\n if (variable.multi || variable.includeAll) {\n return this.getQueryModel().quoteLiteral(value);\n } else {\n return String(value).replace(/'/g, \"''\");\n }\n }\n\n if (typeof value === 'number') {\n return value;\n }\n\n if (Array.isArray(value)) {\n const quotedValues = value.map((v) => this.getQueryModel().quoteLiteral(v));\n return quotedValues.join(',');\n }\n\n return value;\n };\n\n interpolateVariablesInQueries(queries: SQLQuery[], scopedVars: ScopedVars): SQLQuery[] {\n let expandedQueries = queries;\n if (queries && queries.length > 0) {\n expandedQueries = queries.map((query) => {\n const expandedQuery = {\n ...query,\n datasource: this.getRef(),\n rawSql: this.templateSrv.replace(query.rawSql, scopedVars, this.interpolateVariable),\n rawQuery: true,\n };\n return expandedQuery;\n });\n }\n return expandedQueries;\n }\n\n filterQuery(query: SQLQuery): boolean {\n return !query.hide;\n }\n\n applyTemplateVariables(target: SQLQuery, scopedVars: ScopedVars) {\n return {\n refId: target.refId,\n datasource: this.getRef(),\n rawSql: this.templateSrv.replace(target.rawSql, scopedVars, this.interpolateVariable),\n format: target.format,\n };\n }\n\n query(request: DataQueryRequest<SQLQuery>): Observable<DataQueryResponse> {\n // This logic reenables the previous SQL behavior regarding what databases are available for the user to query.\n const databaseIssue = this.checkForDatabaseIssue(request);\n\n if (!!databaseIssue) {\n const error = new Error(databaseIssue);\n return throwError(() => error);\n }\n\n request.targets.forEach((target) => {\n if (request.app === CoreApp.Dashboard || request.app === CoreApp.PanelViewer) {\n return;\n }\n\n reportInteraction('grafana_sql_query_executed', {\n datasource: target.datasource?.type,\n editorMode: target.editorMode,\n format: target.format,\n app: request.app,\n });\n });\n\n return super.query(request);\n }\n\n private checkForDatabaseIssue(request: DataQueryRequest<SQLQuery>) {\n // If the datasource is Postgres and there is no default database configured - either never configured or removed - return a database issue.\n if (this.type === 'grafana-postgresql-datasource' && !this.preconfiguredDatabase) {\n return `You do not currently have a default database configured for this data source. Postgres requires a default\n database with which to connect. Please configure one through the Data Sources Configuration page, or if you\n are using a provisioning file, update that configuration file with a default database.`;\n }\n\n // No need to check for database change/update issues if the datasource is being used in Explore.\n if (request.app !== CoreApp.Explore) {\n /*\n If a preconfigured datasource database has been added/updated - and the user has built ANY number of queries using a\n database OTHER than the preconfigured one, return a database issue - since those databases are no longer available.\n The user will need to update their queries to use the preconfigured database.\n */\n if (!!this.preconfiguredDatabase) {\n for (const target of request.targets) {\n // Test for database configuration change only if query was made in `builder` mode.\n if (\n target.editorMode === EditorMode.Builder &&\n target.dataset &&\n target.dataset !== this.preconfiguredDatabase\n ) {\n return `The configuration for this panel's data source has been modified. The previous database used in this panel's\n saved query is no longer available. Please update the query to use the new database option.\n Previous query parameters will be preserved until the query is updated.`;\n }\n }\n }\n }\n\n return;\n }\n\n async metricFindQuery(query: string, options?: LegacyMetricFindQueryOptions): Promise<MetricFindValue[]> {\n const range = options?.range;\n if (range == null) {\n // i cannot create a scenario where this happens, we handle it just to be sure.\n return [];\n }\n\n let refId = 'tempvar';\n if (options && options.variable && options.variable.name) {\n refId = options.variable.name;\n }\n\n const scopedVars = {\n ...options?.scopedVars,\n ...getSearchFilterScopedVar({ query, wildcardChar: '%', options }),\n };\n\n const rawSql = this.templateSrv.replace(query, scopedVars, this.interpolateVariable);\n\n const interpolatedQuery: SQLQuery = {\n refId: refId,\n datasource: this.getRef(),\n rawSql,\n format: QueryFormat.Table,\n };\n\n // NOTE: we can remove this try-catch when https://github.com/grafana/grafana/issues/82250\n // is fixed.\n let response;\n try {\n response = await this.runMetaQuery(interpolatedQuery, range);\n } catch (error) {\n console.error(error);\n throw new Error('error when executing the sql query');\n }\n return this.getResponseParser().transformMetricFindResponse(response);\n }\n\n // NOTE: this always runs with the `@grafana/data/getDefaultTimeRange` time range\n async runSql<T extends object>(query: string, options?: RunSQLOptions) {\n const range = getDefaultTimeRange();\n const frame = await this.runMetaQuery({ rawSql: query, format: QueryFormat.Table, refId: options?.refId }, range);\n return new DataFrameView<T>(frame);\n }\n\n private runMetaQuery(request: Partial<SQLQuery>, range: TimeRange): Promise<DataFrame> {\n const refId = request.refId || 'meta';\n const queries: DataQuery[] = [{ ...request, datasource: request.datasource || this.getRef(), refId }];\n\n return lastValueFrom(\n getBackendSrv()\n .fetch<BackendDataSourceResponse>({\n url: '/api/ds/query',\n method: 'POST',\n headers: this.getRequestHeaders(),\n data: {\n from: range.from.valueOf().toString(),\n to: range.to.valueOf().toString(),\n queries,\n },\n requestId: refId,\n })\n .pipe(\n map((res: FetchResponse<BackendDataSourceResponse>) => {\n const rsp = toDataQueryResponse(res, queries);\n return rsp.data[0] ?? { fields: [] };\n })\n )\n );\n }\n\n targetContainsTemplate(target: SQLQuery) {\n let queryWithoutMacros = target.rawSql;\n MACRO_NAMES.forEach((value) => {\n queryWithoutMacros = queryWithoutMacros?.replace(value, '') || '';\n });\n return this.templateSrv.containsTemplate(queryWithoutMacros);\n }\n}\n\ninterface RunSQLOptions extends LegacyMetricFindQueryOptions {\n refId?: string;\n}\n","import { Trans } from '@grafana/i18n';\nimport { config } from '@grafana/runtime';\nimport { Field, Icon, Label, Stack, Tooltip } from '@grafana/ui';\n\nimport { SQLOptions } from '../../types';\n\nimport { NumberInput } from './NumberInput';\n\ninterface Props {\n labelWidth: number;\n onMaxLifetimeChanged: (number?: number) => void;\n jsonData: SQLOptions;\n}\nexport function MaxLifetimeField({ labelWidth, onMaxLifetimeChanged, jsonData }: Props) {\n return (\n <Field\n label={\n <Label>\n <Stack gap={0.5}>\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.max-lifetime\">Max lifetime</Trans>\n </span>\n <Tooltip\n content={\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.content-max-lifetime\">\n The maximum amount of time in seconds a connection may be reused. If set to 0, connections are\n reused forever.\n </Trans>\n </span>\n }\n >\n <Icon name=\"info-circle\" size=\"sm\" />\n </Tooltip>\n </Stack>\n </Label>\n }\n >\n <NumberInput\n value={jsonData.connMaxLifetime}\n defaultValue={config.sqlConnectionLimits.connMaxLifetime}\n onChange={onMaxLifetimeChanged}\n width={labelWidth}\n />\n </Field>\n );\n}\n","import { Trans } from '@grafana/i18n';\nimport { config } from '@grafana/runtime';\nimport { Field, Icon, Label, Stack, Tooltip } from '@grafana/ui';\n\nimport { SQLOptions } from '../../types';\n\nimport { NumberInput } from './NumberInput';\n\ninterface Props {\n labelWidth: number;\n onMaxConnectionsChanged: (number?: number) => void;\n jsonData: SQLOptions;\n}\n\nexport function MaxOpenConnectionsField({ labelWidth, onMaxConnectionsChanged, jsonData }: Props) {\n return (\n <Field\n label={\n <Label>\n <Stack gap={0.5}>\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.max-open\">Max open</Trans>\n </span>\n <Tooltip\n content={\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.content-max-open\">\n The maximum number of open connections to the database. If <i>Max idle connections</i> is greater\n than 0 and the <i>Max open connections</i> is less than <i>Max idle connections</i>, then\n <i>Max idle connections</i> will be reduced to match the <i>Max open connections</i> limit. If set\n to 0, there is no limit on the number of open connections.\n </Trans>\n </span>\n }\n >\n <Icon name=\"info-circle\" size=\"sm\" />\n </Tooltip>\n </Stack>\n </Label>\n }\n >\n <NumberInput\n value={jsonData.maxOpenConns}\n defaultValue={config.sqlConnectionLimits.maxOpenConns}\n onChange={onMaxConnectionsChanged}\n width={labelWidth}\n />\n </Field>\n );\n}\n","import { DataSourceSettings } from '@grafana/data';\nimport { t, Trans } from '@grafana/i18n';\nimport { ConfigSubSection } from '@grafana/plugin-ui';\nimport { config } from '@grafana/runtime';\nimport { Field, Icon, InlineLabel, Label, Stack, Switch, Tooltip } from '@grafana/ui';\n\nimport { SQLConnectionLimits, SQLOptions } from '../../types';\n\nimport { MaxLifetimeField } from './MaxLifetimeField';\nimport { MaxOpenConnectionsField } from './MaxOpenConnectionsField';\nimport { NumberInput } from './NumberInput';\n\ninterface Props<T> {\n onOptionsChange: Function;\n options: DataSourceSettings<SQLOptions>;\n}\n\nexport const ConnectionLimits = <T extends SQLConnectionLimits>(props: Props<T>) => {\n const { onOptionsChange, options } = props;\n const jsonData = options.jsonData;\n const autoIdle = jsonData.maxIdleConnsAuto !== undefined ? jsonData.maxIdleConnsAuto : false;\n\n // Update JSON data with new values\n const updateJsonData = (values: {}) => {\n const newOpts = {\n ...options,\n jsonData: {\n ...jsonData,\n ...values,\n },\n };\n\n return onOptionsChange(newOpts);\n };\n\n // For the case of idle connections and connection lifetime\n // use a shared function to update respective properties\n const onJSONDataNumberChanged = (property: keyof SQLConnectionLimits) => {\n return (number?: number) => {\n updateJsonData({ [property]: number });\n };\n };\n\n // When the maximum number of connections is changed\n // see if we have the automatic idle option enabled\n const onMaxConnectionsChanged = (number?: number) => {\n if (autoIdle && number) {\n updateJsonData({\n maxOpenConns: number,\n maxIdleConns: number,\n });\n } else {\n updateJsonData({\n maxOpenConns: number,\n });\n }\n };\n\n // Update auto idle setting when control is toggled\n // and set minimum idle connections if automatic\n // is selected\n const onConnectionIdleAutoChanged = () => {\n let idleConns = undefined;\n let maxConns = undefined;\n\n // If the maximum number of open connections is undefined\n // and we're setting auto idle then set the default amount\n // otherwise take the numeric amount and get the value from that\n if (!autoIdle) {\n if (jsonData.maxOpenConns !== undefined) {\n maxConns = jsonData.maxOpenConns;\n idleConns = jsonData.maxOpenConns;\n }\n } else {\n maxConns = jsonData.maxOpenConns;\n idleConns = jsonData.maxIdleConns;\n }\n\n updateJsonData({\n maxIdleConnsAuto: !autoIdle,\n maxIdleConns: idleConns,\n maxOpenConns: maxConns,\n });\n };\n\n const labelWidth = 40;\n\n return (\n <ConfigSubSection\n title={t('grafana-sql.components.connection-limits.title-connection-limits', 'Connection limits')}\n >\n <MaxOpenConnectionsField\n labelWidth={labelWidth}\n onMaxConnectionsChanged={onMaxConnectionsChanged}\n jsonData={jsonData}\n />\n\n <Field\n label={\n <Label>\n <Stack gap={0.5}>\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.auto-max-idle\">Auto max idle</Trans>\n </span>\n <Tooltip\n content={\n <span>\n <Trans\n i18nKey=\"grafana-sql.components.connection-limits.content-auto-max-idle\"\n values={{ defaultMaxIdle: config.sqlConnectionLimits.maxIdleConns }}\n >\n If enabled, automatically set the number of <i>Maximum idle connections</i> to the same value as\n <i> Max open connections</i>. If the number of maximum open connections is not set it will be set\n to the default ({'{{defaultMaxIdle}}'}).\n </Trans>\n </span>\n }\n >\n <Icon name=\"info-circle\" size=\"sm\" />\n </Tooltip>\n </Stack>\n </Label>\n }\n >\n <Switch value={autoIdle} onChange={onConnectionIdleAutoChanged} />\n </Field>\n\n <Field\n label={\n <Label>\n <Stack gap={0.5}>\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.max-idle\">Max idle</Trans>\n </span>\n <Tooltip\n content={\n <span>\n <Trans i18nKey=\"grafana-sql.components.connection-limits.content-max-idle\">\n The maximum number of connections in the idle connection pool.If <i>Max open connections</i> is\n greater than 0 but less than the <i>Max idle connections</i>, then the <i>Max idle connections</i>{' '}\n will be reduced to match the <i>Max open connections</i> limit. If set to 0, no idle connections\n are retained.\n </Trans>\n </span>\n }\n >\n <Icon name=\"info-circle\" size=\"sm\" />\n </Tooltip>\n </Stack>\n </Label>\n }\n >\n {autoIdle ? (\n <InlineLabel width={labelWidth}>{options.jsonData.maxIdleConns}</InlineLabel>\n ) : (\n <NumberInput\n value={jsonData.maxIdleConns}\n defaultValue={config.sqlConnectionLimits.maxIdleConns}\n onChange={(value) => {\n onJSONDataNumberChanged('maxIdleConns')(value);\n }}\n width={labelWidth}\n />\n )}\n </Field>\n\n <MaxLifetimeField\n labelWidth={labelWidth}\n onMaxLifetimeChanged={onJSONDataNumberChanged('connMaxLifetime')}\n jsonData={jsonData}\n />\n </ConfigSubSection>\n );\n};\n","import { createMonitoringLogger } from '@grafana/runtime';\n\nexport const sqlPluginLogger = createMonitoringLogger('features.plugins.sql');\n","import { useEffect } from 'react';\n\nimport { DataSourcePluginOptionsEditorProps } from '@grafana/data';\nimport { config } from '@grafana/runtime';\n\nimport { SQLOptions } from '../../types';\nimport { sqlPluginLogger } from '../../utils/logging';\n\n/**\n * 1. Moves the database field from the options object to jsonData.database and empties the database field.\n * 2. If max open connections, max idle connections, and auto idle are all undefined set these to default values.\n */\nexport function useMigrateDatabaseFields<T extends SQLOptions, S = {}>({\n onOptionsChange,\n options,\n}: DataSourcePluginOptionsEditorProps<T, S>) {\n useEffect(() => {\n const jsonData = options.jsonData;\n let newOptions = { ...options };\n let optionsUpdated = false;\n\n // Migrate the database field from the column into the jsonData object\n if (options.database) {\n sqlPluginLogger.logDebug(`Migrating from options.database with value ${options.database} for ${options.name}`);\n newOptions.database = '';\n newOptions.jsonData = { ...jsonData, database: options.database };\n optionsUpdated = true;\n }\n\n // Set default values for max open connections, max idle connection,\n // and auto idle if they're all undefined\n if (\n jsonData.maxOpenConns === undefined &&\n jsonData.maxIdleConns === undefined &&\n jsonData.maxIdleConnsAuto === undefined\n ) {\n const { maxOpenConns, maxIdleConns } = config.sqlConnectionLimits;\n\n sqlPluginLogger.logDebug(\n `Setting default max open connections to ${maxOpenConns} and setting max idle connection to ${maxIdleConns}`\n );\n\n // Spread from the jsonData in new options in case\n // the database field was migrated as well\n newOptions.jsonData = {\n ...newOptions.jsonData,\n maxOpenConns: maxOpenConns,\n maxIdleConns: maxIdleConns,\n maxIdleConnsAuto: true,\n };\n\n // Make sure we issue an update if options changed\n optionsUpdated = true;\n }\n\n // If the maximum connection lifetime hasn't been\n // otherwise set fill in with the default from configuration\n if (jsonData.connMaxLifetime === undefined) {\n const { connMaxLifetime } = config.sqlConnectionLimits;\n\n // Spread new options and add our value\n newOptions.jsonData = {\n ...newOptions.jsonData,\n connMaxLifetime: connMaxLifetime,\n };\n\n // Note that we've updated the options\n optionsUpdated = true;\n }\n\n // Only issue an update if we changed options\n if (optionsUpdated) {\n onOptionsChange(newOptions);\n }\n }, [onOptionsChange, options]);\n}\n","import { LANGUAGES, ResourceLoader, Resources } from '@grafana/i18n';\n\nconst resources = LANGUAGES.reduce<Record<string, () => Promise<{ default: Resources }>>>((acc, lang) => {\n acc[lang.code] = async () => await import(`./locales/${lang.code}/grafana-sql.json`);\n return acc;\n}, {});\n\nexport const loadResources: ResourceLoader = async (resolvedLanguage: string) => {\n const translation = await resources[resolvedLanguage]();\n return translation.default;\n};\n","/**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\nfunction baseIsNaN(value) {\n return value !== value;\n}\n\nmodule.exports = baseIsNaN;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n}\n\nmodule.exports = cloneBuffer;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var Stack = require('./_Stack'),\n assignMergeValue = require('./_assignMergeValue'),\n baseFor = require('./_baseFor'),\n baseMergeDeep = require('./_baseMergeDeep'),\n isObject = require('./isObject'),\n keysIn = require('./keysIn'),\n safeGet = require('./_safeGet');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n}\n\nmodule.exports = baseMerge;\n","var Stack = require('./_Stack'),\n equalArrays = require('./_equalArrays'),\n equalByTag = require('./_equalByTag'),\n equalObjects = require('./_equalObjects'),\n getTag = require('./_getTag'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _tokenTypes = _interopRequireDefault(require(\"./tokenTypes\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar INLINE_MAX_LENGTH = 50;\n/**\r\n * Bookkeeper for inline blocks.\r\n *\r\n * Inline blocks are parenthesized expressions that are shorter than INLINE_MAX_LENGTH.\r\n * These blocks are formatted on a single line, unlike longer parenthesized\r\n * expressions where open-parenthesis causes newline and increase of indentation.\r\n */\n\nvar InlineBlock =\n/*#__PURE__*/\nfunction () {\n function InlineBlock() {\n _classCallCheck(this, InlineBlock);\n\n this.level = 0;\n }\n /**\r\n * Begins inline block when lookahead through upcoming tokens determines\r\n * that the block would be smaller than INLINE_MAX_LENGTH.\r\n * @param {Object[]} tokens Array of all tokens\r\n * @param {Number} index Current token position\r\n */\n\n\n _createClass(InlineBlock, [{\n key: \"beginIfPossible\",\n value: function beginIfPossible(tokens, index) {\n if (this.level === 0 && this.isInlineBlock(tokens, index)) {\n this.level = 1;\n } else if (this.level > 0) {\n this.level++;\n } else {\n this.level = 0;\n }\n }\n /**\r\n * Finishes current inline block.\r\n * There might be several nested ones.\r\n */\n\n }, {\n key: \"end\",\n value: function end() {\n this.level--;\n }\n /**\r\n * True when inside an inline block\r\n * @return {Boolean}\r\n */\n\n }, {\n key: \"isActive\",\n value: function isActive() {\n return this.level > 0;\n } // Check if this should be an inline parentheses block\n // Examples are \"NOW()\", \"COUNT(*)\", \"int(10)\", key(`some_column`), DECIMAL(7,2)\n\n }, {\n key: \"isInlineBlock\",\n value: function isInlineBlock(tokens, index) {\n var length = 0;\n var level = 0;\n\n for (var i = index; i < tokens.length; i++) {\n var token = tokens[i];\n length += token.value.length; // Overran max length\n\n if (length > INLINE_MAX_LENGTH) {\n return false;\n }\n\n if (token.type === _tokenTypes[\"default\"].OPEN_PAREN) {\n level++;\n } else if (token.type === _tokenTypes[\"default\"].CLOSE_PAREN) {\n level--;\n\n if (level === 0) {\n return true;\n }\n }\n\n if (this.isForbiddenToken(token)) {\n return false;\n }\n }\n\n return false;\n } // Reserved words that cause newlines, comments and semicolons\n // are not allowed inside inline parentheses block\n\n }, {\n key: \"isForbiddenToken\",\n value: function isForbiddenToken(_ref) {\n var type = _ref.type,\n value = _ref.value;\n return type === _tokenTypes[\"default\"].RESERVED_TOP_LEVEL || type === _tokenTypes[\"default\"].RESERVED_NEWLINE || type === _tokenTypes[\"default\"].COMMENT || type === _tokenTypes[\"default\"].BLOCK_COMMENT || value === ';';\n }\n }]);\n\n return InlineBlock;\n}();\n\nexports[\"default\"] = InlineBlock;\nmodule.exports = exports.default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _includes = _interopRequireDefault(require(\"lodash/includes\"));\n\nvar _tokenTypes = _interopRequireDefault(require(\"./tokenTypes\"));\n\nvar _Indentation = _interopRequireDefault(require(\"./Indentation\"));\n\nvar _InlineBlock = _interopRequireDefault(require(\"./InlineBlock\"));\n\nvar _Params = _interopRequireDefault(require(\"./Params\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar trimSpacesEnd = function trimSpacesEnd(str) {\n return str.replace(/[\\t ]+$/, '');\n};\n\nvar Formatter =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg\r\n * @param {String} cfg.language\r\n * @param {String} cfg.indent\r\n * @param {Bool} cfg.uppercase\r\n * @param {Integer} cfg.linesBetweenQueries\r\n * @param {Object} cfg.params\r\n * @param {Tokenizer} tokenizer\r\n */\n function Formatter(cfg, tokenizer, tokenOverride) {\n _classCallCheck(this, Formatter);\n\n this.cfg = cfg || {};\n this.indentation = new _Indentation[\"default\"](this.cfg.indent);\n this.inlineBlock = new _InlineBlock[\"default\"]();\n this.params = new _Params[\"default\"](this.cfg.params);\n this.tokenizer = tokenizer;\n this.tokenOverride = tokenOverride;\n this.previousReservedWord = {};\n this.tokens = [];\n this.index = 0;\n }\n /**\r\n * Formats whitespace in a SQL string to make it easier to read.\r\n *\r\n * @param {String} query The SQL query string\r\n * @return {String} formatted query\r\n */\n\n\n _createClass(Formatter, [{\n key: \"format\",\n value: function format(query) {\n this.tokens = this.tokenizer.tokenize(query);\n var formattedQuery = this.getFormattedQueryFromTokens();\n return formattedQuery.trim();\n }\n }, {\n key: \"getFormattedQueryFromTokens\",\n value: function getFormattedQueryFromTokens() {\n var _this = this;\n\n var formattedQuery = '';\n this.tokens.forEach(function (token, index) {\n _this.index = index;\n if (_this.tokenOverride) token = _this.tokenOverride(token, _this.previousReservedWord) || token;\n\n if (token.type === _tokenTypes[\"default\"].WHITESPACE) {// ignore (we do our own whitespace formatting)\n } else if (token.type === _tokenTypes[\"default\"].LINE_COMMENT) {\n formattedQuery = _this.formatLineComment(token, formattedQuery);\n } else if (token.type === _tokenTypes[\"default\"].BLOCK_COMMENT) {\n formattedQuery = _this.formatBlockComment(token, formattedQuery);\n } else if (token.type === _tokenTypes[\"default\"].RESERVED_TOP_LEVEL) {\n formattedQuery = _this.formatTopLevelReservedWord(token, formattedQuery);\n _this.previousReservedWord = token;\n } else if (token.type === _tokenTypes[\"default\"].RESERVED_TOP_LEVEL_NO_INDENT) {\n formattedQuery = _this.formatTopLevelReservedWordNoIndent(token, formattedQuery);\n _this.previousReservedWord = token;\n } else if (token.type === _tokenTypes[\"default\"].RESERVED_NEWLINE) {\n formattedQuery = _this.formatNewlineReservedWord(token, formattedQuery);\n _this.previousReservedWord = token;\n } else if (token.type === _tokenTypes[\"default\"].RESERVED) {\n formattedQuery = _this.formatWithSpaces(token, formattedQuery);\n _this.previousReservedWord = token;\n } else if (token.type === _tokenTypes[\"default\"].OPEN_PAREN) {\n formattedQuery = _this.formatOpeningParentheses(token, formattedQuery);\n } else if (token.type === _tokenTypes[\"default\"].CLOSE_PAREN) {\n formattedQuery = _this.formatClosingParentheses(token, formattedQuery);\n } else if (token.type === _tokenTypes[\"default\"].PLACEHOLDER) {\n formattedQuery = _this.formatPlaceholder(token, formattedQuery);\n } else if (token.value === ',') {\n formattedQuery = _this.formatComma(token, formattedQuery);\n } else if (token.value === ':') {\n formattedQuery = _this.formatWithSpaceAfter(token, formattedQuery);\n } else if (token.value === '.') {\n formattedQuery = _this.formatWithoutSpaces(token, formattedQuery);\n } else if (token.value === ';') {\n formattedQuery = _this.formatQuerySeparator(token, formattedQuery);\n } else {\n formattedQuery = _this.formatWithSpaces(token, formattedQuery);\n }\n });\n return formattedQuery;\n }\n }, {\n key: \"formatLineComment\",\n value: function formatLineComment(token, query) {\n return this.addNewline(query + token.value);\n }\n }, {\n key: \"formatBlockComment\",\n value: function formatBlockComment(token, query) {\n return this.addNewline(this.addNewline(query) + this.indentComment(token.value));\n }\n }, {\n key: \"indentComment\",\n value: function indentComment(comment) {\n return comment.replace(/\\n[\\t ]*/g, '\\n' + this.indentation.getIndent() + ' ');\n }\n }, {\n key: \"formatTopLevelReservedWordNoIndent\",\n value: function formatTopLevelReservedWordNoIndent(token, query) {\n this.indentation.decreaseTopLevel();\n query = this.addNewline(query) + this.equalizeWhitespace(this.formatReservedWord(token.value));\n return this.addNewline(query);\n }\n }, {\n key: \"formatTopLevelReservedWord\",\n value: function formatTopLevelReservedWord(token, query) {\n this.indentation.decreaseTopLevel();\n query = this.addNewline(query);\n this.indentation.increaseTopLevel();\n query += this.equalizeWhitespace(this.formatReservedWord(token.value));\n return this.addNewline(query);\n }\n }, {\n key: \"formatNewlineReservedWord\",\n value: function formatNewlineReservedWord(token, query) {\n return this.addNewline(query) + this.equalizeWhitespace(this.formatReservedWord(token.value)) + ' ';\n } // Replace any sequence of whitespace characters with single space\n\n }, {\n key: \"equalizeWhitespace\",\n value: function equalizeWhitespace(string) {\n return string.replace(/[\\t-\\r \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]+/g, ' ');\n } // Opening parentheses increase the block indent level and start a new line\n\n }, {\n key: \"formatOpeningParentheses\",\n value: function formatOpeningParentheses(token, query) {\n // Take out the preceding space unless there was whitespace there in the original query\n // or another opening parens or line comment\n var preserveWhitespaceFor = [_tokenTypes[\"default\"].WHITESPACE, _tokenTypes[\"default\"].OPEN_PAREN, _tokenTypes[\"default\"].LINE_COMMENT];\n\n if (!(0, _includes[\"default\"])(preserveWhitespaceFor, this.previousToken().type)) {\n query = trimSpacesEnd(query);\n }\n\n query += this.cfg.uppercase ? token.value.toUpperCase() : token.value;\n this.inlineBlock.beginIfPossible(this.tokens, this.index);\n\n if (!this.inlineBlock.isActive()) {\n this.indentation.increaseBlockLevel();\n query = this.addNewline(query);\n }\n\n return query;\n } // Closing parentheses decrease the block indent level\n\n }, {\n key: \"formatClosingParentheses\",\n value: function formatClosingParentheses(token, query) {\n token.value = this.cfg.uppercase ? token.value.toUpperCase() : token.value;\n\n if (this.inlineBlock.isActive()) {\n this.inlineBlock.end();\n return this.formatWithSpaceAfter(token, query);\n } else {\n this.indentation.decreaseBlockLevel();\n return this.formatWithSpaces(token, this.addNewline(query));\n }\n }\n }, {\n key: \"formatPlaceholder\",\n value: function formatPlaceholder(token, query) {\n return query + this.params.get(token) + ' ';\n } // Commas start a new line (unless within inline parentheses or SQL \"LIMIT\" clause)\n\n }, {\n key: \"formatComma\",\n value: function formatComma(token, query) {\n query = trimSpacesEnd(query) + token.value + ' ';\n\n if (this.inlineBlock.isActive()) {\n return query;\n } else if (/^LIMIT$/i.test(this.previousReservedWord.value)) {\n return query;\n } else {\n return this.addNewline(query);\n }\n }\n }, {\n key: \"formatWithSpaceAfter\",\n value: function formatWithSpaceAfter(token, query) {\n return trimSpacesEnd(query) + token.value + ' ';\n }\n }, {\n key: \"formatWithoutSpaces\",\n value: function formatWithoutSpaces(token, query) {\n return trimSpacesEnd(query) + token.value;\n }\n }, {\n key: \"formatWithSpaces\",\n value: function formatWithSpaces(token, query) {\n var value = token.type === 'reserved' ? this.formatReservedWord(token.value) : token.value;\n return query + value + ' ';\n }\n }, {\n key: \"formatReservedWord\",\n value: function formatReservedWord(value) {\n return this.cfg.uppercase ? value.toUpperCase() : value;\n }\n }, {\n key: \"formatQuerySeparator\",\n value: function formatQuerySeparator(token, query) {\n this.indentation.resetIndentation();\n return trimSpacesEnd(query) + token.value + '\\n'.repeat(this.cfg.linesBetweenQueries || 1);\n }\n }, {\n key: \"addNewline\",\n value: function addNewline(query) {\n query = trimSpacesEnd(query);\n if (!query.endsWith('\\n')) query += '\\n';\n return query + this.indentation.getIndent();\n }\n }, {\n key: \"previousToken\",\n value: function previousToken() {\n var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n return this.tokens[this.index - offset] || {};\n }\n }]);\n\n return Formatter;\n}();\n\nexports[\"default\"] = Formatter;\nmodule.exports = exports.default;","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var baseFlatten = require('./_baseFlatten');\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, 1) : [];\n}\n\nmodule.exports = flatten;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n}\n\nmodule.exports = arraySome;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = stubFalse;\n","/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeCeil = Math.ceil,\n nativeMax = Math.max;\n\n/**\n * The base implementation of `_.range` and `_.rangeRight` which doesn't\n * coerce arguments.\n *\n * @private\n * @param {number} start The start of the range.\n * @param {number} end The end of the range.\n * @param {number} step The value to increment or decrement by.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Array} Returns the range of numbers.\n */\nfunction baseRange(start, end, step, fromRight) {\n var index = -1,\n length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n result = Array(length);\n\n while (length--) {\n result[fromRight ? length : ++index] = start;\n start += step;\n }\n return result;\n}\n\nmodule.exports = baseRange;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\nmodule.exports = arrayFilter;\n","var isObject = require('./isObject'),\n isPrototype = require('./_isPrototype'),\n nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeysIn;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n/**\r\n * Handles placeholder replacement with given params.\r\n */\nvar Params =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} params\r\n */\n function Params(params) {\n _classCallCheck(this, Params);\n\n this.params = params;\n this.index = 0;\n }\n /**\r\n * Returns param value that matches given placeholder with param key.\r\n * @param {Object} token\r\n * @param {String} token.key Placeholder key\r\n * @param {String} token.value Placeholder value\r\n * @return {String} param or token.value when params are missing\r\n */\n\n\n _createClass(Params, [{\n key: \"get\",\n value: function get(_ref) {\n var key = _ref.key,\n value = _ref.value;\n\n if (!this.params) {\n return value;\n }\n\n if (key) {\n return this.params[key];\n }\n\n return this.params[this.index++];\n }\n }]);\n\n return Params;\n}();\n\nexports[\"default\"] = Params;\nmodule.exports = exports.default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports[\"default\"] = void 0;\n\nvar _Formatter = _interopRequireDefault(require(\"../core/Formatter\"));\n\nvar _Tokenizer = _interopRequireDefault(require(\"../core/Tokenizer\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar reservedWords = ['ALL', 'ALTER', 'ANALYZE', 'AND', 'ANY', 'ARRAY', 'AS', 'ASC', 'BEGIN', 'BETWEEN', 'BINARY', 'BOOLEAN', 'BREAK', 'BUCKET', 'BUILD', 'BY', 'CALL', 'CASE', 'CAST', 'CLUSTER', 'COLLATE', 'COLLECTION', 'COMMIT', 'CONNECT', 'CONTINUE', 'CORRELATE', 'COVER', 'CREATE', 'DATABASE', 'DATASET', 'DATASTORE', 'DECLARE', 'DECREMENT', 'DELETE', 'DERIVED', 'DESC', 'DESCRIBE', 'DISTINCT', 'DO', 'DROP', 'EACH', 'ELEMENT', 'ELSE', 'END', 'EVERY', 'EXCEPT', 'EXCLUDE', 'EXECUTE', 'EXISTS', 'EXPLAIN', 'FALSE', 'FETCH', 'FIRST', 'FLATTEN', 'FOR', 'FORCE', 'FROM', 'FUNCTION', 'GRANT', 'GROUP', 'GSI', 'HAVING', 'IF', 'IGNORE', 'ILIKE', 'IN', 'INCLUDE', 'INCREMENT', 'INDEX', 'INFER', 'INLINE', 'INNER', 'INSERT', 'INTERSECT', 'INTO', 'IS', 'JOIN', 'KEY', 'KEYS', 'KEYSPACE', 'KNOWN', 'LAST', 'LEFT', 'LET', 'LETTING', 'LIKE', 'LIMIT', 'LSM', 'MAP', 'MAPPING', 'MATCHED', 'MATERIALIZED', 'MERGE', 'MISSING', 'NAMESPACE', 'NEST', 'NOT', 'NULL', 'NUMBER', 'OBJECT', 'OFFSET', 'ON', 'OPTION', 'OR', 'ORDER', 'OUTER', 'OVER', 'PARSE', 'PARTITION', 'PASSWORD', 'PATH', 'POOL', 'PREPARE', 'PRIMARY', 'PRIVATE', 'PRIVILEGE', 'PROCEDURE', 'PUBLIC', 'RAW', 'REALM', 'REDUCE', 'RENAME', 'RETURN', 'RETURNING', 'REVOKE', 'RIGHT', 'ROLE', 'ROLLBACK', 'SATISFIES', 'SCHEMA', 'SELECT', 'SELF', 'SEMI', 'SET', 'SHOW', 'SOME', 'START', 'STATISTICS', 'STRING', 'SYSTEM', 'THEN', 'TO', 'TRANSACTION', 'TRIGGER', 'TRUE', 'TRUNCATE', 'UNDER', 'UNION', 'UNIQUE', 'UNKNOWN', 'UNNEST', 'UNSET', 'UPDATE', 'UPSERT', 'USE', 'USER', 'USING', 'VALIDATE', 'VALUE', 'VALUED', 'VALUES', 'VIA', 'VIEW', 'WHEN', 'WHERE', 'WHILE', 'WITH', 'WITHIN', 'WORK', 'XOR'];\nvar reservedTopLevelWords = ['DELETE FROM', 'EXCEPT ALL', 'EXCEPT', 'EXPLAIN DELETE FROM', 'EXPLAIN UPDATE', 'EXPLAIN UPSERT', 'FROM', 'GROUP BY', 'HAVING', 'INFER', 'INSERT INTO', 'LET', 'LIMIT', 'MERGE', 'NEST', 'ORDER BY', 'PREPARE', 'SELECT', 'SET CURRENT SCHEMA', 'SET SCHEMA', 'SET', 'UNNEST', 'UPDATE', 'UPSERT', 'USE KEYS', 'VALUES', 'WHERE'];\nvar reservedTopLevelWordsNoIndent = ['INTERSECT', 'INTERSECT ALL', 'MINUS', 'UNION', 'UNION ALL'];\nvar reservedNewlineWords = ['AND', 'INNER JOIN', 'JOIN', 'LEFT JOIN', 'LEFT OUTER JOIN', 'OR', 'OUTER JOIN', 'RIGHT JOIN', 'RIGHT OUTER JOIN', 'XOR'];\nvar tokenizer;\n\nvar N1qlFormatter =\n/*#__PURE__*/\nfunction () {\n /**\r\n * @param {Object} cfg Different set of configurations\r\n */\n function N1qlFormatter(cfg) {\n _classCallCheck(this, N1qlFormatter);\n\n this.cfg = cfg;\n }\n /**\r\n * Format the whitespace in a N1QL string to make it easier to read\r\n *\r\n * @param {String} query The N1QL string\r\n * @return {String} formatted string\r\n */\n\n\n _createClass(N1qlFormatter, [{\n key: \"format\",\n value: function format(query) {\n if (!tokenizer) {\n tokenizer = new _Tokenizer[\"default\"]({\n reservedWords: reservedWords,\n reservedTopLevelWords: reservedTopLevelWords,\n reservedNewlineWords: reservedNewlineWords,\n reservedTopLevelWordsNoIndent: reservedTopLevelWordsNoIndent,\n stringTypes: [\"\\\"\\\"\", \"''\", '``'],\n openParens: ['(', '[', '{'],\n closeParens: [')', ']', '}'],\n namedPlaceholderTypes: ['$'],\n lineCommentTypes: ['#', '--']\n });\n }\n\n return new _Formatter[\"default\"](this.cfg, tokenizer).format(query);\n }\n }]);\n\n return N1qlFormatter;\n}();\n\nexports[\"default\"] = N1qlFormatter;\nmodule.exports = exports.default;","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n if (typeof globalThis === \"object\") {\n globalThis.regeneratorRuntime = runtime;\n } else {\n Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n }\n}\n","var baseRest = require('./_baseRest'),\n isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n}\n\nmodule.exports = createAssigner;\n","var isObject = require('./isObject'),\n now = require('./now'),\n toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n clearTimeout(timerId);\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n}\n\nmodule.exports = debounce;\n","var baseFindIndex = require('./_baseFindIndex'),\n baseIsNaN = require('./_baseIsNaN'),\n strictIndexOf = require('./_strictIndexOf');\n\n/**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseIndexOf(array, value, fromIndex) {\n return value === value\n ? strictIndexOf(array, value, fromIndex)\n : baseFindIndex(array, baseIsNaN, fromIndex);\n}\n\nmodule.exports = baseIndexOf;\n","export const ENGLISH_US = 'en-US';\nexport const FRENCH_FRANCE = 'fr-FR';\nexport const SPANISH_SPAIN = 'es-ES';\nexport const GERMAN_GERMANY = 'de-DE';\nexport const BRAZILIAN_PORTUGUESE = 'pt-BR';\nexport const CHINESE_SIMPLIFIED = 'zh-Hans';\nexport const ITALIAN_ITALY = 'it-IT';\nexport const JAPANESE_JAPAN = 'ja-JP';\nexport const INDONESIAN_INDONESIA = 'id-ID';\nexport const KOREAN_KOREA = 'ko-KR';\nexport const RUSSIAN_RUSSIA = 'ru-RU';\nexport const CZECH_CZECHIA = 'cs-CZ';\nexport const DUTCH_NETHERLANDS = 'nl-NL';\nexport const HUNGARIAN_HUNGARY = 'hu-HU';\nexport const PORTUGUESE_PORTUGAL = 'pt-PT';\nexport const POLISH_POLAND = 'pl-PL';\nexport const SWEDISH_SWEDEN = 'sv-SE';\nexport const TURKISH_TURKEY = 'tr-TR';\nexport const CHINESE_TRADITIONAL = 'zh-Hant';\n\nexport const DEFAULT_LANGUAGE = ENGLISH_US;\nexport const PSEUDO_LOCALE = 'pseudo';\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","var baseGetTag = require('./_baseGetTag'),\n isLength = require('./isLength'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","var Symbol = require('./_Symbol'),\n arrayMap = require('./_arrayMap'),\n isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","\n import amdMetaModule from 'amd-module';\n\n __webpack_public_path__ =\n amdMetaModule && amdMetaModule.uri\n ? amdMetaModule.uri.slice(0, amdMetaModule.uri.lastIndexOf('/') + 1)\n : 'public/plugins/mssql/';\n ","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\nmodule.exports = mapToArray;\n","var baseRepeat = require('./_baseRepeat'),\n isIterateeCall = require('./_isIterateeCall'),\n toInteger = require('./toInteger'),\n toString = require('./toString');\n\n/**\n * Repeats the given string `n` times.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to repeat.\n * @param {number} [n=1] The number of times to repeat the string.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the repeated string.\n * @example\n *\n * _.repeat('*', 3);\n * // => '***'\n *\n * _.repeat('abc', 2);\n * // => 'abcabc'\n *\n * _.repeat('abc', 0);\n * // => ''\n */\nfunction repeat(string, n, guard) {\n if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n n = 1;\n } else {\n n = toInteger(n);\n }\n return baseRepeat(toString(string), n);\n}\n\nmodule.exports = repeat;\n","var baseGet = require('./_baseGet'),\n baseSet = require('./_baseSet'),\n castPath = require('./_castPath');\n\n/**\n * The base implementation of `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n var index = -1,\n length = paths.length,\n result = {};\n\n while (++index < length) {\n var path = paths[index],\n value = baseGet(object, path);\n\n if (predicate(value, path)) {\n baseSet(result, castPath(path, object), value);\n }\n }\n return result;\n}\n\nmodule.exports = basePickBy;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + (chunkId === 168 ? \"sql-query-editor\" : chunkId) + \".js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.p = \"public/plugins/mssql/\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t231: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = globalThis[\"webpackChunkmssql\"] = globalThis[\"webpackChunkmssql\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","// startup\n// Load entry module and return exports\n// This entry module used 'module' so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(3963);\n"],"names":["hasSymbol","webpackQueues","webpackExports","webpackError","resolveQueue","leafPrototypes","getProto","inProgress","dataWebpackPrefix","basePickBy","hasIn","module","exports","object","paths","value","path","baseGetAllKeys","getSymbols","keys","factory","modules","installedModules","moduleId","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","property","prototype","hasOwnProperty","p","s","__webpack_require__","SpelNode","create","nodeType","position","activeContext","node","type","children","parent","_type","getType","setType","getChildren","addChild","childNode","setParent","message","JSON","stringify","push","getParent","parentNode","getContext","state","peek","setContext","nodeContext","getStartPosition","getEndPosition","getValue","toString","length","_len","arguments","operands","Array","_key","forEach","operand","Stack","startingElements","this","elements","el","pop","empty","search","indexOf","types","LITERAL_INT","LITERAL_LONG","LITERAL_HEXINT","LITERAL_HEXLONG","LITERAL_STRING","LITERAL_REAL","LITERAL_REAL_FLOAT","LPAREN","RPAREN","COMMA","IDENTIFIER","COLON","HASH","RSQUARE","LSQUARE","LCURLY","RCURLY","DOT","PLUS","STAR","MINUS","SELECT_FIRST","SELECT_LAST","QMARK","PROJECT","DIV","GE","GT","LE","LT","EQ","NE","MOD","NOT","ASSIGN","INSTANCEOF","MATCHES","BETWEEN","SELECT","POWER","ELVIS","SAFE_NAVI","BEAN_REF","SYMBOLIC_OR","SYMBOLIC_AND","INC","DEC","TokenKind","tokenChars","_hasPayload","_ordinal","t","getLength","hasPayload","valueOf","id","ordinal","StandardContext","SpelExpressionEvaluator","undefined","_SpelExpressionEvaluator","_StandardContext","_SpelExpressionParser","_Stack","spelExpressionEvaluator","expression","compiledExpression","SpelExpressionParser","parse","eval","context","locals","rootContext","evalCompiled","_compiledExpression","compile","_TokenKind","_Tokenizer","_BooleanLiteral","_NumberLiteral","_StringLiteral","_NullLiteral","_FunctionReference","_MethodReference","_PropertyReference","_VariableReference","_CompoundExpression","_Indexer","_Assign","_OpEQ","_OpNE","_OpGE","_OpGT","_OpLE","_OpLT","_OpPlus","_OpMinus","_OpMultiply","_OpDivide","_OpModulus","_OpPower","_OpInc","_OpDec","_OpNot","_OpAnd","_OpOr","_OpMatches","_Ternary","_Elvis","_InlineList","_InlineMap","_Selection","_Projection","_OpInstanceof","_OpBetween","_TypeReference","_BeanReference","_Identifier","_QualifiedIdentifier","_ConstructorReference","expressionString","tokenStream","tokenStreamLength","tokenStreamPointer","VALID_QUALIFIED_ID_PATTERN","RegExp","constructedNodes","eatExpression","expr","eatLogicalOrExpression","moreTokens","token","peekToken","getKind","NullLiteral","toPosBounds","startPos","endPos","nextToken","assignedValue","Assign","toPosToken","valueIfNull","Elvis","ifTrueExprValue","eatToken","ifFalseExprValue","Ternary","eatLogicalAndExpression","peekIdentifierToken","peekTokenOne","rhExpr","checkOperands","OpOr","eatRelationalExpression","OpAnd","eatSumExpression","relationalOperatorToken","isNumericRelationalOperator","isIdentifier","idString","stringValue","toLowerCase","asInstanceOfToken","asMatchesToken","asBetweenToken","maybeEatRelationalOperator","tk","kind","pos","OpGT","OpLT","OpLE","OpGE","OpEQ","OpNE","OpInstanceof","OpMatches","OpBetween","eatProductExpression","peekTokenAny","checkRightOperand","OpPlus","OpMinus","eatPowerIncDecExpression","OpMultiply","OpDivide","OpModulus","eatUnaryExpression","OpPower","OpInc","OpDec","OpNot","nodes","start","NumberLiteral","parseInt","parseFloat","BooleanLiteral","StringLiteral","maybeEatLiteral","maybeEatParenExpression","typeName","PropertyReference","eatPossiblyQualifiedId","dims","peekTokenConsumeIfMatched","TypeReference","maybeEatTypeReference","nullToken","maybeEatNullReference","newToken","possiblyQualifiedConstructorName","dimensions","maybeEatInlineListOrMap","ConstructorReference","accumulatedArguments","raiseInternalException","consumeArguments","maybeEatConstructorReference","maybeEatMethodOrProperty","maybeEatFunctionOrVar","beanRefToken","beanNameToken","beanName","data","substring","BeanReference","maybeEatBeanReference","maybeEatProjection","maybeEatSelection","maybeEatIndexer","maybeEatNode","CompoundExpression","eatPrimaryExpression","nullSafeNavigation","functionOrVariableName","args","maybeEatMethodArgs","VariableReference","FunctionReference","next","Projection","listElements","closingCurly","InlineList","InlineMap","firstExpression","mapElements","Indexer","peekSelectToken","Selection","FIRST","LAST","ALL","qualifiedIdPieces","isValidQualifiedId","Identifier","QualifiedIdentifier","test","methodOrPropertyName","MethodReference","newNode","expectedKind","desiredTokenKind","consumeIfMatched","slice","identifierString","expected","actual","left","right","operandExpression","checkLeftOperand","end","setConfiguration","config","Tokenizer","tokenize","ast","e","_Token","ALTERNATIVE_OPERATOR_NAMES","FLAGS","ch","charCodeAt","IS_DIGIT","init","inputData","toProcess","max","tokens","lexQuotedStringLiteral","terminated","Token","subarray","lexDoubleQuotedStringLiteral","lexNumericLiteral","firstCharIsZero","dotpos","endOfNumber","isFloat","isReal","isDigit","pushIntToken","isChar","isExponentChar","isSign","isFloatSuffix","isDoubleSuffix","pushRealToken","isHexadecimalDigit","pushHexIntToken","lexIdentifier","asString","isAlphabetic","toUpperCase","pushOneCharOrTwoCharToken","replace","isLong","isTwoCharToken","pushCharToken","pushPairToken","a","b","process","tokenKind","tokenData","_SpelNode","setValue","newValue","stripQuotes","functionName","getRaw","compiledArgs","arg","currentActiveContext","apply","methodName","method","maybeHandleNullSafeNavigation","member","substr","charAt","isArray","includes","propertyName","getName","variableName","expressionComponents","concat","buildContextStack","childrenCount","unbuildContextStack","childCount","leftValue","rightValue","base","exp","Math","pow","postfix","int","cur","regexpString","exec","error","ifTrue","ifFalse","list","map","element","mapPieces","key","keyValue","piece","_typeof","Symbol","iterator","obj","constructor","matches","doesMatch","whichElement","collection","newCollection","filter","selectFromArray","entry","entries","returnValue","selectFromMap","projectCollection","_dims","identifierName","pieces","arr","arr2","from","_toConsumableArray","dimension","_nodes2","authentication","principal","hasRole","role","authorities","grantedAuthority","authority","hasPermission","baseIsMap","baseUnary","nodeUtil","nodeIsMap","isMap","__WEBPACK_EXTERNAL_MODULE__200__","__WEBPACK_EXTERNAL_MODULE__211__","__data__","set","baseAssignValue","eq","memoizeCapped","rePropName","reEscapeChar","stringToPath","string","result","match","number","quote","subString","func","array","index","arrayMap","baseIteratee","getAllKeysIn","predicate","props","prop","r","isNaN","done","TypeError","regeneratorDefine","_regenerator","toStringTag","Generator","u","f","y","G","v","bind","GeneratorFunction","GeneratorFunctionPrototype","getPrototypeOf","setPrototypeOf","__proto__","displayName","w","nativeNow","Date","now","count","lastCalled","stamp","remaining","arrayUnique","jsonLogic","operations","truthy","join","source","temp","String","reduce","min","not_found","sub_props","split","missing","need_count","options","are_missing","is_logic","logic","get_operator","get_values","current","scopedLogic","scopedData","initial","op","values","datum","accumulator","val","sub_ops","operation","Error","uses_data","add_operation","code","rm_operation","rule_like","rule","pattern","pattern_op","rule_op","input","isStrictComparable","baseIsEqualDeep","isObjectLike","baseIsEqual","other","bitmask","customizer","stack","_a","EditorMode","EditorMode2","toOption","LANGUAGES","ENGLISH_US","FRENCH_FRANCE","SPANISH_SPAIN","GERMAN_GERMANY","CHINESE_SIMPLIFIED","BRAZILIAN_PORTUGUESE","CHINESE_TRADITIONAL","ITALIAN_ITALY","JAPANESE_JAPAN","INDONESIAN_INDONESIA","KOREAN_KOREA","RUSSIAN_RUSSIA","CZECH_CZECHIA","DUTCH_NETHERLANDS","HUNGARIAN_HUNGARY","PORTUGUESE_PORTUGAL","POLISH_POLAND","SWEDISH_SWEDEN","TURKISH_TURKEY","nativeMax","transform","otherArgs","OverloadYield","AsyncIterator","resolve","then","asyncIterator","MSSqlQueryModel","quoteLiteral","target","templateSrv","scopedVars","applyQueryDefaults","refId","getSqlCompletionProvider","getColumns","getTables","monaco","language","getStandardSQLCompletionProvider","tables","identifier","table","parseName","processedToken","tablePath","TokenType","Whitespace","endsWith","columns","database","schema","tableName","dataset","getIcon","getRAQBType","toRawSql","sql","rawQuery","haveColumns","sqlColumns","limit","rawColumn","alias","parameters","isLimit","createSelectClause","whereString","groupBy","g","isEmpty","orderBy","orderByDirection","MssqlDatasource","SqlDatasource","getQueryModel","fetchDatasets","datasets","runSql","fields","flat","fetchTables","schemaAndName","fetchFields","query","_","getSchema","uuidv4","column","label","icon","raqbFieldType","getSqlLanguageDefinition","db","sqlLanguageDefinition","q","cols","description","fetchColumns","lookup","completionProvider","formatter","formatSQL","getDB","Promise","getEditorLanguageDefinition","validateQuery","isError","isValid","rawSql","dsID","dispose","_dsID","functions","getFunctions","parts","completion","instanceSettings","super","columnParam","required","MACRO_FUNCTIONS","COMMON_FNS","fn","getMapData","size","ConfigSubSection","getSymbolsIn","keysIn","Uint8Array","equalArrays","mapToArray","setToArray","symbolProto","symbolValueOf","tag","equalFunc","byteLength","byteOffset","buffer","convert","isPartial","stacked","WHITESPACE","WORD","STRING","RESERVED","RESERVED_TOP_LEVEL","RESERVED_TOP_LEVEL_NO_INDENT","RESERVED_NEWLINE","OPERATOR","OPEN_PAREN","CLOSE_PAREN","LINE_COMMENT","BLOCK_COMMENT","NUMBER","PLACEHOLDER","default","_classCallCheck","toPropertyKey","toPrimitive","Number","_defineProperties","writable","_createClass","_possibleConstructorReturn","ReferenceError","_getPrototypeOf","_setPrototypeOf","_inherits","_arrayWithHoles","_arrayLikeToArray","_unsupportedIterableToArray","_nonIterableRest","_iterableToArray","DELETE","SIZE","MASK","NOT_SET","SetRef","ref","OwnerID","ensureSize","iter","__iterate","returnTrue","wrapIndex","uint32Index","NaN","wholeSlice","begin","isNeg","resolveBegin","resolveIndex","resolveEnd","defaultIndex","Infinity","IS_COLLECTION_SYMBOL","isCollection","maybeCollection","Boolean","IS_KEYED_SYMBOL","isKeyed","maybeKeyed","IS_INDEXED_SYMBOL","isIndexed","maybeIndexed","isAssociative","maybeAssociative","Collection","Seq","KeyedCollection","KeyedSeq","IndexedCollection","IndexedSeq","SetCollection","SetSeq","Keyed","Indexed","Set","IS_SEQ_SYMBOL","isSeq","maybeSeq","IS_RECORD_SYMBOL","isRecord","maybeRecord","isImmutable","maybeImmutable","IS_ORDERED_SYMBOL","isOrdered","maybeOrdered","REAL_ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","ITERATOR_SYMBOL","Iterator","iteratorValue","k","iteratorResult","iteratorDone","hasIterator","maybeIterable","getIteratorFn","isIterator","maybeIterator","getIterator","iterable","iteratorFn","KEYS","VALUES","ENTRIES","inspect","toSource","isArrayLike","isInteger","emptySequence","toSeq","seq","maybeIndexedSeqFromValue","fromEntrySeq","isKeysIterable","toSetSeq","ObjectSeq","seqFromValue","__toString","cacheResult","_cache","__iterateUncached","entrySeq","toArray","reverse","cache","__iterator","__iteratorUncached","toKeyedSeq","keyedSeqFromValue","toIndexedSeq","indexedSeqFromValue","of","ArraySeq","_array","notSetValue","has","ii","getOwnPropertySymbols","_object","_keys","EMPTY_SEQ","CollectionSeq","_collection","iterations","step","IS_MAP_SYMBOL","maybeMap","isOrderedMap","maybeOrderedMap","isValueObject","maybeValue","equals","hashCode","is","valueA","valueB","imul","smi","i32","defaultValueOf","hash","hashNullish","hashNumber","STRING_HASH_CACHE_MIN_STRLEN","hashed","stringHashCache","hashString","STRING_HASH_CACHE_SIZE","STRING_HASH_CACHE_MAX_SIZE","cachedHashString","usingWeakMap","weakMap","UID_HASH_KEY","canDefineProperty","propertyIsEnumerable","uniqueID","documentElement","getIENodeHash","nextHash","isExtensible","hashJSObj","sym","symbolMap","hashSymbol","nullish","_objHashUID","WeakMap","ToKeyedSequence","indexed","useKeys","_iter","_useKeys","valueSeq","this$1$1","reversedSequence","reverseFactory","mapper","mappedSequence","mapFactory","ToIndexedSequence","ToSetSequence","FromEntriesSequence","validateEntry","indexedCollection","flipFactory","flipSequence","makeSequence","flip","cacheResultThrough","filterFactory","filterSequence","sliceFactory","originalSize","sliceSize","resolvedBegin","resolvedSize","sliceSeq","skipped","isSkipping","skipWhileFactory","skipSequence","skipping","flattenFactory","depth","flatSequence","stopped","flatDeep","currentDepth","sortFactory","comparator","defaultComparator","isKeyedCollection","sort","maxFactory","maxCompare","comp","zipWithFactory","keyIter","zipper","iters","zipAll","zipSequence","sizes","iterators","isDone","steps","every","some","reify","collectionClass","arrCopy","offset","len","newArr","invariant","condition","assertNotInfinite","coerceKeyPath","keyPath","isPlainObject","proto","parentProto","nextProto","isDataStructure","quoteString","_ignoreError","shallowCopy","to","remove","collectionCopy","splice","updateIn$1","updater","updatedValue","updateInDeeply","inImmutable","existing","wasNotSet","existingValue","nextExisting","nextUpdated","emptyMap","setIn$1","setIn","removeIn","deleteIn","update$1","update","updateIn","merge$1","mergeIntoKeyedWith","mergeWith$1","merger","collections","collection$1","__ownerID","withMutations","mergeIntoCollection","oldVal","mergeDeepWithSources","sources","mergeWithSources","deepMerger","oldValue","newDataStructure","oldSeq","newSeq","deepMergerWith","mergeWith","merge","merged","mergeItem","hasVal","nextVal","mergeDeep","mergeDeepWith","mergeIn","mergeDeepIn","mutable","asMutable","wasAltered","__ensureOwner","asImmutable","__altered","Map","keyValues","_root","updateMap","deleteAll","clear","__hash","OrderedMap","sortBy","MapIterator","iterate","ownerID","makeMap","MapPrototype","removeAll","ArrayMapNode","shift","keyHash","didChangeSize","didAlter","removed","idx","exists","MAX_ARRAY_MAP_SIZE","ValueNode","createNodes","isEditable","newEntries","BitmapIndexedNode","bitmap","bit","popCount","keyHashFrag","updateNode","MAX_BITMAP_INDEXED_SIZE","including","expandedNodes","HashArrayMapNode","expandNodes","isLeafNode","newBitmap","newNodes","setAt","canEdit","newLen","newArray","after","spliceOut","spliceIn","newCount","MIN_HASH_ARRAY_MAP_SIZE","excluding","packedII","packedNodes","packNodes","HashCollisionNode","mergeIntoNode","keyMatch","maxIndex","EMPTY_MAP","_reverse","_stack","mapIteratorFrame","mapIteratorValue","subNode","__prev","prev","root","newRoot","newSize","idx1","idx2","x","IS_LIST_SYMBOL","isList","maybeList","List","emptyList","makeList","VNode","setSize","listNodeFor","_origin","setListBounds","newTail","_tail","getTailOffset","_capacity","updateVNode","_level","updateList","insert","oldSize","unshift","arguments$1","seqs","argument","iterateList","DONE","ListPrototype","removeBefore","level","originIndex","newChild","removingFirst","oldChild","editable","editableVNode","removeAfter","sizeIndex","EMPTY_LIST","tailPos","tail","iterateNodeOrLeaf","iterateLeaf","iterateNode","origin","capacity","nodeHas","lowerNode","newLowerNode","rawIndex","owner","oldOrigin","oldCapacity","newOrigin","newCapacity","newLevel","offsetShift","oldTailOffset","newTailOffset","oldTail","beginIndex","EMPTY_ORDERED_MAP","emptyOrderedMap","_map","_list","updateOrderedMap","newMap","newList","makeOrderedMap","omap","toMap","IS_STACK_SYMBOL","isStack","maybeStack","emptyStack","pushAll","head","_head","makeStack","EMPTY_STACK","StackPrototype","unshiftAll","IS_SET_SYMBOL","isSet","maybeSet","isOrderedSet","maybeOrderedSet","deepEqual","notAssociative","flipped","allEqual","bSize","mixin","ctor","methods","keyCopier","toJS","result$1","emptySet","add","fromKeys","keySeq","intersect","sets","SetPrototype","union","updateSet","didChanges","mapEntries","mapped","toRemove","subtract","OrderedSet","__make","__empty","EMPTY_SET","makeSet","EMPTY_RANGE","Range","abs","_start","_end","_step","ceil","searchValue","possibleIndex","floor","offsetValue","lastIndexOf","getIn$1","searchKeyPath","getIn","hasIn$1","toObject","isIterable","useTuples","toOrderedMap","toOrderedSet","toSet","toStack","toList","__toStringMapper","singleton","concatSeq","flatten","sum","concatFactory","partition","isKeyedIter","groups","coerce","partitionFactory","find","findEntry","sideEffect","separator","joined","isFirst","reducer","initialReduction","reduceRight","butLast","countBy","grouper","countByFactory","entriesSequence","entryMapper","filterNot","not","found","findKey","findLast","findLastEntry","findLastKey","first","flatMap","flatMapFactory","searchKey","groupByFactory","isSubset","isSuperset","keyOf","keyMapper","last","lastKeyOf","maxBy","neg","defaultNegComparator","minBy","rest","skip","amount","skipLast","skipWhile","skipUntil","take","takeLast","takeWhile","takeSequence","iterating","takeWhileFactory","takeUntil","ordered","keyed","h","murmurHashOfSize","hashMerge","hashCollection","CollectionPrototype","toJSON","chain","contains","mapKeys","KeyedCollectionPrototype","findIndex","removeNum","numArgs","spliced","findLastIndex","interpose","interposedSequence","interposeFactory","interleave","zipped","interleaved","zip","defaultZipper","zipWith","IndexedCollectionPrototype","SetCollectionPrototype","reduction","useFirst","emptyOrderedSet","EMPTY_ORDERED_SET","OrderedSetPrototype","makeOrderedSet","Record","defaultValues","hasInitialized","throwOnInvalidDefaultValues","RecordType","indices","RecordTypePrototype","_indices","_name","_defaultValues","propName","console","warn","recordName","setProp","_values","RecordPrototype","str","recordSeq","newValues","makeRecord","getDescriptiveName","likeRecord","record","EMPTY_REPEAT","Repeat","times","_value","fromJS","converter","fromJSWith","defaultConverter","parentValue","converted","version","Iterable","PairSorting","LeftThenRight","RightThenLeft","query_builder_seed","timePart","getTime","random","_createForOfIteratorHelper","_n","F","ownKeys","getOwnPropertyDescriptor","_objectSpread","getOwnPropertyDescriptors","defineProperties","widgetDefKeysToOmit","opDefKeysToOmit","isObject","isObjectOrArray","typeOf","isTypeOf","isSafeKeyForObject","hasSafeOwnProperty","opts","_opts","canCreate","canIgnore","canChangeType","expectedObjType","newObj","pathToTarget","targetKey","goodPath","_iterator","expectedType","err","_opts2","deepCopyObj","deepCopyMixin","arrayMergeMode","circularRefs","specialSymbols","$v","$type","$canCreate","$canChangeType","$arrayMergeMode","newObjChanged","_process2","targetMix","_ref","isMixingArray","isMixingRealArray","indexDelta","_loop","mk","_targetMix$mk","_targetMix$mk$$canCre","_targetMix$mk2","_targetMix$mk$$canCha","_targetMix$mk3","_targetMix$mk$$arrayM","_targetMix$mk4","useSymbols","targetMixValue","isMixValueExplicit","mergeArraysSmart","_targetMix$mk5","omit","fromEntries","_ref2","getOpCardinality","opDef","_opDef$cardinality","cardinality","v1","v2","shallowEqual","deep","shallowEqualArrays","shallowEqualObjects","arrA","arrB","objA","objB","aKeys","bKeys","isImmutableList","toImmutableList","applyToJS","escapeRegExp","mergeCustomizerNoArrays","objValue","srcValue","_source","_cleanJSX","jsx","_i","isDirtyJSX","_cleaned$props","cleaned","isJSX","isJsonLogic","isJL","sleep","delay","setTimeout","arr1","_ref4","orig","_ref5","prevs","_ref6","_ref7","before","_ref8","_ref9","isAfterDirectly","isBeforeDirectly","acc","_ref10","_ref11","newOp","rel","relOp","ind","_deepFreeze","freeze","_isJsonCompatible","tpl","bag","tv","ov","_tv","_ov","getLogger","devMode","_process4","env","NODE_ENV_TEST","log","debug","info","_process3","getFirstDefined","ret","logger","_marked","iterateFuncs","_marked2","iterateFields","_widgetDefKeysToOmit","configKeys","selectTypes","_context","delegateYield","_iterateFields","funcs","stop","_context2","subfields","subfieldsKey","_callee","_config$settings","fieldSeparator","fieldKey","fieldConfig","_context3","settings","t0","t1","getFieldRawConfig","field","_config$settings3","_config$settings2","fieldsKey","caseValueField","getFieldParts","targetFields","part","normalizeField","_config$__fieldNames$","_config$__fieldNames$2","parentField","findStr","__fieldNames","inGroup","startsWith","fullPath","getFuncSignature","funcConfig","returnType","_ref3","getFuncConfig","getFuncArgConfig","funcKey","argKey","argConfig","isFieldDescendantOfField","_config$settings4","getFieldPath","parentPath","_config$settings5","_config$settings6","_field$get","_field$split","_field$get2","getFieldPathParts","onlyKeys","_curr","getFieldId","_field$get3","_funcKey","_argKey","_getFromConfigCache","bucketKey","cacheKey","_config$__cache","__cache","_saveToConfigCache","getFieldSrc","_field$get4","getFieldConfig","_field$get5","widgets","_isFuncArg","_isFunc","getOperatorConfig","operator","opConfig","operators","_widgetConfig$opProps","_fieldWidgetConfig$op","fieldCacheKey","cached","widget","getWidgetForFieldOp","widgetConfig","fieldWidgetConfig","widgetOpProps","opProps","fieldWidgetOpProps","mergedConfig","getFieldWidgetConfig","_fieldConfig$widgets","valueSrc","meta","fieldWidgetProps","widgetProps","valueFieldSettings","fieldSettings","forExport","getFirstField","parentRuleGroupField","parentPathArr","firstField","keysPath","_firstField","_getWidgetsAndSrcsForFieldOp","valueSrcs","isFuncArg","widgetValueSrc","canAdd","filterValueSourcesForField","_fieldConfig$valueSou","_opConfig$valueSource","canAddValueSrc","valueSources","widgetWeight","wg","preferWidgets","mainWidget","w1","w2","res","fieldDefinition","_fieldDefinition$type","fieldType","isOtherType","valueTypes","valueSourcesInfo","vs","__fieldsCntByType","minCnt","__funcsCntByType","getValueSourcesForFieldOp","getWidgetsForFieldOp","getOperatorsForType","_config$types$fieldTy","getOperatorsForField","getFirstOperator","_fieldOps$","fieldOps","getFieldPartsConfigs","parentFieldDef","parentParts","cnf","expandTreePath","suffix","expandTreeSubpath","_len2","_key2","getItemByPath","tree","_children","_res","getAncestorRuleGroups","parentRuleGroups","_id","item","removeIsLockedInTree","newTree","_processNode","isParentLocked","itemPath","isLocked","child","_childId","fixPathsInTree","lev","nodeId","currPath","currId","itemId","uuid","childId","fixEmptyGroupsInTree","allChildrenGone","curr","getFlatTree","items","cases","visibleHeight","globalLeafCount","globalGroupCount","globalCountByType","_flatizeTree","insideCollapsed","insideLocked","insideRuleGroup","atomicLev","caseId","childNo","_items$closestRuleGro","_items$closestRuleGro2","_items$closestRuleGro3","isRoot","collapsed","childrenIds","_child","isRuleGroup","isRule","isGroup","isCaseGroup","isAtomicRule","hasChildren","parentId","closestRuleGroupId","canRegroup","maxNesting","closestRuleGroupCanRegroup","closestRuleGroupMaxNesting","closestRuleGroupLev","currentCaseId","caseNo","itemsBefore","top","globalNoByType","indexPath","globalLeafNo","globalGroupNo","nextAtomicLev","isLeaf","isDefaultCase","atomicRulesCountInCase","_top","parentType","leaf","height","globalAtomicCount","maxChildDepth","sumHeight","childItem","_height","bottom","assign","prevId","nextId","getTotalReordableNodesCountInTree","cnt","children1","getTotalRulesCountInTree","getLightTree","deleteExcess","children1AsArray","properties","operatorOptions","getSwitchValues","vals","caseValue","isEmptyTree","_fixImmutableValue","_v$toJS","vJs","jsToImmutable","outValue","isRuleValue","_outValue$get","_outValue$get$get","defaultConjunction","defaultGroupConjunction","defaultOperatorOptions","operatorConfig","defaults","_groupFieldConfig","_groupFieldConfig2","groupFieldConfig","conjs","conjunctions","defaultGroupProperties","conjunction","getDefaultField","canGetFirst","defaultField","getDefaultSubField","parentRuleGroupConfig","getDefaultFieldSrc","_config$settings$fiel","fieldSources","getDefaultOperator","fieldOperators","globalDefaultOperator","defaultOperator","fieldDefaultOperator","fieldOwnDefaultOperator","ownDefaultOperator","firstOperator","createListWithOneElement","createListFromArray","emptyProperties","calculateValueType","calculatedValueType","getFuncPathLabels","getFieldPathLabels","getValueLabel","delta","isSpecialRange","mergedOpConfig","valueLabels","placeholder","valueLabel","valuePlaceholder","formatFieldName","fieldDef","fieldParts","fieldName","useTableName","fieldPartsCopy","parentFieldName","errors","isEmptyItem","mode","isEmptyRuleGroupExt","isEmptyGroup","isEmptyRule","isEmptyRuleGroupExtPropertiesAndChildren","_config$operators$ope","_config$operators$ope2","childrenAreRequired","filledParts","group","isEmptyRuleProperties","isEmptyGroupChildren","whatRulePropertiesAreCompleted","score","_config$operators$ope3","_config$operators$ope4","_value$filter","fieldSrc","liteCheck","valueType","_isCompletedValue","deepCheck","_value$get","argVal","argValue","argValueSrc","defaultValue","isOptional","completeValue","completeFuncValue","complValue","tmpHasOptional","filteredValueSources","argDefaultValueSrc","completeArgValue","getDefaultArgValue","_getOneChildOrDescendant","setArgValue","setFuncDefaultArgs","funcValue","setFuncDefaultArg","firstValueSrc","queryBuilderFormat","usedFields","formatItem","formatGroup","formatRule","currentChild","rules","_valueType","hasUndefinedValues","operatorDefinition","typeConfig","secondField","ruleQuery","reverseOperatorsForNot","canShortMongoQuery","fixJsonLogicDateCompareOp","formatField","label2","isForDisplay","keepInputOnChangeFieldSrc","fieldItemKeysForSearch","listKeysForSearch","fieldSeparatorDisplay","canReorder","canDeleteLocked","canLeaveEmptyGroup","shouldCreateEmptyGroup","exportPreserveGroups","removeEmptyGroupsOnLoad","removeEmptyRulesOnLoad","removeIncompleteRulesOnLoad","removeInvalidMultiSelectValuesOnLoad","showErrorMessage","setOpOnChangeField","groupOperators","locale","moment","fieldLabel","operatorLabel","funcLabel","fieldPlaceholder","funcPlaceholder","operatorPlaceholder","lockLabel","lockedLabel","deleteLabel","addGroupLabel","addCaseLabel","addDefaultCaseLabel","defaultCaseLabel","addRuleLabel","addSubRuleLabel","addSubGroupLabel","delGroupLabel","notLabel","fieldSourcesPopupTitle","valueSourcesPopupTitle","removeRuleConfirmOptions","removeGroupConfirmOptions","loadMoreLabel","loadingMoreLabel","typeToSearchLabel","loadingLabel","notFoundLabel","applyJsonLogic","addJsonLogicOperation","customJsonLogicOperations","CALL","ctx","JSX","mergeObjects","obj1","obj2","strlen","regexTest","flags","dateA","startOf","dateB","isSame","today","year","month","date","toDate","start_of_today","date_add","dim","datetime_add","datetime","datetime_truncate","addRequiredJsonLogicOperations","jl","jsonLogicFormatConcat","_part$value","jsonLogicImportConcat","dateDimListValues","day","week","datetimeDimListValues","hour","minute","second","NOW","jsonLogicCustomOps","jsonLogicImport","spelFunc","sqlFormatFunc","sqlFunc","mongoFormatFunc","formatFunc","TODAY","START_OF_TODAY","spelImport","spel","_obj$obj","_oneArg$children","_oneArg$children2","_oneArgType$cls","isTruncate","isObjNow","cls","argsLength","oneArg","oneArgType","oneArgProperty","oneArgCls","oneArgConst","isArgDays","sqlImport","sqlObj","sqlDialect","_sqlObj$children","_sqlObj$children2","format","TRUNCATE_DATETIME","renderBrackets","renderSeps","spelFormatFunc","dimPluralUppercase","_oneArg$children3","_oneArg$children4","_oneArgType$cls2","_sqlObj$children7","_sqlObj$children3","_sqlObj$children5","_sqlObj$children8","_dim","_sqlObj$children4","_dateFormat$children","_sqlObj$children6","dateFormat","interval","isFormat","isIntervalDay","unit","_dateFormat$children2","_date","_format","escapeForFormat","mainWidgetProps","customProps","showSearch","listValues","RELATIVE_DATETIME","_spel$methodName","matchRes","_sqlObj$children9","_sqlObj$children10","plus","minus","RELATIVE_DATE","LOWER","mongoFunc","UPPER","LINEAR_REGRESSION","_ref12","coef","bias","_ref13","_ref14","_spel$children","_a$children","_sqlObj$children11","_left$children","_sqlObj$children12","_left$children2","_ref15","_ref16","applyJsonLogicWithPath","callContextFn","_this","compileMetaFieldSettings","asyncFetch","labelYes","labelNo","marks","isArr","validateValue","compileMetaWidget","formatValue","sqlFormatValue","spelFormatValue","spelImportValue","mongoFormatValue","elasticSearchFormatValue","compileMetaOperator","formatOp","mongoFormatOp","sqlFormatOp","spelFormatOp","ignore","elasticSearchQueryType","textSeparators","compileMetaWidgetForType","compileMetaFieldLike","compileMetaField","compileMetaSettings","mui","invokeWith","canCompareFieldWithField","formatReverse","sqlFormatReverse","spelFormatReverse","formatSpelField","formatAggr","normalizeListValues","renderConfirm","useConfirm","renderField","renderOperator","renderFunc","renderConjs","renderButton","renderIcon","renderButtonGroup","renderValueSources","renderFieldSources","renderProvider","renderSwitch","renderSwitchPrefix","renderItem","renderBeforeWidget","renderAfterWidget","renderBeforeActions","renderAfterActions","renderBeforeCaseValue","renderAfterCaseValue","renderRuleError","compileMeta","formatConj","sqlFormatConj","spelFormatConj","compressConfig","baseConfig","zipConfig","_clean2","BasicFuncs","_k","_base","rootKey","decompressConfig","useConfigCompress","_step3","unzipConfig","_mergeDeep2","_resolveAndMergeDeep2","resolved","_step2","_iterator2","_k2","_iterator3","compileConfig","__compliled","_compileConfigParts","subconfig","logs","submeta","newPath","targetObj","newVal","renderReactElement","_newVal","_targetObj","_val","_newVal2","compileJsonLogicReact","_newVal4","_targetObj2","_val2","_newVal3","compileJsonLogic","def","re","argNames","_props","Cmp","_ctx$components","components","W","O","getReactComponentFromCtx","RCE","commonMemo","memoId","configId","memos","areConfigsSame","config1","config2","getCommonMemo","extendConfig","createConfigMemo","reactIndex","maxSize","canCompile","findExtendedConfigInAllMemos","needsToBeCompiled","foundExtConfig","findExtendedConfig","currentMemo","configStore","currentMemoId","storeConfigPair","extendedConfig","findExtended","findConfig","_ret","savedConfig","_ret2","_loop2","findOrExtend","extendAndStore","getExtendedConfig","pickConfig","getBasicConfig","basicConfig","extConfig","clearConfigMemo","getSize","widgetPropsForDeepMerge","opPropsForDeepMerge","_extendConfig","__configId","cachedExtConfig","origConfig","typesConfig","extendTypeConfig","extendTypesConfig","extendFieldsConfig","extendFuncsConfig","extendFieldConfig","momentLocale","excludeOperators","typeWidgetConfig","defOp","fieldPathArr","funcPathArr","funcPathStr","funcDef","tmpIsOptional","argDef","isCaseValue","showLabels","isFunc","excludeOperatorsForField","hasOwnDefaultOperator","_isCaseValue","_fieldConfig$fieldSet","_fieldConfig$fieldSet2","_keysToPutInFieldSett","treeValues","normalizeFieldSettings","excludeKeysFromType","excludeOperatorsForType","shouldIncludeOperators","addOperators","_addOperators","_i2","_widgetPropsForDeepMe","_config$widgets$widge","_typeWidgetConfig$wid","_fieldConfig$mainWidg","_fieldWidgetConfig$wi","opKeys","_typeWidgetConfig$opP","_i3","_opPropsForDeepMerge","_config$operators","_typeWidgetConfig$opP2","_fieldWidgetConfig$op2","opProp","_fieldWidgetConfig","_computeFieldName","_reduce","computedPath","computed","fConfig","computeFieldName","disabled","jsonLogicFormat","ff","tmp","pdef","_not","lockedOp","formatSwitch","formatCase","_groupOperatorDef","_groupOperatorDef2","_groupOperatorDef3","_reversedGroupOpDef","_reversedGroupOpDef2","_getOneChildOrDescend","conjunctionDefinition","conj","jsonLogicConj","origNot","isRuleGroupArray","groupField","groupOperator","groupOperatorDef","formattedValue","formatItemValue","isGroup0","isRuleGroupWithChildren","revChildren","reversedGroupOp","reversedOp","reversedGroupOpDef","groupOpNeedsReverse","groupOpCanReverse","oneChildType","shouldPreserveGroups","preserveSingleRuleGroup","_currentChild$get","_config$operators$rev","_config$operators2","revOp","_jsonLogicIsExclamationOp","filterQuery","resultQuery","_groupOperatorDef4","reduceQuery","formattedField","formattedLhs","optionsMap","having","groupFieldFormatted","formatLogic","_operatorDefinition","_operatorDefinition2","_revOperatorDefinitio","_operatorDefinition3","_revOperatorDefinitio2","_revOperatorDefinitio3","revOperatorDefinition","opNeedsReverse","canRev","filteredCases","_filteredCases$","_defVal","ifArgs","_filteredCases","defVal","isLastIf","_filteredCases$_i","cond","expectedValueType","iValueSrc","iValueType","iValue","asyncListValues","oldUsedFields","fvalue","currentValue","cValue","fieldWidgetDef","fv","operatorDef","_currentValue$get","_currentValue$get2","funcParts","funcLastKey","formattedArgs","gaps","missingArgKeys","_argValue","defaultValueSrc","formattedArgVal","formattedDefaultVal","defaultWidget","defaultFieldWidgetDef","finalFormattedVal","formattedArgsArr","_args","funcName","jsonLogicIsMethod","params","jsonLogicVar","groupVarKey","_properties$get","isRev","firstValueType","formattedOp","rangeOps","eqOps","opOpts","buildFnToFormatOp","mongoEmptyValue","mongoFormatOp1","mop","mc","opNot","_op","useExpr","$field","mv","regex","mongoFormatOp2","mops","mongoFieldEscape","mongoFieldUnescape","mongodbFormat","_mongodbFormat","returnErrors","parents","_canWrapExpr","_formatFieldName","_parents$filter","_groupOperatorDef$car","_conjunction","sep","parentRuleGroup","it","isInsideRuleGroup","isInsideRuleGroupArray","groupOperatorCardinality","groupFieldName","canHaveEmptyChildren","isSimpleGroupWithOneChild","reversedConj","mongoConj","canWrapExpr","formatFieldNameFn","formattedChild","totalQuery","as","notForRule","_f","_parents$filter2","_operatorDefinition4","_formatFunc2","_formatValue2","fvUseExpr","wrapExpr","_formatRightField2","formatRightField","_formatFunc4","rightField","rightFieldDefinition","fieldPartsLabels","fieldFullLabel","formatFieldFn","mongoArgsAsObject","argsCnt","lastArg","argAsyncListValues","_formatValue4","_formatValue6","spelInlineList","javaType","jt","escapedVals","numberJavaTypes","spelEscape","numberToFloat","arrayToArray","isFinite","spelEscapeString","spelFormatConcat","spelImportConcat","isVariable","spelFixList","SqlString","trim","unescapeLike","escapeLike","any_start","any_end","escape","sqlEmptyValue","stringifyForDisplay","wrapWithBrackets","sqlFormat","_sqlFormat","revOpDef","canFormatOp","sqlOp","canFormatRevOp","fieldWidgetDefinition","_values$first","_values$get","valFrom","valTo","valFieldDefinition","argsStr","compareToSign","TypesWithCompareTo","time","spelFormat","_spelFormat","_formatItemValue","isSpelArray","realGroupOperator","checkOp","isGroupOpRev","realGroupOperatorDefinition","_formatItemValue2","omitBrackets","fullSize","filteredSize","formatExpression","spelOp","isCompareTo","sop","compareRes","_formatLhs","realOp","_formatItemValue3","formatLhs","_formatField2","_formatFunc","fieldPartsConfigs","fieldPartsMeta","parentCnf","isSpelMap","isSpelItemMap","isSpelVariable","_argConfig$escapeForF","doEscape","missedArgKey","_formattedArgs$argKey","optionalArgs","queryString","isDebugMode","_config$operators$gro","_config$operators$gro2","_meta$settings","realParentGroupField","conjStr","aggrArgs","_config$settings$form","returnArgs","_meta$settings3","revOperatorDef","fop","labelForFormat","_operator","_meta$settings2","_fvalue$get","_fvalue","_fn","_meta$settings4","jsType","_fieldDef$escapeForFo","cutParentField","_meta$settings5","fieldLabel2","_funcValue$get","_funcValue$get2","_args$keySeq","_meta$settings6","formattedArgsWithNames","argName","_step2$value","buildParameters","queryType","syntax","textField","determineField","script","elasticSearchScript","ES_7_SYNTAX","geoPointString","coordsNumberArray","top_left","lat","lon","bottom_right","buildEsGeoPoint","gte","lte","dateTime","lt","gt","buildEsRangeParameters","buildEsWildcardParameters","buildRegexpParameters","buildEsRule","bool","must_not","ES_6_SYNTAX","elasticSearchFormat","_properties$get2","_properties$get3","recursiveFxn","childrenArray","occurrence","combinator","determineOccurrence","buildEsGroup","getTree","immutableTree","light","loadTree","serTree","isImmutableTree","isTree","_toArray","_translations","jlFieldMarker","jlRawFieldMarker","jlHavingMarker","jlArgsMarker","Proxy","__name","__test","_v$match","jlEqOps","jlRangeOps","jlDualMeaningOps","multiselectOps","createMeta","parentMeta","loadFromJsonLogic","logicTree","_loadFromJsonLogic","allowUnknownFields","conv","buildConv","jsTree","_convertFromLogic","immTree","combinationOperators","opKey","opk","_opConfig$jsonLogic","_opConfig$jsonLogic2$","_opConfig$jsonLogic2","_opConfig$jsonLogicOp","template","opInTemplate","isRevArgs","jsonLogic2","jsonLogicOps","conjKey","_step$value","funcPath","fk","_config$settings$json","altVarKey","varKeys","matchAgainstTemplates","jsonlogic","response","operatorsToCheck","_Object$entries","_Object$entries$_i","tempResponse","_isTemplateMatch","tKeys","jKeys","maybeArgIndex","jlArgs","jlField","jlHaving","expectedTypes","beforeErrorsCnt","isEmptyOp","isNot","convertFieldRhs","convertFuncRhs","convertValRhs","errorsBefore","convertSwitch","convertConj","_convertOp","errorsAfter","convertCaseVal","wrapInDefaultConj","afterErrorsCnt","_e$message","valueFormat","dateVal","setMilliseconds","setHours","setMinutes","setSeconds","isEpoch","epoch","_dateVal","_valueFormat","convertLhs","groupOp","_parse","convertFieldLhs","convertFuncLhs","parsed","_v2","_v4","_filter","parsedGroup","_parsedGroup","argsArr","_vals","funcKeys","fc","_e","argKeys","argsObj","_argVal","complexFields","_v$properties","_v$properties2","_f$includes","complexFieldsGroupAncestors","ancs","fp","groupToId","_v$properties3","groupAncestors","parentFieldParts","groupPath","gf","gfc","groupId","_parseRule","arity","_groupOpConfig$cardin","isAllOrSomeInForMultiselect","opName","_config$operators$opN","groupOpConfig","returnVariants","_conv$combinationOper","_vals3","lhs","isValidOp","_opConfig","_isOneRuleInRuleGroup","jlConjs","parseRes","parseRule","havingVals","parentFieldConfig","opCanReverse","isInRuleGroup","needRev","havingNot","canRevHaving","matchTemp","convertedArgs","_res$properties","wrapInDefaultConjRuleGroup","asyncListValuesArr","defaultCaseVal","buildCaseValProperties","wrapInCase","flatizeTernary","_processTernaryChildren","tern","_tern","if_val","else_val","else_op","valProperties","caseI","caseValueFieldConfig","widgetDef","convVal","EMPTY_GROUP","EMPTY_RULE_GROUP","EMPTY_QUERY","EMPTY_CASE","NO_CONFIG_FOR_FIELD","NO_CONFIG_FOR_OPERATOR","NO_CONFIG_FOR_FUNCTION","INVALID_VALUE","INVALID_FUNC_ARG_VALUE","UNSUPPORTED_FIELD_TYPE","UNSUPPORTED_OPERATOR_FOR_FIELD","INVALID_VALUE_SRC","INCOMPLETE_RULE","INCOMPLETE_LHS","INCOMPLETE_RHS","BAD_MULTISELECT_VALUES","BAD_SELECT_VALUE","INCORRECT_VALUE_TYPE","INCORRECT_VALUE_JS_TYPE","VALUE_LENGTH_CONSTRAINT_FAIL","VALUE_MIN_CONSTRAINT_FAIL","VALUE_MAX_CONSTRAINT_FAIL","NO_CONFIG_FOR_FIELD_VALUE","CANT_COMPARE_FIELD_WITH_ITSELF","CANT_COMPARE_FIELD_WITH_FIELD","INCORRECT_FIELD_TYPE","UNSUPPORTED_FUNCTION_FOR_FIELD","REQUIRED_FUNCTION_ARG","INCORRECT_FUNCTION_RETURN_TYPE","INVALID_RANGE","ITEM_POSITION","ITEM_POSITION_ROOT","ITEM_POSITION_WITH_INDEX_PATH","ITEM_POSITION_IN_CASE","_CONTEXT_MIN_MAX","translations","NSV","NSVP","i18n","fallbackLng","addResources","_translateValidation","getNewValueForFieldOp","_currentField","_currentField$get","_newField","_newField$get","validateRange","oldConfig","newField","newOperator","changedProp","canFix","isEndValue","canDropArgs","convertableWidgets","clearValueOnChangeField","clearValueOnChangeOp","isCase","currentField","newFieldError","currentFieldType","currentFieldSrc","currentOperator","currentValueSrc","currentValueType","currentValueError","isOkWithoutOperator","currentOperatorConfig","newOperatorConfig","currentOperatorCardinality","operatorCardinality","currentFieldConfig","newFieldConfig","isOkWithoutField","currentType","newType","currentListValuesType","listValuesType","newListValuesType","currentFieldSimpleValue","hasFieldChanged","validationErrors","canReuseValue","_validateValue2","fixedField","fieldErrors","willFix","willFixAllErrors","fixed","willRevert","willDrop","showError","firstError","side","currentWidget","newWidget","currentValueWidget","newValueWidget","firstWidgetConfig","defaultValueType","canExtendValueToRange","valueFixes","valueSrcFixes","valueTypeFixes","valueErrors","vType","vSrc","isValidSrc","_validateValue4","fixedValue","allErrors","allErrorsHandled","_newFieldConfig$field","_dv$get","dv","_valueSrcFixes$_i","_valueTypeFixes$_i","_vs","vt","_ignore","newValueSrc","_valueSrcFixes$i","newValueType","_valueTypeFixes$i","rangeErrorObj","rangeValidationError","_willFix","badValue","fixedFrom","fixedTo","newValueError","hasValueErrorChanged","toListValue","title","makeCustomListValue","lv","isCustom","listValuesToArray","listValuesObj","listValuesArr","getItemInListValues","getTitleInListValues","getValueInListValues","mapListValues","mapFn","_lv","searchListValue","getListValue","selectedValue","isValidTree","getTreeBadFields","badFields","valueError","fieldError","fieldStr","checkTree","removeEmptyGroups","removeIncompleteRules","removeEmptyRules","forceFix","_validateTree2","_validateTree","fixedTree","isSanitized","validateTree","finalOptions","sanitizeTree","_validateTree4","fixedErrors","nonFixedErrors","validateAndFixTree","_oldTree","newConfig","_validateTree5","flatItems","oldFlatItems","_ref$translateErrors","translateErrors","_ref$includeStringifi","includeStringifiedItems","_ref$stringifyFixedIt","stringifyFixedItems","_ref$stringifyItemsUs","stringifyItemsUserFriendly","_ref$includeItemsPosi","includeItemsPositions","validateItem","sanitized","_meta$errors$id","errorItem","itemStr","flatItem","isDeleted","itemPosition","trKey","trArgs","_itemPosition$indexPa","_arr","itemPositionStr","_allErrors","itemErrors","fixedItemErrors","nonFixedItemErrors","_addError","_setErrorsAsFixed","_children2","_children3","oldChildren","isGroupExt","canHaveValue","validateRule","nonEmptyChildren","isEmptyChildren","canDrop","validateGroup","serializeRule","_field","_field$toJS","oldSerialized","availOps","_getNewValueForFieldO","newSerialized","hasBeenSanitized","compl","isCompleted","shoudlRemoveRule","incError","_newSerialized$valueS","_newSerialized$valueS2","_oldSerialized$valueS","_newSerialized$value","leftField","_allErrors2","_allErrors3","_allErrors4","_allErrors5","_validateFieldValue2","validateFieldValue","_validateFuncValue2","validateFuncValue","_validateNormalValue2","validateNormalValue","fixedAllErrors","_validResult$error","newError","validResult","_fieldSettings","lastError","wConfig","wType","isAsyncListValues","canSkipTypeCheck","valueTypeof","realListValues","allowCustomValues","_validateValueInList","_values$reduce","goodVals","badVals","vv","_values$reduce2","goodValues","badValues","needFix","validateValueInList","_validateValueInList2","maxLength","minMaxContext","_valueSrc","leftFieldStr","leftFieldConfig","rightFieldStr","rightFieldConfig","_funcConfig$label","_argDef$label","fixedArgVal","argErrors","canDropOrReset","_argErrors$find","argValidationError","canReset","rangeError","valueSrcsArr","valuesArr","areValueSrcsPureValues","validateValues","jsValues","jsVal","setFunc","canFixArgs","oldFuncKey","oldArgs","newFuncSignature","oldFuncSignature","keepArgsKeys","getCompatibleArgsOnFuncChange","setArgValueSrc","argValSrc","_argConfig","_config","setArgValueAsyncListValues","s1","s2","argVals","arg2","arg1","_argValidErrors$filte","argValidErrors","defaultRuleProperties","_item$properties","_item$properties2","_item$properties3","canUseDefaultFieldAndOp","defaultItemProperties","defaultRule","defaultRoot","canAddDefaultRule","asyncGeneratorStep","_excluded","simulateAsyncFetch","all","cPageSize","pageSize","filtered","currentOffset","newOffset","hasMore","fetchSelectedValues","abrupt","_next","_throw","_x","_x2","_x3","mergeListValues","toStart","hideNewValues","old","newFiltered","av","isHidden","optionToListValue","_val$value","customItem","listValue","optionsToListValues","newSelectedListValues","_val$value2","newSelectedValues","_o$value","listValueToOption","groupTitle","grouplabel","renderTitle","_objectWithoutProperties","option","fixListValuesGroupOrder","groupTitles","lv1","_lv1$groupTitle","_lv$groupTitle","nv","manuallyImportedOps","unsupportedOps","_buildFuncSignatures6","brns","isVar","lastChild","currBrn","_currBrn$params","_buildFuncSignatures3","params1","newBrn","objs","_step4","_iterator4","_brn$objs","brn","_params","_buildFuncSignatures5","buildCase","convCond","buildSimpleSwitch","_widgetConfig","importCaseValue","_widgetDef$type","_importCaseValue$call2","normVal","buildRule","_groupField","reversedOpConfig","needWrapWithNot","_postprocessCompiled","parentExpr","isBetweenNormal","isBetweenRev","isBetween","selection","isSize","isLength","sourceParts","convertPath","isThis","itype","_lastChild","_lastChild2","qid","_qid","_cls","_args2","expectingField","_meta$errors","_meta$errors$push","isJsonCompatible","SpelPrimitiveTypes","SpelPrimitiveClasses","_convertToTree","_spel$_groupField","parentSpel","canParseAsArg","_groupFilter","groupFieldValue","groupFilter","_v","convertCaseValue","_convertArg","sw","negative","_spel$children$0$chil","_spel$children$1$chil","compareArgs","oneSpel","convertChildren","_newChildren","newChildren","_fieldObj$groupFieldV","_convertedArgs","fieldObj","opArg","_vals$","_vals$2","ws","groupOpRule","buildRuleGroup","_spel$_groupField2","_config$settings$case","_field2","_fieldConfig","_isVariable","at","_values$","convertCaseValueConcat","maybe","convertFunc","_fsigns$","convertFuncArg","fsigns","buildFuncSignatures","firstSign","convertFuncToValue","maybeOp","convertFuncToOp","argsOrder","matchAll","_funcConfig","isOk","funcType","_funcConfig$args","dateArgsKeys","_argsObj$k","realType","funcArgs","errs","foundSign","foundWidget","candidates","spelImportFuncs","fj","_step5","_step4$value","_s","_iterator5","valueFuncs","_step5$value","_candidates","_candidates$_i","_w","_widgetDef","_spelImportValue$call2","_step6","_iterator6","_step7","_step6$value","_iterator7","opFuncs","_loop4","_argsArr$filter","_step7$value","_loop3","_argsObj$","bestCandidate","allErrs","_map2","leftSource","rightSource","_map4","leftVal","rightVal","_config$settings$case2","_processConcatChildren","convertedChild","loadFromSpel","spelStr","_loadFromSpel","convertedObj","spelOps","revOpConfig","spelConj","fks","funcSignMain","funcSignsOptional","optionalArgKeys","_fk","fs","_fs","_argsOrder","compareToSS","utils","equal","opStr","_this$utils","_opDef","_opOpts","_fieldDef","not_equal","isNotOp","sqlOps","_this$utils2","less","_this$utils3","_len3","_key3","less_or_equal","_this$utils4","_len4","_key4","greater","_this$utils5","_len5","_key5","greater_or_equal","_this$utils6","_len6","_key6","like","_right$valueType","_this$utils7","_len7","_key7","not_like","_this$utils8","_this2","_len8","_key8","starts_with","_this$utils9","_this3","_len9","_key9","ends_with","_this$utils10","_this4","_len10","_key10","between","_this$utils11","_len11","_key11","not_between","_this$utils12","_len12","_key12","is_empty","_this$utils13","_this5","_len13","_key13","is_not_empty","_this$utils14","_this6","_len14","_key14","is_null","_this$utils15","_len15","_key15","is_not_null","_this$utils16","_len16","_key16","select_equals","_this$utils17","_len17","_key17","select_not_equals","_this$utils18","_len18","_key18","select_any_in","_this$utils19","_len19","_key19","select_not_any_in","_this$utils20","_len20","_key20","multiselect_contains","_this$utils21","_len21","_key21","multiselect_not_contains","multiselect_equals","_this7","_this$utils22","_len22","_key22","multiselect_not_equals","_this8","_this$utils23","_len23","_key23","proximity","val1","val2","prox","aVal1","aVal2","_right$value","optionLabel","optionTextBefore","optionPlaceholder","minProximity","maxProximity","_this$utils24","_len24","_key24","_this$utils25","_len25","_key25","none","_this$utils26","_len26","_key26","text","wgtDef","textarea","fullWidth","slider","select","valLabel","multiselect","_this9","valsLabels","_this10","isCallable","_args$fmt","_args$fmt$includes","_args$fmt2","_args$fmt2$toLowerCas","fmt","ISO_8601","utc","timeFormat","use12Hours","_args$fmt3","_args$fmt3$toLowerCas","_args$fmt4","_args$fmt5","_args$fmt5$includes","rightFieldDef","case_value","partsExt","_this11","whereStr","aggrField","aggrFieldDef","_cond","_cond2","_addMixins","mixins","doAdd","mixinFuncs","rangeslider","mixinWidgetRangeslider","treeselect","mixinWidgetTreeselect","treemultiselect","mixinWidgetTreemultiselect","rangeable__date","mixinRangeableWidget","mixName","mixinFunc","addMixins","addMixin","singleWidget","treeData","_this12","_this13","ConfigMixins","removeMixins","AND","sqlConj","spelConjs","OR","ADD_GROUP","ADD_CASE_GROUP","REMOVE_GROUP","SET_CONJUNCTION","SET_NOT","ADD_RULE","REMOVE_RULE","SET_FIELD","SET_FIELD_SRC","SET_OPERATOR","SET_VALUE","SET_VALUE_SRC","SET_FUNC_VALUE","SET_OPERATOR_OPTION","SET_LOCK","SET_TREE","MOVE_ITEM","PLACEMENT_AFTER","PLACEMENT_BEFORE","PLACEMENT_APPEND","PLACEMENT_PREPEND","SET_DRAG_PROGRESS","SET_DRAG_START","SET_DRAG_END","addNewGroup","generatedId","groupUuid","canAddNewRule","origState","addItem","currentNumber","maxNumber","maxNumberOfCases","maxNumberOfRules","isTernary","caseGroup","childrenPath","targetChildren","targetChildrenSize","ruleGroups","_ruleGroups$","ruleGroupPath","ruleGroupField","ruleGroupFieldConfig","_ruleGroups","_ruleGroups$2","_ruleGroupPath","_ruleGroupField","_ruleGroupFieldConfig","ruleGroupItem","_addChildren","isLastDefaultCase","newChildrenWithLast","removeItem","setField","_newFieldConfig$opera","_meta","currentRule","currentProperties","wasRuleGroup","currentOperatorOptions","isRuleGroupExt","isChangeToAnotherType","lastOp","forceKeepOp","strategy","groupProperties","initialEmptyWhere","_getNewValueForFieldO2","newCorrectField","newOperatorOptions","validationError","initEmptyValueLists","_it$id","id1","it1","emptyDrag","dragging","mousePos","dragStart","getActionMeta","action","_affectedField","actionTypesToIgnore","affectedField","getField","setTree","addRule","ruleType","addDefaultCaseGroup","addCaseGroup","addGroup","fromPath","toPath","placement","lock","srcKey","parentFuncs","Utils","Export","Import","initialConfig","getMemoizedTree","setLastTree","getLastConfig","emptyState","_getLastConfig","unset","__lastAction","actionMeta","validatedTree","removeGroup","parentOperator","parentOperatorConfig","hasGroupCountRule","isParentRuleGroup","isEmptyParentGroup","canLeaveEmpty","removeRule","setConjunction","setNot","currentFielType","setFieldSrc","setLock","_getNewValueForFieldO3","setOperator","_newTree","_setFuncValue","isLHS","funcsPath","targetFV","_funcK","_argK","argDefinition","newV","_funcsPath$pop2","funcK","argK","parentFV","_argDefinition","setFuncValue","_newTree2","_getNewValueForFieldO4","setValueSrc","setOperatorOption","sourcePath","sourceChildren","targetPath","isSameParent","isSourceInsideTarget","isTargetInsideSource","sourceSubpathFromTarget","targetSubpathFromSource","newTargetChildren","newSourceChildren","_oldChildren","moveItem","checkEmptyGroups","setDragProgress","setDragStart","setDragEnd","truncateString","useWordBoundary","immutableEqual","_process","Validation","_getReactRootNodeType","_reactRootContainer","getOwnPropertyNames","isUsingLegacyReactDomRender","liteShouldComponentUpdate","self","nextProps","nextState","prevProps","prevState","should","chs","changed","pureShouldComponentUpdate","useOnPropsChanged","shouldComponentUpdate","componentWillReceiveProps","onPropsChanged","origShouldComponentUpdate","bindActionCreators","actionCreators","dispatch","actionCreator","_isNativeReflectConstruct","Reflect","construct","Query","_Component","nextValue","oldValidatedTree","_updateActions","onInit","actions","onChange","newBasicConfig","_this$props","renderBuilder","Component","propTypes","isRequired","ConnectedQuery","connect","DefaultUtils","ConfigUtils","QueryContainer","_this$_reactInternals","_this$_reactInternals2","lastTree","prevTree","prevprevTree","getConfig","prevValue","_createConfigMemo","_reactInternals","getMemoizedConfig","originalTree","createValidationMemo","emptyTree","store","createStore","QueryWrapper","pr","nextConfig","isConfigChanged","storeValue","getState","isTreeChanged","currentTree","isTreeTrulyChanged","canUseOldConfig","get_children","Provider","_extends","createRuleContainer","Rule","_RuleContainer","RuleContainer","dummyFn","removeSelf","isDummyFn","isDraggingMe","isInDraggingTempo","isDraggingTempo","hasError","className","selectedField","selectedFieldSrc","selectedFieldType","parentFieldPathSize","parentFieldCanReorder","selectedOperator","reordableNodesCnt","totalRulesCnt","isTrueLocked","parentReordableNodesCnt","onDragStart","OtherUtils","clone","TreeUtils","_isReorderingTree","createSortableContainer","Builder","_SortableContainer","CanMoveFn","SortableContainer","_getEventTarget","__mocked_window","document","body","window","dom","treeEl","closest","_isUsingLegacyReactDomRender","classList","groupPadding","treeElContainer","scrollTop","_getScrollParent","tmpAllGroups","_getDraggableNodeEl","_getPlaceholderNodeEl","querySelectorAll","anyGroup","getComputedStyle","getPropertyValue","offsetLeft","offsetTop","offsetWidth","offsetHeight","itemInfo","paddingLeft","clientX","clientY","eventTarget","addEventListener","onDrag","onDragEnd","doHandleDrag","startDragging","startMousePos","__mock_dom","dragEl","plhEl","plX","_treeEl","_plhEl2","getBoundingClientRect","scrollX","plY","scrollY","startX","startY","startClientX","startClientY","startScrollTop","handleDrag","preventDefault","_cacheEls","removeEventListener","_prevProps","_prevState","oldPlX","oldPlY","indexId","ignoreCache","querySelector","els","getElementsByClassName","overflowY","scrollHeight","_isScrollable","dragInfo","canMoveFn","dragRect","plhRect","hovRect","treeRect","moveInfo","dragId","width","dragDirs","hrz","vrt","hovCNodeEl","trgCoord","__mocked_hov_container","hovNodeEl","elementFromPoint","_hovNodeEl$firstChild","rootGroupContainer","firstChild","hovNodeId","getAttribute","hovEl","doAppend","doPrepend","hovHeight","hovII","trgRect","trgEl","trgII","altII","hovInnerEl","hovEl2","hovRect2","hovHeight2","isSamePos","dragLeftOffset","dragLev","round","availMoves","altMoves","isToRoot","isToCase","prevCaseId","nextCaseId","prevCase","nextCase","addCaseII","am","toII","fromCaseII","toCaseII","bestMode","filteredMoves","trg","isInside","toParentII","canMove","levs","curLev","allLevs","closestDragLev","move","fromII","_this$props$config$se","canRegroupCases","canLeaveEmptyCase","newDepthLev","isBeforeAfter","isPend","isLev1","isParentChange","isStructChange","isRuleGroupAffected","targetRuleGroupId","targetRuleGroupMaxNesting","targetRuleGroupCanRegroup","newDepthLevInRuleGroup","isForbiddenRuleGroupChange","isForbiddenStructChange","isLockedChange","isLastFromCase","newRulesInTargetCase","GroupOrRule","_Draggable","_PureComponent","Draggable","handleDraggerMouseDown","wrapper","otherProps","styles","cn","style","PureComponent","Operator","getMeta","_config$types$selecte","operatorsOptions","buildOptions","selectedOpts","selectedKeys","selectedKey","selectedPath","selectedLabel","selectedAltLabel","tooltip","ops","altLabel","readonly","renderProps","selectedFieldId","Col","DragIcon","xmlns","viewBox","fill","WithConfirmFn","confirmFn","getWidgetId","getRenderFromConfig","renderFn","OperatorWrapper","showOperator","showOperatorLabel","selectedFieldWidgetConfig","customOperatorSelectProps","operatorInlineLabel","RuleUtils","Field","widgetId","maxLabelsLength","isFieldSelected","currField","getFieldLabel","partsLabels","selectedFullLabel","parentFieldPath","sourceFields","lookingForFieldType","errorText","fieldOpts","optGroup","prefix","_countFieldsMatchesType","fullFieldPath","fullLabel","hideForSelect","hasItemsMatchesType","matchesType","FuncSelect","needUpdateItems","getItems","canUseFuncForField","filteredFuncs","filterFuncs","selectedFuncKey","isFuncSelected","currFunc","getFuncLabel","leftFieldFullkey","targetDefinition","subpath","funcFullkey","_targetDefinition","canUse","allowSelfNesting","fullFuncPath","funcOpts","_excluded2","ListUtils","_Utils$TreeUtils","WidgetFactoryMemo","memo","widgetFactory","isConst","WidgetFactory","parentDelta","immValue","immValueError","widgetDefinition","widgetValueLabel","fieldPath","fixedImmValue","useMemo","_immValueError$get","errorMessage","placeholders","simpleField","funcArgDummyOpDef","Widget","_setValue","widgetType","oldRange","_setValueSrc","renderWidget","iValues","aField","_widgets$delta","hasValueSources","widgetLabel","valueSourcesOptions","_widgets$delta2","ValueSources","sourceLabel","renderSep","sepText","sepLabel","renderWidgetDelta","configChanged","changedKeys","_iValueSrcs","_iValueSrcs2","_this$meta","_this$meta2","fieldFunc","fieldArg","isForRuleGroup","iValueSrcs","isSpecialRangeForSrcField","isTrueSpecialRange","defaultValueSourcesLabels","_valueSourcesInfo$src","_valueSourcesInfo$src2","_this2$meta","_iValueSrcs3","_widgetDefinition","_this2$meta2","oldWidgetMeta","vsId","_this$meta3","fieldId","FuncWidget","_this$props2","_this$props3","renderFuncSelect","_value$get2","_this$props4","selectProps","renderArgLabel","showPrefix","renderArgLabelSep","renderArgVal","_this$props5","defaultValueSource","ArgWidget","renderArgSep","argIndex","renderBracketBefore","renderBracketAfter","renderFuncArgs","funcDefinition","_value$get3","_value$get4","funcLevel","_Component2","_delta","_this2$props","_this2$props2","FieldWrapper","classname","customFieldSelectProps","fieldSourcesOptions","canSelectFieldSource","OperatorOptions","operatorDefinitions","_operatorDefinitions$","optionsFactory","basicOptionsProps","optionsCmp","setOption","Icon","Btn","BtnGrp","Switch","BeforeWidget","AfterWidget","RuleError","doRemove","selectedFieldConfig","isSelectedGroup","isFieldAndOpSelected","selectedOperatorConfig","selectedOperatorHasOptions","hideOperator","showDragIcon","showWidget","showOperatorOptions","confirmOptions","isEmptyCurrentRule","onOk","onCancel","ruleData","_buildWidgetProps","immutableFieldsMode","immutableOpsMode","immutableValuesMode","oneError","onMouseDown","_this$props6","immutableGroupsMode","onClick","_this$props7","showLock","checkedLabel","hideLabel","_this$props8","canShrinkValue","renderOperatorOptions","renderError","drag","renderDrag","renderLock","del","renderDel","ConnectedRuleContainer","createGroupContainer","Group","itemType","_GroupContainer","GroupContainer","_selectedConjunction","selectedConjunction","conjunctionOptions","_getConjunctionOptions","oldConjunction","checked","currentNesting","allowFurtherNesting","isMaxNestingExceeded","ConnectedGroupContainer","groupActionsPositionList","topLeft","topCenter","topRight","bottomLeft","bottomCenter","bottomRight","GroupActions","canAddGroup","canAddRule","canDeleteGroup","groupActionsPosition","setLockSwitch","addRuleBtn","addGroupBtn","delGroupBtn","BasicGroup","childrenClassName","BeforeActions","AfterActions","Conjs","isEmptyCurrentGroup","showNot","forceShowConj","isOneChild","showConjs","renderChildren","isGroupTopPosition","isNoChildren","renderHeader","renderActions","Item","reordableNodesCntForItem","totalRulesCntForItem","extraPropsForItem","_item","conjunctionOptionsForGroupField","_this$props9","renderHeaderWrapper","renderChildrenWrapper","renderFooterWrapper","_get","RuleGroupActions","addSubRuleBtn","_superPropGet","RuleGroup","_BasicGroup","_selectedFieldConfig$","RuleGroupExtActions","addSubGroupBtn","RuleGroupExt","renderGroupField","_selectedFieldConfig$2","_this$props10","SwitchGroupActions","canAddDefault","addCaseGroupBtn","addDefaultCaseGroupBtn","SwitchGroup","hasDefaultCase","_this$props$children","_this$props$children2","totalCasesCnt","_this$props$children3","casesToReorder","_this$props$children4","CaseGroup","BeforeCaseValue","AfterCaseValue","renderHeaderLeft","renderHeaderCenter","renderCondition","renderBeforeValue","renderValue","renderAfterValue","oneValue","hasValue","getProperties","_props$properties","typeMap","rule_group","rule_group_ext","switch_group","case_group","_props$properties2","itemComponent","_updPath","rootType","ConnectedSortableContainer","ValueField","needUpdateMeta","filteredFields","filterFields","_leftFieldConfig$widg","customPlaceholder","leftFieldWidgetField","leftFieldWidgetFieldProps","rightFieldKey","rightFieldFullkey","hideForCompare","isValueField","_props$customProps","customRadioYesProps","radioYes","customRadioNoProps","radioNo","onRadioChange","textValue","maxRows","dtValue","multiple","opt","selected","getMultiSelectValues","numberValue","customInputProps","customSliderProps","display","_renderOptions","fontWeight","color","conjsCount","lessThenTwo","showConj","onNotChange","htmlFor","_conjunctionOptions$k","typeToLabel","btnLabel","renderOptions","okText","cancelText","confirm","VanillaProvider","Proximity","handleChange","defaultProximity","selectedProximity","proxValues","Select","defaultProps","ProximityOperator","VanillaTextWidget","VanillaTextAreaWidget","VanillaNumberWidget","VanillaSliderWidget","VanillaSelectWidget","VanillaMultiSelectWidget","VanillaDateWidget","VanillaTimeWidget","VanillaDateTimeWidget","VanillaBooleanWidget","ValueFieldWidget","VanillaFieldSelect","_ref17","_ref18","VanillaConjs","_ref19","VanillaSwitch","_ref20","VanillaButton","_ref21","VanillaIcon","_ref22","VanillaButtonGroup","_ref23","_ref24","VanillaValueSources","_ref25","_ref26","vanillaConfirm","_ref27","defaultSliderWidth","defaultSelectWidth","defaultSearchWidth","defaultMaxRows","renderSize","C","P","_Utils$Autocomplete","Autocomplete","_Utils$ListUtils","ReactUtils","assocIndexOf","nativeCreate","_regeneratorDefine","_invoke","identity","overRest","setToString","toNumber","INFINITY","baseCreate","getPrototype","isPrototype","__WEBPACK_EXTERNAL_MODULE__1269__","reWhitespace","baseIndexOf","isString","toInteger","fromIndex","guard","__WEBPACK_EXTERNAL_MODULE__1308__","cloneArrayBuffer","cloneDataView","cloneRegExp","cloneSymbol","cloneTypedArray","isDeep","Ctor","arrayPush","isFlattenable","baseFlatten","isStrict","iteratee","_Formatter","_interopRequireDefault","descriptor","tokenizer","reservedWords","reservedTopLevelWords","reservedTopLevelWordsNoIndent","reservedNewlineWords","StandardSqlFormatter","cfg","instance","Constructor","protoProps","staticProps","stringTypes","openParens","closeParens","indexedPlaceholderTypes","namedPlaceholderTypes","lineCommentTypes","copyObject","castPath","isArguments","isIndex","toKey","hasFunc","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","MapCache","baseForOwn","baseValues","QueryEditorPropertyType","QueryEditorExpressionType","baseGetTag","thisArg","freeGlobal","freeExports","freeModule","freeProcess","require","binding","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","ListCache","__WEBPACK_EXTERNAL_MODULE__2007__","getTag","baseIsNative","range","createRange","isKey","__WEBPACK_EXTERNAL_MODULE__2468__","baseGet","baseSlice","coreJsData","_repeat","_last","INDENT_TYPE_TOP_LEVEL","Indentation","indent","indentTypes","hasOwn","classNames","classes","appendClass","parseValue","newClass","baseMerge","createAssigner","srcIndex","getNative","memoize","objectProto","nativeObjectToString","symToStringTag","isOwn","unmasked","canCookies","cookie","order","voidElement","attrs","comment","lastIndex","content","msg","services","forward","alreadyWarned","matchHtmlEntity","htmlEntities","unescapeHtmlEntity","defaultOptions","bindI18n","bindI18nStore","transEmptyNodeValue","transSupportBasicHtmlNodes","transWrapTextNodes","transKeepBasicHtmlNodesFor","useSuspense","unescape","setDefaults","i18nInstance","setI18n","checkLength","i18nIsDynamicList","getAsArray","nodesToString","i18nOptions","i18nKey","stringNode","keepArray","childIndex","isValidElement","childPropsCount","shouldKeepChild","childChildren","renderNodes","knownComponentsMap","targetString","combinedTOpts","shouldUnescape","emptyChildrenButNeedsHandling","keep","getData","childs","renderInner","rootReactNode","mappedChildren","mapAST","hasValidReactChildren","pushTranslatedJSX","inner","mem","isVoid","dummy","cloneElement","Children","createElement","reactNode","astNode","reactNodes","translationContent","interpolator","interpolate","newTarget","mergeProps","isElement","isValidTranslationWithChildren","isEmptyTransWithHTML","isKnownComponent","wrapTextNodes","fixComponentProps","component","translation","componentKey","Fragment","generateComponents","generateArrayComponents","componentMap","generateObjectComponents","isComponentsMap","react","createContext","tOptions","ns","i18nFromProps","tFromProps","additionalProps","i18nFromContext","defaultNS","defaultNSFromContext","useContext","reactI18nextOptions","namespaces","nodeAsString","hashTransKey","interpolation","defaultVariables","interpolationOverride","alwaysFormat","generatedComponents","indexedChildren","componentsMap","useAsParent","defaultTransParent","Trans","tFunc","transComponent","PSEUDO_LOCALE","initTFuncAndTransComponent","getI18nInstance","getFixedT","I18NextTrans","loadNamespacedResources","namespace","loaders","resolvedLanguage","DEFAULT_LANGUAGE","loader","resources","addResourceBundle","initDefaultI18nInstance","initPromise","use","initReactI18next","returnEmptyString","lng","initPluginTranslations","getI18n","initDefaultReactI18nInstance","getResolvedLanguage","defaultMessage","__WEBPACK_EXTERNAL_MODULE__3059__","dataView","objectCreate","QueryFormat","QUERY_FORMAT_OPTIONS","toOptionFromData","baseToString","_isEmpty","_escapeRegExp","_tokenTypes","WHITESPACE_REGEX","NUMBER_REGEX","OPERATOR_REGEX","BLOCK_COMMENT_REGEX","LINE_COMMENT_REGEX","createLineCommentRegex","RESERVED_TOP_LEVEL_REGEX","createReservedWordRegex","RESERVED_TOP_LEVEL_NO_INDENT_REGEX","RESERVED_NEWLINE_REGEX","RESERVED_PLAIN_REGEX","WORD_REGEX","createWordRegex","specialWordChars","STRING_REGEX","createStringRegex","OPEN_PAREN_REGEX","createParenRegex","CLOSE_PAREN_REGEX","INDEXED_PLACEHOLDER_REGEX","createPlaceholderRegex","IDENT_NAMED_PLACEHOLDER_REGEX","STRING_NAMED_PLACEHOLDER_REGEX","createStringPattern","reservedWordsPattern","patterns","parens","escapeParen","paren","typesRegex","getNextToken","previousToken","getWhitespaceToken","getCommentToken","getStringToken","getOpenParenToken","getCloseParenToken","getPlaceholderToken","getNumberToken","getReservedWordToken","getWordToken","getOperatorToken","getTokenOnFirstMatch","getLineCommentToken","getBlockCommentToken","getIdentNamedPlaceholderToken","getStringNamedPlaceholderToken","getIndexedPlaceholderToken","getPlaceholderTokenWithKey","parseKey","getEscapedPlaceholderKey","quoteChar","getTopLevelReservedToken","getNewlineReservedToken","getTopLevelReservedTokenNoIndent","getPlainReservedToken","ID_GLOBAL_REGEXP","QUAL_GLOBAL_REGEXP","CHARS_GLOBAL_REGEXP","CHARS_ESCAPE_MAP","escapeString","chunkIndex","escapedVal","zeroPad","escapeId","forbidQualified","stringifyObjects","timeZone","dateToString","arrayToList","Buffer","isBuffer","bufferToString","toSqlString","objectToValues","placeholdersRegex","valuesIndex","millisecond","dt","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","tz","convertTimezone","setTime","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","raw","__WEBPACK_EXTERNAL_MODULE__3241__","baseMatches","baseMatchesProperty","COLUMN","MACROS","Filter","Value","Table","Column","_b","_c","provider","triggerCharacters","builtinFunctions","supportedFunctions","comparisonOperators","toLocaleLowerCase","Comparison","logicalOperators","Logical","supportedOperators","supportedMacros","uid","maskSrcKey","IE_PROTO","resolver","memoized","Cache","fromRight","getAllKeys","objProps","objLength","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","haveColumn","haveFunction","setGroupByField","GroupBy","setPropertyField","Property","createFunctionField","Function","getColumnValue","_instanceof","nativeMap","nativeSet","nativePromise","circular","includeNonEnumerable","allParents","allChildren","useBuffer","_clone","reject","__isArray","__isRegExp","__getRegExpFlags","__isDate","allocUnsafe","copy","keyChild","valueChild","entryChild","symbols","symbol","allPropertyNames","__objToStr","global","ignoreCase","multiline","clonePrototype","baseClamp","regenerator","regeneratorAsyncIterator","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","isBinary","isKeyable","assignValue","nested","funcToString","arrayLikeKeys","baseKeys","nativeFloor","pluginJson","loadSQLResources","plugin","DataSourcePlugin","setQueryEditor","SqlQueryEditorLazy","setQueryEditorHelp","CheatSheet","setConfigEditor","ConfigurationEditor","baseHasIn","hasPath","regeneratorAsync","regeneratorAsyncGen","regeneratorKeys","regeneratorValues","_regeneratorRuntime","resultName","finish","_t","sent","wrap","isGeneratorFunction","mark","awrap","async","NumberInput","setIsEmpty","useState","Input","currentTarget","stubFalse","isFunction","isMasked","reIsHostCtor","funcProto","reIsNative","Db2Formatter","constant","baseSetToString","matchesStrictComparable","COMPARE_PARTIAL_FLAG","sqlFormatter","DataSourceDescription","dataSourceName","docsLink","hasRequiredFields","theme","useTheme2","container","css","margin","marginTop","spacing","typography","colors","secondary","link","textDecoration","cx","href","ConfigSection","GenericConfigSection","effect","useEffect","AzureCloud","AzureCloud2","getDefaultAzureCloud","azure","cloud","instanceOfAzureCredential","authType","concealed","concealedLegacy","getClientSecret","secureJsonFields","azureClientSecret","clientSecret","secret","secureJsonData","getAdPassword","password","getCredentials","dsSettings","credentials","oboEnabled","jsonData","azureCredentials","managedIdentityEnabled","workloadIdentityEnabled","azureCloud","tenantId","clientId","userId","userIdentityEnabled","serviceCredentials","serviceCredentialsEnabled","getDatasourceCredentials","AzureCredentialsForm","azureEntraPasswordCredentialsEnabled","azureCloudOptions","onCredentialsChange","onClientIdChange","event","updated","authTypeOptions","div","isDisabled","inputId","aria-label","invalid","gap","data-testid","Button","variant","KnownAzureClouds","Public","AzureAuthSettings","dataSourceConfig","azureAuthType","cloudName","oauthPassThru","disableGrafanaCache","updateDatasourceCredentials","useEffectOnce","readOnly","MSSQLAuthenticationType","MSSQLEncryptOptions","UsernameMessage","span","KerberosConfig","onOptionsChange","keytabFilePath","credentialCache","credentialCacheLookupFile","authenticationType","kerberosKeytab","FieldSet","user","updateDatasourcePluginJsonDataOption","kerberosCredentialCache","kerberosCredentialCacheLookupFile","KerberosAdvancedSettings","configFilePath","UDPConnectionLimit","onUDPLimitChanged","enableDNSLookupKDC","TextLink","external","LONG_WIDTH","useMigrateDatabaseFields","useStyles2","getStyles","azureAuthIsSupported","azureAuthEnabled","azureAuthSettings","onDSOptionChanged","encryptOptions","disable","false","true","Alert","severity","permissionType","example1","example2","em","Divider","url","onUpdateDatasourceJsonDataOption","ul","ulPadding","li","encryptionValue","encrypt","tlsSkipVerify","sslRootCertFile","serverName","sqlAuth","basicAuthenticationOptions","windowsAuth","kerberosRaw","azureAuth","buildAuthenticationOptions","SecretInput","isConfigured","onReset","updateDatasourcePluginResetOption","onUpdateDatasourceSecureJsonDataOption","isCollapsible","isInitiallyOpen","ConnectionLimits","exampleInterval","timeInterval","defaultTimeout","connectionTimeout","secureSocksDSProxyEnabled","SecureSocksProxySettings","isNew","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","componentName","location","propFullName","getShim","ReactPropTypes","bigint","any","arrayOf","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","SetCache","arraySome","cacheHas","arrLength","othLength","arrStacked","seen","arrValue","othIndex","hashClear","hashDelete","hashGet","hashHas","hashSet","Hash","spreadableSymbol","isConcatSpreadable","baseIsTypedArray","nodeIsTypedArray","isTypedArray","baseIsArguments","objectCtorString","baseFor","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","lower","upper","toFinite","remainder","pairs","LARGE_ARRAY_SIZE","keysFunc","editorMode","Code","DataView","__WEBPACK_EXTERNAL_MODULE__5959__","baseKeysIn","mapTag","promiseTag","setTag","weakMapTag","dataViewTag","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","ArrayBuffer","ctorString","createBaseFor","__WEBPACK_EXTERNAL_MODULE__6089__","randomUUID","crypto","getRandomValues","rnds8","byteToHex","unsafeStringify","buf","rnds","rng","RangeError","reIsDeepProp","reIsPlainProp","nativeKeys","arrayEach","baseAssign","baseAssignIn","cloneBuffer","copyArray","copySymbols","copySymbolsIn","initCloneArray","initCloneByTag","initCloneObject","argsTag","funcTag","objectTag","cloneableTags","baseClone","isFlat","isFull","subValue","arrayFilter","stubArray","nativeGetSymbols","overArg","reIsUint","baseProperty","basePropertyDeep","baseTimes","inherited","isArg","isBuff","isType","skipIndexes","isOpen","setIsOpen","iconName","isSubSection","collapsibleButtonAriaLabel","header","justifyContent","alignItems","subtitle","fontWeightRegular","descriptionText","marginBottom","bodySmall","IconButton","reFlags","regexp","h2","columnName","null","previous","timeGroupMacro","pre","br","baseUnset","customOmitClone","flatRest","CLONE_DEEP_FLAG","trimmedEndIndex","reTrimStart","shortOut","_Db2Formatter","_N1qlFormatter","_PlSqlFormatter","_StandardSqlFormatter","_default","__WEBPACK_EXTERNAL_MODULE__7694__","arrayBuffer","__WEBPACK_EXTERNAL_MODULE__7781__","matchData","noCustomizer","tokenOverride","previousReservedToken","PlSqlFormatter","typedArray","for","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","__self","__source","$$typeof","_owner","jsxs","OperatorType","OperatorType2","MacroType","MacroType2","TokenType2","StatementPosition","StatementPosition2","SuggestionKind","SuggestionKind2","CompletionItemPriority","CompletionItemPriority2","CompletionItemKind","CompletionItemKind2","CompletionItemInsertTextRule","CompletionItemInsertTextRule2","assignMergeValue","isArrayLikeObject","safeGet","toPlainObject","mergeFunc","isCommon","isTyped","baseIsMatch","getMatchData","setCacheAdd","setCacheHas","webpackAsyncContext","req","ids","symbolsFunc","reRegExpChar","reHasRegExpChar","__WEBPACK_EXTERNAL_MODULE__8531__","stackClear","stackDelete","stackGet","stackHas","stackSet","baseRange","isIterateeCall","baseIsSet","nodeIsSet","basePick","pick","intervalParam","fillParam","MACRO_NAMES","ResponseParser","transformMetricFindResponse","frame","valueField","uniqBy","QueryEditor","lazy","Suspense","fallback","LoadingPlaceholder","marginLeft","migrateAnnotation","annotation","oldQuery","newQuery","workspace","subscription","DataSourceWithBackend","getResponseParser","responseParser","interpolateVariablesInQueries","queries","expandedQueries","datasource","getRef","interpolateVariable","hide","applyTemplateVariables","request","databaseIssue","checkForDatabaseIssue","throwError","targets","app","CoreApp","Dashboard","PanelViewer","reportInteraction","preconfiguredDatabase","Explore","metricFindQuery","variable","getSearchFilterScopedVar","wildcardChar","interpolatedQuery","runMetaQuery","getDefaultTimeRange","DataFrameView","lastValueFrom","getBackendSrv","fetch","headers","getRequestHeaders","requestId","pipe","rsp","toDataQueryResponse","targetContainsTemplate","queryWithoutMacros","containsTemplate","getTemplateSrv","multi","includeAll","settingsData","annotations","prepareAnnotation","MaxLifetimeField","labelWidth","onMaxLifetimeChanged","Label","Tooltip","connMaxLifetime","sqlConnectionLimits","MaxOpenConnectionsField","onMaxConnectionsChanged","maxOpenConns","autoIdle","maxIdleConnsAuto","updateJsonData","newOpts","onJSONDataNumberChanged","maxIdleConns","defaultMaxIdle","idleConns","maxConns","InlineLabel","sqlPluginLogger","createMonitoringLogger","newOptions","optionsUpdated","logDebug","lang","loadResources","getRawTag","objectToString","baseMergeDeep","equalByTag","equalObjects","arrayTag","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","InlineBlock","isInlineBlock","isForbiddenToken","COMMENT","_includes","_Indentation","_InlineBlock","_Params","trimSpacesEnd","Formatter","indentation","inlineBlock","previousReservedWord","getFormattedQueryFromTokens","formattedQuery","formatLineComment","formatBlockComment","formatTopLevelReservedWord","formatTopLevelReservedWordNoIndent","formatNewlineReservedWord","formatWithSpaces","formatOpeningParentheses","formatClosingParentheses","formatPlaceholder","formatComma","formatWithSpaceAfter","formatWithoutSpaces","formatQuerySeparator","addNewline","indentComment","getIndent","decreaseTopLevel","equalizeWhitespace","formatReservedWord","increaseTopLevel","preserveWhitespaceFor","uppercase","beginIfPossible","isActive","increaseBlockLevel","decreaseBlockLevel","resetIndentation","repeat","linesBetweenQueries","nativeCeil","resIndex","nativeKeysIn","isProto","Params","N1qlFormatter","baseRest","assigner","nativeMin","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","clearTimeout","cancel","flush","baseFindIndex","baseIsNaN","strictIndexOf","typedArrayTags","symbolToString","baseRepeat","baseSet","freeSelf","__webpack_module_cache__","cachedModule","loaded","__webpack_modules__","queue","hasAwait","currentDeps","outerResolve","depQueues","promise","rej","deps","dep","wrapDeps","getResult","fnQueue","definition","chunkId","promises","needAttach","scripts","getElementsByTagName","charset","timeout","nc","setAttribute","src","onScriptComplete","onerror","onload","doneFns","removeChild","appendChild","nmd","installedChunks","j","installedChunkData","errorType","realSrc","webpackJsonpCallback","parentChunkLoadingFunction","chunkIds","moreModules","chunkLoadingGlobal"],"sourceRoot":""}