code: function addWatch(watch, resolverFunction, shouldDebounce, pendingSetName) {
  				if (!watch) return
  
  				let responseFunction
  				if (shouldDebounce) {
  					responseFunction = (store) => {
  						store.commit(pendingSetName, true)
  						// resolver function is debounced here
  						return resolverFunction(store)
  					}
  				}
  				else responseFunction = resolverFunction
  
  				const watchType = typeof watch
  				if (watchType == 'function') {
  					watches.push([watch, responseFunction])
  				}
  				else {
  					if (watchType == 'string') watch = [watch]
  					else if (!(watch instanceof Array)) throw Error(`Watches must be a function, a string, or an array of strings: ${watch}`)
  
  					for (const methodName of watch) {
  						// TODO this will have huge problems with namespaced actions and mutations. right now this will only work with actions and mutations in the current module
  						if (actions.hasOwnProperty(methodName)) {
  							if (!subscribeActionNames[methodName]) subscribeActionNames[methodName] = []
  							subscribeActionNames[methodName].push(responseFunction)
  						}
  						else if (mutations.hasOwnProperty(methodName)) {
  							if (!subscribeMutationNames[methodName]) subscribeMutationNames[methodName] = []
  							subscribeMutationNames[methodName].push(responseFunction)
  						}
  						else throw Error(`A watch or watchClosely was provided that couldn't be mapped to a mutation or action: ${methodName}`)
  					}
  				}
  			}
docs: basically, the watch and the watchClosely have to have the same thing done with them, where the watch has debouncing and the watchClosely doesn't if the watch param is a function, it's added to the watches if it's a string or an array of strings, it's added to the response function manifests those response functions will take the store, and then dispatch an action function addWatch(watch, shouldDebounce) {