@lingual/i18n-check 0.8.2 → 0.8.4

package/dist/utils/findInvalidi18nTranslations.test.js

@@ -2,204 +2,204 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const findInvalidi18nTranslations_1 = require("./findInvalidi18nTranslations");
 const flattenTranslations_1 = require("./flattenTranslations");
-const sourceFile = require("../../translations/i18NextMessageExamples/en-us.json");
-const targetFile = require("../../translations/i18NextMessageExamples/de-de.json");
-describe("findInvalid18nTranslations:compareTranslationFiles", () => {
-    it("should return empty array if files are identical", () => {
+const sourceFile = require('../../translations/i18NextMessageExamples/en-us.json');
+const targetFile = require('../../translations/i18NextMessageExamples/de-de.json');
+describe('findInvalid18nTranslations:compareTranslationFiles', () => {
+    it('should return empty array if files are identical', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)(sourceFile), (0, flattenTranslations_1.flattenTranslations)(sourceFile))).toEqual([]);
     });
-    it("should return the invalid keys in the target file", () => {
+    it('should return the invalid keys in the target file', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
             ...sourceFile,
-            "ten.eleven.twelve": "ten eleven twelve",
+            'ten.eleven.twelve': 'ten eleven twelve',
         }), (0, flattenTranslations_1.flattenTranslations)(targetFile))).toEqual([
             {
-                key: "key_with_broken_de",
-                msg: "Error in interpolation: Expected value but received val",
+                key: 'key_with_broken_de',
+                msg: 'Error in interpolation: Expected value but received val',
             },
             {
-                key: "intlNumber_broken_de",
-                msg: "Missing element interpolation",
+                key: 'intlNumber_broken_de',
+                msg: 'Missing element interpolation',
             },
         ]);
     });
-    it("should return an empty array if the strings contain paranthesis that have different content", () => {
+    it('should return an empty array if the strings contain paranthesis that have different content', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)((0, flattenTranslations_1.flattenTranslations)({
-            keyText: "Key(s)",
-        }), (0, flattenTranslations_1.flattenTranslations)({ keyText: "Taste(n)" }))).toEqual([]);
+            keyText: 'Key(s)',
+        }), (0, flattenTranslations_1.flattenTranslations)({ keyText: 'Taste(n)' }))).toEqual([]);
     });
-    it("should return empty array if placeholders are identical but in different positions", () => {
+    it('should return empty array if placeholders are identical but in different positions', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            basic: "added {{this}} and {{that}} should work.",
+            basic: 'added {{this}} and {{that}} should work.',
         }, {
-            basic: "It is {{this}} with different position {{that}}",
+            basic: 'It is {{this}} with different position {{that}}',
         })).toEqual([]);
     });
-    it("should return the invalid key if tags are not identical", () => {
+    it('should return the invalid key if tags are not identical', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            tag: 'This is some <b>bold text</b> and some <i>italic</i> text.',
         }, {
-            tag: "There is some <b>bold text</b> and some other <span>italic</span> text.",
+            tag: 'There is some <b>bold text</b> and some other <span>italic</span> text.',
         })).toEqual([
             {
-                key: "tag",
+                key: 'tag',
                 msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
             },
         ]);
     });
-    it("should return empty array if tags are identical", () => {
+    it('should return empty array if tags are identical', () => {
         expect((0, findInvalidi18nTranslations_1.compareTranslationFiles)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            tag: 'This is some <b>bold text</b> and some <i>italic</i> text.',
         }, {
-            tag: "There is some <b>bold text</b> and some other <i>italic</i> text.",
+            tag: 'There is some <b>bold text</b> and some other <i>italic</i> text.',
         })).toEqual([]);
     });
 });
-describe("findInvalidTranslations", () => {
-    it("should return an empty object if all files have no invalid keys", () => {
+describe('findInvalidTranslations', () => {
+    it('should return an empty object if all files have no invalid keys', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)(sourceFile, { de: sourceFile })).toEqual({});
     });
-    it("should return an object containing the keys for the missing language", () => {
-        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: targetFile })).toEqual({
+    it('should return an object containing the keys for the missing language', () => {
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, { de: targetFile })).toEqual({
             de: [
                 {
-                    key: "key_with_broken_de",
-                    msg: "Error in interpolation: Expected value but received val",
+                    key: 'key_with_broken_de',
+                    msg: 'Error in interpolation: Expected value but received val',
                 },
                 {
-                    key: "intlNumber_broken_de",
-                    msg: "Missing element interpolation",
+                    key: 'intlNumber_broken_de',
+                    msg: 'Missing element interpolation',
                 },
             ],
         });
     });
-    it("should return an object containing the keys for every language with missing key", () => {
-        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
+    it('should return an object containing the keys for every language with missing key', () => {
+        expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, {
             de: targetFile,
             fr: {
-                key_with_broken_de: "Some format {{value, formatname}} and some other format {{value, formatname}}",
+                key_with_broken_de: 'Some format {{value, formatname}} and some other format {{value, formatname}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "key_with_broken_de",
-                    msg: "Error in interpolation: Expected value but received val",
+                    key: 'key_with_broken_de',
+                    msg: 'Error in interpolation: Expected value but received val',
                 },
                 {
-                    key: "intlNumber_broken_de",
-                    msg: "Missing element interpolation",
+                    key: 'intlNumber_broken_de',
+                    msg: 'Missing element interpolation',
                 },
             ],
             fr: [
                 {
-                    key: "key_with_broken_de",
-                    msg: "Unexpected interpolation element",
+                    key: 'key_with_broken_de',
+                    msg: 'Unexpected interpolation element',
                 },
             ],
         });
     });
-    it("should find invalid interval", () => {
+    it('should find invalid interval', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            key1_interval: "(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];",
+            key1_interval: '(1)[one item];(2-7)[a few items];(7-inf)[a lot of items];',
         }, {
             de: {
-                key1_interval: "(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];",
+                key1_interval: '(1-2)[one or two items];(3-7)[a few items];(7-inf)[a lot of items];',
             },
         })).toEqual({
             de: [
                 {
-                    key: "key1_interval",
-                    msg: "Error in plural: Expected 1 but received 1-2, Error in plural: Expected 2-7 but received 3-7",
+                    key: 'key1_interval',
+                    msg: 'Error in plural: Expected 1 but received 1-2, Error in plural: Expected 2-7 but received 3-7',
                 },
             ],
         });
     });
-    it("should find invalid nested interpolation", () => {
+    it('should find invalid nested interpolation', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            "tree.one": "added {{something}}",
+            'tree.one': 'added {{something}}',
         }, {
             de: {
-                "tree.one": "added {{somethings}}",
+                'tree.one': 'added {{somethings}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "tree.one",
-                    msg: "Error in interpolation: Expected something but received somethings",
+                    key: 'tree.one',
+                    msg: 'Error in interpolation: Expected something but received somethings',
                 },
             ],
         });
     });
-    it("should find invalid relative time formatting", () => {
+    it('should find invalid relative time formatting', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            intlRelativeTimeWithOptionsExplicit: "Lorem {{val, relativetime(range: quarter; style: narrow;)}}",
+            intlRelativeTimeWithOptionsExplicit: 'Lorem {{val, relativetime(range: quarter; style: narrow;)}}',
         }, {
             de: {
-                intlRelativeTimeWithOptionsExplicit: "Lorem {{val, relativetime(range: quarter; style: long;)}}",
+                intlRelativeTimeWithOptionsExplicit: 'Lorem {{val, relativetime(range: quarter; style: long;)}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "intlRelativeTimeWithOptionsExplicit",
-                    msg: "Error in interpolation: Expected relativetime(range: quarter; style: narrow;) but received relativetime(range: quarter; style: long;)",
+                    key: 'intlRelativeTimeWithOptionsExplicit',
+                    msg: 'Error in interpolation: Expected relativetime(range: quarter; style: narrow;) but received relativetime(range: quarter; style: long;)',
                 },
             ],
         });
     });
-    it("should find invalid key with options", () => {
+    it('should find invalid key with options', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            keyWithOptions: "Some format {{value, formatname(option1Name: option1Value; option2Name: option2Value)}}",
+            keyWithOptions: 'Some format {{value, formatname(option1Name: option1Value; option2Name: option2Value)}}',
         }, {
             de: {
-                keyWithOptions: "Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}",
+                keyWithOptions: 'Some format {{value, formatname(option3Name: option3Value; option4Name: option4Value)}}',
             },
         })).toEqual({
             de: [
                 {
-                    key: "keyWithOptions",
-                    msg: "Error in interpolation: Expected formatname(option1Name: option1Value; option2Name: option2Value) but received formatname(option3Name: option3Value; option4Name: option4Value)",
+                    key: 'keyWithOptions',
+                    msg: 'Error in interpolation: Expected formatname(option1Name: option1Value; option2Name: option2Value) but received formatname(option3Name: option3Value; option4Name: option4Value)',
                 },
             ],
         });
     });
-    it("should find invalid nesting", () => {
+    it('should find invalid nesting', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            nesting1: "1 $t(nesting2)",
+            nesting1: '1 $t(nesting2)',
         }, {
             de: {
-                nesting1: "1 $t(nesting3)",
+                nesting1: '1 $t(nesting3)',
             },
         })).toEqual({
             de: [
                 {
-                    key: "nesting1",
-                    msg: "Error in nesting: Expected nesting2 but received nesting3",
+                    key: 'nesting1',
+                    msg: 'Error in nesting: Expected nesting2 but received nesting3',
                 },
             ],
         });
     });
-    it("should find invalid tags", () => {
+    it('should find invalid tags', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            tag: "This is some <b>bold text</b> and some <i>italic</i> text.",
+            tag: 'This is some <b>bold text</b> and some <i>italic</i> text.',
         }, {
             de: {
-                tag: "There is some <b>bold text</b> and some other <span>text inside a span</span>!",
+                tag: 'There is some <b>bold text</b> and some other <span>text inside a span</span>!',
             },
         })).toEqual({
             de: [
                 {
-                    key: "tag",
+                    key: 'tag',
                     msg: 'Expected tag "</i>" but received "</span>", Expected tag "<i>" but received "<span>"',
                 },
             ],
         });
     });
-    it("should recognize special characters", () => {
+    it('should recognize special characters', () => {
         expect((0, findInvalidi18nTranslations_1.findInvalid18nTranslations)({
-            key: "Test < {{a}} and > {{max_a}}",
+            key: 'Test < {{a}} and > {{max_a}}',
         }, {
             de: {
-                key: "Test < {{a}} und > {{max_a}}",
+                key: 'Test < {{a}} und > {{max_a}}',
             },
         })).toEqual({});
     });

package/dist/utils/findMissingKeys.d.ts

@@ -1,3 +1,3 @@
-import { Translation } from "../types";
+import { Translation } from '../types';
 export declare const findMissingKeys: (source: Translation, targets: Record<string, Translation>) => Record<string, string[]>;
 export declare const compareTranslationFiles: (a: Translation, b: Translation) => string[];

package/dist/utils/findMissingKeys.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareTranslationFiles = exports.findMissingKeys = void 0;
 const findMissingKeys = (source, targets) => {
-    let differences = {};
+    const differences = {};
     for (const [lang, file] of Object.entries(targets)) {
         const result = (0, exports.compareTranslationFiles)(source, file);
         if (result.length > 0) {
@@ -13,7 +13,7 @@ const findMissingKeys = (source, targets) => {
 };
 exports.findMissingKeys = findMissingKeys;
 const compareTranslationFiles = (a, b) => {
-    let diffs = [];
+    const diffs = [];
     for (const key in a) {
         const counterKey = b[key];
         if (!counterKey) {

package/dist/utils/findMissingKeys.test.js

@@ -2,40 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const findMissingKeys_1 = require("./findMissingKeys");
 const sourceFile = {
-    "one.two.three": "one two three",
-    "four.five.six": "four five six",
-    "seven.eight.nine": "seven eight nine",
+    'one.two.three': 'one two three',
+    'four.five.six': 'four five six',
+    'seven.eight.nine': 'seven eight nine',
 };
 const secondaryFile = {
-    "one.two.three": "one two three",
-    "four.five.six": "four five six",
-    "seven.eight.nine": "seven eight nine",
+    'one.two.three': 'one two three',
+    'four.five.six': 'four five six',
+    'seven.eight.nine': 'seven eight nine',
 };
-describe("findMissingKeys:compareTranslationFiles", () => {
-    it("should return empty array if files are identical", () => {
+describe('findMissingKeys:compareTranslationFiles', () => {
+    it('should return empty array if files are identical', () => {
         expect((0, findMissingKeys_1.compareTranslationFiles)(sourceFile, secondaryFile)).toEqual([]);
     });
-    it("should return the missing keys in the secondary file", () => {
-        expect((0, findMissingKeys_1.compareTranslationFiles)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, secondaryFile)).toEqual(["ten.eleven.twelve"]);
+    it('should return the missing keys in the secondary file', () => {
+        expect((0, findMissingKeys_1.compareTranslationFiles)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, secondaryFile)).toEqual(['ten.eleven.twelve']);
     });
 });
-describe("findMissingKeys", () => {
-    it("should return an empty object if all files have no missing keys", () => {
+describe('findMissingKeys', () => {
+    it('should return an empty object if all files have no missing keys', () => {
         expect((0, findMissingKeys_1.findMissingKeys)(sourceFile, { de: secondaryFile })).toEqual({});
     });
-    it("should return an object containing the keys for the missing language", () => {
-        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, { de: secondaryFile })).toEqual({ de: ["ten.eleven.twelve"] });
+    it('should return an object containing the keys for the missing language', () => {
+        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, { de: secondaryFile })).toEqual({ de: ['ten.eleven.twelve'] });
     });
-    it("should return an object containing the keys for every language with missing key", () => {
-        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, "ten.eleven.twelve": "ten eleven twelve" }, {
+    it('should return an object containing the keys for every language with missing key', () => {
+        expect((0, findMissingKeys_1.findMissingKeys)({ ...sourceFile, 'ten.eleven.twelve': 'ten eleven twelve' }, {
             de: secondaryFile,
             fr: {
-                "four.five.six": "four five six",
-                "seven.eight.nine": "seven eight nine",
+                'four.five.six': 'four five six',
+                'seven.eight.nine': 'seven eight nine',
             },
         })).toEqual({
-            de: ["ten.eleven.twelve"],
-            fr: ["one.two.three", "ten.eleven.twelve"],
+            de: ['ten.eleven.twelve'],
+            fr: ['one.two.three', 'ten.eleven.twelve'],
         });
     });
 });

package/dist/utils/flattenTranslations.d.ts

@@ -1,3 +1,3 @@
-import { Translation } from "../types";
+import { Translation } from '../types';
 export declare const flattenTranslations: (translations: Translation) => Translation;
 export declare const flattenEntry: (entry: Translation, keys?: string[]) => Translation;

package/dist/utils/flattenTranslations.js

@@ -12,10 +12,10 @@ exports.flattenTranslations = flattenTranslations;
  * Top level search for any objects
  */
 const hasNestedDefinitions = (translations) => {
-    return Object.values(translations).find((translation) => typeof translation === "object");
+    return Object.values(translations).find((translation) => typeof translation === 'object');
 };
 const isTranslationObject = (entry) => {
-    return typeof entry === "object";
+    return typeof entry === 'object';
 };
 const flattenEntry = (entry, keys = []) => {
     const result = {};
@@ -26,7 +26,7 @@ const flattenEntry = (entry, keys = []) => {
     for (const [k, v] of entries) {
         Object.assign(result, isTranslationObject(v)
             ? (0, exports.flattenEntry)(v, [...keys, String(k)])
-            : { [[...keys, String(k)].join(".")]: v });
+            : { [[...keys, String(k)].join('.')]: v });
     }
     return result;
 };

package/dist/utils/flattenTranslations.test.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const flattenTranslations_1 = require("./flattenTranslations");
-const flatStructure = require("../../translations/en-us.json");
-const nestedStructure = require("../../translations/flattenExamples/en-us.json");
+const flatStructure = require('../../translations/en-us.json');
+const nestedStructure = require('../../translations/flattenExamples/en-us.json');
 const expectedFlatStructure = {
-    "test.drive.one": "testing one",
-    "test.drive.two": "testing two",
-    "other.nested.three": "testing three",
-    "other.nested.deep.more.final": "nested translation",
+    'test.drive.one': 'testing one',
+    'test.drive.two': 'testing two',
+    'other.nested.three': 'testing three',
+    'other.nested.deep.more.final': 'nested translation',
 };
-describe("flattenTranslations", () => {
-    it("should do nothing if the file structure is flat", () => {
+describe('flattenTranslations', () => {
+    it('should do nothing if the file structure is flat', () => {
         expect((0, flattenTranslations_1.flattenTranslations)(flatStructure)).toEqual(flatStructure);
     });
-    describe("flattenEntry", () => {
-        it("should flatten a nested object", () => {
+    describe('flattenEntry', () => {
+        it('should flatten a nested object', () => {
             expect((0, flattenTranslations_1.flattenEntry)({
                 a: {
-                    b: { c: "one" },
+                    b: { c: 'one' },
                 },
-            })).toEqual({ "a.b.c": "one" });
+            })).toEqual({ 'a.b.c': 'one' });
         });
     });
-    it("should do nothing if the file structure is flat", () => {
+    it('should do nothing if the file structure is flat', () => {
         expect((0, flattenTranslations_1.flattenTranslations)(nestedStructure)).toEqual(expectedFlatStructure);
     });
 });

package/dist/utils/i18NextParser.d.ts

@@ -1,36 +1,36 @@
 export type MessageFormatElement = {
-    type: "text";
+    type: 'text';
     content: string;
 } | {
-    type: "interpolation";
+    type: 'interpolation';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "interpolation_unescaped";
+    type: 'interpolation_unescaped';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "nesting";
+    type: 'nesting';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "plural";
+    type: 'plural';
     raw: string;
     prefix: string;
     suffix: string;
     content: string;
     variable: string;
 } | {
-    type: "tag";
+    type: 'tag';
     raw: string;
     voidElement: boolean;
 };

package/dist/utils/i18NextParser.js

@@ -2,13 +2,13 @@
 //  Based on https://github.com/i18next/i18next-translation-parser/blob/v1.0.0/src/parse.js
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = void 0;
-const REGEXP = new RegExp("({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)(?=\\[)|<[^>]+>)", "g");
-const DOUBLE_BRACE = "{{";
-const $_T_BRACE = "$t{";
-const $_T_PARENTHESIS = "$t(";
-const OPEN_PARENTHESIS = "(";
-const OPEN_TAG = "<";
-const CLOSE_TAG = "</";
+const REGEXP = new RegExp('({{[^}]+}}|\\$t{[^}]+}|\\$t\\([^\\)]+\\)|\\([0-9\\-inf]+\\)(?=\\[)|<[^>]+>)', 'g');
+const DOUBLE_BRACE = '{{';
+const $_T_BRACE = '$t{';
+const $_T_PARENTHESIS = '$t(';
+const OPEN_PARENTHESIS = '(';
+const OPEN_TAG = '<';
+const CLOSE_TAG = '</';
 const parse = (input) => {
     let ast = [];
     ast = parseInput([input]);
@@ -21,15 +21,15 @@ const parseInput = (input) => {
     }
     let ast = [];
     input.forEach((element) => {
-        const elements = element.split(REGEXP).filter((element) => element !== "");
+        const elements = element.split(REGEXP).filter((element) => element !== '');
         const result = elements.reduce((acc, match) => {
-            if (match.indexOf("{{-") === 0) {
+            if (match.indexOf('{{-') === 0) {
                 const content = match.substring(3, match.length - 2);
                 acc.push({
-                    type: "interpolation_unescaped",
+                    type: 'interpolation_unescaped',
                     raw: match,
-                    prefix: "{{-",
-                    suffix: "}}",
+                    prefix: '{{-',
+                    suffix: '}}',
                     content,
                     variable: content.trim(),
                 });
@@ -37,10 +37,10 @@ const parseInput = (input) => {
             else if (match.indexOf(DOUBLE_BRACE) === 0) {
                 const content = match.substring(2, match.length - 2);
                 acc.push({
-                    type: "interpolation",
+                    type: 'interpolation',
                     raw: match,
-                    prefix: "{{",
-                    suffix: "}}",
+                    prefix: '{{',
+                    suffix: '}}',
                     content,
                     variable: content.trim(),
                 });
@@ -48,10 +48,10 @@ const parseInput = (input) => {
             else if (match.indexOf($_T_BRACE) === 0) {
                 const content = match.substring(3, match.length - 1);
                 acc.push({
-                    type: "nesting",
+                    type: 'nesting',
                     raw: match,
-                    prefix: "$t{",
-                    suffix: "}",
+                    prefix: '$t{',
+                    suffix: '}',
                     content,
                     variable: content.trim(),
                 });
@@ -59,10 +59,10 @@ const parseInput = (input) => {
             else if (match.indexOf($_T_PARENTHESIS) === 0) {
                 const content = match.substring(3, match.length - 1);
                 acc.push({
-                    type: "nesting",
+                    type: 'nesting',
                     raw: match,
-                    prefix: "$t(",
-                    suffix: ")",
+                    prefix: '$t(',
+                    suffix: ')',
                     content,
                     variable: content.trim(),
                 });
@@ -71,30 +71,30 @@ const parseInput = (input) => {
                 /\([0-9\-inf]+\)/.test(match)) {
                 const content = match.substring(1, match.length - 1);
                 acc.push({
-                    type: "plural",
+                    type: 'plural',
                     raw: match,
-                    prefix: "(",
-                    suffix: ")",
+                    prefix: '(',
+                    suffix: ')',
                     content,
                     variable: content.trim(),
                 });
             }
             else if (match.indexOf(CLOSE_TAG) === 0) {
                 acc.push({
-                    type: "tag",
+                    type: 'tag',
                     raw: match,
-                    voidElement: match.substring(match.length - 2) === "/>",
+                    voidElement: match.substring(match.length - 2) === '/>',
                 });
             }
             else if (match.indexOf(OPEN_TAG) === 0 && /<[^\s]+/.test(match)) {
                 acc.push({
-                    type: "tag",
+                    type: 'tag',
                     raw: match,
-                    voidElement: match.substring(match.length - 2) === "/>",
+                    voidElement: match.substring(match.length - 2) === '/>',
                 });
             }
             else {
-                acc.push({ type: "text", content: match });
+                acc.push({ type: 'text', content: match });
             }
             return acc;
         }, []);