SYMBOL INDEX (550 symbols across 166 files)

FILE: src/background/BackgroundEventsListeners.js
  function handleScheduleBackup (line 9) | async function handleScheduleBackup() {
  class BackgroundEventsListeners (line 78) | class BackgroundEventsListeners {
    method onActionClicked (line 79) | static onActionClicked() {
    method onCommand (line 83) | static onCommand(name) {
    method onAlarms (line 91) | static onAlarms(event) {
    method onWebNavigationCompleted (line 100) | static onWebNavigationCompleted({ tabId, url, frameId }) {
    method onContextMenuClicked (line 106) | static onContextMenuClicked(event, tab) {
    method onNotificationClicked (line 110) | static async onNotificationClicked(notificationId) {
    method onRuntimeStartup (line 123) | static onRuntimeStartup() {
    method onHistoryStateUpdated (line 129) | static onHistoryStateUpdated({ frameId, url, tabId }) {
    method onRuntimeInstalled (line 135) | static async onRuntimeInstalled({ reason }) {

FILE: src/background/BackgroundOffscreen.js
  constant OFFSCREEN_URL (line 7) | const OFFSCREEN_URL = Browser.runtime.getURL('/offscreen.html');
  class BackgroundOffscreen (line 9) | class BackgroundOffscreen {
    method instance (line 17) | static get instance() {
    method constructor (line 28) | constructor() {
    method #ensureDocument (line 38) | async #ensureDocument() {
    method isOpened (line 61) | async isOpened() {
    method sendMessage (line 78) | async sendMessage(name, data) {

FILE: src/background/BackgroundUtils.js
  class BackgroundUtils (line 4) | class BackgroundUtils {
    method openDashboard (line 5) | static async openDashboard(url, updateTab = true) {
    method sendMessageToDashboard (line 50) | static async sendMessageToDashboard(type, data) {

FILE: src/background/BackgroundWorkflowTriggers.js
  class BackgroundWorkflowTriggers (line 11) | class BackgroundWorkflowTriggers {
    method visitWebTriggers (line 12) | static async visitWebTriggers(tabId, tabUrl, spa = false) {
    method scheduleWorkflow (line 44) | static async scheduleWorkflow({ name }) {
    method contextMenu (line 123) | static async contextMenu({ parentMenuItemId, menuItemId, frameId }, ta...
    method reRegisterTriggers (line 153) | static async reRegisterTriggers(isStartup = false) {

FILE: src/background/BackgroundWorkflowUtils.js
  class BackgroundWorkflowUtils (line 5) | class BackgroundWorkflowUtils {
    method instance (line 13) | static get instance() {
    method constructor (line 22) | constructor() {
    method flattenTeamWorkflows (line 26) | static flattenTeamWorkflows(workflows) {
    method getWorkflow (line 30) | static async getWorkflow(workflowId) {
    method #ensureWorkflowManager (line 63) | async #ensureWorkflowManager() {
    method stopExecution (line 76) | async stopExecution(stateId) {
    method resumeExecution (line 92) | async resumeExecution(stateId, nextBlock) {
    method updateExecutionState (line 111) | async updateExecutionState(stateId, data) {
    method executeWorkflow (line 124) | async executeWorkflow(workflowData, options) {

FILE: src/background/index.js
  function executeCommands (line 107) | async function executeCommands() {
  constant DOWNLOADS_STORAGE_KEY (line 734) | const DOWNLOADS_STORAGE_KEY = 'automa-rename-downloaded-files';
  function determineFilenameListener (line 753) | function determineFilenameListener(item, suggest) {
  function handleDownloadChanged (line 830) | function handleDownloadChanged(downloadDelta) {
  function handleDownloadCreated (line 888) | async function handleDownloadCreated(downloadItem) {
  function cleanupDownloadListeners (line 929) | function cleanupDownloadListeners() {
  function registerBackgroundDownloadListeners (line 944) | async function registerBackgroundDownloadListeners() {

FILE: src/common/utils/constant.js
  constant IS_FIREFOX (line 1) | const IS_FIREFOX = BROWSER_TYPE === 'firefox';

FILE: src/composable/blockValidation.js
  function useBlockValidation (line 4) | function useBlockValidation(blockId, data) {

FILE: src/composable/commandManager.js
  function useCommandManager (line 3) | function useCommandManager({ maxHistory = 100 } = {}) {

FILE: src/composable/componentId.js
  function useComponentId (line 3) | function useComponentId(prefix) {

FILE: src/composable/dialog.js
  function useDialog (line 3) | function useDialog() {

FILE: src/composable/editorBlock.js
  function useEditorBlock (line 5) | function useEditorBlock(label) {

FILE: src/composable/groupTooltip.js
  function useGroupTooltip (line 5) | function useGroupTooltip(elements, options = {}) {

FILE: src/composable/hasPermissions.js
  function useHasPermissions (line 6) | function useHasPermissions(permissions) {

FILE: src/composable/liveQuery.js
  function useLiveQuery (line 4) | function useLiveQuery(querier) {

FILE: src/composable/shortcut.js
  function getReadableShortcut (line 65) | function getReadableShortcut(str) {
  function getShortcut (line 84) | function getShortcut(id, data) {
  function useShortcut (line 95) | function useShortcut(shortcuts, handler) {

FILE: src/composable/theme.js
  function useTheme (line 12) | function useTheme() {

FILE: src/content/blocksHandler/handlerAttributeValue.js
  function handleAttributeValue (line 3) | function handleAttributeValue(block) {

FILE: src/content/blocksHandler/handlerClipboard.js
  function clipboard (line 1) | function clipboard() {

FILE: src/content/blocksHandler/handlerConditions.js
  function handleConditionElement (line 8) | async function handleConditionElement({ data, type, id, frameSelector }) {
  function handleConditionCode (line 56) | async function handleConditionCode({ data, refData }) {

FILE: src/content/blocksHandler/handlerCreateElement.js
  function createNode (line 10) | function createNode(tag, attrs = {}, content = '') {
  function createElement (line 21) | async function createElement(block) {

FILE: src/content/blocksHandler/handlerElementExists.js
  function elementExists (line 3) | function elementExists(block) {

FILE: src/content/blocksHandler/handlerElementScroll.js
  function isElScrollable (line 3) | function isElScrollable(element) {
  function findScrollableElement (line 14) | function findScrollableElement(
  function elementScroll (line 50) | function elementScroll(block) {

FILE: src/content/blocksHandler/handlerEventClick.js
  function eventClick (line 6) | function eventClick(block) {

FILE: src/content/blocksHandler/handlerForms.js
  function forms (line 7) | async function forms(block) {

FILE: src/content/blocksHandler/handlerGetText.js
  function getText (line 3) | function getText(block) {

FILE: src/content/blocksHandler/handlerHoverElement.js
  function eventClick (line 5) | function eventClick(block) {

FILE: src/content/blocksHandler/handlerJavascriptCode.js
  function javascriptCode (line 4) | function javascriptCode({ data, isPreloadScripts, frameSelector }) {

FILE: src/content/blocksHandler/handlerLink.js
  function link (line 3) | async function link(block) {

FILE: src/content/blocksHandler/handlerLoopData.js
  function loopElements (line 5) | async function loopElements(block) {

FILE: src/content/blocksHandler/handlerLoopElements.js
  function getScrollParent (line 5) | function getScrollParent(node) {
  function excludeSelector (line 23) | function excludeSelector({ type, selector, loopAttr }) {

FILE: src/content/blocksHandler/handlerPressKey.js
  function pressKeyWithJs (line 14) | async function pressKeyWithJs({ element, keys, pressTime }) {
  function pressKeyWithCommand (line 94) | async function pressKeyWithCommand({
  function pressKey (line 156) | async function pressKey({ data, debugMode, activeTabId }) {

FILE: src/content/blocksHandler/handlerSaveAssets.js
  function saveAssets (line 3) | async function saveAssets(block) {

FILE: src/content/blocksHandler/handlerSwitchTo.js
  function switchTo (line 6) | function switchTo(block) {

FILE: src/content/blocksHandler/handlerTakeScreenshot.js
  function findScrollableElement (line 5) | function findScrollableElement(
  function injectStyle (line 34) | function injectStyle() {
  function canvasToBase64 (line 43) | function canvasToBase64(canvas, { format, quality }) {
  function loadAsyncImg (line 46) | function loadAsyncImg(src) {
  function takeScreenshot (line 55) | async function takeScreenshot(tabId, options) {
  function captureElement (line 65) | async function captureElement({ selector, tabId, options, $frameRect }) {

FILE: src/content/blocksHandler/handlerTriggerEvent.js
  function triggerEvent (line 66) | function triggerEvent({ data, id, frameSelector, debugMode, activeTabId ...

FILE: src/content/blocksHandler/handlerUploadFile.js
  function injectFiles (line 4) | function injectFiles(element, files) {

FILE: src/content/blocksHandler/handlerVerifySelector.js
  constant SLEEP_TIME (line 4) | const SLEEP_TIME = 1700;
  function verifySelector (line 6) | async function verifySelector(block) {

FILE: src/content/commandPalette/index.js
  function pageLoaded (line 5) | function pageLoaded() {

FILE: src/content/elementObserver.js
  function matchPatternToRegex (line 34) | function matchPatternToRegex(str) {
  function tryObserve (line 44) | function tryObserve({ selector, observer, options, id }) {

FILE: src/content/elementSelector/listSelector.js
  function getAllSiblings (line 4) | function getAllSiblings(el, selector) {
  function getCssPath (line 37) | function getCssPath(el, root = document.body) {
  function getElementList (line 68) | function getElementList(el, maxDepth = 50, paths = []) {

FILE: src/content/elementSelector/selectorFrameContext.js
  function getElementRectWithOffset (line 10) | function getElementRectWithOffset(element, data) {
  function getElementsRect (line 19) | function getElementsRect(data) {
  function resetElementSelector (line 71) | function resetElementSelector(data) {
  function findElement (line 82) | function findElement({ selector, selectorType, frameRect }) {
  function onMessage (line 105) | function onMessage({ data }) {

FILE: src/content/handleSelector.js
  function markElement (line 6) | function markElement(el, { id, data }) {
  function getDocumentCtx (line 12) | function getDocumentCtx(frameSelector) {
  function queryElements (line 29) | function queryElements(data, documentCtx = document) {

FILE: src/content/index.js
  function messageToFrame (line 21) | function messageToFrame(frameElement, blockData) {
  function executeBlock (line 52) | async function executeBlock(data) {
  function messageListener (line 121) | async function messageListener({ data, source }) {

FILE: src/content/injectAppStyles.js
  function generateStyleEl (line 3) | function generateStyleEl(css, classes = true) {

FILE: src/content/services/recordWorkflow/recordEvents.js
  function addBlock (line 15) | async function addBlock(detail) {
  function onChange (line 42) | function onChange({ target }) {
  function onKeydown (line 114) | async function onKeydown(event) {
  function onClick (line 176) | function onClick(event) {
  function onFocusIn (line 319) | function onFocusIn({ target }) {
  function onFocusOut (line 325) | function onFocusOut({ target }) {
  function cleanUp (line 331) | function cleanUp() {

FILE: src/content/services/shortcutListener.js
  function automaCustomEventListener (line 9) | function automaCustomEventListener(findWorkflow) {
  function workflowShortcutsListener (line 27) | function workflowShortcutsListener(findWorkflow, shortcutsObj) {
  function getWorkflows (line 65) | async function getWorkflows() {

FILE: src/content/services/webService.js
  function initWebListener (line 8) | function initWebListener() {
  function sendMessageBack (line 25) | function sendMessageBack(type, payload = {}) {
  method upgrade (line 42) | upgrade(event) {

FILE: src/content/showExecutedBlock.js
  function generateElement (line 3) | function generateElement(block) {

FILE: src/content/synchronizedLock.js
  class SynchronizedLock (line 1) | class SynchronizedLock {
    method constructor (line 2) | constructor() {
    method getLock (line 7) | async getLock(timeout = 10000) {
    method releaseLock (line 25) | releaseLock() {

FILE: src/content/utils.js
  function simulateClickElement (line 1) | function simulateClickElement(element) {
  function generateLoopSelectors (line 16) | function generateLoopSelectors(
  function elementSelectorInstance (line 40) | function elementSelectorInstance() {
  function getElementRect (line 54) | function getElementRect(target, withAttributes) {
  function getElementPath (line 81) | function getElementPath(el, root = document.documentElement) {
  function generateXPath (line 92) | function generateXPath(element, root = document.body) {
  function automaRefDataStr (line 118) | function automaRefDataStr(varName) {
  function messageTopFrame (line 153) | function messageTopFrame(windowCtx) {
  function getElementPosition (line 174) | async function getElementPosition(element) {

FILE: src/directives/VAutofocus.js
  method mounted (line 2) | mounted(el, { value = true }) {

FILE: src/directives/VClosePopover.js
  method mounted (line 4) | mounted(el) {
  method beforeUnmount (line 7) | beforeUnmount(el) {

FILE: src/directives/VTooltip.js
  function getContent (line 3) | function getContent(content) {
  method mounted (line 16) | mounted(el, { value, arg = 'top', instance, modifiers }) {
  method updated (line 31) | updated(el, { value, arg = 'top' }) {

FILE: src/execute/index.js
  function getWorkflowDetail (line 5) | function getWorkflowDetail() {
  function writeResult (line 24) | function writeResult(text) {

FILE: src/lib/compsUi.js
  function componentsExtractor (line 12) | function componentsExtractor(app, components) {

FILE: src/lib/cronstrue.js
  function readableCron (line 12) | function readableCron(expression) {

FILE: src/lib/pinia.js
  function saveToStoragePlugin (line 4) | function saveToStoragePlugin({ store, options }) {

FILE: src/lib/query-selector-shadow-dom/index.js
  function querySelectorAllDeep (line 22) | function querySelectorAllDeep(
  function querySelectorDeep (line 30) | function querySelectorDeep(
  function _querySelectorDeep (line 38) | function _querySelectorDeep(selector, findMany, root, allElements = null) {
  function findMatchingElement (line 101) | function findMatchingElement(splitSelector, possibleElementsIndex, root) {
  function splitByCharacterUnlessQuoted (line 137) | function splitByCharacterUnlessQuoted(selector, character) {
  function isDocumentNode (line 162) | function isDocumentNode(node) {
  function findParentOrHost (line 169) | function findParentOrHost(element, root) {
  function collectAllElementsDeep (line 193) | function collectAllElementsDeep(

FILE: src/lib/query-selector-shadow-dom/normalize.js
  function normalizeSelector (line 15) | function normalizeSelector(sel) {

FILE: src/lib/vRemixicon.js
  method setup (line 341) | setup(props) {
  method install (line 387) | install(app) {

FILE: src/lib/vueI18n.js
  function setI18nLanguage (line 11) | function setI18nLanguage(locale) {
  function loadLocaleMessages (line 17) | async function loadLocaleMessages(locale, location) {

FILE: src/newtab/utils/RecordWorkflowUtils.js
  class RecordWorkflowUtils (line 6) | class RecordWorkflowUtils {
    method updateRecording (line 7) | static async updateRecording(callback) {
    method onTabCreated (line 20) | static onTabCreated(tab) {
    method onTabsActivated (line 50) | static async onTabsActivated({ tabId }) {
    method onWebNavigationCommited (line 69) | static onWebNavigationCommited({ frameId, tabId, url, transitionType }) {
    method onWebNavigationCompleted (line 103) | static async onWebNavigationCompleted({ tabId, url, frameId }) {

FILE: src/newtab/utils/blocksValidation.js
  function validateTrigger (line 11) | async function validateTrigger(data) {
  function validateExecuteWorkflow (line 73) | async function validateExecuteWorkflow(data) {
  function validateNewTab (line 79) | async function validateNewTab(data) {
  function validateSwitchTab (line 85) | async function validateSwitchTab(data) {
  function validateProxy (line 102) | async function validateProxy(data) {
  function validateCloseTab (line 108) | async function validateCloseTab(data) {
  function validateTakeScreenshot (line 116) | async function validateTakeScreenshot(data) {
  function validateInteractionBasic (line 124) | async function validateInteractionBasic(data) {
  function validateExportData (line 130) | async function validateExportData(data) {
  function validateAttributeValue (line 148) | async function validateAttributeValue(data) {
  function validateGoogleSheets (line 158) | async function validateGoogleSheets(data) {
  function validateWebhook (line 168) | async function validateWebhook(data) {
  function validateLoopData (line 174) | async function validateLoopData(data) {
  function validateLoopElements (line 194) | async function validateLoopElements(data) {
  function validateClipboard (line 209) | async function validateClipboard() {
  function validateSwitchTo (line 223) | async function validateSwitchTo(data) {
  function validateUploadFile (line 231) | async function validateUploadFile(data) {
  function validateSaveAssets (line 242) | async function validateSaveAssets(data) {
  function validatePressKey (line 256) | async function validatePressKey(data) {
  function validateNotification (line 269) | async function validateNotification() {
  function validateCookie (line 276) | async function validateCookie() {

FILE: src/newtab/utils/elementSelector.js
  function makeDashboardFocus (line 6) | async function makeDashboardFocus() {
  function initElementSelector (line 16) | async function initElementSelector(tab = null) {
  function verifySelector (line 49) | async function verifySelector(data) {
  function selectElement (line 81) | async function selectElement(name) {

FILE: src/sandbox/index.js
  function fetchResponse (line 8) | function fetchResponse({ id, data }) {
  function sendResponse (line 26) | function sendResponse(payload) {

FILE: src/sandbox/utils/handleJavascriptBlock.js
  function cleanUp (line 74) | function cleanUp() {

FILE: src/service/browser-api/BrowserAPIEventHandler.js
  constant BROWSER_API_EVENTS (line 6) | const BROWSER_API_EVENTS = {
  function onBrowserAPIEvent (line 11) | function onBrowserAPIEvent(name, ...args) {
  class BrowserAPIEventHandler (line 23) | class BrowserAPIEventHandler {
    method instance (line 31) | static get instance() {
    method constructor (line 51) | constructor() {
    method createEventListener (line 63) | createEventListener(name) {
    method onBrowserEventListener (line 140) | onBrowserEventListener(event) {
    method onToggleBrowserEventListener (line 149) | onToggleBrowserEventListener({ name, type }) {

FILE: src/service/browser-api/BrowserAPIService.js
  constant IS_BROWSER_API_AVAILABLE (line 21) | const IS_BROWSER_API_AVAILABLE = 'tabs' in Browser;
  function sendBrowserApiMessage (line 23) | function sendBrowserApiMessage(name, ...args) {
  class BrowserContentScript (line 36) | class BrowserContentScript {
    method isContentScriptInjected (line 42) | static async isContentScriptInjected(target, messageId) {
    method inject (line 75) | static async inject({ file, target, injectImmediately, waitUntilInject...
    method isInjected (line 146) | static async isInjected({ tabId, allFrames, frameId }, messageId) {
  class BrowserAPIService (line 165) | class BrowserAPIService {
    method runtimeMessageHandler (line 170) | static runtimeMessageHandler({ args, name }) {

FILE: src/service/renderer/RendererWorkflowService.js
  class RendererWorkflowService (line 4) | class RendererWorkflowService {
    method executeWorkflow (line 5) | static executeWorkflow(workflowData, options) {
    method stopWorkflowExecution (line 22) | static stopWorkflowExecution(executionId) {

FILE: src/stores/folder.js
  method addFolder (line 14) | async addFolder(name) {
  method deleteFolder (line 24) | async deleteFolder(id) {
  method updateFolder (line 33) | async updateFolder(id, data = {}) {
  method load (line 42) | load() {

FILE: src/stores/hostedWorkflow.js
  method loadData (line 23) | async loadData() {
  method insert (line 30) | async insert(data, idKey = 'hostId') {
  method delete (line 43) | async delete(id) {
  method update (line 51) | async update({ id, data }) {
  method fetchWorkflows (line 59) | async fetchWorkflows(ids) {

FILE: src/stores/main.js
  method loadSettings (line 43) | loadSettings() {
  method updateSettings (line 49) | async updateSettings(settings = {}) {
  method checkGDriveIntegration (line 53) | async checkGDriveIntegration(force = false, retryCount = 0) {
  method getConnectedSheets (line 91) | async getConnectedSheets() {

FILE: src/stores/package.js
  method insert (line 43) | async insert(data, newId = true) {
  method update (line 54) | async update({ id, data }) {
  method delete (line 63) | async delete(id) {
  method deleteShared (line 74) | deleteShared(id) {
  method insertShared (line 78) | insertShared(id) {
  method loadData (line 81) | async loadData(force = false) {
  method loadShared (line 91) | async loadShared() {

FILE: src/stores/sharedWorkflow.js
  method insert (line 18) | insert(data) {
  method update (line 27) | update({ id, data }) {
  method delete (line 34) | delete(id) {
  method fetchWorkflows (line 37) | async fetchWorkflows(useCache = true) {

FILE: src/stores/teamWorkflow.js
  method insert (line 28) | async insert(teamId, data) {
  method update (line 41) | async update({ teamId, id, data, deepmerge = false }) {
  method delete (line 58) | async delete(teamId, id) {
  method loadData (line 66) | async loadData() {

FILE: src/stores/user.js
  method loadUser (line 27) | async loadUser(options = false) {
  method signOut (line 83) | async signOut() {

FILE: src/stores/workflow.js
  function convertWorkflowsToObject (line 82) | function convertWorkflowsToObject(workflows) {
  method loadData (line 115) | async loadData() {
  method updateStates (line 138) | updateStates(newStates) {
  method insert (line 141) | async insert(data = {}, options = {}) {
  method update (line 168) | async update({ id, data = {}, deep = false }) {
  method insertOrUpdate (line 215) | async insertOrUpdate(
  method delete (line 247) | async delete(id) {

FILE: src/utils/FindElement.js
  class FindElement (line 21) | class FindElement {
    method cssSelector (line 22) | static cssSelector(data, documentCtx = document) {
    method xpath (line 54) | static xpath(data, documentCtx = document) {

FILE: src/utils/api.js
  function fetchApi (line 5) | async function fetchApi(path, options = {}) {
  function cacheApi (line 44) | async function cacheApi(key, callback, useCache = true) {
  function getSharedWorkflows (line 79) | async function getSharedWorkflows(useCache = true) {
  function getUserWorkflows (line 110) | async function getUserWorkflows(useCache = true) {
  function validateOauthToken (line 158) | function validateOauthToken() {
  function fetchGapi (line 199) | async function fetchGapi(url, resource = {}, options = {}) {

FILE: src/utils/callbackBridge.js
  function isCallbackBridge (line 8) | function isCallbackBridge(obj) {
  class CallbackBridge (line 16) | class CallbackBridge {
    method constructor (line 17) | constructor() {
    method setupMessageHandlers (line 22) | setupMessageHandlers() {
    method createCallbackHandler (line 49) | createCallbackHandler(callback, callbackId) {
    method executeCallback (line 89) | static async executeCallback(callbackId, result, error = null) {
    method generateCallbackId (line 101) | static generateCallbackId() {
  function processCallbacksInData (line 115) | function processCallbacksInData(obj, bridge) {
  function sendMessageWithCallbacks (line 143) | async function sendMessageWithCallbacks(messageName, data, prefix = '') {
  function executeCallbacksInData (line 154) | async function executeCallbacksInData(obj, result, error = null) {
  function hasCallbackBridges (line 181) | function hasCallbackBridges(obj) {
  function getCallbackBridgeIds (line 202) | function getCallbackBridgeIds(obj) {

FILE: src/utils/codeEditorAutocomplete.js
  function completeProperties (line 8) | function completeProperties(from, object) {
  function completeFromGlobalScope (line 37) | function completeFromGlobalScope(context) {
  function automaFuncsCompletion (line 59) | function automaFuncsCompletion(snippets) {

FILE: src/utils/convertWorkflowData.js
  function extractBlock (line 21) | function extractBlock(blockId) {

FILE: src/utils/credentialUtil.js
  function encryptValue (line 8) | function encryptValue(value) {
  function decryptValue (line 16) | function decryptValue(value) {

FILE: src/utils/dataExporter.js
  function generateJSON (line 19) | function generateJSON(keys, data) {

FILE: src/utils/decryptFlow.js
  function getWorkflowPass (line 8) | function getWorkflowPass(pass) {

FILE: src/utils/editor/DroppedNode.js
  class DroppedNode (line 7) | class DroppedNode {
    method isNode (line 8) | static isNode(target) {
    method isHandle (line 14) | static isHandle(target) {
    method isEdge (line 18) | static isEdge(target) {
    method replaceNode (line 22) | static replaceNode(editor, { block, target: targetEl }) {
    method appendNode (line 83) | static appendNode(editor, { target, nodeId }) {
    method insertBetweenNode (line 97) | static insertBetweenNode(editor, { target, nodeId, outputs }) {

FILE: src/utils/editor/EditorCommands.js
  class EditorCommands (line 1) | class EditorCommands {
    method constructor (line 2) | constructor(editor, initialStates = {}) {
    method nodeAdded (line 7) | nodeAdded(addedNodes) {
    method nodeRemoved (line 25) | nodeRemoved(ids) {
    method edgeAdded (line 38) | edgeAdded(addedEdges) {
    method edgeRemoved (line 56) | edgeRemoved(ids) {

FILE: src/utils/editor/editorAutocomplete.js
  function getData (line 10) | function getData(blockName, blockData) {
  method trigger (line 29) | trigger(blockId, data) {

FILE: src/utils/getAIPoweredInfo.js
  constant BASE_URL (line 3) | const BASE_URL = secrets.apApiUrl;

FILE: src/utils/getFile.js
  function readFileAsBase64 (line 1) | function readFileAsBase64(blob) {
  function downloadFile (line 11) | async function downloadFile(url, options) {
  function getLocalFile (line 29) | function getLocalFile(path, options) {

FILE: src/utils/getSharedData.js
  function getBlocks (line 4) | function getBlocks() {

FILE: src/utils/getTranslateLog.js
  function translateLog (line 14) | function translateLog(log) {
  function getDataSnapshot (line 45) | function getDataSnapshot(propsCtxData, refData) {
  function getLogs (line 66) | function getLogs(dataType, translatedLog, curStateCtxData) {

FILE: src/utils/googleSheetsApi.js
  function queryBuilder (line 3) | function queryBuilder(obj) {
  method getUrl (line 16) | getUrl(path) {
  method getValues (line 19) | getValues({ spreadsheetId, range }) {
  method getRange (line 24) | getRange({ spreadsheetId, range }) {
  method clearValues (line 33) | clearValues({ spreadsheetId, range }) {
  method updateValues (line 40) | updateValues({ spreadsheetId, range, options, append }) {
  method create (line 59) | create(name) {
  method addSheet (line 71) | addSheet({ sheetName, spreadsheetId }) {
  method getUrl (line 89) | getUrl(spreadsheetId, range) {
  method getValues (line 92) | getValues({ spreadsheetId, range }) {
  method getRange (line 97) | getRange({ spreadsheetId, range }) {
  method clearValues (line 112) | clearValues({ spreadsheetId, range }) {
  method updateValues (line 117) | updateValues({ spreadsheetId, range, options = {}, append }) {

FILE: src/utils/handleFormElement.js
  function reactJsEvent (line 9) | function reactJsEvent(element, value) {
  function formEvent (line 17) | function formEvent(element, data) {
  function inputText (line 62) | async function inputText({ data, element, isEditable }) {

FILE: src/utils/helper.js
  function getActiveTab (line 4) | async function getActiveTab() {
  function isXPath (line 29) | function isXPath(str) {
  function visibleInViewport (line 35) | function visibleInViewport(element) {
  function sleep (line 49) | function sleep(timeout = 500) {
  function findTriggerBlock (line 57) | function findTriggerBlock(drawflow = {}) {
  function throttle (line 73) | function throttle(callback, limit) {
  function convertArrObjTo2DArr (line 87) | function convertArrObjTo2DArr(arr) {
  function convert2DArrayToArrayObj (line 113) | function convert2DArrayToArrayObj(values) {
  function parseJSON (line 143) | function parseJSON(data, def) {
  function parseFlow (line 153) | function parseFlow(flow) {
  function replaceMustache (line 159) | function replaceMustache(str, replacer) {
  function openFilePicker (line 164) | function openFilePicker(acceptedFileTypes = [], attrs = {}) {
  function fileSaver (line 193) | function fileSaver(filename, data) {
  function countDuration (line 202) | function countDuration(started, ended) {
  function toCamelCase (line 212) | function toCamelCase(str, capitalize = false) {
  function isObject (line 222) | function isObject(obj) {
  function objectHasKey (line 226) | function objectHasKey(obj, key) {
  function isWhitespace (line 230) | function isWhitespace(str) {
  function debounce (line 234) | function debounce(callback, time = 200) {
  function clearCache (line 251) | async function clearCache(workflow) {
  function arraySorter (line 273) | function arraySorter({ data, key, order = 'asc' }) {

FILE: src/utils/message.js
  function sendMessage (line 14) | function sendMessage(name = '', data = {}, prefix = '') {
  class MessageListener (line 27) | class MessageListener {
    method constructor (line 30) | constructor(prefix = '') {
    method on (line 37) | on(name, listener) {
    method listener (line 48) | listener(message, sender) {
    method sendMessage (line 88) | sendMessage(name, data) {

FILE: src/utils/openGDriveFilePicker.js
  function fetchGDriveSheets (line 8) | async function fetchGDriveSheets() {
  function openGDrivePickerPopup (line 43) | function openGDrivePickerPopup(accessToken) {

FILE: src/utils/recordKeys.js
  function recordPressedKey (line 4) | function recordPressedKey(
  function recordShortcut (line 36) | function recordShortcut(

FILE: src/utils/serialization.js
  function serializeFunctions (line 1) | function serializeFunctions(obj) {
  function deserializeFunctions (line 26) | function deserializeFunctions(obj) {

FILE: src/utils/simulateEvent/index.js
  function getEventObj (line 3) | function getEventObj(name, params) {

FILE: src/utils/simulateEvent/mouseEvent.js
  function mousedown (line 2) | async function mousedown() {
  function mouseup (line 6) | async function mouseup() {
  function click (line 10) | async function click() {
  function dblclick (line 16) | async function dblclick() {
  function mousemove (line 20) | async function mousemove() {
  function mouseenter (line 24) | async function mouseenter() {
  function mouseleave (line 27) | async function mouseleave() {

FILE: src/utils/workflowData.js
  method hasPermission (line 18) | hasPermission({ data }) {
  method hasPermission (line 36) | hasPermission() {
  method hasPermission (line 46) | hasPermission() {
  method hasPermission (line 52) | hasPermission() {
  method hasPermission (line 58) | hasPermission() {
  method hasPermission (line 64) | hasPermission() {
  function getWorkflowPermissions (line 70) | async function getWorkflowPermissions(drawflow) {
  function importWorkflow (line 95) | function importWorkflow(attrs = {}) {
  function convertWorkflow (line 177) | function convertWorkflow(workflow, additionalKeys = []) {
  function findIncludedWorkflows (line 201) | function findIncludedWorkflows(
  function exportWorkflow (line 235) | function exportWorkflow(workflow) {

FILE: src/utils/workflowTrigger.js
  function registerContextMenu (line 6) | function registerContextMenu(triggerId, data) {
  function removeFromWorkflowQueue (line 71) | async function removeFromWorkflowQueue(workflowId) {
  function cleanWorkflowTriggers (line 84) | async function cleanWorkflowTriggers(workflowId, triggers) {
  function registerSpecificDay (line 150) | function registerSpecificDay(workflowId, data) {
  function registerInterval (line 187) | function registerInterval(workflowId, data) {
  function registerSpecificDate (line 197) | async function registerSpecificDate(workflowId, data) {
  function registerVisitWeb (line 216) | async function registerVisitWeb(workflowId, data) {
  function registerKeyboardShortcut (line 244) | async function registerKeyboardShortcut(workflowId, data) {
  function registerOnStartup (line 257) | async function registerOnStartup() {
  function registerCronJob (line 261) | async function registerCronJob(workflowId, data) {
  function registerWorkflowTrigger (line 283) | async function registerWorkflowTrigger(workflowId, { data }) {

FILE: src/workflowEngine/WorkflowEngine.js
  class WorkflowEngine (line 15) | class WorkflowEngine {
    method constructor (line 16) | constructor(workflow, { states, logger, blocksHandler, isPopup, option...
    method init (line 123) | async init() {
    method addRefDataSnapshot (line 348) | addRefDataSnapshot(key) {
    method addWorker (line 356) | addWorker(detail) {
    method addLogHistory (line 366) | addLogHistory(detail) {
    method stop (line 402) | async stop() {
    method executeQueue (line 414) | async executeQueue() {
    method destroyWorker (line 434) | async destroyWorker(workerId) {
    method destroy (line 453) | async destroy(status, message, blockDetail) {
    method updateState (line 628) | async updateState(data) {
    method dispatchEvent (line 653) | dispatchEvent(name, params) {
    method on (line 663) | on(name, listener) {

FILE: src/workflowEngine/WorkflowLogger.js
  class WorkflowLogger (line 3) | class WorkflowLogger {
    method add (line 4) | async add({ detail, history, ctxData, data }) {

FILE: src/workflowEngine/WorkflowManager.js
  method get (line 13) | get() {
  method set (line 18) | set(key, value) {
  class WorkflowManager (line 25) | class WorkflowManager {
    method instance (line 33) | static get instance() {
    method constructor (line 45) | constructor() {
    method execute (line 50) | execute(workflowData, options) {
    method stopExecution (line 154) | stopExecution(stateId) {
    method resumeExecution (line 164) | resumeExecution(id, nextBlock) {
    method updateExecution (line 174) | updateExecution(id, stateData) {

FILE: src/workflowEngine/WorkflowState.js
  class WorkflowState (line 4) | class WorkflowState {
    method constructor (line 5) | constructor({ storage, key = 'workflowState' }) {
    method _updateBadge (line 15) | _updateBadge() {
    method _saveToStorage (line 21) | _saveToStorage() {
    method dispatchEvent (line 32) | dispatchEvent(name, params) {
    method on (line 42) | on(name, listener) {
    method off (line 48) | off(name, listener) {
    method getAll (line 56) | get getAll() {
    method get (line 60) | async get(stateId) {
    method add (line 74) | async add(id, data = {}) {
    method stop (line 80) | async stop(id) {
    method resume (line 93) | async resume(id, nextBlock) {
    method update (line 106) | async update(id, data = {}) {
    method delete (line 120) | async delete(id) {

FILE: src/workflowEngine/WorkflowWorker.js
  function blockExecutionWrapper (line 15) | function blockExecutionWrapper(blockHandler, blockData) {
  class WorkflowWorker (line 38) | class WorkflowWorker {
    method constructor (line 39) | constructor(id, engine, options = {}) {
    method init (line 66) | init({ blockId, execParam, state }) {
    method addDataToColumn (line 77) | addDataToColumn(key, value) {
    method setVariable (line 112) | async setVariable(name, value) {
    method getBlockConnections (line 143) | getBlockConnections(blockId, outputIndex = 1) {
    method executeNextBlocks (line 154) | executeNextBlocks(
    method resume (line 219) | resume(nextBlock) {
    method executeBlock (line 232) | async executeBlock(block, execParam = {}, isRetry = false) {
    method reset (line 459) | reset() {
    method _sendMessageToTab (line 494) | async _sendMessageToTab(payload, options = {}, runBeforeLoad = false) {

FILE: src/workflowEngine/blocksHandler/handlerActiveTab.js
  function activeTab (line 5) | async function activeTab(block) {

FILE: src/workflowEngine/blocksHandler/handlerAiWorkflow.js
  function aiWorkflow (line 4) | async function aiWorkflow(block, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerBlocksGroup.js
  function blocksGroup (line 1) | function blocksGroup({ data, id }, { prevBlockData }) {

FILE: src/workflowEngine/blocksHandler/handlerBrowserEvent.js
  function handleEventListener (line 4) | function handleEventListener(target, validate) {
  function onTabLoaded (line 27) | function onTabLoaded({ tabLoadedUrl, activeTabLoaded, timeout }, { id }) {

FILE: src/workflowEngine/blocksHandler/handlerClipboard.js
  function doCommand (line 5) | function doCommand(command, value) {

FILE: src/workflowEngine/blocksHandler/handlerCloseTab.js
  function closeWindow (line 3) | async function closeWindow(data, windowId) {
  function closeTab (line 29) | async function closeTab(data, tabId) {

FILE: src/workflowEngine/blocksHandler/handlerConditions.js
  function checkConditions (line 8) | function checkConditions(data, conditionOptions) {
  function conditions (line 47) | async function conditions({ data, id }, { prevBlockData, refData }) {

FILE: src/workflowEngine/blocksHandler/handlerCookie.js
  function getValues (line 4) | function getValues(data, keys) {
  function cookie (line 35) | async function cookie({ data, id }) {

FILE: src/workflowEngine/blocksHandler/handlerCreateElement.js
  function getAutomaScript (line 7) | function getAutomaScript(refData) {
  function createElementScript (line 27) | function createElementScript(code, blockId, $automaScript, $preloadScrip...
  function handleCreateElement (line 53) | async function handleCreateElement(block, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerDataMapping.js
  function mapData (line 4) | function mapData(data, sources) {
  function dataMapping (line 21) | async function dataMapping({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerDelay.js
  function delay (line 1) | function delay(block) {

FILE: src/workflowEngine/blocksHandler/handlerDeleteData.js
  function deleteData (line 1) | function deleteData({ data, id }) {

FILE: src/workflowEngine/blocksHandler/handlerElementExists.js
  function elementExists (line 1) | function elementExists(block) {

FILE: src/workflowEngine/blocksHandler/handlerExecuteWorkflow.js
  function workflowListener (line 8) | function workflowListener(workflow, options) {
  function findWorkflow (line 40) | function findWorkflow(workflows, workflowId) {
  function executeWorkflow (line 48) | async function executeWorkflow({ id: blockId, data }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerExportData.js
  function blobToBase64 (line 4) | function blobToBase64(blob) {
  function exportData (line 12) | async function exportData({ data, id }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerForwardPage.js
  function goBack (line 3) | async function goBack({ id }) {

FILE: src/workflowEngine/blocksHandler/handlerGoBack.js
  function goBack (line 3) | async function goBack({ id }) {

FILE: src/workflowEngine/blocksHandler/handlerGoogleDrive.js
  function getFilename (line 6) | function getFilename(url) {
  function googleDrive (line 19) | async function googleDrive({ id, data }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerGoogleSheets.js
  function getSpreadsheetValues (line 9) | async function getSpreadsheetValues({
  function getSpreadsheetRange (line 31) | async function getSpreadsheetRange({ spreadsheetId, range, isDriveSheet ...
  function clearSpreadsheetValues (line 49) | async function clearSpreadsheetValues({ spreadsheetId, range, isDriveShe...
  function updateSpreadsheetValues (line 62) | async function updateSpreadsheetValues(

FILE: src/workflowEngine/blocksHandler/handlerHandleDialog.js
  function handleDialog (line 21) | async function handleDialog({ data, id: blockId }) {

FILE: src/workflowEngine/blocksHandler/handlerHandleDownload.js
  constant DOWNLOADS_STORAGE_KEY (line 6) | const DOWNLOADS_STORAGE_KEY = 'automa-rename-downloaded-files';
  function getDownloadFilesFromStorage (line 12) | async function getDownloadFilesFromStorage() {
  function saveDownloadFilesToStorage (line 26) | async function saveDownloadFilesToStorage(filesData) {
  function removeDownloadFromStorage (line 40) | async function removeDownloadFromStorage(downloadId) {
  function registerDownloadListeners (line 53) | async function registerDownloadListeners() {
  function handleDownload (line 80) | async function handleDownload({ data, id: blockId }) {

FILE: src/workflowEngine/blocksHandler/handlerHoverElement.js
  function hoverElement (line 4) | async function hoverElement(block) {

FILE: src/workflowEngine/blocksHandler/handlerIncreaseVariable.js
  function increaseVariable (line 3) | async function increaseVariable({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerInsertData.js
  function insertData (line 7) | async function insertData({ id, data }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerInteractionBlock.js
  function checkAccess (line 5) | async function checkAccess(blockName) {
  function interactionHandler (line 26) | async function interactionHandler(block) {

FILE: src/workflowEngine/blocksHandler/handlerJavascriptCode.js
  function getAutomaScript (line 15) | function getAutomaScript({ varName, refData, everyNewTab, isEval = false...
  function executeInWebpage (line 59) | async function executeInWebpage(args, target, worker) {
  function javascriptCode (line 260) | async function javascriptCode({ outputs, data, ...block }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerLogData.js
  function logData (line 3) | async function logData({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerLoopBreakpoint.js
  function loopBreakpoint (line 3) | async function loopBreakpoint(block, { prevBlockData }) {

FILE: src/workflowEngine/blocksHandler/handlerLoopData.js
  function loopData (line 4) | async function loopData({ data, id }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerLoopElements.js
  function loopElements (line 1) | async function loopElements({ data, id }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerNewTab.js
  function isValidURL (line 11) | function isValidURL(url) {
  function newTab (line 21) | async function newTab({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerNewWindow.js
  function newWindow (line 4) | async function newWindow({ data, id }) {

FILE: src/workflowEngine/blocksHandler/handlerParameterPrompt.js
  function getInputtedParams (line 7) | function getInputtedParams(promptId, ms = 10000) {
  function renderParamValue (line 38) | async function renderParamValue(param, refData, isPopup) {

FILE: src/workflowEngine/blocksHandler/handlerProxy.js
  function setProxy (line 4) | function setProxy({ data, id }) {

FILE: src/workflowEngine/blocksHandler/handlerRegexVariable.js
  function regexVariable (line 3) | async function regexVariable({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerReloadTab.js
  function reloadTab (line 3) | async function reloadTab({ id }) {

FILE: src/workflowEngine/blocksHandler/handlerRepeatTask.js
  function repeatTask (line 1) | function repeatTask({ data, id }) {

FILE: src/workflowEngine/blocksHandler/handlerSaveAssets.js
  function getFilename (line 3) | function getFilename(url) {

FILE: src/workflowEngine/blocksHandler/handlerSliceVariable.js
  function sliceData (line 3) | async function sliceData({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerSortData.js
  function sliceData (line 3) | async function sliceData({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerSwitchTo.js
  function switchTo (line 4) | async function switchTo(block) {

FILE: src/workflowEngine/blocksHandler/handlerTabUrl.js
  function logData (line 3) | async function logData({ id, data }) {

FILE: src/workflowEngine/blocksHandler/handlerTakeScreenshot.js
  function saveImage (line 6) | async function saveImage({ filename, uri, ext }) {
  function takeScreenshot (line 37) | async function takeScreenshot({ data, id, label }) {

FILE: src/workflowEngine/blocksHandler/handlerTrigger.js
  function trigger (line 1) | async function trigger(block) {

FILE: src/workflowEngine/blocksHandler/handlerWaitConnections.js
  function waitConnections (line 1) | async function waitConnections({ data, id }, { prevBlock }) {

FILE: src/workflowEngine/blocksHandler/handlerWebhook.js
  constant ALL_HTTP_RESPONSE_KEYWORD (line 6) | const ALL_HTTP_RESPONSE_KEYWORD = '$response';
  function webhook (line 8) | async function webhook({ data, id }, { refData }) {

FILE: src/workflowEngine/blocksHandler/handlerWhileLoop.js
  function whileLoop (line 4) | async function whileLoop({ data, id }, { refData }) {

FILE: src/workflowEngine/helper.js
  function escapeElementPolicy (line 6) | function escapeElementPolicy(script) {
  function messageSandbox (line 47) | function messageSandbox(type, data = {}) {
  function getFrames (line 69) | async function getFrames(tabId) {
  function sendDebugCommand (line 89) | function sendDebugCommand(tabId, method, params = {}) {
  function attachDebugger (line 95) | async function attachDebugger(tabId, prevTab) {
  function waitTabLoaded (line 114) | function waitTabLoaded({ tabId, listenError = false, ms = 10000 }) {
  function convertData (line 174) | function convertData(data, type) {
  function automaRefDataStr (line 199) | function automaRefDataStr(varName) {
  function injectPreloadScript (line 234) | function injectPreloadScript({ target, scripts, frameSelector }) {
  function checkCSPAndInject (line 269) | async function checkCSPAndInject(
  function fallbackCopyTextToClipboard (line 300) | function fallbackCopyTextToClipboard(text) {
  function copyTextToClipboard (line 322) | function copyTextToClipboard(text) {

FILE: src/workflowEngine/injectContentScript.js
  function contentScriptExist (line 5) | async function contentScriptExist(tabId, frameId = 0) {

FILE: src/workflowEngine/templating/mustacheReplacer.js
  function extractStrFunction (line 12) | function extractStrFunction(str) {
  function keyParser (line 29) | function keyParser(key, data) {
  function replacer (line 64) | function replacer(

FILE: src/workflowEngine/templating/templatingFunctions.js
  function parseJSON (line 12) | function parseJSON(data, def) {
  method date (line 23) | date(...args) {
  method randint (line 45) | randint(min = 0, max = 100) {
  method getLength (line 48) | getLength(str) {
  method slice (line 53) | slice(value, start, end) {
  method multiply (line 61) | multiply(value, multiplyBy) {
  method increment (line 66) | increment(value, incrementBy) {
  method divide (line 71) | divide(value, divideBy) {
  method subtract (line 76) | subtract(value, subtractBy) {
  method randData (line 81) | randData(str) {
  method filter (line 119) | filter(data, exps) {
  method replace (line 124) | replace(value, search, replace) {
  method replaceAll (line 129) | replaceAll(value, search, replace) {
  method toLowerCase (line 134) | toLowerCase(value) {
  method toUpperCase (line 139) | toUpperCase(value) {
  method modulo (line 144) | modulo(value, divisor) {
  method stringify (line 147) | stringify(value) {

FILE: src/workflowEngine/utils/javascriptBlockUtil.js
  function automaFetchClient (line 3) | function automaFetchClient(id, { type, resource }) {
  function jsContentHandlerEval (line 37) | function jsContentHandlerEval({
  function jsContentHandler (line 74) | function jsContentHandler($blockData, $preloadScripts, $automaScript) {

FILE: src/workflowEngine/utils/testConditions.js
  function getConditionItemValue (line 51) | async function getConditionItemValue({ type, data }) {
  function checkConditions (line 143) | async function checkConditions(items) {

FILE: src/workflowEngine/utils/webhookUtil.js
  function executeWebhook (line 84) | async function executeWebhook({

FILE: src/workflowEngine/workflowEvent.js
  class WorkflowEvent (line 5) | class WorkflowEvent {
    method #httpRequest (line 6) | static async #httpRequest({ url, method, headers, body }, refData) {
    method #javascriptCode (line 26) | static async #javascriptCode(event, refData) {
    method handle (line 39) | static async handle(event, refData) {

FILE: tailwind.config.js
  function withOpacityValue (line 5) | function withOpacityValue(variable) {
  function rem2px (line 13) | function rem2px(input, fontSize = 16) {

FILE: webpack.config.js
  constant ASSET_PATH (line 12) | const ASSET_PATH = process.env.ASSET_PATH || '/';
  method transform (line 167) | transform(content) {