axyseo 2.0.0-alpha.0.0.37 → 2.0.0-alpha.0.0.39

package/build/languageProcessing/helpers/word/areWordsInSentence.js

@@ -0,0 +1,17 @@
+import { filter } from "lodash";
+import getWords from "./getWords.js";
+
+/**
+ * Checks if one or more words of a list occur in a sentence.
+ *
+ * @param {Array} words The list of words.
+ * @param {string} sentence The sentence to match against.
+ * @returns {Boolean} Whether the sentence contains the word.
+ */
+export default function areWordsInSentence(words, sentence) {
+  const matches = filter(getWords(sentence), function (word) {
+    return words.includes(word.toLocaleLowerCase());
+  });
+  return matches.length !== 0;
+}
+//# sourceMappingURL=areWordsInSentence.js.map

package/build/languageProcessing/helpers/word/areWordsInSentence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"areWordsInSentence.js","names":["filter","getWords","areWordsInSentence","words","sentence","matches","word","includes","toLocaleLowerCase","length"],"sources":["../../../../src/languageProcessing/helpers/word/areWordsInSentence.js"],"sourcesContent":["import { filter } from \"lodash\";\nimport getWords from \"./getWords.js\";\n\n/**\n * Checks if one or more words of a list occur in a sentence.\n *\n * @param {Array} words The list of words.\n * @param {string} sentence The sentence to match against.\n * @returns {Boolean} Whether the sentence contains the word.\n */\nexport default function areWordsInSentence( words, sentence ) {\n\tconst matches = filter( getWords( sentence ), function( word ) {\n\t\treturn words.includes( word.toLocaleLowerCase() );\n\t} );\n\treturn matches.length !== 0;\n}\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,QAAQ;AAC/B,OAAOC,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,kBAAkBA,CAAEC,KAAK,EAAEC,QAAQ,EAAG;EAC7D,MAAMC,OAAO,GAAGL,MAAM,CAAEC,QAAQ,CAAEG,QAAS,CAAC,EAAE,UAAUE,IAAI,EAAG;IAC9D,OAAOH,KAAK,CAACI,QAAQ,CAAED,IAAI,CAACE,iBAAiB,CAAC,CAAE,CAAC;EAClD,CAAE,CAAC;EACH,OAAOH,OAAO,CAACI,MAAM,KAAK,CAAC;AAC5B","ignoreList":[]}

package/build/languageProcessing/helpers/word/countMetaDescriptionLength.js

@@ -0,0 +1,18 @@
+/**
+ * Check the length of the description.
+ *
+ * @param {string}  date          The date.
+ * @param {string}  description   The meta description.
+ *
+ * @returns {number} The length of the description.
+ */
+export default function (date, description) {
+  let descriptionLength = description.length;
+  /* If the meta description is preceded by a date, two spaces and a hyphen (" - ") are added as well. Therefore,
+  three needs to be added to the total length. */
+  if (date !== "" && descriptionLength > 0) {
+    descriptionLength += date.length + 3;
+  }
+  return descriptionLength;
+}
+//# sourceMappingURL=countMetaDescriptionLength.js.map

package/build/languageProcessing/helpers/word/countMetaDescriptionLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"countMetaDescriptionLength.js","names":["date","description","descriptionLength","length"],"sources":["../../../../src/languageProcessing/helpers/word/countMetaDescriptionLength.js"],"sourcesContent":["/**\n * Check the length of the description.\n *\n * @param {string}  date          The date.\n * @param {string}  description   The meta description.\n *\n * @returns {number} The length of the description.\n */\nexport default function( date, description ) {\n\tlet descriptionLength = description.length;\n\t/* If the meta description is preceded by a date, two spaces and a hyphen (\" - \") are added as well. Therefore,\n\tthree needs to be added to the total length. */\n\tif ( date !== \"\" && descriptionLength > 0 ) {\n\t\tdescriptionLength += date.length + 3;\n\t}\n\n\treturn descriptionLength;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUA,IAAI,EAAEC,WAAW,EAAG;EAC5C,IAAIC,iBAAiB,GAAGD,WAAW,CAACE,MAAM;EAC1C;AACD;EACC,IAAKH,IAAI,KAAK,EAAE,IAAIE,iBAAiB,GAAG,CAAC,EAAG;IAC3CA,iBAAiB,IAAIF,IAAI,CAACG,MAAM,GAAG,CAAC;EACrC;EAEA,OAAOD,iBAAiB;AACzB","ignoreList":[]}

package/build/languageProcessing/helpers/word/countWords.js

@@ -0,0 +1,15 @@
+/** @module stringProcessing/countWords */
+
+import getWords from "./getWords.js";
+
+/**
+ * Calculates the word count of a certain text.
+ *
+ * @param {string} text The text to be counted.
+ *
+ * @returns {number} The word count of the given text.
+ */
+export default function (text) {
+  return getWords(text).length;
+}
+//# sourceMappingURL=countWords.js.map

package/build/languageProcessing/helpers/word/countWords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"countWords.js","names":["getWords","text","length"],"sources":["../../../../src/languageProcessing/helpers/word/countWords.js"],"sourcesContent":["/** @module stringProcessing/countWords */\n\nimport getWords from \"./getWords.js\";\n\n/**\n * Calculates the word count of a certain text.\n *\n * @param {string} text The text to be counted.\n *\n * @returns {number} The word count of the given text.\n */\nexport default function( text ) {\n\treturn getWords( text ).length;\n}\n"],"mappings":"AAAA;;AAEA,OAAOA,QAAQ;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,IAAI,EAAG;EAC/B,OAAOD,QAAQ,CAAEC,IAAK,CAAC,CAACC,MAAM;AAC/B","ignoreList":[]}

package/build/languageProcessing/helpers/word/createPunctuationTokens.js

@@ -0,0 +1,41 @@
+import { punctuationRegexEnd, punctuationRegexStart } from "../sanitize/removePunctuation";
+import { hashedHtmlEntitiesRegexEnd, hashedHtmlEntitiesRegexStart } from "../../../helpers/htmlEntities";
+
+/**
+ * Removes punctuation from the beginning and end of a word token, and creates separate tokens from them.
+ *
+ * @param {string[]} rawTokens	The tokens that may contain punctuation at the beginning and end of words.
+ *
+ * @returns {string[]} The tokens with the punctuation moved into separate tokens.
+ */
+const createPunctuationTokens = rawTokens => {
+  const tokenTexts = [];
+  rawTokens.forEach(token => {
+    // Pretokens contains all that occurs before the first letter of the token.
+    const preTokens = [];
+    // Posttokens contains all that occurs after the last letter of the token.
+    const postTokens = [];
+
+    // Add all punctuation marks that occur before the first letter of the token to the pretokens array.
+    // Also, prevent matching with a hashed HTML entity in the beginning of the token.
+    while (punctuationRegexStart.test(token) && !hashedHtmlEntitiesRegexStart.test(token)) {
+      preTokens.push(token[0]);
+      token = token.slice(1);
+    }
+    // Add all punctuation marks that occur after the last letter of the token to the posttokens array.
+    // Also, prevent matching with a hashed HTML entity at the end of the token.
+    while (punctuationRegexEnd.test(token) && !hashedHtmlEntitiesRegexEnd.test(token)) {
+      // Using unshift here because we are iterating from the end of the string to the beginning,
+      // and we want to keep the order of the punctuation marks.
+      // Therefore, we add them to the start of the array.
+      postTokens.unshift(token[token.length - 1]);
+      token = token.slice(0, -1);
+    }
+    let currentTokens = [...preTokens, token, ...postTokens];
+    currentTokens = currentTokens.filter(x => x !== "");
+    tokenTexts.push(...currentTokens);
+  });
+  return tokenTexts;
+};
+export default createPunctuationTokens;
+//# sourceMappingURL=createPunctuationTokens.js.map

package/build/languageProcessing/helpers/word/createPunctuationTokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPunctuationTokens.js","names":["punctuationRegexEnd","punctuationRegexStart","hashedHtmlEntitiesRegexEnd","hashedHtmlEntitiesRegexStart","createPunctuationTokens","rawTokens","tokenTexts","forEach","token","preTokens","postTokens","test","push","slice","unshift","length","currentTokens","filter","x"],"sources":["../../../../src/languageProcessing/helpers/word/createPunctuationTokens.js"],"sourcesContent":["import { punctuationRegexEnd, punctuationRegexStart } from \"../sanitize/removePunctuation\";\nimport { hashedHtmlEntitiesRegexEnd, hashedHtmlEntitiesRegexStart } from \"../../../helpers/htmlEntities\";\n\n/**\n * Removes punctuation from the beginning and end of a word token, and creates separate tokens from them.\n *\n * @param {string[]} rawTokens\tThe tokens that may contain punctuation at the beginning and end of words.\n *\n * @returns {string[]} The tokens with the punctuation moved into separate tokens.\n */\nconst createPunctuationTokens = ( rawTokens ) => {\n\tconst tokenTexts = [];\n\trawTokens.forEach( token => {\n\t\t// Pretokens contains all that occurs before the first letter of the token.\n\t\tconst preTokens = [];\n\t\t// Posttokens contains all that occurs after the last letter of the token.\n\t\tconst postTokens = [];\n\n\t\t// Add all punctuation marks that occur before the first letter of the token to the pretokens array.\n\t\t// Also, prevent matching with a hashed HTML entity in the beginning of the token.\n\t\twhile ( punctuationRegexStart.test( token ) && ! hashedHtmlEntitiesRegexStart.test( token ) ) {\n\t\t\tpreTokens.push( token[ 0 ] );\n\t\t\ttoken = token.slice( 1 );\n\t\t}\n\t\t// Add all punctuation marks that occur after the last letter of the token to the posttokens array.\n\t\t// Also, prevent matching with a hashed HTML entity at the end of the token.\n\t\twhile ( punctuationRegexEnd.test( token ) && ! hashedHtmlEntitiesRegexEnd.test( token ) ) {\n\t\t\t// Using unshift here because we are iterating from the end of the string to the beginning,\n\t\t\t// and we want to keep the order of the punctuation marks.\n\t\t\t// Therefore, we add them to the start of the array.\n\t\t\tpostTokens.unshift( token[ token.length - 1 ] );\n\t\t\ttoken = token.slice( 0, -1 );\n\t\t}\n\n\t\tlet currentTokens = [ ...preTokens, token, ...postTokens ];\n\t\tcurrentTokens = currentTokens.filter( x => x !== \"\" );\n\t\ttokenTexts.push( ...currentTokens );\n\t} );\n\treturn tokenTexts;\n};\n\nexport default createPunctuationTokens;\n"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,qBAAqB;AACnD,SAASC,0BAA0B,EAAEC,4BAA4B;;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,uBAAuB,GAAKC,SAAS,IAAM;EAChD,MAAMC,UAAU,GAAG,EAAE;EACrBD,SAAS,CAACE,OAAO,CAAEC,KAAK,IAAI;IAC3B;IACA,MAAMC,SAAS,GAAG,EAAE;IACpB;IACA,MAAMC,UAAU,GAAG,EAAE;;IAErB;IACA;IACA,OAAQT,qBAAqB,CAACU,IAAI,CAAEH,KAAM,CAAC,IAAI,CAAEL,4BAA4B,CAACQ,IAAI,CAAEH,KAAM,CAAC,EAAG;MAC7FC,SAAS,CAACG,IAAI,CAAEJ,KAAK,CAAE,CAAC,CAAG,CAAC;MAC5BA,KAAK,GAAGA,KAAK,CAACK,KAAK,CAAE,CAAE,CAAC;IACzB;IACA;IACA;IACA,OAAQb,mBAAmB,CAACW,IAAI,CAAEH,KAAM,CAAC,IAAI,CAAEN,0BAA0B,CAACS,IAAI,CAAEH,KAAM,CAAC,EAAG;MACzF;MACA;MACA;MACAE,UAAU,CAACI,OAAO,CAAEN,KAAK,CAAEA,KAAK,CAACO,MAAM,GAAG,CAAC,CAAG,CAAC;MAC/CP,KAAK,GAAGA,KAAK,CAACK,KAAK,CAAE,CAAC,EAAE,CAAC,CAAE,CAAC;IAC7B;IAEA,IAAIG,aAAa,GAAG,CAAE,GAAGP,SAAS,EAAED,KAAK,EAAE,GAAGE,UAAU,CAAE;IAC1DM,aAAa,GAAGA,aAAa,CAACC,MAAM,CAAEC,CAAC,IAAIA,CAAC,KAAK,EAAG,CAAC;IACrDZ,UAAU,CAACM,IAAI,CAAE,GAAGI,aAAc,CAAC;EACpC,CAAE,CAAC;EACH,OAAOV,UAAU;AAClB,CAAC;AAED,eAAeF,uBAAuB","ignoreList":[]}

package/build/languageProcessing/helpers/word/filterWordsFromArray.js

@@ -0,0 +1,16 @@
+import { filter, includes } from "lodash";
+
+/**
+ * Filters certain words from an array of words.
+ *
+ * @param {Array} array The words to check.
+ * @param {Array} words The words to filter.
+ *
+ * @returns {Array} The original array with the certain words filtered out.
+ */
+export default function filterWordsFromArray(array, words = []) {
+  return filter(array, function (word) {
+    return !includes(words, word.trim().toLocaleLowerCase());
+  });
+}
+//# sourceMappingURL=filterWordsFromArray.js.map

package/build/languageProcessing/helpers/word/filterWordsFromArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterWordsFromArray.js","names":["filter","includes","filterWordsFromArray","array","words","word","trim","toLocaleLowerCase"],"sources":["../../../../src/languageProcessing/helpers/word/filterWordsFromArray.js"],"sourcesContent":["import { filter, includes } from \"lodash\";\n\n/**\n * Filters certain words from an array of words.\n *\n * @param {Array} array The words to check.\n * @param {Array} words The words to filter.\n *\n * @returns {Array} The original array with the certain words filtered out.\n */\nexport default function filterWordsFromArray( array, words = [] ) {\n\treturn filter( array, function( word ) {\n\t\treturn ( ! includes( words, word.trim().toLocaleLowerCase() ) );\n\t} );\n}\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,QAAQ,QAAQ,QAAQ;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,oBAAoBA,CAAEC,KAAK,EAAEC,KAAK,GAAG,EAAE,EAAG;EACjE,OAAOJ,MAAM,CAAEG,KAAK,EAAE,UAAUE,IAAI,EAAG;IACtC,OAAS,CAAEJ,QAAQ,CAAEG,KAAK,EAAEC,IAAI,CAACC,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAE,CAAC;EAC9D,CAAE,CAAC;AACJ","ignoreList":[]}

package/build/languageProcessing/helpers/word/followsIndex.js

@@ -0,0 +1,24 @@
+import { isEmpty, forEach, includes } from "lodash";
+
+/**
+ * Checks whether a given word is followed by any word from a given list.
+ *
+ * @param {Array} followingWords    The array of objects with matches and indices.
+ * @param {Object} match            The object with the match and index to test the following words for.
+ *
+ * @returns {boolean} Returns true if the match is followed by a given word, otherwise returns false.
+ */
+export default function (followingWords, match) {
+  if (isEmpty(followingWords)) {
+    return false;
+  }
+
+  // The followingWordIndices include the preceding space.
+  const wordAfterMatchIndex = match.index + match.match.length;
+  const followingWordsIndices = [];
+  forEach(followingWords, function (followingWord) {
+    followingWordsIndices.push(followingWord.index);
+  });
+  return includes(followingWordsIndices, wordAfterMatchIndex);
+}
+//# sourceMappingURL=followsIndex.js.map

package/build/languageProcessing/helpers/word/followsIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"followsIndex.js","names":["isEmpty","forEach","includes","followingWords","match","wordAfterMatchIndex","index","length","followingWordsIndices","followingWord","push"],"sources":["../../../../src/languageProcessing/helpers/word/followsIndex.js"],"sourcesContent":["import { isEmpty, forEach, includes } from \"lodash\";\n\n/**\n * Checks whether a given word is followed by any word from a given list.\n *\n * @param {Array} followingWords    The array of objects with matches and indices.\n * @param {Object} match            The object with the match and index to test the following words for.\n *\n * @returns {boolean} Returns true if the match is followed by a given word, otherwise returns false.\n */\nexport default function( followingWords, match ) {\n\tif ( isEmpty( followingWords ) ) {\n\t\treturn false;\n\t}\n\n\t// The followingWordIndices include the preceding space.\n\tconst wordAfterMatchIndex = match.index + match.match.length;\n\tconst followingWordsIndices = [];\n\n\tforEach( followingWords, function( followingWord ) {\n\t\tfollowingWordsIndices.push( followingWord.index );\n\t} );\n\n\treturn includes( followingWordsIndices, wordAfterMatchIndex );\n}\n"],"mappings":"AAAA,SAASA,OAAO,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,cAAc,EAAEC,KAAK,EAAG;EAChD,IAAKJ,OAAO,CAAEG,cAAe,CAAC,EAAG;IAChC,OAAO,KAAK;EACb;;EAEA;EACA,MAAME,mBAAmB,GAAGD,KAAK,CAACE,KAAK,GAAGF,KAAK,CAACA,KAAK,CAACG,MAAM;EAC5D,MAAMC,qBAAqB,GAAG,EAAE;EAEhCP,OAAO,CAAEE,cAAc,EAAE,UAAUM,aAAa,EAAG;IAClDD,qBAAqB,CAACE,IAAI,CAAED,aAAa,CAACH,KAAM,CAAC;EAClD,CAAE,CAAC;EAEH,OAAOJ,QAAQ,CAAEM,qBAAqB,EAAEH,mBAAoB,CAAC;AAC9D","ignoreList":[]}

package/build/languageProcessing/helpers/word/getAllWordsFromTree.js

@@ -0,0 +1,24 @@
+import getSentencesFromTree from "../sentence/getSentencesFromTree";
+import { flatMap } from "lodash";
+import removePunctuation from "../sanitize/removePunctuation";
+
+/**
+ * Gets the words from the tree, i.e. from the paragraph and heading nodes.
+ * These two node types are the nodes that should contain words for the analysis.
+ *
+ * @param {Paper} paper The paper to get the tree and words from.
+ *
+ * @returns {String[]} Array of words retrieved from the tree.
+ */
+export default function (paper) {
+  const sentences = getSentencesFromTree(paper);
+  // Get all the tokens from each sentence.
+  const tokens = sentences.map(sentence => sentence.tokens);
+  let words = flatMap(tokens).map(token => token.text);
+  // Remove punctuation and spaces.
+  words = words.map(token => removePunctuation(token));
+
+  // Filter out empty tokens.
+  return words.filter(word => word.trim() !== "");
+}
+//# sourceMappingURL=getAllWordsFromTree.js.map

package/build/languageProcessing/helpers/word/getAllWordsFromTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAllWordsFromTree.js","names":["getSentencesFromTree","flatMap","removePunctuation","paper","sentences","tokens","map","sentence","words","token","text","filter","word","trim"],"sources":["../../../../src/languageProcessing/helpers/word/getAllWordsFromTree.js"],"sourcesContent":["import getSentencesFromTree from \"../sentence/getSentencesFromTree\";\nimport { flatMap } from \"lodash\";\nimport removePunctuation from \"../sanitize/removePunctuation\";\n\n/**\n * Gets the words from the tree, i.e. from the paragraph and heading nodes.\n * These two node types are the nodes that should contain words for the analysis.\n *\n * @param {Paper} paper The paper to get the tree and words from.\n *\n * @returns {String[]} Array of words retrieved from the tree.\n */\nexport default function( paper ) {\n\tconst sentences = getSentencesFromTree( paper );\n\t// Get all the tokens from each sentence.\n\tconst tokens = sentences.map( sentence => sentence.tokens );\n\tlet words = flatMap( tokens ).map( token => token.text );\n\t// Remove punctuation and spaces.\n\twords = words.map( token => removePunctuation( token ) );\n\n\t// Filter out empty tokens.\n\treturn words.filter( word => word.trim() !== \"\" );\n}\n"],"mappings":"AAAA,OAAOA,oBAAoB;AAC3B,SAASC,OAAO,QAAQ,QAAQ;AAChC,OAAOC,iBAAiB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,KAAK,EAAG;EAChC,MAAMC,SAAS,GAAGJ,oBAAoB,CAAEG,KAAM,CAAC;EAC/C;EACA,MAAME,MAAM,GAAGD,SAAS,CAACE,GAAG,CAAEC,QAAQ,IAAIA,QAAQ,CAACF,MAAO,CAAC;EAC3D,IAAIG,KAAK,GAAGP,OAAO,CAAEI,MAAO,CAAC,CAACC,GAAG,CAAEG,KAAK,IAAIA,KAAK,CAACC,IAAK,CAAC;EACxD;EACAF,KAAK,GAAGA,KAAK,CAACF,GAAG,CAAEG,KAAK,IAAIP,iBAAiB,CAAEO,KAAM,CAAE,CAAC;;EAExD;EACA,OAAOD,KAAK,CAACG,MAAM,CAAEC,IAAI,IAAIA,IAAI,CAACC,IAAI,CAAC,CAAC,KAAK,EAAG,CAAC;AAClD","ignoreList":[]}

package/build/languageProcessing/helpers/word/getWords.js

@@ -0,0 +1,37 @@
+/** @module stringProcessing/countWords */
+import sanitizeString from "../sanitize/sanitizeString";
+import { filter, flatMap } from "lodash";
+import removePunctuation, { punctuationRegexString } from "../sanitize/removePunctuation.js";
+const punctuationRegex = new RegExp(`([${punctuationRegexString}])`, "g");
+
+/**
+ * Returns an array with words used in the text.
+ *
+ * @param {string} text The text to be counted.
+ * @param {string} [wordBoundaryRegexString=\\s] The regex string for the word boundary that should be used to split the text into words.
+ * @param {boolean} [shouldRemovePunctuation=true] If punctuation should be removed. Defaults to `true`.
+ *
+ * @returns {Array} The array with all words.
+ */
+export default function (text, wordBoundaryRegexString = "\\s", shouldRemovePunctuation = true) {
+  // Unify whitespaces and non-breaking spaces, remove table of content and strip the tags and multiple spaces.
+  text = sanitizeString(text);
+  if (text === "") {
+    return [];
+  }
+  const wordBoundaryRegex = new RegExp(wordBoundaryRegexString, "g");
+  let words = text.split(wordBoundaryRegex);
+  if (shouldRemovePunctuation) {
+    words = words.map(removePunctuation);
+  } else {
+    // If punctuation is not removed, punctuation marks are tokenized as if they were words.
+    words = flatMap(words, word => {
+      const newWord = word.replace(punctuationRegex, " $1 ");
+      return newWord.split(" ");
+    });
+  }
+  return filter(words, function (word) {
+    return word.trim() !== "";
+  });
+}
+//# sourceMappingURL=getWords.js.map

package/build/languageProcessing/helpers/word/getWords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWords.js","names":["sanitizeString","filter","flatMap","removePunctuation","punctuationRegexString","punctuationRegex","RegExp","text","wordBoundaryRegexString","shouldRemovePunctuation","wordBoundaryRegex","words","split","map","word","newWord","replace","trim"],"sources":["../../../../src/languageProcessing/helpers/word/getWords.js"],"sourcesContent":["/** @module stringProcessing/countWords */\nimport sanitizeString from \"../sanitize/sanitizeString\";\nimport { filter, flatMap } from \"lodash\";\nimport removePunctuation, { punctuationRegexString } from \"../sanitize/removePunctuation.js\";\n\nconst punctuationRegex = new RegExp( `([${punctuationRegexString}])`, \"g\" );\n\n/**\n * Returns an array with words used in the text.\n *\n * @param {string} text The text to be counted.\n * @param {string} [wordBoundaryRegexString=\\\\s] The regex string for the word boundary that should be used to split the text into words.\n * @param {boolean} [shouldRemovePunctuation=true] If punctuation should be removed. Defaults to `true`.\n *\n * @returns {Array} The array with all words.\n */\nexport default function( text, wordBoundaryRegexString = \"\\\\s\", shouldRemovePunctuation = true ) {\n\t// Unify whitespaces and non-breaking spaces, remove table of content and strip the tags and multiple spaces.\n\ttext = sanitizeString( text );\n\n\tif ( text === \"\" ) {\n\t\treturn [];\n\t}\n\n\tconst wordBoundaryRegex = new RegExp( wordBoundaryRegexString, \"g\" );\n\n\tlet words = text.split( wordBoundaryRegex );\n\n\tif ( shouldRemovePunctuation ) {\n\t\twords = words.map( removePunctuation );\n\t} else {\n\t\t// If punctuation is not removed, punctuation marks are tokenized as if they were words.\n\t\twords = flatMap( words, ( word ) => {\n\t\t\tconst newWord = word.replace( punctuationRegex, \" $1 \" );\n\t\t\treturn newWord.split( \" \" );\n\t\t} );\n\t}\n\n\treturn filter( words, function( word ) {\n\t\treturn word.trim() !== \"\";\n\t} );\n}\n\n"],"mappings":"AAAA;AACA,OAAOA,cAAc;AACrB,SAASC,MAAM,EAAEC,OAAO,QAAQ,QAAQ;AACxC,OAAOC,iBAAiB,IAAIC,sBAAsB;AAElD,MAAMC,gBAAgB,GAAG,IAAIC,MAAM,CAAE,KAAKF,sBAAsB,IAAI,EAAE,GAAI,CAAC;;AAE3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUG,IAAI,EAAEC,uBAAuB,GAAG,KAAK,EAAEC,uBAAuB,GAAG,IAAI,EAAG;EAChG;EACAF,IAAI,GAAGP,cAAc,CAAEO,IAAK,CAAC;EAE7B,IAAKA,IAAI,KAAK,EAAE,EAAG;IAClB,OAAO,EAAE;EACV;EAEA,MAAMG,iBAAiB,GAAG,IAAIJ,MAAM,CAAEE,uBAAuB,EAAE,GAAI,CAAC;EAEpE,IAAIG,KAAK,GAAGJ,IAAI,CAACK,KAAK,CAAEF,iBAAkB,CAAC;EAE3C,IAAKD,uBAAuB,EAAG;IAC9BE,KAAK,GAAGA,KAAK,CAACE,GAAG,CAAEV,iBAAkB,CAAC;EACvC,CAAC,MAAM;IACN;IACAQ,KAAK,GAAGT,OAAO,CAAES,KAAK,EAAIG,IAAI,IAAM;MACnC,MAAMC,OAAO,GAAGD,IAAI,CAACE,OAAO,CAAEX,gBAAgB,EAAE,MAAO,CAAC;MACxD,OAAOU,OAAO,CAACH,KAAK,CAAE,GAAI,CAAC;IAC5B,CAAE,CAAC;EACJ;EAEA,OAAOX,MAAM,CAAEU,KAAK,EAAE,UAAUG,IAAI,EAAG;IACtC,OAAOA,IAAI,CAACG,IAAI,CAAC,CAAC,KAAK,EAAE;EAC1B,CAAE,CAAC;AACJ","ignoreList":[]}

package/build/languageProcessing/helpers/word/includesIndex.js

@@ -0,0 +1,29 @@
+import { forEach, includes, isEmpty } from "lodash";
+
+/**
+ * Checks whether a given word is directly preceded by a word from a list of words.
+ *
+ * @param {Array} precedingWords    The array of objects with matches and indices.
+ * @param {number} matchIndex       The index of the word for which to check whether it's preceded by one of the other words.
+ * @param {boolean} addSpace        True if a space should be added.
+ *
+ * @returns {boolean} Returns true if the match is preceded by a given word, otherwise returns false.
+ */
+export default function (precedingWords, matchIndex, addSpace = true) {
+  /*
+  1 if there is a space between the match and the preceding word
+  (because the end word boundary is not included in the match).
+  0 if the preceding word is a contraction.
+  */
+  const space = addSpace ? 1 : 0;
+  if (isEmpty(precedingWords)) {
+    return false;
+  }
+  const precedingWordsEndIndices = [];
+  forEach(precedingWords, function (precedingWord) {
+    const precedingWordsEndIndex = precedingWord.index + precedingWord.match.length + space;
+    precedingWordsEndIndices.push(precedingWordsEndIndex);
+  });
+  return includes(precedingWordsEndIndices, matchIndex);
+}
+//# sourceMappingURL=includesIndex.js.map

package/build/languageProcessing/helpers/word/includesIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includesIndex.js","names":["forEach","includes","isEmpty","precedingWords","matchIndex","addSpace","space","precedingWordsEndIndices","precedingWord","precedingWordsEndIndex","index","match","length","push"],"sources":["../../../../src/languageProcessing/helpers/word/includesIndex.js"],"sourcesContent":["import { forEach, includes, isEmpty } from \"lodash\";\n\n/**\n * Checks whether a given word is directly preceded by a word from a list of words.\n *\n * @param {Array} precedingWords    The array of objects with matches and indices.\n * @param {number} matchIndex       The index of the word for which to check whether it's preceded by one of the other words.\n * @param {boolean} addSpace        True if a space should be added.\n *\n * @returns {boolean} Returns true if the match is preceded by a given word, otherwise returns false.\n */\nexport default function( precedingWords, matchIndex, addSpace = true ) {\n\t/*\n\t1 if there is a space between the match and the preceding word\n\t(because the end word boundary is not included in the match).\n\t0 if the preceding word is a contraction.\n\t*/\n\tconst space = addSpace ? 1 : 0;\n\n\tif ( isEmpty( precedingWords ) ) {\n\t\treturn false;\n\t}\n\n\tconst precedingWordsEndIndices = [];\n\tforEach( precedingWords, function( precedingWord ) {\n\t\tconst precedingWordsEndIndex = precedingWord.index + precedingWord.match.length + space;\n\t\tprecedingWordsEndIndices.push( precedingWordsEndIndex );\n\t} );\n\treturn includes( precedingWordsEndIndices, matchIndex );\n}\n"],"mappings":"AAAA,SAASA,OAAO,EAAEC,QAAQ,EAAEC,OAAO,QAAQ,QAAQ;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,UAAUC,cAAc,EAAEC,UAAU,EAAEC,QAAQ,GAAG,IAAI,EAAG;EACtE;AACD;AACA;AACA;AACA;EACC,MAAMC,KAAK,GAAGD,QAAQ,GAAG,CAAC,GAAG,CAAC;EAE9B,IAAKH,OAAO,CAAEC,cAAe,CAAC,EAAG;IAChC,OAAO,KAAK;EACb;EAEA,MAAMI,wBAAwB,GAAG,EAAE;EACnCP,OAAO,CAAEG,cAAc,EAAE,UAAUK,aAAa,EAAG;IAClD,MAAMC,sBAAsB,GAAGD,aAAa,CAACE,KAAK,GAAGF,aAAa,CAACG,KAAK,CAACC,MAAM,GAAGN,KAAK;IACvFC,wBAAwB,CAACM,IAAI,CAAEJ,sBAAuB,CAAC;EACxD,CAAE,CAAC;EACH,OAAOR,QAAQ,CAAEM,wBAAwB,EAAEH,UAAW,CAAC;AACxD","ignoreList":[]}

package/build/languageProcessing/helpers/word/indices.js

@@ -0,0 +1,130 @@
+import { isUndefined, forEach } from "lodash";
+import stripSpaces from "../sanitize/stripSpaces.js";
+import { isWordInSentence as matchWordInSentence, characterInBoundary } from "./matchWordInSentence.js";
+
+/**
+ * Returns the indices of a string in a text. If it is found multiple times, it will return multiple indices.
+ *
+ * @param {string} word The word to find in the text.
+ * @param {string} text The text to check for the given word.
+ *
+ * @returns {Array} All indices found.
+ */
+function getIndicesByWord(word, text) {
+  let startIndex = 0;
+  const searchStringLength = word.length;
+  let index;
+  const indices = [];
+  while ((index = text.indexOf(word, startIndex)) > -1) {
+    // Check if the previous and next character are word boundaries to determine if a complete word was detected
+    const isPreviousCharacterWordBoundary = characterInBoundary(text[index - 1]) || index === 0;
+    const isNextCharacterWordBoundary = characterInBoundary(text[index + searchStringLength]) || text.length === index + searchStringLength;
+    if (isPreviousCharacterWordBoundary && isNextCharacterWordBoundary) {
+      indices.push({
+        index: index,
+        match: word
+      });
+    }
+    startIndex = index + searchStringLength;
+  }
+  return indices;
+}
+
+/**
+ * Matches string with an array, returns the word and the index it was found on.
+ *
+ * @param {Array} words The array with strings to match.
+ * @param {string} text The text to match the strings from the array to.
+ *
+ * @returns {Array} The array with words, containing the index of the match and the matched string.
+ * Returns an empty array if none are found.
+ */
+const getIndicesByWordList = function (words, text) {
+  let matchedWords = [];
+  forEach(words, function (word) {
+    word = stripSpaces(word);
+    if (!matchWordInSentence(word, text)) {
+      return;
+    }
+    matchedWords = matchedWords.concat(getIndicesByWord(word, text));
+  });
+  return matchedWords;
+};
+
+/**
+ * Sorts the array on the index property of each entry.
+ *
+ * @param {Array} indices The array with indices.
+ *
+ * @returns {Array} The sorted array with indices.
+ */
+const sortIndices = function (indices) {
+  return indices.sort(function (a, b) {
+    return a.index - b.index;
+  });
+};
+
+/**
+ * Filters duplicate entries if the indices overlap.
+ *
+ * @param {Array} indices The array with indices to be filtered.
+ *
+ * @returns {Array} The filtered array.
+ */
+const filterIndices = function (indices) {
+  indices = sortIndices(indices);
+  const filtered = [];
+  for (let i = 0; i < indices.length; i++) {
+    // If the next index is within the range of the current index and the length of the word, remove it
+    // This makes sure we don't match combinations twice, like "even though" and "though".
+    if (!isUndefined(indices[i + 1]) && indices[i + 1].index < indices[i].index + indices[i].match.length) {
+      filtered.push(indices[i]);
+
+      // Adds 1 to i, so we skip the next index that is overlapping with the current index.
+      i++;
+      continue;
+    }
+    filtered.push(indices[i]);
+  }
+  return filtered;
+};
+
+/**
+ * Matches string with an array, returns the word and the index it was found on, and sorts the match instances based on
+ * the index property of the match.
+ *
+ * @param {Array} words The array with strings to match.
+ * @param {string} text The text to match the strings from the array to.
+ *
+ * @returns {Array} The array with words, containing the index of the match and the matched string.
+ * Returns an empty array if none are found.
+ */
+const getIndicesByWordListSorted = function (words, text) {
+  let matchedWords = [];
+  forEach(words, function (word) {
+    word = stripSpaces(word);
+    if (!matchWordInSentence(word, text)) {
+      return matchedWords;
+    }
+    matchedWords = matchedWords.concat(getIndicesByWord(word, text));
+  });
+  matchedWords = matchedWords.sort(function (a, b) {
+    if (a.index < b.index) {
+      return -1;
+    }
+    if (a.index > b.index) {
+      return 1;
+    }
+    return 0;
+  });
+  return matchedWords;
+};
+export { getIndicesByWord, getIndicesByWordList, filterIndices, sortIndices, getIndicesByWordListSorted };
+export default {
+  getIndicesByWord,
+  getIndicesByWordList,
+  filterIndices,
+  sortIndices,
+  getIndicesByWordListSorted
+};
+//# sourceMappingURL=indices.js.map

package/build/languageProcessing/helpers/word/indices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indices.js","names":["isUndefined","forEach","stripSpaces","isWordInSentence","matchWordInSentence","characterInBoundary","getIndicesByWord","word","text","startIndex","searchStringLength","length","index","indices","indexOf","isPreviousCharacterWordBoundary","isNextCharacterWordBoundary","push","match","getIndicesByWordList","words","matchedWords","concat","sortIndices","sort","a","b","filterIndices","filtered","i","getIndicesByWordListSorted"],"sources":["../../../../src/languageProcessing/helpers/word/indices.js"],"sourcesContent":["import { isUndefined, forEach } from \"lodash\";\nimport stripSpaces from \"../sanitize/stripSpaces.js\";\nimport { isWordInSentence as matchWordInSentence, characterInBoundary } from \"./matchWordInSentence.js\";\n\n/**\n * Returns the indices of a string in a text. If it is found multiple times, it will return multiple indices.\n *\n * @param {string} word The word to find in the text.\n * @param {string} text The text to check for the given word.\n *\n * @returns {Array} All indices found.\n */\nfunction getIndicesByWord( word, text ) {\n\tlet startIndex = 0;\n\tconst searchStringLength = word.length;\n\tlet index;\n\tconst indices = [];\n\twhile ( ( index = text.indexOf( word, startIndex ) ) > -1 ) {\n\t\t// Check if the previous and next character are word boundaries to determine if a complete word was detected\n\t\tconst isPreviousCharacterWordBoundary = characterInBoundary( text[ index - 1 ] ) || index === 0;\n\n\t\tconst isNextCharacterWordBoundary = characterInBoundary( text[ index + searchStringLength ] ) ||\n\t\t\t( text.length === index + searchStringLength );\n\n\t\tif ( isPreviousCharacterWordBoundary && isNextCharacterWordBoundary ) {\n\t\t\tindices.push(\n\t\t\t\t{\n\t\t\t\t\tindex: index,\n\t\t\t\t\tmatch: word,\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\t\tstartIndex = index + searchStringLength;\n\t}\n\treturn indices;\n}\n\n/**\n * Matches string with an array, returns the word and the index it was found on.\n *\n * @param {Array} words The array with strings to match.\n * @param {string} text The text to match the strings from the array to.\n *\n * @returns {Array} The array with words, containing the index of the match and the matched string.\n * Returns an empty array if none are found.\n */\nconst getIndicesByWordList = function( words, text ) {\n\tlet matchedWords = [];\n\n\tforEach( words, function( word ) {\n\t\tword = stripSpaces( word );\n\t\tif ( ! matchWordInSentence( word, text ) ) {\n\t\t\treturn;\n\t\t}\n\t\tmatchedWords = matchedWords.concat( getIndicesByWord( word, text ) );\n\t} );\n\treturn matchedWords;\n};\n\n/**\n * Sorts the array on the index property of each entry.\n *\n * @param {Array} indices The array with indices.\n *\n * @returns {Array} The sorted array with indices.\n */\nconst sortIndices = function( indices ) {\n\treturn indices.sort( function( a, b ) {\n\t\treturn ( a.index - b.index );\n\t} );\n};\n\n/**\n * Filters duplicate entries if the indices overlap.\n *\n * @param {Array} indices The array with indices to be filtered.\n *\n * @returns {Array} The filtered array.\n */\nconst filterIndices = function( indices ) {\n\tindices = sortIndices( indices );\n\tconst filtered = [];\n\tfor ( let i = 0; i < indices.length; i++ ) {\n\t\t// If the next index is within the range of the current index and the length of the word, remove it\n\t\t// This makes sure we don't match combinations twice, like \"even though\" and \"though\".\n\t\tif ( ! isUndefined( indices[ i + 1 ] ) && indices[ i + 1 ].index < indices[ i ].index + indices[ i ].match.length ) {\n\t\t\tfiltered.push( indices[ i ] );\n\n\t\t\t// Adds 1 to i, so we skip the next index that is overlapping with the current index.\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tfiltered.push( indices[ i ] );\n\t}\n\treturn filtered;\n};\n\n/**\n * Matches string with an array, returns the word and the index it was found on, and sorts the match instances based on\n * the index property of the match.\n *\n * @param {Array} words The array with strings to match.\n * @param {string} text The text to match the strings from the array to.\n *\n * @returns {Array} The array with words, containing the index of the match and the matched string.\n * Returns an empty array if none are found.\n */\nconst getIndicesByWordListSorted = function( words, text ) {\n\tlet matchedWords = [];\n\n\tforEach( words, function( word ) {\n\t\tword = stripSpaces( word );\n\t\tif ( ! matchWordInSentence( word, text ) ) {\n\t\t\treturn matchedWords;\n\t\t}\n\t\tmatchedWords = matchedWords.concat( getIndicesByWord( word, text ) );\n\t} );\n\n\tmatchedWords = matchedWords.sort( function( a, b ) {\n\t\tif ( a.index < b.index ) {\n\t\t\treturn -1;\n\t\t}\n\t\tif ( a.index > b.index ) {\n\t\t\treturn 1;\n\t\t}\n\t\treturn 0;\n\t} );\n\n\treturn matchedWords;\n};\n\nexport {\n\tgetIndicesByWord,\n\tgetIndicesByWordList,\n\tfilterIndices,\n\tsortIndices,\n\tgetIndicesByWordListSorted,\n};\n\nexport default {\n\tgetIndicesByWord,\n\tgetIndicesByWordList,\n\tfilterIndices,\n\tsortIndices,\n\tgetIndicesByWordListSorted,\n};\n"],"mappings":"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","ignoreList":[]}

package/build/languageProcessing/helpers/word/markWordsInSentences.js

@@ -0,0 +1,177 @@
+import matchWords from "../match/matchTextWithArray";
+import arrayToRegex from "../regex/createRegexFromArray";
+import addMark from "../../../markers/addMarkSingleWord";
+import Mark from "../../../values/Mark";
+import { escapeRegExp } from "lodash";
+import getAnchorsFromText from "../link/getAnchorsFromText";
+import { SINGLE_QUOTES_ARRAY, SINGLE_QUOTES_REGEX } from "../sanitize/quotes";
+
+// Regex to deconstruct an anchor into open tag, content and close tag.
+const anchorDeconstructionRegex = /(<a[\s]+[^>]+>)([^]*?)(<\/a>)/;
+
+/**
+ * Deconstructs an anchor to the opening tag and the content. The content is the anchor text.
+ * We don't return the closing tag since the value would always be the same, i.e. </a>.
+ *
+ * @param {string} anchor An anchor of the shape <a ...>...</a>.
+ *
+ * @returns {object} An object containing the opening tag and the content.
+ */
+export const deConstructAnchor = function (anchor) {
+  // The const array mirrors the anchorDeconstructionRegex, using a comma to access the first element without a name.
+  const [, openTag, content] = anchor.match(anchorDeconstructionRegex);
+  return {
+    openTag: openTag,
+    content: content
+  };
+};
+
+/**
+ * Reconstructs an anchor from an openTag, the content, and the closing tag.
+ *
+ * @param {string} openTag The opening tag of the anchor. Must be of the shape <a ...>.
+ * @param {string} content The text of the anchor.
+ *
+ * @returns {string} An anchor.
+ */
+export const reConstructAnchor = function (openTag, content) {
+  return `${openTag}${content}</a>`;
+};
+
+/**
+ * Gets the anchors and marks the anchors' text if the words are found in it.
+ *
+ * @param {string} sentence The sentence to retrieve the anchors from.
+ * @param {RegExp} wordsRegex The regex of the words.
+ *
+ * @returns {Object} The anchors and the marked anchors.
+ */
+const getMarkedAnchors = function (sentence, wordsRegex) {
+  // Retrieve the anchors.
+  const anchors = getAnchorsFromText(sentence);
+  // For every anchor, apply the markings only to the anchor tag.
+  const markedAnchors = anchors.map(anchor => {
+    // Retrieve the open tag and the content/anchor text.
+    const {
+      openTag,
+      content
+    } = deConstructAnchor(anchor);
+
+    // Apply the marking to the anchor text if there is a match.
+    const markedAnchorText = content.replace(wordsRegex, x => addMark(x));
+
+    // Create a new anchor tag with a (marked) anchor text.
+    return reConstructAnchor(openTag, markedAnchorText);
+  });
+  return {
+    anchors,
+    markedAnchors
+  };
+};
+
+/**
+ * Adds marks to a sentence and merges marks if those are only separated by a space
+ * (e.g., if highlighting words "ballet" and "shoes" in a sentence "I have a lot of ballet shoes and other paraphernalia."
+ * the marks will be put around "ballet shoes" together, not "`ballet` `shoes`".)
+ *
+ * @param {string}    sentence               The sentence to mark words in.
+ * @param {[string]}  wordsFoundInSentence   The words to mark in the sentence.
+ * @param {function}  matchWordCustomHelper  The language-specific helper function to match word in text.
+ *
+ * @returns {string} The sentence with marks.
+ */
+export const collectMarkingsInSentence = function (sentence, wordsFoundInSentence, matchWordCustomHelper) {
+  const allWordsFound = [];
+  wordsFoundInSentence.forEach(word => {
+    // Check if the word in `wordsFoundInSentence` contains single quote(s).
+    const matchedSingleQuotes = word.match(SINGLE_QUOTES_REGEX);
+    if (matchedSingleQuotes) {
+      /*
+       * If yes, make all different combinations of the word with different types of single quotes in the array.
+       * Later, a regex will be created for all words that were found in the sentence including their variations.
+       *
+       * For example:
+       * `wordsFoundInSentence`: [ "red", "panda’s" ]
+       * For the word "panda’s", we'll create the following variations:
+       * "panda's", "panda‘s", "panda’s", "panda‛s", "panda`s", "panda‹s", "panda›s"
+       * And those variations will be added to `allWordsFound`.
+       */
+      SINGLE_QUOTES_ARRAY.forEach(singleQuote => {
+        matchedSingleQuotes.forEach(matchedSingleQuote => {
+          allWordsFound.push(escapeRegExp(word.replace(new RegExp(matchedSingleQuote, "g"), singleQuote)));
+        });
+      });
+    } else {
+      allWordsFound.push(escapeRegExp(word));
+    }
+  });
+
+  // If a language has a custom helper to match words, we disable the word boundary when creating the regex.
+  const wordsRegex = matchWordCustomHelper ? arrayToRegex(allWordsFound, true) : arrayToRegex(allWordsFound);
+
+  // Retrieve the anchors and mark the anchors' text if the words are found in the anchors' text.
+  const {
+    anchors,
+    markedAnchors
+  } = getMarkedAnchors(sentence, wordsRegex);
+  let markup = sentence.replace(wordsRegex, function (x) {
+    return addMark(x);
+  });
+
+  /**
+   * In 'markup', we apply the markings also inside the anchor's attribute if there is a match, on top of
+   * marking the anchor's text.
+   * The step below is to replace the incorrectly marked anchors with the marked anchors that we want:
+   * where the markings are only applied in the anchor's text.
+   */
+  if (anchors.length > 0) {
+    const markupAnchors = getAnchorsFromText(markup);
+    for (let i = 0; i < markupAnchors.length; i++) {
+      markup = markup.replace(markupAnchors[i], markedAnchors[i]);
+    }
+  }
+
+  /*
+   * If two marks are separated by only a space, remove the closing tag of the first mark and the opening tag of the
+   * second mark so that the two marks can be combined into one.
+   */
+  return markup.replace(new RegExp("</yoastmark> <yoastmark class='yoast-text-mark'>", "ig"), " ");
+};
+
+/**
+ * Adds marks to a sentence.
+ *
+ * @param {string}      sentence                The sentence in which we want to apply highlighting.
+ * @param {Array}       wordsFoundInSentence    The words to highlight in a sentence.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ * @returns {Mark[]}  The array of Mark objects of each sentence.
+ */
+export function markWordsInASentence(sentence, wordsFoundInSentence, matchWordCustomHelper) {
+  return [new Mark({
+    original: sentence,
+    marked: collectMarkingsInSentence(sentence, wordsFoundInSentence, matchWordCustomHelper)
+  })];
+}
+
+/**
+ * Adds marks to an array of sentences.
+ *
+ * @param {[string]}    wordsToMark The words to mark.
+ * @param {[string]}    sentences   The sentences in which to mark these words.
+ * @param {string}      locale      The locale.
+ * @param {function}    matchWordCustomHelper   The language-specific helper function to match word in text.
+ *
+ * @returns {[string]} The sentences with marks.
+ */
+export function markWordsInSentences(wordsToMark, sentences, locale, matchWordCustomHelper) {
+  let wordsFoundInSentence = [];
+  let markings = [];
+  sentences.forEach(function (sentence) {
+    wordsFoundInSentence = matchWords(sentence, wordsToMark, locale, matchWordCustomHelper).matches;
+    if (wordsFoundInSentence.length > 0) {
+      markings = markings.concat(markWordsInASentence(sentence, wordsFoundInSentence, matchWordCustomHelper));
+    }
+  });
+  return markings;
+}
+//# sourceMappingURL=markWordsInSentences.js.map