{"version":3,"file":"static/js/lintWorker.031a3d93.chunk.js","mappings":"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","sources":["../packages/ast/src/utils.ts","ce/workers/Evaluation/getEntityForEvalContextMap.ts","workers/Evaluation/getEntityForContext.ts","ce/workers/Evaluation/Actions.ts","workers/common/JSLibrary/index.ts","utils/DynamicBindingUtils.ts","workers/Evaluation/handlers/workerEnv.ts","workers/common/DependencyMap/utils.ts","workers/Evaluation/evaluate.ts","ce/entities/FeatureFlag.ts","../packages/ast/src/index.ts","workers/Evaluation/JSObject/index.ts","workers/common/JSLibrary/lodash-wrapper.js","workers/Evaluation/setters.ts","../packages/ast/src/jsObject/index.ts","ce/entities/DataTree/types.ts","ee/entities/DataTree/types.ts","workers/Evaluation/fns/index.ts","ce/workers/Evaluation/evaluationUtils.ts","components/editorComponents/ActionCreator/constants.ts","ce/constants/routes/appRoutes.ts","entities/DependencyMap/index.ts","plugins/Linting/types.ts","workers/common/JSLibrary/resetJSLibraries.ts","ce/plugins/Linting/lib/entity/types.ts","plugins/Linting/utils/diffGenerator.ts","plugins/Linting/lib/entity/JSActionEntity.ts","plugins/Linting/lib/entity/ActionEntity.ts","plugins/Linting/lib/entity/AppsmithEntity.ts","plugins/Linting/lib/entity/WidgetEntity.ts","ce/plugins/Linting/lib/entity/index.ts","ee/plugins/Linting/lib/entity/index.ts","ce/plugins/Linting/lib/entity/isDynamicEntity.ts","plugins/Linting/utils/pathUtils.ts","plugins/Linting/utils/mergeMaps.ts","ce/plugins/Linting/utils/getEntityDependencies.ts","plugins/Linting/utils/groupDifferencesByType.ts","plugins/Linting/utils/getEvaluationContext.ts","plugins/Linting/globalData.ts","plugins/Linting/customRules/no-floating-promises.ts","plugins/Linting/constants.ts","plugins/Linting/utils/isEntityFunction.ts","plugins/Linting/utils/getLintSeverity.ts","ce/plugins/Linting/utils/getInvalidModuleInputsError.ts","ee/plugins/Linting/utils/getInvalidModuleInputsError.ts","../packages/utils/src/object/keys.ts","instrumentation/generateWebWorkerTraces.ts","pages/Editor/SaaSEditor/constants.ts","ce/IDE/Interfaces/IDETypes.ts","ce/IDE/constants/routes.ts","ce/entities/IDE/utils/getIDETypeByUrl.ts","ce/utils/permissionHelpers.tsx","ce/entities/IDE/utils/getEditableTabPermissions.ts","plugins/Linting/utils/getLintingErrors.ts","ce/utils/lintRulesHelpers.ts","plugins/Linting/utils/getJSToLint.ts","plugins/Linting/utils/lintJSObjectProperty.ts","plugins/Linting/utils/lintJSProperty.ts","plugins/Linting/lintTree.ts","plugins/Linting/utils/sortLintingPathsByType.ts","plugins/Linting/utils/lintBindingPath.ts","plugins/Linting/utils/lintTriggerPath.ts","plugins/Linting/utils/lintJSObjectBody.ts","plugins/Linting/utils/entityParser.ts","plugins/Linting/lib/entity/EntityTree.ts","plugins/Linting/handlers/lintService.ts","plugins/Linting/handlers/index.ts","plugins/Linting/handlers/updateJSLibraryGlobals.ts","plugins/Linting/handlers/setupLinkingWorkerEnv.ts","plugins/Linting/linters/worker.ts","ce/entities/DataTree/utils.ts","../packages/ast/src/constants/ast.ts","../webpack/bootstrap","../webpack/runtime/amd options","../webpack/runtime/chunk loaded","../webpack/runtime/compat get default export","../webpack/runtime/create fake namespace object","../webpack/runtime/define property getters","../webpack/runtime/ensure chunk","../webpack/runtime/get javascript chunk filename","../webpack/runtime/get mini-css chunk filename","../webpack/runtime/global","../webpack/runtime/hasOwnProperty shorthand","../webpack/runtime/make namespace object","../webpack/runtime/node module decorator","../webpack/runtime/runtimeId","../webpack/runtime/publicPath","../webpack/runtime/compat","../webpack/runtime/importScripts chunk loading","../webpack/runtime/nonce","../webpack/runtime/startup chunk dependencies","../webpack/startup"],"sourcesContent":["import unescapeJS from \"unescape-js\";\nimport type { PropertyNode } from \"../index\";\nimport { isLiteralNode } from \"../index\";\n\nconst beginsWithLineBreakRegex = /^\\s+|\\s+$/;\n\nexport function sanitizeScript(js: string, evaluationVersion: number) {\n  // We remove any line breaks from the beginning of the script because that\n  // makes the final function invalid. We also unescape any escaped characters\n  // so that eval can happen\n  //default value of evalutaion version is 2\n  evaluationVersion = evaluationVersion ? evaluationVersion : 2;\n  const trimmedJS = js.replace(beginsWithLineBreakRegex, \"\");\n\n  return evaluationVersion > 1 ? trimmedJS : unescapeJS(trimmedJS);\n}\n\n// For the times when you need to know if something truly an object like { a: 1, b: 2}\n// typeof, lodash.isObject and others will return false positives for things like array, null, etc\nexport const isTrueObject = (\n  item: unknown,\n): item is Record<string, unknown> => {\n  return Object.prototype.toString.call(item) === \"[object Object]\";\n};\n\nexport const getNameFromPropertyNode = (node: PropertyNode): string =>\n  isLiteralNode(node.key) ? String(node.key.value) : node.key.name;\n\ninterface Position {\n  line: number;\n  ch: number;\n}\n\nexport const extractContentByPosition = (\n  content: string,\n  position: { from: Position; to: Position },\n) => {\n  const eachLine = content.split(\"\\n\");\n\n  let returnedString = \"\";\n\n  for (let i = position.from.line; i <= position.to.line; i++) {\n    if (i === position.from.line) {\n      returnedString =\n        position.from.line !== position.to.line\n          ? eachLine[position.from.line].slice(position.from.ch)\n          : eachLine[position.from.line].slice(\n              position.from.ch,\n              position.to.ch + 1,\n            );\n    } else if (i === position.to.line) {\n      returnedString += eachLine[position.to.line].slice(0, position.to.ch + 1);\n    } else {\n      returnedString += eachLine[i];\n    }\n\n    if (i !== position.to.line) {\n      returnedString += \"\\n\";\n    }\n  }\n\n  return returnedString;\n};\n\nexport const getStringValue = (\n  inputValue: string | number | boolean | RegExp,\n) => {\n  if (typeof inputValue === \"object\" || typeof inputValue === \"boolean\") {\n    inputValue = JSON.stringify(inputValue);\n  } else if (typeof inputValue === \"number\" || typeof inputValue === \"string\") {\n    inputValue += \"\";\n  }\n\n  return inputValue;\n};\n","import { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { getJSActionForEvalContext } from \"ee/workers/Evaluation/getJSActionForEvalContext\";\n\nexport const getEntityForEvalContextMap: Record<\n  string,\n  (entityName: string, entity: DataTreeEntity) => unknown\n> = {\n  [ENTITY_TYPE.JSACTION]: (entityName, entity) => {\n    return getJSActionForEvalContext(entityName, entity);\n  },\n};\n","import { getEntityForEvalContextMap } from \"ee/workers/Evaluation/getEntityForEvalContextMap\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\n\nexport function getEntityForEvalContext(\n  entity: DataTreeEntity,\n  entityName: string,\n) {\n  const getterMethod = getEntityForEvalContextMap[entity.ENTITY_TYPE];\n\n  if (!getterMethod) return entity;\n\n  return getterMethod(entityName, entity);\n}\n","/* eslint-disable @typescript-eslint/ban-types */\n\nimport set from \"lodash/set\";\nimport type { DataTreeEntityConfig } from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { EvalContext } from \"workers/Evaluation/evaluate\";\nimport type { EvaluationVersion } from \"constants/EvalConstants\";\nimport { addFn } from \"workers/Evaluation/fns/utils/fnGuard\";\nimport {\n  getEntityFunctions,\n  getPlatformFunctions,\n} from \"ee/workers/Evaluation/fns\";\nimport { getEntityForEvalContext } from \"workers/Evaluation/getEntityForContext\";\nimport { klona } from \"klona/full\";\nimport { isEmpty } from \"lodash\";\nimport setters from \"workers/Evaluation/setters\";\ndeclare global {\n  /** All identifiers added to the worker global scope should also\n   * be included in the DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS in\n   * app/client/src/constants/WidgetValidation.ts\n   * */\n\n  interface Window {\n    $isDataField: boolean;\n    $isAsync: boolean;\n    $evaluationVersion: EvaluationVersion;\n    $cloudHosting: boolean;\n  }\n}\n\nexport enum ExecutionType {\n  PROMISE = \"PROMISE\",\n  TRIGGER = \"TRIGGER\",\n}\n\n/**\n * This method returns new dataTree with entity function and platform function\n */\nexport const getDataTreeContext = (args: {\n  dataTree: Readonly<DataTree>;\n  removeEntityFunctions?: boolean;\n  isTriggerBased: boolean;\n  configTree: ConfigTree;\n}) => {\n  const {\n    configTree,\n    dataTree,\n    isTriggerBased,\n    removeEntityFunctions = false,\n  } = args;\n  const EVAL_CONTEXT: EvalContext = {};\n\n  const dataTreeEntries = Object.entries(dataTree);\n  const entityFunctionCollection: Record<string, Record<string, Function>> = {};\n\n  if (isTriggerBased && !removeEntityFunctions) setters.clear();\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    EVAL_CONTEXT[entityName] = getEntityForEvalContext(entity, entityName);\n\n    // when we evaluate data field and removeEntityFunctions is true then we skip adding entity function to evalContext\n    const skipEntityFunctions = !removeEntityFunctions && !isTriggerBased;\n\n    if (skipEntityFunctions) continue;\n\n    for (const entityFn of getEntityFunctions()) {\n      if (!entityFn.qualifier(entity)) continue;\n\n      const func = entityFn.fn(entity, entityName);\n      const fullPath = `${entityFn.path || `${entityName}.${entityFn.name}`}`;\n\n      set(entityFunctionCollection, fullPath, func);\n    }\n\n    // Don't add entity function ( setter method ) to evalContext if removeEntityFunctions is true\n    if (removeEntityFunctions) continue;\n\n    const entityConfig = configTree[entityName];\n    const entityMethodMap = setters.getEntitySettersFromConfig(\n      entityConfig,\n      entityName,\n      entity,\n    );\n\n    if (isEmpty(entityMethodMap)) continue;\n\n    EVAL_CONTEXT[entityName] = Object.assign(\n      {},\n      dataTree[entityName],\n      entityMethodMap,\n    );\n  }\n\n  if (removeEntityFunctions) {\n    removeEntityFunctionsFromEvalContext(\n      entityFunctionCollection,\n      EVAL_CONTEXT,\n    );\n\n    return EVAL_CONTEXT;\n  }\n\n  if (!isTriggerBased) {\n    return EVAL_CONTEXT;\n  }\n\n  // if eval is not trigger based i.e., sync eval then we skip adding entity function to evalContext\n  addEntityFunctionsToEvalContext(EVAL_CONTEXT, entityFunctionCollection);\n\n  return EVAL_CONTEXT;\n};\n\nexport const addEntityFunctionsToEvalContext = (\n  evalContext: EvalContext,\n  entityFunctionCollection: Record<string, Record<string, Function>>,\n) => {\n  for (const [entityName, funcObj] of Object.entries(\n    entityFunctionCollection,\n  )) {\n    evalContext[entityName] = Object.assign(\n      {},\n      evalContext[entityName],\n      funcObj,\n    );\n  }\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const addPlatformFunctionsToEvalContext = (context: any) => {\n  for (const fnDef of getPlatformFunctions()) {\n    addFn(context, fnDef.name, fnDef.fn.bind(context));\n  }\n};\n\nexport function getAllSetterFunctions(\n  dataTree: DataTree,\n  configTree: ConfigTree,\n) {\n  const entitiesSetterFunctions: Record<string, true> = {};\n  const dataTreeEntries = Object.entries(dataTree);\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    const entityConfig = configTree[entityName];\n    const entityMethodMap = setters.getEntitySettersFromConfig(\n      entityConfig,\n      entityName,\n      entity,\n    );\n\n    if (isEmpty(entityMethodMap)) continue;\n\n    for (const methodName of Object.keys(entityMethodMap)) {\n      entitiesSetterFunctions[`${entityName}.${methodName}`] = true;\n    }\n  }\n\n  return entitiesSetterFunctions;\n}\n\nexport function getEntitySetterFunctions(\n  entityConfig: DataTreeEntityConfig,\n  entityName: string,\n  entity: DataTreeEntity,\n) {\n  const entitySetterFunctions: Record<string, true> = {};\n  const entityMethodMap = setters.getEntitySettersFromConfig(\n    entityConfig,\n    entityName,\n    entity,\n  );\n\n  for (const methodName of Object.keys(entityMethodMap)) {\n    entitySetterFunctions[`${entityName}.${methodName}`] = true;\n  }\n\n  return entitySetterFunctions;\n}\n\nexport const getAllAsyncFunctions = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n) => {\n  let allAsyncFunctions: Record<string, true> = {};\n  const dataTreeEntries = Object.entries(dataTree);\n\n  for (const [entityName, entity] of dataTreeEntries) {\n    for (const entityFn of getEntityFunctions()) {\n      if (!entityFn.qualifier(entity)) continue;\n\n      const fullPath = `${entityFn.path || `${entityName}.${entityFn.name}`}`;\n\n      allAsyncFunctions[fullPath] = true;\n    }\n  }\n\n  const setterMethods = getAllSetterFunctions(dataTree, configTree);\n\n  allAsyncFunctions = { ...allAsyncFunctions, ...setterMethods };\n\n  for (const platformFn of getPlatformFunctions()) {\n    allAsyncFunctions[platformFn.name] = true;\n  }\n\n  return allAsyncFunctions;\n};\n\nexport const removeEntityFunctionsFromEvalContext = (\n  entityFunctionCollection: Record<string, Record<string, Function>>,\n  evalContext: EvalContext,\n) => {\n  for (const [entityName, funcObj] of Object.entries(\n    entityFunctionCollection,\n  )) {\n    const entity = klona(evalContext[entityName]);\n\n    Object.keys(funcObj).forEach((entityFn) => {\n      delete entity[entityFn];\n    });\n    evalContext[entityName] = entity;\n  }\n};\n","import lodashPackageJson from \"lodash/package.json\";\nimport momentPackageJson from \"moment-timezone/package.json\";\n\nexport interface JSLibrary {\n  version?: string;\n  docsURL: string;\n  name: string;\n  accessor: string[];\n  url?: string;\n  id?: string;\n}\n\nexport const defaultLibraries: JSLibrary[] = [\n  {\n    accessor: [\"_\"],\n    version: lodashPackageJson.version,\n    docsURL: `https://lodash.com/docs/${lodashPackageJson.version}`,\n    name: \"lodash\",\n  },\n  {\n    accessor: [\"moment\"],\n    version: momentPackageJson.version,\n    docsURL: `https://momentjs.com/docs/`,\n    name: \"moment\",\n  },\n  {\n    accessor: [\"forge\"],\n    version: \"1.3.0\",\n    docsURL: \"https://github.com/digitalbazaar/forge\",\n    name: \"forge\",\n  },\n];\n\nexport const JSLibraries = [...defaultLibraries];\n\nconst JSLibraryAccessorModifier = () => {\n  let jsLibraryAccessorSet = new Set(\n    JSLibraries.flatMap((lib) => lib.accessor),\n  );\n\n  return {\n    regenerateSet: () => {\n      jsLibraryAccessorSet = new Set(\n        JSLibraries.flatMap((lib) => lib.accessor),\n      );\n\n      return;\n    },\n    getSet: () => {\n      return jsLibraryAccessorSet;\n    },\n  };\n};\n\nexport const JSLibraryAccessor = JSLibraryAccessorModifier();\n\nexport const libraryReservedIdentifiers = defaultLibraries.reduce(\n  (acc, lib) => {\n    lib.accessor.forEach((a) => (acc[a] = true));\n\n    return acc;\n  },\n  {} as Record<string, boolean>,\n);\n","import _, { get, isString } from \"lodash\";\nimport { DATA_BIND_REGEX } from \"constants/BindingsConstants\";\nimport type { Action } from \"entities/Action\";\nimport type { WidgetProps } from \"widgets/BaseWidget\";\nimport type { Severity } from \"entities/AppsmithConsole\";\nimport {\n  getEntityNameAndPropertyPath,\n  isAction,\n  isJSAction,\n  isTrueObject,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { DataTreeEntityConfig } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { getType, Types } from \"./TypeHelpers\";\nimport { ViewTypes } from \"components/formControls/utils\";\n\nexport type DependencyMap = Record<string, Array<string>>;\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FormEditorConfigs = Record<string, any[]>;\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type FormSettingsConfigs = Record<string, any[]>;\nexport type FormDependencyConfigs = Record<string, DependencyMap>;\nexport type FormDatasourceButtonConfigs = Record<string, string[]>;\n\nfunction hasNonStringSemicolons(stringifiedJS: string) {\n  // This regex pattern matches semicolons that are not inside single or double quotes\n  const regex = /;(?=(?:[^']*'[^']*')*[^']*$)(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/g;\n\n  return regex.test(stringifiedJS);\n}\n\n// referencing DATA_BIND_REGEX fails for the value \"{{Table1.tableData[Table1.selectedRowIndex]}}\" if you run it multiple times and don't recreate\nexport const isDynamicValue = (value: string): boolean =>\n  DATA_BIND_REGEX.test(value);\n\n//{{}}{{}}}\nexport function getDynamicStringSegments(dynamicString: string): string[] {\n  let stringSegments = [];\n  const indexOfDoubleParanStart = dynamicString.indexOf(\"{{\");\n\n  if (indexOfDoubleParanStart === -1) {\n    return [dynamicString];\n  }\n\n  //{{}}{{}}}\n  const firstString = dynamicString.substring(0, indexOfDoubleParanStart);\n\n  firstString && stringSegments.push(firstString);\n  let rest = dynamicString.substring(\n    indexOfDoubleParanStart,\n    dynamicString.length,\n  );\n  //{{}}{{}}}\n  let sum = 0;\n\n  for (let i = 0; i <= rest.length - 1; i++) {\n    const char = rest[i];\n    const prevChar = rest[i - 1];\n\n    if (char === \"{\") {\n      sum++;\n    } else if (char === \"}\") {\n      sum--;\n\n      if (prevChar === \"}\" && sum === 0) {\n        stringSegments.push(rest.substring(0, i + 1));\n        rest = rest.substring(i + 1, rest.length);\n\n        if (rest) {\n          stringSegments = stringSegments.concat(\n            getDynamicStringSegments(rest),\n          );\n          break;\n        }\n      }\n    }\n  }\n\n  if (sum !== 0 && dynamicString !== \"\") {\n    return [dynamicString];\n  }\n\n  return stringSegments;\n}\n\n//{{}}{{}}}\nexport const getDynamicBindings = (\n  dynamicString: string,\n  entity?: DataTreeEntity,\n): { stringSegments: string[]; jsSnippets: string[] } => {\n  // Protect against bad string parse\n  if (!isString(dynamicString)) {\n    return { stringSegments: [], jsSnippets: [] };\n  }\n\n  const sanitisedString = dynamicString.trim();\n\n  if (entity && isJSAction(entity)) {\n    return { stringSegments: [sanitisedString], jsSnippets: [sanitisedString] };\n  }\n\n  // Get the {{binding}} bound values\n  const stringSegments = getDynamicStringSegments(sanitisedString);\n  // Get the \"binding\" path values\n  const jsSnippets = stringSegments.map((segment) => {\n    const length = segment.length;\n    const matches = isDynamicValue(segment);\n\n    if (matches) {\n      return segment.substring(2, length - 2);\n    }\n\n    return \"\";\n  });\n\n  return { stringSegments, jsSnippets };\n};\n\nexport const combineDynamicBindings = (\n  jsSnippets: string[],\n  stringSegments: string[],\n) => {\n  return stringSegments\n    .map((segment, index) => {\n      if (jsSnippets[index] && jsSnippets[index].length > 0) {\n        return addOperatorPrecedenceIfNeeded(jsSnippets[index]);\n      } else {\n        return JSON.stringify(segment);\n      }\n    })\n    .join(\" + \");\n};\n\n/**\n * Operator precedence example: JSCode =  Color is  {{ currentItem.color || \"Blue\"}}  PS: currentItem.color is undefined\n *  Previously this code would be transformed to  (() =>  \"Color is\" + currentItem.color || \"Blue\")() which evaluates to \"Color is undefined\" rather than \"Color is Blue\"\n * with precedence we'd have (() =>  \"Color is\" + (currentItem.color || \"Blue\"))() which evaluates to Color is Blue,  because the parentheses change the order of evaluation, giving  higher precedence in this case to (currentItem.color || \"Blue\").\n */\nfunction addOperatorPrecedenceIfNeeded(stringifiedJS: string) {\n  /**\n   *  parenthesis doesn't work with ; i.e Color is  {{ currentItem.color || \"Blue\" ;}} cant be (() =>  \"Color is\" + (currentItem.color || \"Blue\";))()\n   */\n  if (!hasNonStringSemicolons(stringifiedJS)) {\n    return `(${stringifiedJS})`;\n  }\n\n  return stringifiedJS;\n}\n\nexport enum EvalErrorTypes {\n  CYCLICAL_DEPENDENCY_ERROR = \"CYCLICAL_DEPENDENCY_ERROR\",\n  EVAL_PROPERTY_ERROR = \"EVAL_PROPERTY_ERROR\",\n  EVAL_TREE_ERROR = \"EVAL_TREE_ERROR\",\n  UNKNOWN_ERROR = \"UNKNOWN_ERROR\",\n  BAD_UNEVAL_TREE_ERROR = \"BAD_UNEVAL_TREE_ERROR\",\n  PARSE_JS_ERROR = \"PARSE_JS_ERROR\",\n  EXTRACT_DEPENDENCY_ERROR = \"EXTRACT_DEPENDENCY_ERROR\",\n  CLONE_ERROR = \"CLONE_ERROR\",\n  SERIALIZATION_ERROR = \"SERIALIZATION_ERROR\",\n}\n\nexport interface EvalError {\n  type: EvalErrorTypes;\n  message: string;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  context?: Record<string, any>;\n}\n\nexport interface DynamicPath {\n  key: string;\n  value?: string;\n}\n\nexport interface WidgetDynamicPathListProps {\n  dynamicBindingPathList?: DynamicPath[];\n  dynamicTriggerPathList?: DynamicPath[];\n  dynamicPropertyPathList?: DynamicPath[];\n}\n\nexport interface EntityWithBindings {\n  dynamicBindingPathList?: DynamicPath[];\n}\n\nexport const getEntityDynamicBindingPathList = (\n  entity: EntityWithBindings,\n): DynamicPath[] => {\n  if (\n    entity &&\n    entity.dynamicBindingPathList &&\n    Array.isArray(entity.dynamicBindingPathList)\n  ) {\n    return [...entity.dynamicBindingPathList];\n  }\n\n  return [];\n};\n\nexport const isPathADynamicBinding = (\n  entity: EntityWithBindings,\n  path: string,\n): boolean => {\n  if (\n    entity &&\n    entity.dynamicBindingPathList &&\n    Array.isArray(entity.dynamicBindingPathList)\n  ) {\n    return _.find(entity.dynamicBindingPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n/**\n * Get property path from full property path\n * Input: \"Table1.meta.searchText\" => Output: \"meta.searchText\"\n * @param {string} fullPropertyPath\n * @return {*}\n */\nexport const getPropertyPath = (fullPropertyPath: string) => {\n  return fullPropertyPath.substring(fullPropertyPath.indexOf(\".\") + 1);\n};\n\nexport const getWidgetDynamicTriggerPathList = (\n  widget: WidgetProps,\n): DynamicPath[] => {\n  if (\n    widget &&\n    widget.dynamicTriggerPathList &&\n    Array.isArray(widget.dynamicTriggerPathList)\n  ) {\n    return [...widget.dynamicTriggerPathList];\n  }\n\n  return [];\n};\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const isPathDynamicTrigger = (widget: any, path: string): boolean => {\n  if (\n    widget &&\n    widget.dynamicTriggerPathList &&\n    Array.isArray(widget.dynamicTriggerPathList)\n  ) {\n    return _.find(widget.dynamicTriggerPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n\nexport const getWidgetDynamicPropertyPathList = (\n  widget: WidgetProps,\n): DynamicPath[] => {\n  if (\n    widget &&\n    widget.dynamicPropertyPathList &&\n    Array.isArray(widget.dynamicPropertyPathList)\n  ) {\n    return [...widget.dynamicPropertyPathList];\n  }\n\n  return [];\n};\n\nexport const isPathDynamicProperty = (\n  widget: WidgetProps,\n  path: string,\n): boolean => {\n  if (\n    widget &&\n    widget.dynamicPropertyPathList &&\n    Array.isArray(widget.dynamicPropertyPathList)\n  ) {\n    return _.find(widget.dynamicPropertyPathList, { key: path }) !== undefined;\n  }\n\n  return false;\n};\n\nexport const THEME_BINDING_REGEX = /{{.*appsmith\\.theme\\..*}}/;\n\nexport const isThemeBoundProperty = (\n  widget: WidgetProps,\n  path: string,\n): boolean => {\n  return widget && widget[path] && THEME_BINDING_REGEX.test(widget[path]);\n};\n\nexport const unsafeFunctionForEval = [\n  \"XMLHttpRequest\",\n  \"setImmediate\",\n  \"Navigator\",\n];\n\nexport const isChildPropertyPath = (\n  parentPropertyPath: string,\n  childPropertyPath: string,\n  // In non-strict mode, an exact match is treated as a child path\n  // Eg. \"Api1\" is a child property path of \"Api1\"\n  strict = false,\n): boolean => {\n  return (\n    (!strict && parentPropertyPath === childPropertyPath) ||\n    childPropertyPath.startsWith(`${parentPropertyPath}.`) ||\n    childPropertyPath.startsWith(`${parentPropertyPath}[`)\n  );\n};\n\n/**\n * Paths set via evaluator on entities\n * During evaluation, the evaluator will set various data points\n * on the entity objects to describe their state while evaluating.\n * This information can be found on the following paths\n * These paths are meant to be objects with\n * information about the properties in\n * a single place\n *\n * Stored in a flattened object like\n * widget.__evaluation__.errors.primaryColumns.customColumn.computedValue = [...]\n **/\nexport const EVALUATION_PATH = \"__evaluation__\";\nexport const EVAL_ERROR_PATH = `${EVALUATION_PATH}.errors`;\nexport const EVAL_VALUE_PATH = `${EVALUATION_PATH}.evaluatedValues`;\n\n/**\n * non-populated object\n {\n   __evaluation__:{\n     evaluatedValues:{\n       primaryColumns: [...],\n       primaryColumns.status: {...},\n       primaryColumns.action: {...}\n     }\n   }\n }\n\n * Populated Object\n {\n   __evaluation__:{\n     evaluatedValues:{\n       primaryColumns: {\n         status: [...],\n         action:[...]\n        }\n     }\n   }\n }\n\n */\nconst getNestedEvalPath = (\n  fullPropertyPath: string,\n  pathType: string,\n  fullPath = true,\n  isPopulated = false,\n) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const nestedPath = isPopulated\n    ? `${pathType}.${propertyPath}`\n    : `${pathType}.['${propertyPath}']`;\n\n  if (fullPath) {\n    return `${entityName}.${nestedPath}`;\n  }\n\n  return nestedPath;\n};\n\nexport const getEvalErrorPath = (\n  fullPropertyPath: string,\n  options = {\n    fullPath: true,\n    isPopulated: false,\n  },\n) => {\n  return getNestedEvalPath(\n    fullPropertyPath,\n    EVAL_ERROR_PATH,\n    options.fullPath,\n    options.isPopulated,\n  );\n};\n\nexport const getEvalValuePath = (\n  fullPropertyPath: string,\n  options = {\n    fullPath: true,\n    isPopulated: false,\n  },\n) => {\n  return getNestedEvalPath(\n    fullPropertyPath,\n    EVAL_VALUE_PATH,\n    options.fullPath,\n    options.isPopulated,\n  );\n};\n\nexport enum PropertyEvaluationErrorType {\n  VALIDATION = \"VALIDATION\",\n  PARSE = \"PARSE\",\n  LINT = \"LINT\",\n}\n\nexport enum PropertyEvaluationErrorCategory {\n  ACTION_INVOCATION_IN_DATA_FIELD = \"ACTION_INVOCATION_IN_DATA_FIELD\",\n}\nexport interface PropertyEvaluationErrorKind {\n  category: PropertyEvaluationErrorCategory;\n  rootcause: string;\n}\n\nexport interface DataTreeError {\n  raw: string;\n  errorMessage: Error;\n  severity: Severity.WARNING | Severity.ERROR;\n}\n\nexport interface EvaluationError extends DataTreeError {\n  errorType:\n    | PropertyEvaluationErrorType.PARSE\n    | PropertyEvaluationErrorType.VALIDATION;\n  originalBinding?: string;\n  kind?: Partial<PropertyEvaluationErrorKind>;\n}\n\nexport interface LintError extends DataTreeError {\n  errorType: PropertyEvaluationErrorType.LINT;\n  errorSegment: string;\n  originalBinding: string;\n  variables: (string | undefined | null)[];\n  code: string;\n  line: number;\n  ch: number;\n  originalPath?: string;\n  lintLength?: number;\n}\n\nexport interface DataTreeEvaluationProps {\n  __evaluation__?: {\n    errors: Record<string, EvaluationError[]>;\n    evaluatedValues?: Record<string, unknown>;\n  };\n}\n\nexport const PropertyEvalErrorTypeDebugMessage: Record<\n  PropertyEvaluationErrorType,\n  (propertyPath: string) => string\n> = {\n  [PropertyEvaluationErrorType.VALIDATION]: (propertyPath: string) =>\n    `The value at ${propertyPath} is invalid`,\n  [PropertyEvaluationErrorType.PARSE]: () => `Could not parse the binding`,\n  [PropertyEvaluationErrorType.LINT]: () => `Errors found while evaluating`,\n};\n\n// this variable temporarily holds dynamic paths generated by the recursive function (getDynamicValuePaths - Line 468).\nlet temporaryDynamicPathStore: DynamicPath[] = [];\n\n// recursive function to get full key path of any object that has dynamic bindings.\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst getDynamicValuePaths = (val: any, parentPath: string) => {\n  if (isString(val) && isDynamicValue(val)) {\n    return temporaryDynamicPathStore.push({ key: `${parentPath}` });\n  }\n\n  if (Array.isArray(val)) {\n    val.forEach((obj, index) => {\n      return getDynamicValuePaths(obj, `${parentPath}[${index}]`);\n    });\n  }\n\n  if (isTrueObject(val)) {\n    Object.entries(val).forEach(([key, value]) => {\n      getDynamicValuePaths(value, `${parentPath}.${key}`);\n    });\n  }\n};\n\nexport function getDynamicBindingsChangesSaga(\n  action: Action,\n  value: unknown,\n  field: string,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  formData?: any,\n) {\n  const bindingField = field.replace(\"actionConfiguration.\", \"\");\n  // we listen to any viewType changes.\n  const viewType = field.endsWith(\".viewType\");\n  let dynamicBindings: DynamicPath[] = action.dynamicBindingPathList\n    ? [...action.dynamicBindingPathList]\n    : [];\n\n  if (field.endsWith(\".jsonData\") || field.endsWith(\".componentData\")) {\n    return dynamicBindings;\n  }\n\n  if (\n    action.datasource &&\n    (\"datasourceConfiguration\" in action.datasource ||\n      \"datasourceConfiguration\" in (formData?.datasource || {})) &&\n    field === \"datasource\"\n  ) {\n    // only the datasource.datasourceConfiguration.url can be a dynamic field\n    dynamicBindings = dynamicBindings.filter(\n      (binding) => binding.key !== \"datasourceUrl\" && binding.key !== \"path\",\n    );\n    // ideally as we check for the datasource url, we should check for the path field as well.\n    const datasourceUrl = action.datasource?.datasourceConfiguration?.url || \"\";\n    const datasourcePathField = action.actionConfiguration?.path;\n    const datasourceFormPathField = formData?.actionConfiguration?.path;\n\n    isDynamicValue(datasourceUrl) &&\n      dynamicBindings.push({ key: \"datasourceUrl\" });\n\n    // as we check the datasource url for bindings, check the path too.\n    isDynamicValue(datasourcePathField || datasourceFormPathField) &&\n      dynamicBindings.push({ key: \"path\" });\n\n    return dynamicBindings;\n  }\n\n  // When a key-value pair is added or deleted from a fieldArray\n  // Value is an Array representing the new fieldArray.\n\n  if (Array.isArray(value)) {\n    // first we clear the dynamic bindings of any paths that is a child of the current path.\n    dynamicBindings = dynamicBindings.filter(\n      (binding) => !isChildPropertyPath(bindingField, binding.key),\n    );\n\n    // then we recursively go through the value and find paths with dynamic bindings\n    temporaryDynamicPathStore = [];\n\n    if (!!value) {\n      getDynamicValuePaths(value, bindingField);\n    }\n\n    if (!!temporaryDynamicPathStore && temporaryDynamicPathStore.length > 0) {\n      dynamicBindings = [...dynamicBindings, ...temporaryDynamicPathStore];\n    }\n  } else if (getType(value) === Types.OBJECT) {\n    dynamicBindings = dynamicBindings.filter((dynamicPath) => {\n      if (isChildPropertyPath(bindingField, dynamicPath.key)) {\n        const childPropertyValue = _.get(value, dynamicPath.key);\n\n        return isDynamicValue(childPropertyValue);\n      }\n\n      return !!dynamicPath;\n    });\n  } else if (typeof value === \"string\") {\n    const fieldExists = _.some(dynamicBindings, { key: bindingField });\n\n    const isDynamic = isDynamicValue(value);\n\n    if (!isDynamic && fieldExists) {\n      dynamicBindings = dynamicBindings.filter((d) => d.key !== bindingField);\n    }\n\n    if (isDynamic && !fieldExists) {\n      dynamicBindings = [...dynamicBindings, { key: bindingField }];\n    }\n  }\n\n  // the reason this is done is to change the dynamicBindingsPathlist of a component when a user toggles the form control\n  // from component mode to json mode and vice versa.\n\n  // when in json mode, we want to get rid of all the existing componentData paths and replace it with a single path for the json mode\n  // for example: [{key: 'formData.sortBy.data[0].column'}, {key: 'formData.sortBy.data[1].column'}] will be replaced with just this [{key: 'formData.sortBy.data'}]\n\n  // when in component mode, we want to first remove all the paths for json mode and\n  //  get back all the paths in the componentData that have dynamic bindings and add them to the the dynamic bindings pathlist.\n  // for example: [{key: 'formData.sortBy.data'}] will be replaced with this [{key: 'formData.sortBy.data[0].column'}, {key: 'formData.sortBy.data[1].column'}]\n\n  // if the currently changing field is a component's view type\n  if (!!viewType) {\n    const dataBindingField = bindingField.replace(\".viewType\", \".data\");\n\n    // then we filter the field of any paths that includes the binding fields\n    dynamicBindings = dynamicBindings.filter(\n      (dynamicPath) => !dynamicPath?.key?.includes(dataBindingField),\n    );\n\n    // if the value of the viewType is of json and, we push in the field\n    if (value === ViewTypes.JSON) {\n      const jsonFieldPath = field.replace(\".viewType\", \".jsonData\");\n      const jsonFieldValue = get(action, jsonFieldPath);\n\n      if (isDynamicValue(jsonFieldValue)) {\n        dynamicBindings.push({ key: dataBindingField });\n      }\n    } else if (value === ViewTypes.COMPONENT) {\n      const componentFieldPath = field.replace(\".viewType\", \".componentData\");\n      const componentFieldValue = get(action, componentFieldPath);\n\n      temporaryDynamicPathStore = [];\n\n      if (!!componentFieldValue) {\n        getDynamicValuePaths(componentFieldValue, dataBindingField);\n      }\n\n      if (!!temporaryDynamicPathStore && temporaryDynamicPathStore.length > 0) {\n        dynamicBindings = [...dynamicBindings, ...temporaryDynamicPathStore];\n      }\n    }\n  }\n\n  return dynamicBindings;\n}\n\nexport function getEntityType(entity: DataTreeEntity) {\n  return \"ENTITY_TYPE\" in entity && entity.ENTITY_TYPE;\n}\n\nexport function getEntityId(entity: DataTreeEntity) {\n  if (isAction(entity)) return entity.actionId;\n\n  if (isWidget(entity)) return entity.widgetId;\n\n  if (isJSAction(entity)) return entity.actionId;\n}\n\nexport function getEntityName(\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n) {\n  if (isAction(entity)) return entityConfig.name;\n\n  if (isWidget(entity)) return entity.widgetName;\n\n  if (isJSAction(entity)) return entityConfig.name;\n}\n","import type { FeatureFlags } from \"ee/entities/FeatureFlag\";\n\nexport class WorkerEnv {\n  static flags: FeatureFlags = {} as FeatureFlags;\n  static cloudHosting: boolean;\n\n  static setFeatureFlags(featureFlags: FeatureFlags) {\n    WorkerEnv.flags = featureFlags;\n  }\n\n  static setCloudHosting(cloudHosting: boolean) {\n    WorkerEnv.cloudHosting = cloudHosting;\n  }\n\n  static getFeatureFlags() {\n    return WorkerEnv.flags;\n  }\n\n  static getCloudHosting() {\n    return WorkerEnv.cloudHosting;\n  }\n}\n","import { find, toPath, union } from \"lodash\";\nimport type { EvalError } from \"utils/DynamicBindingUtils\";\nimport { EvalErrorTypes } from \"utils/DynamicBindingUtils\";\nimport { extractIdentifierInfoFromCode } from \"@shared/ast\";\nimport {\n  convertPathToString,\n  getEntityNameAndPropertyPath,\n  isJSActionConfig,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\n\nimport type { WidgetEntityConfig } from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport {\n  DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS,\n  JAVASCRIPT_KEYWORDS,\n} from \"constants/WidgetValidation\";\nimport { libraryReservedIdentifiers } from \"workers/common/JSLibrary\";\n\n/** This function extracts validReferences and invalidReferences from a binding {{}}\n * @param script\n * @param allPaths\n * @returns validReferences - Valid references from bindings\n * invalidReferences- References which are currently invalid\n * @example - For binding {{unknownEntity.name + Api1.name}}, it returns\n * {\n * validReferences:[Api1.name],\n * invalidReferences: [unknownEntity.name]\n * }\n */\nexport const extractInfoFromBinding = (\n  script: string,\n  allKeys: Record<string, true>,\n) => {\n  const { references } = extractIdentifierInfoFromCode(\n    script,\n    self.evaluationVersion,\n    invalidEntityIdentifiers,\n  );\n\n  return getPrunedReferences(references, allKeys);\n};\n\nexport const getPrunedReferences = (\n  references: string[],\n  allKeys: Record<string, true>,\n) => {\n  const prunedReferences: Set<string> = new Set<string>();\n\n  references.forEach((reference: string) => {\n    // If the identifier exists directly, add it and return\n    if (allKeys.hasOwnProperty(reference)) {\n      prunedReferences.add(reference);\n\n      return;\n    }\n\n    const subpaths = toPath(reference);\n    let current = \"\";\n\n    // We want to keep going till we reach top level, but not add top level\n    // Eg: Input1.text should not depend on entire Table1 unless it explicitly asked for that.\n    // This is mainly to avoid a lot of unnecessary evals, if we feel this is wrong\n    // we can remove the length requirement, and it will still work\n    while (subpaths.length > 1) {\n      current = convertPathToString(subpaths);\n\n      // We've found the dep, add it and return\n      if (allKeys.hasOwnProperty(current)) {\n        prunedReferences.add(current);\n\n        return;\n      }\n\n      subpaths.pop();\n    }\n\n    // If no valid reference is derived, add reference as is\n    prunedReferences.add(reference);\n  });\n\n  return Array.from(prunedReferences);\n};\n\ninterface BindingsInfo {\n  references: string[];\n  errors: EvalError[];\n}\nexport const extractInfoFromBindings = (\n  bindings: string[],\n  allKeys: Record<string, true>,\n) => {\n  return bindings.reduce(\n    (bindingsInfo: BindingsInfo, binding) => {\n      try {\n        const references = extractInfoFromBinding(binding, allKeys);\n\n        return {\n          ...bindingsInfo,\n          references: union(bindingsInfo.references, references),\n        };\n      } catch (error) {\n        const newEvalError: EvalError = {\n          type: EvalErrorTypes.EXTRACT_DEPENDENCY_ERROR,\n          message: (error as Error).message,\n          context: {\n            script: binding,\n          },\n        };\n\n        return {\n          ...bindingsInfo,\n          errors: union(bindingsInfo.errors, [newEvalError]),\n        };\n      }\n    },\n    { references: [], errors: [] },\n  );\n};\n\n/**This function returns a unique array containing a merge of both arrays\n * @param currentArr\n * @param updateArr\n * @returns A unique array containing a merge of both arrays\n */\nexport const mergeArrays = <T>(currentArr: T[], updateArr: T[]): T[] => {\n  if (!currentArr) return updateArr;\n\n  return union(currentArr, updateArr);\n};\n\n/**\n * Identifiers which can not be valid names of entities and are not dynamic in nature.\n * therefore should be removed from the list of references extracted from code.\n * NB: DATA_TREE_KEYWORDS in app/client/src/constants/WidgetValidation.ts isn't included, although they are not valid entity names,\n * they can refer to potentially dynamic entities.\n * Eg. \"appsmith\"\n */\nexport const invalidEntityIdentifiers: Record<string, unknown> = {\n  ...JAVASCRIPT_KEYWORDS,\n  ...DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS,\n  ...libraryReservedIdentifiers,\n};\n\nexport function isADynamicTriggerPath(\n  entity: DataTreeEntity,\n  propertyPath: string,\n  entityConfig: WidgetEntityConfig,\n) {\n  if (isWidget(entity)) {\n    const dynamicTriggerPathlist = entityConfig?.dynamicTriggerPathList;\n    const isTriggerPath = find(dynamicTriggerPathlist, { key: propertyPath });\n\n    if (isTriggerPath) {\n      return true;\n    }\n\n    return false;\n  }\n}\n\nexport function isJSFunction(configTree: ConfigTree, fullPath: string) {\n  const { entityName, propertyPath } = getEntityNameAndPropertyPath(fullPath);\n  const entityConfig = configTree[entityName];\n\n  return (\n    isJSActionConfig(entityConfig) &&\n    propertyPath &&\n    propertyPath in entityConfig.meta\n  );\n}\nexport function convertArrayToObject(arr: string[]) {\n  return arr.reduce(\n    (acc, item) => {\n      return { ...acc, [item]: true } as const;\n    },\n    {} as Record<string, true>,\n  );\n}\n","/* eslint-disable no-console */\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { EvaluationError } from \"utils/DynamicBindingUtils\";\nimport { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport unescapeJS from \"unescape-js\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport type { EventType } from \"constants/AppsmithActionConstants/ActionConstants\";\nimport type { TriggerMeta } from \"ee/sagas/ActionExecution/ActionExecutionSagas\";\nimport indirectEval from \"./indirectEval\";\nimport DOM_APIS from \"./domApis\";\nimport {\n  JSLibraryAccessor,\n  libraryReservedIdentifiers,\n} from \"../common/JSLibrary\";\nimport {\n  ActionInDataFieldErrorModifier,\n  errorModifier,\n  FoundPromiseInSyncEvalError,\n  PrimitiveErrorModifier,\n  TypeErrorModifier,\n} from \"./errorModifier\";\nimport { getDataTreeContext } from \"ee/workers/Evaluation/Actions\";\nimport { set } from \"lodash\";\nimport { klona } from \"klona\";\nimport { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\n\nexport interface EvalResult {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  result: any;\n  errors: EvaluationError[];\n}\n\nexport enum EvaluationScriptType {\n  EXPRESSION = \"EXPRESSION\",\n  ANONYMOUS_FUNCTION = \"ANONYMOUS_FUNCTION\",\n  ASYNC_ANONYMOUS_FUNCTION = \"ASYNC_ANONYMOUS_FUNCTION\",\n  TRIGGERS = \"TRIGGERS\",\n  OBJECT_PROPERTY = \"OBJECT_PROPERTY\",\n}\n\nexport const ScriptTemplate = \"<<string>>\";\n\nexport const EvaluationScripts: Record<EvaluationScriptType, string> = {\n  [EvaluationScriptType.EXPRESSION]: `\n  function $$closedFn () {\n    const $$result = ${ScriptTemplate}\n    return $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n  [EvaluationScriptType.ANONYMOUS_FUNCTION]: `\n  function $$closedFn (script) {\n    const $$userFunction = script;\n    const $$result = $$userFunction?.apply(THIS_CONTEXT, ARGUMENTS);\n    return $$result\n  }\n  $$closedFn(${ScriptTemplate})\n  `,\n  [EvaluationScriptType.ASYNC_ANONYMOUS_FUNCTION]: `\n  async function $$closedFn (script) {\n    const $$userFunction = script;\n    const $$result = $$userFunction?.apply(THIS_CONTEXT, ARGUMENTS);\n    return await $$result;\n  }\n  $$closedFn(${ScriptTemplate})\n  `,\n  [EvaluationScriptType.TRIGGERS]: `\n  async function $$closedFn () {\n    const $$result = ${ScriptTemplate};\n    return await $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n  [EvaluationScriptType.OBJECT_PROPERTY]: `\n  function $$closedFn () {\n    const $$result = {${ScriptTemplate}}\n    return $$result\n  }\n  $$closedFn.call(THIS_CONTEXT)\n  `,\n};\n\nconst topLevelWorkerAPIs = Object.keys(self).reduce(\n  (acc, key: string) => {\n    acc[key] = true;\n\n    return acc;\n  },\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  {} as any,\n);\n\nconst ignoreGlobalObjectKeys = new Set([\n  \"evaluationVersion\",\n  \"window\",\n  \"document\",\n  \"location\",\n]);\n\nexport function resetWorkerGlobalScope() {\n  const jsLibraryAccessorSet = JSLibraryAccessor.getSet();\n\n  for (const key of Object.keys(self)) {\n    if (topLevelWorkerAPIs[key] || DOM_APIS[key]) continue;\n\n    //TODO: Remove this once we have a better way to handle this\n    if (ignoreGlobalObjectKeys.has(key)) continue;\n\n    if (jsLibraryAccessorSet.has(key)) continue;\n\n    if (libraryReservedIdentifiers[key]) continue;\n\n    try {\n      // @ts-expect-error: Types are not available\n      delete self[key];\n    } catch (e) {\n      // @ts-expect-error: Types are not available\n      self[key] = undefined;\n    }\n  }\n}\n\nexport const getScriptType = (\n  evalArgumentsExist = false,\n  isTriggerBased = false,\n): EvaluationScriptType => {\n  let scriptType = EvaluationScriptType.EXPRESSION;\n\n  if (evalArgumentsExist && isTriggerBased) {\n    scriptType = EvaluationScriptType.ASYNC_ANONYMOUS_FUNCTION;\n  } else if (evalArgumentsExist && !isTriggerBased) {\n    scriptType = EvaluationScriptType.ANONYMOUS_FUNCTION;\n  } else if (isTriggerBased && !evalArgumentsExist) {\n    scriptType = EvaluationScriptType.TRIGGERS;\n  }\n\n  return scriptType;\n};\n\nexport const additionalLibrariesNames: string[] = [];\n\nexport const getScriptToEval = (\n  userScript: string,\n  type: EvaluationScriptType,\n): string => {\n  // Using replace here would break scripts with replacement patterns (ex: $&, $$)\n  const buffer = EvaluationScripts[type].split(ScriptTemplate);\n\n  return `${buffer[0]}${userScript}${buffer[1]}`;\n};\n\nconst beginsWithLineBreakRegex = /^\\s+|\\s+$/;\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type EvalContext = Record<string, any>;\n\nexport interface createEvaluationContextArgs {\n  dataTree: DataTree;\n  configTree?: ConfigTree;\n  context?: EvaluateContext;\n  isTriggerBased: boolean;\n  evalArguments?: Array<unknown>;\n  /*\n   Whether to remove functions like \"run\", \"clear\" from entities in global context\n   use case => To show lint warning when Api.run is used in a function bound to a data field (Eg. Button.text)\n   */\n  removeEntityFunctions?: boolean;\n}\n\n/**\n * overrideContext is a set of key-value pairs where they key is a path\n * and the value is any value.\n *\n * The purpose of overrideContext is to update the EVAL_CONTEXT's entity properties\n * with new value during runtime.\n * An example of runtime would be execution of a query where some parameters are passed\n * to the .run function.\n * This enables to override the entities and their values in EVAL_CONTEXT without any side-effects\n * to the actual dataTree since this is a non-persistent transient state of evaluation.\n *\n * Example:\n * overrideContext = {\n *  \"Input1.text\": \"hello\"\n * }\n * // before overriding\n * EVAL_CONTEXT = {\n *  \"Input1\": {\n *    \"text\": \"Hey!\"\n *  }\n * \"Text1\": {\n *    \"text\": \"YOLO\"\n *  }\n * }\n *\n * // after overriding just for the particular evaluation\n * EVAL_CONTEXT = {\n *  \"Input1\": {\n *    \"text\": \"Hello\"\n *  },\n * \"Text1\": {\n *  \"text\": \"YOLO\"\n * }\n *\n * Where is this overriding actually used?\n * At the time of writing this, the use case originated to evaluate run-time params of a\n * query module instance as pass them off as inputs.\n * Eg. QueryModule1.run({ input1: \"10\" }) and the bindings for this could be QueryModule1.inputs.input1\n * So the executionParams needs to be put in the EVAL_CONTEXT with the above path and the supplied value.\n * Therefore an overriding of the EVAL_CONTEXT is required during runtime execution.\n *\n * Why klona is used to cloned here?\n * Since EVAL_CONTEXT is build from the dataTree by adding the entities directly referentially\n * Eg. EVAL_CONTEXT[\"Input1\"] = dataTree[\"Input1\"]\n * Overriding the EVAL_CONTEXT directly using set(EVAL_CONTEXT, path, value); would mutate the dataTree\n * thus polluting the dataTree for the next evaluation.\n * To avoid this, all the unique entities of present in the overrideContext is identified and cloned once for\n * the particular entities only. This avoid unnecessary cloning of every entity and further multiple times.\n *\n */\nconst overrideEvalContext = (\n  EVAL_CONTEXT: EvalContext,\n  overrideContext?: Record<string, unknown>,\n) => {\n  if (overrideContext) {\n    const entitiesClonedSoFar = new Set();\n\n    Object.keys(overrideContext).forEach((path) => {\n      const { entityName } = getEntityNameAndPropertyPath(path);\n\n      if (entityName in EVAL_CONTEXT && !entitiesClonedSoFar.has(entityName)) {\n        entitiesClonedSoFar.add(entityName);\n        EVAL_CONTEXT[entityName] = klona(EVAL_CONTEXT[entityName]);\n      }\n    });\n\n    Object.entries(overrideContext).forEach(([path, value]) => {\n      set(EVAL_CONTEXT, path, value);\n    });\n  }\n};\n\n/**\n * This method created an object with dataTree and appsmith's framework actions that needs to be added to worker global scope for the JS code evaluation to then consume it.\n *\n * Example:\n * - For `eval(\"Table1.tableData\")` code to work as expected, we define Table1.tableData in worker global scope and for that we use `createEvaluationContext` to get the object to set in global scope.\n */\nexport const createEvaluationContext = (args: createEvaluationContextArgs) => {\n  const {\n    configTree = {},\n    context,\n    dataTree,\n    evalArguments,\n    isTriggerBased,\n    removeEntityFunctions,\n  } = args;\n\n  const EVAL_CONTEXT: EvalContext = {};\n\n  ///// Adding callback data\n  EVAL_CONTEXT.ARGUMENTS = evalArguments;\n  //// Adding contextual data not part of data tree\n  EVAL_CONTEXT.THIS_CONTEXT = context?.thisContext || {};\n\n  if (context?.globalContext) {\n    Object.assign(EVAL_CONTEXT, context.globalContext);\n  }\n\n  const dataTreeContext = getDataTreeContext({\n    dataTree,\n    configTree,\n    removeEntityFunctions: !!removeEntityFunctions,\n    isTriggerBased,\n  });\n\n  Object.assign(EVAL_CONTEXT, dataTreeContext);\n\n  overrideEvalContext(EVAL_CONTEXT, context?.overrideContext);\n\n  return EVAL_CONTEXT;\n};\n\nexport function sanitizeScript(js: string) {\n  // We remove any line breaks from the beginning of the script because that\n  // makes the final function invalid. We also unescape any escaped characters\n  // so that eval can happen\n  const trimmedJS = js.replace(beginsWithLineBreakRegex, \"\");\n\n  return self.evaluationVersion > 1 ? trimmedJS : unescapeJS(trimmedJS);\n}\n\n/** Define a context just for this script\n * thisContext will define it on the `this`\n * globalContext will define it globally\n * requestId is used for completing promises\n */\nexport interface EvaluateContext {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  thisContext?: Record<string, any>;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  globalContext?: Record<string, any>;\n  requestId?: string;\n  eventType?: EventType;\n  triggerMeta?: TriggerMeta;\n  overrideContext?: Record<string, unknown>;\n}\n\nexport const getUserScriptToEvaluate = (\n  userScript: string,\n  isTriggerBased: boolean,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n) => {\n  const unescapedJS = sanitizeScript(userScript);\n\n  // If nothing is present to evaluate, return\n  if (!unescapedJS.length) {\n    return {\n      script: \"\",\n    };\n  }\n\n  const scriptType = getScriptType(!!evalArguments, isTriggerBased);\n  const script = getScriptToEval(unescapedJS, scriptType);\n\n  return { script };\n};\n\nexport function setEvalContext({\n  configTree,\n  context,\n  dataTree,\n  evalArguments,\n  isDataField,\n  isTriggerBased,\n}: {\n  context?: EvaluateContext;\n  dataTree: DataTree;\n  configTree?: ConfigTree;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>;\n  isDataField: boolean;\n  isTriggerBased: boolean;\n}) {\n  self[\"$isDataField\"] = isDataField;\n\n  const evalContext = createEvaluationContext({\n    dataTree,\n    configTree,\n    context,\n    evalArguments,\n    isTriggerBased,\n  });\n\n  Object.assign(self, evalContext);\n}\n\nexport function evaluateSync(\n  userScript: string,\n  dataTree: DataTree,\n  isJSCollection: boolean,\n  context?: EvaluateContext,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n  configTree: ConfigTree = {},\n  evalContextCache?: EvalContext,\n): EvalResult {\n  return (function () {\n    const errors: EvaluationError[] = [];\n    let result;\n\n    const { script } = getUserScriptToEvaluate(\n      userScript,\n      false,\n      evalArguments,\n    );\n\n    // If nothing is present to evaluate, return instead of evaluating\n    if (!script.length) {\n      return {\n        errors: [],\n        result: undefined,\n        triggers: [],\n      };\n    }\n\n    self[\"$isDataField\"] = true;\n    const EVAL_CONTEXT: EvalContext = {};\n\n    ///// Adding callback data\n    EVAL_CONTEXT.ARGUMENTS = evalArguments;\n    //// Adding contextual data not part of data tree\n    EVAL_CONTEXT.THIS_CONTEXT = context?.thisContext || {};\n\n    if (context?.globalContext) {\n      Object.assign(EVAL_CONTEXT, context.globalContext);\n    }\n\n    if (evalContextCache) {\n      Object.assign(EVAL_CONTEXT, evalContextCache);\n    } else {\n      const dataTreeContext = getDataTreeContext({\n        dataTree,\n        configTree,\n        removeEntityFunctions: false,\n        isTriggerBased: isJSCollection,\n      });\n\n      Object.assign(EVAL_CONTEXT, dataTreeContext);\n    }\n\n    overrideEvalContext(EVAL_CONTEXT, context?.overrideContext);\n\n    Object.assign(self, EVAL_CONTEXT);\n\n    try {\n      result = indirectEval(script);\n\n      if (result instanceof Promise) {\n        /**\n         * If a promise is returned in data field then show the error to help understand data field doesn't await to resolve promise.\n         * NOTE: Awaiting for promise will make data field evaluation slower.\n         */\n        throw new FoundPromiseInSyncEvalError();\n      }\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      const { errorCategory, errorMessage, rootcause } = errorModifier.run(\n        error,\n        { userScript: error.userScript || userScript, source: error.source },\n        [ActionInDataFieldErrorModifier, TypeErrorModifier],\n      );\n\n      errors.push({\n        errorMessage,\n        severity: Severity.ERROR,\n        raw: script,\n        errorType: PropertyEvaluationErrorType.PARSE,\n        originalBinding: userScript,\n        kind: {\n          category: errorCategory,\n          rootcause,\n        },\n      });\n    } finally {\n      self[\"$isDataField\"] = false;\n    }\n\n    return { result, errors };\n  })();\n}\n\nexport async function evaluateAsync(\n  userScript: string,\n  dataTree: DataTree,\n  configTree: ConfigTree,\n  context?: EvaluateContext,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  evalArguments?: Array<any>,\n) {\n  return (async function () {\n    resetWorkerGlobalScope();\n    const errors: EvaluationError[] = [];\n    let result;\n\n    const { script } = getUserScriptToEvaluate(userScript, true, evalArguments);\n\n    setEvalContext({\n      dataTree,\n      configTree,\n      isDataField: false,\n      isTriggerBased: true,\n      context,\n      evalArguments,\n    });\n\n    try {\n      result = await indirectEval(script);\n      // TODO: Fix this the next time the file is edited\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      const { errorMessage } = errorModifier.run(\n        error,\n        { userScript: error.userScript || userScript, source: error.source },\n        [PrimitiveErrorModifier, TypeErrorModifier],\n      );\n\n      errors.push({\n        errorMessage: errorMessage,\n        severity: Severity.ERROR,\n        raw: script,\n        errorType: PropertyEvaluationErrorType.PARSE,\n        originalBinding: userScript,\n      });\n    } finally {\n      return {\n        result,\n        errors,\n      };\n    }\n  })();\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function shouldAddSetter(setter: any, entity: DataTreeEntity) {\n  const isDisabledExpression = setter.disabled;\n\n  if (!isDisabledExpression) return true;\n\n  const isDisabledFn = new Function(\"options\", isDisabledExpression);\n\n  return !isDisabledFn({ entity });\n}\n","// Please follow naming convention : https://www.notion.so/appsmith/Using-Feature-Flags-in-Appsmith-d362fe7acc7d4ef0aa12e1f5f9b83b5f?pvs=4#f6d4242e56284e84af25cadef71b7aeb to create feature flags.\nexport const FEATURE_FLAG = {\n  TEST_FLAG: \"TEST_FLAG\",\n  release_datasource_environments_enabled:\n    \"release_datasource_environments_enabled\",\n  release_appnavigationlogoupload_enabled:\n    \"release_appnavigationlogoupload_enabled\",\n  release_embed_hide_share_settings_enabled:\n    \"release_embed_hide_share_settings_enabled\",\n  release_table_serverside_filtering_enabled:\n    \"release_table_serverside_filtering_enabled\",\n  license_branding_enabled: \"license_branding_enabled\",\n  license_sso_saml_enabled: \"license_sso_saml_enabled\",\n  license_sso_oidc_enabled: \"license_sso_oidc_enabled\",\n  license_private_embeds_enabled: \"license_private_embeds_enabled\",\n  release_show_publish_app_to_community_enabled:\n    \"release_show_publish_app_to_community_enabled\",\n  license_gac_enabled: \"license_gac_enabled\",\n  release_anvil_enabled: \"release_anvil_enabled\",\n  license_git_branch_protection_enabled:\n    \"license_git_branch_protection_enabled\",\n  license_git_continuous_delivery_enabled:\n    \"license_git_continuous_delivery_enabled\",\n  license_widget_rtl_support_enabled: \"license_widget_rtl_support_enabled\",\n  ab_one_click_learning_popover_enabled:\n    \"ab_one_click_learning_popover_enabled\",\n  ab_appsmith_ai_query: \"ab_appsmith_ai_query\",\n  rollout_remove_feature_walkthrough_enabled:\n    \"rollout_remove_feature_walkthrough_enabled\",\n  rollout_eslint_enabled: \"rollout_eslint_enabled\",\n  release_drag_drop_building_blocks_enabled:\n    \"release_drag_drop_building_blocks_enabled\",\n  release_layout_conversion_enabled: \"release_layout_conversion_enabled\",\n  release_git_persist_branch_enabled: \"release_git_persist_branch_enabled\",\n  release_ide_animations_enabled: \"release_ide_animations_enabled\",\n  release_ide_datasource_selector_enabled:\n    \"release_ide_datasource_selector_enabled\",\n  release_custom_widget_ai_builder: \"release_custom_widget_ai_builder\",\n  ab_request_new_integration_enabled: \"ab_request_new_integration_enabled\",\n  release_evaluation_scope_cache: \"release_evaluation_scope_cache\",\n  release_gs_all_sheets_options_enabled:\n    \"release_gs_all_sheets_options_enabled\",\n  release_git_modularisation_enabled: \"release_git_modularisation_enabled\",\n  release_git_api_contracts_enabled: \"release_git_api_contracts_enabled\",\n  ab_premium_datasources_view_enabled: \"ab_premium_datasources_view_enabled\",\n  kill_session_recordings_enabled: \"kill_session_recordings_enabled\",\n  config_mask_session_recordings_enabled:\n    \"config_mask_session_recordings_enabled\",\n  config_user_session_recordings_enabled:\n    \"config_user_session_recordings_enabled\",\n  release_ads_entity_item_enabled: \"release_ads_entity_item_enabled\",\n  release_external_saas_plugins_enabled:\n    \"release_external_saas_plugins_enabled\",\n  release_tablev2_infinitescroll_enabled:\n    \"release_tablev2_infinitescroll_enabled\",\n  release_table_custom_sort_function_enabled:\n    \"release_table_custom_sort_function_enabled\",\n} as const;\n\nexport type FeatureFlag = keyof typeof FEATURE_FLAG;\n\nexport type FeatureFlags = Record<FeatureFlag, boolean>;\n\nexport const DEFAULT_FEATURE_FLAG_VALUE: FeatureFlags = {\n  TEST_FLAG: true,\n  release_datasource_environments_enabled: false,\n  release_appnavigationlogoupload_enabled: false,\n  release_embed_hide_share_settings_enabled: false,\n  release_table_serverside_filtering_enabled: false,\n  license_branding_enabled: false,\n  license_sso_saml_enabled: false,\n  license_sso_oidc_enabled: false,\n  license_private_embeds_enabled: false,\n  release_show_publish_app_to_community_enabled: false,\n  license_gac_enabled: false,\n  release_anvil_enabled: false,\n  release_drag_drop_building_blocks_enabled: false,\n  license_git_branch_protection_enabled: false,\n  license_git_continuous_delivery_enabled: false,\n  license_widget_rtl_support_enabled: false,\n  ab_one_click_learning_popover_enabled: false,\n  ab_appsmith_ai_query: false,\n  rollout_remove_feature_walkthrough_enabled: true,\n  rollout_eslint_enabled: false,\n  release_layout_conversion_enabled: false,\n  release_git_persist_branch_enabled: false,\n  release_ide_animations_enabled: false,\n  release_ide_datasource_selector_enabled: false,\n  release_custom_widget_ai_builder: false,\n  ab_request_new_integration_enabled: false,\n  release_evaluation_scope_cache: false,\n  release_gs_all_sheets_options_enabled: false,\n  release_git_modularisation_enabled: false,\n  release_git_api_contracts_enabled: false,\n  ab_premium_datasources_view_enabled: false,\n  kill_session_recordings_enabled: false,\n  config_user_session_recordings_enabled: true,\n  config_mask_session_recordings_enabled: true,\n  release_ads_entity_item_enabled: false,\n  release_external_saas_plugins_enabled: false,\n  release_tablev2_infinitescroll_enabled: false,\n  release_table_custom_sort_function_enabled: false,\n};\n\nexport const AB_TESTING_EVENT_KEYS = {\n  abTestingFlagLabel: \"abTestingFlagLabel\",\n  abTestingFlagValue: \"abTestingFlagValue\",\n};\n","import type { Node, SourceLocation, Options, Comment } from \"acorn\";\nimport { parse } from \"acorn\";\nimport { ancestor, simple } from \"acorn-walk\";\nimport { ECMA_VERSION, NodeTypes } from \"./constants\";\nimport { has, isFinite, isNil, isString, toPath } from \"lodash\";\nimport { getStringValue, isTrueObject, sanitizeScript } from \"./utils\";\nimport { jsObjectDeclaration } from \"./jsObject\";\nimport { attachComments } from \"astravel\";\nimport { generate } from \"astring\";\n/*\n * Valuable links:\n *\n * * ESTree spec: Javascript AST is called ESTree.\n * Each es version has its md file in the repo to find features\n * implemented and their node type\n * https://github.com/estree/estree\n *\n * * Acorn: The parser we use to get the AST\n * https://github.com/acornjs/acorn\n *\n * * Acorn walk: The walker we use to traverse the AST\n * https://github.com/acornjs/acorn/tree/master/acorn-walk\n *\n * * AST Explorer: Helpful web tool to see ASTs and its parts\n * https://astexplorer.net/\n *\n */\n\ntype Pattern =\n  | IdentifierNode\n  | AssignmentPatternNode\n  | ArrayPatternNode\n  | ObjectPatternNode\n  | RestElementNode;\ntype Expression = Node;\nexport type ArgumentTypes =\n  | LiteralNode\n  | ArrowFunctionExpressionNode\n  | ObjectExpression\n  | MemberExpressionNode\n  | CallExpressionNode\n  | BinaryExpressionNode\n  | BlockStatementNode\n  | IdentifierNode;\n// doc: https://github.com/estree/estree/blob/master/es5.md#memberexpression\nexport interface MemberExpressionNode extends Node {\n  type: NodeTypes.MemberExpression;\n  object: MemberExpressionNode | IdentifierNode | CallExpressionNode;\n  property: IdentifierNode | LiteralNode;\n  computed: boolean;\n  // doc: https://github.com/estree/estree/blob/master/es2020.md#chainexpression\n  optional?: boolean;\n}\n\nexport interface BinaryExpressionNode extends Node {\n  type: NodeTypes.BinaryExpression;\n  left: BinaryExpressionNode | IdentifierNode;\n  right: BinaryExpressionNode | IdentifierNode;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#identifier\nexport interface IdentifierNode extends Node {\n  type: NodeTypes.Identifier;\n  name: string;\n}\n\nexport interface ArrayPatternNode extends Node {\n  type: NodeTypes.ArrayPattern;\n  elements: Array<Pattern | null>;\n}\n\nexport interface AssignmentProperty extends Node {\n  type: NodeTypes.Property;\n  key: Expression;\n  value: Pattern;\n  kind: \"init\";\n  method: false;\n  shorthand: boolean;\n  computed: boolean;\n}\n\nexport interface RestElementNode extends Node {\n  type: NodeTypes.RestElement;\n  argument: Pattern;\n}\n\nexport interface ObjectPatternNode extends Node {\n  type: NodeTypes.ObjectPattern;\n  properties: Array<AssignmentProperty | RestElementNode>;\n}\n\n//Using this to handle the Variable property refactor\ninterface RefactorIdentifierNode extends Node {\n  type: NodeTypes.Identifier;\n  name: string;\n  property?: IdentifierNode;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#variabledeclarator\ninterface VariableDeclaratorNode extends Node {\n  type: NodeTypes.VariableDeclarator;\n  id: IdentifierNode;\n  init: Expression | null;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functions\ninterface Function extends Node {\n  id: IdentifierNode | null;\n  params: Pattern[];\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functiondeclaration\ninterface FunctionDeclarationNode extends Node, Function {\n  type: NodeTypes.FunctionDeclaration;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#functionexpression\ninterface FunctionExpressionNode extends Expression, Function {\n  type: NodeTypes.FunctionExpression;\n  async: boolean;\n}\n\nexport interface ArrowFunctionExpressionNode extends Expression, Function {\n  type: NodeTypes.ArrowFunctionExpression;\n  async: boolean;\n}\n\nexport interface ObjectExpression extends Expression {\n  type: NodeTypes.ObjectExpression;\n  properties: Array<PropertyNode>;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es2015.md#assignmentpattern\ninterface AssignmentPatternNode extends Node {\n  type: NodeTypes.AssignmentPattern;\n  left: Pattern;\n  right: ArgumentTypes;\n}\n\n// doc: https://github.com/estree/estree/blob/master/es5.md#literal\nexport interface LiteralNode extends Node {\n  type: NodeTypes.Literal;\n  value: string | boolean | null | number | RegExp;\n  raw: string;\n}\n\nexport interface CallExpressionNode extends Node {\n  type: NodeTypes.CallExpression;\n  callee: CallExpressionNode | IdentifierNode | MemberExpressionNode;\n  arguments: ArgumentTypes[];\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#thisexpression\nexport interface ThisExpressionNode extends Expression {\n  type: \"ThisExpression\";\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#conditionalexpression\nexport interface ConditionalExpressionNode extends Expression {\n  type: \"ConditionalExpression\";\n  test: Expression;\n  alternate: Expression;\n  consequent: Expression;\n}\n\n// https://github.com/estree/estree/blob/master/es2017.md#awaitexpression\nexport interface AwaitExpressionNode extends Expression {\n  type: \"AwaitExpression\";\n  argument: Expression;\n}\n\nexport interface BlockStatementNode extends Node {\n  type: \"BlockStatement\";\n  body: [Node];\n}\n\ninterface NodeList {\n  references: Set<string>;\n  functionalParams: Set<string>;\n  variableDeclarations: Set<string>;\n  identifierList: Array<IdentifierNode>;\n}\n\n// https://github.com/estree/estree/blob/master/es5.md#property\nexport interface PropertyNode extends Node {\n  type: NodeTypes.Property;\n  key: LiteralNode | IdentifierNode;\n  value: Node;\n  kind: \"init\" | \"get\" | \"set\";\n}\n\nexport interface ExpressionStatement extends Node {\n  type: \"ExpressionStatement\";\n  expression: Expression;\n}\n\nexport interface Program extends Node {\n  type: \"Program\";\n  body: [Directive | Statement];\n}\n\nexport type Statement = Node;\n\nexport interface Directive extends ExpressionStatement {\n  expression: LiteralNode;\n  directive: string;\n}\n\nexport interface ExportDefaultDeclarationNode extends Node {\n  declaration: Node;\n}\n\n// Node with location details\nexport type NodeWithLocation<NodeType> = NodeType & {\n  loc: SourceLocation;\n};\n\ntype AstOptions = Omit<Options, \"ecmaVersion\">;\n\ninterface EntityRefactorResponse {\n  isSuccess: boolean;\n  body: { script: string; refactorCount: number } | { error: string };\n}\n\n/* We need these functions to typescript casts the nodes with the correct types */\nexport const isIdentifierNode = (node: Node): node is IdentifierNode => {\n  return node.type === NodeTypes.Identifier;\n};\n\nexport const isMemberExpressionNode = (\n  node: Node,\n): node is MemberExpressionNode => {\n  return node.type === NodeTypes.MemberExpression;\n};\n\nexport const isThisExpressionNode = (\n  node: Node,\n): node is ThisExpressionNode => {\n  return node.type === NodeTypes.ThisExpression;\n};\n\nexport const isConditionalExpressionNode = (\n  node: Node,\n): node is ConditionalExpressionNode =>\n  node.type === NodeTypes.ConditionalExpression;\n\nexport const isAwaitExpressionNode = (\n  node: Node,\n): node is AwaitExpressionNode => node.type === NodeTypes.AwaitExpression;\n\nexport const isBinaryExpressionNode = (\n  node: Node,\n): node is BinaryExpressionNode => {\n  return node.type === NodeTypes.BinaryExpression;\n};\n\nexport const isVariableDeclarator = (\n  node: Node,\n): node is VariableDeclaratorNode => {\n  return node.type === NodeTypes.VariableDeclarator;\n};\n\nconst isFunctionDeclaration = (node: Node): node is FunctionDeclarationNode => {\n  return node.type === NodeTypes.FunctionDeclaration;\n};\n\nconst isFunctionExpression = (node: Node): node is FunctionExpressionNode => {\n  return node.type === NodeTypes.FunctionExpression;\n};\n\nexport const isArrowFunctionExpression = (\n  node: Node,\n): node is ArrowFunctionExpressionNode => {\n  return node.type === NodeTypes.ArrowFunctionExpression;\n};\n\nexport const isAssignmentExpression = (\n  node: Node,\n): node is AssignmentExpressionNode => {\n  return node.type === NodeTypes.AssignmentExpression;\n};\n\nexport const isObjectExpression = (node: Node): node is ObjectExpression => {\n  return node.type === NodeTypes.ObjectExpression;\n};\n\nconst isAssignmentPatternNode = (node: Node): node is AssignmentPatternNode => {\n  return node.type === NodeTypes.AssignmentPattern;\n};\n\nexport const isArrayPatternNode = (node: Node): node is ArrayPatternNode => {\n  return node.type === NodeTypes.ArrayPattern;\n};\n\nexport const isObjectPatternNode = (node: Node): node is ObjectPatternNode => {\n  return node.type === NodeTypes.ObjectPattern;\n};\n\nexport const isRestElementNode = (node: Node): node is RestElementNode => {\n  return node.type === NodeTypes.RestElement;\n};\n\nexport const isLiteralNode = (node: Node): node is LiteralNode => {\n  return node.type === NodeTypes.Literal;\n};\n\nexport const isPropertyNode = (node: Node): node is PropertyNode => {\n  return node.type === NodeTypes.Property;\n};\n\nexport const isCallExpressionNode = (\n  node: Node,\n): node is CallExpressionNode => {\n  return node.type === NodeTypes.CallExpression;\n};\n\nexport const isBlockStatementNode = (\n  node: Node,\n): node is BlockStatementNode => {\n  return node.type === NodeTypes.BlockStatement;\n};\n\nexport const isExpressionStatementNode = (\n  node: Node,\n): node is ExpressionStatement => {\n  return node.type === NodeTypes.ExpressionStatement;\n};\n\nexport const isExportDefaultDeclarationNode = (\n  node: Node,\n): node is ExportDefaultDeclarationNode => {\n  return node.type === NodeTypes.ExportDefaultDeclaration;\n};\n\nexport const isPropertyAFunctionNode = (\n  node: Node,\n): node is ArrowFunctionExpressionNode | FunctionExpressionNode => {\n  return (\n    node.type === NodeTypes.ArrowFunctionExpression ||\n    node.type === NodeTypes.FunctionExpression\n  );\n};\n\nconst isArrayAccessorNode = (node: Node): node is MemberExpressionNode => {\n  return (\n    isMemberExpressionNode(node) &&\n    node.computed &&\n    isLiteralNode(node.property) &&\n    isFinite(node.property.value)\n  );\n};\n\nexport const wrapCode = (code: string) => {\n  return `\n    (function() {\n      return ${code}\n    })\n  `;\n};\n\n//Tech-debt: should upgrade this to better logic\n//Used slice for a quick resolve of critical bug\nconst unwrapCode = (code: string) => {\n  const unwrapedCode = code.slice(32);\n\n  return unwrapedCode.slice(0, -10);\n};\n\nconst getFunctionalParamNamesFromNode = (\n  node:\n    | FunctionDeclarationNode\n    | FunctionExpressionNode\n    | ArrowFunctionExpressionNode,\n) => {\n  return Array.from(getFunctionalParamsFromNode(node)).map(\n    (functionalParam) => functionalParam.paramName,\n  );\n};\n\n// Memoize the ast generation code to improve performance.\n// Since this will be used by both the server and the client, we want to prevent regeneration of ast\n// for the the same code snippet\nexport const getAST = (code: string, options?: AstOptions) =>\n  parse(code, { ...options, ecmaVersion: ECMA_VERSION });\n\nexport const attachCommentsToAst = (\n  ast: Node,\n  commentArray: Array<Comment>,\n) => {\n  return attachComments(ast, commentArray);\n};\n/**\n * An AST based extractor that fetches all possible references in a given\n * piece of code. We use this to get any references to the global entities in Appsmith\n * and create dependencies on them. If the reference was updated, the given piece of code\n * should run again.\n * @param code: The piece of script where references need to be extracted from\n */\n\nexport interface IdentifierInfo {\n  references: string[];\n  functionalParams: string[];\n  variables: string[];\n  isError: boolean;\n}\nexport const extractIdentifierInfoFromCode = (\n  code: string,\n  evaluationVersion: number,\n  invalidIdentifiers?: Record<string, unknown>,\n): IdentifierInfo => {\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    /* wrapCode - Wrapping code in a function, since all code/script get wrapped with a function during evaluation.\n       Some syntax won't be valid unless they're at the RHS of a statement.\n       Since we're assigning all code/script to RHS during evaluation, we do the same here.\n       So that during ast parse, those errors are neglected.\n    */\n    /* e.g. IIFE without braces\n      function() { return 123; }() -> is invalid\n      let result = function() { return 123; }() -> is valid\n    */\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode);\n    const { functionalParams, references, variableDeclarations }: NodeList =\n      ancestorWalk(ast);\n    const referencesArr = Array.from(references).filter((reference) => {\n      // To remove references derived from declared variables and function params,\n      // We extract the topLevelIdentifier Eg. Api1.name => Api1\n      const topLevelIdentifier = toPath(reference)[0];\n\n      return !(\n        functionalParams.has(topLevelIdentifier) ||\n        variableDeclarations.has(topLevelIdentifier) ||\n        has(invalidIdentifiers, topLevelIdentifier)\n      );\n    });\n\n    return {\n      references: referencesArr,\n      functionalParams: Array.from(functionalParams),\n      variables: Array.from(variableDeclarations),\n      isError: false,\n    };\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return {\n        references: [],\n        functionalParams: [],\n        variables: [],\n        isError: true,\n      };\n    }\n\n    throw e;\n  }\n};\n\nexport const entityRefactorFromCode = (\n  script: string,\n  oldName: string,\n  newName: string,\n  isJSObject: boolean,\n  evaluationVersion: number,\n  invalidIdentifiers?: Record<string, unknown>,\n): EntityRefactorResponse => {\n  //Sanitizing leads to removal of special charater.\n  //Hence we are not sanatizing the script. Fix(#18492)\n  //If script is a JSObject then replace export default to decalartion.\n  if (isJSObject) script = jsObjectToCode(script);\n  else script = wrapCode(script);\n\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n  //Copy of script to refactor\n  let refactorScript = script;\n  //Difference in length of oldName and newName\n  const nameLengthDiff: number = newName.length - oldName.length;\n  //Offset index used for deciding location of oldName.\n  let refactorOffset = 0;\n  //Count of refactors on the script\n  let refactorCount = 0;\n\n  try {\n    ast = getAST(script);\n    const {\n      functionalParams,\n      identifierList,\n      references,\n      variableDeclarations,\n    }: NodeList = ancestorWalk(ast);\n    const identifierArray = Array.from(\n      identifierList,\n    ) as Array<RefactorIdentifierNode>;\n    //To handle if oldName has property (\"JSObject.myfunc\")\n    const oldNameArr = oldName.split(\".\");\n    const referencesArr = Array.from(references).filter((reference) => {\n      // To remove references derived from declared variables and function params,\n      // We extract the topLevelIdentifier Eg. Api1.name => Api1\n      const topLevelIdentifier = toPath(reference)[0];\n\n      return !(\n        functionalParams.has(topLevelIdentifier) ||\n        variableDeclarations.has(topLevelIdentifier) ||\n        has(invalidIdentifiers, topLevelIdentifier)\n      );\n    });\n\n    //Traverse through all identifiers in the script\n    identifierArray.forEach((identifier) => {\n      if (identifier.name === oldNameArr[0]) {\n        let index = 0;\n\n        while (index < referencesArr.length) {\n          if (identifier.name === referencesArr[index].split(\".\")[0]) {\n            //Replace the oldName by newName\n            //Get start index from node and get subarray from index 0 till start\n            //Append above with new name\n            //Append substring from end index from the node till end of string\n            //Offset variable is used to alter the position based on `refactorOffset`\n            //In case of nested JS action get end postion fro the property.\n            ///Default end index\n            let endIndex = identifier.end;\n            const propertyNode = identifier.property;\n            //Flag variable : true if property should be updated\n            //false if property should not be updated\n            const propertyCondFlag =\n              oldNameArr.length > 1 &&\n              propertyNode &&\n              oldNameArr[1] === propertyNode.name;\n\n            //Condition to validate if Identifier || Property should be updated??\n            if (oldNameArr.length === 1 || propertyCondFlag) {\n              //Condition to extend end index in case of property match\n              if (propertyCondFlag && propertyNode) {\n                endIndex = propertyNode.end;\n              }\n\n              refactorScript =\n                refactorScript.substring(0, identifier.start + refactorOffset) +\n                newName +\n                refactorScript.substring(endIndex + refactorOffset);\n              refactorOffset += nameLengthDiff;\n              ++refactorCount;\n              //We are only looking for one match in refrence for the identifier name.\n              break;\n            }\n          }\n\n          index++;\n        }\n      }\n    });\n\n    //If script is a JSObject then revert decalartion to export default.\n    if (isJSObject) refactorScript = jsCodeToObject(refactorScript);\n    else refactorScript = unwrapCode(refactorScript);\n\n    return {\n      isSuccess: true,\n      body: { script: refactorScript, refactorCount },\n    };\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return { isSuccess: false, body: { error: \"Syntax Error\" } };\n    }\n\n    throw e;\n  }\n};\n\nexport interface functionParam {\n  paramName: string;\n  defaultValue: unknown;\n}\n\nexport const getFunctionalParamsFromNode = (\n  node:\n    | FunctionDeclarationNode\n    | FunctionExpressionNode\n    | ArrowFunctionExpressionNode,\n  needValue = false,\n  code = \"\",\n): Set<functionParam> => {\n  const functionalParams = new Set<functionParam>();\n\n  node.params.forEach((paramNode) => {\n    if (isIdentifierNode(paramNode)) {\n      functionalParams.add({\n        paramName: paramNode.name,\n        defaultValue: undefined,\n      });\n    } else if (isAssignmentPatternNode(paramNode)) {\n      if (isIdentifierNode(paramNode.left)) {\n        const paramName = paramNode.left.name;\n\n        if (!needValue || !code) {\n          functionalParams.add({ paramName, defaultValue: undefined });\n        } else {\n          const defaultValueInString = code.slice(\n            paramNode.right.start,\n            paramNode.right.end,\n          );\n          const defaultValue =\n            paramNode.right.type === \"Literal\" &&\n            typeof paramNode.right.value === \"string\"\n              ? paramNode.right.value\n              : `{{${defaultValueInString}}}`;\n\n          functionalParams.add({\n            paramName,\n            defaultValue,\n          });\n        }\n      } else if (\n        isObjectPatternNode(paramNode.left) ||\n        isArrayPatternNode(paramNode.left)\n      ) {\n        functionalParams.add({\n          paramName: \"\",\n          defaultValue: undefined,\n        });\n      }\n      // The below computations are very basic and can be evolved into nested\n      // parsing logic to find param and it's default value.\n    } else if (isObjectPatternNode(paramNode)) {\n      functionalParams.add({\n        paramName: \"\",\n        defaultValue: `{{{}}}`,\n      });\n    } else if (isArrayPatternNode(paramNode)) {\n      functionalParams.add({\n        paramName: \"\",\n        defaultValue: \"{{[]}}\",\n      });\n    } else if (isRestElementNode(paramNode)) {\n      if (\"name\" in paramNode.argument) {\n        functionalParams.add({\n          paramName: paramNode.argument.name,\n          defaultValue: undefined,\n        });\n      }\n    }\n  });\n\n  return functionalParams;\n};\n\nconst constructFinalMemberExpIdentifier = (\n  node: MemberExpressionNode,\n  child = \"\",\n): string => {\n  const propertyAccessor = getPropertyAccessor(node.property);\n\n  if (isIdentifierNode(node.object)) {\n    return `${node.object.name}${propertyAccessor}${child}`;\n  } else {\n    const propertyAccessor = getPropertyAccessor(node.property);\n    const nestedChild = `${propertyAccessor}${child}`;\n\n    return constructFinalMemberExpIdentifier(\n      node.object as MemberExpressionNode,\n      nestedChild,\n    );\n  }\n};\n\nconst getPropertyAccessor = (propertyNode: IdentifierNode | LiteralNode) => {\n  if (isIdentifierNode(propertyNode)) {\n    return `.${propertyNode.name}`;\n  } else if (isLiteralNode(propertyNode) && isString(propertyNode.value)) {\n    // is string literal search a['b']\n    return `.${propertyNode.value}`;\n  } else if (isLiteralNode(propertyNode) && isFinite(propertyNode.value)) {\n    // is array index search - a[9]\n    return `[${propertyNode.value}]`;\n  }\n};\n\nexport const isTypeOfFunction = (type: string) => {\n  return (\n    type === NodeTypes.ArrowFunctionExpression ||\n    type === NodeTypes.FunctionExpression\n  );\n};\n\nexport interface MemberExpressionData {\n  property: NodeWithLocation<IdentifierNode | LiteralNode>;\n  object: NodeWithLocation<IdentifierNode>;\n}\n\nexport interface AssignmentExpressionData {\n  property: NodeWithLocation<IdentifierNode | LiteralNode>;\n  object: NodeWithLocation<IdentifierNode | MemberExpressionNode>;\n  parentNode: NodeWithLocation<AssignmentExpressionNode>;\n}\n\nexport interface CallExpressionData {\n  property: NodeWithLocation<IdentifierNode>;\n  params: NodeWithLocation<MemberExpressionNode | LiteralNode>[];\n}\n\n// This interface is used for storing call expression nodes with callee as member node\n// example of such case is when a function is called on object like obj.func()\n// This is required to understand whether appsmith.store.test.func() is present in script\n// in order to display mutation error on such statements.\nexport interface MemberCallExpressionData {\n  property: NodeWithLocation<MemberExpressionNode | LiteralNode>;\n  object: NodeWithLocation<MemberExpressionNode>;\n  parentNode: NodeWithLocation<CallExpressionNode>;\n}\n\nexport interface AssignmentExpressionNode extends Node {\n  operator: string;\n  left: Expression;\n  Right: Expression;\n}\n\n/** Function returns Invalid top-level member expressions from code\n * @param code\n * @param data\n * @param evaluationVersion\n * @returns information about all invalid property/method assessment in code\n * @example Given data {\n * JSObject1: {\n * name:\"JSObject\",\n * data:[]\n * },\n * Api1:{\n * name: \"Api1\",\n * data: []\n * }\n * },\n * For code {{Api1.name + JSObject.unknownProperty}}, function returns information about \"JSObject.unknownProperty\" node.\n */\nexport const extractExpressionsFromCode = (\n  code: string,\n  data: Record<string, any>,\n  evaluationVersion: number,\n): {\n  invalidTopLevelMemberExpressionsArray: MemberExpressionData[];\n  assignmentExpressionsData: AssignmentExpressionData[];\n  callExpressionsData: CallExpressionData[];\n  memberCallExpressionData: MemberCallExpressionData[];\n} => {\n  const assignmentExpressionsData = new Set<AssignmentExpressionData>();\n  const callExpressionsData = new Set<CallExpressionData>();\n  const memberCallExpressionData = new Set<MemberCallExpressionData>();\n  const invalidTopLevelMemberExpressions = new Set<MemberExpressionData>();\n  const variableDeclarations = new Set<string>();\n  let functionalParams = new Set<string>();\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode, { locations: true });\n  } catch (e) {\n    if (e instanceof SyntaxError) {\n      // Syntax error. Ignore and return empty list\n      return {\n        invalidTopLevelMemberExpressionsArray: [],\n        assignmentExpressionsData: [],\n        callExpressionsData: [],\n        memberCallExpressionData: [],\n      };\n    }\n\n    throw e;\n  }\n  simple(ast, {\n    MemberExpression(node: Node) {\n      const { computed, object, property } = node as MemberExpressionNode;\n\n      // We are only interested in top-level MemberExpression nodes\n      // Eg. for Api1.data.name, we are only interested in Api1.data\n      if (!isIdentifierNode(object)) return;\n\n      if (!(object.name in data) || !isTrueObject(data[object.name])) return;\n\n      // For computed member expressions (assessed via [], eg. JSObject1[\"name\"] ),\n      // We are only interested in strings\n      if (\n        isLiteralNode(property) &&\n        isString(property.value) &&\n        !(property.value in data[object.name])\n      ) {\n        invalidTopLevelMemberExpressions.add({\n          object,\n          property,\n        } as MemberExpressionData);\n      }\n\n      // We ignore computed member expressions if property is an identifier (JSObject[name])\n      // This is because we can't statically determine what the value of the identifier might be.\n      if (\n        isIdentifierNode(property) &&\n        !computed &&\n        !(property.name in data[object.name])\n      ) {\n        invalidTopLevelMemberExpressions.add({\n          object,\n          property,\n        } as MemberExpressionData);\n      }\n    },\n    VariableDeclarator(node: Node) {\n      if (isVariableDeclarator(node)) {\n        variableDeclarations.add(node.id.name);\n      }\n    },\n    FunctionDeclaration(node: Node) {\n      if (!isFunctionDeclaration(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    FunctionExpression(node: Node) {\n      if (!isFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    ArrowFunctionExpression(node: Node) {\n      if (!isArrowFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    AssignmentExpression(node: Node) {\n      if (\n        !isAssignmentExpression(node) ||\n        node.operator !== \"=\" ||\n        !isMemberExpressionNode(node.left)\n      )\n        return;\n\n      const { object, property } = node.left;\n\n      assignmentExpressionsData.add({\n        object,\n        property,\n        parentNode: node,\n      } as AssignmentExpressionData);\n    },\n    CallExpression(node: Node) {\n      if (isCallExpressionNode(node)) {\n        if (isIdentifierNode(node.callee)) {\n          callExpressionsData.add({\n            property: node.callee,\n            params: node.arguments,\n          } as CallExpressionData);\n        }\n\n        if (isMemberExpressionNode(node.callee)) {\n          const { object, property } = node.callee;\n\n          memberCallExpressionData.add({\n            object,\n            property,\n            parentNode: node,\n          } as MemberCallExpressionData);\n        }\n      }\n    },\n  });\n\n  const invalidTopLevelMemberExpressionsArray = Array.from(\n    invalidTopLevelMemberExpressions,\n  ).filter((MemberExpression) => {\n    return !(\n      variableDeclarations.has(MemberExpression.object.name) ||\n      functionalParams.has(MemberExpression.object.name)\n    );\n  });\n\n  return {\n    invalidTopLevelMemberExpressionsArray,\n    assignmentExpressionsData: [...assignmentExpressionsData],\n    callExpressionsData: [...callExpressionsData],\n    memberCallExpressionData: [...memberCallExpressionData],\n  };\n};\n\nconst ancestorWalk = (ast: Node): NodeList => {\n  //List of all Identifier nodes with their property(if exists).\n  const identifierList = new Array<RefactorIdentifierNode>();\n  // List of all references found\n  const references = new Set<string>();\n  // List of variables declared within the script. All identifiers and member expressions derived from declared variables will be removed\n  const variableDeclarations = new Set<string>();\n  // List of functional params declared within the script. All identifiers and member expressions derived from functional params will be removed\n  let functionalParams = new Set<string>();\n\n  /*\n   * We do an ancestor walk on the AST in order to extract all references. For example, for member expressions and identifiers, we need to know\n   * what surrounds the identifier (its parent and ancestors), ancestor walk will give that information in the callback\n   * doc: https://github.com/acornjs/acorn/tree/master/acorn-walk\n   */\n  ancestor(ast, {\n    Identifier(node: Node, ancestors: Node[]) {\n      /*\n       * We are interested in identifiers. Due to the nature of AST, Identifier nodes can\n       * also be nested inside MemberExpressions. For deeply nested object references, there\n       * could be nesting of many MemberExpressions. To find the final reference, we will\n       * try to find the top level MemberExpression that does not have a MemberExpression parent.\n       * */\n      let candidateTopLevelNode: IdentifierNode | MemberExpressionNode =\n        node as IdentifierNode;\n      let depth = ancestors.length - 2; // start \"depth\" with first parent\n\n      while (depth > 0) {\n        const parent = ancestors[depth];\n\n        if (\n          isMemberExpressionNode(parent) &&\n          /* Member expressions that are \"computed\" (with [ ] search)\n             and the ones that have optional chaining ( a.b?.c )\n             will be considered top level node.\n             We will stop looking for further parents */\n          /* \"computed\" exception - isArrayAccessorNode\n             Member expressions that are array accessors with static index - [9]\n             will not be considered top level.\n             We will continue looking further. */\n          (!parent.computed || isArrayAccessorNode(parent)) &&\n          !parent.optional\n        ) {\n          candidateTopLevelNode = parent;\n          depth = depth - 1;\n        } else {\n          // Top level found\n          break;\n        }\n      }\n\n      //If parent is a Member expression then attach property to the Node.\n      //else push Identifier Node.\n      const parentNode = ancestors[ancestors.length - 2];\n\n      if (isMemberExpressionNode(parentNode)) {\n        identifierList.push({\n          ...(node as IdentifierNode),\n          property: parentNode.property as IdentifierNode,\n        });\n      } else identifierList.push(node as RefactorIdentifierNode);\n\n      if (isIdentifierNode(candidateTopLevelNode)) {\n        // If the node is an Identifier, just save that\n        references.add(candidateTopLevelNode.name);\n      } else {\n        // For MemberExpression Nodes, we will construct a final reference string and then add\n        // it to the references list\n        const memberExpIdentifier = constructFinalMemberExpIdentifier(\n          candidateTopLevelNode,\n        );\n\n        references.add(memberExpIdentifier);\n      }\n    },\n    VariableDeclarator(node: Node) {\n      // keep a track of declared variables so they can be\n      // removed from the final list of references\n      if (isVariableDeclarator(node)) {\n        variableDeclarations.add(node.id.name);\n      }\n    },\n    FunctionDeclaration(node: Node) {\n      // params in function declarations are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isFunctionDeclaration(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    FunctionExpression(node: Node) {\n      // params in function expressions are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n    ArrowFunctionExpression(node: Node) {\n      // params in arrow function expressions are also counted as references so we keep\n      // track of them and remove them from the final list of references\n      if (!isArrowFunctionExpression(node)) return;\n\n      functionalParams = new Set([\n        ...functionalParams,\n        ...getFunctionalParamNamesFromNode(node),\n      ]);\n    },\n  });\n\n  return {\n    references,\n    functionalParams,\n    variableDeclarations,\n    identifierList,\n  };\n};\n\n//Replace export default by a variable declaration.\n//This is required for acorn to parse code into AST.\nconst jsObjectToCode = (script: string) => {\n  return script.replace(/export default/g, jsObjectDeclaration);\n};\n\n//Revert the string replacement from 'jsObjectToCode'.\n//variable declaration is replaced back by export default.\nconst jsCodeToObject = (script: string) => {\n  return script.replace(jsObjectDeclaration, \"export default\");\n};\n\nexport const isFunctionPresent = (\n  script: string,\n  evaluationVersion: number,\n) => {\n  try {\n    const sanitizedScript = sanitizeScript(script, evaluationVersion);\n    const ast = getAST(sanitizedScript, {\n      locations: true,\n      ranges: true,\n    });\n\n    let isFunction = false;\n\n    simple(ast, {\n      FunctionDeclaration() {\n        isFunction = true;\n      },\n      FunctionExpression() {\n        isFunction = true;\n      },\n      ArrowFunctionExpression() {\n        isFunction = true;\n      },\n    });\n\n    return isFunction;\n  } catch (e) {\n    return false;\n  }\n};\n\nexport function getMemberExpressionObjectFromProperty(\n  propertyName: string,\n  code: string,\n  evaluationVersion = 2,\n) {\n  if (!propertyName) return [];\n\n  const memberExpressionObjects = new Set<string>();\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n\n  try {\n    const sanitizedScript = sanitizeScript(code, evaluationVersion);\n    const wrappedCode = wrapCode(sanitizedScript);\n\n    ast = getAST(wrappedCode, { locations: true });\n    simple(ast, {\n      MemberExpression(node: Node) {\n        const { object, property } = node as MemberExpressionNode;\n\n        if (!isLiteralNode(property) && !isIdentifierNode(property)) return;\n\n        const propName = isLiteralNode(property)\n          ? property.value\n          : property.name;\n\n        if (!isNil(propName) && getStringValue(propName) === propertyName) {\n          const memberExpressionObjectString = generate(object);\n\n          memberExpressionObjects.add(memberExpressionObjectString);\n        }\n      },\n    });\n\n    return Array.from(memberExpressionObjects);\n  } catch (e) {\n    return [];\n  }\n}\n","import { get, isEmpty, isUndefined, set } from \"lodash\";\nimport type { JSActionEntity } from \"ee/entities/DataTree/types\";\nimport type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { EvalErrorTypes, getEvalValuePath } from \"utils/DynamicBindingUtils\";\nimport type { JSUpdate, ParsedJSSubAction } from \"utils/JSPaneUtils\";\nimport { parseJSObject, isJSFunctionProperty } from \"@shared/ast\";\nimport type DataTreeEvaluator from \"workers/common/DataTreeEvaluator\";\nimport { evaluateSync } from \"workers/Evaluation/evaluate\";\nimport type { DataTreeDiff } from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  DataTreeDiffEvent,\n  getEntityNameAndPropertyPath,\n  isJSAction,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport {\n  removeFunctionsAndVariableJSCollection,\n  updateJSCollectionInUnEvalTree,\n} from \"workers/Evaluation/JSObject/utils\";\nimport { dataTreeEvaluator } from \"../handlers/evalTree\";\nimport JSObjectCollection from \"./Collection\";\nimport ExecutionMetaData from \"../fns/utils/ExecutionMetaData\";\nimport { jsPropertiesState } from \"./jsPropertiesState\";\nimport { getFixedTimeDifference } from \"workers/common/DataTreeEvaluator/utils\";\n\n/**\n * Here we update our unEvalTree according to the change in JSObject's body\n *\n * @param jsUpdates\n * @param localUnEvalTree\n * @returns\n */\nexport const getUpdatedLocalUnEvalTreeAfterJSUpdates = (\n  jsUpdates: Record<string, JSUpdate>,\n  localUnEvalTree: DataTree,\n  configTree: ConfigTree,\n) => {\n  if (!isEmpty(jsUpdates)) {\n    Object.entries(jsUpdates).forEach(([entityName, jsEntity]) => {\n      const entity = localUnEvalTree[entityName] as JSActionEntity;\n      const parsedBody = jsEntity.parsedBody;\n\n      if (isJSAction(entity)) {\n        if (!!parsedBody) {\n          //add/delete/update functions from dataTree\n          localUnEvalTree = updateJSCollectionInUnEvalTree(\n            parsedBody,\n            entity,\n            localUnEvalTree,\n            configTree,\n            entityName,\n          );\n        } else {\n          //if parse error remove functions and variables from dataTree\n          localUnEvalTree = removeFunctionsAndVariableJSCollection(\n            localUnEvalTree,\n            entity,\n            entityName,\n            configTree,\n          );\n        }\n      }\n    });\n  }\n\n  return localUnEvalTree;\n};\n\nexport const validJSBodyRegex = new RegExp(/^export default[\\s]*?({[\\s\\S]*?})/);\n\n/**\n * Here we parse the JSObject and then determine\n * 1. it's nature : async or sync\n * 2. Find arguments of JS Actions\n *\n * @param dataTreeEvalRef\n * @param entity\n * @param jsUpdates\n * @param unEvalDataTree\n * @param entityName\n * @returns\n */\nexport function saveResolvedFunctionsAndJSUpdates(\n  dataTreeEvalRef: DataTreeEvaluator,\n  entity: JSActionEntity,\n  jsUpdates: Record<string, JSUpdate>,\n  unEvalDataTree: DataTree,\n  entityName: string,\n) {\n  jsPropertiesState.delete(entityName);\n  const correctFormat =\n    entity.hasOwnProperty(\"body\") &&\n    !isUndefined(entity.body) &&\n    validJSBodyRegex.test(entity.body);\n  const isEmptyBody =\n    entity.hasOwnProperty(\"body\") &&\n    !isUndefined(entity.body) &&\n    entity?.body.trim() === \"\";\n\n  if (!isUndefined(entity.body) && (correctFormat || isEmptyBody)) {\n    try {\n      JSObjectCollection.deleteResolvedFunction(entityName);\n      JSObjectCollection.deleteUnEvalState(entityName);\n      JSObjectCollection.clearCachedVariablesForEvaluationContext(entityName);\n\n      const parseStartTime = performance.now();\n      const { parsedObject, success } = parseJSObject(entity.body);\n      const parseEndTime = performance.now();\n      const JSObjectASTParseTime = getFixedTimeDifference(\n        parseEndTime,\n        parseStartTime,\n      );\n\n      dataTreeEvalRef.logs.push({\n        JSObjectName: entityName,\n        JSObjectASTParseTime,\n      });\n\n      const actionsMap: Record<string, ParsedJSSubAction> = {};\n      const variablesMap: Record<string, { name: string; value: unknown }> = {};\n\n      if (success) {\n        if (!!parsedObject) {\n          jsPropertiesState.update(entityName, parsedObject);\n          parsedObject.forEach((parsedElement) => {\n            if (isJSFunctionProperty(parsedElement)) {\n              if (actionsMap[parsedElement.key]) return;\n\n              try {\n                ExecutionMetaData.setExecutionMetaData({\n                  enableJSVarUpdateTracking: false,\n                  enableJSFnPostProcessors: false,\n                });\n                const { result } = evaluateSync(\n                  parsedElement.value,\n                  unEvalDataTree,\n                  false,\n                );\n\n                ExecutionMetaData.setExecutionMetaData({\n                  enableJSVarUpdateTracking: true,\n                  enableJSFnPostProcessors: true,\n                });\n\n                if (!!result) {\n                  let params: Array<{ name: string; value: unknown }> = [];\n\n                  if (parsedElement.arguments) {\n                    params = parsedElement.arguments.map(\n                      ({ defaultValue, paramName }) => ({\n                        name: paramName,\n                        value: defaultValue,\n                      }),\n                    );\n                  }\n\n                  const functionString = parsedElement.value;\n\n                  JSObjectCollection.updateResolvedFunctions(\n                    `${entityName}.${parsedElement.key}`,\n                    result,\n                  );\n                  JSObjectCollection.updateUnEvalState(\n                    `${entityName}.${parsedElement.key}`,\n                    functionString,\n                  );\n                  actionsMap[parsedElement.key] = {\n                    name: parsedElement.key,\n                    body: functionString,\n                    arguments: params,\n                  };\n                }\n              } catch {\n                // in case we need to handle error state\n              }\n            } else if (parsedElement.type !== \"literal\") {\n              // when a jsobject property is of the type \"prop1\" or 'prop1', ast outputs the\n              // key as \"\\\"prop1\\\"\" or \"\\'prop1\\'\". We need to remove the extra quotes.\n              const isStringRepresentation =\n                parsedElement.key.startsWith(\"'\") ||\n                parsedElement.key.startsWith('\"');\n              const parsedKey = isStringRepresentation\n                ? parsedElement.key.slice(1, -1)\n                : parsedElement.key;\n\n              variablesMap[parsedKey] = {\n                name: parsedKey,\n                value: parsedElement.value,\n              };\n              JSObjectCollection.updateUnEvalState(\n                `${entityName}.${parsedElement.key}`,\n                parsedElement.value,\n              );\n            }\n          });\n          const parsedBody = {\n            body: entity.body,\n            actions: Object.values(actionsMap),\n            variables: Object.values(variablesMap),\n          };\n\n          set(jsUpdates, `${entityName}`, {\n            parsedBody,\n            id: entity.actionId,\n          });\n        } else {\n          set(jsUpdates, `${entityName}`, {\n            parsedBody: undefined,\n            id: entity.actionId,\n          });\n        }\n      }\n    } catch (e) {\n      //if we need to push error as popup in case\n    }\n  } else {\n    const parsedBody = {\n      body: entity.body,\n      actions: [],\n      variables: [],\n    };\n\n    set(jsUpdates, `${entityName}`, {\n      parsedBody: parsedBody,\n      id: entity.actionId,\n    });\n  }\n\n  if (!correctFormat && !isUndefined(entity.body)) {\n    const errors = {\n      type: EvalErrorTypes.PARSE_JS_ERROR,\n      context: {\n        entity: entity,\n        propertyPath: entityName + \".body\",\n      },\n      message: \"Start object with export default\",\n    };\n\n    dataTreeEvalRef.errors.push(errors);\n  }\n\n  return jsUpdates;\n}\n\nexport function parseJSActions(\n  dataTreeEvalRef: DataTreeEvaluator,\n  unEvalDataTree: DataTree,\n  oldUnEvalTree?: DataTree,\n  differences?: DataTreeDiff[],\n) {\n  const resolvedFunctions = JSObjectCollection.getResolvedFunctions();\n  const unEvalState = JSObjectCollection.getUnEvalState();\n  let jsUpdates: Record<string, JSUpdate> = {};\n\n  if (!!differences && !!oldUnEvalTree) {\n    differences.forEach((diff) => {\n      const { entityName, propertyPath } = getEntityNameAndPropertyPath(\n        diff.payload.propertyPath,\n      );\n      const entity = unEvalDataTree[entityName];\n\n      if (!isJSAction(entity)) return false;\n\n      if (diff.event === DataTreeDiffEvent.DELETE) {\n        // when JSObject is deleted, we remove it from currentJSCollectionState & resolvedFunctions\n        if (unEvalState && unEvalState[diff.payload.propertyPath]) {\n          JSObjectCollection.deleteUnEvalState(diff.payload.propertyPath);\n        }\n\n        if (resolvedFunctions && resolvedFunctions[diff.payload.propertyPath]) {\n          JSObjectCollection.deleteResolvedFunction(diff.payload.propertyPath);\n        }\n      }\n\n      if (\n        (diff.event === DataTreeDiffEvent.EDIT && propertyPath === \"body\") ||\n        (diff.event === DataTreeDiffEvent.NEW && propertyPath === \"\")\n      ) {\n        jsUpdates = saveResolvedFunctionsAndJSUpdates(\n          dataTreeEvalRef,\n          entity,\n          jsUpdates,\n          unEvalDataTree,\n          entityName,\n        );\n      }\n    });\n  } else {\n    Object.keys(unEvalDataTree).forEach((entityName) => {\n      const entity = unEvalDataTree[entityName];\n\n      if (!isJSAction(entity)) {\n        return;\n      }\n\n      jsUpdates = saveResolvedFunctionsAndJSUpdates(\n        dataTreeEvalRef,\n        entity,\n        jsUpdates,\n        unEvalDataTree,\n        entityName,\n      );\n    });\n  }\n\n  Object.keys(jsUpdates).forEach((entityName) => {\n    const parsedBody = jsUpdates[entityName].parsedBody;\n\n    if (!parsedBody) return;\n\n    parsedBody.actions = parsedBody.actions.map((action) => {\n      return {\n        ...action,\n      } as ParsedJSSubAction;\n    });\n  });\n\n  return { jsUpdates };\n}\n\nexport function getJSEntities(dataTree: DataTree) {\n  const jsCollections: Record<string, JSActionEntity> = {};\n\n  Object.keys(dataTree).forEach((entityName: string) => {\n    const entity = dataTree[entityName];\n\n    if (isJSAction(entity)) {\n      jsCollections[entityName] = entity;\n    }\n  });\n\n  return jsCollections;\n}\n\nexport function updateEvalTreeWithJSCollectionState(evalTree: DataTree) {\n  // loop through jsCollectionState and set all values to evalTree\n  const jsCollections = JSObjectCollection.getVariableState();\n  const jsCollectionEntries = Object.entries(jsCollections);\n\n  for (const [jsObjectName, variableState] of jsCollectionEntries) {\n    if (!evalTree[jsObjectName]) continue;\n\n    evalTree[jsObjectName] = Object.assign(\n      evalTree[jsObjectName],\n      variableState,\n    );\n  }\n}\n\nexport function updateEvalTreeValueFromContext(paths: string[][]) {\n  const currentEvalContext = self;\n\n  if (!dataTreeEvaluator) return;\n\n  const evalTree = dataTreeEvaluator.getEvalTree();\n\n  for (const fullPathArray of paths) {\n    const [jsObjectName, variableName] = fullPathArray;\n    const entity = evalTree[jsObjectName];\n\n    if (jsObjectName && variableName && isJSAction(entity)) {\n      if (!(jsObjectName in currentEvalContext)) continue;\n\n      const variableValue = get(currentEvalContext, [\n        jsObjectName,\n        variableName,\n      ]);\n      const value = variableValue;\n\n      JSObjectCollection.setVariableValue(\n        value,\n        `${jsObjectName}.${variableName}`,\n      );\n      /*\n      JSobject variable values are picked from evalProps until the unevalValue is not modified.\n      Hence, we need to set the value in evalProps to ensure it doesn't have stale values.\n      */\n      set(\n        dataTreeEvaluator.evalProps,\n        getEvalValuePath(`${jsObjectName}.${variableName}`, {\n          isPopulated: true,\n          fullPath: true,\n        }),\n        value,\n      );\n    }\n  }\n}\n","// 🚧 NOTE: this file exists only for the worker thread, as the worker thread needs to pass\n// the full Lodash library around. *Do not* import it in the main thread code, as that will\n// result in bundling the full Lodash. If you’re trying to pass a Lodash reference into some\n// function in the main thread, consider if you can instead:\n//\n// - import and call Lodash directly:\n//\n//   Before:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray(_);\n//\n//   After:\n//     // a.js\n//     import _ from 'lodash';\n//     export function mapArray() { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     mapArray();\n//\n// - pass only the function you need about:\n//\n//   Before:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray(_);\n//\n//   After:\n//     // a.js\n//     export function mapArray(_) { return _.map(someArray, someFunction); }\n//     // b.js\n//     import { mapArray } from './a';\n//     import _ from 'lodash';\n//     mapArray({ map: _.map });\nif (\n  typeof window !== \"undefined\" &&\n  // Jest mocks the `window` object when running worker tests\n  process.env.NODE_ENV !== \"test\"\n) {\n  throw new Error(\"lodash-wrapper.js must only be used in a worker thread\");\n}\n\n/////////////////////////////////////////////////////////////////////////\n//\n// We use babel-plugin-lodash to only import the lodash functions we use.\n// Unfortunately, the plugin doesn’t work with the following pattern:\n//   import _ from 'lodash';\n//   const something = _;\n// When it encounters code like above, it will replace _ with `undefined`,\n// which will break the app (https://github.com/lodash/babel-plugin-lodash/issues/235).\n//\n// Given that we *need* to use the full lodash in ./resetJSLibraries.js,\n// we use this workaround where we’re importing Lodash using CommonJS require().\n// It works because babel-plugin-lodash doesn’t support CommonJS require().\nmodule.exports = require(\"lodash\");\n","import {\n  getEntityNameAndPropertyPath,\n  isWidget,\n  overrideWidgetProperties,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport { evalTreeWithChanges } from \"./evalTreeWithChanges\";\nimport { dataTreeEvaluator } from \"./handlers/evalTree\";\nimport { get, set } from \"lodash\";\nimport { validate } from \"./validations\";\nimport type {\n  DataTreeEntityConfig,\n  WidgetEntity,\n} from \"ee/entities/DataTree/types\";\nimport type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport { getFnWithGuards, isAsyncGuard } from \"./fns/utils/fnGuard\";\nimport { shouldAddSetter } from \"./evaluate\";\nimport { EVAL_WORKER_SYNC_ACTION } from \"ee/workers/Evaluation/evalWorkerActions\";\n\nclass Setters {\n  /** stores the setter method accessor as key and true as value\n   *\n   * example - ```{ \"Table1.setVisibility\": true, \"Table1.setData\": true }```\n   */\n  private setterMethodLookup: Record<string, true> = {};\n  /** stores the setter property accessor as key and setter method name as value\n   *\n   * example - ```{ \"Table1.tableData\": \"Table1.setData\" }```\n   */\n  private setterAccessorMap: Record<string, string> = {};\n\n  private async applySetterMethod(\n    path: string,\n    value: unknown,\n    setterMethodName: string,\n  ) {\n    const { entityName, propertyPath } = getEntityNameAndPropertyPath(path);\n\n    if (!dataTreeEvaluator) return;\n\n    const evalTree = dataTreeEvaluator.getEvalTree();\n    const configTree = dataTreeEvaluator.getConfigTree();\n\n    const entity = evalTree[entityName];\n    const entityConfig = configTree[entityName];\n\n    const updatedProperties: string[][] = [];\n    const overriddenProperties: string[] = [];\n    const evalMetaUpdates: EvalMetaUpdates = [];\n\n    let parsedValue = value;\n\n    if (value === undefined) {\n      const error = new Error(\n        `The value passed to ${entityName}.${setterMethodName}() evaluates to undefined.`,\n      );\n\n      error.name = entityName + \".\" + setterMethodName + \" failed\";\n      throw error;\n    }\n\n    const { validationPaths } = entityConfig;\n\n    if (validationPaths) {\n      const validationConfig = validationPaths[propertyPath] || {};\n\n      const config = {\n        ...validationConfig,\n        params: { ...(validationConfig.params || {}) },\n      };\n\n      config.params.strict = true;\n\n      const { isValid, messages, parsed } = validate(\n        config,\n        value,\n        entity as Record<string, unknown>,\n        propertyPath,\n      );\n\n      parsedValue = parsed;\n\n      if (!isValid) {\n        const message = messages && messages[0] ? messages[0].message : \"\";\n        const error = new Error(\n          `${entityName + \".\" + setterMethodName}: ${message}`,\n        );\n\n        error.name = entityName + \".\" + setterMethodName + \" failed\";\n        throw error;\n      }\n    }\n\n    if (isWidget(entity)) {\n      overrideWidgetProperties({\n        entity: entity as WidgetEntity,\n        propertyPath,\n        value: parsedValue,\n        currentTree: evalTree,\n        configTree,\n        evalMetaUpdates,\n        fullPropertyPath: path,\n        isNewWidget: false,\n        shouldUpdateGlobalContext: true,\n        overriddenProperties,\n      });\n\n      overriddenProperties.forEach((propPath) => {\n        updatedProperties.push([entityName, propPath]);\n      });\n    }\n\n    set(evalTree, path, parsedValue);\n    set(self, path, parsedValue);\n\n    /**\n     * Making the update to dataTree async as there could be queue microtask updates that need to execute before this update.\n     * Issue:- https://github.com/appsmithorg/appsmith/issues/25364\n     */\n    return new Promise((resolve) => {\n      resolve(parsedValue);\n    }).then((res) => {\n      updatedProperties.push([entityName, propertyPath]);\n\n      evalTreeWithChanges({\n        data: {\n          updatedValuePaths: updatedProperties,\n          metaUpdates: evalMetaUpdates,\n        },\n        method: EVAL_WORKER_SYNC_ACTION.EVAL_TREE_WITH_CHANGES,\n        webworkerTelemetry: {},\n      });\n\n      return res;\n    });\n  }\n  /** Generates a new setter method */\n  private createSetter(\n    path: string,\n    setterMethodName: string,\n    entityName: string,\n  ) {\n    /** register the setter method in the lookup */\n    set(this.setterMethodLookup, [entityName, setterMethodName], true);\n\n    const fn = async (value: unknown) => {\n      if (!dataTreeEvaluator) return;\n\n      return this.applySetterMethod(path, value, setterMethodName);\n    };\n\n    return getFnWithGuards(fn, setterMethodName, [isAsyncGuard]);\n  }\n\n  clear() {\n    this.setterMethodLookup = {};\n  }\n\n  has(entityName: string, propertyName: string) {\n    return get(this.setterMethodLookup, [entityName, propertyName], false);\n  }\n\n  getMap() {\n    return this.setterMethodLookup;\n  }\n\n  getSetterAccessorMap() {\n    return this.setterAccessorMap;\n  }\n\n  getEntitySettersFromConfig(\n    entityConfig: DataTreeEntityConfig,\n    entityName: string,\n    entity: DataTreeEntity,\n  ) {\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const setterMethodMap: Record<string, any> = {};\n\n    if (!entityConfig) return setterMethodMap;\n\n    if (entityConfig.__setters) {\n      for (const setterMethodName of Object.keys(entityConfig.__setters)) {\n        const pathToSet = entityConfig.__setters[setterMethodName].path;\n\n        if (!shouldAddSetter(entityConfig.__setters[setterMethodName], entity))\n          continue;\n\n        this.setterAccessorMap[pathToSet] = `${entityName}.${setterMethodName}`;\n\n        setterMethodMap[setterMethodName] = this.createSetter(\n          pathToSet,\n          setterMethodName,\n          entityName,\n        );\n      }\n    }\n\n    return setterMethodMap;\n  }\n\n  init(configTree: ConfigTree, dataTree: DataTree) {\n    const configTreeEntries = Object.entries(configTree);\n\n    for (const [entityName, entityConfig] of configTreeEntries) {\n      const entity = dataTree[entityName];\n\n      this.getEntitySettersFromConfig(entityConfig, entityName, entity);\n    }\n  }\n}\n\nconst setters = new Setters();\n\nexport default setters;\n","import { parseExpressionAt, type Node } from \"acorn\";\nimport { simple } from \"acorn-walk\";\nimport type {\n  IdentifierNode,\n  LiteralNode,\n  NodeWithLocation,\n  PropertyNode,\n} from \"../index\";\nimport {\n  getAST,\n  isExportDefaultDeclarationNode,\n  isObjectExpression,\n  isTypeOfFunction,\n} from \"../index\";\nimport { generate } from \"astring\";\nimport type { functionParam } from \"../index\";\nimport { getFunctionalParamsFromNode, isPropertyAFunctionNode } from \"../index\";\nimport { ECMA_VERSION, SourceType } from \"../../index\";\nimport escodegen, { attachComments } from \"escodegen\";\nimport { extractContentByPosition } from \"../utils\";\n\nconst jsObjectVariableName =\n  \"____INTERNAL_JS_OBJECT_NAME_USED_FOR_PARSING_____\";\n\nexport const jsObjectDeclaration = `var ${jsObjectVariableName} =`;\n\nexport interface JSPropertyPosition {\n  startLine: number;\n  startColumn: number;\n  endLine: number;\n  endColumn: number;\n  keyStartLine: number;\n  keyEndLine: number;\n  keyStartColumn: number;\n  keyEndColumn: number;\n}\n\ninterface BaseJSProperty {\n  key: string;\n  value: string;\n  type: string;\n  position: Partial<JSPropertyPosition>;\n  rawContent: string;\n}\n\nexport type JSFunctionProperty = BaseJSProperty & {\n  arguments: functionParam[];\n  // If function uses the \"async\" keyword\n  isMarkedAsync: boolean;\n};\nexport type JSVarProperty = BaseJSProperty;\n\nexport type TParsedJSProperty = JSVarProperty | JSFunctionProperty;\n\ninterface Property extends PropertyNode {\n  key: IdentifierNode;\n}\n\nexport const isJSFunctionProperty = (\n  t: TParsedJSProperty,\n): t is JSFunctionProperty => {\n  return isTypeOfFunction(t.type);\n};\n\nexport const parseJSObject = (code: string) => {\n  let ast: Node = { end: 0, start: 0, type: \"\" };\n  const result: TParsedJSProperty[] = [];\n\n  try {\n    const comments: any = [];\n    const token: any = [];\n\n    ast = getAST(code, {\n      sourceType: SourceType.module,\n      onComment: comments,\n      onToken: token,\n      ranges: true,\n      locations: true,\n    });\n    attachComments(ast, comments, token);\n  } catch (e) {\n    return { parsedObject: result, success: false };\n  }\n\n  const parsedObjectProperties = new Set<TParsedJSProperty>();\n  let JSObjectProperties: NodeWithLocation<PropertyNode>[] = [];\n\n  simple(ast, {\n    ExportDefaultDeclaration(node: Node) {\n      if (\n        !isExportDefaultDeclarationNode(node) ||\n        !isObjectExpression(node.declaration)\n      )\n        return;\n\n      JSObjectProperties = node.declaration\n        .properties as NodeWithLocation<PropertyNode>[];\n    },\n  });\n\n  JSObjectProperties.forEach((node) => {\n    const propertyKey = node.key as NodeWithLocation<\n      LiteralNode | IdentifierNode\n    >;\n    let property: TParsedJSProperty = {\n      key: generate(node.key),\n      value: generate(node.value),\n      rawContent: extractContentByPosition(code, {\n        from: {\n          line: node.loc.start.line - 1,\n          ch: node.loc.start.column,\n        },\n        to: {\n          line: node.loc.end.line - 1,\n          ch: node.loc.end.column - 1,\n        },\n      }),\n      type: node.value.type,\n      position: {\n        startLine: node.loc.start.line,\n        startColumn: node.loc.start.column,\n        endLine: node.loc.end.line,\n        endColumn: node.loc.end.column,\n        keyStartLine: propertyKey.loc.start.line,\n        keyEndLine: propertyKey.loc.end.line,\n        keyStartColumn: propertyKey.loc.start.column,\n        keyEndColumn: propertyKey.loc.end.column,\n      },\n    };\n\n    if (isPropertyAFunctionNode(node.value)) {\n      const params = getFunctionalParamsFromNode(node.value, true, code);\n\n      property = {\n        ...property,\n        arguments: [...params],\n        isMarkedAsync: node.value.async,\n      };\n    }\n\n    parsedObjectProperties.add(property);\n  });\n\n  return { parsedObject: [...parsedObjectProperties], success: true };\n};\n\nexport const addPropertiesToJSObjectCode = (\n  code: string,\n  obj: Record<string, string>,\n) => {\n  try {\n    const ast = getAST(code, { sourceType: \"module\" });\n\n    simple(ast, {\n      ExportDefaultDeclaration(node: any) {\n        const properties: Property[] = node?.declaration?.properties;\n\n        Object.entries(obj).forEach(([key, value]) => {\n          // Check if a property with the same name already exists\n          const existingPropertyIndex = properties.findIndex(\n            (property) => property.key.name === key,\n          );\n\n          const astValue = parseExpressionAt(value, 0, {\n            ecmaVersion: ECMA_VERSION,\n          });\n\n          // Create a new property\n          const newProperty = {\n            type: \"Property\",\n            key: { type: \"Identifier\", name: key },\n            value: astValue,\n            kind: \"init\",\n            method: false,\n            shorthand: false,\n            computed: false,\n          } as unknown as Property;\n\n          if (existingPropertyIndex >= 0) {\n            // Replace the existing property\n            properties[existingPropertyIndex] = newProperty;\n          } else {\n            // Add the new property\n            properties.push(newProperty);\n          }\n        });\n      },\n    });\n\n    return escodegen.generate(ast);\n  } catch (e) {\n    return code;\n  }\n};\n","import type { ActionResponse } from \"api/ActionAPI\";\nimport type { PluginType, PluginId } from \"entities/Plugin\";\nimport type { ValidationConfig } from \"constants/PropertyControlConstants\";\nimport type { ActionConfig } from \"entities/Action\";\nimport type { ActionDescription } from \"ee/workers/Evaluation/fns\";\nimport type { Variable } from \"entities/JSCollection\";\nimport type { DependencyMap, DynamicPath } from \"utils/DynamicBindingUtils\";\nimport type { Page } from \"entities/Page\";\nimport type { MetaWidgetsReduxState } from \"reducers/entityReducers/metaWidgetsReducer\";\nimport type { WidgetConfigProps } from \"WidgetProvider/constants\";\nimport type { ActionDataState } from \"ee/reducers/entityReducers/actionsReducer\";\nimport type { WidgetProps } from \"widgets/BaseWidget\";\nimport type { CanvasWidgetsReduxState } from \"ee/reducers/entityReducers/canvasWidgetsReducer\";\nimport type { MetaState } from \"reducers/entityReducers/metaReducer\";\nimport type { AppDataState } from \"reducers/entityReducers/appReducer\";\nimport type { JSCollectionDataState } from \"ee/reducers/entityReducers/jsActionsReducer\";\nimport type { AppTheme } from \"entities/AppTheming\";\nimport type { LoadingEntitiesState } from \"reducers/evaluationReducers/loadingEntitiesReducer\";\nimport type { LayoutSystemTypes } from \"layoutSystems/types\";\nimport type { Module } from \"ee/constants/ModuleConstants\";\nimport type { ModuleInstance } from \"ee/constants/ModuleInstanceConstants\";\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ActionDispatcher = (...args: any[]) => ActionDescription;\n\nexport const ENTITY_TYPE = {\n  ACTION: \"ACTION\",\n  WIDGET: \"WIDGET\",\n  APPSMITH: \"APPSMITH\",\n  JSACTION: \"JSACTION\",\n} as const;\nexport const JSACTION_TYPE = ENTITY_TYPE.JSACTION;\nexport const ACTION_TYPE = ENTITY_TYPE.ACTION;\n\ntype ValueOf<T> = T[keyof T];\nexport type EntityTypeValue = ValueOf<typeof ENTITY_TYPE>;\n\nexport enum EvaluationSubstitutionType {\n  TEMPLATE = \"TEMPLATE\",\n  PARAMETER = \"PARAMETER\",\n  SMART_SUBSTITUTE = \"SMART_SUBSTITUTE\",\n}\n\n// Action entity types\nexport interface ActionEntity {\n  actionId: string;\n  isLoading: boolean;\n  data: ActionResponse[\"body\"];\n  run: ActionDispatcher | Record<string, unknown>;\n  clear: ActionDispatcher | Record<string, unknown>;\n  responseMeta: {\n    statusCode?: string;\n    isExecutionSuccess: boolean;\n    headers?: unknown;\n  };\n  ENTITY_TYPE: typeof ENTITY_TYPE.ACTION;\n  config: Partial<ActionConfig>;\n  datasourceUrl: string;\n}\n\nexport interface ActionEntityConfig extends EntityConfig {\n  dynamicBindingPathList: DynamicPath[];\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.ACTION;\n  dependencyMap: DependencyMap;\n  logBlackList: Record<string, true>;\n  pluginType: PluginType;\n  pluginId: PluginId;\n  actionId: string;\n  name: string;\n  moduleId?: string;\n  moduleInstanceId?: string;\n  isPublic?: boolean;\n}\n\n// JSAction (JSObject) entity Types\n\nexport interface MetaArgs {\n  arguments: Variable[];\n  confirmBeforeExecute: boolean;\n}\n\nexport interface JSActionEntityConfig extends EntityConfig {\n  meta: Record<string, MetaArgs>;\n  dynamicBindingPathList: DynamicPath[];\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  variables?: Array<string>;\n  dependencyMap: DependencyMap;\n  pluginType: PluginType.JS;\n  name: string;\n  ENTITY_TYPE: typeof ENTITY_TYPE.JSACTION;\n  actionId: string;\n  moduleId?: string;\n  moduleInstanceId?: string;\n  isPublic?: boolean;\n  actionNames: Set<string>;\n}\n\nexport interface JSActionEntity {\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [propName: string]: any;\n  body?: string;\n  ENTITY_TYPE: typeof ENTITY_TYPE.JSACTION;\n  actionId: string;\n}\nexport type PagelistEntity = Page[];\n\n// Widget entity Types\n\n// Private widgets do not get evaluated\n// For example, for widget Button1 in a List widget List1, List1.template.Button1.text gets evaluated,\n// so there is no need to evaluate Button1.text\nexport type PrivateWidgets = Record<string, true>;\n\n/**\n *  Map of overriding property as key and overridden property as values\n */\nexport type OverridingPropertyPaths = Record<string, string[]>;\n\nexport enum OverridingPropertyType {\n  META = \"META\",\n  DEFAULT = \"DEFAULT\",\n}\nexport interface overrideDependency {\n  DEFAULT: string;\n  META: string;\n}\n/**\n *  Map of property name as key and value as object with defaultPropertyName and metaPropertyName which it depends on.\n */\nexport type PropertyOverrideDependency = Record<\n  string,\n  Partial<overrideDependency>\n>;\n\nexport interface WidgetConfig extends EntityConfig {\n  bindingPaths: Record<string, EvaluationSubstitutionType>;\n  reactivePaths: Record<string, EvaluationSubstitutionType>;\n  triggerPaths: Record<string, boolean>;\n  validationPaths: Record<string, ValidationConfig>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.WIDGET;\n  logBlackList: Record<string, true>;\n  propertyOverrideDependency: PropertyOverrideDependency;\n  overridingPropertyPaths: OverridingPropertyPaths;\n  privateWidgets: PrivateWidgets;\n}\n\nexport interface EntityConfig {\n  __setters?: Record<string, unknown>;\n  bindingPaths?: Record<string, EvaluationSubstitutionType>;\n  reactivePaths?: Record<string, EvaluationSubstitutionType>;\n  validationPaths?: Record<string, ValidationConfig>;\n  dynamicBindingPathList?: DynamicPath[];\n  dependencyMap?: Record<string, string[]>;\n}\n\n//data factory types\nexport type UnEvalTreeEntityObject =\n  | ActionEntity\n  | JSActionEntity\n  | WidgetEntity;\n\nexport interface WidgetEntity extends WidgetProps {\n  meta: Record<string, unknown>;\n  ENTITY_TYPE: typeof ENTITY_TYPE.WIDGET;\n}\nexport type DataTreeEntityObject =\n  | ActionEntity\n  | JSActionEntity\n  | WidgetEntity\n  | AppsmithEntity;\n\nexport interface WidgetEntityConfig\n  extends Partial<WidgetProps>,\n    Omit<WidgetConfigProps, \"widgetName\" | \"rows\" | \"columns\">,\n    WidgetConfig {\n  widgetId: string;\n  defaultMetaProps: Array<string>;\n  type: string;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  __setters?: Record<string, any>;\n}\n\nexport interface AppsmithEntity extends Omit<AppDataState, \"store\"> {\n  ENTITY_TYPE: typeof ENTITY_TYPE.APPSMITH;\n  store: Record<string, unknown>;\n  theme: AppTheme[\"properties\"];\n  currentPageName: string;\n  workspaceName: string;\n  appName: string;\n  currentEnvironmentName: string;\n}\n\nexport interface DataTreeSeed {\n  actions: ActionDataState;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  editorConfigs: Record<string, any[]>;\n  pluginDependencyConfig: Record<string, DependencyMap>;\n  widgets: CanvasWidgetsReduxState;\n  widgetsMeta: MetaState;\n  appData: AppDataState;\n  jsActions: JSCollectionDataState;\n  theme: AppTheme[\"properties\"];\n  metaWidgets: MetaWidgetsReduxState;\n  isMobile: boolean;\n  moduleInputs: Module[\"inputsForm\"];\n  moduleInstances: Record<string, ModuleInstance> | null;\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  moduleInstanceEntities: any;\n  layoutSystemType: LayoutSystemTypes;\n  loadingEntities: LoadingEntitiesState;\n}\n\nexport type DataTreeEntityConfig =\n  | WidgetEntityConfig\n  | ActionEntityConfig\n  | JSActionEntityConfig;\n","export * from \"ce/entities/DataTree/types\";\nimport { ENTITY_TYPE as CE_ENTITY_TYPE } from \"ce/entities/DataTree/types\";\n\nexport const ENTITY_TYPE = {\n  ...CE_ENTITY_TYPE,\n  MODULE_INPUT: \"MODULE_INPUT\",\n  MODULE_INSTANCE: \"MODULE_INSTANCE\",\n} as const;\n\ntype ValueOf<T> = T[keyof T];\nexport type EntityTypeValue = ValueOf<typeof ENTITY_TYPE>;\n","import type {\n  TNavigateToActionType,\n  TNavigateToDescription,\n} from \"./navigateTo\";\nimport navigateTo from \"./navigateTo\";\nimport type { TShowAlertActionType, TShowAlertDescription } from \"./showAlert\";\nimport showAlert from \"./showAlert\";\nimport type {\n  TCloseModalActionType,\n  TCloseModalDescription,\n  TShowModalActionType,\n  TShowModalDescription,\n} from \"./modalFns\";\nimport { closeModal, showModal } from \"./modalFns\";\nimport type { TDownloadActionType, TDownloadDescription } from \"./download\";\nimport download from \"./download\";\nimport type {\n  TPostWindowMessageActionType,\n  TPostWindowMessageDescription,\n} from \"./postWindowMessage\";\nimport postWindowMessage from \"./postWindowMessage\";\nimport type {\n  TCopyToClipboardActionType,\n  TCopyToClipboardDescription,\n} from \"./copyToClipboard\";\nimport copyToClipboard from \"./copyToClipboard\";\nimport type {\n  TResetWidgetActionType,\n  TResetWidgetDescription,\n} from \"./resetWidget\";\nimport resetWidget from \"./resetWidget\";\nimport type {\n  TClearStoreDescription,\n  TRemoveValueDescription,\n  TStoreValueDescription,\n} from \"./storeFns\";\nimport { clearStore, removeValue, storeValue } from \"./storeFns\";\nimport type {\n  TClearActionType,\n  TClearDescription,\n  TRunActionType,\n  TRunDescription,\n} from \"./actionFns\";\nimport run, { clear } from \"./actionFns\";\nimport { isAppsmithEntity } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { ActionEntity } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type {\n  TGetGeoLocationActionType,\n  TGetGeoLocationDescription,\n  TStopWatchGeoLocationActionType,\n  TStopWatchGeoLocationDescription,\n  TWatchGeoLocationActionType,\n  TWatchGeoLocationDescription,\n} from \"./geolocationFns\";\nimport {\n  getGeoLocation,\n  stopWatchGeoLocation,\n  watchGeoLocation,\n} from \"./geolocationFns\";\nimport { getFnWithGuards, isAsyncGuard } from \"./utils/fnGuard\";\nimport { isRunNClearFnQualifierEntity } from \"ee/workers/Evaluation/fns/utils/isRunNClearFnQualifierEntity\";\n\nexport const getPlatformFunctions = () => {\n  return platformFns;\n};\n\nexport const getEntityFunctions = () => {\n  return entityFns;\n};\n\nconst platformFns = [\n  {\n    name: \"navigateTo\",\n    fn: navigateTo,\n  },\n  {\n    name: \"showAlert\",\n    fn: showAlert,\n  },\n  {\n    name: \"showModal\",\n    fn: showModal,\n  },\n  {\n    name: \"closeModal\",\n    fn: closeModal,\n  },\n  {\n    name: \"download\",\n    fn: download,\n  },\n  {\n    name: \"postWindowMessage\",\n    fn: postWindowMessage,\n  },\n  {\n    name: \"copyToClipboard\",\n    fn: copyToClipboard,\n  },\n  {\n    name: \"resetWidget\",\n    fn: resetWidget,\n  },\n  {\n    name: \"storeValue\",\n    fn: storeValue,\n  },\n  {\n    name: \"removeValue\",\n    fn: removeValue,\n  },\n  {\n    name: \"clearStore\",\n    fn: clearStore,\n  },\n];\n\nconst entityFns = [\n  {\n    name: \"run\",\n    qualifier: (entity: DataTreeEntity) => isRunNClearFnQualifierEntity(entity),\n    fn: (entity: DataTreeEntity, entityName: string) => {\n      const actionEntity = entity as ActionEntity;\n\n      // @ts-expect-error: name is not defined on ActionEntity\n      actionEntity.name = entityName;\n\n      return getFnWithGuards(\n        run.bind(actionEntity as ActionEntity),\n        `${entityName}.run`,\n        [isAsyncGuard],\n      );\n    },\n  },\n  {\n    name: \"clear\",\n    qualifier: (entity: DataTreeEntity) => isRunNClearFnQualifierEntity(entity),\n    fn: (entity: DataTreeEntity, entityName: string) =>\n      getFnWithGuards(\n        clear.bind(entity as ActionEntity),\n        `${entityName}.clear`,\n        [isAsyncGuard],\n      ),\n  },\n  {\n    name: \"getGeoLocation\",\n    path: \"appsmith.geolocation.getCurrentPosition\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(\n        getGeoLocation,\n        \"appsmith.geolocation.getCurrentPosition\",\n        [isAsyncGuard],\n      ),\n  },\n  {\n    name: \"watchGeoLocation\",\n    path: \"appsmith.geolocation.watchPosition\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(watchGeoLocation, \"appsmith.geolocation.watchPosition\", [\n        isAsyncGuard,\n      ]),\n  },\n  {\n    name: \"stopWatchGeoLocation\",\n    path: \"appsmith.geolocation.clearWatch\",\n    qualifier: (entity: DataTreeEntity) => isAppsmithEntity(entity),\n    fn: () =>\n      getFnWithGuards(stopWatchGeoLocation, \"appsmith.geolocation.clearWatch\", [\n        isAsyncGuard,\n      ]),\n  },\n];\n\nexport type ActionTriggerKeys =\n  | TClearActionType\n  | TRunActionType\n  | TDownloadActionType\n  | TShowModalActionType\n  | TCloseModalActionType\n  | TShowAlertActionType\n  | TDownloadActionType\n  | TNavigateToActionType\n  | TResetWidgetActionType\n  | TCopyToClipboardActionType\n  | TPostWindowMessageActionType\n  | TGetGeoLocationActionType\n  | TWatchGeoLocationActionType\n  | TStopWatchGeoLocationActionType;\n\nexport const getActionTriggerFunctionNames = (): Record<string, string> => {\n  return ActionTriggerFunctionNames;\n};\n\nconst ActionTriggerFunctionNames: Record<string, string> = {\n  CLEAR_INTERVAL: \"clearInterval\",\n  CLEAR_PLUGIN_ACTION: \"action.clear\",\n  CLOSE_MODAL: \"closeModal\",\n  COPY_TO_CLIPBOARD: \"copyToClipboard\",\n  DOWNLOAD: \"download\",\n  NAVIGATE_TO: \"navigateTo\",\n  RESET_WIDGET_META_RECURSIVE_BY_NAME: \"resetWidget\",\n  RUN_PLUGIN_ACTION: \"action.run\",\n  SET_INTERVAL: \"setInterval\",\n  SHOW_ALERT: \"showAlert\",\n  SHOW_MODAL_BY_NAME: \"showModal\",\n  STORE_VALUE: \"storeValue\",\n  REMOVE_VALUE: \"removeValue\",\n  CLEAR_STORE: \"clearStore\",\n  GET_CURRENT_LOCATION: \"getCurrentLocation\",\n  WATCH_CURRENT_LOCATION: \"watchLocation\",\n  STOP_WATCHING_CURRENT_LOCATION: \"stopWatch\",\n  POST_MESSAGE: \"postWindowMessage\",\n  SET_TIMEOUT: \"setTimeout\",\n  CLEAR_TIMEOUT: \"clearTimeout\",\n};\n\nexport type ActionDescription =\n  | TRunDescription\n  | TClearDescription\n  | TShowModalDescription\n  | TCloseModalDescription\n  | TClearDescription\n  | TStoreValueDescription\n  | TClearStoreDescription\n  | TRemoveValueDescription\n  | TDownloadDescription\n  | TPostWindowMessageDescription\n  | TNavigateToDescription\n  | TShowAlertDescription\n  | TResetWidgetDescription\n  | TCopyToClipboardDescription\n  | TGetGeoLocationDescription\n  | TWatchGeoLocationDescription\n  | TStopWatchGeoLocationDescription;\n","import type { DependencyMap, EvaluationError } from \"utils/DynamicBindingUtils\";\nimport {\n  EVAL_ERROR_PATH,\n  isChildPropertyPath,\n  isDynamicValue,\n  PropertyEvaluationErrorType,\n  isPathDynamicTrigger,\n  isPathADynamicBinding,\n} from \"utils/DynamicBindingUtils\";\nimport type { Diff } from \"deep-diff\";\nimport type {\n  DataTreeEntity,\n  DataTree,\n  ConfigTree,\n} from \"entities/DataTree/dataTreeTypes\";\nimport { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport _, { difference, get, has, isEmpty, isNil, set } from \"lodash\";\nimport type { WidgetTypeConfigMap } from \"WidgetProvider/factory\";\nimport { PluginType } from \"entities/Plugin\";\nimport { klona } from \"klona/full\";\nimport { warn as logWarn } from \"loglevel\";\nimport type { EvalMetaUpdates } from \"ee/workers/common/DataTreeEvaluator/types\";\nimport type {\n  JSActionEntityConfig,\n  PrivateWidgets,\n  JSActionEntity,\n  ActionEntity,\n  AppsmithEntity,\n  WidgetEntity,\n  DataTreeEntityConfig,\n  WidgetEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type { EvalProps } from \"workers/common/DataTreeEvaluator\";\nimport { validateWidgetProperty } from \"workers/common/DataTreeEvaluator/validationUtils\";\nimport { isWidgetActionOrJsObject } from \"ee/entities/DataTree/utils\";\nimport type { Difference } from \"microdiff\";\n\n// Dropdown1.options[1].value -> Dropdown1.options[1]\n// Dropdown1.options[1] -> Dropdown1.options\n// Dropdown1.options -> Dropdown1\nexport const IMMEDIATE_PARENT_REGEX = /^(.*)(\\..*|\\[.*\\])$/;\n\nexport enum DataTreeDiffEvent {\n  NEW = \"NEW\",\n  DELETE = \"DELETE\",\n  EDIT = \"EDIT\",\n  NOOP = \"NOOP\", // No Operation (don’t do anything)\n}\n\nexport interface DataTreeDiff {\n  payload: {\n    propertyPath: string;\n    value?: string;\n  };\n  event: DataTreeDiffEvent;\n}\n\nexport class CrashingError extends Error {}\n\nexport const convertPathToString = (arrPath: Array<string | number>) => {\n  let string = \"\";\n\n  arrPath.forEach((segment) => {\n    if (isInt(segment)) {\n      string = string + \"[\" + segment + \"]\";\n    } else {\n      if (string.length !== 0) {\n        string = string + \".\";\n      }\n\n      string = string + segment;\n    }\n  });\n\n  return string;\n};\n\n// Todo: improve the logic here\n// Right now NaN, Infinity, floats, everything works\nfunction isInt(val: string | number): boolean {\n  return Number.isInteger(val) || (_.isString(val) && /^\\d+$/.test(val));\n}\n\n// Removes the entity name from the property path\nexport function getEntityNameAndPropertyPath(fullPath: string): {\n  entityName: string;\n  propertyPath: string;\n} {\n  const indexOfFirstDot = fullPath.indexOf(\".\");\n\n  if (indexOfFirstDot === -1) {\n    // No dot was found so path is the entity name itself\n    return {\n      entityName: fullPath,\n      propertyPath: \"\",\n    };\n  }\n\n  const entityName = fullPath.substring(0, indexOfFirstDot);\n  const propertyPath = fullPath.substring(indexOfFirstDot + 1);\n\n  return { entityName, propertyPath };\n}\n\nexport function translateCollectionDiffs(\n  propertyPath: string,\n  data: unknown,\n  event: DataTreeDiffEvent,\n) {\n  const dataTreeDiffs: DataTreeDiff[] = [];\n\n  if (Array.isArray(data)) {\n    data.forEach((diff, idx) => {\n      dataTreeDiffs.push({\n        event,\n        payload: {\n          propertyPath: `${propertyPath}[${idx}]`,\n        },\n      });\n    });\n  } else if (isTrueObject(data)) {\n    Object.keys(data).forEach((diffKey) => {\n      const path = `${propertyPath}.${diffKey}`;\n\n      dataTreeDiffs.push({\n        event,\n        payload: {\n          propertyPath: path,\n        },\n      });\n    });\n  }\n\n  return dataTreeDiffs;\n}\n\n//these paths are not required to go through evaluate tree as these are internal properties\nconst ignorePathsForEvalRegex =\n  \".(reactivePaths|bindingPaths|triggerPaths|validationPaths|dynamicBindingPathList)\";\n\n//match if paths are part of ignorePathsForEvalRegex\nconst isUninterestingChangeForDependencyUpdate = (path: string) => {\n  return path.match(ignorePathsForEvalRegex);\n};\n\nexport const translateDiffEventToDataTreeDiffEvent = (\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  difference: Diff<any, any>,\n  unEvalDataTree: DataTree,\n): DataTreeDiff | DataTreeDiff[] => {\n  let result: DataTreeDiff | DataTreeDiff[] = {\n    payload: {\n      propertyPath: \"\",\n      value: \"\",\n    },\n    event: DataTreeDiffEvent.NOOP,\n  };\n\n  if (!difference.path) {\n    return result;\n  }\n\n  const propertyPath = convertPathToString(difference.path);\n\n  // add propertyPath to NOOP event\n  result.payload = {\n    propertyPath,\n    value: \"\",\n  };\n\n  //we do not need evaluate these paths because these are internal paths\n  const isUninterestingPathForUpdateTree =\n    isUninterestingChangeForDependencyUpdate(propertyPath);\n\n  if (!!isUninterestingPathForUpdateTree) {\n    return result;\n  }\n\n  const { entityName } = getEntityNameAndPropertyPath(propertyPath);\n  const entity = unEvalDataTree[entityName];\n  const isJsAction = isJSAction(entity);\n\n  switch (difference.kind) {\n    case \"N\": {\n      result.event = DataTreeDiffEvent.NEW;\n      result.payload = {\n        propertyPath,\n      };\n      break;\n    }\n    case \"D\": {\n      result.event = DataTreeDiffEvent.DELETE;\n      result.payload = { propertyPath };\n      break;\n    }\n    case \"E\": {\n      const rhsChange =\n        typeof difference.rhs === \"string\" &&\n        (isDynamicValue(difference.rhs) || isJsAction);\n\n      const lhsChange =\n        typeof difference.lhs === \"string\" &&\n        (isDynamicValue(difference.lhs) || isJsAction);\n\n      if (rhsChange || lhsChange) {\n        result = [\n          {\n            event:\n              difference.lhs === undefined\n                ? DataTreeDiffEvent.NEW\n                : DataTreeDiffEvent.EDIT,\n            payload: {\n              propertyPath,\n              value: difference.rhs,\n            },\n          },\n        ];\n        /**\n         * If lhs is an array/object\n         * Add delete events for all memberExpressions\n         */\n\n        const dataTreeDeleteDiffs = translateCollectionDiffs(\n          propertyPath,\n          difference.lhs,\n          DataTreeDiffEvent.DELETE,\n        );\n\n        result = result.concat(dataTreeDeleteDiffs);\n      } else if (difference.lhs === undefined || difference.rhs === undefined) {\n        // Handle static value changes that change structure that can lead to\n        // old bindings being eligible\n        if (difference.lhs === undefined && !isNil(difference.rhs)) {\n          result.event = DataTreeDiffEvent.NEW;\n          result.payload = { propertyPath };\n        }\n\n        if (difference.rhs === undefined && !isNil(difference.lhs)) {\n          result = [\n            {\n              event: DataTreeDiffEvent.EDIT,\n              payload: {\n                propertyPath,\n                value: difference.rhs,\n              },\n            },\n          ];\n\n          const dataTreeDeleteDiffs = translateCollectionDiffs(\n            propertyPath,\n            difference.lhs,\n            DataTreeDiffEvent.DELETE,\n          );\n\n          result = dataTreeDeleteDiffs.concat(result);\n        }\n      } else if (\n        isTrueObject(difference.lhs) &&\n        !isTrueObject(difference.rhs)\n      ) {\n        // This will happen for static value changes where a property went\n        // from being an object to any other type like string or number\n        // in such a case we want to delete all nested paths of the\n        // original lhs object\n\n        result = translateCollectionDiffs(\n          propertyPath,\n          difference.lhs,\n          DataTreeDiffEvent.DELETE,\n        );\n\n        // when an object is being replaced by an array\n        // list all new array accessors that are being added\n        // so dependencies will be created based on existing bindings\n        if (Array.isArray(difference.rhs)) {\n          result = result.concat(\n            translateCollectionDiffs(\n              propertyPath,\n              difference.rhs,\n              DataTreeDiffEvent.NEW,\n            ),\n          );\n        }\n      } else if (\n        !isTrueObject(difference.lhs) &&\n        isTrueObject(difference.rhs)\n      ) {\n        // This will happen for static value changes where a property went\n        // from being any other type like string or number to an object\n        // in such a case we want to add all nested paths of the\n        // new rhs object\n        result = translateCollectionDiffs(\n          propertyPath,\n          difference.rhs,\n          DataTreeDiffEvent.NEW,\n        );\n\n        // when an array is being replaced by an object\n        // remove all array accessors that are deleted\n        // so dependencies by existing bindings are removed\n        if (Array.isArray(difference.lhs)) {\n          result = result.concat(\n            translateCollectionDiffs(\n              propertyPath,\n              difference.lhs,\n              DataTreeDiffEvent.DELETE,\n            ),\n          );\n        }\n      }\n\n      break;\n    }\n    case \"A\": {\n      return translateDiffEventToDataTreeDiffEvent(\n        {\n          ...difference.item,\n          path: [...difference.path, difference.index],\n        },\n        unEvalDataTree,\n      );\n    }\n    default: {\n      break;\n    }\n  }\n\n  return result;\n};\n\nexport const translateDiffArrayIndexAccessors = (\n  propertyPath: string,\n  array: unknown[],\n  event: DataTreeDiffEvent,\n) => {\n  const result: DataTreeDiff[] = [];\n\n  array.forEach((data, index) => {\n    const path = `${propertyPath}[${index}]`;\n\n    result.push({\n      event,\n      payload: {\n        propertyPath: path,\n      },\n    });\n  });\n\n  return result;\n};\n/*\n  Table1.selectedRow\n  Table1.selectedRow.email: [\"Input1.defaultText\"]\n */\n\nexport const addDependantsOfNestedPropertyPaths = (\n  parentPaths: Array<string>,\n  inverseMap: DependencyMap,\n): Set<string> => {\n  const withNestedPaths: Set<string> = new Set();\n  const dependantNodes = Object.keys(inverseMap);\n\n  parentPaths.forEach((propertyPath) => {\n    withNestedPaths.add(propertyPath);\n    dependantNodes\n      .filter((dependantNodePath) =>\n        isChildPropertyPath(propertyPath, dependantNodePath),\n      )\n      .forEach((dependantNodePath) => {\n        inverseMap[dependantNodePath].forEach((path) => {\n          withNestedPaths.add(path);\n        });\n      });\n  });\n\n  return withNestedPaths;\n};\n\nexport function isWidget(\n  entity: Partial<DataTreeEntity> | DataTreeEntityConfig,\n): entity is WidgetEntity | WidgetEntityConfig {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.WIDGET\n  );\n}\n\nexport const shouldSuppressAutoComplete = (widget: WidgetEntity) =>\n  Boolean(widget.suppressAutoComplete);\n\nexport const shouldSuppressDebuggerError = (widget: WidgetEntity) =>\n  Boolean(widget.suppressDebuggerError);\n\nexport function isAction(\n  entity: Partial<DataTreeEntity>,\n): entity is ActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.ACTION\n  );\n}\n\nexport function isAppsmithEntity(\n  entity: DataTreeEntity,\n): entity is AppsmithEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.APPSMITH\n  );\n}\n\nexport function isJSAction(entity: DataTreeEntity): entity is JSActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION\n  );\n}\n/**\n *\n * isAnyJSAction checks if the entity is a JSAction ( or a JSModuleInstance on EE )\n */\nexport function isAnyJSAction(entity: DataTreeEntity) {\n  return isJSAction(entity);\n}\n\nexport function isJSActionConfig(\n  entity: DataTreeEntityConfig,\n): entity is JSActionEntityConfig {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION\n  );\n}\n\nexport function isJSObject(entity: DataTreeEntity): entity is JSActionEntity {\n  return (\n    typeof entity === \"object\" &&\n    \"ENTITY_TYPE\" in entity &&\n    entity.ENTITY_TYPE === ENTITY_TYPE.JSACTION &&\n    \"pluginType\" in entity &&\n    entity.pluginType === PluginType.JS\n  );\n}\n\nexport function isDataTreeEntity(entity: unknown) {\n  return !!entity && typeof entity === \"object\" && \"ENTITY_TYPE\" in entity;\n}\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const serialiseToBigInt = (value: any) =>\n  JSON.stringify(value, (_, v) => (typeof v === \"bigint\" ? v.toString() : v));\n\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const removeFunctionsAndSerialzeBigInt = (value: any) =>\n  JSON.parse(serialiseToBigInt(value));\n// We need to remove functions from data tree to avoid any unexpected identifier while JSON parsing\n// Check issue https://github.com/appsmithorg/appsmith/issues/719\n// TODO: Fix this the next time the file is edited\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const removeFunctions = (value: any) => {\n  if (_.isFunction(value)) {\n    return \"Function call\";\n  } else if (_.isObject(value)) {\n    return removeFunctionsAndSerialzeBigInt(value);\n  } else {\n    return value;\n  }\n};\n\nexport const makeParentsDependOnChildren = (\n  depMap: DependencyMap,\n  allkeys: Record<string, true>,\n): DependencyMap => {\n  //return depMap;\n  // Make all parents depend on child\n  Object.keys(depMap).forEach((key) => {\n    depMap = makeParentsDependOnChild(depMap, key, allkeys);\n    depMap[key].forEach((path) => {\n      depMap = makeParentsDependOnChild(depMap, path, allkeys);\n    });\n  });\n\n  return depMap;\n};\n\nexport const makeParentsDependOnChild = (\n  depMap: DependencyMap,\n  child: string,\n  allkeys: Record<string, true>,\n): DependencyMap => {\n  const result: DependencyMap = depMap;\n  let curKey = child;\n\n  if (!allkeys[curKey]) {\n    logWarn(\n      `makeParentsDependOnChild - ${curKey} is not present in dataTree.`,\n      \"This might result in a cyclic dependency.\",\n    );\n  }\n\n  let matches: Array<string> | null;\n\n  // Note: The `=` is intentional\n  // Stops looping when match is null\n  while ((matches = curKey.match(IMMEDIATE_PARENT_REGEX)) !== null) {\n    const parentKey = matches[1];\n    // Todo: switch everything to set.\n    const existing = new Set(result[parentKey] || []);\n\n    existing.add(curKey);\n    result[parentKey] = Array.from(existing);\n    curKey = parentKey;\n  }\n\n  return result;\n};\n\n// The idea is to find the immediate parents of the property paths\n// e.g. For Table1.selectedRow.email, the parent is Table1.selectedRow\nexport const getImmediateParentsOfPropertyPaths = (\n  propertyPaths: Array<string>,\n): Array<string> => {\n  // Use a set to ensure that we dont have duplicates\n  const parents: Set<string> = new Set();\n\n  propertyPaths.forEach((path) => {\n    const matches = path.match(IMMEDIATE_PARENT_REGEX);\n\n    if (matches !== null) {\n      parents.add(matches[1]);\n    }\n  });\n\n  return Array.from(parents);\n};\n\nexport const getAllPaths = (\n  records: Record<string, unknown> | unknown,\n  curKey = \"\",\n  result: Record<string, true> = {},\n): Record<string, true> => {\n  // Add the key if it exists\n  if (curKey) result[curKey] = true;\n\n  if (Array.isArray(records)) {\n    for (let i = 0; i < records.length; i++) {\n      const tempKey = curKey ? `${curKey}[${i}]` : `${i}`;\n\n      getAllPaths(records[i], tempKey, result);\n    }\n  } else if (isTrueObject(records)) {\n    for (const key of Object.keys(records)) {\n      const tempKey = curKey ? `${curKey}.${key}` : `${key}`;\n\n      getAllPaths(records[key], tempKey, result);\n    }\n  }\n\n  return result;\n};\nexport const getAllPathsBasedOnDiffPaths = (\n  records: Record<string, unknown> | unknown,\n  diff: DataTreeDiff[],\n  // this argument would be mutable\n  previousResult: Record<string, true> = {},\n): Record<string, true> => {\n  const newResult = previousResult;\n\n  diff.forEach((curr) => {\n    const { event, payload } = curr;\n\n    if (event === DataTreeDiffEvent.DELETE) {\n      delete newResult[payload.propertyPath];\n    }\n\n    if (event === DataTreeDiffEvent.NEW || event === DataTreeDiffEvent.EDIT) {\n      const newDataSegments = get(records, payload.propertyPath);\n\n      // directly mutates on the result so we don't have to merge it back to the result\n      getAllPaths(newDataSegments, payload.propertyPath, newResult);\n    }\n  });\n\n  return newResult;\n};\nexport const trimDependantChangePaths = (\n  changePaths: Set<string>,\n  dependencyMap: DependencyMap,\n): Array<string> => {\n  const trimmedPaths = [];\n\n  for (const path of changePaths) {\n    let foundADependant = false;\n\n    if (path in dependencyMap) {\n      const dependants = dependencyMap[path];\n\n      for (const dependantPath of dependants) {\n        if (changePaths.has(dependantPath)) {\n          foundADependant = true;\n          break;\n        }\n      }\n    }\n\n    if (!foundADependant) {\n      trimmedPaths.push(path);\n    }\n  }\n\n  return trimmedPaths;\n};\n\nexport function getSafeToRenderDataTree(\n  tree: DataTree,\n  widgetTypeConfigMap: WidgetTypeConfigMap,\n  configTree: ConfigTree,\n) {\n  return Object.keys(tree).reduce((tree, entityKey: string) => {\n    const entity = tree[entityKey];\n\n    if (!isWidget(entity)) {\n      return tree;\n    }\n\n    const entityConfig = configTree[entityKey] as WidgetEntityConfig;\n\n    const safeToRenderEntity = { ...entity };\n\n    // Set user input values to their parsed values\n    Object.entries(entityConfig.validationPaths).forEach(\n      ([property, validation]) => {\n        const value = _.get(entity, property);\n        // Pass it through parse\n        const { parsed } = validateWidgetProperty(\n          validation,\n          value,\n          entityConfig,\n          property,\n        );\n\n        _.set(safeToRenderEntity, property, parsed);\n      },\n    );\n    // Set derived values to undefined or else they would go as bindings\n    Object.keys(\n      widgetTypeConfigMap[entityConfig.type].derivedProperties,\n    ).forEach((property) => {\n      _.set(safeToRenderEntity, property, undefined);\n    });\n\n    return { ...tree, [entityKey]: safeToRenderEntity };\n  }, tree);\n}\n\nexport const addErrorToEntityProperty = ({\n  configTree,\n  errors,\n  evalProps,\n  fullPropertyPath,\n}: {\n  errors: EvaluationError[];\n  fullPropertyPath: string;\n  evalProps: EvalProps;\n  configTree: ConfigTree;\n}) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const isPrivateEntityPath =\n    getAllPrivateWidgetsInDataTree(configTree)[entityName];\n  const logBlackList = get(configTree, `${entityName}.logBlackList`, {});\n\n  if (propertyPath && !(propertyPath in logBlackList) && !isPrivateEntityPath) {\n    const errorPath = `${entityName}.${EVAL_ERROR_PATH}['${propertyPath}']`;\n    const existingErrors = get(evalProps, errorPath, []) as EvaluationError[];\n\n    set(evalProps, errorPath, existingErrors.concat(errors));\n  }\n};\n\nexport const resetValidationErrorsForEntityProperty = ({\n  evalProps,\n  fullPropertyPath,\n}: {\n  fullPropertyPath: string;\n  evalProps: EvalProps;\n}) => {\n  const { entityName, propertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n\n  if (propertyPath) {\n    const errorPath = `${entityName}.${EVAL_ERROR_PATH}['${propertyPath}']`;\n    const existingErrorsExceptValidation = (\n      _.get(evalProps, errorPath, []) as EvaluationError[]\n    ).filter(\n      (error) => error.errorType !== PropertyEvaluationErrorType.VALIDATION,\n    );\n\n    _.set(evalProps, errorPath, existingErrorsExceptValidation);\n  }\n};\n\n// For the times when you need to know if something truly an object like { a: 1, b: 2}\n// typeof, lodash.isObject and others will return false positives for things like array, null, etc\nexport const isTrueObject = (\n  item: unknown,\n): item is Record<string, unknown> => {\n  return Object.prototype.toString.call(item) === \"[object Object]\";\n};\n\n/**\n * This function finds the datatype of the given value.\n * typeof, lodash and others will return false positives for things like array, wrapper objects, etc\n * @param value\n * @returns datatype of the received value as string\n */\nexport const findDatatype = (value: unknown) => {\n  return Object.prototype.toString.call(value).slice(8, -1).toLowerCase();\n};\n\nexport const isDynamicLeaf = (\n  unEvalTree: DataTree,\n  propertyPath: string,\n  configTree: ConfigTree,\n) => {\n  const [entityName, ...propPathEls] = _.toPath(propertyPath);\n\n  // Framework feature: Top level items are never leaves\n  if (entityName === propertyPath) return false;\n\n  // Ignore if this was a delete op\n  if (!unEvalTree.hasOwnProperty(entityName)) return false;\n\n  const entityConfig = configTree[entityName];\n  const entity = unEvalTree[entityName];\n\n  if (!isWidgetActionOrJsObject(entity)) return false;\n\n  const relativePropertyPath = convertPathToString(propPathEls);\n\n  return (\n    (!isEmpty(entityConfig.reactivePaths) &&\n      relativePropertyPath in entityConfig.reactivePaths) ||\n    (isWidget(entityConfig) &&\n      relativePropertyPath in entityConfig?.triggerPaths)\n  );\n};\n\nexport const addWidgetPropertyDependencies = ({\n  widgetConfig,\n  widgetName,\n}: {\n  widgetConfig: WidgetEntityConfig;\n  widgetName: string;\n}) => {\n  const dependencies: DependencyMap = {};\n\n  Object.entries(widgetConfig.propertyOverrideDependency).forEach(\n    ([overriddenPropertyKey, overridingPropertyKeyMap]) => {\n      const existingDependenciesSet = new Set(\n        dependencies[`${widgetName}.${overriddenPropertyKey}`] || [],\n      );\n\n      // add meta dependency\n      overridingPropertyKeyMap.META &&\n        existingDependenciesSet.add(\n          `${widgetName}.${overridingPropertyKeyMap.META}`,\n        );\n      // add default dependency\n      overridingPropertyKeyMap.DEFAULT &&\n        existingDependenciesSet.add(\n          `${widgetName}.${overridingPropertyKeyMap.DEFAULT}`,\n        );\n\n      dependencies[`${widgetName}.${overriddenPropertyKey}`] = [\n        ...existingDependenciesSet,\n      ];\n    },\n  );\n\n  return dependencies;\n};\n\nexport const isPrivateEntityPath = (\n  privateWidgets: PrivateWidgets,\n  fullPropertyPath: string,\n) => {\n  const entityName = fullPropertyPath.split(\".\")[0];\n\n  if (Object.keys(privateWidgets).indexOf(entityName) !== -1) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const getAllPrivateWidgetsInDataTree = (\n  configTree: ConfigTree,\n): PrivateWidgets => {\n  let privateWidgets: PrivateWidgets = {};\n\n  Object.keys(configTree).forEach((entityName) => {\n    const entityConfig = configTree[entityName] as WidgetEntityConfig;\n\n    if (isWidget(entityConfig) && !_.isEmpty(entityConfig.privateWidgets)) {\n      privateWidgets = { ...privateWidgets, ...entityConfig.privateWidgets };\n    }\n  });\n\n  return privateWidgets;\n};\n\nexport const getDataTreeWithoutPrivateWidgets = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n): DataTree => {\n  const privateWidgets = getAllPrivateWidgetsInDataTree(configTree);\n  const privateWidgetNames = Object.keys(privateWidgets);\n  const treeWithoutPrivateWidgets = _.omit(dataTree, privateWidgetNames);\n\n  return treeWithoutPrivateWidgets;\n};\n\nconst getDataTreeWithoutSuppressedAutoComplete = (\n  dataTree: DataTree,\n): DataTree => {\n  const entityIds = Object.keys(dataTree).filter((entityName) => {\n    const entity = dataTree[entityName];\n\n    return (\n      isWidget(entity) && shouldSuppressAutoComplete(entity as WidgetEntity)\n    );\n  });\n\n  return _.omit(dataTree, entityIds);\n};\n\nexport const getDataTreeForAutocomplete = (\n  dataTree: DataTree,\n  configTree: ConfigTree,\n): DataTree => {\n  const treeWithoutPrivateWidgets = getDataTreeWithoutPrivateWidgets(\n    dataTree,\n    configTree,\n  );\n  const treeWithoutSuppressedAutoComplete =\n    getDataTreeWithoutSuppressedAutoComplete(treeWithoutPrivateWidgets);\n\n  return treeWithoutSuppressedAutoComplete;\n};\n\n/**\n *  overrideWidgetProperties method has logic to update overriddenPropertyPaths when overridingPropertyPaths are evaluated.\n *\n *  when we evaluate widget's overridingPropertyPaths for example defaultText of input widget,\n *  we override the values like text and meta.text in dataTree, these values are called as overriddenPropertyPaths\n *\n * @param {{\n *   entity: WidgetEntity;\n *   propertyPath: string;\n *   value: unknown;\n *   currentTree: DataTree;\n *   evalMetaUpdates: EvalMetaUpdates;\n * }} params\n * @return {*}\n */\nexport const overrideWidgetProperties = (params: {\n  entity: WidgetEntity;\n  propertyPath: string;\n  value: unknown;\n  currentTree: DataTree;\n  configTree: ConfigTree;\n  evalMetaUpdates: EvalMetaUpdates;\n  fullPropertyPath: string;\n  isNewWidget: boolean;\n  shouldUpdateGlobalContext?: boolean;\n  overriddenProperties?: string[];\n  safeTree?: DataTree;\n}) => {\n  const {\n    configTree,\n    currentTree,\n    entity,\n    evalMetaUpdates,\n    fullPropertyPath,\n    isNewWidget,\n    overriddenProperties,\n    propertyPath,\n    safeTree,\n    shouldUpdateGlobalContext,\n    value,\n  } = params;\n  const { entityName } = getEntityNameAndPropertyPath(fullPropertyPath);\n\n  const configEntity = configTree[entityName] as WidgetEntityConfig;\n\n  if (propertyPath in configEntity.overridingPropertyPaths) {\n    const clonedValue = klona(value);\n    const overridingPropertyPaths =\n      configEntity.overridingPropertyPaths[propertyPath];\n\n    const pathsNotToOverride = widgetPathsNotToOverride(\n      isNewWidget,\n      propertyPath,\n      configEntity,\n    );\n\n    overridingPropertyPaths.forEach((overriddenPropertyPath) => {\n      const overriddenPropertyPathArray = overriddenPropertyPath.split(\".\");\n\n      if (pathsNotToOverride.includes(overriddenPropertyPath)) return;\n\n      const fullPath = [entityName, ...overriddenPropertyPathArray];\n\n      _.set(currentTree, fullPath, clonedValue);\n\n      if (safeTree) _.set(safeTree, fullPath, klona(value));\n\n      if (shouldUpdateGlobalContext) {\n        _.set(self, fullPath, clonedValue);\n      }\n\n      overriddenProperties?.push(overriddenPropertyPath);\n\n      // evalMetaUpdates has all updates from property which overrides meta values.\n      if (\n        propertyPath.split(\".\")[0] !== \"meta\" &&\n        overriddenPropertyPathArray[0] === \"meta\"\n      ) {\n        const metaPropertyPath = overriddenPropertyPathArray.slice(1);\n\n        evalMetaUpdates.push({\n          widgetId: entity.widgetId,\n          metaPropertyPath,\n          value: clonedValue,\n        });\n      }\n    });\n  } else if (\n    propertyPath in configEntity.propertyOverrideDependency &&\n    value === undefined\n  ) {\n    // When a reset a widget its meta value becomes undefined, ideally they should reset to default value.\n    // below we handle logic to reset meta values to default values.\n    const propertyOverridingKeyMap =\n      configEntity.propertyOverrideDependency[propertyPath];\n\n    if (propertyOverridingKeyMap.DEFAULT) {\n      const defaultValue = entity[propertyOverridingKeyMap.DEFAULT];\n\n      if (defaultValue !== undefined) {\n        const clonedDefaultValue = klona(defaultValue);\n        const fullPath = [entityName, ...propertyPath.split(\".\")];\n\n        _.set(currentTree, fullPath, clonedDefaultValue);\n\n        if (safeTree) _.set(safeTree, fullPath, klona(defaultValue));\n\n        if (shouldUpdateGlobalContext) {\n          _.set(self, fullPath, clonedDefaultValue);\n        }\n\n        return {\n          overwriteParsedValue: true,\n          newValue: clonedDefaultValue,\n        };\n      }\n    }\n  }\n};\n\nexport const isATriggerPath = (\n  entityConfig: DataTreeEntityConfig,\n  propertyPath: string,\n) => {\n  return (\n    isWidget(entityConfig) && isPathDynamicTrigger(entityConfig, propertyPath)\n  );\n};\n\n// Checks if entity newly got added to the unevalTree\nexport const isNewEntity = (updates: Set<string>, entityName: string) => {\n  return updates.has(entityName);\n};\n\nconst widgetPathsNotToOverride = (\n  isNewWidget: boolean,\n  propertyPath: string,\n  entityConfig: WidgetEntityConfig,\n) => {\n  let pathsNotToOverride: string[] = [];\n  const overriddenPropertyPaths =\n    entityConfig.overridingPropertyPaths[propertyPath];\n\n  // Check if widget has pre-existing meta values (although newly added to the unevalTree)\n  if (isNewWidget && entityConfig.isMetaPropDirty) {\n    const overriddenMetaPaths = overriddenPropertyPaths.filter(\n      (path) => path.split(\".\")[0] === \"meta\",\n    );\n\n    // If widget is newly added but has pre-existing meta values, this meta values take precedence and should not be overridden\n    pathsNotToOverride = [...overriddenMetaPaths];\n    // paths which these meta values override should also not get overridden\n    overriddenMetaPaths.forEach((path) => {\n      if (entityConfig.overridingPropertyPaths.hasOwnProperty(path)) {\n        pathsNotToOverride = [\n          ...pathsNotToOverride,\n          ...entityConfig.overridingPropertyPaths[path],\n        ];\n      }\n    });\n  }\n\n  return pathsNotToOverride;\n};\n\nconst isWidgetDefaultPropertyPath = (\n  widget: WidgetEntityConfig,\n  propertyPath: string,\n) => {\n  for (const property of Object.keys(widget.propertyOverrideDependency)) {\n    const overrideDependency = widget.propertyOverrideDependency[property];\n\n    if (overrideDependency.DEFAULT === propertyPath) return true;\n  }\n\n  return false;\n};\n\nconst isMetaWidgetTemplate = (widget: WidgetEntity) => {\n  return !!widget.siblingMetaWidgets;\n};\n\n// When a default value changes in a template(widgets used to generate other widgets), meta values of metaWidgets not present in the unevalTree become stale\nexport function getStaleMetaStateIds(args: {\n  entity: WidgetEntity;\n  entityConfig: WidgetEntityConfig;\n  propertyPath: string;\n  isNewWidget: boolean;\n  metaWidgets: string[];\n}) {\n  const { entity, entityConfig, isNewWidget, metaWidgets, propertyPath } = args;\n\n  return !isNewWidget &&\n    isWidgetDefaultPropertyPath(entityConfig, propertyPath) &&\n    isMetaWidgetTemplate(entity)\n    ? difference(entity.siblingMetaWidgets, metaWidgets)\n    : [];\n}\n\nexport function convertJSFunctionsToString(\n  jscollections: Record<string, JSActionEntity>,\n  configTree: ConfigTree,\n) {\n  const collections = klona(jscollections);\n\n  Object.keys(collections).forEach((collectionName) => {\n    const jsCollection = collections[collectionName];\n    const jsCollectionConfig = configTree[\n      collectionName\n    ] as JSActionEntityConfig;\n    const jsFunctions = jsCollectionConfig.meta;\n\n    for (const funcName in jsFunctions) {\n      if (jsCollection[funcName] instanceof String) {\n        if (has(jsCollection, [funcName, \"data\"])) {\n          set(jsCollection, [`${funcName}.data`], {});\n        }\n\n        set(jsCollection, funcName, jsCollection[funcName].toString());\n      }\n    }\n  });\n\n  return collections;\n}\n\nexport const isAPathDynamicBindingPath = (\n  entity: DataTreeEntity,\n  entityConfig: DataTreeEntityConfig,\n  propertyPath: string,\n) => {\n  return (\n    isWidgetActionOrJsObject(entity) &&\n    isPathADynamicBinding(entityConfig, propertyPath)\n  );\n};\n\nexport const isNotEntity = (entity: DataTreeEntity) => {\n  return !isAction(entity) && !isWidget(entity) && !isJSAction(entity);\n};\n\nexport const isEntityAction = (entity: DataTreeEntity) => {\n  return isAction(entity);\n};\n\nexport const isPropertyAnEntityAction = (\n  entity: DataTreeEntity,\n  propertyPath: string,\n  entityConfig: DataTreeEntityConfig,\n) => {\n  if (!isJSAction(entity)) return false;\n\n  const { actionNames } = entityConfig as JSActionEntityConfig;\n\n  return actionNames.has(propertyPath);\n};\n\nexport const convertMicroDiffToDeepDiff = (\n  microDiffDifferences: Difference[],\n): Diff<unknown, unknown>[] =>\n  microDiffDifferences.map((microDifference) => {\n    const { path, type } = microDifference;\n\n    //convert microDiff format to deepDiff format\n    if (type === \"CREATE\") {\n      return {\n        kind: \"N\",\n        path,\n        rhs: microDifference.value,\n      };\n    }\n\n    if (type === \"REMOVE\") {\n      return {\n        kind: \"D\",\n        path,\n        lhs: microDifference.oldValue,\n      };\n    }\n\n    return {\n      kind: \"E\",\n      path,\n      lhs: microDifference.oldValue,\n      rhs: microDifference.value,\n    };\n  });\n","import { APPSMITH_NAMESPACED_FUNCTIONS as EE_APPSMITH_NAMESPACED_FUNCTIONS } from \"ee/entities/Engine/actionHelpers\";\n\nexport enum APPSMITH_GLOBAL_FUNCTIONS {\n  navigateTo = \"navigateTo\",\n  showAlert = \"showAlert\",\n  showModal = \"showModal\",\n  closeModal = \"closeModal\",\n  storeValue = \"storeValue\",\n  removeValue = \"removeValue\",\n  clearStore = \"clearStore\",\n  download = \"download\",\n  copyToClipboard = \"copyToClipboard\",\n  resetWidget = \"resetWidget\",\n  setInterval = \"setInterval\",\n  clearInterval = \"clearInterval\",\n  postWindowMessage = \"postWindowMessage\",\n}\n\nexport enum APPSMITH_NAMESPACED_FUNCTIONS {\n  getGeolocation = \"appsmith.geolocation.getCurrentPosition\",\n  watchGeolocation = \"appsmith.geolocation.watchPosition\",\n  stopWatchGeolocation = \"appsmith.geolocation.clearWatch\",\n}\n\nexport enum APPSMITH_INTEGRATIONS {\n  none = \"none\",\n  integration = \"integration\",\n  jsFunction = \"jsFunction\",\n}\n\nexport const AppsmithFunction = {\n  ...APPSMITH_INTEGRATIONS,\n  ...APPSMITH_GLOBAL_FUNCTIONS,\n  ...APPSMITH_NAMESPACED_FUNCTIONS,\n  ...EE_APPSMITH_NAMESPACED_FUNCTIONS,\n};\n\nexport const AppsmithFunctionsWithFields = [\n  ...Object.values(APPSMITH_NAMESPACED_FUNCTIONS),\n  ...Object.keys(APPSMITH_GLOBAL_FUNCTIONS),\n];\n\nexport const RESET_CHILDREN_OPTIONS = [\n  { label: \"true\", value: \"true\", id: \"true\" },\n  { label: \"false\", value: \"false\", id: \"false\" },\n];\n\nexport const FILE_TYPE_OPTIONS = [\n  { label: \"Select file type (optional)\", value: \"\", id: \"\" },\n  { label: \"Plain text\", value: \"'text/plain'\", id: \"text/plain\" },\n  { label: \"HTML\", value: \"'text/html'\", id: \"text/html\" },\n  { label: \"CSV\", value: \"'text/csv'\", id: \"text/csv\" },\n  { label: \"JSON\", value: \"'application/json'\", id: \"application/json\" },\n  { label: \"JPEG\", value: \"'image/jpeg'\", id: \"image/jpeg\" },\n  { label: \"PNG\", value: \"'image/png'\", id: \"image/png\" },\n  { label: \"SVG\", value: \"'image/svg+xml'\", id: \"image/svg+xml\" },\n];\n\nexport const NAVIGATION_TARGET_FIELD_OPTIONS = [\n  {\n    label: \"Same window\",\n    value: \"'SAME_WINDOW'\",\n    id: \"SAME_WINDOW\",\n  },\n  {\n    label: \"New window\",\n    value: \"'NEW_WINDOW'\",\n    id: \"NEW_WINDOW\",\n  },\n];\n\nexport const ViewTypes = {\n  SELECTOR_VIEW: \"SELECTOR_VIEW\",\n  KEY_VALUE_VIEW: \"KEY_VALUE_VIEW\",\n  TEXT_VIEW: \"TEXT_VIEW\",\n  BOOL_VIEW: \"BOOL_VIEW\",\n  TAB_VIEW: \"TAB_VIEW\",\n  NO_VIEW: \"NO_VIEW\",\n  ACTION_SELECTOR_VIEW: \"ACTION_SELECTOR_VIEW\",\n};\n\nexport const NAVIGATE_TO_TAB_OPTIONS = {\n  PAGE_NAME: \"page-name\",\n  URL: \"url\",\n};\n\nexport const NEW_MODAL_LABEL = \"New Modal\";\nconst SELECT_OPTIONS_LABEL = \"Select file type (optional)\";\n\nexport const DEFAULT_LABELS = [NEW_MODAL_LABEL, SELECT_OPTIONS_LABEL];\n\nexport const DEFAULT_SELECTOR_VIEW_TEXT = \"Select Action\";\n\nexport const EMPTY_BINDING = \"{{}}\";\nexport const EMPTY_BINDING_WITH_EMPTY_OBJECT = \"{{{}}}\";\n\nexport enum FieldType {\n  PARAMS_FIELD = \"PARAMS_FIELD\",\n  ACTION_SELECTOR_FIELD = \"ACTION_SELECTOR_FIELD\",\n  ON_SUCCESS_FIELD = \"ON_SUCCESS_FIELD\",\n  ON_ERROR_FIELD = \"ON_ERROR_FIELD\",\n  SHOW_MODAL_FIELD = \"SHOW_MODAL_FIELD\",\n  CLOSE_MODAL_FIELD = \"CLOSE_MODAL_FIELD\",\n  PAGE_SELECTOR_FIELD = \"PAGE_SELECTOR_FIELD\",\n  KEY_VALUE_FIELD = \"KEY_VALUE_FIELD\",\n  URL_FIELD = \"URL_FIELD\",\n  ALERT_TEXT_FIELD = \"ALERT_TEXT_FIELD\",\n  ALERT_TYPE_SELECTOR_FIELD = \"ALERT_TYPE_SELECTOR_FIELD\",\n  KEY_TEXT_FIELD_REMOVE_VALUE = \"KEY_TEXT_FIELD_REMOVE_VALUE\",\n  KEY_TEXT_FIELD_STORE_VALUE = \"KEY_TEXT_FIELD_STORE_VALUE\",\n  VALUE_TEXT_FIELD = \"VALUE_TEXT_FIELD\",\n  QUERY_PARAMS_FIELD = \"QUERY_PARAMS_FIELD\",\n  DOWNLOAD_DATA_FIELD = \"DOWNLOAD_DATA_FIELD\",\n  DOWNLOAD_FILE_NAME_FIELD = \"DOWNLOAD_FILE_NAME_FIELD\",\n  DOWNLOAD_FILE_TYPE_FIELD = \"DOWNLOAD_FILE_TYPE_FIELD\",\n  COPY_TEXT_FIELD = \"COPY_TEXT_FIELD\",\n  NAVIGATION_TARGET_FIELD = \"NAVIGATION_TARGET_FIELD\",\n  WIDGET_NAME_FIELD = \"WIDGET_NAME_FIELD\",\n  RESET_CHILDREN_FIELD = \"RESET_CHILDREN_FIELD\",\n  ARGUMENT_KEY_VALUE_FIELD = \"ARGUMENT_KEY_VALUE_FIELD\",\n  CALLBACK_FUNCTION_FIELD_SET_INTERVAL = \"CALLBACK_FUNCTION_FIELD_SET_INTERVAL\",\n  CALLBACK_FUNCTION_FIELD_GEOLOCATION = \"CALLBACK_FUNCTION_FIELD_GEOLOCATION\",\n  DELAY_FIELD = \"DELAY_FIELD\",\n  ID_FIELD = \"ID_FIELD\",\n  CLEAR_INTERVAL_ID_FIELD = \"CLEAR_INTERVAL_ID_FIELD\",\n  MESSAGE_FIELD = \"MESSAGE_FIELD\",\n  TARGET_ORIGIN_FIELD = \"TARGET_ORIGIN_FIELD\",\n  SOURCE_FIELD = \"SOURCE_FIELD\",\n  PAGE_NAME_AND_URL_TAB_SELECTOR_FIELD = \"PAGE_NAME_AND_URL_TAB_SELECTOR_FIELD\",\n  API_AND_QUERY_SUCCESS_FAILURE_TAB_FIELD = \"API_AND_QUERY_SUCCESS_FAILURE_TAB_FIELD\",\n  CALLBACK_FUNCTION_API_AND_QUERY = \"CALLBACK_FUNCTION_API_AND_QUERY\",\n  ADD_ACTION = \"ADD_ACTION\",\n}\n\nexport const Variants = {\n  mainBlock: \"mainBlock\",\n  callbackBlock: \"callbackBlock\",\n  hoverBorder: \"hoverBorder\",\n};\n","// Leaving this require here. The path-to-regexp module has a commonJS version and an ESM one.\n// We are loading the correct one with the typings with our compilerOptions property \"moduleResolution\" set to \"node\". Ref: https://stackoverflow.com/questions/59013618/unable-to-find-module-path-to-regexp\n// All solutions from closed issues on their repo have been tried. Ref: https://github.com/pillarjs/path-to-regexp/issues/193\n\nimport { matchPath } from \"react-router\";\n\n// eslint-disable-next-line @typescript-eslint/no-var-requires\nconst { match } = require(\"path-to-regexp\");\n\n// Regex to extract the id from the URL path which supports both the formats:\n// 1. With Mongo ObjectIds\n// 2. With UUID\nconst MONGO_OBJECT_ID_REGEX = \"[0-9a-f]{24}\";\nconst UUID_REGEX =\n  \"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\";\n\nexport const ID_EXTRACTION_REGEX = `(${MONGO_OBJECT_ID_REGEX}|${UUID_REGEX})`;\n\nexport const BUILDER_BASE_PATH_DEPRECATED = \"/applications\";\nexport const BUILDER_VIEWER_PATH_PREFIX = \"/app/\";\nexport const BUILDER_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const BUILDER_CUSTOM_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:customSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\nexport const VIEWER_CUSTOM_PATH = `${BUILDER_VIEWER_PATH_PREFIX}:customSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\nexport const getViewerPath = (\n  applicationSlug: string,\n  pageSlug: string,\n  basePageId: string,\n) =>\n  `${BUILDER_VIEWER_PATH_PREFIX}${applicationSlug}/${pageSlug}-${basePageId}`;\nexport const getViewerCustomPath = (customSlug: string, basePageId: string) =>\n  `${BUILDER_VIEWER_PATH_PREFIX}${customSlug}-${basePageId}`;\nexport const BUILDER_PATH_DEPRECATED = `/applications/:baseApplicationId${ID_EXTRACTION_REGEX}/pages/:basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATH_DEPRECATED = `/applications/:baseApplicationId${ID_EXTRACTION_REGEX}/pages/:basePageId${ID_EXTRACTION_REGEX}`;\nexport const VIEWER_PATH_DEPRECATED_REGEX =\n  /\\/applications\\/[^/]+\\/pages\\/[^/]+/;\n\nexport const VIEWER_FORK_PATH = `/fork`;\nexport const INTEGRATION_EDITOR_PATH = `/datasources/:selectedTab`;\n\nexport const WIDGETS_EDITOR_BASE_PATH = `/widgets`;\nexport const WIDGETS_EDITOR_ID_PATH = `${WIDGETS_EDITOR_BASE_PATH}/:widgetIds`;\n\n/*\n * CUSTOM WIDGET BUILDER PATHS\n */\nexport const CUSTOM_WIDGETS_EDITOR_ID_PATH = `${BUILDER_PATH}${WIDGETS_EDITOR_ID_PATH}/builder`;\nexport const CUSTOM_WIDGETS_EDITOR_ID_PATH_CUSTOM = `${BUILDER_CUSTOM_PATH}${WIDGETS_EDITOR_ID_PATH}/builder`;\nexport const CUSTOM_WIDGETS_DEPRECATED_EDITOR_ID_PATH = `${BUILDER_PATH_DEPRECATED}${WIDGETS_EDITOR_ID_PATH}/builder`;\n/* */\n\nexport const API_EDITOR_BASE_PATH = `/api`;\nexport const API_EDITOR_ID_PATH = `${API_EDITOR_BASE_PATH}/:baseApiId`;\nexport const API_EDITOR_ID_ADD_PATH = `${API_EDITOR_BASE_PATH}/:baseApiId/add`;\nexport const API_EDITOR_PATH_WITH_SELECTED_PAGE_ID = `${API_EDITOR_BASE_PATH}?importTo=:importTo`;\nexport const QUERIES_EDITOR_BASE_PATH = `/queries`;\nexport const ADD_PATH = `/add`;\nexport const LIST_PATH = \"/list\";\n\nexport const ENTITY_PATH = \"/:entity\";\nexport const QUERIES_EDITOR_ID_PATH = `${QUERIES_EDITOR_BASE_PATH}/:baseQueryId`;\nexport const QUERIES_EDITOR_ADD_PATH = `${QUERIES_EDITOR_BASE_PATH}${ADD_PATH}`;\nexport const QUERIES_EDITOR_ID_ADD_PATH = `${QUERIES_EDITOR_BASE_PATH}/:baseQueryId/add`;\nexport const JS_COLLECTION_EDITOR_PATH = `/jsObjects`;\nexport const JS_COLLECTION_ID_PATH = `${JS_COLLECTION_EDITOR_PATH}/:baseCollectionId`;\nexport const JS_COLLECTION_ID_ADD_PATH = `${JS_COLLECTION_EDITOR_PATH}/:baseCollectionId/add`;\nexport const DATA_SOURCES_EDITOR_LIST_PATH = `/datasource`;\nexport const DATA_SOURCES_EDITOR_ID_PATH = `/datasource/:datasourceId`;\nexport const APP_LIBRARIES_EDITOR_PATH = `/libraries`;\nexport const APP_PACKAGES_EDITOR_PATH = `/packages`;\nexport const APP_SETTINGS_EDITOR_PATH = `/settings`;\nexport const SAAS_GSHEET_EDITOR_ID_PATH = `/saas/google-sheets-plugin/datasources/:datasourceId`;\nexport const BUILDER_CHECKLIST_PATH = `/checklist`;\nexport const ADMIN_SETTINGS_PATH = \"/settings\";\nexport const ADMIN_SETTINGS_CATEGORY_DEFAULT_PATH = \"/settings/general\";\nexport const ADMIN_SETTINGS_CATEGORY_ACL_PATH = \"/settings/groups\";\nexport const ADMIN_SETTINGS_CATEGORY_AUDIT_LOGS_PATH = \"/settings/audit-logs\";\nexport const ADMIN_SETTINGS_CATEGORY_PATH = \"/settings/:category/:selected?\";\nexport const BUILDER_PATCH_PATH = `/:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}/edit`;\nexport const VIEWER_PATCH_PATH = `/:applicationSlug/:pageSlug(.*\\-):basePageId${ID_EXTRACTION_REGEX}`;\n\nexport const matchApiBasePath = match(API_EDITOR_BASE_PATH);\nexport const matchApiPath = match(API_EDITOR_ID_PATH);\nexport const matchDatasourcePath = (pathname: string) =>\n  matchPath(pathname, {\n    path: [`${BUILDER_PATH}${DATA_SOURCES_EDITOR_ID_PATH}`],\n    strict: false,\n    exact: false,\n  });\n\nexport const matchSAASGsheetsPath = (pathname: string) =>\n  matchPath(pathname, {\n    path: [`${BUILDER_PATH}${SAAS_GSHEET_EDITOR_ID_PATH}`],\n    strict: false,\n    exact: false,\n  });\nexport const matchQueryBasePath = match(QUERIES_EDITOR_BASE_PATH);\nexport const matchQueryPath = match(QUERIES_EDITOR_ID_PATH);\nexport const matchQueryBuilderPath = match(\n  BUILDER_PATH + QUERIES_EDITOR_ID_PATH,\n);\nexport const matchBuilderPath = (\n  pathName: string,\n  options?: { end?: boolean },\n) =>\n  match(BUILDER_PATH, options)(pathName) ||\n  match(BUILDER_PATH_DEPRECATED, options)(pathName) ||\n  match(BUILDER_CUSTOM_PATH, options)(pathName) ||\n  match(BUILDER_PATH + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_CUSTOM_PATH + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_PATH_DEPRECATED + WIDGETS_EDITOR_ID_PATH, options)(pathName) ||\n  match(BUILDER_PATH + WIDGETS_EDITOR_ID_PATH + ADD_PATH, options)(pathName);\n\nexport const matchJSObjectPath = match(JS_COLLECTION_ID_PATH);\nexport const matchViewerPath = (pathName: string) =>\n  match(VIEWER_PATH)(pathName) ||\n  match(VIEWER_PATH_DEPRECATED)(pathName) ||\n  match(VIEWER_CUSTOM_PATH)(pathName);\nexport const matchViewerForkPath = (pathName: string) =>\n  match(`${VIEWER_PATH}${VIEWER_FORK_PATH}`)(pathName) ||\n  match(`${VIEWER_CUSTOM_PATH}${VIEWER_FORK_PATH}`)(pathName) ||\n  match(`${VIEWER_PATH_DEPRECATED}${VIEWER_FORK_PATH}`)(pathName);\n\nexport const matchAppLibrariesPath = (pathName: string) =>\n  match(`${BUILDER_PATH}${APP_LIBRARIES_EDITOR_PATH}`)(pathName);\n\nexport const matchAppPackagesPath = (pathName: string) =>\n  match(`${BUILDER_PATH}${APP_PACKAGES_EDITOR_PATH}`)(pathName);\n\nexport const addBranchParam = (branch: string) => {\n  const url = new URL(window.location.href);\n\n  url.searchParams.set(GIT_BRANCH_QUERY_KEY, encodeURIComponent(branch));\n\n  return url.toString().slice(url.origin.length);\n};\n\nexport interface BuilderRouteParams {\n  basePageId: string;\n  baseApplicationId: string;\n}\n\nexport interface AppViewerRouteParams {\n  basePageId: string;\n  baseApplicationId?: string;\n}\n\nexport interface APIEditorRouteParams {\n  basePageId: string;\n  baseApiId?: string;\n}\n\nexport interface QueryEditorRouteParams {\n  basePageId: string;\n  baseQueryId?: string;\n  baseApiId?: string;\n}\n\nexport interface JSEditorRouteParams {\n  basePageId: string;\n  baseCollectionId?: string;\n}\n\nexport const GIT_BRANCH_QUERY_KEY = \"branch\";\n\nexport const INTEGRATION_TABS = {\n  ACTIVE: \"ACTIVE\",\n  NEW: \"NEW\",\n};\n\nexport const INTEGRATION_EDITOR_MODES = {\n  AUTO: \"auto\",\n  MOCK: \"mock\",\n};\n\nexport const PLACEHOLDER_APP_SLUG = \"application\";\nexport const PLACEHOLDER_PAGE_ID = \"basePageId\";\nexport const PLACEHOLDER_PAGE_SLUG = \"page\";\n\nexport const SHOW_FILE_PICKER_KEY = \"showPicker\";\nexport const RESPONSE_STATUS = \"response_status\";\n\nexport const basePathForActiveAction = [BUILDER_PATH, BUILDER_PATH_DEPRECATED];\n","import { difference } from \"lodash\";\nimport { isChildPropertyPath } from \"utils/DynamicBindingUtils\";\nimport { sort } from \"fast-sort\";\n\nexport type TDependencies = Map<string, Set<string>>;\nexport default class DependencyMap {\n  #nodes: Map<string, true>;\n  #dependencies: TDependencies;\n  #dependenciesInverse: TDependencies;\n  #invalidDependencies: TDependencies;\n  #invalidDependenciesInverse: TDependencies;\n\n  constructor() {\n    this.#nodes = new Map();\n    this.#dependencies = new Map();\n    this.#invalidDependencies = new Map();\n    this.#dependenciesInverse = new Map();\n    this.#invalidDependenciesInverse = new Map();\n  }\n\n  // Returns all nodes in the graph\n  get nodes() {\n    return Object.fromEntries(this.#nodes);\n  }\n\n  // Returns all edges in the graph\n  get dependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#dependencies.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get inverseDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#dependenciesInverse.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get invalidDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#invalidDependencies.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  get inverseInvalidDependencies() {\n    const deps: Record<string, string[]> = {};\n\n    for (const [key, value] of this.#invalidDependenciesInverse.entries()) {\n      deps[key] = Array.from(value);\n    }\n\n    return deps;\n  }\n\n  /**\n   * Adds new dependencies to the graph.\n   * Iterates over the dependencies and adds them to the graph if they it is a valid node.\n   * If the dependency is not a valid node, it is added to the invalid dependencies and inverse invalid dependency.\n   * @param node\n   * @param dependencies\n   */\n  public addDependency = (node: string, dependencies: string[]) => {\n    // Only add dependencies for nodes present in the graph\n    if (!this.#nodes.has(node)) return;\n\n    const validDependencies = new Set<string>();\n    const invalidDependencies = new Set<string>();\n\n    // Update the validDependencies and invalidDependencies\n    // Valid dependencies are dependencies present in this.#node, otherwise, they are invalid.\n    for (const dependency of dependencies) {\n      if (this.#nodes.has(dependency)) {\n        validDependencies.add(dependency);\n\n        if (this.#dependenciesInverse.has(dependency)) {\n          this.#dependenciesInverse.get(dependency)?.add(node);\n        } else {\n          this.#dependenciesInverse.set(dependency, new Set([node]));\n        }\n      } else {\n        invalidDependencies.add(dependency);\n\n        if (this.#invalidDependenciesInverse.has(dependency)) {\n          this.#invalidDependenciesInverse.get(dependency)?.add(node);\n        } else {\n          this.#invalidDependenciesInverse.set(dependency, new Set([node]));\n        }\n      }\n    }\n\n    // Now that we have created a new set of dependencies, and invalid dependencies for the node,\n    // we need to remove the node from the inverse-dependencies of previous invalidDeps and validDeps, which have been removed.\n\n    const previousNodeDependencies =\n      this.#dependencies.get(node) || new Set<string>();\n    const newNodeDependencies = validDependencies;\n\n    // dependencies removed from path\n    const removedNodeDependencies = difference(\n      Array.from(previousNodeDependencies),\n      Array.from(newNodeDependencies),\n    );\n\n    // Remove node from the inverseDependencies of removed deps\n    for (const removedDependency of removedNodeDependencies) {\n      this.#dependenciesInverse.get(removedDependency)?.delete(node);\n    }\n\n    const previousNodeInvalidDependencies =\n      this.#invalidDependencies.get(node) || new Set<string>();\n    const newNodeInvalidDependencies = invalidDependencies;\n\n    // invalid dependencies removed from path\n    const removedNodeInvalidDependencies = difference(\n      Array.from(previousNodeInvalidDependencies),\n      Array.from(newNodeInvalidDependencies),\n    );\n\n    // Remove node from the inverseDependencies of removed invalidDeps\n    for (const removedInvalidDependency of removedNodeInvalidDependencies) {\n      this.#invalidDependenciesInverse\n        .get(removedInvalidDependency)\n        ?.delete(node);\n    }\n\n    // Now set the new deps and invalidDeps\n    this.#dependencies.set(node, validDependencies);\n    this.#invalidDependencies.set(node, invalidDependencies);\n  };\n\n  private removeDependency = (node: string) => {\n    let didUpdateDependencies = false;\n    const directDependenciesOfNode = this.getDirectDependencies(node);\n\n    for (const directDependency of directDependenciesOfNode) {\n      this.#dependenciesInverse.get(directDependency)?.delete(node);\n      didUpdateDependencies = true;\n    }\n\n    const nodeExistedInDependencies = this.#dependencies.delete(node);\n\n    if (nodeExistedInDependencies) {\n      didUpdateDependencies = true;\n    }\n\n    this.#invalidDependencies.delete(node);\n\n    return didUpdateDependencies;\n  };\n\n  /**\n   * Adds new nodes to the graph. Should be called when a new node is added to the graph.\n   * Iterates over the nodes and checks in the invalid dependency map, to see if it was used earlier.\n   * If it was used earlier, it is added to the valid dependencies and removed from the invalid dependencies.\n   * @param nodes\n   */\n\n  addNodes = (nodes: Record<string, true>, strict = true) => {\n    const nodesToAdd = strict\n      ? Object.keys(nodes)\n      : sort(Object.keys(nodes)).desc((node) => node.split(\".\").length);\n\n    let didUpdateGraph = false;\n\n    for (const newNode of nodesToAdd) {\n      if (this.#nodes.has(newNode)) continue;\n\n      // New node introduced to the graph.\n      this.#nodes.set(newNode, true);\n      // Check the paths that consumed this node before it was introduced.\n      const nodesThatAlreadyDependedOnThis =\n        this.#invalidDependenciesInverse.get(newNode) || new Set<string>();\n\n      if (!strict) {\n        // In non-strict mode, when the newly added path is a parent of an invalid node,\n        // all paths depending on the invalid node should be added as paths depending on new path\n        // Example => if Button1.text depends on Api1.data.invalidNode(which doesn't exist), if Api1.data is newly added,\n        // then Button1.text should be added to paths that depend on Api1.data\n\n        for (const [invalidNode, dependants] of this\n          .#invalidDependenciesInverse) {\n          if (\n            !nodes.hasOwnProperty(invalidNode) &&\n            isChildPropertyPath(newNode, invalidNode, true)\n          ) {\n            dependants.forEach((dependant) => {\n              nodesThatAlreadyDependedOnThis.add(dependant);\n              this.#invalidDependencies.get(dependant)?.delete(invalidNode);\n            });\n            this.#invalidDependenciesInverse.delete(invalidNode);\n          }\n        }\n      }\n\n      for (const iNode of nodesThatAlreadyDependedOnThis) {\n        // since the invalid node is now valid, add it to the valid dependencies.\n        this.#dependencies.get(iNode)?.add(newNode);\n        this.#invalidDependencies.get(iNode)?.delete(newNode);\n        didUpdateGraph = true;\n\n        if (this.#dependenciesInverse.has(newNode)) {\n          this.#dependenciesInverse.get(newNode)?.add(iNode);\n        } else {\n          this.#dependenciesInverse.set(newNode, new Set([iNode]));\n        }\n      }\n\n      this.#invalidDependenciesInverse.delete(newNode);\n    }\n\n    return didUpdateGraph;\n  };\n\n  removeNodes = (nodes: Record<string, true>) => {\n    let didUpdateDependencies = false;\n\n    for (const node of Object.keys(nodes)) {\n      if (!this.#nodes.has(node)) continue;\n\n      // Remove node from the graph.\n      this.#nodes.delete(node);\n      // Check the paths that consumed this node before it was removed.\n      const nodesThatAlreadyDependedOnThis =\n        this.#dependenciesInverse.get(node) || [];\n\n      for (const iNode of nodesThatAlreadyDependedOnThis) {\n        // since the valid node is now invalid, add it to the invalid dependencies.\n        this.#invalidDependencies.get(iNode)?.add(node);\n        this.#dependencies.get(iNode)?.delete(node);\n        didUpdateDependencies = true;\n\n        if (!this.#nodes.has(iNode)) continue;\n\n        if (this.#invalidDependenciesInverse.has(node)) {\n          this.#invalidDependenciesInverse.get(node)?.add(iNode);\n        } else {\n          this.#invalidDependenciesInverse.set(node, new Set([iNode]));\n        }\n      }\n\n      this.#dependenciesInverse.delete(node);\n      const nodeExistedInDependencies = this.removeDependency(node);\n\n      if (nodeExistedInDependencies) didUpdateDependencies = true;\n    }\n\n    return didUpdateDependencies;\n  };\n\n  isRelated = (source: string, targets: string[]) => {\n    if (targets.includes(source)) return true;\n\n    const visited = new Set();\n    const queue = [source];\n\n    while (queue.length) {\n      const node = queue.shift() as string;\n\n      if (visited.has(node)) continue;\n\n      visited.add(node);\n\n      if (targets.includes(node)) return true;\n\n      const nodes = this.#dependencies.get(node) || [];\n\n      for (const n of nodes) {\n        queue.push(n);\n      }\n    }\n\n    return false;\n  };\n\n  getDependents(node: string) {\n    const nodes = this.#dependenciesInverse.get(node);\n\n    return Array.from(nodes || []);\n  }\n  getDirectDependencies(node: string) {\n    const nodes = this.#dependencies.get(node);\n\n    return Array.from(nodes || []);\n  }\n\n  getAllReachableNodes(source: string, targets: string[]) {\n    const reachableNodes: string[] = [];\n\n    if (targets.includes(source)) reachableNodes.push(source);\n\n    const visited = new Set();\n    const queue = [source];\n\n    while (queue.length) {\n      const node = queue.shift() as string;\n\n      if (visited.has(node)) continue;\n\n      visited.add(node);\n\n      if (targets.includes(node)) reachableNodes.push(node);\n\n      const nodes = this.#dependencies.get(node) || [];\n\n      for (const n of nodes) {\n        queue.push(n);\n      }\n    }\n\n    return reachableNodes;\n  }\n  get rawDependencies() {\n    return this.#dependencies;\n  }\n}\n","import type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { LintErrorsStore } from \"reducers/lintingReducers/lintErrorsReducers\";\nimport type {\n  createEvaluationContext,\n  EvaluationScriptType,\n} from \"workers/Evaluation/evaluate\";\nimport type { DependencyMap } from \"utils/DynamicBindingUtils\";\nimport type { TJSPropertiesState } from \"workers/Evaluation/JSObject/jsPropertiesState\";\nimport type { JSLibrary } from \"workers/common/JSLibrary\";\nimport type { WebworkerSpanData, Attributes } from \"instrumentation/types\";\nimport type { LINTER_TYPE } from \"./constants\";\n\nexport type WebworkerTelemetryAttribute = WebworkerSpanData | Attributes;\n\nexport enum LINT_WORKER_ACTIONS {\n  LINT_TREE = \"LINT_TREE\",\n  UPDATE_LINT_GLOBALS = \"UPDATE_LINT_GLOBALS\",\n  SETUP = \"SETUP\",\n}\nexport interface LintTreeResponse {\n  errors: LintErrorsStore;\n  lintedJSPaths: string[];\n  jsPropertiesState: TJSPropertiesState;\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n}\n\nexport interface LintTreeRequestPayload {\n  unevalTree: DataTree;\n  configTree: ConfigTree;\n  cloudHosting: boolean;\n  forceLinting?: boolean;\n}\n\nexport interface LintRequest<T> {\n  data: T;\n  method: LINT_WORKER_ACTIONS;\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n}\n\nexport interface LintTreeSagaRequestData {\n  unevalTree: DataTree;\n  configTree: ConfigTree;\n  forceLinting?: boolean;\n}\nexport interface lintTriggerPathProps {\n  userScript: string;\n  entity: DataTreeEntity;\n  globalData: ReturnType<typeof createEvaluationContext>;\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n}\nexport interface lintBindingPathProps {\n  dynamicBinding: string;\n  entity: DataTreeEntity;\n  fullPropertyPath: string;\n  globalData: ReturnType<typeof createEvaluationContext>;\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n}\nexport interface getLintingErrorsProps {\n  script: string;\n  data: Record<string, unknown>;\n  // {{user's code}}\n  originalBinding: string;\n  scriptType: EvaluationScriptType;\n  options?: {\n    isJsObject: boolean;\n  };\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n  getLinterTypeFn?: () => LINTER_TYPE;\n}\n\nexport interface getLintErrorsFromTreeProps {\n  pathsToLint: string[];\n  unEvalTree: DataTree;\n  jsPropertiesState: TJSPropertiesState;\n  cloudHosting: boolean;\n  asyncJSFunctionsInDataFields: DependencyMap;\n  configTree: ConfigTree;\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>;\n}\n\nexport interface getLintErrorsFromTreeResponse {\n  errors: LintErrorsStore;\n  lintedJSPaths: string[];\n}\n\nexport interface updateJSLibraryProps {\n  add?: boolean;\n  libs: JSLibrary[];\n}\n","import _ from \"./lodash-wrapper\";\nimport moment from \"moment-timezone\";\nimport forge from \"node-forge\";\nimport { defaultLibraries, JSLibraryAccessor } from \"./index\";\nimport { JSLibraries, libraryReservedIdentifiers } from \"./index\";\nimport { invalidEntityIdentifiers } from \"../DependencyMap/utils\";\nconst defaultLibImplementations = {\n  lodash: _,\n  moment: moment,\n  // We are removing some functionalities of node-forge because they wont\n  // work in the worker thread\n  forge: /*#__PURE*/ _.omit(forge, [\"tls\", \"http\", \"xhr\", \"socket\", \"task\"]),\n};\n\nexport function resetJSLibraries() {\n  JSLibraries.length = 0;\n  JSLibraries.push(...defaultLibraries);\n  const defaultLibraryAccessors = defaultLibraries.map(\n    (lib) => lib.accessor[0],\n  );\n\n  for (const key of Object.keys(libraryReservedIdentifiers)) {\n    if (defaultLibraryAccessors.includes(key)) continue;\n\n    try {\n      // @ts-expect-error: Types are not available\n      delete self[key];\n    } catch (e) {\n      // @ts-expect-error: Types are not available\n      self[key] = undefined;\n    }\n    //we have to update invalidEntityIdentifiers as well\n    delete libraryReservedIdentifiers[key];\n    delete invalidEntityIdentifiers[key];\n  }\n\n  JSLibraries.forEach((library) => {\n    if (!(library.name in defaultLibImplementations))\n      throw new Error(\n        `resetJSLibraries(): implementation for library ${library.name} not found. Have you forgotten to add it to the defaultLibrariesImpls object?`,\n      );\n\n    // @ts-expect-error: Types are not available\n    self[library.accessor] = defaultLibImplementations[library.name];\n  });\n  JSLibraryAccessor.regenerateSet();\n}\n","import type { Diff } from \"deep-diff\";\n\nexport const ENTITY_TYPE = {\n  ACTION: \"ACTION\",\n  WIDGET: \"WIDGET\",\n  APPSMITH: \"APPSMITH\",\n  JSACTION: \"JSACTION\",\n};\n\ntype ValueOf<T> = T[keyof T];\nexport type EntityTypeValue = ValueOf<typeof ENTITY_TYPE>;\n\nexport interface IEntity {\n  getName(): string;\n  getId(): string;\n  getType(): EntityTypeValue;\n  getRawEntity(): unknown;\n  getConfig(): unknown;\n  computeDifference(entity?: IEntity): Diff<unknown>[] | undefined;\n}\n","import type { TParsedJSProperty } from \"@shared/ast\";\nimport type { Diff } from \"deep-diff\";\nimport { diff } from \"deep-diff\";\nimport type { jsLintEntityParser } from \"./entityParser\";\nimport type { IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { JSEntity } from \"plugins/Linting/lib/entity/JSActionEntity\";\n\nexport interface EntityDiffGenerator {\n  generate(\n    baseEntity?: IEntity,\n    compareEntity?: IEntity,\n  ): Diff<unknown>[] | undefined;\n}\n\nexport class DefaultDiffGenerator implements EntityDiffGenerator {\n  generate(baseEntity?: IEntity, compareEntity?: IEntity) {\n    return diff(\n      this.generateDiffObj(baseEntity),\n      this.generateDiffObj(compareEntity),\n    );\n  }\n  generateDiffObj(entity?: IEntity) {\n    if (!entity) {\n      return {};\n    }\n\n    return { [entity.getName()]: entity.getRawEntity() };\n  }\n}\n\nexport class JSLintDiffGenerator implements EntityDiffGenerator {\n  generate(baseEntity?: JSEntity, compareEntity?: JSEntity) {\n    return diff(\n      this.generateDiffObj(baseEntity),\n      this.generateDiffObj(compareEntity),\n    );\n  }\n  generateDiffObj(entity?: JSEntity) {\n    if (!entity) {\n      return {};\n    }\n\n    const entityForDiff: Record<string, string> = {};\n\n    for (const [propertyName, propertyValue] of Object.entries(\n      entity.getRawEntity(),\n    )) {\n      const jsParser = entity.entityParser as typeof jsLintEntityParser;\n      const { parsedEntityConfig } = jsParser.parse(\n        entity.getRawEntity(),\n        entity.getConfig(),\n      );\n\n      if (!parsedEntityConfig) continue;\n\n      entityForDiff[propertyName] = this.getHashedConfigString(\n        propertyValue,\n        parsedEntityConfig[propertyName] as TParsedJSProperty,\n      );\n    }\n\n    return { [entity.getName()]: entityForDiff };\n  }\n\n  getHashedConfigString(propertyValue: string, config: TParsedJSProperty) {\n    if (!config || !config.position || !config.value) return propertyValue;\n\n    const { endColumn, endLine, startColumn, startLine } = config.position;\n\n    return config.value + `${startColumn}${endColumn}${startLine}${endLine}`;\n  }\n}\n\nexport const jsLintDiffGenerator = new JSLintDiffGenerator();\nexport const defaultDiffGenerator = new DefaultDiffGenerator();\n","import type {\n  JSActionEntity as TJSActionEntity,\n  JSActionEntityConfig as TJSActionEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport {\n  defaultDiffGenerator,\n  type EntityDiffGenerator,\n} from \"plugins/Linting/utils/diffGenerator\";\nimport type { EntityParser } from \"plugins/Linting/utils/entityParser\";\nimport type { TParsedJSProperty } from \"@shared/ast\";\nimport { isJSFunctionProperty } from \"@shared/ast\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { Diff } from \"deep-diff\";\n\nexport class JSEntity implements IEntity {\n  entity: TJSActionEntity;\n  private config: TJSActionEntityConfig;\n  entityParser: EntityParser;\n  diffGenerator: EntityDiffGenerator = defaultDiffGenerator;\n\n  constructor(\n    entity: TJSActionEntity,\n    config: TJSActionEntityConfig,\n    entityParser: EntityParser,\n    diffGenerator: EntityDiffGenerator,\n  ) {\n    entityParser.parse(entity, config);\n    this.entity = entity;\n    this.config = config;\n    this.entityParser = entityParser;\n    this.diffGenerator = diffGenerator;\n  }\n  getType() {\n    return ENTITY_TYPE.JSACTION;\n  }\n  getRawEntity() {\n    return this.entity;\n  }\n  getConfig() {\n    return this.config;\n  }\n  getName() {\n    return this.config.name;\n  }\n  getId() {\n    return this.config.actionId;\n  }\n  isEqual(body: string) {\n    return body === this.getRawEntity().body;\n  }\n  computeDifference(oldEntity?: IEntity): Diff<unknown>[] | undefined {\n    return this.diffGenerator.generate(oldEntity, this);\n  }\n  getFns() {\n    const jsFunctions = [];\n    const { parsedEntity, parsedEntityConfig } = this.entityParser.parse(\n      this.entity,\n      this.config,\n    );\n\n    for (const propertyName of Object.keys(parsedEntityConfig)) {\n      const jsPropertyConfig = parsedEntityConfig[\n        propertyName\n      ] as TParsedJSProperty;\n      const jsPropertyFullName = `${this.getName()}.${propertyName}`;\n\n      if (!isJSFunctionProperty(jsPropertyConfig)) continue;\n\n      jsFunctions.push({\n        name: jsPropertyFullName,\n        body: parsedEntity[propertyName],\n        isMarkedAsync: jsPropertyConfig.isMarkedAsync,\n      });\n    }\n\n    return jsFunctions;\n  }\n}\n","import type {\n  ActionEntity as TActionEntity,\n  ActionEntityConfig as TActionEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport {\n  defaultDiffGenerator,\n  type EntityDiffGenerator,\n} from \"plugins/Linting/utils/diffGenerator\";\nimport type { EntityParser } from \"plugins/Linting/utils/entityParser\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { Diff } from \"deep-diff\";\n\nexport class ActionEntity implements IEntity {\n  private entity: TActionEntity;\n  private config: TActionEntityConfig;\n  entityParser: EntityParser;\n  diffGenerator: EntityDiffGenerator = defaultDiffGenerator;\n  constructor(\n    entity: TActionEntity,\n    config: TActionEntityConfig,\n    entityParser: EntityParser,\n    diffGenerator: EntityDiffGenerator,\n  ) {\n    this.entity = entity;\n    this.config = config;\n    this.entityParser = entityParser;\n    this.diffGenerator = diffGenerator;\n  }\n  getType() {\n    return ENTITY_TYPE.ACTION;\n  }\n  getRawEntity() {\n    return this.entityParser.parse(this.entity, this.config).parsedEntity;\n  }\n  getName() {\n    return this.config.name;\n  }\n  getId() {\n    return this.config.actionId;\n  }\n  getConfig() {\n    return this.config;\n  }\n  computeDifference(oldEntity?: IEntity): Diff<unknown>[] | undefined {\n    return this.diffGenerator.generate(oldEntity, this);\n  }\n}\n","import type { AppsmithEntity as TAppsmithEntity } from \"ee/entities/DataTree/types\";\nimport type { EntityDiffGenerator } from \"plugins/Linting/utils/diffGenerator\";\nimport type { EntityParser } from \"plugins/Linting/utils/entityParser\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { Diff } from \"deep-diff\";\n\nexport class AppsmithEntity implements IEntity {\n  private entity: TAppsmithEntity;\n  private config: undefined;\n  entityParser: EntityParser;\n  diffGenerator: EntityDiffGenerator;\n  constructor(\n    entity: TAppsmithEntity,\n    config: undefined,\n    entityParser: EntityParser,\n    diffGenerator: EntityDiffGenerator,\n  ) {\n    this.entity = entity;\n    this.config = config;\n    this.entityParser = entityParser;\n    this.diffGenerator = diffGenerator;\n  }\n  getType() {\n    return ENTITY_TYPE.APPSMITH;\n  }\n  getConfig() {\n    return this.config;\n  }\n  getRawEntity(): TAppsmithEntity {\n    return this.entity;\n  }\n  getName() {\n    return \"appsmith\";\n  }\n  getId(): string {\n    return \"appsmith\";\n  }\n  computeDifference(oldEntity?: IEntity): Diff<unknown>[] | undefined {\n    return this.diffGenerator.generate(oldEntity, this);\n  }\n}\n","import type {\n  WidgetEntity as TWidgetEntity,\n  WidgetEntityConfig as TWidgetEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport {\n  defaultDiffGenerator,\n  type EntityDiffGenerator,\n} from \"plugins/Linting/utils/diffGenerator\";\nimport type { EntityParser } from \"plugins/Linting/utils/entityParser\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { Diff } from \"deep-diff\";\n\nexport class WidgetEntity implements IEntity {\n  private entity: TWidgetEntity;\n  private config: TWidgetEntityConfig;\n  entityParser: EntityParser;\n  diffGenerator: EntityDiffGenerator = defaultDiffGenerator;\n  constructor(\n    entity: TWidgetEntity,\n    config: TWidgetEntityConfig,\n    entityParser: EntityParser,\n    diffGenerator: EntityDiffGenerator,\n  ) {\n    this.entity = entity;\n    this.config = config;\n    this.entityParser = entityParser;\n    this.diffGenerator = diffGenerator;\n  }\n  getType() {\n    return ENTITY_TYPE.WIDGET;\n  }\n  getRawEntity() {\n    return this.entityParser.parse(this.entity, this.config).parsedEntity;\n  }\n  getName() {\n    return this.entity.widgetName;\n  }\n  getId() {\n    return this.config.widgetId as string;\n  }\n  getConfig() {\n    return this.config;\n  }\n  computeDifference(oldEntity?: IEntity): Diff<unknown>[] | undefined {\n    return this.diffGenerator.generate(oldEntity, this);\n  }\n}\n","import type {\n  WidgetEntity as TWidgetEntity,\n  AppsmithEntity as TAppsmithEntity,\n  DataTreeEntityConfig,\n  WidgetEntityConfig as TWidgetEntityConfig,\n  JSActionEntity as TJSActionEntity,\n  ActionEntity as TActionEntity,\n  ActionEntityConfig as TActionEntityConfig,\n  JSActionEntityConfig as TJSActionEntityConfig,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type { EntityClassLoader } from \"plugins/Linting/lib/entity/EntityTree\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport { JSEntity } from \"plugins/Linting/lib/entity/JSActionEntity\";\nimport { ActionEntity } from \"plugins/Linting/lib/entity/ActionEntity\";\nimport { AppsmithEntity } from \"plugins/Linting/lib/entity/AppsmithEntity\";\nimport { WidgetEntity } from \"plugins/Linting/lib/entity/WidgetEntity\";\nimport {\n  isAction,\n  isJSAction,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\n\nexport default class EntityFactory {\n  static getEntity<\n    T extends DataTreeEntity,\n    K extends DataTreeEntityConfig | undefined,\n  >(entity: T, config: K, classLoader: EntityClassLoader): IEntity {\n    const { DiffGenerator, Parser } = classLoader.load(\n      entity as DataTreeEntity,\n    );\n\n    if (isWidget(entity)) {\n      return new WidgetEntity(\n        entity as TWidgetEntity,\n        config as TWidgetEntityConfig,\n        new Parser(),\n        new DiffGenerator(),\n      );\n    } else if (isJSAction(entity)) {\n      return new JSEntity(\n        entity as TJSActionEntity,\n        config as TJSActionEntityConfig,\n        new Parser(),\n        new DiffGenerator(),\n      );\n    } else if (isAction(entity)) {\n      return new ActionEntity(\n        entity as TActionEntity,\n        config as TActionEntityConfig,\n        new Parser(),\n        new DiffGenerator(),\n      );\n    } else {\n      return new AppsmithEntity(\n        entity as TAppsmithEntity,\n        undefined,\n        new Parser(),\n        new DiffGenerator(),\n      );\n    }\n  }\n}\n\nexport function isJSEntity(entity: IEntity): entity is JSEntity {\n  return entity.getType() === ENTITY_TYPE.JSACTION;\n}\nexport function isActionEntity(entity: IEntity): entity is ActionEntity {\n  return entity.getType() === ENTITY_TYPE.ACTION;\n}\nexport function isAppsmithEntity(entity: IEntity): entity is AppsmithEntity {\n  return entity.getType() === ENTITY_TYPE.APPSMITH;\n}\nexport function isWidgetEntity(entity: IEntity): entity is WidgetEntity {\n  return entity.getType() === ENTITY_TYPE.WIDGET;\n}\n","export * from \"ce/plugins/Linting/lib/entity/index\";\nimport { default as CE_EntityFactory } from \"ce/plugins/Linting/lib/entity\";\nexport default CE_EntityFactory;\n","import type { ActionEntity } from \"plugins/Linting/lib/entity/ActionEntity\";\nimport type { JSEntity } from \"plugins/Linting/lib/entity/JSActionEntity\";\nimport type { WidgetEntity } from \"plugins/Linting/lib/entity/WidgetEntity\";\nimport { ENTITY_TYPE, type IEntity } from \"ee/plugins/Linting/lib/entity/types\";\n\nexport type DynamicEntityType = JSEntity | WidgetEntity | ActionEntity;\n// only Widgets, jsActions and Actions have paths that can be dynamic\nexport function isDynamicEntity(entity: IEntity): entity is DynamicEntityType {\n  return [\n    ENTITY_TYPE.JSACTION,\n    ENTITY_TYPE.WIDGET,\n    ENTITY_TYPE.ACTION,\n  ].includes(entity.getType());\n}\n","import { isWidgetEntity } from \"ee/plugins/Linting/lib/entity\";\nimport {\n  convertPathToString,\n  getEntityNameAndPropertyPath,\n  isTrueObject,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport { toPath, union } from \"lodash\";\nimport { isDynamicEntity } from \"ee/plugins/Linting/lib/entity/isDynamicEntity\";\nimport type { IEntity } from \"ee/plugins/Linting/lib/entity/types\";\n\nexport class PathUtils {\n  static getReactivePaths(entity: IEntity) {\n    if (!isDynamicEntity(entity)) return [];\n\n    const config = entity.getConfig();\n    const name = entity.getName();\n    const reactivePaths = config.reactivePaths;\n\n    if (!reactivePaths) return [];\n\n    return PathUtils.getFullNamesFromPropertyPaths(\n      Object.keys(reactivePaths),\n      name,\n    );\n  }\n  static getBindingPaths(entity: IEntity) {\n    if (!isDynamicEntity(entity)) return [];\n\n    const config = entity.getConfig();\n    const name = entity.getName();\n    const bindingPaths = config.bindingPaths;\n\n    if (!bindingPaths) return [];\n\n    return PathUtils.getFullNamesFromPropertyPaths(\n      Object.keys(bindingPaths),\n      name,\n    );\n  }\n\n  static getTriggerPaths(entity: IEntity) {\n    if (!isWidgetEntity(entity)) return [];\n\n    const config = entity.getConfig();\n    const name = entity.getName();\n    const triggerPaths = config.triggerPaths;\n\n    return PathUtils.getFullNamesFromPropertyPaths(\n      Object.keys(triggerPaths),\n      name,\n    );\n  }\n\n  static getDynamicPaths(entity: IEntity) {\n    if (!isDynamicEntity(entity)) return [];\n\n    const reactivePaths = PathUtils.getReactivePaths(entity);\n    const triggerPaths = PathUtils.getTriggerPaths(entity);\n    const bindingPaths = PathUtils.getBindingPaths(entity);\n\n    return union(reactivePaths, triggerPaths, bindingPaths);\n  }\n  static getFullNamesFromPropertyPaths(paths: string[], parentName: string) {\n    return paths.map((path) => `${parentName}.${path}`);\n  }\n  static isDataPath(fullPath: string, entity: IEntity) {\n    if (!isWidgetEntity(entity) || !this.isDynamicLeaf(entity, fullPath))\n      return false;\n\n    const entityConfig = entity.getConfig();\n    const { propertyPath } = getEntityNameAndPropertyPath(fullPath);\n\n    return !(propertyPath in entityConfig.triggerPaths);\n  }\n  static getDataPaths(entity: IEntity) {\n    if (!isWidgetEntity(entity)) return [];\n\n    return PathUtils.getBindingPaths(entity);\n  }\n  static isDynamicLeaf(entity: IEntity, fullPropertyPath: string) {\n    const [entityName, ...propPathEls] = toPath(fullPropertyPath);\n\n    // Framework feature: Top level items are never leaves\n    if (entityName === fullPropertyPath) return false;\n\n    const entityConfig = entity.getConfig() as Record<string, unknown>;\n\n    if (!entityConfig) return false;\n\n    const reactivePaths = entityConfig.reactivePaths as Record<string, unknown>;\n\n    if (!isDynamicEntity(entity) || !entityConfig) return false;\n\n    const relativePropertyPath = convertPathToString(propPathEls);\n\n    return (\n      relativePropertyPath in reactivePaths ||\n      (isWidgetEntity(entity) &&\n        relativePropertyPath in entity.getConfig().triggerPaths)\n    );\n  }\n\n  static getAllPaths = (\n    // TODO: Fix this the next time the file is edited\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    records: any,\n    curKey = \"\",\n    result: Record<string, true> = {},\n  ): Record<string, true> => {\n    if (curKey) result[curKey] = true;\n\n    if (Array.isArray(records)) {\n      for (let i = 0; i < records.length; i++) {\n        const tempKey = curKey ? `${curKey}[${i}]` : `${i}`;\n\n        PathUtils.getAllPaths(records[i], tempKey, result);\n      }\n    } else if (isTrueObject(records)) {\n      for (const key of Object.keys(records)) {\n        const tempKey = curKey ? `${curKey}.${key}` : `${key}`;\n\n        PathUtils.getAllPaths(records[key], tempKey, result);\n      }\n    }\n\n    return result;\n  };\n}\n","import { mergeWith, union } from \"lodash\";\nimport type { DependencyMap } from \"utils/DynamicBindingUtils\";\n\nexport function mergeMaps(firstMap: DependencyMap, secondMap: DependencyMap) {\n  return mergeWith(\n    firstMap,\n    secondMap,\n    (firstVal: string[], secondVal: string[]) => {\n      return union(firstVal, secondVal);\n    },\n  );\n}\n","import {\n  addWidgetPropertyDependencies,\n  convertPathToString,\n  getEntityNameAndPropertyPath,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport type { DependencyMap as TDependencyMap } from \"utils/DynamicBindingUtils\";\nimport { getPropertyPath } from \"utils/DynamicBindingUtils\";\nimport { getDynamicBindings } from \"utils/DynamicBindingUtils\";\nimport { getEntityDynamicBindingPathList } from \"utils/DynamicBindingUtils\";\nimport { mergeMaps } from \"plugins/Linting/utils/mergeMaps\";\nimport { flatten, get, has, isString, toPath, union, uniq } from \"lodash\";\nimport { extractIdentifierInfoFromCode } from \"@shared/ast\";\nimport { PathUtils } from \"plugins/Linting/utils/pathUtils\";\n\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type { ActionEntity } from \"plugins/Linting/lib/entity/ActionEntity\";\nimport type { JSEntity } from \"plugins/Linting/lib/entity/JSActionEntity\";\nimport type { WidgetEntity } from \"plugins/Linting/lib/entity/WidgetEntity\";\nimport type { IEntity } from \"ee/plugins/Linting/lib/entity/types\";\n\nexport const getDependencies: Record<\n  string,\n  (entity: IEntity) => TDependencyMap\n> = {\n  [ENTITY_TYPE.ACTION]: (entity) =>\n    getActionDependencies(entity as ActionEntity),\n  [ENTITY_TYPE.JSACTION]: (entity) => getJSDependencies(entity as JSEntity),\n  [ENTITY_TYPE.WIDGET]: (entity) =>\n    getWidgetDependencies(entity as WidgetEntity),\n};\n\nexport const getPathDependencies: Record<\n  string,\n  (entity: IEntity, fullPropertyPath: string) => TDependencyMap\n> = {\n  [ENTITY_TYPE.ACTION]: (entity, fullPropertyPath) =>\n    getActionPropertyPathDependencies(entity as ActionEntity, fullPropertyPath),\n  [ENTITY_TYPE.JSACTION]: (entity, fullPropertyPath) =>\n    getJSPropertyPathDependencies(entity as JSEntity, fullPropertyPath),\n  [ENTITY_TYPE.WIDGET]: (entity, fullPropertyPath) =>\n    getWidgetPropertyPathDependencies(entity as WidgetEntity, fullPropertyPath),\n};\n\nexport function getEntityDependencies(\n  entity: IEntity,\n): TDependencyMap | undefined {\n  const entityType = entity.getType();\n  const getDependenciesMethod = getDependencies[entityType];\n\n  return getDependenciesMethod && getDependenciesMethod(entity);\n}\n\nfunction getWidgetDependencies(widgetEntity: WidgetEntity): TDependencyMap {\n  let dependencies: TDependencyMap = {};\n  const widgetConfig = widgetEntity.getConfig();\n  const widgetName = widgetEntity.getName();\n\n  const widgetInternalDependencies = addWidgetPropertyDependencies({\n    widgetConfig,\n    widgetName,\n  });\n\n  dependencies = mergeMaps(dependencies, widgetInternalDependencies);\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(widgetConfig);\n  const dynamicTriggerPathList = widgetConfig.dynamicTriggerPathList || [];\n  const allDynamicPaths = union(dynamicTriggerPathList, dynamicBindingPathList);\n\n  for (const dynamicPath of allDynamicPaths) {\n    const propertyPath = dynamicPath.key;\n    const dynamicPathDependency = getDependencyFromEntityPath(\n      propertyPath,\n      widgetEntity,\n    );\n\n    dependencies = mergeMaps(dependencies, dynamicPathDependency);\n  }\n\n  return dependencies;\n}\n\nfunction getJSDependencies(jsEntity: JSEntity): TDependencyMap {\n  let dependencies: TDependencyMap = {};\n  const jsActionConfig = jsEntity.getConfig();\n  const jsActionReactivePaths = jsActionConfig.reactivePaths || {};\n\n  for (const reactivePath of Object.keys(jsActionReactivePaths)) {\n    const reactivePathDependency = getDependencyFromEntityPath(\n      reactivePath,\n      jsEntity,\n    );\n\n    dependencies = mergeMaps(dependencies, reactivePathDependency);\n  }\n\n  const jsEntityInternalDependencyMap =\n    getEntityInternalDependencyMap(jsEntity);\n\n  dependencies = mergeMaps(dependencies, jsEntityInternalDependencyMap);\n\n  return dependencies;\n}\n\nfunction getActionDependencies(actionEntity: ActionEntity): TDependencyMap {\n  let dependencies: TDependencyMap = {};\n  const actionConfig = actionEntity.getConfig();\n\n  const actionInternalDependencyMap =\n    getEntityInternalDependencyMap(actionEntity);\n\n  dependencies = mergeMaps(dependencies, actionInternalDependencyMap);\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(actionConfig);\n\n  for (const dynamicPath of dynamicBindingPathList) {\n    const propertyPath = dynamicPath.key;\n    const dynamicPathDependency = getDependencyFromEntityPath(\n      propertyPath,\n      actionEntity,\n    );\n\n    dependencies = mergeMaps(dependencies, dynamicPathDependency);\n  }\n\n  return dependencies;\n}\n\nexport function getDependencyFromEntityPath(\n  propertyPath: string,\n  entity: IEntity,\n): TDependencyMap {\n  const unevalPropValue = get(\n    entity.getRawEntity(),\n    propertyPath,\n    \"\",\n  ).toString();\n  const entityName = entity.getName();\n  const { jsSnippets } = getDynamicBindings(unevalPropValue);\n  const validJSSnippets = jsSnippets.filter((jsSnippet) => !!jsSnippet);\n  const dynamicPathDependency: TDependencyMap = {\n    [`${entityName}.${propertyPath}`]: validJSSnippets,\n  };\n\n  return dynamicPathDependency;\n}\n\nfunction getEntityInternalDependencyMap(entity: IEntity) {\n  const entityConfig = entity.getConfig();\n  const entityName = entity.getName();\n  const dependencies: TDependencyMap = {};\n  const internalDependencyMap: TDependencyMap = entityConfig\n    ? (entityConfig as Record<string, TDependencyMap>).dependencyMap\n    : {};\n\n  for (const [path, pathDependencies] of Object.entries(\n    internalDependencyMap,\n  )) {\n    const fullPropertyPath = `${entityName}.${path}`;\n    const fullPathDependencies = pathDependencies.map(\n      (dependentPath) => `${entityName}.${dependentPath}`,\n    );\n\n    dependencies[fullPropertyPath] = fullPathDependencies;\n  }\n\n  return dependencies;\n}\n\nexport function getEntityPathDependencies(\n  entity: IEntity,\n  fullPropertyPath: string,\n) {\n  const entityType = entity.getType();\n  const getPathDependenciesMethod = getPathDependencies[entityType];\n\n  return (\n    getPathDependenciesMethod &&\n    getPathDependenciesMethod(entity, fullPropertyPath)\n  );\n}\n\nfunction getWidgetPropertyPathDependencies(\n  widgetEntity: WidgetEntity,\n  fullPropertyPath: string,\n): TDependencyMap {\n  const { propertyPath: entityPropertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const widgetConfig = widgetEntity.getConfig();\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(widgetConfig);\n  const dynamicTriggerPathList = widgetConfig.dynamicTriggerPathList || [];\n  const allDynamicPaths = union(dynamicTriggerPathList, dynamicBindingPathList);\n  const isPathADynamicPath =\n    allDynamicPaths.find(\n      (dynamicPath) => dynamicPath.key === entityPropertyPath,\n    ) !== undefined;\n\n  if (!isPathADynamicPath) return {};\n\n  const dynamicPathDependency = getDependencyFromEntityPath(\n    entityPropertyPath,\n    widgetEntity,\n  );\n\n  return dynamicPathDependency;\n}\n\nfunction getJSPropertyPathDependencies(\n  jsEntity: JSEntity,\n  fullPropertyPath: string,\n): TDependencyMap {\n  const { propertyPath: entityPropertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const jsActionConfig = jsEntity.getConfig();\n  const jsActionReactivePaths = jsActionConfig.reactivePaths || {};\n  const isPathAReactivePath =\n    Object.keys(jsActionReactivePaths).find(\n      (path) => path === entityPropertyPath,\n    ) !== undefined;\n\n  if (!isPathAReactivePath) return {};\n\n  const reactivePathDependency = getDependencyFromEntityPath(\n    entityPropertyPath,\n    jsEntity,\n  );\n\n  return reactivePathDependency;\n}\n\nfunction getActionPropertyPathDependencies(\n  actionEntity: ActionEntity,\n  fullPropertyPath: string,\n): TDependencyMap {\n  const { propertyPath: entityPropertyPath } =\n    getEntityNameAndPropertyPath(fullPropertyPath);\n  const actionConfig = actionEntity.getConfig();\n\n  const dynamicBindingPathList = getEntityDynamicBindingPathList(actionConfig);\n  const isADynamicPath = dynamicBindingPathList.find(\n    (path) => path.key === entityPropertyPath,\n  );\n\n  if (!isADynamicPath) return {};\n\n  const dynamicPathDependency = getDependencyFromEntityPath(\n    entityPropertyPath,\n    actionEntity,\n  );\n\n  return dynamicPathDependency;\n}\n\nexport function extractReferencesFromPath(\n  entity: IEntity,\n  fullPropertyPath: string,\n  tree: Record<string, unknown>,\n) {\n  if (!PathUtils.isDynamicLeaf(entity, fullPropertyPath)) return [];\n\n  const entityPropertyPath = getPropertyPath(fullPropertyPath);\n  const rawEntity = entity.getRawEntity() as DataTreeEntity;\n  const propertyPathContent = get(rawEntity, entityPropertyPath);\n\n  if (!isString(propertyPathContent)) return [];\n\n  const { jsSnippets } = getDynamicBindings(propertyPathContent, rawEntity);\n  const validJSSnippets = jsSnippets.filter((jsSnippet) => !!jsSnippet);\n\n  const referencesInPropertyPath = flatten(\n    validJSSnippets.map((jsSnippet) =>\n      extractReferencesFromJSSnippet(jsSnippet, tree),\n    ),\n  );\n\n  return referencesInPropertyPath;\n}\n\nexport function extractReferencesFromJSSnippet(\n  jsSnippet: string,\n  tree: Record<string, unknown>,\n) {\n  const { references } = extractIdentifierInfoFromCode(jsSnippet, 2);\n  const prunedReferences = flatten(\n    references.map((reference) => getPrunedReference(reference, tree)),\n  );\n\n  return uniq(prunedReferences);\n}\n\nfunction getPrunedReference(\n  reference: string,\n  tree: Record<string, unknown>,\n): string[] {\n  if (has(tree, reference)) {\n    return [reference];\n  }\n\n  const subpaths = toPath(reference);\n  let currentString = \"\";\n  const references = [];\n\n  // We want to keep going till we reach top level\n  while (subpaths.length > 0) {\n    currentString = convertPathToString(subpaths);\n    references.push(currentString);\n\n    // We've found the dep, add it and return\n    if (has(tree, currentString)) {\n      return references;\n    }\n\n    subpaths.pop();\n  }\n\n  return references;\n}\n","import type {\n  Diff,\n  DiffArray,\n  DiffDeleted,\n  DiffEdit,\n  DiffNew,\n} from \"deep-diff\";\nimport { isEmpty, partition } from \"lodash\";\n\nexport function groupDifferencesByType(differences: Diff<unknown>[]): {\n  edits: DiffEdit<unknown, unknown>[];\n  additions: DiffNew<unknown>[];\n  deletions: DiffDeleted<unknown>[];\n} {\n  if (isEmpty(differences)) return { edits: [], additions: [], deletions: [] };\n\n  const [edits, others] = partition(differences, (diff) => diff.kind === \"E\");\n  const [additions, deletionsAndArrayChanges] = partition(\n    others,\n    (diff) => diff.kind === \"N\",\n  );\n  const [deletions, arrayChanges] = partition(\n    deletionsAndArrayChanges,\n    (diff) => diff.kind === \"D\",\n  );\n\n  const refinedChanges = (arrayChanges as DiffArray<unknown>[]).reduce(\n    (acc, currentDiff) => {\n      if (!currentDiff.path) return acc;\n\n      const { index, item, path } = currentDiff;\n\n      return [\n        ...acc,\n        {\n          ...item,\n          path: [...path, index],\n        },\n      ];\n    },\n    [] as Diff<unknown>[],\n  );\n\n  const result = groupDifferencesByType(refinedChanges);\n\n  return {\n    edits: edits.concat(result.edits),\n    additions: additions.concat(result.additions),\n    deletions: deletions.concat(result.deletions),\n  };\n}\n","import type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { createEvaluationContext } from \"workers/Evaluation/evaluate\";\nimport { getActionTriggerFunctionNames } from \"ee/workers/Evaluation/fns\";\n\nexport function getEvaluationContext(\n  unevalTree: DataTree,\n  configTree: ConfigTree,\n  cloudHosting: boolean,\n  options: { withFunctions: boolean },\n) {\n  if (!options.withFunctions)\n    return createEvaluationContext({\n      dataTree: unevalTree,\n      configTree,\n      isTriggerBased: false,\n      removeEntityFunctions: true,\n    });\n\n  const evalContext = createEvaluationContext({\n    dataTree: unevalTree,\n    configTree,\n    isTriggerBased: true,\n    removeEntityFunctions: false,\n  });\n\n  const platformFnNamesMap = Object.values(\n    getActionTriggerFunctionNames(),\n  ).reduce(\n    (acc, name) => ({ ...acc, [name]: true }),\n    {} as { [x: string]: boolean },\n  );\n\n  Object.assign(evalContext, platformFnNamesMap);\n\n  return evalContext;\n}\n","import type { ConfigTree, DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport { isEmpty } from \"lodash\";\nimport type { EvalContext } from \"workers/Evaluation/evaluate\";\nimport { getEvaluationContext } from \"./utils/getEvaluationContext\";\n\nclass GlobalData {\n  globalDataWithFunctions: EvalContext = {};\n  globalDataWithoutFunctions: EvalContext = {};\n  unevalTree: DataTree = {};\n  configTree: ConfigTree = {};\n  cloudHosting = false;\n\n  initialize(\n    unevalTree: DataTree,\n    configTree: ConfigTree,\n    cloudHosting: boolean,\n  ) {\n    this.globalDataWithFunctions = {};\n    this.globalDataWithoutFunctions = {};\n    this.unevalTree = unevalTree;\n    this.configTree = configTree;\n    this.cloudHosting = cloudHosting;\n  }\n\n  getGlobalData(withFunctions: boolean) {\n    // Our goal is to create global data (with or without functions) only once during a linting cycle\n    if (withFunctions) {\n      if (isEmpty(this.globalDataWithFunctions)) {\n        this.globalDataWithFunctions = getEvaluationContext(\n          this.unevalTree,\n          this.configTree,\n          this.cloudHosting,\n          {\n            withFunctions: true,\n          },\n        );\n      }\n\n      return this.globalDataWithFunctions;\n    } else {\n      if (isEmpty(this.globalDataWithoutFunctions)) {\n        this.globalDataWithoutFunctions = getEvaluationContext(\n          this.unevalTree,\n          this.configTree,\n          this.cloudHosting,\n          {\n            withFunctions: false,\n          },\n        );\n      }\n\n      return this.globalDataWithoutFunctions;\n    }\n  }\n}\n\nexport const globalData = new GlobalData();\n","import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nexport const noFloatingPromisesLintRule: Rule.RuleModule = {\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Requires handling of Promises (using await or .then())\",\n      category: \"Possible Errors\",\n      recommended: false,\n    },\n    messages: {\n      unhandledPromise:\n        \"Unhandled Promise detected. Handle using await or .then()\",\n    },\n    schema: [], // Rule does not accept configuration options\n  },\n  create: function (context: Rule.RuleContext) {\n    // Access async functions from settings\n    const asyncFunctions = context.settings?.asyncFunctions || [];\n\n    return {\n      FunctionDeclaration(node: ESTree.FunctionDeclaration) {\n        // Start traversal from the function body\n        traverseNode(node.body, null);\n      },\n    };\n\n    /**\n     * Recursively traverses the AST node and its children.\n     * Processes CallExpressions and continues traversing child nodes.\n     */\n    function traverseNode(\n      node: ESTree.Node | null,\n      parent: ESTree.Node | null,\n    ) {\n      if (!node) return;\n\n      if (node.type === \"CallExpression\") {\n        checkCallExpression(node as ESTree.CallExpression, parent);\n      }\n\n      // Retrieve keys for child nodes and traverse them\n      const visitorKeys = context.getSourceCode().visitorKeys[node.type] || [];\n\n      for (const key of visitorKeys) {\n        const child = (node as any)[key]; // eslint-disable-line @typescript-eslint/no-explicit-any\n\n        if (Array.isArray(child)) {\n          child.forEach(\n            (c) => c && typeof c.type === \"string\" && traverseNode(c, node),\n          );\n        } else if (child && typeof child.type === \"string\") {\n          traverseNode(child, node);\n        }\n      }\n    }\n\n    /**\n     * Determines if a node is inside an async function by traversing its parent chain.\n     */\n    function isInAsyncFunction(node: ESTree.Node | null): boolean {\n      while (node) {\n        if (\n          (node.type === \"FunctionDeclaration\" ||\n            node.type === \"FunctionExpression\") &&\n          node.async\n        ) {\n          return true;\n        }\n\n        // Move to the parent node in the AST\n        // @ts-expect-error: Types may not always define `parent`\n        node = node.parent;\n      }\n\n      return false;\n    }\n\n    /**\n     * Checks if a CallExpression represents an unhandled Promise.\n     * Reports an error if the promise is not awaited or chained with `.then()`, `.catch()`, or `.finally()`.\n     */\n    function checkCallExpression(\n      node: ESTree.CallExpression,\n      parent: ESTree.Node | null,\n    ) {\n      const callee = node.callee;\n      let isPotentialAsyncCall = false;\n\n      // Identify async calls by matching against the asyncFunctions list\n      if (callee.type === \"MemberExpression\") {\n        const object = callee.object;\n        const property = callee.property;\n\n        if (\n          property.type === \"Identifier\" &&\n          object.type === \"Identifier\" &&\n          asyncFunctions.includes(`${object.name}.${property.name}`)\n        ) {\n          isPotentialAsyncCall = true;\n        }\n      }\n\n      // Report if the async call is unhandled and not properly awaited\n      if (isPotentialAsyncCall && isInAsyncFunction(parent)) {\n        if (\n          parent &&\n          parent.type !== \"AwaitExpression\" &&\n          parent.type !== \"ReturnStatement\" &&\n          !isHandledWithPromiseMethods(parent)\n        ) {\n          context.report({\n            node,\n            messageId: \"unhandledPromise\",\n          });\n        }\n      }\n    }\n\n    /**\n     * Determines if a CallExpression is handled with `.then()`, `.catch()`, or `.finally()`.\n     */\n    function isHandledWithPromiseMethods(parent: ESTree.Node): boolean {\n      if (\n        parent.type === \"MemberExpression\" &&\n        parent.property &&\n        [\"then\", \"catch\", \"finally\"].includes(\n          (parent.property as ESTree.Identifier).name,\n        )\n      ) {\n        return true;\n      }\n\n      return false;\n    }\n  },\n};\n","import { ECMA_VERSION } from \"@shared/ast\";\nimport type { LintOptions } from \"jshint\";\nimport isEntityFunction from \"./utils/isEntityFunction\";\nimport { noFloatingPromisesLintRule } from \"./customRules/no-floating-promises\";\nimport { getLintRulesBasedOnContext } from \"ee/utils/lintRulesHelpers\";\n\nimport type { IDEType } from \"ee/IDE/Interfaces/IDETypes\";\n\nexport enum LINTER_TYPE {\n  \"JSHINT\" = \"JSHint\",\n  \"ESLINT\" = \"ESLint\",\n}\n\nexport const lintOptions = (\n  globalData: Record<string, boolean | \"readonly\" | \"writable\">,\n  asyncFunctions: string[],\n  ideType: IDEType,\n  linterType: LINTER_TYPE = LINTER_TYPE.JSHINT,\n) => {\n  if (linterType === LINTER_TYPE.JSHINT) {\n    return {\n      indent: 2,\n      esversion: ECMA_VERSION,\n      eqeqeq: false, // Not necessary to use ===\n      curly: false, // Blocks can be added without {}, eg if (x) return true\n      freeze: true, // Overriding inbuilt classes like Array is not allowed\n      undef: true, // Undefined variables should be reported as error\n      forin: false, // Doesn't require filtering for..in loops with obj.hasOwnProperty()\n      noempty: false, // Empty blocks are allowed\n      strict: false, // We won't force strict mode\n      unused: \"strict\", // Unused variables are not allowed\n      asi: true, // Tolerate Automatic Semicolon Insertion (no semicolons)\n      boss: true, // Tolerate assignments where comparisons would be expected\n      evil: false, // Use of eval not allowed\n      funcscope: true, // Tolerate variable definition inside control statements\n      sub: true, // Don't force dot notation\n      expr: true, // suppresses warnings about the use of expressions where normally you would expect to see assignments or function calls\n      // environments\n      browser: false,\n      worker: true,\n      mocha: false,\n      // global values\n      globals: globalData,\n      loopfunc: true,\n    } as LintOptions;\n  } else {\n    const extraRules = getLintRulesBasedOnContext({ ideType });\n\n    return {\n      languageOptions: {\n        ecmaVersion: ECMA_VERSION,\n        globals: globalData,\n        sourceType: \"script\",\n      },\n      // Need to pass for custom rules\n      settings: {\n        globalData,\n        asyncFunctions,\n      },\n      plugins: {\n        customRules: {\n          rules: {\n            \"no-floating-promises\": noFloatingPromisesLintRule,\n          },\n        },\n      },\n      rules: {\n        ...extraRules,\n        eqeqeq: \"off\",\n        curly: \"off\",\n        \"no-extend-native\": \"error\",\n        \"no-undef\": \"error\",\n        \"guard-for-in\": \"off\",\n        \"no-empty\": \"off\",\n        strict: \"off\",\n        \"no-unused-vars\": [\n          \"warn\",\n          { vars: \"all\", args: \"all\", ignoreRestSiblings: false },\n        ],\n        \"no-cond-assign\": \"off\",\n        \"no-eval\": \"error\",\n        \"block-scoped-var\": \"off\",\n        \"dot-notation\": \"off\",\n        \"no-unused-expressions\": \"off\",\n        \"no-loop-func\": \"off\",\n      },\n    } as const;\n  }\n};\n\nexport const JS_OBJECT_START_STATEMENT = \"export default\";\nexport const INVALID_JSOBJECT_START_STATEMENT = `JSObject must start with '${JS_OBJECT_START_STATEMENT}'`;\nexport const INVALID_JSOBJECT_START_STATEMENT_ERROR_CODE =\n  \"INVALID_JSOBJECT_START_STATEMENT_ERROR_CODE\";\n// https://github.com/jshint/jshint/blob/d3d84ae1695359aef077ddb143f4be98001343b4/src/messages.js#L204\nexport const IDENTIFIER_NOT_DEFINED_LINT_ERROR_CODE = \"W117\";\n\n// For these error types, we want to show a warning\n// All messages can be found here => https://github.com/jshint/jshint/blob/2.9.5/src/messages.js\nexport const WARNING_LINT_ERRORS = {\n  \"no-unused-vars\": \"'{a}' is assigned a value but never used.\",\n  W098: \"'{a}' is defined but never used.\",\n  W014: \"Misleading line break before '{a}'; readers may interpret this as an expression boundary.\",\n  ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD:\n    \"Cannot execute async code on functions bound to data fields\",\n  ACTION_MODAL_STRING: 'Use Modal1.name instead of \"Modal\" as a string',\n};\n\nexport function asyncActionInSyncFieldLintMessage(isJsObject = false) {\n  return isJsObject\n    ? `Cannot execute async code on functions bound to data fields`\n    : `Data fields cannot execute async code`;\n}\n\n/** These errors should be overlooked\n * E041 => Unrecoverable syntax error.\n * W032 => Unnecessary semicolon.\n */\nexport const IGNORED_LINT_ERRORS = [\"E041\", \"W032\"];\nexport const SUPPORTED_WEB_APIS = {\n  console: true,\n  crypto: true,\n  fetch: true,\n};\nexport enum CustomLintErrorCode {\n  INVALID_ENTITY_PROPERTY = \"INVALID_ENTITY_PROPERTY\",\n  ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD = \"ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD\",\n  // ButtonWidget.text = \"test\"\n  INVALID_WIDGET_PROPERTY_SETTER = \"INVALID_WIDGET_PROPERTY_SETTER\",\n  // appsmith.store.value = \"test\"\n  INVALID_APPSMITH_STORE_PROPERTY_SETTER = \"INVALID_APPSMITH_STORE_PROPERTY_SETTER\",\n  // showModal(\"Modal1\")\n  ACTION_MODAL_STRING = \"ACTION_MODAL_STRING\",\n  INVALID_INPUTS = \"INVALID_INPUTS\",\n}\n\nexport const CUSTOM_LINT_ERRORS: Record<\n  CustomLintErrorCode,\n  // TODO: Fix this the next time the file is edited\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (...args: any[]) => string\n> = {\n  [CustomLintErrorCode.INVALID_ENTITY_PROPERTY]: (\n    entityName: string,\n    propertyName: string,\n    entity: unknown,\n    isJsObject: boolean,\n  ) =>\n    isEntityFunction(entity, propertyName, entityName)\n      ? asyncActionInSyncFieldLintMessage(isJsObject)\n      : `\"${propertyName}\" doesn't exist in ${entityName}`,\n\n  [CustomLintErrorCode.ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD]: (\n    dataFieldBindings: string[],\n    fullName: string,\n    isMarkedAsync: boolean,\n  ) => {\n    const hasMultipleBindings = dataFieldBindings.length > 1;\n    const bindings = dataFieldBindings.join(\" , \");\n\n    return isMarkedAsync\n      ? `Cannot bind async functions to data fields. Convert this to a sync function or remove references to \"${fullName}\" on the following data ${\n          hasMultipleBindings ? \"fields\" : \"field\"\n        }: ${bindings}`\n      : `Functions bound to data fields cannot execute async code. Remove async statements highlighted below or remove references to \"${fullName}\" on the following data ${\n          hasMultipleBindings ? \"fields\" : \"field\"\n        }: ${bindings}`;\n  },\n  [CustomLintErrorCode.INVALID_WIDGET_PROPERTY_SETTER]: (\n    methodName: string,\n    objectName: string,\n    propertyName: string,\n    isValidProperty: boolean,\n  ) => {\n    const suggestionSentence = methodName\n      ? `Use ${methodName}(value) instead.`\n      : `Use ${objectName} setter method instead.`;\n\n    const lintErrorMessage = !isValidProperty\n      ? `${objectName} doesn't have a property named ${propertyName}`\n      : `Direct mutation of widget properties is not supported. ${suggestionSentence}`;\n\n    return lintErrorMessage;\n  },\n  [CustomLintErrorCode.INVALID_APPSMITH_STORE_PROPERTY_SETTER]: () => {\n    return \"Use storeValue() method to modify the store\";\n  },\n  [CustomLintErrorCode.ACTION_MODAL_STRING]: (modalName: string) => {\n    return `Use ${modalName}.name instead of \"${modalName}\" as a string`;\n  },\n  [CustomLintErrorCode.INVALID_INPUTS]: (\n    inputs: string[],\n    invalidKey: string,\n  ) => {\n    return `${invalidKey} doesn't exist in valid list of inputs: ${inputs.join(\", \")} `;\n  },\n};\n","import type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { isDataTreeEntity } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { getEntityFunctions } from \"ee/workers/Evaluation/fns\";\nimport setters from \"workers/Evaluation/setters\";\n\nexport default function isEntityFunction(\n  entity: unknown,\n  propertyName: string,\n  entityName: string,\n) {\n  if (!isDataTreeEntity(entity)) return false;\n\n  if (setters.has(entityName, propertyName)) return true;\n\n  const entityFns = getEntityFunctions();\n\n  return entityFns.find((entityFn) => {\n    const entityFnpropertyName = entityFn.path\n      ? entityFn.path.split(\".\")[1]\n      : entityFn.name;\n\n    return (\n      entityFnpropertyName === propertyName &&\n      entityFn.qualifier(entity as DataTreeEntity)\n    );\n  });\n}\n","import {\n  asyncActionInSyncFieldLintMessage,\n  WARNING_LINT_ERRORS,\n} from \"../constants\";\nimport { Severity } from \"entities/AppsmithConsole\";\n\nexport default function getLintSeverity(\n  code: string,\n  errorMessage: string,\n): Severity.WARNING | Severity.ERROR {\n  const severity =\n    code in WARNING_LINT_ERRORS ||\n    errorMessage === asyncActionInSyncFieldLintMessage(true)\n      ? Severity.WARNING\n      : Severity.ERROR;\n\n  return severity;\n}\n","import type { MemberCallExpressionData } from \"@shared/ast\";\nimport type { Position } from \"codemirror\";\nimport type { LintError } from \"utils/DynamicBindingUtils\";\n\nexport interface InvalidModuleInputsErrorProps {\n  data: Record<string, unknown>;\n  memberCallExpressions: MemberCallExpressionData[];\n  originalBinding: string;\n  script: string;\n  scriptPos: Position;\n}\n\nfunction getInvalidModuleInputsError(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  _props: InvalidModuleInputsErrorProps,\n): LintError[] {\n  return [];\n}\n\nexport default getInvalidModuleInputsError;\n","export * from \"ce/plugins/Linting/utils/getInvalidModuleInputsError\";\nimport { default as CE_getInvalidModuleInputsError } from \"ce/plugins/Linting/utils/getInvalidModuleInputsError\";\nexport default CE_getInvalidModuleInputsError;\n","/**\n * Why we need this?\n * By default Object.keys return values's type is flawed. It returns array of strings and because of that we lose the type information of the object\n * when looping through the keys. This function returns an array of keys with the correct type information.\n *\n * with classic Object.keys: Object.keys({ a: 1, b: 2 }) -> string[]\n * with objectKeys: objectKeys({ a: 1, b: 2 }) -> (\"a\" | \"b\")[]\n *\n * @param object\n * @returns array of keys with correct type information\n */\n\nexport function objectKeys<T extends object>(object: T): Array<keyof T> {\n  return Object.keys(object) as Array<keyof T>;\n}\n","import type { WebworkerSpanData, Attributes } from \"./types\";\n\n//this is used in webworkers to generate telemetry data\n//this telemetry data is pushed to the main thread which is converted\n//to regular otlp telemetry data and subsequently exported to our telemetry collector\nexport const newWebWorkerSpanData = (\n  spanName: string,\n  attributes: Attributes = {},\n): WebworkerSpanData => {\n  return {\n    attributes,\n    spanName,\n    startTime: Date.now(),\n    endTime: Date.now(),\n  };\n};\n\nconst addEndTimeForWebWorkerSpanData = (span: WebworkerSpanData) => {\n  span.endTime = Date.now();\n};\n\nexport const profileAsyncFn = async <T>(\n  spanName: string,\n  fn: () => Promise<T>,\n  allSpans: Record<string, WebworkerSpanData | Attributes>,\n  attributes: Attributes = {},\n) => {\n  const span = newWebWorkerSpanData(spanName, attributes);\n  const res: T = await fn();\n\n  addEndTimeForWebWorkerSpanData(span);\n  allSpans[spanName] = span;\n\n  return res;\n};\n\nexport const profileFn = <T>(\n  spanName: string,\n  attributes: Attributes = {},\n  allSpans: Record<string, WebworkerSpanData | Attributes>,\n  fn: () => T,\n) => {\n  const span = newWebWorkerSpanData(spanName, attributes);\n  const res: T = fn();\n\n  addEndTimeForWebWorkerSpanData(span);\n  allSpans[spanName] = span;\n\n  return res;\n};\n\nexport const filterSpanData = (\n  spanData: Record<string, WebworkerSpanData | Attributes>,\n): Record<string, WebworkerSpanData> => {\n  return Object.keys(spanData)\n    .filter((key) => !key.startsWith(\"__\"))\n    .reduce<Record<string, WebworkerSpanData>>((obj, key) => {\n      obj[key] = spanData[key] as WebworkerSpanData;\n\n      return obj;\n    }, {});\n};\n","export const SAAS_BASE_PATH = `/saas`;\nexport const SAAS_EDITOR_PATH = `${SAAS_BASE_PATH}/:pluginPackageName`;\nexport const SAAS_EDITOR_DATASOURCE_ID_PATH = `${SAAS_EDITOR_PATH}/datasources/:datasourceId`;\nexport const SAAS_EDITOR_API_ID_PATH = `${SAAS_EDITOR_PATH}/api/:baseApiId`;\nexport const SAAS_EDITOR_API_ID_ADD_PATH = `${SAAS_EDITOR_PATH}/api/:baseApiId/:sidebarState`;\n\nexport const APPSMITH_TOKEN_STORAGE_KEY = \"APPSMITH_AUTH_TOKEN\";\n","export const IDE_TYPE = {\n  None: \"None\",\n  App: \"App\",\n} as const;\n\nexport type IDEType = keyof typeof IDE_TYPE;\n","import {\n  ADD_PATH,\n  API_EDITOR_ID_ADD_PATH,\n  API_EDITOR_ID_PATH,\n  BUILDER_CUSTOM_PATH,\n  BUILDER_PATH,\n  BUILDER_PATH_DEPRECATED,\n  DATA_SOURCES_EDITOR_ID_PATH,\n  ENTITY_PATH,\n  INTEGRATION_EDITOR_PATH,\n  JS_COLLECTION_ID_ADD_PATH,\n  JS_COLLECTION_ID_PATH,\n  QUERIES_EDITOR_ID_ADD_PATH,\n  QUERIES_EDITOR_ID_PATH,\n  WIDGETS_EDITOR_ID_PATH,\n} from \"ee/constants/routes/appRoutes\";\nimport {\n  SAAS_EDITOR_API_ID_ADD_PATH,\n  SAAS_EDITOR_API_ID_PATH,\n  SAAS_EDITOR_DATASOURCE_ID_PATH,\n} from \"pages/Editor/SaaSEditor/constants\";\n\nimport { IDE_TYPE, type IDEType } from \"../Interfaces/IDETypes\";\n\nexport const EntityPaths: string[] = [\n  API_EDITOR_ID_ADD_PATH,\n  API_EDITOR_ID_PATH,\n  QUERIES_EDITOR_ID_ADD_PATH,\n  QUERIES_EDITOR_ID_PATH,\n  DATA_SOURCES_EDITOR_ID_PATH,\n  INTEGRATION_EDITOR_PATH,\n  SAAS_EDITOR_DATASOURCE_ID_PATH,\n  SAAS_EDITOR_API_ID_ADD_PATH,\n  SAAS_EDITOR_API_ID_PATH,\n  JS_COLLECTION_ID_PATH,\n  JS_COLLECTION_ID_ADD_PATH,\n  WIDGETS_EDITOR_ID_PATH,\n  WIDGETS_EDITOR_ID_PATH + ADD_PATH,\n  ENTITY_PATH,\n];\nexport const IDEBasePaths: Readonly<Record<IDEType, string[]>> = {\n  [IDE_TYPE.None]: [],\n  [IDE_TYPE.App]: [BUILDER_PATH, BUILDER_PATH_DEPRECATED, BUILDER_CUSTOM_PATH],\n};\n","import { IDEBasePaths } from \"ee/IDE/constants/routes\";\nimport { IDE_TYPE, type IDEType } from \"ee/IDE/Interfaces/IDETypes\";\nimport { matchPath } from \"react-router-dom\";\n\nexport function getIDETypeByUrl(path: string): IDEType {\n  for (const type in IDEBasePaths) {\n    const basePaths = IDEBasePaths[type as IDEType];\n\n    if (matchPath(path, { path: basePaths })) {\n      return type as IDEType;\n    }\n  }\n\n  return IDE_TYPE.None;\n}\n","/* eslint-disable @typescript-eslint/no-unused-vars */\nexport enum PERMISSION_TYPE {\n  /* Workspace permissions */\n  CREATE_WORKSPACE = \"createWorkspaces:organization\",\n  MANAGE_WORKSPACE = \"manage:workspaces\",\n  READ_WORKSPACE = \"read:workspaces\",\n  INVITE_USER_TO_WORKSPACE = \"inviteUsers:workspace\",\n  /* Application permissions */\n  MANAGE_WORKSPACE_APPLICATION = \"manage:workspaceApplications\",\n  MANAGE_APPLICATION = \"manage:applications\",\n  EXPORT_APPLICATION = \"export:applications\",\n  DELETE_WORKSPACE_APPLICATIONS = \"delete:workspaceApplications\",\n  READ_WORKSPACE_APPLICATIONS = \"read:workspaceApplications\",\n  EXPORT_WORKSPACE_APPLICATIONS = \"export:workspaceApplications\",\n  READ_APPLICATION = \"read:applications\",\n  MAKE_PUBLIC_APPLICATION = \"makePublic:applications\",\n  MAKE_PUBLIC_WORKSPACE_APPLICATIONS = \"makePublic:workspaceApplications\",\n  PUBLISH_APPLICATION = \"publish:workspaceApplications\",\n  CREATE_APPLICATION = \"create:applications\",\n  /* Datasource permissions */\n  CREATE_DATASOURCES = \"create:datasources\",\n  READ_DATASOURCES = \"read:datasources\",\n  EXECUTE_DATASOURCES = \"execute:datasources\",\n  CREATE_DATASOURCE_ACTIONS = \"create:datasourceActions\",\n  DELETE_DATASOURCES = \"delete:datasources\",\n  MANAGE_DATASOURCES = \"manage:datasources\",\n  EXECUTE_WORKSPACE_DATASOURCES = \"execute:workspaceDatasources\",\n  MANAGE_WORKSPACE_DATASOURCES = \"manage:workspaceDatasources\",\n  READ_WORKSPACE_DATASOURCES = \"read:workspaceDatasources\",\n  /* Page permissions */\n  CREATE_PAGES = \"create:pages\",\n  MANAGE_PAGES = \"manage:pages\",\n  DELETE_PAGES = \"delete:pages\",\n  /* Query permissions */\n  CREATE_ACTIONS = \"create:pageActions\",\n  MANAGE_ACTIONS = \"manage:actions\",\n  DELETE_ACTIONS = \"delete:actions\",\n  EXECUTE_ACTIONS = \"execute:actions\",\n  /* Git application permissions */\n  GIT_APPLICATION_CONNECT = \"connectToGit:applications\",\n  GIT_APPLICATION_MANAGE_PROTECTED_BRANCHES = \"manageProtectedBranches:applications\",\n  GIT_APPLICATION_MANAGE_DEFAULT_BRANCH = \"manageDefaultBranches:applications\",\n  GIT_APPLICATION_MANAGE_AUTO_COMMIT = \"manageAutoCommit:applications\",\n}\n\nexport enum LOGIC_FILTER {\n  AND = \"AND\",\n  OR = \"OR\",\n}\n\nexport const isPermitted = (\n  permissions: string[] = [],\n  type: string | string[],\n  filter: LOGIC_FILTER = LOGIC_FILTER.AND,\n) => {\n  if (Array.isArray(type)) {\n    if (filter === LOGIC_FILTER.AND) {\n      return type.every((t) => permissions.includes(t));\n    } else {\n      return type.some((t) => permissions.includes(t));\n    }\n  }\n\n  return permissions.includes(type);\n};\n\nexport const hasDeleteApplicationPermission = (permissions: string[] = []) => {\n  return isPermitted(permissions, PERMISSION_TYPE.MANAGE_APPLICATION);\n};\n\nexport const hasCreateNewAppPermission = (permissions: string[] = []) => {\n  return isPermitted(permissions, PERMISSION_TYPE.CREATE_APPLICATION);\n};\n\nexport const hasDeleteWorkspacePermission = (permissions: string[] = []) => {\n  return isPermitted(permissions, PERMISSION_TYPE.MANAGE_WORKSPACE);\n};\n\nexport const hasInviteUserToApplicationPermission = (\n  permissions: string[] = [],\n) => {\n  return isPermitted(permissions, PERMISSION_TYPE.INVITE_USER_TO_WORKSPACE);\n};\n\nexport const hasCreateWorkspacePermission = (_permissions?: string[]) => true;\n\nexport const hasCreateDatasourcePermission = (_permissions?: string[]) => true;\n\nexport const hasReadDatasourcePermission = (_permissions?: string[]) => true;\n\nexport const hasManageDatasourcePermission = (_permissions?: string[]) => true;\n\nexport const hasManageWorkspaceDatasourcePermission = (\n  _permissions?: string[],\n) => true;\n\nexport const hasDeleteDatasourcePermission = (_permissions?: string[]) => true;\n\nexport const hasCreateDatasourceActionPermission = (_permissions?: string[]) =>\n  true;\n\nexport const hasCreatePagePermission = (_permissions?: string[]) => true;\n\nexport const hasManagePagePermission = (_permissions?: string[]) => true;\n\nexport const hasDeletePagePermission = (_permissions?: string[]) => true;\n\nexport const hasCreateActionPermission = (_permissions?: string[]) => true;\n\nexport const hasManageActionPermission = (_permissions?: string[]) => true;\n\nexport const hasDeleteActionPermission = (_permissions?: string[]) => true;\n\nexport const hasExecuteActionPermission = (_permissions?: string[]) => true;\n\nexport const hasAuditLogsReadPermission = (_permissions?: string[]) => true;\n\nexport const hasManageWorkspaceEnvironmentPermission = (\n  _permissions?: string[],\n) => false;\n\nexport const hasGitAppConnectPermission = (permissions: string[] = []) => {\n  return isPermitted(permissions, PERMISSION_TYPE.GIT_APPLICATION_CONNECT);\n};\n\nexport const hasGitAppManageProtectedBranchesPermission = (\n  permissions: string[] = [],\n) => {\n  return isPermitted(\n    permissions,\n    PERMISSION_TYPE.GIT_APPLICATION_MANAGE_PROTECTED_BRANCHES,\n  );\n};\n\nexport const hasGitAppManageDefaultBranchPermission = (\n  permissions: string[] = [],\n) => {\n  return isPermitted(\n    permissions,\n    PERMISSION_TYPE.GIT_APPLICATION_MANAGE_DEFAULT_BRANCH,\n  );\n};\n\nexport const hasGitAppManageAutoCommitPermission = (\n  permissions: string[] = [],\n) => {\n  return isPermitted(\n    permissions,\n    PERMISSION_TYPE.GIT_APPLICATION_MANAGE_AUTO_COMMIT,\n  );\n};\n","import {\n  BUILDER_CUSTOM_PATH,\n  BUILDER_PATH,\n  BUILDER_PATH_DEPRECATED,\n} from \"ee/constants/routes/appRoutes\";\n\nimport type { EntityItem } from \"ee/IDE/Interfaces/EntityItem\";\nimport { getHasManageActionPermission } from \"ee/utils/BusinessFeatures/permissionPageHelpers\";\n\nexport const EDITOR_PATHS = [\n  BUILDER_CUSTOM_PATH,\n  BUILDER_PATH,\n  BUILDER_PATH_DEPRECATED,\n];\n\nexport interface EditableTabPermissions {\n  isFeatureEnabled: boolean;\n  entity?: EntityItem;\n}\n\nexport const getEditableTabPermissions = ({\n  entity,\n  isFeatureEnabled,\n}: EditableTabPermissions) => {\n  return getHasManageActionPermission(\n    isFeatureEnabled,\n    entity?.userPermissions || [],\n  );\n};\n","import type { Position } from \"codemirror\";\nimport type { LintError } from \"utils/DynamicBindingUtils\";\nimport { JSHINT as jshint } from \"jshint\";\nimport type { LintError as JSHintError } from \"jshint\";\nimport { get, isEmpty, isNumber, keys } from \"lodash\";\nimport type {\n  MemberExpressionData,\n  AssignmentExpressionData,\n  CallExpressionData,\n  MemberCallExpressionData,\n} from \"@shared/ast\";\nimport {\n  extractExpressionsFromCode,\n  isIdentifierNode,\n  isLiteralNode,\n} from \"@shared/ast\";\nimport { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport type { EvaluationScriptType } from \"workers/Evaluation/evaluate\";\nimport { EvaluationScripts, ScriptTemplate } from \"workers/Evaluation/evaluate\";\nimport {\n  asyncActionInSyncFieldLintMessage,\n  CustomLintErrorCode,\n  CUSTOM_LINT_ERRORS,\n  IDENTIFIER_NOT_DEFINED_LINT_ERROR_CODE,\n  IGNORED_LINT_ERRORS,\n  lintOptions,\n  SUPPORTED_WEB_APIS,\n  LINTER_TYPE,\n} from \"../constants\";\nimport type { getLintingErrorsProps } from \"../types\";\nimport { JSLibraries } from \"workers/common/JSLibrary\";\nimport getLintSeverity from \"./getLintSeverity\";\nimport { APPSMITH_GLOBAL_FUNCTIONS } from \"components/editorComponents/ActionCreator/constants\";\nimport { last } from \"lodash\";\nimport { isWidget } from \"ee/workers/Evaluation/evaluationUtils\";\nimport setters from \"workers/Evaluation/setters\";\nimport { isMemberExpressionNode } from \"@shared/ast/src\";\nimport { generate } from \"astring\";\nimport getInvalidModuleInputsError from \"ee/plugins/Linting/utils/getInvalidModuleInputsError\";\nimport { objectKeys } from \"@appsmith/utils\";\nimport { profileFn } from \"instrumentation/generateWebWorkerTraces\";\nimport { WorkerEnv } from \"workers/Evaluation/handlers/workerEnv\";\nimport { FEATURE_FLAG } from \"ee/entities/FeatureFlag\";\nimport { Linter } from \"eslint-linter-browserify\";\nimport { ENTITY_TYPE } from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport type { AppsmithEntity } from \"ee/entities/DataTree/types\";\nimport { getIDETypeByUrl } from \"ee/entities/IDE/utils\";\nimport { IDE_TYPE, type IDEType } from \"ee/IDE/Interfaces/IDETypes\";\n\nconst EvaluationScriptPositions: Record<string, Position> = {};\n\nfunction getLinterType() {\n  let linterType = LINTER_TYPE.JSHINT;\n\n  const flagValues = WorkerEnv.getFeatureFlags();\n\n  if (flagValues?.[FEATURE_FLAG.rollout_eslint_enabled]) {\n    linterType = LINTER_TYPE.ESLINT;\n  }\n\n  return linterType;\n}\n\nfunction getEvaluationScriptPosition(scriptType: EvaluationScriptType) {\n  if (isEmpty(EvaluationScriptPositions)) {\n    // We are computing position of <<script>> in our templates.\n    // This will be used to get the exact location of error in linting\n    keys(EvaluationScripts).forEach((type) => {\n      EvaluationScriptPositions[type] = getPositionInEvaluationScript(\n        type as EvaluationScriptType,\n      );\n    });\n  }\n\n  return EvaluationScriptPositions[scriptType];\n}\n\nexport function generateLintingGlobalData(\n  data: Record<string, unknown>,\n  linterType = LINTER_TYPE.JSHINT,\n) {\n  const asyncFunctions: string[] = [];\n  let ideType: IDEType = IDE_TYPE.App;\n  let globalData: Record<string, boolean | \"readonly\" | \"writable\"> = {};\n\n  if (linterType === LINTER_TYPE.JSHINT) {\n    // TODO: cleanup jshint implementation once rollout is complete\n\n    for (const dataKey in data) {\n      globalData[dataKey] = true;\n    }\n\n    // Add all js libraries\n    const libAccessors = ([] as string[]).concat(\n      ...JSLibraries.map((lib) => lib.accessor),\n    );\n\n    libAccessors.forEach((accessor) => (globalData[accessor] = true));\n    // Add all supported web apis\n    objectKeys(SUPPORTED_WEB_APIS).forEach(\n      (apiName) => (globalData[apiName] = true),\n    );\n  } else {\n    globalData = {\n      setTimeout: \"readonly\",\n      clearTimeout: \"readonly\",\n      console: \"readonly\",\n    };\n\n    for (const dataKey in data) {\n      globalData[dataKey] = \"readonly\";\n\n      const dataValue = data[dataKey] as DataTreeEntity;\n\n      if (\n        !!dataValue &&\n        dataValue.hasOwnProperty(\"ENTITY_TYPE\") &&\n        !!dataValue[\"ENTITY_TYPE\"]\n      ) {\n        const { ENTITY_TYPE: dataValueEntityType } = dataValue;\n\n        if (dataValueEntityType === ENTITY_TYPE.ACTION) {\n          asyncFunctions.push(`${dataKey}.run`);\n        } else if (dataValueEntityType === ENTITY_TYPE.JSACTION) {\n          const ignoreKeys = [\"body\", \"ENTITY_TYPE\", \"actionId\"];\n\n          for (const key in dataValue) {\n            if (!ignoreKeys.includes(key)) {\n              const value = dataValue[key];\n\n              if (\n                typeof value === \"string\" &&\n                value.startsWith(\"async function\")\n              ) {\n                asyncFunctions.push(`${dataKey}.${key}`);\n              }\n            }\n          }\n        } else if (dataValueEntityType === ENTITY_TYPE.APPSMITH) {\n          const appsmithEntity: AppsmithEntity = dataValue;\n\n          ideType = getIDETypeByUrl(appsmithEntity.URL.pathname);\n        }\n      }\n    }\n\n    // Add all js libraries\n    const libAccessors = ([] as string[]).concat(\n      ...JSLibraries.map((lib) => lib.accessor),\n    );\n\n    libAccessors.forEach((accessor) => (globalData[accessor] = \"readonly\"));\n    // Add all supported web apis\n    objectKeys(SUPPORTED_WEB_APIS).forEach(\n      (apiName) => (globalData[apiName] = \"readonly\"),\n    );\n  }\n\n  return { globalData, asyncFunctions, ideType };\n}\n\nfunction sanitizeESLintErrors(\n  lintErrors: Linter.LintMessage[],\n  scriptPos: Position,\n): Linter.LintMessage[] {\n  return lintErrors.reduce((result: Linter.LintMessage[], lintError) => {\n    // Ignored errors should not be reported\n    if (IGNORED_LINT_ERRORS.includes(lintError.ruleId || \"\")) return result;\n\n    /** Some error messages reference line numbers,\n     * Eg. Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'\n     * these line numbers need to be re-calculated based on the binding location.\n     * Errors referencing line numbers outside the user's script should also be ignored\n     * */\n    let message = lintError.message;\n    const matchedLines = message.match(/line \\d/gi);\n    const lineNumbersInErrorMessage = new Set<number>();\n    let isInvalidErrorMessage = false;\n\n    if (matchedLines) {\n      matchedLines.forEach((lineStatement) => {\n        const digitString = lineStatement.split(\" \")[1];\n        const digit = Number(digitString);\n\n        if (isNumber(digit)) {\n          if (digit < scriptPos.line) {\n            // referenced line number is outside the scope of user's script\n            isInvalidErrorMessage = true;\n          } else {\n            lineNumbersInErrorMessage.add(digit);\n          }\n        }\n      });\n    }\n\n    if (isInvalidErrorMessage) return result;\n\n    if (lineNumbersInErrorMessage.size) {\n      Array.from(lineNumbersInErrorMessage).forEach((lineNumber) => {\n        message = message.replaceAll(\n          `line ${lineNumber}`,\n          `line ${lineNumber - scriptPos.line + 1}`,\n        );\n      });\n    }\n\n    result.push({\n      ...lintError,\n      message,\n    });\n\n    return result;\n  }, []);\n}\n\nfunction sanitizeJSHintErrors(\n  lintErrors: JSHintError[],\n  scriptPos: Position,\n): JSHintError[] {\n  return lintErrors.reduce((result: JSHintError[], lintError) => {\n    // Ignored errors should not be reported\n    if (IGNORED_LINT_ERRORS.includes(lintError.code)) return result;\n\n    /** Some error messages reference line numbers,\n     * Eg. Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'\n     * these line numbers need to be re-calculated based on the binding location.\n     * Errors referencing line numbers outside the user's script should also be ignored\n     * */\n    let message = lintError.reason;\n    const matchedLines = message.match(/line \\d/gi);\n    const lineNumbersInErrorMessage = new Set<number>();\n    let isInvalidErrorMessage = false;\n\n    if (matchedLines) {\n      matchedLines.forEach((lineStatement) => {\n        const digitString = lineStatement.split(\" \")[1];\n        const digit = Number(digitString);\n\n        if (isNumber(digit)) {\n          if (digit < scriptPos.line) {\n            // referenced line number is outside the scope of user's script\n            isInvalidErrorMessage = true;\n          } else {\n            lineNumbersInErrorMessage.add(digit);\n          }\n        }\n      });\n    }\n\n    if (isInvalidErrorMessage) return result;\n\n    if (lineNumbersInErrorMessage.size) {\n      Array.from(lineNumbersInErrorMessage).forEach((lineNumber) => {\n        message = message.replaceAll(\n          `line ${lineNumber}`,\n          `line ${lineNumber - scriptPos.line + 1}`,\n        );\n      });\n    }\n\n    result.push({\n      ...lintError,\n      reason: message,\n    });\n\n    return result;\n  }, []);\n}\n\nconst getLintErrorMessage = (\n  reason: string,\n  code: string,\n  variables: string[],\n  isJSObject = false,\n): string => {\n  switch (code) {\n    case IDENTIFIER_NOT_DEFINED_LINT_ERROR_CODE: {\n      return getRefinedW117Error(variables[0], reason, isJSObject);\n    }\n    default: {\n      return reason;\n    }\n  }\n};\n\nfunction convertESLintErrorToAppsmithLintError(\n  eslintError: Linter.LintMessage,\n  script: string,\n  originalBinding: string,\n  scriptPos: Position,\n): LintError {\n  const { column, endColumn = 0, line, message, ruleId } = eslintError;\n\n  // Compute actual error position\n  const actualErrorLineNumber = line - scriptPos.line;\n  const actualErrorCh =\n    line === scriptPos.line\n      ? eslintError.column - scriptPos.ch\n      : eslintError.column;\n\n  return {\n    errorType: PropertyEvaluationErrorType.LINT,\n    raw: script,\n    severity: getLintSeverity(ruleId || \"\", message),\n    errorMessage: {\n      name: \"LintingError\",\n      message: message,\n    },\n    errorSegment: \"\",\n    originalBinding,\n    // By keeping track of these variables we can highlight the exact text that caused the error.\n    variables: [],\n    lintLength: Math.max(endColumn - column, 0),\n    code: ruleId || \"\",\n    line: actualErrorLineNumber,\n    ch: actualErrorCh,\n  };\n}\n\nfunction convertJsHintErrorToAppsmithLintError(\n  jsHintError: JSHintError,\n  script: string,\n  originalBinding: string,\n  scriptPos: Position,\n  isJSObject = false,\n): LintError {\n  const { a, b, c, code, d, evidence, reason } = jsHintError;\n\n  // Compute actual error position\n  const actualErrorLineNumber = jsHintError.line - scriptPos.line;\n  const actualErrorCh =\n    jsHintError.line === scriptPos.line\n      ? jsHintError.character - scriptPos.ch\n      : jsHintError.character;\n  const lintErrorMessage = getLintErrorMessage(\n    reason,\n    code,\n    [a, b, c, d],\n    isJSObject,\n  );\n\n  return {\n    errorType: PropertyEvaluationErrorType.LINT,\n    raw: script,\n    severity: getLintSeverity(code, lintErrorMessage),\n    errorMessage: {\n      name: \"LintingError\",\n      message: lintErrorMessage,\n    },\n    errorSegment: evidence,\n    originalBinding,\n    // By keeping track of these variables we can highlight the exact text that caused the error.\n    variables: [a, b, c, d],\n    code: code,\n    line: actualErrorLineNumber,\n    ch: actualErrorCh,\n  };\n}\n\nexport default function getLintingErrors({\n  data,\n  // this is added to help with tests, once jshint is removed, this param can be removed\n  getLinterTypeFn = getLinterType,\n  options,\n  originalBinding,\n  script,\n  scriptType,\n  webworkerTelemetry,\n}: getLintingErrorsProps): LintError[] {\n  const linterType = getLinterTypeFn();\n  const scriptPos = getEvaluationScriptPosition(scriptType);\n  const {\n    asyncFunctions,\n    globalData: lintingGlobalData,\n    ideType,\n  } = generateLintingGlobalData(data, linterType);\n  const lintingOptions = lintOptions(\n    lintingGlobalData,\n    asyncFunctions,\n    ideType,\n    linterType,\n  );\n\n  let messages: Linter.LintMessage[] = [];\n  let lintErrors: LintError[] = [];\n\n  profileFn(\n    \"Linter\",\n    // adding some metrics to compare the performance changes with eslint\n    {\n      linter: linterType,\n      linesOfCodeLinted: originalBinding.split(\"\\n\").length,\n      codeSizeInChars: originalBinding.length,\n    },\n    webworkerTelemetry,\n    () => {\n      if (linterType === LINTER_TYPE.JSHINT) {\n        jshint(script, lintingOptions);\n      } else if (linterType === LINTER_TYPE.ESLINT) {\n        const linter = new Linter();\n\n        messages = linter.verify(script, lintingOptions);\n      }\n    },\n  );\n\n  if (linterType === LINTER_TYPE.JSHINT) {\n    const sanitizedJSHintErrors = sanitizeJSHintErrors(\n      jshint.errors,\n      scriptPos,\n    );\n\n    lintErrors = sanitizedJSHintErrors.map((lintError) =>\n      convertJsHintErrorToAppsmithLintError(\n        lintError,\n        script,\n        originalBinding,\n        scriptPos,\n        options?.isJsObject,\n      ),\n    );\n  } else {\n    const sanitizedESLintErrors = sanitizeESLintErrors(messages, scriptPos);\n\n    lintErrors = sanitizedESLintErrors.map((lintError) =>\n      convertESLintErrorToAppsmithLintError(\n        lintError,\n        script,\n        originalBinding,\n        scriptPos,\n      ),\n    );\n  }\n\n  const customLintErrors = getCustomErrorsFromScript(\n    script,\n    data,\n    scriptPos,\n    originalBinding,\n    options?.isJsObject,\n  );\n\n  return lintErrors.concat(customLintErrors);\n}\n\nfunction getInvalidWidgetPropertySetterErrors({\n  assignmentExpressions,\n  data,\n  originalBinding,\n  script,\n  scriptPos,\n}: {\n  data: Record<string, unknown>;\n  assignmentExpressions: AssignmentExpressionData[];\n  scriptPos: Position;\n  originalBinding: string;\n  script: string;\n}) {\n  const invalidWidgetPropertySetterErrors: LintError[] = [];\n  const setterAccessorMap = setters.getSetterAccessorMap();\n\n  for (const { object, parentNode, property } of assignmentExpressions) {\n    if (!isIdentifierNode(object)) continue;\n\n    const assignmentExpressionString = generate(parentNode);\n    const objectName = object.name;\n    const propertyName = isLiteralNode(property)\n      ? (property.value as string)\n      : property.name;\n\n    const entity = data[objectName];\n\n    if (!entity || !isWidget(entity)) continue;\n\n    const isValidProperty = propertyName in entity;\n\n    const methodName = get(setterAccessorMap, `${objectName}.${propertyName}`);\n\n    const lintErrorMessage = CUSTOM_LINT_ERRORS[\n      CustomLintErrorCode.INVALID_WIDGET_PROPERTY_SETTER\n    ](methodName, objectName, propertyName, isValidProperty);\n\n    // line position received after AST parsing is 1 more than the actual line of code, hence we subtract 1 to get the actual line number\n    const objectStartLine = object.loc.start.line - 1;\n\n    // AST parsing start column position from index 0 whereas codemirror start ch position from index 1, hence we add 1 to get the actual ch position\n    const objectStartCol = object.loc.start.column + 1;\n\n    invalidWidgetPropertySetterErrors.push({\n      errorType: PropertyEvaluationErrorType.LINT,\n      raw: script,\n      severity: getLintSeverity(\n        CustomLintErrorCode.INVALID_WIDGET_PROPERTY_SETTER,\n        lintErrorMessage,\n      ),\n      errorMessage: {\n        name: \"LintingError\",\n        message: lintErrorMessage,\n      },\n      errorSegment: assignmentExpressionString,\n      originalBinding,\n      variables: [assignmentExpressionString, null, null],\n      code: CustomLintErrorCode.INVALID_ENTITY_PROPERTY,\n      line: objectStartLine - scriptPos.line,\n      ch:\n        objectStartLine === scriptPos.line\n          ? objectStartCol - scriptPos.ch\n          : objectStartCol,\n    });\n  }\n\n  return invalidWidgetPropertySetterErrors;\n}\n\nfunction getInvalidAppsmithStoreSetterErrors({\n  appsmithStoreMutationExpressions,\n  originalBinding,\n  script,\n  scriptPos,\n}: {\n  data: Record<string, unknown>;\n  appsmithStoreMutationExpressions: Array<\n    AssignmentExpressionData | MemberCallExpressionData\n  >;\n  scriptPos: Position;\n  originalBinding: string;\n  script: string;\n}) {\n  const assignmentExpressionErrors: LintError[] = [];\n\n  for (const { object, parentNode } of appsmithStoreMutationExpressions) {\n    if (!isMemberExpressionNode(object)) continue;\n\n    const assignmentExpressionString = generate(parentNode);\n\n    if (!assignmentExpressionString.startsWith(\"appsmith.store\")) continue;\n\n    const lintErrorMessage =\n      CUSTOM_LINT_ERRORS[\n        CustomLintErrorCode.INVALID_APPSMITH_STORE_PROPERTY_SETTER\n      ]();\n\n    // line position received after AST parsing is 1 more than the actual line of code, hence we subtract 1 to get the actual line number\n    const objectStartLine = object.loc.start.line - 1;\n\n    // AST parsing start column position from index 0 whereas codemirror start ch position from index 1, hence we add 1 to get the actual ch position\n    const objectStartCol = object.loc.start.column + 1;\n\n    assignmentExpressionErrors.push({\n      errorType: PropertyEvaluationErrorType.LINT,\n      raw: script,\n      severity: getLintSeverity(\n        CustomLintErrorCode.INVALID_APPSMITH_STORE_PROPERTY_SETTER,\n        lintErrorMessage,\n      ),\n      errorMessage: {\n        name: \"LintingError\",\n        message: lintErrorMessage,\n      },\n      errorSegment: assignmentExpressionString,\n      originalBinding,\n      variables: [assignmentExpressionString, null, null],\n      code: CustomLintErrorCode.INVALID_APPSMITH_STORE_PROPERTY_SETTER,\n      line: objectStartLine - scriptPos.line,\n      ch:\n        objectStartLine === scriptPos.line\n          ? objectStartCol - scriptPos.ch\n          : objectStartCol,\n    });\n  }\n\n  return assignmentExpressionErrors;\n}\n\nfunction getInvalidEntityPropertyErrors(\n  invalidTopLevelMemberExpressions: MemberExpressionData[],\n  script: string,\n  data: Record<string, unknown>,\n  scriptPos: Position,\n  originalBinding: string,\n  isJSObject: boolean,\n) {\n  return invalidTopLevelMemberExpressions.map(\n    ({ object, property }): LintError => {\n      const propertyName = isLiteralNode(property)\n        ? (property.value as string)\n        : property.name;\n      // line position received after AST parsing is 1 more than the actual line of code, hence we subtract 1 to get the actual line number\n      const objectStartLine = object.loc.start.line - 1;\n      // For computed member expressions (entity[\"property\"]), add an extra 1 to the start column to account for \"[\".\n      const propertyStartColumn = !isLiteralNode(property)\n        ? property.loc.start.column + 1\n        : property.loc.start.column + 2;\n      const lintErrorMessage = CUSTOM_LINT_ERRORS[\n        CustomLintErrorCode.INVALID_ENTITY_PROPERTY\n      ](object.name, propertyName, data[object.name], isJSObject);\n\n      return {\n        errorType: PropertyEvaluationErrorType.LINT,\n        raw: script,\n        severity: getLintSeverity(\n          CustomLintErrorCode.INVALID_ENTITY_PROPERTY,\n          lintErrorMessage,\n        ),\n        errorMessage: {\n          name: \"LintingError\",\n          message: lintErrorMessage,\n        },\n        errorSegment: `${object.name}.${propertyName}`,\n        originalBinding,\n        variables: [propertyName, null, null, null],\n        code: CustomLintErrorCode.INVALID_ENTITY_PROPERTY,\n        line: objectStartLine - scriptPos.line,\n        ch:\n          objectStartLine === scriptPos.line\n            ? propertyStartColumn - scriptPos.ch\n            : propertyStartColumn,\n      };\n    },\n  );\n}\n\n// returns custom lint errors caused by\n// 1. accessing invalid properties. Eg. jsObject.unknownProperty\n// 2. direct mutation of widget properties. Eg. widget1.left = 10\n// 3. imperative update of appsmith store object. Eg. appsmith.store.val = 10\nfunction getCustomErrorsFromScript(\n  script: string,\n  data: Record<string, unknown>,\n  scriptPos: Position,\n  originalBinding: string,\n  isJSObject = false,\n): LintError[] {\n  let invalidTopLevelMemberExpressions: MemberExpressionData[] = [];\n  let assignmentExpressions: AssignmentExpressionData[] = [];\n  let callExpressions: CallExpressionData[] = [];\n  let memberCallExpressions: MemberCallExpressionData[] = [];\n\n  try {\n    const value = extractExpressionsFromCode(\n      script,\n      data,\n      self.evaluationVersion,\n    );\n\n    invalidTopLevelMemberExpressions =\n      value.invalidTopLevelMemberExpressionsArray;\n    assignmentExpressions = value.assignmentExpressionsData;\n    callExpressions = value.callExpressionsData;\n    memberCallExpressions = value.memberCallExpressionData;\n  } catch (e) {}\n\n  const invalidWidgetPropertySetterErrors =\n    getInvalidWidgetPropertySetterErrors({\n      assignmentExpressions,\n      script,\n      scriptPos,\n      originalBinding,\n      data,\n    });\n\n  const invalidPropertyErrors = getInvalidEntityPropertyErrors(\n    invalidTopLevelMemberExpressions,\n    script,\n    data,\n    scriptPos,\n    originalBinding,\n    isJSObject,\n  );\n\n  // This ensures that all cases where appsmith.store is getting modified\n  // either by assignment using `appsmith.store.test = \"\"`\n  // or by calling a function like `appsmith.store.test.push()` will result in lint error\n  const appsmithStoreMutationExpressions: Array<\n    AssignmentExpressionData | MemberCallExpressionData\n  > = [...assignmentExpressions, ...memberCallExpressions];\n\n  const invalidAppsmithStorePropertyErrors =\n    getInvalidAppsmithStoreSetterErrors({\n      appsmithStoreMutationExpressions,\n      script,\n      scriptPos,\n      originalBinding,\n      data,\n    });\n\n  const moduleInputErrors = getInvalidModuleInputsError({\n    memberCallExpressions,\n    originalBinding,\n    scriptPos,\n    data,\n    script,\n  });\n\n  const invalidActionModalErrors = getActionModalStringValueErrors({\n    callExpressions,\n    script,\n    scriptPos,\n    originalBinding,\n  });\n\n  return [\n    ...invalidPropertyErrors,\n    ...invalidWidgetPropertySetterErrors,\n    ...invalidAppsmithStorePropertyErrors,\n    ...invalidActionModalErrors,\n    ...moduleInputErrors,\n  ];\n}\n\nfunction getRefinedW117Error(\n  undefinedVar: string,\n  originalReason: string,\n  isJsObject = false,\n) {\n  // Refine error message for await using in field not marked as async\n  if (undefinedVar === \"await\") {\n    return \"'await' expressions are only allowed within async functions. Did you mean to mark this function as 'async'?\";\n  }\n\n  // Handle case where platform functions are used in data fields\n  if (APPSMITH_GLOBAL_FUNCTIONS.hasOwnProperty(undefinedVar)) {\n    return asyncActionInSyncFieldLintMessage(isJsObject);\n  }\n\n  return originalReason;\n}\n\nfunction getPositionInEvaluationScript(type: EvaluationScriptType): Position {\n  const script = EvaluationScripts[type];\n\n  const index = script.indexOf(ScriptTemplate);\n  const substr = script.slice(0, index !== -1 ? index : 0);\n  const lines = substr.split(\"\\n\");\n  const lastLine = last(lines) || \"\";\n\n  return { line: lines.length, ch: lastLine.length };\n}\n\nfunction getActionModalStringValueErrors({\n  callExpressions,\n  originalBinding,\n  script,\n  scriptPos,\n}: {\n  callExpressions: CallExpressionData[];\n  scriptPos: Position;\n  originalBinding: string;\n  script: string;\n}) {\n  const actionModalLintErrors: LintError[] = [];\n\n  for (const { params, property } of callExpressions) {\n    if (property.name === \"showModal\" || property.name === \"closeModal\") {\n      if (params[0] && isLiteralNode(params[0])) {\n        const lintErrorMessage = CUSTOM_LINT_ERRORS[\n          CustomLintErrorCode.ACTION_MODAL_STRING\n        ](params[0].value);\n        const callExpressionsString = generate(params[0]);\n\n        // line position received after AST parsing is 1 more than the actual line of code, hence we subtract 1 to get the actual line number\n        const objectStartLine = params[0].loc.start.line - 1;\n\n        // AST parsing start column position from index 0 whereas codemirror start ch position from index 1, hence we add 1 to get the actual ch position\n        const objectStartCol = params[0].loc.start.column + 1;\n\n        actionModalLintErrors.push({\n          errorType: PropertyEvaluationErrorType.LINT,\n          raw: script,\n          severity: getLintSeverity(\n            CustomLintErrorCode.ACTION_MODAL_STRING,\n            lintErrorMessage,\n          ),\n          errorMessage: {\n            name: \"LintingError\",\n            message: lintErrorMessage,\n          },\n          errorSegment: callExpressionsString,\n          originalBinding,\n          variables: [callExpressionsString, null, null],\n          code: CustomLintErrorCode.ACTION_MODAL_STRING,\n          line: objectStartLine - scriptPos.line,\n          ch:\n            objectStartLine === scriptPos.line\n              ? objectStartCol - scriptPos.ch\n              : objectStartCol,\n        });\n      }\n    }\n  }\n\n  return actionModalLintErrors;\n}\n","import type { IDEType } from \"ee/IDE/Interfaces/IDETypes\";\n\ninterface ContextType {\n  ideType: IDEType;\n}\n\n/**\n * Function used to conditionally enable/disable custom rules based on context provided\n *\n * @returns {Record<string, \"off\"|\"error\">} Object with settings for the rule\n * */\nexport const getLintRulesBasedOnContext = ({}: ContextType): Record<\n  string,\n  \"off\" | \"error\"\n> => {\n  return {};\n};\n","import type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { isJSAction } from \"ee/workers/Evaluation/evaluationUtils\";\n\n// Removes \"export default\" statement from js Object\n\nexport function getJSToLint(\n  entity: DataTreeEntity,\n  snippet: string,\n  propertyPath: string,\n): string {\n  return entity && isJSAction(entity) && propertyPath === \"body\"\n    ? snippet.replace(/export default/g, \"\")\n    : snippet;\n}\n","import type { LintError } from \"utils/DynamicBindingUtils\";\nimport type { DependencyMap } from \"utils/DynamicBindingUtils\";\nimport { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { CustomLintErrorCode, CUSTOM_LINT_ERRORS } from \"../constants\";\nimport type {\n  TJSFunctionPropertyState,\n  TJSpropertyState,\n} from \"workers/Evaluation/JSObject/jsPropertiesState\";\nimport { globalData } from \"../globalData\";\nimport getLintSeverity from \"./getLintSeverity\";\nimport lintJSProperty from \"./lintJSProperty\";\nimport { isEmpty } from \"lodash\";\nimport type { WebworkerTelemetryAttribute } from \"../types\";\n\nexport default function lintJSObjectProperty(\n  jsPropertyFullName: string,\n  jsObjectState: Record<string, TJSpropertyState>,\n  asyncJSFunctionsInDataFields: DependencyMap,\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>,\n) {\n  let lintErrors: LintError[] = [];\n  const { propertyPath: jsPropertyName } =\n    getEntityNameAndPropertyPath(jsPropertyFullName);\n  const jsPropertyState = jsObjectState[jsPropertyName];\n  const isAsyncJSFunctionBoundToSyncField =\n    asyncJSFunctionsInDataFields.hasOwnProperty(jsPropertyFullName) &&\n    !isEmpty(asyncJSFunctionsInDataFields[jsPropertyFullName]);\n\n  const jsPropertyLintErrors = lintJSProperty(\n    jsPropertyFullName,\n    jsPropertyState,\n    globalData.getGlobalData(!isAsyncJSFunctionBoundToSyncField),\n    webworkerTelemetry,\n  );\n\n  lintErrors = lintErrors.concat(jsPropertyLintErrors);\n\n  // if function is async, and bound to a data field, then add custom lint error\n  if (isAsyncJSFunctionBoundToSyncField) {\n    lintErrors.push(\n      generateAsyncFunctionBoundToDataFieldCustomError(\n        asyncJSFunctionsInDataFields[jsPropertyFullName],\n        jsPropertyState,\n        jsPropertyFullName,\n      ),\n    );\n  }\n\n  return lintErrors;\n}\n\nfunction generateAsyncFunctionBoundToDataFieldCustomError(\n  dataFieldBindings: string[],\n  jsPropertyState: TJSpropertyState,\n  jsPropertyFullName: string,\n): LintError {\n  const { propertyPath: jsPropertyName } =\n    getEntityNameAndPropertyPath(jsPropertyFullName);\n  const lintErrorMessage =\n    CUSTOM_LINT_ERRORS.ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD(\n      dataFieldBindings,\n      jsPropertyFullName,\n      (jsPropertyState as TJSFunctionPropertyState).isMarkedAsync,\n    );\n\n  return {\n    errorType: PropertyEvaluationErrorType.LINT,\n    raw: jsPropertyState.value,\n    severity: getLintSeverity(\n      CustomLintErrorCode.ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD,\n      lintErrorMessage,\n    ),\n    errorMessage: {\n      name: \"LintingError\",\n      message: lintErrorMessage,\n    },\n    errorSegment: jsPropertyFullName,\n    originalBinding: jsPropertyState.value,\n    // By keeping track of these variables we can highlight the exact text that caused the error.\n    variables: [jsPropertyName, null, null, null],\n    code: CustomLintErrorCode.ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD,\n    line: jsPropertyState.position.keyStartLine - 1,\n    ch: jsPropertyState.position.keyStartColumn + 1,\n    originalPath: jsPropertyFullName,\n  };\n}\n","import type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport type { LintError } from \"utils/DynamicBindingUtils\";\nimport { isNil } from \"lodash\";\nimport {\n  EvaluationScriptType,\n  getScriptToEval,\n  getScriptType,\n} from \"workers/Evaluation/evaluate\";\nimport type { TJSpropertyState } from \"workers/Evaluation/JSObject/jsPropertiesState\";\nimport getLintingErrors from \"./getLintingErrors\";\nimport type { WebworkerTelemetryAttribute } from \"../types\";\n\nexport default function lintJSProperty(\n  jsPropertyFullName: string,\n  jsPropertyState: TJSpropertyState,\n  globalData: DataTree,\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>,\n): LintError[] {\n  if (isNil(jsPropertyState)) {\n    return [];\n  }\n\n  const scriptType = getScriptType(false, false);\n  const scriptToLint = getScriptToEval(\n    jsPropertyState.value,\n    EvaluationScriptType.OBJECT_PROPERTY,\n  );\n  const propLintErrors = getLintingErrors({\n    script: scriptToLint,\n    data: globalData,\n    originalBinding: jsPropertyState.value,\n    scriptType,\n    options: { isJsObject: true },\n    webworkerTelemetry,\n  });\n  const refinedErrors = propLintErrors.map((lintError) => {\n    return {\n      ...lintError,\n      line: lintError.line + jsPropertyState.position.startLine - 1,\n      ch:\n        lintError.line === 0\n          ? lintError.ch + jsPropertyState.position.startColumn\n          : lintError.ch,\n      originalPath: jsPropertyFullName,\n    };\n  });\n\n  return refinedErrors;\n}\n","import { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\nimport { get, isEmpty, set } from \"lodash\";\nimport type { LintErrorsStore } from \"reducers/lintingReducers/lintErrorsReducers\";\nimport type { LintError } from \"utils/DynamicBindingUtils\";\nimport { globalData } from \"./globalData\";\nimport lintBindingPath from \"./utils/lintBindingPath\";\nimport lintTriggerPath from \"./utils/lintTriggerPath\";\nimport lintJSObjectBody from \"./utils/lintJSObjectBody\";\nimport sortLintingPathsByType from \"./utils/sortLintingPathsByType\";\nimport lintJSObjectProperty from \"./utils/lintJSObjectProperty\";\nimport setters from \"workers/Evaluation/setters\";\nimport type {\n  getLintErrorsFromTreeProps,\n  getLintErrorsFromTreeResponse,\n} from \"./types\";\n\nexport function getLintErrorsFromTree({\n  asyncJSFunctionsInDataFields,\n  cloudHosting,\n  configTree,\n  jsPropertiesState,\n  pathsToLint,\n  unEvalTree,\n  webworkerTelemetry,\n}: getLintErrorsFromTreeProps): getLintErrorsFromTreeResponse {\n  const lintTreeErrors: LintErrorsStore = {};\n  const lintedJSPaths = new Set<string>();\n\n  setters.init(configTree, unEvalTree);\n  globalData.initialize(unEvalTree, configTree, cloudHosting);\n\n  const { bindingPaths, jsObjectPaths, triggerPaths } = sortLintingPathsByType(\n    pathsToLint,\n    unEvalTree,\n    configTree,\n  );\n\n  // Lint binding paths\n  bindingPaths.forEach((bindingPath) => {\n    const { entityName } = getEntityNameAndPropertyPath(bindingPath);\n    const entity = unEvalTree[entityName];\n    const unEvalPropertyValue = get(\n      unEvalTree,\n      bindingPath,\n    ) as unknown as string;\n    const lintErrors = lintBindingPath({\n      dynamicBinding: unEvalPropertyValue,\n      entity,\n      fullPropertyPath: bindingPath,\n      globalData: globalData.getGlobalData(false),\n      webworkerTelemetry,\n    });\n\n    set(lintTreeErrors, `[\"${bindingPath}\"]`, lintErrors);\n  });\n\n  // Lint TriggerPaths\n  triggerPaths.forEach((triggerPath) => {\n    const { entityName } = getEntityNameAndPropertyPath(triggerPath);\n    const entity = unEvalTree[entityName];\n    const unEvalPropertyValue = get(\n      unEvalTree,\n      triggerPath,\n    ) as unknown as string;\n\n    // remove all lint errors from path\n    set(lintTreeErrors, `[\"${triggerPath}\"]`, []);\n    const lintErrors = lintTriggerPath({\n      userScript: unEvalPropertyValue,\n      entity,\n      globalData: globalData.getGlobalData(true),\n      webworkerTelemetry,\n    });\n\n    set(lintTreeErrors, `[\"${triggerPath}\"]`, lintErrors);\n  });\n\n  // Lint jsobject paths\n  if (jsObjectPaths.size) {\n    jsObjectPaths.forEach((jsObjectPath) => {\n      const { entityName: jsObjectName, propertyPath: jsPropertyName } =\n        getEntityNameAndPropertyPath(jsObjectPath);\n      const jsObjectState = get(jsPropertiesState, jsObjectName);\n      const jsObjectBodyPath = `[\"${jsObjectName}.body\"]`;\n\n      // An empty state shows that there is a parse error in the jsObject or the object is empty, so we lint the entire body\n      // instead of an individual properties\n      if (isEmpty(jsObjectState)) {\n        lintedJSPaths.add(`${jsObjectName}.body`);\n        const jsObjectBodyLintErrors = lintJSObjectBody(\n          jsObjectName,\n          globalData.getGlobalData(true),\n          webworkerTelemetry,\n        );\n\n        set(lintTreeErrors, jsObjectBodyPath, jsObjectBodyLintErrors);\n      } else if (jsPropertyName !== \"body\") {\n        lintedJSPaths.add(jsObjectPath);\n        const propertyLintErrors = lintJSObjectProperty(\n          jsObjectPath,\n          jsObjectState,\n          asyncJSFunctionsInDataFields,\n          webworkerTelemetry,\n        );\n        const currentLintErrorsInBody = get(\n          lintTreeErrors,\n          jsObjectBodyPath,\n          [] as LintError[],\n        );\n        const updatedLintErrors = [\n          ...currentLintErrorsInBody,\n          ...propertyLintErrors,\n        ];\n\n        set(lintTreeErrors, jsObjectBodyPath, updatedLintErrors);\n      }\n    });\n  }\n\n  return {\n    errors: lintTreeErrors,\n    lintedJSPaths: Array.from(lintedJSPaths),\n  };\n}\n","import type { DataTree, ConfigTree } from \"entities/DataTree/dataTreeTypes\";\nimport {\n  getEntityNameAndPropertyPath,\n  isATriggerPath,\n  isDynamicLeaf,\n  isJSAction,\n} from \"ee/workers/Evaluation/evaluationUtils\";\n\nexport default function sortLintingPathsByType(\n  pathsToLint: string[],\n  unevalTree: DataTree,\n  configTree: ConfigTree,\n) {\n  const triggerPaths = new Set<string>();\n  const bindingPaths = new Set<string>();\n  const jsObjectPaths = new Set<string>();\n\n  for (const fullPropertyPath of pathsToLint) {\n    const { entityName, propertyPath } =\n      getEntityNameAndPropertyPath(fullPropertyPath);\n    const entity = unevalTree[entityName];\n    const entityConfig = configTree[entityName];\n\n    if (isJSAction(entity)) {\n      jsObjectPaths.add(fullPropertyPath);\n      continue;\n    }\n\n    // We are only interested in dynamic leaves\n    if (!isDynamicLeaf(unevalTree, fullPropertyPath, configTree)) continue;\n\n    if (isATriggerPath(entityConfig, propertyPath)) {\n      triggerPaths.add(fullPropertyPath);\n      continue;\n    }\n\n    bindingPaths.add(fullPropertyPath);\n  }\n\n  return { triggerPaths, bindingPaths, jsObjectPaths };\n}\n","import type { LintError } from \"utils/DynamicBindingUtils\";\nimport { getDynamicBindings } from \"utils/DynamicBindingUtils\";\nimport { getScriptToEval, getScriptType } from \"workers/Evaluation/evaluate\";\nimport { getEntityNameAndPropertyPath } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { lintBindingPathProps } from \"../types\";\nimport getLintingErrors from \"./getLintingErrors\";\nimport { getJSToLint } from \"./getJSToLint\";\n\nexport default function lintBindingPath({\n  dynamicBinding,\n  entity,\n  fullPropertyPath,\n  globalData,\n  webworkerTelemetry,\n}: lintBindingPathProps) {\n  let lintErrors: LintError[] = [];\n  const { propertyPath } = getEntityNameAndPropertyPath(fullPropertyPath);\n  // Get the {{binding}} bound values\n  const { jsSnippets, stringSegments } = getDynamicBindings(\n    dynamicBinding,\n    entity,\n  );\n\n  if (stringSegments) {\n    jsSnippets.forEach((jsSnippet, index) => {\n      if (jsSnippet) {\n        const jsSnippetToLint = getJSToLint(entity, jsSnippet, propertyPath);\n        // {{user's code}}\n        const originalBinding = getJSToLint(\n          entity,\n          stringSegments[index],\n          propertyPath,\n        );\n        const scriptType = getScriptType(false, false);\n        const scriptToLint = getScriptToEval(jsSnippetToLint, scriptType);\n        const lintErrorsFromSnippet = getLintingErrors({\n          script: scriptToLint,\n          data: globalData,\n          originalBinding,\n          scriptType,\n          webworkerTelemetry,\n        });\n\n        lintErrors = lintErrors.concat(lintErrorsFromSnippet);\n      }\n    });\n  }\n\n  return lintErrors;\n}\n","import { getDynamicBindings } from \"utils/DynamicBindingUtils\";\nimport {\n  EvaluationScriptType,\n  getScriptToEval,\n} from \"workers/Evaluation/evaluate\";\nimport type { lintTriggerPathProps } from \"../types\";\nimport getLintingErrors from \"./getLintingErrors\";\n\nexport default function lintTriggerPath({\n  entity,\n  globalData,\n  userScript,\n  webworkerTelemetry,\n}: lintTriggerPathProps) {\n  const { jsSnippets } = getDynamicBindings(userScript, entity);\n  const script = getScriptToEval(jsSnippets[0], EvaluationScriptType.TRIGGERS);\n\n  return getLintingErrors({\n    script,\n    data: globalData,\n    originalBinding: jsSnippets[0],\n    scriptType: EvaluationScriptType.TRIGGERS,\n    webworkerTelemetry,\n  });\n}\n","import type { JSActionEntity } from \"ee/entities/DataTree/types\";\nimport type { DataTree } from \"entities/DataTree/dataTreeTypes\";\nimport type { LintError } from \"utils/DynamicBindingUtils\";\nimport { PropertyEvaluationErrorType } from \"utils/DynamicBindingUtils\";\nimport { getScriptToEval, getScriptType } from \"workers/Evaluation/evaluate\";\nimport {\n  INVALID_JSOBJECT_START_STATEMENT,\n  INVALID_JSOBJECT_START_STATEMENT_ERROR_CODE,\n  JS_OBJECT_START_STATEMENT,\n} from \"../constants\";\nimport { Severity } from \"entities/AppsmithConsole\";\nimport { getJSToLint } from \"./getJSToLint\";\nimport getLintingErrors from \"./getLintingErrors\";\nimport type { WebworkerTelemetryAttribute } from \"../types\";\n\nexport default function lintJSObjectBody(\n  jsObjectName: string,\n  globalData: DataTree,\n  webworkerTelemetry: Record<string, WebworkerTelemetryAttribute>,\n): LintError[] {\n  const jsObject = globalData[jsObjectName];\n  const rawJSObjectbody = (jsObject as unknown as JSActionEntity).body;\n\n  if (!rawJSObjectbody) return [];\n\n  if (!rawJSObjectbody.startsWith(JS_OBJECT_START_STATEMENT)) {\n    return [\n      {\n        errorType: PropertyEvaluationErrorType.LINT,\n        errorSegment: \"\",\n        originalBinding: rawJSObjectbody,\n        line: 0,\n        ch: 0,\n        code: INVALID_JSOBJECT_START_STATEMENT_ERROR_CODE,\n        variables: [],\n        raw: rawJSObjectbody,\n        errorMessage: {\n          name: \"LintingError\",\n          message: INVALID_JSOBJECT_START_STATEMENT,\n        },\n        severity: Severity.ERROR,\n      },\n    ];\n  }\n\n  const scriptType = getScriptType(false, false);\n  const jsbodyToLint = getJSToLint(jsObject, rawJSObjectbody, \"body\"); // remove \"export default\"\n  const scriptToLint = getScriptToEval(jsbodyToLint, scriptType);\n\n  return getLintingErrors({\n    script: scriptToLint,\n    data: globalData,\n    originalBinding: jsbodyToLint,\n    scriptType,\n    webworkerTelemetry,\n  });\n}\n","import type {\n  DataTreeEntityConfig,\n  JSActionEntityConfig,\n  JSActionEntity as TJSActionEntity,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { EvaluationSubstitutionType } from \"ee/entities/DataTree/types\";\nimport type { TParsedJSProperty } from \"@shared/ast\";\nimport { isJSFunctionProperty } from \"@shared/ast\";\nimport { parseJSObject } from \"@shared/ast\";\nimport type { JSVarProperty } from \"@shared/ast\";\nimport type { JSFunctionProperty } from \"@shared/ast\";\nimport { uniq } from \"lodash\";\nimport { validJSBodyRegex } from \"workers/Evaluation/JSObject\";\n\nexport interface EntityParser {\n  parse<T extends DataTreeEntity, K extends DataTreeEntityConfig>(\n    entity: T,\n    entityConfig: K,\n  ): ParsedEntity<T>;\n  parse<T extends TJSActionEntity, K extends JSActionEntityConfig>(\n    entity: T,\n    entityConfig: K,\n  ): ParsedEntity<T>;\n}\n\ntype TParsedJSEntity = Record<string, string> & {\n  body: string;\n};\n\ntype TParsedJSEntityConfig = Record<string, TParsedJSProperty>;\n\nexport interface ParsedJSCache {\n  parsedEntity: ParsedEntity<TJSActionEntity>;\n  parsedEntityConfig: TParsedJSEntityConfig;\n}\n\nexport interface ParsedEntity<T> {\n  parsedEntity: Partial<T>;\n  parsedEntityConfig: Record<string, unknown>;\n}\n\nexport class DefaultEntityParser implements EntityParser {\n  parse<T extends DataTreeEntity>(entity: T) {\n    return {\n      parsedEntity: entity,\n      parsedEntityConfig: {},\n    };\n  }\n}\n\nexport class JSLintEntityParser implements EntityParser {\n  #parsedJSCache: ParsedEntity<TJSActionEntity> = {\n    parsedEntity: {},\n    parsedEntityConfig: {},\n  };\n  parse(entity: TJSActionEntity, entityConfig: JSActionEntityConfig) {\n    const jsEntityBody = entity.body || \"\";\n\n    if (\n      this.#parsedJSCache &&\n      jsEntityBody === this.#parsedJSCache.parsedEntity.body\n    ) {\n      return {\n        parsedEntity: this.#parsedJSCache.parsedEntity,\n        parsedEntityConfig: this.#parsedJSCache.parsedEntityConfig,\n      };\n    }\n\n    const { parsedObject, success } = this.#parseJSObjectBody(jsEntityBody);\n\n    const parsedJSEntityConfig: Record<string, unknown> = {};\n    const parsedJSEntity: TParsedJSEntity = { body: jsEntityBody };\n\n    if (success) {\n      for (const [propertyName, parsedPropertyDetails] of Object.entries(\n        parsedObject,\n      )) {\n        const { position, rawContent, type, value } = parsedPropertyDetails;\n\n        parsedJSEntity[propertyName] = value;\n\n        if (isJSFunctionProperty(parsedPropertyDetails)) {\n          parsedJSEntityConfig[propertyName] = {\n            isMarkedAsync: parsedPropertyDetails.isMarkedAsync,\n            position,\n            value: rawContent,\n            type,\n          } as JSFunctionProperty;\n        } else if (type !== \"literal\") {\n          parsedJSEntityConfig[propertyName] = {\n            position: position,\n            value: rawContent,\n            type,\n          } as JSVarProperty;\n        }\n      }\n    }\n\n    // Save parsed entity to cache\n    this.#parsedJSCache = {\n      parsedEntity: parsedJSEntity,\n      parsedEntityConfig: parsedJSEntityConfig,\n    };\n\n    // update entity and entity config\n    const requiredProps = [\"actionId\", \"body\", \"ENTITY_TYPE\"];\n\n    for (const property of Object.keys(entity)) {\n      if (requiredProps.includes(property)) continue;\n\n      delete entity[property];\n      delete entityConfig.reactivePaths[property];\n    }\n\n    for (const [propertyName, propertyValue] of Object.entries(\n      parsedJSEntity,\n    )) {\n      entity[propertyName] = propertyValue;\n      entityConfig.reactivePaths[propertyName] =\n        EvaluationSubstitutionType.TEMPLATE;\n      const propertyConfig = parsedJSEntityConfig[\n        propertyName\n      ] as TParsedJSProperty;\n\n      if (propertyConfig && isJSFunctionProperty(propertyConfig)) {\n        entity[`${propertyName}.data`] = {};\n      }\n    }\n\n    return this.#parsedJSCache;\n  }\n\n  #isValidJSBody(jsBody: string) {\n    return !!jsBody.trim() && validJSBodyRegex.test(jsBody);\n  }\n\n  #parseJSObjectBody = (jsBody: string) => {\n    const unsuccessfulParsingResponse = {\n      success: false,\n      parsedObject: {},\n    } as const;\n    let response:\n      | { success: false; parsedObject: Record<string, never> }\n      | { success: true; parsedObject: Record<string, TParsedJSProperty> } =\n      unsuccessfulParsingResponse;\n\n    if (this.#isValidJSBody(jsBody)) {\n      const { parsedObject: parsedProperties, success } = parseJSObject(jsBody);\n\n      if (success) {\n        // When a parsed object has duplicate keys, the jsobject is invalid and its body (not individual properties) needs to be linted\n        // so we return an empty object\n        const allPropertyKeys = parsedProperties.map(\n          (property) => property.key,\n        );\n        const uniqueKeys = uniq(allPropertyKeys);\n        const hasUniqueKeys = allPropertyKeys.length === uniqueKeys.length;\n\n        if (hasUniqueKeys) {\n          response = {\n            success: true,\n            parsedObject: parsedProperties.reduce(\n              (acc: Record<string, TParsedJSProperty>, property) => {\n                const updatedProperties = { ...acc, [property.key]: property };\n\n                return updatedProperties;\n              },\n              {},\n            ),\n          } as const;\n        }\n      }\n    }\n\n    return response;\n  };\n}\n\nexport const jsLintEntityParser = new JSLintEntityParser();\n","import type {\n  ConfigTree,\n  DataTree,\n  DataTreeEntity,\n} from \"entities/DataTree/dataTreeTypes\";\nimport type { IEntity } from \"ee/plugins/Linting/lib/entity/types\";\nimport type { Diff } from \"deep-diff\";\nimport EntityFactory from \"ee/plugins/Linting/lib/entity\";\nimport { PathUtils } from \"plugins/Linting/utils/pathUtils\";\nimport { isJSAction } from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { EntityParser } from \"plugins/Linting/utils/entityParser\";\nimport {\n  DefaultEntityParser,\n  JSLintEntityParser,\n} from \"plugins/Linting/utils/entityParser\";\nimport type { EntityDiffGenerator } from \"plugins/Linting/utils/diffGenerator\";\nimport {\n  DefaultDiffGenerator,\n  JSLintDiffGenerator,\n} from \"plugins/Linting/utils/diffGenerator\";\nimport { union } from \"lodash\";\n\nexport abstract class EntityTree {\n  protected tree = new Map<string, IEntity>();\n  protected unEvalTree: DataTree = {};\n  protected configTree: ConfigTree = {};\n  constructor(unEvalTree: DataTree, configTree: ConfigTree) {\n    this.unEvalTree = unEvalTree;\n    this.configTree = configTree;\n  }\n  abstract buildTree(unEvalTree: DataTree, configTree: ConfigTree): void;\n  computeDifferences(newTree: EntityTree) {\n    const differences: Diff<unknown>[] = [];\n\n    if (!newTree) return differences;\n\n    const entityNames = Object.keys(this.getRawTree());\n    const newEntityNames = Object.keys(newTree.getRawTree());\n    const allEntityNames = union(entityNames, newEntityNames);\n\n    for (const entityName of allEntityNames) {\n      const entity = this.getEntityByName(entityName);\n      const newEntity = newTree.getEntityByName(entityName);\n\n      if (!newEntity) {\n        differences.push({\n          path: [entityName],\n          kind: \"D\",\n          lhs: entity?.getRawEntity(),\n        });\n        continue;\n      }\n\n      const difference = newEntity.computeDifference(entity);\n\n      if (!difference) continue;\n\n      differences.push(...difference);\n    }\n\n    return differences;\n  }\n\n  getAllPaths = (): Record<string, true> => {\n    return PathUtils.getAllPaths(this.unEvalTree);\n  };\n\n  getRawTree() {\n    const rawTree: DataTree = {};\n\n    for (const [name, entity] of this.tree.entries()) {\n      rawTree[name] = entity.getRawEntity() as DataTreeEntity;\n    }\n\n    return rawTree as DataTree;\n  }\n\n  getEntityByName(name: string) {\n    return this.tree.get(name);\n  }\n\n  getEntities() {\n    const entities = Array.from(this.tree.values());\n\n    return entities;\n  }\n}\n\nexport interface EntityClassLoader {\n  load(entity: DataTreeEntity): {\n    Parser: { new (): EntityParser };\n    DiffGenerator: { new (): EntityDiffGenerator };\n  };\n}\n\nclass LintEntityClassLoader implements EntityClassLoader {\n  load(entity: DataTreeEntity) {\n    if (isJSAction(entity)) {\n      return {\n        Parser: JSLintEntityParser,\n        DiffGenerator: JSLintDiffGenerator,\n      };\n    }\n\n    return {\n      Parser: DefaultEntityParser,\n      DiffGenerator: DefaultDiffGenerator,\n    };\n  }\n}\n\nexport class LintEntityTree extends EntityTree {\n  constructor(unEvalTree: DataTree, configTree: ConfigTree) {\n    super(unEvalTree, configTree);\n    this.buildTree(unEvalTree, configTree);\n  }\n  buildTree(unEvalTree: DataTree, configTree: ConfigTree): void {\n    const entities = Object.entries(unEvalTree);\n    const classLoader = new LintEntityClassLoader();\n\n    for (const [name, entity] of entities) {\n      const config = configTree[name];\n\n      this.tree.set(name, EntityFactory.getEntity(entity, config, classLoader));\n    }\n  }\n}\n","import { get, intersection, isEmpty, uniq } from \"lodash\";\nimport {\n  convertPathToString,\n  getAllPaths,\n  getEntityNameAndPropertyPath,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport { AppsmithFunctionsWithFields } from \"components/editorComponents/ActionCreator/constants\";\nimport { PathUtils } from \"plugins/Linting/utils/pathUtils\";\nimport { extractReferencesFromPath } from \"ee/plugins/Linting/utils/getEntityDependencies\";\nimport { groupDifferencesByType } from \"plugins/Linting/utils/groupDifferencesByType\";\nimport type {\n  LintRequest,\n  LintTreeRequestPayload,\n  LintTreeResponse,\n} from \"plugins/Linting/types\";\nimport { getLintErrorsFromTree } from \"plugins/Linting/lintTree\";\nimport type {\n  TJSPropertiesState,\n  TJSpropertyState,\n} from \"workers/Evaluation/JSObject/jsPropertiesState\";\nimport { isJSEntity } from \"ee/plugins/Linting/lib/entity\";\nimport DependencyMap from \"entities/DependencyMap\";\nimport {\n  LintEntityTree,\n  type EntityTree,\n} from \"plugins/Linting/lib/entity/EntityTree\";\nimport { getEntityFunctions } from \"ee/workers/Evaluation/fns\";\n\nclass LintService {\n  cachedEntityTree: EntityTree | null;\n  dependencyMap: DependencyMap = new DependencyMap();\n  constructor() {\n    this.cachedEntityTree = null;\n\n    if (isEmpty(this.cachedEntityTree)) {\n      this.dependencyMap = new DependencyMap();\n      this.dependencyMap.addNodes(\n        convertArrayToObject(AppsmithFunctionsWithFields),\n      );\n    }\n  }\n\n  lintTree = (lintRequest: LintRequest<LintTreeRequestPayload>) => {\n    const { data: payload, webworkerTelemetry } = lintRequest;\n    const {\n      cloudHosting,\n      configTree,\n      forceLinting = false,\n      unevalTree: unEvalTree,\n    } = payload;\n\n    const entityTree = new LintEntityTree(unEvalTree, configTree);\n\n    const { asyncJSFunctionsInDataFields, pathsToLint } =\n      isEmpty(this.cachedEntityTree) || forceLinting\n        ? this.lintFirstTree(entityTree)\n        : this.lintUpdatedTree(entityTree);\n\n    const jsEntities = entityTree.getEntities().filter(isJSEntity);\n    const jsPropertiesState: TJSPropertiesState = {};\n\n    for (const jsEntity of jsEntities) {\n      const rawEntity = jsEntity.getRawEntity();\n      const config = jsEntity.getConfig();\n\n      if (!jsEntity.entityParser) continue;\n\n      const { parsedEntityConfig } = jsEntity.entityParser.parse(\n        rawEntity,\n        config,\n      );\n\n      jsPropertiesState[jsEntity.getName()] = parsedEntityConfig as Record<\n        string,\n        TJSpropertyState\n      >;\n    }\n\n    const lintTreeResponse: LintTreeResponse = {\n      errors: {},\n      lintedJSPaths: [],\n      jsPropertiesState,\n      webworkerTelemetry,\n    };\n\n    try {\n      const { errors: lintErrors, lintedJSPaths } = getLintErrorsFromTree({\n        pathsToLint,\n        unEvalTree: this.cachedEntityTree?.getRawTree() || {},\n        jsPropertiesState,\n        cloudHosting,\n        asyncJSFunctionsInDataFields,\n        webworkerTelemetry,\n        configTree,\n      });\n\n      lintTreeResponse.errors = lintErrors;\n      lintTreeResponse.lintedJSPaths = lintedJSPaths;\n      lintTreeResponse.webworkerTelemetry = webworkerTelemetry;\n    } catch (e) {}\n\n    return lintTreeResponse;\n  };\n\n  private lintFirstTree = (entityTree: EntityTree) => {\n    const pathsToLint: Array<string> = [];\n    const allNodes: Record<string, true> = entityTree.getAllPaths();\n    const asyncJSFunctionsInDataFields: Record<string, string[]> = {};\n\n    this.dependencyMap.addNodes(allNodes);\n\n    const entities = entityTree.getEntities();\n\n    for (const entity of entities) {\n      const dynamicPaths = PathUtils.getDynamicPaths(entity);\n\n      for (const path of dynamicPaths) {\n        const references = extractReferencesFromPath(entity, path, allNodes);\n\n        this.dependencyMap.addDependency(path, references);\n        pathsToLint.push(path);\n      }\n    }\n\n    const asyncEntityActions = AppsmithFunctionsWithFields.concat(\n      getAllEntityActions(entityTree),\n    );\n    const asyncFns = entities\n      .filter(isJSEntity)\n      .flatMap((e) => e.getFns())\n      .filter(\n        (fn) =>\n          fn.isMarkedAsync ||\n          this.dependencyMap.isRelated(fn.name, asyncEntityActions),\n      )\n      .map((fn) => fn.name);\n\n    for (const asyncFn of asyncFns) {\n      const nodesThatDependOnAsyncFn =\n        this.dependencyMap.getDependents(asyncFn);\n      const dataPathsThatDependOnAsyncFn = filterDataPaths(\n        nodesThatDependOnAsyncFn,\n        entityTree,\n      );\n\n      if (isEmpty(dataPathsThatDependOnAsyncFn)) continue;\n\n      asyncJSFunctionsInDataFields[asyncFn] = dataPathsThatDependOnAsyncFn;\n    }\n\n    this.cachedEntityTree = entityTree;\n\n    return {\n      pathsToLint,\n      asyncJSFunctionsInDataFields,\n    };\n  };\n\n  private lintUpdatedTree(entityTree: EntityTree) {\n    const asyncJSFunctionsInDataFields: Record<string, string[]> = {};\n    const pathsToLint: string[] = [];\n    const NOOP = {\n      pathsToLint: [],\n      asyncJSFunctionsInDataFields,\n    };\n    const entityTreeDiff =\n      this.cachedEntityTree?.computeDifferences(entityTree);\n\n    if (!entityTreeDiff) return NOOP;\n\n    const { additions, deletions, edits } =\n      groupDifferencesByType(entityTreeDiff);\n\n    const allNodes = getAllPaths(entityTree.getRawTree());\n\n    const updatedPathsDetails: Record<\n      string,\n      {\n        previousDependencies: string[];\n        currentDependencies: string[];\n        updateType: \"EDIT\" | \"ADD\" | \"DELETE\";\n      }\n    > = {};\n\n    for (const edit of edits) {\n      const pathString = convertPathToString(edit?.path || []);\n\n      if (!pathString) continue;\n\n      const { entityName } = getEntityNameAndPropertyPath(pathString);\n      const entity = entityTree.getEntityByName(entityName);\n\n      if (!entity) continue;\n\n      const dynamicPaths = PathUtils.getDynamicPaths(entity);\n\n      if (!dynamicPaths.includes(pathString)) {\n        if (!dynamicPaths.some((p) => pathString.startsWith(p))) continue;\n      }\n\n      const previousDependencies =\n        this.dependencyMap.getDirectDependencies(pathString);\n      const references = extractReferencesFromPath(\n        entity,\n        pathString,\n        allNodes,\n      );\n\n      this.dependencyMap.addDependency(pathString, references);\n      pathsToLint.push(pathString);\n\n      updatedPathsDetails[pathString] = {\n        previousDependencies,\n        currentDependencies: references,\n        updateType: \"EDIT\",\n      };\n    }\n\n    for (const addition of additions) {\n      const pathString = convertPathToString(addition?.path || []);\n\n      if (!pathString) continue;\n\n      const { entityName } = getEntityNameAndPropertyPath(pathString);\n\n      if (!entityName) continue;\n\n      const entity = entityTree.getEntityByName(entityName);\n\n      if (!entity) continue;\n\n      const allAddedPaths = PathUtils.getAllPaths({\n        [pathString]: get(entityTree.getRawTree(), pathString),\n      });\n\n      this.dependencyMap.addNodes(allAddedPaths);\n\n      for (const path of Object.keys(allAddedPaths)) {\n        const previousDependencies =\n          this.dependencyMap.getDirectDependencies(path);\n        const references = extractReferencesFromPath(entity, path, allNodes);\n\n        if (PathUtils.isDynamicLeaf(entity, path)) {\n          this.dependencyMap.addDependency(path, references);\n          pathsToLint.push(path);\n        }\n\n        const incomingDeps = this.dependencyMap.getDependents(path);\n\n        pathsToLint.push(...incomingDeps);\n\n        updatedPathsDetails[path] = {\n          previousDependencies,\n          currentDependencies: references,\n          updateType: \"ADD\",\n        };\n      }\n    }\n\n    for (const deletion of deletions) {\n      const pathString = convertPathToString(deletion?.path || []);\n\n      if (!pathString) continue;\n\n      const { entityName } = getEntityNameAndPropertyPath(pathString);\n\n      if (!entityName) continue;\n\n      const entity = this.cachedEntityTree?.getEntityByName(entityName); // Use previous tree in a DELETE EVENT\n\n      if (!entity) continue;\n\n      const allDeletedPaths = PathUtils.getAllPaths({\n        [pathString]: get(this.cachedEntityTree?.getRawTree(), pathString),\n      });\n\n      for (const path of Object.keys(allDeletedPaths)) {\n        const previousDependencies =\n          this.dependencyMap.getDirectDependencies(path);\n\n        updatedPathsDetails[path] = {\n          previousDependencies,\n          currentDependencies: [],\n          updateType: \"DELETE\",\n        };\n\n        const incomingDeps = this.dependencyMap.getDependents(path);\n\n        pathsToLint.push(...incomingDeps);\n      }\n\n      this.dependencyMap.removeNodes(allDeletedPaths);\n    }\n\n    // generate async functions only after dependencyMap update is complete\n    const asyncEntityActions = AppsmithFunctionsWithFields.concat(\n      getAllEntityActions(entityTree),\n    );\n    const asyncFns = entityTree\n      .getEntities()\n      .filter(isJSEntity)\n      .flatMap((e) => e.getFns())\n      .filter(\n        (fn) =>\n          fn.isMarkedAsync ||\n          this.dependencyMap.isRelated(fn.name, asyncEntityActions),\n      )\n      .map((fn) => fn.name);\n\n    // generate asyncFunctionsBoundToSyncFields\n\n    for (const [updatedPath, details] of Object.entries(updatedPathsDetails)) {\n      const { currentDependencies, previousDependencies, updateType } = details;\n      const { entityName } = getEntityNameAndPropertyPath(updatedPath);\n\n      if (!entityName) continue;\n\n      // Use cached entityTree in a delete event\n      const entityTreeToUse =\n        updateType === \"DELETE\" ? this.cachedEntityTree : entityTree;\n      const entity = entityTreeToUse?.getEntityByName(entityName);\n\n      if (!entity) continue;\n\n      if (isJSEntity(entity) && asyncFns.includes(updatedPath)) {\n        const nodesThatDependOnAsyncFn =\n          this.dependencyMap.getDependents(updatedPath);\n        const dataPathsThatDependOnAsyncFn = filterDataPaths(\n          nodesThatDependOnAsyncFn,\n          entityTree,\n        );\n\n        if (!isEmpty(dataPathsThatDependOnAsyncFn)) {\n          asyncJSFunctionsInDataFields[updatedPath] =\n            dataPathsThatDependOnAsyncFn;\n        }\n\n        continue;\n      }\n\n      const isDataPath = PathUtils.isDataPath(updatedPath, entity);\n\n      if (!isDataPath) continue;\n\n      const asyncDeps = intersection(asyncFns, currentDependencies);\n      const prevAsyncDeps = intersection(asyncFns, previousDependencies);\n\n      for (const asyncFn of asyncDeps) {\n        const nodesThatDependOnAsyncFn =\n          this.dependencyMap.getDependents(asyncFn);\n        const dataPathsThatDependOnAsyncFn = filterDataPaths(\n          nodesThatDependOnAsyncFn,\n          entityTree,\n        );\n\n        if (isEmpty(dataPathsThatDependOnAsyncFn)) continue;\n\n        asyncJSFunctionsInDataFields[asyncFn] = dataPathsThatDependOnAsyncFn;\n      }\n\n      pathsToLint.push(...asyncDeps, ...prevAsyncDeps);\n    }\n\n    this.cachedEntityTree = entityTree;\n\n    return {\n      pathsToLint: uniq(pathsToLint),\n      entityTree,\n      asyncJSFunctionsInDataFields,\n    };\n  }\n}\n\nfunction convertArrayToObject(arr: string[]) {\n  return arr.reduce(\n    (acc, item) => {\n      return { ...acc, [item]: true } as const;\n    },\n    {} as Record<string, true>,\n  );\n}\n\nfunction filterDataPaths(paths: string[], entityTree: EntityTree) {\n  const dataPaths: string[] = [];\n\n  for (const path of paths) {\n    const { entityName } = getEntityNameAndPropertyPath(path);\n    const entity = entityTree.getEntityByName(entityName);\n\n    if (!entity || !PathUtils.isDataPath(path, entity)) continue;\n\n    dataPaths.push(path);\n  }\n\n  return dataPaths;\n}\n\nfunction getAllEntityActions(entityTree: EntityTree) {\n  const allEntityActions = new Set<string>();\n\n  for (const [entityName, entity] of Object.entries(entityTree.getRawTree())) {\n    for (const entityFnDescription of getEntityFunctions()) {\n      if (entityFnDescription.qualifier(entity)) {\n        const fullPath = `${\n          entityFnDescription.path ||\n          `${entityName}.${entityFnDescription.name}`\n        }`;\n\n        allEntityActions.add(fullPath);\n      }\n    }\n  }\n\n  return [...allEntityActions];\n}\n\nexport const lintService = new LintService();\n","import { LINT_WORKER_ACTIONS } from \"plugins/Linting/types\";\nimport { updateJSLibraryGlobals } from \"./updateJSLibraryGlobals\";\nimport { lintService } from \"./lintService\";\nimport { setupLintingWorkerEnv } from \"./setupLinkingWorkerEnv\";\n\nexport const handlerMap = {\n  [LINT_WORKER_ACTIONS.LINT_TREE]: lintService.lintTree,\n  [LINT_WORKER_ACTIONS.UPDATE_LINT_GLOBALS]: updateJSLibraryGlobals,\n  [LINT_WORKER_ACTIONS.SETUP]: setupLintingWorkerEnv,\n} as const;\n","import type { LintRequest, updateJSLibraryProps } from \"plugins/Linting/types\";\nimport { isEqual } from \"lodash\";\nimport { JSLibraries, JSLibraryAccessor } from \"workers/common/JSLibrary\";\nimport { resetJSLibraries } from \"workers/common/JSLibrary/resetJSLibraries\";\n\nexport function updateJSLibraryGlobals({\n  data,\n}: LintRequest<updateJSLibraryProps>) {\n  const { add, libs } = data;\n\n  if (add) {\n    JSLibraries.push(...libs);\n  } else if (add === false) {\n    for (const lib of libs) {\n      const idx = JSLibraries.findIndex((l) =>\n        isEqual(l.accessor.sort(), lib.accessor.sort()),\n      );\n\n      if (idx === -1) {\n        JSLibraryAccessor.regenerateSet();\n\n        return;\n      }\n\n      JSLibraries.splice(idx, 1);\n    }\n  } else {\n    resetJSLibraries();\n    JSLibraries.push(...libs);\n  }\n\n  JSLibraryAccessor.regenerateSet();\n\n  return true;\n}\n","import type { FeatureFlags } from \"ee/entities/FeatureFlag\";\nimport { WorkerEnv } from \"workers/Evaluation/handlers/workerEnv\";\nimport type { LintRequest } from \"../types\";\n\nexport const setupLintingWorkerEnv = ({\n  data: featureFlags,\n}: LintRequest<FeatureFlags>) => {\n  WorkerEnv.setFeatureFlags(featureFlags);\n};\n","import type { TMessage } from \"utils/MessageUtil\";\nimport { MessageType } from \"utils/MessageUtil\";\nimport { WorkerMessenger } from \"workers/Evaluation/fns/utils/Messenger\";\nimport type {\n  LintRequest,\n  LintTreeRequestPayload,\n  updateJSLibraryProps,\n} from \"../types\";\nimport { handlerMap } from \"../handlers\";\nimport type { FeatureFlags } from \"ee/entities/FeatureFlag\";\n\n// The messageListener can have either of these three types\ntype LinterFunctionPayload = LintTreeRequestPayload &\n  FeatureFlags &\n  updateJSLibraryProps;\n\nexport function messageListener(\n  e: MessageEvent<TMessage<LintRequest<LinterFunctionPayload>>>,\n) {\n  const { messageType } = e.data;\n\n  if (messageType !== MessageType.REQUEST) return;\n\n  const startTime = Date.now();\n  const { body, messageId } = e.data;\n  const { method } = body;\n\n  if (!method) return;\n\n  const messageHandler = handlerMap[method];\n\n  if (typeof messageHandler !== \"function\") return;\n\n  const responseData = messageHandler(body);\n\n  if (!responseData) return;\n\n  const endTime = Date.now();\n\n  WorkerMessenger.respond(messageId, responseData, startTime, endTime);\n}\n\nself.onmessage = messageListener;\n","import type {\n  PropertyOverrideDependency,\n  OverridingPropertyPaths,\n  WidgetEntity,\n  ActionEntity,\n  JSActionEntity,\n} from \"ee/entities/DataTree/types\";\nimport type { DataTreeEntity } from \"entities/DataTree/dataTreeTypes\";\nimport { OverridingPropertyType } from \"ee/entities/DataTree/types\";\nimport {\n  isAction,\n  isJSAction,\n  isWidget,\n} from \"ee/workers/Evaluation/evaluationUtils\";\nimport type { Module } from \"ee/constants/ModuleConstants\";\ninterface SetOverridingPropertyParams {\n  key: string;\n  value: string;\n  propertyOverrideDependency: PropertyOverrideDependency;\n  overridingPropertyPaths: OverridingPropertyPaths;\n  type: OverridingPropertyType;\n}\n\nexport const setOverridingProperty = ({\n  key: propertyName,\n  overridingPropertyPaths,\n  propertyOverrideDependency,\n  type,\n  value: overridingPropertyKey,\n}: SetOverridingPropertyParams) => {\n  if (!(propertyName in propertyOverrideDependency)) {\n    propertyOverrideDependency[propertyName] = {\n      [OverridingPropertyType.DEFAULT]: undefined,\n      [OverridingPropertyType.META]: undefined,\n    };\n  }\n\n  switch (type) {\n    case OverridingPropertyType.DEFAULT:\n      propertyOverrideDependency[propertyName][OverridingPropertyType.DEFAULT] =\n        overridingPropertyKey;\n      break;\n\n    case OverridingPropertyType.META:\n      propertyOverrideDependency[propertyName][OverridingPropertyType.META] =\n        overridingPropertyKey;\n\n      break;\n    default:\n  }\n\n  if (Array.isArray(overridingPropertyPaths[overridingPropertyKey])) {\n    const updatedOverridingProperty = new Set(\n      overridingPropertyPaths[overridingPropertyKey],\n    );\n\n    overridingPropertyPaths[overridingPropertyKey] = [\n      ...updatedOverridingProperty.add(propertyName),\n    ];\n  } else {\n    overridingPropertyPaths[overridingPropertyKey] = [propertyName];\n  }\n\n  // if property dependent on metaProperty also has defaultProperty then defaultProperty will also override metaProperty on eval.\n  const defaultPropertyName = propertyOverrideDependency[propertyName].DEFAULT;\n\n  if (type === OverridingPropertyType.META && defaultPropertyName) {\n    overridingPropertyPaths[defaultPropertyName].push(overridingPropertyKey);\n  }\n};\n\nexport const generateDataTreeModuleInputs = (\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  moduleInputs: Module[\"inputsForm\"],\n) => {\n  return {\n    unEvalEntity: null,\n    configEntity: null,\n  };\n};\n\nexport function isWidgetActionOrJsObject(\n  entity: DataTreeEntity,\n): entity is ActionEntity | WidgetEntity | JSActionEntity {\n  return isWidget(entity) || isAction(entity) || isJSAction(entity);\n}\n","export const ECMA_VERSION = 11;\n\n/* Indicates the mode the code should be parsed in. \nThis influences global strict mode and parsing of import and export declarations.\n*/\nexport enum SourceType {\n  script = \"script\",\n  module = \"module\",\n}\n\n// Each node has an attached type property which further defines\n// what all properties can the node have.\n// We will just define the ones we are working with\nexport enum NodeTypes {\n  Identifier = \"Identifier\",\n  AssignmentPattern = \"AssignmentPattern\",\n  Literal = \"Literal\",\n  Property = \"Property\",\n  RestElement = \"RestElement\",\n  ObjectPattern = \"ObjectPattern\",\n  ArrayPattern = \"ArrayPattern\",\n  // Declaration - https://github.com/estree/estree/blob/master/es5.md#declarations\n  FunctionDeclaration = \"FunctionDeclaration\",\n  ExportDefaultDeclaration = \"ExportDefaultDeclaration\",\n  VariableDeclarator = \"VariableDeclarator\",\n  // Expression - https://github.com/estree/estree/blob/master/es5.md#expressions\n  MemberExpression = \"MemberExpression\",\n  FunctionExpression = \"FunctionExpression\",\n  ArrowFunctionExpression = \"ArrowFunctionExpression\",\n  AssignmentExpression = \"AssignmentExpression\",\n  ObjectExpression = \"ObjectExpression\",\n  ArrayExpression = \"ArrayExpression\",\n  ThisExpression = \"ThisExpression\",\n  CallExpression = \"CallExpression\",\n  BinaryExpression = \"BinaryExpression\",\n  ExpressionStatement = \"ExpressionStatement\",\n  BlockStatement = \"BlockStatement\",\n  ConditionalExpression = \"ConditionalExpression\",\n  AwaitExpression = \"AwaitExpression\",\n}\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// the startup function\n__webpack_require__.x = () => {\n\t// Load entry module and return exports\n\t// This entry module depends on other loaded chunks and execution need to be delayed\n\tvar __webpack_exports__ = __webpack_require__.O(undefined, [9222,5477,3222,7994,2327,976], () => (__webpack_require__(93740)))\n\t__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n\treturn __webpack_exports__;\n};\n\n","__webpack_require__.amdO = {};","var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\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};","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' && !~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};","// 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 and sibling chunks for the entrypoint\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"static/js/\" + ({\"248\":\"auto-track\",\"521\":\"remoteMiddleware\",\"3104\":\"schemaFilter\",\"5021\":\"blueprint-icons\",\"5050\":\"ajs-destination\",\"6999\":\"remix-icons\",\"7538\":\"queryString\",\"9010\":\"tsub-middleware\",\"9222\":\"svg-icons\",\"9694\":\"legacyVideos\"}[chunkId] || chunkId) + \".\" + {\"248\":\"f008a257\",\"521\":\"0e5b22a7\",\"976\":\"bbc6732f\",\"2327\":\"a2e54e7a\",\"3104\":\"1b02f095\",\"3222\":\"28fba642\",\"3646\":\"038bfa00\",\"4831\":\"89c721f8\",\"4996\":\"e58b4ba4\",\"5021\":\"9cef11d0\",\"5050\":\"c80d51a1\",\"5477\":\"d91710cb\",\"6999\":\"cf894592\",\"7538\":\"1b09bb08\",\"7994\":\"9730c13a\",\"8081\":\"8867453f\",\"8627\":\"3466c660\",\"9010\":\"03b316e9\",\"9222\":\"bf84475d\",\"9694\":\"dd96c20e\"}[chunkId] + \".chunk.js\";\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn undefined;\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__.j = 2558;","__webpack_require__.p = \"/\";","(() => {\n  if (typeof __webpack_require__ !== 'undefined') {\n    var oldGetScript = __webpack_require__.u;\n    var oldLoadScript = __webpack_require__.e;\n    var queryMap = {};\n    var countMap = {};\n    var getRetryDelay = function () {\n      return 3000;\n    };\n    __webpack_require__.u = function (chunkId) {\n      var result = oldGetScript(chunkId);\n      return (\n        result +\n        (queryMap.hasOwnProperty(chunkId) ? '?' + queryMap[chunkId] : '')\n      );\n    };\n    __webpack_require__.e = function (chunkId) {\n      var result = oldLoadScript(chunkId);\n      return result.catch(function (error) {\n        var retries = countMap.hasOwnProperty(chunkId) ? countMap[chunkId] : 2;\n        if (retries < 1) {\n          var realSrc = oldGetScript(chunkId);\n          error.message =\n            'Loading chunk ' +\n            chunkId +\n            ' failed after 2 retries.\\n(' +\n            realSrc +\n            ')';\n          error.request = realSrc;\n          window.location.href = '/404.html';\n          throw error;\n        }\n        return new Promise(function (resolve) {\n          var retryAttempt = 2 - retries + 1;\n          setTimeout(function () {\n            var retryAttemptString = '&retry-attempt=' + retryAttempt;\n            var cacheBust = 'cache-bust=true' + retryAttemptString;\n            queryMap[chunkId] = cacheBust;\n            countMap[chunkId] = retries - 1;\n            resolve(__webpack_require__.e(chunkId));\n          }, getRetryDelay(retryAttempt));\n        });\n      });\n    };\n  }\n})();\n","// no baseURI\n\n// object to store loaded chunks\n// \"1\" means \"already loaded\"\nvar installedChunks = {\n\t2558: 1\n};\n\n// importScripts chunk loading\nvar installChunk = (data) => {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\tfor(var moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\twhile(chunkIds.length)\n\t\tinstalledChunks[chunkIds.pop()] = 1;\n\tparentChunkLoadingFunction(data);\n};\n__webpack_require__.f.i = (chunkId, promises) => {\n\t// \"1\" is the signal for \"already loaded\"\n\tif(!installedChunks[chunkId]) {\n\t\tif(true) { // all chunks have JS\n\t\t\timportScripts(__webpack_require__.p + __webpack_require__.u(chunkId));\n\t\t}\n\t}\n};\n\nvar chunkLoadingGlobal = self[\"webpackChunkappsmith\"] = self[\"webpackChunkappsmith\"] || [];\nvar parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);\nchunkLoadingGlobal.push = installChunk;\n\n// no HMR\n\n// no HMR manifest","__webpack_require__.nc = undefined;","var next = __webpack_require__.x;\n__webpack_require__.x = () => {\n\treturn Promise.all([9222,5477,3222,7994,2327,976].map(__webpack_require__.e, __webpack_require__)).then(next);\n};","// run startup\nvar __webpack_exports__ = __webpack_require__.x();\n"],"names":["beginsWithLineBreakRegex","sanitizeScript","js","evaluationVersion","trimmedJS","replace","unescapeJS","isTrueObject","item","Object","prototype","toString","call","extractContentByPosition","content","position","eachLine","split","returnedString","i","from","line","to","slice","ch","getStringValue","inputValue","JSON","stringify","getEntityForEvalContextMap","ENTITY_TYPE","JSACTION","entityName","entity","getJSActionForEvalContext","getEntityForEvalContext","getterMethod","getDataTreeContext","args","configTree","dataTree","isTriggerBased","removeEntityFunctions","EVAL_CONTEXT","dataTreeEntries","entries","entityFunctionCollection","setters","clear","entityFn","getEntityFunctions","qualifier","func","fn","fullPath","path","name","set","entityConfig","entityMethodMap","getEntitySettersFromConfig","_isEmpty","assign","removeEntityFunctionsFromEvalContext","addEntityFunctionsToEvalContext","evalContext","funcObj","getAllAsyncFunctions","allAsyncFunctions","setterMethods","entitiesSetterFunctions","methodName","keys","getAllSetterFunctions","platformFn","getPlatformFunctions","klona","forEach","defaultLibraries","accessor","version","lodashPackageJson","docsURL","momentPackageJson","JSLibraries","JSLibraryAccessor","JSLibraryAccessorModifier","jsLibraryAccessorSet","Set","flatMap","lib","regenerateSet","getSet","libraryReservedIdentifiers","reduce","acc","a","isDynamicValue","value","DATA_BIND_REGEX","test","getDynamicStringSegments","dynamicString","stringSegments","indexOfDoubleParanStart","indexOf","firstString","substring","push","rest","length","sum","char","prevChar","concat","getDynamicBindings","_isString","jsSnippets","sanitisedString","trim","isJSAction","map","segment","EvalErrorTypes","getEntityDynamicBindingPathList","dynamicBindingPathList","Array","isArray","getPropertyPath","fullPropertyPath","isPathDynamicTrigger","widget","dynamicTriggerPathList","undefined","_find","key","isChildPropertyPath","parentPropertyPath","childPropertyPath","arguments","startsWith","EVALUATION_PATH","EVAL_ERROR_PATH","EVAL_VALUE_PATH","getNestedEvalPath","pathType","isPopulated","propertyPath","getEntityNameAndPropertyPath","nestedPath","getEvalValuePath","options","PropertyEvaluationErrorType","PropertyEvaluationErrorCategory","VALIDATION","PARSE","LINT","WorkerEnv","setFeatureFlags","featureFlags","flags","setCloudHosting","cloudHosting","getFeatureFlags","getCloudHosting","invalidEntityIdentifiers","JAVASCRIPT_KEYWORDS","DEDICATED_WORKER_GLOBAL_SCOPE_IDENTIFIERS","EvaluationScriptType","ScriptTemplate","EvaluationScripts","EXPRESSION","ANONYMOUS_FUNCTION","ASYNC_ANONYMOUS_FUNCTION","TRIGGERS","OBJECT_PROPERTY","self","getScriptType","evalArgumentsExist","scriptType","getScriptToEval","userScript","type","buffer","overrideEvalContext","overrideContext","entitiesClonedSoFar","has","add","_ref","_set","createEvaluationContext","context","evalArguments","ARGUMENTS","THIS_CONTEXT","thisContext","globalContext","dataTreeContext","getUserScriptToEvaluate","unescapedJS","script","setEvalContext","_ref2","isDataField","evaluateSync","isJSCollection","evalContextCache","errors","result","triggers","indirectEval","Promise","FoundPromiseInSyncEvalError","error","errorCategory","errorMessage","rootcause","errorModifier","run","source","ActionInDataFieldErrorModifier","TypeErrorModifier","severity","Severity","ERROR","raw","errorType","originalBinding","kind","category","shouldAddSetter","setter","isDisabledExpression","disabled","Function","isDisabledFn","FEATURE_FLAG","TEST_FLAG","release_datasource_environments_enabled","release_appnavigationlogoupload_enabled","release_embed_hide_share_settings_enabled","release_table_serverside_filtering_enabled","license_branding_enabled","license_sso_saml_enabled","license_sso_oidc_enabled","license_private_embeds_enabled","release_show_publish_app_to_community_enabled","license_gac_enabled","release_anvil_enabled","license_git_branch_protection_enabled","license_git_continuous_delivery_enabled","license_widget_rtl_support_enabled","ab_one_click_learning_popover_enabled","ab_appsmith_ai_query","rollout_remove_feature_walkthrough_enabled","rollout_eslint_enabled","release_drag_drop_building_blocks_enabled","release_layout_conversion_enabled","release_git_persist_branch_enabled","release_ide_animations_enabled","release_ide_datasource_selector_enabled","release_custom_widget_ai_builder","ab_request_new_integration_enabled","release_evaluation_scope_cache","release_gs_all_sheets_options_enabled","release_git_modularisation_enabled","release_git_api_contracts_enabled","ab_premium_datasources_view_enabled","kill_session_recordings_enabled","config_mask_session_recordings_enabled","config_user_session_recordings_enabled","release_ads_entity_item_enabled","release_external_saas_plugins_enabled","release_tablev2_infinitescroll_enabled","release_table_custom_sort_function_enabled","isIdentifierNode","node","NodeTypes","Identifier","isMemberExpressionNode","MemberExpression","isVariableDeclarator","VariableDeclarator","isFunctionDeclaration","FunctionDeclaration","isFunctionExpression","FunctionExpression","isArrowFunctionExpression","ArrowFunctionExpression","isObjectExpression","ObjectExpression","isArrayPatternNode","ArrayPattern","isObjectPatternNode","ObjectPattern","isLiteralNode","Literal","isExportDefaultDeclarationNode","ExportDefaultDeclaration","isPropertyAFunctionNode","isArrayAccessorNode","computed","property","isFinite","wrapCode","code","getFunctionalParamNamesFromNode","getFunctionalParamsFromNode","functionalParam","paramName","getAST","parse","ecmaVersion","ECMA_VERSION","extractIdentifierInfoFromCode","invalidIdentifiers","ast","end","start","sanitizedScript","wrappedCode","functionalParams","references","variableDeclarations","ancestorWalk","filter","reference","topLevelIdentifier","toPath","variables","isError","e","SyntaxError","needValue","params","paramNode","defaultValue","AssignmentPattern","isAssignmentPatternNode","left","defaultValueInString","right","RestElement","isRestElementNode","argument","constructFinalMemberExpIdentifier","child","propertyAccessor","getPropertyAccessor","object","nestedChild","propertyNode","isString","isTypeOfFunction","extractExpressionsFromCode","data","assignmentExpressionsData","callExpressionsData","memberCallExpressionData","invalidTopLevelMemberExpressions","locations","invalidTopLevelMemberExpressionsArray","simple","id","AssignmentExpression","isAssignmentExpression","operator","parentNode","CallExpression","isCallExpressionNode","callee","identifierList","ancestor","ancestors","candidateTopLevelNode","depth","parent","optional","memberExpIdentifier","getMemberExpressionObjectFromProperty","propertyName","memberExpressionObjects","propName","isNil","memberExpressionObjectString","generate","validJSBodyRegex","RegExp","updateEvalTreeValueFromContext","paths","currentEvalContext","dataTreeEvaluator","evalTree","getEvalTree","fullPathArray","jsObjectName","variableName","_get","JSObjectCollection","setVariableValue","evalProps","window","Error","module","exports","constructor","setterMethodLookup","setterAccessorMap","applySetterMethod","setterMethodName","getConfigTree","updatedProperties","overriddenProperties","evalMetaUpdates","parsedValue","validationPaths","validationConfig","config","strict","isValid","messages","parsed","validate","message","isWidget","overrideWidgetProperties","currentTree","isNewWidget","shouldUpdateGlobalContext","propPath","resolve","then","res","evalTreeWithChanges","updatedValuePaths","metaUpdates","method","EVAL_WORKER_SYNC_ACTION","EVAL_TREE_WITH_CHANGES","webworkerTelemetry","createSetter","this","getFnWithGuards","async","isAsyncGuard","getMap","getSetterAccessorMap","setterMethodMap","__setters","pathToSet","init","configTreeEntries","isJSFunctionProperty","t","parseJSObject","comments","token","sourceType","SourceType","onComment","onToken","ranges","attachComments","parsedObject","success","parsedObjectProperties","JSObjectProperties","declaration","properties","propertyKey","rawContent","loc","column","startLine","startColumn","endLine","endColumn","keyStartLine","keyEndLine","keyStartColumn","keyEndColumn","isMarkedAsync","ACTION","WIDGET","APPSMITH","EvaluationSubstitutionType","CE_ENTITY_TYPE","MODULE_INPUT","MODULE_INSTANCE","platformFns","entityFns","navigateTo","showAlert","showModal","closeModal","download","postWindowMessage","copyToClipboard","resetWidget","storeValue","removeValue","clearStore","isRunNClearFnQualifierEntity","actionEntity","bind","isAppsmithEntity","getGeoLocation","watchGeoLocation","stopWatchGeoLocation","getActionTriggerFunctionNames","ActionTriggerFunctionNames","CLEAR_INTERVAL","CLEAR_PLUGIN_ACTION","CLOSE_MODAL","COPY_TO_CLIPBOARD","DOWNLOAD","NAVIGATE_TO","RESET_WIDGET_META_RECURSIVE_BY_NAME","RUN_PLUGIN_ACTION","SET_INTERVAL","SHOW_ALERT","SHOW_MODAL_BY_NAME","STORE_VALUE","REMOVE_VALUE","CLEAR_STORE","GET_CURRENT_LOCATION","WATCH_CURRENT_LOCATION","STOP_WATCHING_CURRENT_LOCATION","POST_MESSAGE","SET_TIMEOUT","CLEAR_TIMEOUT","IMMEDIATE_PARENT_REGEX","convertPathToString","arrPath","string","val","Number","isInteger","indexOfFirstDot","isAction","isDataTreeEntity","serialiseToBigInt","_","v","getAllPaths","records","curKey","tempKey","addErrorToEntityProperty","isPrivateEntityPath","getAllPrivateWidgetsInDataTree","logBlackList","errorPath","existingErrors","resetValidationErrorsForEntityProperty","_ref3","existingErrorsExceptValidation","isDynamicLeaf","unEvalTree","propPathEls","_toPath","hasOwnProperty","isWidgetActionOrJsObject","relativePropertyPath","reactivePaths","triggerPaths","addWidgetPropertyDependencies","_ref4","widgetConfig","widgetName","dependencies","propertyOverrideDependency","_ref5","overriddenPropertyKey","overridingPropertyKeyMap","existingDependenciesSet","META","DEFAULT","privateWidgets","safeTree","configEntity","overridingPropertyPaths","clonedValue","pathsNotToOverride","widgetPathsNotToOverride","overriddenPropertyPath","overriddenPropertyPathArray","includes","metaPropertyPath","widgetId","propertyOverridingKeyMap","clonedDefaultValue","overwriteParsedValue","newValue","isATriggerPath","overriddenPropertyPaths","isMetaPropDirty","overriddenMetaPaths","APPSMITH_GLOBAL_FUNCTIONS","APPSMITH_NAMESPACED_FUNCTIONS","EE_APPSMITH_NAMESPACED_FUNCTIONS","AppsmithFunctionsWithFields","values","match","require","ID_EXTRACTION_REGEX","BUILDER_VIEWER_PATH_PREFIX","BUILDER_PATH","BUILDER_CUSTOM_PATH","BUILDER_PATH_DEPRECATED","INTEGRATION_EDITOR_PATH","WIDGETS_EDITOR_ID_PATH","API_EDITOR_BASE_PATH","API_EDITOR_ID_PATH","API_EDITOR_ID_ADD_PATH","QUERIES_EDITOR_BASE_PATH","ADD_PATH","ENTITY_PATH","QUERIES_EDITOR_ID_PATH","QUERIES_EDITOR_ID_ADD_PATH","JS_COLLECTION_EDITOR_PATH","JS_COLLECTION_ID_PATH","JS_COLLECTION_ID_ADD_PATH","DATA_SOURCES_EDITOR_ID_PATH","_nodes","_classPrivateFieldLooseKey","_dependencies","_dependenciesInverse","_invalidDependencies","_invalidDependenciesInverse","DependencyMap","_this","defineProperty","writable","addDependency","_classPrivateFieldLooseBase","validDependencies","invalidDependencies","dependency","_classPrivateFieldLoo","_classPrivateFieldLoo2","get","previousNodeDependencies","newNodeDependencies","removedNodeDependencies","_difference","removedDependency","_classPrivateFieldLoo3","delete","previousNodeInvalidDependencies","newNodeInvalidDependencies","removedNodeInvalidDependencies","removedInvalidDependency","_classPrivateFieldLoo4","removeDependency","didUpdateDependencies","directDependenciesOfNode","getDirectDependencies","directDependency","_classPrivateFieldLoo5","addNodes","nodes","nodesToAdd","sort","desc","didUpdateGraph","newNode","nodesThatAlreadyDependedOnThis","invalidNode","dependants","dependant","_classPrivateFieldLoo6","iNode","_classPrivateFieldLoo7","_classPrivateFieldLoo8","_classPrivateFieldLoo9","removeNodes","_classPrivateFieldLoo10","_classPrivateFieldLoo11","_classPrivateFieldLoo12","isRelated","targets","visited","queue","shift","n","Map","fromEntries","deps","inverseDependencies","inverseInvalidDependencies","getDependents","getAllReachableNodes","reachableNodes","rawDependencies","LINT_WORKER_ACTIONS","defaultLibImplementations","lodash","moment","forge","DefaultDiffGenerator","baseEntity","compareEntity","diff","generateDiffObj","getName","getRawEntity","JSLintDiffGenerator","entityForDiff","propertyValue","jsParser","entityParser","parsedEntityConfig","getConfig","getHashedConfigString","defaultDiffGenerator","JSEntity","diffGenerator","getType","getId","actionId","isEqual","body","computeDifference","oldEntity","getFns","jsFunctions","parsedEntity","jsPropertyConfig","jsPropertyFullName","ActionEntity","AppsmithEntity","WidgetEntity","isJSEntity","isWidgetEntity","getEntity","classLoader","DiffGenerator","Parser","load","isDynamicEntity","PathUtils","getReactivePaths","getFullNamesFromPropertyPaths","getBindingPaths","bindingPaths","getTriggerPaths","getDynamicPaths","_union","parentName","isDataPath","getDataPaths","_PathUtils","mergeMaps","firstMap","secondMap","_mergeWith","firstVal","secondVal","getDependencyFromEntityPath","unevalPropValue","validJSSnippets","jsSnippet","getEntityInternalDependencyMap","internalDependencyMap","dependencyMap","pathDependencies","fullPathDependencies","dependentPath","extractReferencesFromPath","tree","entityPropertyPath","rawEntity","propertyPathContent","referencesInPropertyPath","_flatten","prunedReferences","_has","subpaths","currentString","pop","getPrunedReference","_uniq","extractReferencesFromJSSnippet","groupDifferencesByType","differences","edits","additions","deletions","others","_partition","deletionsAndArrayChanges","arrayChanges","currentDiff","index","getEvaluationContext","unevalTree","withFunctions","platformFnNamesMap","globalData","globalDataWithFunctions","globalDataWithoutFunctions","initialize","getGlobalData","noFloatingPromisesLintRule","meta","docs","description","recommended","unhandledPromise","schema","create","_context$settings","asyncFunctions","settings","traverseNode","isPotentialAsyncCall","isInAsyncFunction","isHandledWithPromiseMethods","report","messageId","checkCallExpression","visitorKeys","getSourceCode","c","LINTER_TYPE","JS_OBJECT_START_STATEMENT","INVALID_JSOBJECT_START_STATEMENT","WARNING_LINT_ERRORS","W098","W014","ASYNC_FUNCTION_BOUND_TO_SYNC_FIELD","ACTION_MODAL_STRING","asyncActionInSyncFieldLintMessage","IGNORED_LINT_ERRORS","SUPPORTED_WEB_APIS","console","crypto","fetch","CustomLintErrorCode","CUSTOM_LINT_ERRORS","INVALID_ENTITY_PROPERTY","isJsObject","find","isEntityFunction","dataFieldBindings","fullName","hasMultipleBindings","bindings","join","INVALID_WIDGET_PROPERTY_SETTER","objectName","isValidProperty","INVALID_APPSMITH_STORE_PROPERTY_SETTER","modalName","INVALID_INPUTS","inputs","invalidKey","getLintSeverity","WARNING","_props","objectKeys","newWebWorkerSpanData","spanName","attributes","startTime","Date","now","endTime","addEndTimeForWebWorkerSpanData","span","SAAS_EDITOR_PATH","SAAS_EDITOR_DATASOURCE_ID_PATH","SAAS_EDITOR_API_ID_PATH","SAAS_EDITOR_API_ID_ADD_PATH","IDE_TYPE","IDEBasePaths","getIDETypeByUrl","basePaths","matchPath","PERMISSION_TYPE","EvaluationScriptPositions","getLinterType","linterType","JSHINT","flagValues","ESLINT","getEvaluationScriptPosition","_keys","lines","lastLine","_last","getPositionInEvaluationScript","getLintErrorMessage","reason","isJSObject","undefinedVar","originalReason","getRefinedW117Error","getLintingErrors","getLinterTypeFn","scriptPos","lintingGlobalData","ideType","dataKey","libAccessors","apiName","setTimeout","clearTimeout","dataValue","dataValueEntityType","ignoreKeys","URL","pathname","generateLintingGlobalData","lintingOptions","indent","esversion","eqeqeq","curly","freeze","undef","forin","noempty","unused","asi","boss","evil","funcscope","sub","expr","browser","worker","mocha","globals","loopfunc","extraRules","getLintRulesBasedOnContext","languageOptions","plugins","customRules","rules","vars","ignoreRestSiblings","lintOptions","lintErrors","allSpans","profileFn","linter","linesOfCodeLinted","codeSizeInChars","jshint","Linter","verify","sanitizedJSHintErrors","lintError","matchedLines","lineNumbersInErrorMessage","isInvalidErrorMessage","lineStatement","digitString","digit","_isNumber","size","lineNumber","replaceAll","sanitizeJSHintErrors","jsHintError","b","d","evidence","actualErrorLineNumber","actualErrorCh","character","lintErrorMessage","errorSegment","convertJsHintErrorToAppsmithLintError","sanitizedESLintErrors","ruleId","sanitizeESLintErrors","eslintError","lintLength","Math","max","convertESLintErrorToAppsmithLintError","customLintErrors","assignmentExpressions","callExpressions","memberCallExpressions","invalidWidgetPropertySetterErrors","assignmentExpressionString","objectStartLine","objectStartCol","getInvalidWidgetPropertySetterErrors","invalidPropertyErrors","propertyStartColumn","getInvalidEntityPropertyErrors","invalidAppsmithStorePropertyErrors","appsmithStoreMutationExpressions","assignmentExpressionErrors","getInvalidAppsmithStoreSetterErrors","moduleInputErrors","getInvalidModuleInputsError","invalidActionModalErrors","actionModalLintErrors","callExpressionsString","getActionModalStringValueErrors","getCustomErrorsFromScript","getJSToLint","snippet","lintJSObjectProperty","jsObjectState","asyncJSFunctionsInDataFields","jsPropertyName","jsPropertyState","isAsyncJSFunctionBoundToSyncField","jsPropertyLintErrors","_isNil","originalPath","lintJSProperty","generateAsyncFunctionBoundToDataFieldCustomError","getLintErrorsFromTree","jsPropertiesState","pathsToLint","lintTreeErrors","lintedJSPaths","jsObjectPaths","sortLintingPathsByType","bindingPath","dynamicBinding","jsSnippetToLint","lintErrorsFromSnippet","lintBindingPath","triggerPath","unEvalPropertyValue","lintTriggerPath","jsObjectPath","jsObjectBodyPath","jsObjectBodyLintErrors","jsObject","rawJSObjectbody","jsbodyToLint","lintJSObjectBody","propertyLintErrors","updatedLintErrors","DefaultEntityParser","_parsedJSCache","_isValidJSBody","_parseJSObjectBody","JSLintEntityParser","_isValidJSBody2","jsBody","response","parsedProperties","allPropertyKeys","uniqueKeys","jsEntityBody","parsedJSEntityConfig","parsedJSEntity","parsedPropertyDetails","requiredProps","TEMPLATE","propertyConfig","EntityTree","computeDifferences","newTree","entityNames","getRawTree","newEntityNames","allEntityNames","getEntityByName","newEntity","lhs","difference","rawTree","getEntities","LintEntityClassLoader","LintEntityTree","super","buildTree","entities","EntityFactory","filterDataPaths","entityTree","dataPaths","getAllEntityActions","allEntityActions","entityFnDescription","lintService","cachedEntityTree","lintTree","lintRequest","payload","forceLinting","lintFirstTree","lintUpdatedTree","jsEntities","jsEntity","lintTreeResponse","_this$cachedEntityTre","allNodes","dynamicPaths","asyncEntityActions","asyncFns","asyncFn","dataPathsThatDependOnAsyncFn","_this$cachedEntityTre2","NOOP","entityTreeDiff","updatedPathsDetails","edit","pathString","some","p","previousDependencies","currentDependencies","updateType","addition","allAddedPaths","incomingDeps","deletion","_this$cachedEntityTre3","_this$cachedEntityTre4","allDeletedPaths","updatedPath","details","entityTreeToUse","asyncDeps","_intersection","prevAsyncDeps","handlerMap","LINT_TREE","UPDATE_LINT_GLOBALS","libs","idx","findIndex","l","_isEqual","splice","defaultLibraryAccessors","library","resetJSLibraries","SETUP","onmessage","messageType","MessageType","REQUEST","messageHandler","responseData","WorkerMessenger","respond","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","m","x","__webpack_exports__","O","amdO","deferred","chunkIds","priority","notFulfilled","Infinity","fulfilled","j","every","r","getter","__esModule","leafPrototypes","getProto","getPrototypeOf","obj","mode","ns","def","current","getOwnPropertyNames","definition","o","enumerable","f","chunkId","all","promises","u","miniCssF","g","globalThis","prop","Symbol","toStringTag","nmd","children","oldGetScript","oldLoadScript","queryMap","countMap","catch","retries","realSrc","request","location","href","retryAttempt","cacheBust","installedChunks","importScripts","chunkLoadingGlobal","parentChunkLoadingFunction","moreModules","runtime","nc","next"],"sourceRoot":""}