proskomma-core 0.9.7 → 0.9.12

package/test/code/main/cv_indexes.cjs

@@ -0,0 +1,189 @@
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'CV Indexes';
+
+const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk2 = pkWithDoc('../test_data/usfm/web_psa51.usfm', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk3 = pkWithDoc('../test_data/usfm/verse_range.usfm', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const rangeQuery = 'startBlock startItem endBlock endItem nextToken ' +
+  'items { type subType payload } ' +
+  'tokens { type subType payload } ' +
+  'wordLikes: tokens(withSubTypes:"wordLike") { type subType payload } ' +
+  'text normalized: text(normalizeSpace:true) dumpItems';
+const cvQuery = `{ chapter verseNumbers { number range } verseRanges { range numbers } verses { verse { ${rangeQuery} verseRange } } }`;
+const cQuery = `{ chapter ${rangeQuery} }`;
+const cvCharsQuery = `{ chapter verses { verse { tokens(includeContext:true withChars:["Ruth", "Boaz", "Naomi"]) { payload position} text } } }`;
+
+const checkIndexFields = (t, index) => {
+  t.ok('startBlock' in index);
+  t.ok('endBlock' in index);
+  t.ok('startItem' in index);
+  t.ok('endItem' in index);
+  t.ok('nextToken' in index);
+  t.ok(index.text.length > 0);
+  t.ok(index.items.length > 0);
+  t.ok(index.tokens.length > 0);
+  t.ok(index.wordLikes.length > 0);
+  t.ok(index.dumpItems.length > 0);
+};
+
+test(
+  `cvIndexes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1 + 10);
+      const query =
+        `{ documents { cvIndexes ${cvQuery} } }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const index = result.data.documents[0].cvIndexes[0];
+      checkIndexFields(t, index.verses[1].verse[0]);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cIndexes (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1 + 10);
+      const query =
+        `{ documents { cIndexes ${cQuery} } }`;
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const index = result.data.documents[0].cIndexes[0];
+      checkIndexFields(t, index);
+      // console.log(JSON.stringify(result.data.documents[0].cIndexes, null, 2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cvIndex (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2 + 10 + 6);
+      let query =
+        `{ documents { cvIndex(chapter:3) ${cvQuery} } }`;
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      let index = result.data.documents[0].cvIndex;
+      t.equal(index.chapter, 3);
+      checkIndexFields(t, index.verses[1].verse[0]);
+      const verseNumbers = result.data.documents[0].cvIndex.verseNumbers;
+      t.equal(verseNumbers.length, 18);
+      t.equal(Math.max(...verseNumbers.map(n => n.number)), 18);
+      t.equal(Math.min(...verseNumbers.map(n => n.number)), 1);
+      query =
+        `{ documents { cvIndex(chapter:9) ${cvQuery} } }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      index = result.data.documents[0].cvIndex;
+      t.equal(index.chapter, 9);
+      t.equal(index.verses.length, 0);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cvIndex v0 (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      let query =
+        `{ documents { cvIndex(chapter:51) ${cvQuery} } }`;
+      let result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const verseNumbers = result.data.documents[0].cvIndex.verseNumbers;
+      t.equal(verseNumbers.length, 20);
+      t.equal(Math.max(...verseNumbers.map(n => n.number)), 19);
+      t.equal(Math.min(...verseNumbers.map(n => n.number)), 0);
+      // console.log(JSON.stringify(result.data.documents[0].cvIndex.verses.map(v => v.verse[0].dumpItems), null, 2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cvIndex verseRanges (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      let query =
+        `{ documents { cvIndex(chapter:1) ${cvQuery} } }`;
+      let result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      // console.log(JSON.stringify(result.data.documents[0].cvIndex.verseRanges, null, 2));
+      const verseRanges = result.data.documents[0].cvIndex.verseRanges;
+      t.equal(verseRanges.length, 1);
+      t.equal(verseRanges[0].range, '1-2');
+      t.equal(verseRanges[0].numbers.length, 2);
+      t.equal(verseRanges[0].numbers[0], 1);
+      t.equal(verseRanges[0].numbers[1], 2);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cIndex (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(2 + 10 + 3);
+      let query =
+        `{ documents { cIndex(chapter:3) ${cQuery} } }`;
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      let index = result.data.documents[0].cIndex;
+      t.equal(index.chapter, 3);
+      checkIndexFields(t, index);
+      query =
+        `{ documents { cIndex(chapter:9) ${cQuery} } }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      index = result.data.documents[0].cIndex;
+      t.equal(index.chapter, 9);
+      t.equal(index.startBlock, null);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `cvIndexes withChars (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(1);
+      let query =
+        `{ documents { cvIndexes ${cvCharsQuery} } }`;
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      // console.log(JSON.stringify(result.data, null, 2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/cv_navigation.cjs

@@ -0,0 +1,124 @@
+/* eslint-disable no-await-in-loop */
+const test = require('tape');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'cv Navigation';
+
+const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk2 = pkWithDoc('../test_data/usx/web_psa_40_60.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk3 = pkWithDoc('../test_data/usfm/ust_psa_verse_ranges.usfm', {
+  lang: 'eng',
+  abbr: 'ust',
+})[0];
+
+test(
+  `Next/Previous Chapter (${testGroup})`,
+  async function (t) {
+    try {
+      const expected = [
+        ['2', '1', '3'],
+        ['1', null, '2'],
+        ['4', '3', null],
+        ['5', null, null],
+      ];
+      t.plan(3 * expected.length);
+
+      for (const [chap, prev, next] of expected) {
+        const query =
+          '{ documents { nav: cvNavigation(chapter:"%c%" verse:"3") { previousChapter nextChapter } } }'
+            .replace('%c%', chap);
+        const result = await pk.gqlQuery(query);
+        t.equal(result.errors, undefined);
+        const nav = result.data.documents[0].nav;
+        t.equal(nav.previousChapter, prev);
+        t.equal(nav.nextChapter, next);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Next/Previous Verse (${testGroup})`,
+  async function (t) {
+    try {
+      const expected = [
+        [pk, 2, 3, 2, 2, 2, 4],
+        [pk, 1, 22, 1, 21, 2, 1],
+        [pk, 2, 1, 1, 22, 2, 2],
+        [pk, 1, 1, null, null, 1, 2],
+        [pk, 5, 1, null, null, null, null],
+        [pk, 1, 0, null, null, null, null],
+        [pk, 1, 50, null, null, null, null],
+        [pk2, 50, 23, 50, 22, 51, 0],
+        [pk2, 51, 1, 51, 0, 51, 2],
+        [pk2, 51, 0, 50, 23, 51, 1],
+      ];
+      t.plan(5 * expected.length);
+
+      for (const [pros, chap, verse, prevChap, prevVerse, nextChap, nextVerse] of expected) {
+        const query =
+          '{ documents { nav: cvNavigation(chapter:"%c%" verse:"%v%") { previousVerse { chapter verse } nextVerse { chapter verse } } } }'
+            .replace('%c%', chap)
+            .replace('%v%', verse);
+        const result = await pros.gqlQuery(query);
+        t.equal(result.errors, undefined);
+        const nav = result.data.documents[0].nav;
+        t.equal(nav.nextVerse && nav.nextVerse.chapter, nextChap);
+        t.equal(nav.nextVerse && nav.nextVerse.verse, nextVerse);
+        t.equal(nav.previousVerse && nav.previousVerse.chapter, prevChap);
+        t.equal(nav.previousVerse && nav.previousVerse.verse, prevVerse);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Next/Previous VerseRangeVerse (${testGroup})`,
+  async function (t) {
+    try {
+      const expected = [
+        [pk, 2, 3, 2, 2, 2, 4],
+        [pk, 1, 22, 1, 21, 2, 1],
+        [pk, 2, 1, 1, 22, 2, 2],
+        [pk, 1, 1, null, null, 1, 2],
+        [pk, 5, 1, null, null, null, null],
+        [pk, 1, 0, null, null, null, null],
+        [pk, 1, 50, null, null, null, null],
+        [pk2, 50, 23, 50, 22, 51, 0],
+        [pk2, 51, 1, 51, 0, 51, 2],
+        [pk2, 51, 0, 50, 23, 51, 1],
+        [pk3, 150, 4, 150, 2, 150, 6],
+      ];
+      t.plan(5 * expected.length);
+
+      for (const [pros, chap, verse, prevChap, prevVerse, nextChap, nextVerse] of expected) {
+        const query =
+          '{ documents { nav: cvNavigation(chapter:"%c%" verse:"%v%") { previousVerseRangeVerse { chapter verse } nextVerseRangeVerse { chapter verse } } } }'
+            .replace('%c%', chap)
+            .replace('%v%', verse);
+        const result = await pros.gqlQuery(query);
+        t.equal(result.errors, undefined);
+        const nav = result.data.documents[0].nav;
+        t.equal(nav.nextVerseRangeVerse && nav.nextVerseRangeVerse.chapter, nextChap);
+        t.equal(nav.nextVerseRangeVerse && nav.nextVerseRangeVerse.verse, nextVerse);
+        t.equal(nav.previousVerseRangeVerse && nav.previousVerseRangeVerse.chapter, prevChap);
+        t.equal(nav.previousVerseRangeVerse && nav.previousVerseRangeVerse.verse, prevVerse);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

package/test/code/main/document.cjs

@@ -0,0 +1,382 @@
+const path = require('path');
+const test = require('tape');
+const fse = require('fs-extra');
+const deepEqual = require('deep-equal');
+
+const { Proskomma } = require('../../../src/index.cjs');
+
+const { pkWithDoc } = require('../../lib/load.js');
+
+const testGroup = 'Graph Document';
+
+const pk = pkWithDoc('../test_data/usx/web_rut.usx', {
+  lang: 'eng',
+  abbr: 'web',
+})[0];
+
+const pk2 = new Proskomma();
+const fp = '../../test_data/usfm/int.usfm';
+const content = fse.readFileSync(path.resolve(__dirname, fp));
+
+pk2.importUsfmPeriph(
+  { lang: 'eng', abbr: 'abc' },
+  content,
+  {},
+);
+
+const pk3 = pkWithDoc('../test_data/usfm/78-GALspavbl.usfm', {
+  lang: 'spa',
+  abbr: 'vbl',
+})[0];
+
+test(
+  `DocSetId (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(3);
+      const query = '{ documents { docSetId } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('docSetId' in result.data.documents[0]);
+    } catch
+    (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Headers (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const query = '{ documents { headers { key value }  toc: header(id:"toc") } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('headers' in result.data.documents[0]);
+      t.equal(result.data.documents[0].headers.length, 7);
+      t.equal(result.data.documents[0].headers.filter(h => h.key === 'toc')[0].value, 'The Book of Ruth');
+      t.equal(result.data.documents[0].toc, 'The Book of Ruth');
+    } catch
+    (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Headers with accents (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(6);
+      const query = '{ documents { headers { key value }  toc: header(id:"toc") } }';
+      const result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('headers' in result.data.documents[0]);
+      t.equal(result.data.documents[0].headers.length, 5);
+      t.equal(result.data.documents[0].headers.filter(h => h.key === 'toc')[0].value, 'Gálatas');
+      t.equal(result.data.documents[0].toc, 'Gálatas');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `ID Parts (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(14);
+      const query = '{ documents { idParts { type parts part(index:0) nullPart: part(index:9) } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      let idParts = result.data.documents[0].idParts;
+      t.equal(idParts.type, 'book');
+      t.equal(idParts.parts.length, 2);
+      t.equal(idParts.parts[0], 'RUT');
+      t.equal(idParts.part, 'RUT');
+      t.ok(!idParts.nullPart);
+      result = await pk2.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      idParts = result.data.documents[0].idParts;
+      t.equal(idParts.type, 'periph');
+      t.equal(idParts.parts.length, 4);
+      t.equal(idParts.parts[0], 'P00');
+      t.equal(idParts.parts[1], 'INT');
+      t.equal(idParts.parts[2], 'intbible');
+      t.equal(idParts.part, 'P00');
+      t.ok(!idParts.nullPart);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainSequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainSequence { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainSequence' in result.data.documents[0]);
+      t.ok('id' in result.data.documents[0].mainSequence);
+    } catch
+    (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequences (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { sequences { id } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sequences' in result.data.documents[0]);
+      t.ok('id' in result.data.documents[0].sequences[0]);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequences by type and ids (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(11);
+      let query = '{ documents { sequences(types:"main") { id type } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sequences' in result.data.documents[0]);
+      t.equal(result.data.documents[0].sequences.length, 1);
+      const mainSequence = result.data.documents[0].sequences[0];
+      t.equal(mainSequence.type, 'main');
+      const mainId = mainSequence.id;
+      query = `{ documents { sequences(ids:"${mainId}") { id type } } }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sequences' in result.data.documents[0]);
+      t.equal(result.data.documents[0].sequences.length, 1);
+      const foundSequence = result.data.documents[0].sequences[0];
+      t.equal(foundSequence.id, mainId);
+      t.equal(foundSequence.type, 'main');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `Sequence (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(10);
+      let query = '{ documents { mainSequence { id } } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      const mainId = result.data.documents[0].mainSequence.id;
+      query = `{ documents { sequence(id:"${mainId}") { id type } } }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sequence' in result.data.documents[0]);
+      const foundSequence = result.data.documents[0].sequence;
+      t.equal(foundSequence.id, mainId);
+      t.equal(foundSequence.type, 'main');
+      query = `{ documents { sequence(id:"banana") { id type } } }`;
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sequence' in result.data.documents[0]);
+      t.equal(result.data.documents[0].sequence, null);
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainBlocks (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainBlocks { text } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainBlocks' in result.data.documents[0]);
+      t.ok(result.data.documents[0].mainBlocks[0].text.startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainBlocksText (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      const query = '{ documents { mainBlocksText normalized: mainBlocksText(normalizeSpace:true) } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainBlocksText' in result.data.documents[0]);
+      t.ok(result.data.documents[0].mainBlocksText[0].startsWith('In the days when'));
+      t.ok(result.data.documents[0].normalized[0].startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainBlocksItems (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(7);
+      const query = '{ documents { mainBlocksItems { type subType payload } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainBlocksItems' in result.data.documents[0]);
+      t.equal(result.data.documents[0].mainBlocksItems[0][0].payload, 'chapter/1');
+      t.equal(result.data.documents[0].mainBlocksItems[0][1].payload, 'verse/1');
+      t.equal(result.data.documents[0].mainBlocksItems[0][2].payload, 'verses/1');
+      t.equal(result.data.documents[0].mainBlocksItems[0][3].payload, 'In');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainBlocksTokens (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      const query = '{ documents { mainBlocksTokens { type subType payload } } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainBlocksTokens' in result.data.documents[0]);
+      t.equal(result.data.documents[0].mainBlocksTokens[0][0].payload, 'In');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `mainText (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(5);
+      const query = '{ documents { mainText normalized: mainText(normalizeSpace:true) } }';
+      const result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('mainText' in result.data.documents[0]);
+      t.ok(result.data.documents[0].mainText.startsWith('In the days when'));
+      t.ok(result.data.documents[0].normalized.startsWith('In the days when'));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `perf (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      let query = '{ documents { perf } }';
+      let result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('perf' in result.data.documents[0]);
+      let perfJSON;
+      t.doesNotThrow(() => perfJSON = JSON.parse(result.data.documents[0].perf));
+      query = '{ documents { perf(indent:2) } }';
+      result = await pk.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('perf' in result.data.documents[0]);
+      let perfJSON2;
+      t.doesNotThrow(() => perfJSON2 = JSON.parse(result.data.documents[0].perf));
+      t.ok(deepEqual(perfJSON, perfJSON2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `sofria (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(9);
+      let query = '{ documents { sofria } }';
+      let result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sofria' in result.data.documents[0]);
+      let sofriaJSON;
+      t.doesNotThrow(() => sofriaJSON = JSON.parse(result.data.documents[0].sofria));
+      query = '{ documents { sofria(indent:2) } }';
+      result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('sofria' in result.data.documents[0]);
+      let sofriaJSON2;
+      t.doesNotThrow(() => sofriaJSON2 = JSON.parse(result.data.documents[0].sofria));
+      t.ok(deepEqual(sofriaJSON, sofriaJSON2));
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);
+
+test(
+  `usfm (${testGroup})`,
+  async function (t) {
+    try {
+      t.plan(4);
+      let query = '{ documents { usfm } }';
+      let result = await pk3.gqlQuery(query);
+      t.equal(result.errors, undefined);
+      t.ok('documents' in result.data);
+      t.ok('usfm' in result.data.documents[0]);
+
+      let rawUsfm = fse.readFileSync(path.resolve(__dirname, '../../test_data/usfm/78-GALspavbl.usfm')).toString();
+      let tabRawUsfm = rawUsfm.split(/(\\[a-z]+[\d\*]?|\n)/g).filter((e) => e !== '' && e !== ' ' && e !== '\n');
+
+      let outputUsfm = result.data.documents[0].usfm;
+      let tabOutputUsfm = outputUsfm.split(/(\\[a-z]+[\d\*]?|\n)/g).filter((e) => e !== '' && e !== ' ' && e !== '\n');
+
+      let diff = [];
+
+      tabRawUsfm.forEach((elem, i) => {
+        if (!tabOutputUsfm[i] || elem.trim() !== tabOutputUsfm[i].trim()) {
+          diff.push([tabOutputUsfm[i], elem]);
+        }
+      });
+      t.equal(diff.join(''), '');
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);