rita 3.0.22 → 3.0.25

package/dist/rita.cjs

@@ -845,32 +845,32 @@ var Tokenizer = class {
    * Returns an array containing all unique alphabetical words (tokens) in the text.
    * Punctuation and case are ignored unless specified otherwise.
    * @param {string} text - The text from which to extract the tokens
-   * @param {object} [opts] - The options
-   * @param {boolean} opts.caseSensitive=false - Whether to pay attention to case
-   * @param {boolean} opts.ignoreStopWords=false - Whether to ignore words like 'the', 'and', 'a', 'of', etc, as specified in RiTa.STOP_WORDS
-   * @param {boolean} opts.splitContractions=false - Whether to convert contractions (e.g., "I'd" or "she'll") into multiple individual tokens
-   * @param {boolean} opts.includePunct=false - Whether to include punctuation in the results
-   * @param {boolean} opts.sort=false - Whether to sort the tokens before returning them
+   * @param {object} [options] - The options
+   * @param {boolean} [options.caseSensitive=false] - Whether to pay attention to case
+   * @param {boolean} [options.ignoreStopWords=false] - Whether to ignore words like 'the', 'and', 'a', 'of', etc, as specified in RiTa.STOP_WORDS
+   * @param {boolean} [options.splitContractions=false] - Whether to convert contractions (e.g., "I'd" or "she'll") into multiple individual tokens
+   * @param {boolean} [options.includePunct=false] - Whether to include punctuation in the results
+   * @param {boolean} [options.sort=false] - Whether to sort the tokens before returning them
    * @returns {string[]} Array of tokens
    */
-  tokens(text, opts = {
+  tokens(text, options = {
     caseSensitive: false,
     ignoreStopWords: false,
     splitContractions: false,
     includePunct: false,
     sort: false
   }) {
-    let words = this.tokenize(text, opts), map = {};
+    let words = this.tokenize(text, options), map = {};
     words.forEach((w) => {
-      if (!opts.caseSensitive)
+      if (!options.caseSensitive)
         w = w.toLowerCase();
-      if (opts.includePunct || ALPHA_RE.test(w))
+      if (options.includePunct || ALPHA_RE.test(w))
         map[w] = 1;
     });
     let tokens = Object.keys(map);
-    if (opts.ignoreStopWords)
+    if (options.ignoreStopWords)
       tokens = tokens.filter((t) => !this.RiTa.isStopWord(t));
-    return opts.sort ? tokens.sort() : tokens;
+    return options.sort ? tokens.sort() : tokens;
   }
   tokenize(input, opts = {
     // regex: null,
@@ -41591,8 +41591,7 @@ var Analyzer = class {
     return features;
   }
   computePhones(word, opts) {
-    if (!this.lts)
-      this.lts = new rita_lts_default(this.RiTa);
+    this.lts = this.lts || new rita_lts_default(this.RiTa);
     return this.lts.buildPhones(word, opts);
   }
   phonesToStress(phones) {
@@ -41609,8 +41608,7 @@ var Analyzer = class {
     return stress;
   }
   analyzeWord(word, opts = {}) {
-    let RiTa2 = this.RiTa;
-    let result = RiTa2.CACHING && this.cache[word];
+    let result = this.RiTa.CACHING && this.cache[word];
     if (typeof result === "undefined") {
       let slash = "/", delim = "-";
       let lex = this.RiTa.lexicon;
@@ -41639,7 +41637,7 @@ var Analyzer = class {
       }
       result = { phones, stresses, syllables };
       Object.keys(result).forEach((k) => result[k] = result[k].trim());
-      if (RiTa2.CACHING)
+      if (this.RiTa.CACHING)
         this.cache[word] = result;
     }
     return result;
@@ -41926,15 +41924,29 @@ var randgen_default = SeededRandom;
 var _json = require('@ungap/structured-clone/json');
 var _RiMarkov = class _RiMarkov {
   // RiTa
-  constructor(n, opts = {}) {
+  /**
+   * Creates a new RiMarkov object with functions for text-generation and other probabilistic functions, 
+   * via Markov chains (or n-grams) with options to process words or tokens split by arbitrary regular expressions.
+   * @param {number} [n] - the n-gram size (an integer >= 2)
+   * @param {object} [options={}] - options for the model
+   * @param {string|string[]} [options.text] - a text string, or array of sentences, to add to the model (same as via model.addText()
+   * @param {boolean} [options.trace] - output trace info to the console
+   * @param {number} [options.maxLengthMatch] - # of words allowed in result to match a sequence in the input, default=∞
+   * @param {number} [options.maxAttempts=999] - max attempts before to complete one ore more generations before erroring, default=999
+   * @param {object} [options.tokenize] - custom tokenize() function, defaults to RiTa.tokenize()
+   * @param {function} [options.untokenize] - custom untokenize() function, defaults to RiTa.untokenize()
+   * @param {boolean} [options.disableInputChecks=false] - if true, allow result to be present in the input, default
+   * @memberof RiMarkov
+   */
+  constructor(n, options = {}) {
     this.n = n;
     this.root = new Node(null, "ROOT");
-    this.trace = opts.trace;
-    this.mlm = opts.maxLengthMatch;
-    this.maxAttempts = opts.maxAttempts || 999;
-    this.tokenize = opts.tokenize || _RiMarkov.parent.tokenize;
-    this.untokenize = opts.untokenize || _RiMarkov.parent.untokenize;
-    this.disableInputChecks = opts.disableInputChecks;
+    this.trace = options.trace;
+    this.mlm = options.maxLengthMatch;
+    this.maxAttempts = options.maxAttempts || 999;
+    this.tokenize = options.tokenize || _RiMarkov.parent.tokenize;
+    this.untokenize = options.untokenize || _RiMarkov.parent.untokenize;
+    this.disableInputChecks = options.disableInputChecks;
     this.sentenceStarts = [];
     this.sentenceEnds = /* @__PURE__ */ new Set();
     if (this.n < 2)
@@ -41943,12 +41955,19 @@ var _RiMarkov = class _RiMarkov {
       throw Error("maxLengthMatch must be >= N");
     if (!this.disableInputChecks || this.mlm)
       this.input = [];
-    if (opts.text)
-      this.addText(opts.text);
+    if (options.text)
+      this.addText(options.text);
   }
+  /**
+   * Loads text into the model. If a raw string is provided, it will be split into sentences 
+   * via RiTa.sentences(). If an array is provided, each string will be treated as an individual sentence.
+   * @param {string|string[]} text - a text string, or array of sentences, to add to the model
+   * @param {number} [multiplier=1] - number of times to add the text to the model
+   * @return {RiMarkov} - the RiMarkov instance
+   */
   addText(text, multiplier = 1) {
     let sents = Array.isArray(text) ? text : _RiMarkov.parent.sentences(text);
-    let wrap, allWords = [];
+    let allWords = [];
     for (let k = 0; k < multiplier; k++) {
       for (let i = 0; i < sents.length; i++) {
         let words = this.tokenize(sents[i]);
@@ -41963,19 +41982,47 @@ var _RiMarkov = class _RiMarkov {
         this.input.push(allWords[i]);
       }
     }
+    return this;
   }
-  generate(count, opts = {}) {
+  /** 
+   * @overload
+   * @param {number} count
+   * @param {object} [options={}] - options for the generation
+   * @param {number} [options.minLength=5] - minimum length of each sentence
+   * @param {number} [options.maxLength=35] - maximum length of each sentence
+   * @param {number} [options.temperature=1] - temperature acts as a knob to adjust the probability that input elements will be selected for the output. At higher values, infrequent words are more likely to be chosen, while at lower values the most frequent inputs are more likely to be output. If no value is provided, then tokens are chosen according to their relative frequency in the input.
+   * @param {boolean} [options.allowDuplicates=false] - if true, allow duplicate sentences in the output
+   * @param {string|string[]} [options.seed] - a seed string or array of tokens to start the generation
+   * @returns {string[]}
+   *
+   * @overload
+   * @param {object} [options={}] - options for the generation
+   * @param {number} [options.minLength=5] - minimum length of each sentence
+   * @param {number} [options.maxLength=35] - maximum length of each sentence
+   * @param {number} [options.temperature=1] - temperature acts as a knob to adjust the probability that input elements will be selected for the output. At higher values, infrequent words are more likely to be chosen, while at lower values the most frequent inputs are more likely to be output. If no value is provided, then tokens are chosen according to their relative frequency in the input.
+   * @param {boolean} [options.allowDuplicates=false] - if true, allow duplicate sentences in the output
+   * @param {string|string[]} [options.seed] - a seed string or array of tokens to start the generation
+   * @returns {string}
+   */
+  generate(count, options = {}) {
+    let returnsArray = false;
+    if (typeof count === "number") {
+      if (count === 1) {
+        throw Error("For one result, use generate() with no 'count' argument");
+      }
+      returnsArray = true;
+    }
     if (arguments.length === 1 && typeof count === "object") {
-      opts = count;
+      options = count;
       count = 1;
     }
     const num = count || 1;
-    const minLength = opts.minLength || 5;
-    const maxLength = opts.maxLength || 35;
-    if (typeof opts.temperature !== "undefined" && opts.temperature <= 0) {
+    const minLength = options.minLength || 5;
+    const maxLength = options.maxLength || 35;
+    if (typeof options.temperature !== "undefined" && options.temperature <= 0) {
       throw Error("Temperature option must be greater than 0");
     }
-    let tries = 0, tokens = [], usedStarts = [];
+    let tries = 0, tokens = [];
     let minIdx = 0, sentenceIdxs = [];
     let markedNodes = [];
     const unmarkNodes = () => {
@@ -42014,7 +42061,7 @@ var _RiMarkov = class _RiMarkov {
         return false;
       }
       let flatSent = this.untokenize(sentence);
-      if (!opts.allowDuplicates && isSubArray(sentence, tokens.slice(0, sentIdx))) {
+      if (!options.allowDuplicates && isSubArray(sentence, tokens.slice(0, sentIdx))) {
         fail("duplicate (pop: " + next.token + ")");
         return false;
       }
@@ -42101,7 +42148,7 @@ var _RiMarkov = class _RiMarkov {
       return len ? sentenceIdxs[len - 1] : 0;
     };
     const selectStart = () => {
-      let seed = opts.seed;
+      let seed = options.seed;
       if (seed && seed.length) {
         if (typeof seed === "string")
           seed = this.tokenize(seed);
@@ -42131,7 +42178,7 @@ var _RiMarkov = class _RiMarkov {
         continue;
       }
       let parent = this._pathTo(tokens);
-      let next = this._selectNext(parent, opts.temperature, tokens, notMarked);
+      let next = this._selectNext(parent, options.temperature, tokens, notMarked);
       if (!next) {
         fail("mlm-fail(" + this.mlm + ")", this._flatten(tokens), true);
         continue;
@@ -42150,13 +42197,22 @@ var _RiMarkov = class _RiMarkov {
     }
     unmarkNodes();
     let str = this.untokenize(tokens.map((t) => t.token)).trim();
-    return num > 1 ? this._splitEnds(str) : str;
+    return returnsArray ? this._splitEnds(str) : str;
   }
+  /**
+   * Converts the model to a JSON-formatted string for storage or serialization
+   * @return {string} - the JSON string
+   */
   toJSON() {
     let data = Object.keys(this).reduce((acc, k) => Object.assign(acc, { [k]: this[k] }), {});
     data.sentenceEnds = [...data.sentenceEnds];
     return _json.stringify.call(void 0, data);
   }
+  /**
+   * Creates a new model from one previously saved as JSON
+   * @param {string} json - the JSON string to load
+   * @return {RiMarkov} - the RiMarkov instance
+   */
   static fromJSON(json) {
     let parsed = _json.parse.call(void 0, json);
     let rm = Object.assign(new _RiMarkov(), parsed);
@@ -42167,7 +42223,13 @@ var _RiMarkov = class _RiMarkov {
     populate(rm.root = new Node(null, "ROOT"), jsonRoot);
     return rm;
   }
-  /* returns array of possible tokens after pre and (optionally) before post */
+  /**
+   * Returns array of possible tokens after pre and (optionally) before post. If only one array parameter is provided, this function returns all possible next words, ordered by probability, for the given array. 
+   * If two arrays are provided, it returns an unordered list of possible words w that complete the n-gram consisting of: pre[0]...pre[k], w, post[k+1]...post[n].
+   * @param {string[]} pre - the list of tokens preceding the completion
+   * @param {string[]} [post] - the (optional) list of tokens following the completion
+   * @return {string[]} - an unordered list of possible next tokens 
+   */
   completions(pre, post) {
     let tn, result = [];
     if (post) {
@@ -42191,8 +42253,14 @@ var _RiMarkov = class _RiMarkov {
     }
     return result;
   }
-  /* return an object mapping {string -> prob} */
-  probabilities(path, temp) {
+  /**
+   * Returns the full set of possible next tokens as a object, mapping tokens to probabilities,
+   *  given an array of tokens representing the path down the tree (with length less than `n`).
+   * @param {string|string[]} path - the path to the node as a string or an array of tokens
+   * @param {number} [temperature=1] - temperature acts as a knob to adjust the probability that input elements will be selected for the output. At higher values, infrequent words are more likely to be chosen, while at lower values the most frequent inputs are more likely to be output. If no value is provided, then tokens are chosen according to their relative frequency in the input.
+   * @return {object} - a map of tokens to probabilities
+   */
+  probabilities(path, temperature) {
     if (!Array.isArray(path))
       path = this.tokenize(path);
     const probs = {};
@@ -42200,11 +42268,17 @@ var _RiMarkov = class _RiMarkov {
     if (parent) {
       const children = parent.childNodes();
       const weights = children.map((n) => n.count);
-      const pdist = _RiMarkov.parent.randomizer.ndist(weights, temp);
+      const pdist = _RiMarkov.parent.randomizer.ndist(weights, temperature);
       children.forEach((c, i) => probs[c.token] = pdist[i]);
     }
     return probs;
   }
+  /**
+   * Returns either the raw (unigram) probability for a single token in the model (0 if it does not exist), OR
+   * the probability of a sequence of K tokens where K is less than `n` (0 if the sequence does not exist).
+   * @param {string|string[]} data - the token or array of tokens to check
+   * @return {number} - the probability of the token or sequence
+   */
   probability(data) {
     let p = 0;
     if (data && data.length) {
@@ -42214,10 +42288,20 @@ var _RiMarkov = class _RiMarkov {
     }
     return p;
   }
+  /**
+   * Returns a string representation of the model or a subtree of the model, optionally ordered by probability.
+   * @param {object} root - the root node of the subtree to print
+   * @param {boolean} sort - if true, sort the nodes by probability
+   * @return {string} - the string representation of the model 
+   */
   toString(root, sort) {
     root = root || this.root;
     return root.asTree(sort).replace(/{}/g, "");
   }
+  /**
+   * Returns the number of tokens currently in the model.
+   * @return {number} - number of tokens
+   */
   size() {
     return this.root.childCount(true);
   }
@@ -42491,16 +42575,15 @@ var markov_default = RiMarkov;
 
 // src/rita.js
 var _riscript = require('riscript');
-var { Grammar: RiGrammar } = _riscript.RiScript;
 var RiTa = class _RiTa {
   /**
    * Create a RiTa grammar instance
-   * @param {object} rules - the rules of the grammar
-   * @param {object} context - the context of the grammar
-   * @returns {object} - a new RiGrammar instance // TODO: fix return type -> RiGrammar
+   * @param {object} [rules] - the rules of the grammar
+   * @param {object} [context] - the context of the grammar
+   * @returns {RiGrammar} - a new RiGrammar instance
    */
   static grammar(rules, context) {
-    return new RiGrammar(rules, context);
+    return new (0, _riscript.RiGrammar)(rules, context);
   }
   /**
    * Add a transform function to the RiScript parser
@@ -42535,9 +42618,9 @@ var RiTa = class _RiTa {
   /**
    * Evaluates the input script via the RiScript parser
    * @param {string} script - the script to evaluate
-   * @param {object} context - the context to evaluate the script ing
+   * @param {object} [context] - the context to evaluate the script ing
    * @param {object} [options] - options for the evaluation
-   * @param {boolean} options.trace - whether to trace the evaluation
+   * @param {boolean} [options.trace] - whether to trace the evaluation
    * @returns {string} the result of the evaluation
    */
   static evaluate(script, context, options) {
@@ -42547,6 +42630,13 @@ var RiTa = class _RiTa {
    * Creates a new RiMarkov object
    * @param {number} n - an int representing the n-factor of the markov chain 
    * @param {object} [options] - options for the markov chain
+   * @param {string|string[]} [options.text] - a text string, or array of sentences, to add to the model (same as via model.addText()
+   * @param {number} [options.maxLengthMatch] - # of words allowed in result to match a sequence in the input, default=∞
+   * @param {number} [options.maxAttempts=999] - max attempts before to complete one ore more generations before erroring, default=999
+   * @param {function} [options.tokenize] - custom tokenizer with tokenize() method, defaults to RiTa.tokenize()
+   * @param {function} [options.untokenize] - custom untokenizer with untokenize() method, defaults to RiTa.untokenize()
+   * @param {boolean} [options.disableInputChecks=false] - if true, allow result to be present in the input, default
+   * @param {boolean} [options.trace] - output trace info to the console
    * @returns {RiMarkov}
    */
   static markov(n, options) {
@@ -42557,9 +42647,9 @@ var RiTa = class _RiTa {
    * @overload
    * @param {string} keyword 
    * @param {object} [options]  
-   * @param {number} options.numWords - the number of words to include in the context
-   * @param {string} options.text - the text as input for the KWIC model
-   * @param {string[]} options.words - the array of words to be used as input for the KWIC model
+   * @param {number} [options.numWords] - the number of words to include in the context
+   * @param {string} [options.text] - the text as input for the KWIC model
+   * @param {string[]} [options.words] - the array of words to be used as input for the KWIC model
    * @returns {string[]} all the occurrences of the keyword in the model, each with no more 
    * than 'numWords' words of context on either side
    * @overload
@@ -42575,11 +42665,11 @@ var RiTa = class _RiTa {
    * Creates a concordance, a list of words with their frequency of occurence, from the given text and options.
    * @param {string} text - the text from which to create the concordance
    * @param {object} [options] - options for the concordance
-   * @param {boolean} options.ignoreCase=false - whether to ignore case when creating the concordance
-   * @param {boolean} options.ignoreStopWords=false - whether to ignore stop words like
+   * @param {boolean} [options.ignoreCase=false] - whether to ignore case when creating the concordance
+   * @param {boolean} [options.ignoreStopWords=false] - whether to ignore stop words like
    *  'the', 'and', 'a', 'of', etc, as specified in RiTa.STOP_WORDS
-   * @param {boolean} options.ignorePunctuation=false - whether to ignore punctuation when creating the concordance
-   * @param {string[]} options.wordsToIgnore=null - words to ignore when creating the concordance (alternate stop-words)
+   * @param {boolean} [options.ignorePunctuation=false] - whether to ignore punctuation when creating the concordance
+   * @param {string[]} [options.wordsToIgnore=null] - words to ignore when creating the concordance (alternate stop-words)
    * @returns {object} the concordance, an object with words as keys and frequencies as values
    */
   static concordance(text, options) {
@@ -42641,14 +42731,14 @@ var RiTa = class _RiTa {
    * (length, syllable-count, phonemic pattern, stress pattern, part-of-speech, etc.).
    * @param {(string|RegExp)} [pattern] - the pattern to match
    * @param {object} [options] 
-   * @param {number} options.minLength=4 - the minimum length of the word
-   * @param {number} options.maxLength=-1 - the maximum length of the word
-   * @param {number} options.numSyllables=null - the number of syllables in the word 
-   * @param {number} options.limit=10 - the maximum number of results to retur   
-   * @param {string} options.pos=null - the part-of-speech of the word to return,
+   * @param {number} [options.minLength=4] - the minimum length of the word
+   * @param {number} [options.maxLength=-1] - the maximum length of the word
+   * @param {number} [options.numSyllables=null] - the number of syllables in the word 
+   * @param {number} [options.limit=10] - the maximum number of results to retur   
+   * @param {string} [options.pos=null] - the part-of-speech of the word to return,
    *  either from the Penn tag set or the simplified tag set [a, r, v, n]
-   * @param {RegExp} options.pattern=null - the spelling or phonemic pattern to match
-   * @param {string} options.type=null - the type of regex or string pattern to match, 
+   * @param {RegExp} [options.pattern=null] - the spelling or phonemic pattern to match
+   * @param {string} [options.type=null] - the type of regex or string pattern to match, 
    * options are 'stresses' or 'phones' or 'letters' (the default)
    * @returns {string} a random word matching the criteria in the options object 
    */
@@ -42660,12 +42750,12 @@ var RiTa = class _RiTa {
    * their final stressed vowel and all following phonemes are identical.
    * @param {string} word 
    * @param {object} [options]
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
    * @returns {Promise<string[]>} an array of rhymes that match criteria in the options object 
    */
@@ -42687,12 +42777,12 @@ var RiTa = class _RiTa {
    *  of each word in the lexicon via a minimum-edit-distance metric.
    * @param {string} word 
    * @param {object} [options]
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
    * @returns {Promise<string[]>} an array of alliterations matching criteria in the options object 
    */
@@ -42703,7 +42793,7 @@ var RiTa = class _RiTa {
    * Returns true if the word is in the lexicon, else false
    * @param {string} word - the word to check
    * @param {object} [options] - options for the search
-   * @param {boolean} options.noDerivations=false - whether to ignore derivations and only search for raw words
+   * @param {boolean} [options.noDerivations=false] - whether to ignore derivations and only search for raw words
    * @returns {boolean} true if the word is in the lexicon, else false
    */
   static hasWord(word, options) {
@@ -42713,7 +42803,7 @@ var RiTa = class _RiTa {
    * Returns true if the word is an abbreviation, else false
    * @param {string} input - the word to check
    * @param {object} [options] - options for the search
-   * @param {boolean} options.caseSensitive=false - whether to ignore case when checking for abbreviations
+   * @param {boolean} [options.caseSensitive=false] - whether to ignore case when checking for abbreviations
    * @returns {boolean} true if the word is an abbreviation, else false
    */
   static isAbbrev(input, options) {
@@ -42739,12 +42829,12 @@ var RiTa = class _RiTa {
    * to each word in the lexicon, returning the set of closest matches that also match the criteria in the options object.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return  (pass -1 to return all matches) 
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set or the simplified tag set [a, r, v, n]
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return  (pass -1 to return all matches) 
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set or the simplified tag set [a, r, v, n]
    * @returns {Promise<string[]>} an array of words matching the spelling pattern and criteria in the options object 
    */
   static async spellsLike(word, options) {
@@ -42755,13 +42845,13 @@ var RiTa = class _RiTa {
    *  to each word in the lexicon, returning the set of closest matches that also match the criteria in the options object.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {boolean} options.matchSpelling=false, if true will also attempt to match spelling by returning an intersection with RiTa.spellsLike()
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {boolean} [options.matchSpelling=false] if true will also attempt to match spelling by returning an intersection with RiTa.spellsLike()
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
    * @returns {Promise<string[]>} an array of words matching the phonemic pattern and criteria in the options object 
    */
@@ -42773,7 +42863,7 @@ var RiTa = class _RiTa {
    * from the Penn tag set or the simplified tag set [a, r, v, n].
    * @param {(string|string[])} word - the word or words to tag
    * @param {object} [options] - options for the tagging
-   * @param {boolean} options.simple - use simple tags (noun=n,verb=v,adverb=a,adjective=r)
+   * @param {boolean} [options.simple] - use simple tags (noun=n,verb=v,adverb=a,adjective=r)
    * @returns {string|string[]} - an array of part-of-speech tags for each word in the input
    */
   static pos(word, options) {
@@ -42830,7 +42920,7 @@ var RiTa = class _RiTa {
    * Tags the input string with part-of-speech tags, either from the Penn tag set or the simplified tag set [a, r, v, n].
    * @param {string} sentence - the sentence to tag
    * @param {object} [options] - options for the tagging
-   * @param {boolean} options.simple=false - use the simplified tag set [a, r, v, n]
+   * @param {boolean} [options.simple=false] - use the simplified tag set [a, r, v, n]
    * @returns {string} the tagged sentence
    */
   static posInline(sentence, options) {
@@ -42857,14 +42947,14 @@ var RiTa = class _RiTa {
    * spelling, phonemes, stresses, part-of-speech, etc. If no regex or options are supplied, the full set of words is returned.
    * @param {(string|RegExp)} [pattern] - the pattern to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
-   * @param {string} options.type - the type of regex or string pattern to match, options are 'stresses'
+   * @param {string} [options.type] - the type of regex or string pattern to match, options are 'stresses'
    *  or 'phones' or 'letters' (the default)
    * @returns {Promise<string[]>} an array of words matching the criteria in both the pattern and the options object 
    */
@@ -42876,13 +42966,13 @@ var RiTa = class _RiTa {
     * Punctuation and case are ignored unless specified otherwise.
     * @param {string} text - The text from which to extract the tokens
     * @param {object} [options] - The options
-    * @param {boolean} options.caseSensitive=false - Whether to pay attention to case
-    * @param {boolean} options.ignoreStopWords=false - Whether to ignore words such as 'the', 'and', 'a', 'of', etc,
+    * @param {boolean} [options.caseSensitive=false] - Whether to pay attention to case
+    * @param {boolean} [options.ignoreStopWords=false] - Whether to ignore words such as 'the', 'and', 'a', 'of', etc,
     *  as specified in RiTa.STOP_WORDS
-    * @param {boolean} options.splitContractions=false - Whether to convert contractions
+    * @param {boolean} [options.splitContractions=false] - Whether to convert contractions
     *  (e.g., "I'd" or "she'll") into multiple individual tokens
-    * @param {boolean} options.includePunct=false - Whether to include punctuation in the results
-    * @param {boolean} options.sort=false - Whether to sort the tokens before returning them
+    * @param {boolean} [options.includePunct=false] - Whether to include punctuation in the results
+    * @param {boolean} [options.sort=false] - Whether to sort the tokens before returning them
     * @returns {string[]} Array of tokens
     */
   static tokens(text, options = {
@@ -42898,10 +42988,10 @@ var RiTa = class _RiTa {
    * Tokenizes an input string into words, according to the Penn Treebank conventions
    * @param {string} input - The text to tokenize
    * @param {object} [options] - The options
-   * @param {RegExp} options.regex=null - An optional custom regex to split on
-   * @param {boolean} options.splitHyphens=false - Whether to split hyphenated words 
+   * @param {RegExp} [options.regex=null] - An optional custom regex to split on
+   * @param {boolean} [options.splitHyphens=false] - Whether to split hyphenated words 
    * (e.g., "mother-in-law") into multiple individual tokens
-   * @param {boolean} options.splitContractions=false - Whether to split contractions 
+   * @param {boolean} [options.splitContractions=false] - Whether to split contractions 
    * (e.g., "I'd" or "she'll") into multiple individual tokens
    * @returns {string[]} Array of tokens
    */
@@ -42912,7 +43002,7 @@ var RiTa = class _RiTa {
    * Joins an array (of words and punctuation) into a sentence, according to 
    * the Penn Treebank conventions. The inverse of RiTa.tokenize().
    * @param {string[]} input - The array of words to join
-   * @param {string} delim=' ' - The delimiter to use between words, or a space by default
+   * @param {string} [delim=' '] - The delimiter to use between words, or a space by default
    * @returns {string} The joined sentence
    */
   static untokenize(input, delim = " ") {
@@ -42964,14 +43054,14 @@ var RiTa = class _RiTa {
    * Conjugates the 'verb' according to the specified options (tense, person, number, etc.)
    * @param {string} verbWord 
    * @param {object} [options]
-   * @param {number} options.tense - the tense of the verb, either RiTa.PAST, RiTa.PRESENT, or RiTa.FUTURE
-   * @param {number} options.person - the person of the verb, either RiTa.FIRST, RiTa.SECOND, or RiTa.THIRD
-   * @param {number} options.number - the number of the verb, either RiTa.SINGULAR or RiTa.PLURAL
-   * @param {number} options.form - the form of the verb, either RiTa.INFINITIVE or RiTa.GERUND
-   * @param {boolean} options.passive - whether the verb should be passive
-   * @param {boolean} options.progressive - whether the verb should be progressive
-   * @param {boolean} options.perfect - whether the verb should be perfect
-   * @param {boolean} options.interrogative - whether the verb should be in interrogative form
+   * @param {number} [options.tense] - the tense of the verb, either RiTa.PAST, RiTa.PRESENT, or RiTa.FUTURE
+   * @param {number} [options.person] - the person of the verb, either RiTa.FIRST, RiTa.SECOND, or RiTa.THIRD
+   * @param {number} [options.number] - the number of the verb, either RiTa.SINGULAR or RiTa.PLURAL
+   * @param {number} [options.form] - the form of the verb, either RiTa.INFINITIVE or RiTa.GERUND
+   * @param {boolean} [options.passive] - whether the verb should be passive
+   * @param {boolean} [options.progressive] - whether the verb should be progressive
+   * @param {boolean} [options.perfect] - whether the verb should be perfect
+   * @param {boolean} [options.interrogative] - whether the verb should be in interrogative form
    * @returns {string} the conjugated verb
    */
   static conjugate(verbWord, options) {
@@ -42980,6 +43070,7 @@ var RiTa = class _RiTa {
   /**
    * Analyzes the input and returns a new string containing the stresses for each syllable of the input text .
    * @param {string} input - the text to analyze
+   * @param {object} [options] - options for the analysis
    * @returns {string} a string containing the stresses for each syllable of the input text
    */
   static stresses(input, options) {
@@ -42988,6 +43079,7 @@ var RiTa = class _RiTa {
   /**
    * Analyzes the input and returns a new string containing the syllables of the input text.
    * @param {string} input - the text to analyze
+   * @param {object} [options] - options for the analysis
    * @returns {string} a string containing the syllables of the input text
    */
   static syllables(input, options) {
@@ -42996,6 +43088,7 @@ var RiTa = class _RiTa {
   /**
    * Analyzes the input and returns a new string containing the phonemes of the input text.
    * @param {string} input - the text to analyze
+   * @param {object} [options] - options for the analysis
    * @returns {string} a string containing the phones of the input text
    */
   static phones(input, options) {
@@ -43006,7 +43099,7 @@ var RiTa = class _RiTa {
    * including phonemes, syllables, stresses, and part-of-speech tags.
    * @param {string} input - the text to analyze
    * @param {object} [options] - options for the analysis
-   * @param {boolean} options.simple=false - whether to use the simplified tag set [a, r, v, n]
+   * @param {boolean} [options.simple=false] - whether to use the simplified tag set [a, r, v, n]
    * @returns {object} an object containing the features of the input text (phones, syllables, stresses, pos), or the features inline
    */
   static analyze(input, options) {
@@ -43019,13 +43112,13 @@ var RiTa = class _RiTa {
    *  returning the set of closest matches that also match the criteria in the options object.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    * or the simplified tag set [a, r, v, n]
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
    * @return {string[]} an array of words matching the spelling pattern and criteria in the options object
    */
   static spellsLikeSync(word, options) {
@@ -43036,13 +43129,13 @@ var RiTa = class _RiTa {
    *  to each word in the lexicon, returning the set of closest matches that also match the criteria in the options object.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words 
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.matchSpelling=false, if true will also attempt to match spelling by returning an intersection with RiTa.spellsLike()
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words 
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.matchSpelling=false] if true will also attempt to match spelling by returning an intersection with RiTa.spellsLike()
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
    * @return {string[]} an array of words matching the phonemic pattern and criteria in the options object 
    */
@@ -43054,12 +43147,12 @@ var RiTa = class _RiTa {
    * Two words are considered as rhyming if their final stressed vowel and all following phonemes are identical.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set  
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set  
    * or the simplified tag set [a, r, v, n]
    * @return {string[]} an array of rhymes that match criteria in the options object
    */
@@ -43072,14 +43165,14 @@ var RiTa = class _RiTa {
    * part-of-speech, etc.
    * @param {(string|RegExp)} [pattern] - the pattern to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    * or the simplified tag set [a, r, v, n]
-   * @param {string} options.type - the type of regex or string pattern to match, options are 'stresses' or 'phones' or 'letters' (the default)
+   * @param {string} [options.type] - the type of regex or string pattern to match, options are 'stresses' or 'phones' or 'letters' (the default)
    * @return {string[]} an array of words matching the criteria in both the pattern and the options object
    */
   static searchSync(pattern, options) {
@@ -43090,12 +43183,12 @@ var RiTa = class _RiTa {
    * of the input string to those of each word in the lexicon via a minimum-edit-distance metric.
    * @param {string} word - the word to match
    * @param {object} [options] - options for the search
-   * @param {number} options.minLength=4 - the minimum length of the words
-   * @param {number} options.maxLength - the maximum length of the words
-   * @param {number} options.numSyllables - the number of syllables in the words
-   * @param {number} options.limit=10 - the maximum number of results to return (pass -1 to return all matches)
-   * @param {boolean} options.shuffle=false - whether to shuffle the results before returning them
-   * @param {string} options.pos - the part-of-speech of the words to return, either from the Penn tag set
+   * @param {number} [options.minLength=4] - the minimum length of the words
+   * @param {number} [options.maxLength] - the maximum length of the words
+   * @param {number} [options.numSyllables] - the number of syllables in the words
+   * @param {number} [options.limit=10] - the maximum number of results to return (pass -1 to return all matches)
+   * @param {boolean} [options.shuffle=false] - whether to shuffle the results before returning them
+   * @param {string} [options.pos] - the part-of-speech of the words to return, either from the Penn tag set
    *  or the simplified tag set [a, r, v, n]
    * @return {string[]} an array of alliterations matching criteria in the options object
    */
@@ -43128,7 +43221,7 @@ var RiTa = class _RiTa {
     return _RiTa.randomizer.random(...arguments);
   }
 };
-RiTa.RiGrammar = RiGrammar;
+RiTa.RiGrammar = _riscript.RiGrammar;
 RiTa.RiMarkov = markov_default;
 RiTa.Stemmer = stemmer_default;
 RiTa.randomizer = new randgen_default();
@@ -43143,7 +43236,7 @@ markov_default.parent = RiTa;
 stemmer_default.tokenizer = RiTa.tokenizer;
 RiTa.SILENT = false;
 RiTa.SILENCE_LTS = false;
-RiTa.VERSION = "3.0.22";
+RiTa.VERSION = "3.0.25";
 RiTa.FIRST = 1;
 RiTa.SECOND = 2;
 RiTa.THIRD = 3;
@@ -43170,9 +43263,9 @@ RiTa.GERUND = 2;
 RiTa.SPLIT_CONTRACTIONS = false;
 var ONLY_PUNCT = /^[\p{P}|\+|-|<|>|\^|\$|\ufffd|`]*$/u;
 var IS_LETTER = /^[a-z\u00C0-\u00ff]+$/;
-RiTa.RiScript = _riscript.RiScript;
 RiTa.riscript = new (0, _riscript.RiScript)({ RiTa });
 
 
-exports.RiTa = RiTa;
+
+exports.RiMarkov = markov_default; exports.RiTa = RiTa;
 //# sourceMappingURL=rita.cjs.map