Executar função manualmente annyang - deve ser fácil mas não lembro

Bom dia a todos,

Estou quebrando a cabeça mas faz muito tempo que não mecho com códigos e javascript. Deve se algo fácil mas como faz muito tempo que não mecho ta dificil pra entender.

este script é de comando de voz ai ao invés de chamar um função pela voz queria chamar por comando manual, só que pegando já todos os comandos cadastrados na minha index:

 var commands = {

 'estou falando': comando,

}

ai queria chamar esses comandos também dessa forma:

execComando('estou falando');

Código js:

//! annyang
//! version : 2.5.0
//! author : Tal Ater @TalAter
//! license : MIT
//! https://www.TalAter.com/annyang/

(function (root, factory) {
 "use strict";
 if (typeof define === 'function' && define.amd) { // AMD + global
 define([], function () {
 return (root.annyang = factory(root));
 });
 } else if (typeof module === 'object' && module.exports) { // CommonJS
 module.exports = factory(root);
 } else { // Browser globals
 root.annyang = factory(root);
 }
}(typeof window !== 'undefined' ? window : this, function (root, undefined) {
 "use strict";

 /**
 * # Quick Tutorial, Intro and Demos
 *
 * The quickest way to get started is to visit the [annyang homepage]([https://www.talater.com/annyang/](https://www.talater.com/annyang/)).
 *
 * For a more in-depth look at annyang, read on.
 *
 * # API Reference
 */

 var annyang;

 // Get the SpeechRecognition object, while handling browser prefixes
 var SpeechRecognition = root.SpeechRecognition ||
 root.webkitSpeechRecognition ||
 root.mozSpeechRecognition ||
 root.msSpeechRecognition ||
 root.oSpeechRecognition;

 // Check browser support
 // This is done as early as possible, to make it as fast as possible for unsupported browsers
 if (!SpeechRecognition) {
 return null;
 }

 var commandsList = [];
 var recognition;
 var callbacks = { start: [], error: [], end: [], result: [], resultMatch: [], resultNoMatch: [], errorNetwork: [], errorPermissionBlocked: [], errorPermissionDenied: [] };
 var autoRestart;
 var lastStartedAt = 0;
 var autoRestartCount = 0;
 var debugState = false;
 var debugStyle = 'font-weight: bold; color: #00f;';
 var pauseListening = false;
 var isListening = false;

 // The command matching code is a modified version of Backbone.Router by Jeremy Ashkenas, under the MIT license.
 var optionalParam = /\s*\((.*?)\)\s*/g;
 var optionalRegex = /(\(\?:[^)]+\))\?/g;
 var namedParam = /(\(\?)?:\w+/g;
 var splatParam = /\*\w+/g;
 var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#]/g;
 var commandToRegExp = function(command) {
 command = command.replace(escapeRegExp, '\\$&')
 .replace(optionalParam, '(?:$1)?')
 .replace(namedParam, function(match, optional) {
 return optional ? match : '([^\\s]+)';
 })
 .replace(splatParam, '(.*?)')
 .replace(optionalRegex, '\\s*$1?\\s*');
 return new RegExp('^' + command + '$', 'i');
 };

 // This method receives an array of callbacks to iterate over, and invokes each of them
 var invokeCallbacks = function(callbacks) {
 var args = Array.prototype.slice.call(arguments, 1);
 callbacks.forEach(function(callback) {
 callback.callback.apply(callback.context, args);
 });
 };

 var isInitialized = function() {
 return recognition !== undefined;
 };

 // method for logging in developer console when debug mode is on
 var logMessage = function(text, extraParameters) {
 if (text.indexOf('%c') === -1 && !extraParameters) {
 console.log(text);
 } else {
 extraParameters = extraParameters || debugStyle;
 console.log(text, extraParameters);
 }
 };

 var initIfNeeded = function() {
 if (!isInitialized()) {
 annyang.init({}, false);
 }
 };

 var registerCommand = function(command, cb, phrase) {
 commandsList.push({ command: command, callback: cb, originalPhrase: phrase });
 if (debugState) {
 logMessage('Comando inicializado: %c'+phrase, debugStyle);
 }
 };

 var parseResults = function(results) {
 invokeCallbacks(callbacks.result, results);
 var commandText;
 // go over each of the 5 results and alternative results received (we've set maxAlternatives to 5 above)
 for (var i = 0; i<results.length; i++) {
 // the text recognized
 commandText = results[i].trim();
 if (debugState) {

 logMessage('Speech recognized: %c'+commandText, debugStyle);
 }

 // try and match recognized text to one of the commands on the list
 for (var j = 0, l = commandsList.length; j < l; j++) {
 var currentCommand = commandsList[j];
 var result = currentCommand.command.exec(commandText);
 if (result) {
 var parameters = result.slice(1);
 if (debugState) {
 logMessage('command matched: %c'+currentCommand.originalPhrase, debugStyle);
 if (parameters.length) {
 logMessage('with parameters', parameters);
 }
 }
 // execute the matched command
 currentCommand.callback.apply(this, parameters);
 invokeCallbacks(callbacks.resultMatch, commandText, currentCommand.originalPhrase, results);
 return;
 }
 }
 }
 invokeCallbacks(callbacks.resultNoMatch, results);
 };

 annyang = {

 /**
 * Initialize annyang with a list of commands to recognize.
 *
 * #### Examples:
 * 

`javascript
* var commands = {'hello :name': helloFunction};
* var commands2 = {'hi': helloFunction};
*
* // initialize annyang, overwriting any previously added commands
* annyang.init(commands, true);
* // adds an additional command without removing the previous commands
* annyang.init(commands2, false);
*

`
 * As of v1.1.0 it is no longer required to call init(). Just start() listening whenever you want, and addCommands() whenever, and as often as you like.
 *
 * @param {Object} commands - Commands that annyang should listen to
 * @param {boolean} [resetCommands=true] - Remove all commands before initializing?
 * @method init
 * @deprecated
 * @see [Commands Object](#commands-object)
 */
 init: function(commands, resetCommands) {

 // resetCommands defaults to true
 if (resetCommands === undefined) {
 resetCommands = true;
 } else {
 resetCommands = !!resetCommands;
 }

 // Abort previous instances of recognition already running
 if (recognition && recognition.abort) {
 recognition.abort();
 }

 // initiate SpeechRecognition
 recognition = new SpeechRecognition();

 // Set the max number of alternative transcripts to try and match with a command
 recognition.maxAlternatives = 5;

 // In HTTPS, turn off continuous mode for faster results.
 // In HTTP, turn on continuous mode for much slower results, but no repeating security notices
 recognition.continuous = root.location.protocol === 'http:';

 // Sets the language to the default 'en-US'. This can be changed with annyang.setLanguage()
 recognition.lang = 'pt-BR';

 recognition.onstart = function() {
 isListening = true;
 invokeCallbacks(callbacks.start);
 };

 recognition.onerror = function(event) {
 invokeCallbacks(callbacks.error, event);
 switch (event.error) {
 case 'network':
 invokeCallbacks(callbacks.errorNetwork, event);
 break;
 case 'not-allowed':
 case 'service-not-allowed':
 // if permission to use the mic is denied, turn off auto-restart
 autoRestart = false;
 // determine if permission was denied by user or automatically.
 if (new Date().getTime()-lastStartedAt < 200) {
 invokeCallbacks(callbacks.errorPermissionBlocked, event);
 } else {
 invokeCallbacks(callbacks.errorPermissionDenied, event);
 }
 break;
 }
 };

 recognition.onend = function() {
 isListening = false;
 invokeCallbacks(callbacks.end);
 // annyang will auto restart if it is closed automatically and not by user action.
 if (autoRestart) {
 // play nicely with the browser, and never restart annyang automatically more than once per second
 var timeSinceLastStart = new Date().getTime()-lastStartedAt;
 autoRestartCount += 1;
 if (autoRestartCount % 10 === 0) {
 if (debugState) {
 logMessage('Speech Recognition is repeatedly stopping and starting. See [http://is.gd/annyang_restarts](http://is.gd/annyang_restarts) for tips.');
 }
 }
 if (timeSinceLastStart < 1000) {
 setTimeout(function() {
 annyang.start({ paused: pauseListening });
 }, 1000-timeSinceLastStart);
 } else {
 annyang.start({ paused: pauseListening });
 }
 }
 };

 recognition.onresult = function(event) {
 if(pauseListening) {
 if (debugState) {
 logMessage('Speech heard, but annyang is paused');
 }
 return false;
 }

 // Map the results to an array
 var SpeechRecognitionResult = event.results[event.resultIndex];
 var results = [];
 for (var k = 0; k<SpeechRecognitionResult.length; k++) {
 results[k] = SpeechRecognitionResult[k].transcript;
 }

 parseResults(results);
 };

 // build commands list
 if (resetCommands) {
 commandsList = [];
 }
 if (commands.length) {
 this.addCommands(commands);
 }
 },

 /**
 * Start listening.
 * It's a good idea to call this after adding some commands first, but not mandatory.
 *
 * Receives an optional options object which supports the following options:
 *
 * - `autoRestart` (boolean, default: true) Should annyang restart itself if it is closed indirectly, because of silence or window conflicts?
 * - `continuous` (boolean) Allow forcing continuous mode on or off. Annyang is pretty smart about this, so only set this if you know what you're doing.
 * - `paused` (boolean, default: true) Start annyang in paused mode.
 *
 * #### Examples:
 * 

`javascript
* // Start listening, don't restart automatically
* annyang.start({ autoRestart: false });
* // Start listening, don't restart automatically, stop recognition after first phrase recognized
* annyang.start({ autoRestart: false, continuous: false });
*

`
 * @param {Object} [options] - Optional options.
 * @method start
 */
 start: function(options) {
 initIfNeeded();
 options = options || {};
 if (options.paused !== undefined) {
 pauseListening = !!options.paused;
 } else {
 pauseListening = false;
 }
 if (options.autoRestart !== undefined) {
 autoRestart = !!options.autoRestart;
 } else {
 autoRestart = true;
 }
 if (options.continuous !== undefined) {
 recognition.continuous = !!options.continuous;
 }

 lastStartedAt = new Date().getTime();
 try {
 recognition.start();
 } catch(e) {
 if (debugState) {
 logMessage(e.message);
 }
 }
 },

 /**
 * Stop listening, and turn off mic.
 *
 * Alternatively, to only temporarily pause annyang responding to commands without stopping the SpeechRecognition engine or closing the mic, use pause() instead.
 * @see [pause()](#pause)
 *
 * @method abort
 */
 abort: function() {
 autoRestart = false;
 autoRestartCount = 0;
 if (isInitialized()) {
 recognition.abort();
 }
 },

 /**
 * Pause listening. annyang will stop responding to commands (until the resume or start methods are called), without turning off the browser's SpeechRecognition engine or the mic.
 *
 * Alternatively, to stop the SpeechRecognition engine and close the mic, use abort() instead.
 * @see [abort()](#abort)
 *
 * @method pause
 */
 pause: function() {
 pauseListening = true;
 },

 /**
 * Resumes listening and restores command callback execution when a result matches.
 * If SpeechRecognition was aborted (stopped), start it.
 *
 * @method resume
 */
 resume: function() {
 annyang.start();
 },

 /**
 * Turn on output of debug messages to the console. Ugly, but super-handy!
 *
 * @param {boolean} [newState=true] - Turn on/off debug messages
 * @method debug
 */
 debug: function(newState) {
 if (arguments.length > 0) {
 debugState = !!newState;
 } else {
 debugState = true;
 }
 },

 /**
 * Set the language the user will speak in. If this method is not called, defaults to 'en-US'.
 *
 * @param {String} language - The language (locale)
 * @method setLanguage
 * @see [Languages]([https://github.com/TalAter/annyang/blob/master/docs/FAQ.md#what-languages-are-supported](https://github.com/TalAter/annyang/blob/master/docs/FAQ.md#what-languages-are-supported))
 */
 setLanguage: function(language) {
 initIfNeeded();
 recognition.lang = language;
 },

 /**
 * Add commands that annyang will respond to. Similar in syntax to init(), but doesn't remove existing commands.
 *
 * #### Examples:
 * 

`javascript
* var commands = {'hello :name': helloFunction, 'howdy': helloFunction};
* var commands2 = {'hi': helloFunction};
*
* annyang.addCommands(commands);
* annyang.addCommands(commands2);
* // annyang will now listen to all three commands
*

`
 *
 * @param {Object} commands - Commands that annyang should listen to
 * @method addCommands
 * @see [Commands Object](#commands-object)
 */
 addCommands: function(commands) {
 var cb;

 initIfNeeded();

 for (var phrase in commands) {
 if (commands.hasOwnProperty(phrase)) {
 cb = root[commands[phrase]] || commands[phrase];
 if (typeof cb === 'function') {
 // convert command to regex then register the command
 registerCommand(commandToRegExp(phrase), cb, phrase);
 } else if (typeof cb === 'object' && cb.regexp instanceof RegExp) {
 // register the command
 registerCommand(new RegExp(cb.regexp.source, 'i'), cb.callback, phrase);
 } else {
 if (debugState) {
 logMessage('Can not register command: %c'+phrase, debugStyle);
 }
 continue;
 }
 }
 }
 },

 /**
 * Remove existing commands. Called with a single phrase, array of phrases, or methodically. Pass no params to remove all commands.
 *
 * #### Examples:
 * 

`javascript
* var commands = {'hello': helloFunction, 'howdy': helloFunction, 'hi': helloFunction};
*
* // Remove all existing commands
* annyang.removeCommands();
*
* // Add some commands
* annyang.addCommands(commands);
*
* // Don't respond to hello
* annyang.removeCommands('hello');
*
* // Don't respond to howdy or hi
* annyang.removeCommands(['howdy', 'hi']);
*

`
 * @param {String|Array|Undefined} [commandsToRemove] - Commands to remove
 * @method removeCommands
 */
 removeCommands: function(commandsToRemove) {
 if (commandsToRemove === undefined) {
 commandsList = [];
 return;
 }
 commandsToRemove = Array.isArray(commandsToRemove) ? commandsToRemove : [commandsToRemove];
 commandsList = commandsList.filter(function(command) {
 for (var i = 0; i<commandsToRemove.length; i++) {
 if (commandsToRemove[i] === command.originalPhrase) {
 return false;
 }
 }
 return true;
 });
 },

 /**
 * Add a callback function to be called in case one of the following events happens:
 *
 * * `start` - Fired as soon as the browser's Speech Recognition engine starts listening
 * * `error` - Fired when the browser's Speech Recogntion engine returns an error, this generic error callback will be followed by more accurate error callbacks (both will fire if both are defined)
 * Callback function will be called with the error event as the first argument
 * * `errorNetwork` - Fired when Speech Recognition fails because of a network error
 * Callback function will be called with the error event as the first argument
 * * `errorPermissionBlocked` - Fired when the browser blocks the permission request to use Speech Recognition.
 * Callback function will be called with the error event as the first argument
 * * `errorPermissionDenied` - Fired when the user blocks the permission request to use Speech Recognition.
 * Callback function will be called with the error event as the first argument
 * * `end` - Fired when the browser's Speech Recognition engine stops
 * * `result` - Fired as soon as some speech was identified. This generic callback will be followed by either the `resultMatch` or `resultNoMatch` callbacks.
 * Callback functions for to this event will be called with an array of possible phrases the user said as the first argument
 * * `resultMatch` - Fired when annyang was able to match between what the user said and a registered command
 * Callback functions for this event will be called with three arguments in the following order:
 * * The phrase the user said that matched a command
 * * The command that was matched
 * * An array of possible alternative phrases the user might have said
 * * `resultNoMatch` - Fired when what the user said didn't match any of the registered commands.
 * Callback functions for this event will be called with an array of possible phrases the user might've said as the first argument
 *
 * #### Examples:
 * 

`javascript
* annyang.addCallback('error', function() {
* $('.myErrorText').text('There was an error!');
* });
*
* annyang.addCallback('resultMatch', function(userSaid, commandText, phrases) {
* console.log(userSaid); // sample output: 'hello'
* console.log(commandText); // sample output: 'hello (there)'
* console.log(phrases); // sample output: ['hello', 'halo', 'yellow', 'polo', 'hello kitty']
* });
*
* // pass local context to a global function called notConnected
* annyang.addCallback('errorNetwork', notConnected, this);
*

`
 * @param {String} type - Name of event that will trigger this callback
 * @param {Function} callback - The function to call when event is triggered
 * @param {Object} [context] - Optional context for the callback function
 * @method addCallback
 */
 addCallback: function(type, callback, context) {
 if (callbacks[type] === undefined) {
 return;
 }
 var cb = root[callback] || callback;
 if (typeof cb !== 'function') {
 return;
 }
 callbacks[type].push({callback: cb, context: context || this});
 },

 /**
 * Remove callbacks from events.
 *
 * - Pass an event name and a callback command to remove that callback command from that event type.
 * - Pass just an event name to remove all callback commands from that event type.
 * - Pass undefined as event name and a callback command to remove that callback command from all event types.
 * - Pass no params to remove all callback commands from all event types.
 *
 * #### Examples:
 * 

`javascript
* annyang.addCallback('start', myFunction1);
* annyang.addCallback('start', myFunction2);
* annyang.addCallback('end', myFunction1);
* annyang.addCallback('end', myFunction2);
*
* // Remove all callbacks from all events:
* annyang.removeCallback();
*
* // Remove all callbacks attached to end event:
* annyang.removeCallback('end');
*
* // Remove myFunction2 from being called on start:
* annyang.removeCallback('start', myFunction2);
*
* // Remove myFunction1 from being called on all events:
* annyang.removeCallback(undefined, myFunction1);
*

`
 *
 * @param type Name of event type to remove callback from
 * @param callback The callback function to remove
 * @returns undefined
 * @method removeCallback
 */
 removeCallback: function(type, callback) {
 var compareWithCallbackParameter = function(cb) {
 return cb.callback !== callback;
 };
 // Go over each callback type in callbacks store object
 for (var callbackType in callbacks) {
 if (callbacks.hasOwnProperty(callbackType)) {
 // if this is the type user asked to delete, or he asked to delete all, go ahead.
 if (type === undefined || type === callbackType) {
 // If user asked to delete all callbacks in this type or all types
 if (callback === undefined) {
 callbacks[callbackType] = [];
 } else {
 // Remove all matching callbacks
 callbacks[callbackType] = callbacks[callbackType].filter(compareWithCallbackParameter);
 }
 }
 }
 }
 },

 /**
 * Returns true if speech recognition is currently on.
 * Returns false if speech recognition is off or annyang is paused.
 *
 * @return boolean true = SpeechRecognition is on and annyang is listening
 * @method isListening
 */
 isListening: function() {
 return isListening && !pauseListening;
 },

 /**
 * Returns the instance of the browser's SpeechRecognition object used by annyang.
 * Useful in case you want direct access to the browser's Speech Recognition engine.
 *
 * @returns SpeechRecognition The browser's Speech Recognizer currently used by annyang
 * @method getSpeechRecognizer
 */
 getSpeechRecognizer: function() {
 return recognition;
 },

 /**
 * Simulate speech being recognized. This will trigger the same events and behavior as when the Speech Recognition
 * detects speech.
 *
 * Can accept either a string containing a single sentence, or an array containing multiple sentences to be checked
 * in order until one of them matches a command (similar to the way Speech Recognition Alternatives are parsed)
 *
 * #### Examples:
 * 

`javascript
* annyang.trigger('Time for some thrilling heroics');
* annyang.trigger(
* ['Time for some thrilling heroics', 'Time for some thrilling aerobics']
* );
*

`
 *
 * @param string|array sentences A sentence as a string or an array of strings of possible sentences
 * @returns undefined
 * @method trigger
 */
 trigger: function(sentences) {
 if(!annyang.isListening()) {
 if (debugState) {
 if (!isListening) {
 logMessage('Cannot trigger while annyang is aborted');
 } else {
 logMessage('Speech heard, but annyang is paused');
 }
 }
 return;
 }

 if (!Array.isArray(sentences)) {
 sentences = [sentences];
 }

 parseResults(sentences);
 }
 };

 return annyang;

}));

/**
* # Good to Know
*
* ## Commands Object
*
* Both the [init()]() and addCommands() methods receive a commands object.
*
* annyang understands commands with named variables, splats, and optional words.
*
Use named variables for one word arguments in your command.
Use splats to capture multi-word text at the end of your command (greedy).
Use optional words or phrases to define a part of the command as optional.
*
* #### Examples:
*

`html

* <script>
* var commands = {
// annyang will capture anything after a splat () and pass it to the function.
* // e.g. saying "Show me Batman and Robin" will call showFlickr('Batman and Robin');
'show me tag': showFlickr,
*
* // A named variable is a one word variable, that can fit anywhere in your command.
* // e.g. saying "calculate October stats" will call calculateStats('October');
* 'calculate :month stats': calculateStats,
*
* // By defining a part of the following command as optional, annyang will respond
* // to both: "say hello to my little friend" as well as "say hello friend"
* 'say hello (to my little) friend': greeting
* };
*
* var showFlickr = function(tag) {
* var url = 'http://api.flickr.com/services/rest/?tags='+tag;
* $.getJSON(url);
* }
*
* var calculateStats = function(month) {
* $('#stats').text('Statistics for '+month);
* }
*
* var greeting = function() {
* $('#greeting').text('Hello!');
* }
* </script>
*

`
 *
 * ### Using Regular Expressions in commands
 * For advanced commands, you can pass a regular expression object, instead of
 * a simple string command.
 *
 * This is done by passing an object containing two properties: `regexp`, and
 * `callback` instead of the function.
 *
 * #### Examples:
 * 

`javascript
* var calculateFunction = function(month) { console.log(month); }
* var commands = {
* // This example will accept any word as the "month"
* 'calculate :month stats': calculateFunction,
* // This example will only accept months which are at the start of a quarter
* 'calculate :quarter stats': {'regexp': /^calculate (January|April|July|October) stats$/, 'callback': calculateFunction}
* }

`
*
*/