@digigov/text-search 1.2.0-85c27c19 → 1.2.0-b4cd6916

package/cjs/search/lang/gr/encoder/index.js

@@ -21,15 +21,18 @@ __export(encoder_exports, {
   encodeGreek: () => encodeGreek
 });
 module.exports = __toCommonJS(encoder_exports);
-var import_normalization_map = require("./normalization-map");
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+var import_normalization_map = require("@digigov/text-search/search/lang/gr/normalization-map");
+const whitespaceRegex = new RegExp("[p{Z}p{S}p{P}p{C}]+", "u");
+const diacriticsRegex = new RegExp("[\u0300-\u036F]", "g");
 const greekCharsRegex = new RegExp(
   Object.keys(import_normalization_map.greekToGreeklishMap).join("|"),
   "igu"
 );
 function encodeGreek(str) {
-  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(greekCharsRegex, (match) => import_normalization_map.greekToGreeklishMap[match]).split(whitespaceRegex);
+  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(
+    greekCharsRegex,
+    (match) => match in import_normalization_map.greekToGreeklishMap ? import_normalization_map.greekToGreeklishMap[match] : match
+  ).split(whitespaceRegex);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/cjs/search/lang/gr/encoder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/search/lang/gr/encoder.ts"],
-  "sourcesContent": ["import { greekToGreeklishMap } from './normalization-map';\n\nconst whitespaceRegex = /[\\p{Z}\\p{S}\\p{P}\\p{C}]+/u;\nconst diacriticsRegex = /[\\u0300-\\u036f]/g;\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])\n    .split(whitespaceRegex);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAAoC;AAEpC,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AACxB,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,4CAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B,QAAQ,iBAAiB,CAAC,UAAW,6CAA4B,KAAK,CAAC,EACvE,MAAM,eAAe;AAC1B;",
+  "sourcesContent": ["import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';\n\nconst whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');\nconst diacriticsRegex = new RegExp('[\\u0300-\\u036f]', 'g');\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) =>\n      match in greekToGreeklishMap\n        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]\n        : match\n    )\n    .split(whitespaceRegex);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAAoC;AAEpC,MAAM,kBAAkB,IAAI,OAAO,uBAAuB,GAAG;AAC7D,MAAM,kBAAkB,IAAI,OAAO,mBAAmB,GAAG;AACzD,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,4CAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B;AAAA,IAAQ;AAAA,IAAiB,CAAC,UACzB,SAAS,+CACL,6CAAoB,KAAyC,IAC7D;AAAA,EACN,EACC,MAAM,eAAe;AAC1B;",
   "names": []
 }

package/index.js

@@ -1,4 +1,4 @@
-/** @license Digigov v1.2.0-85c27c19
+/** @license Digigov v1.2.0-b4cd6916
  *
  * This source code is licensed under the BSD-2-Clause license found in the
  * LICENSE file in the root directory of this source tree.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digigov/text-search",
-  "version": "1.2.0-85c27c19",
+  "version": "1.2.0-b4cd6916",
   "description": "@digigov text-search",
   "author": "GRNET Developers <devs@lists.grnet.gr>",
   "license": "BSD-2-Clause",

package/search/lang/gr/encoder/index.js

@@ -1,12 +1,15 @@
-import { greekToGreeklishMap } from "./normalization-map";
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+import { greekToGreeklishMap } from "@digigov/text-search/search/lang/gr/normalization-map";
+const whitespaceRegex = new RegExp("[p{Z}p{S}p{P}p{C}]+", "u");
+const diacriticsRegex = new RegExp("[\u0300-\u036F]", "g");
 const greekCharsRegex = new RegExp(
   Object.keys(greekToGreeklishMap).join("|"),
   "igu"
 );
 function encodeGreek(str) {
-  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(greekCharsRegex, (match) => greekToGreeklishMap[match]).split(whitespaceRegex);
+  return ("" + str).toLowerCase().normalize("NFD").replace(diacriticsRegex, "").replace(
+    greekCharsRegex,
+    (match) => match in greekToGreeklishMap ? greekToGreeklishMap[match] : match
+  ).split(whitespaceRegex);
 }
 export {
   encodeGreek

package/search/lang/gr/encoder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/search/lang/gr/encoder.ts"],
-  "sourcesContent": ["import { greekToGreeklishMap } from './normalization-map';\n\nconst whitespaceRegex = /[\\p{Z}\\p{S}\\p{P}\\p{C}]+/u;\nconst diacriticsRegex = /[\\u0300-\\u036f]/g;\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])\n    .split(whitespaceRegex);\n}\n"],
-  "mappings": "AAAA,SAAS,2BAA2B;AAEpC,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AACxB,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,mBAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B,QAAQ,iBAAiB,CAAC,UAAW,oBAA4B,KAAK,CAAC,EACvE,MAAM,eAAe;AAC1B;",
+  "sourcesContent": ["import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';\n\nconst whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');\nconst diacriticsRegex = new RegExp('[\\u0300-\\u036f]', 'g');\nconst greekCharsRegex = new RegExp(\n  Object.keys(greekToGreeklishMap).join('|'),\n  'igu'\n);\n\n/**\n * Encode a string containing greek characters to greeklish\n *\n * This function is used to encode and tokenize a string containing greek characters.\n * It replaces greek characters with their latin counterparts, while also removing\n * any diacritics.\n *\n * @param str - The string to encode\n * @returns An array of encoded words\n */\nexport function encodeGreek(str: string) {\n  return ('' + str)\n    .toLowerCase()\n    .normalize('NFD')\n    .replace(diacriticsRegex, '')\n    .replace(greekCharsRegex, (match) =>\n      match in greekToGreeklishMap\n        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]\n        : match\n    )\n    .split(whitespaceRegex);\n}\n"],
+  "mappings": "AAAA,SAAS,2BAA2B;AAEpC,MAAM,kBAAkB,IAAI,OAAO,uBAAuB,GAAG;AAC7D,MAAM,kBAAkB,IAAI,OAAO,mBAAmB,GAAG;AACzD,MAAM,kBAAkB,IAAI;AAAA,EAC1B,OAAO,KAAK,mBAAmB,EAAE,KAAK,GAAG;AAAA,EACzC;AACF;AAYO,SAAS,YAAY,KAAa;AACvC,UAAQ,KAAK,KACV,YAAY,EACZ,UAAU,KAAK,EACf,QAAQ,iBAAiB,EAAE,EAC3B;AAAA,IAAQ;AAAA,IAAiB,CAAC,UACzB,SAAS,sBACL,oBAAoB,KAAyC,IAC7D;AAAA,EACN,EACC,MAAM,eAAe;AAC1B;",
   "names": []
 }

package/src/hook.spec.ts

@@ -1,6 +1,6 @@
-import { act, renderHook } from '@testing-library/react-hooks';
-import useSearch from './hook';
-import documents from './test-utils/data.json';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import useSearch from '@digigov/text-search/hook';
+import documents from '@digigov/text-search/test-utils/data.json';
 
 describe('loading', () => {
   it('should start when searching', async () => {
@@ -10,33 +10,27 @@ describe('loading', () => {
     expect(result.current.loading).toBe(true);
   });
   it('should stop after search is completed', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
   });
 });
 
 describe('reset', () => {
   it('should change the returned result back to the initial data', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     act(() => result.current.reset());
     expect(result.current.data).toEqual(documents);
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
   });
 });
 
@@ -45,23 +39,20 @@ describe('search', () => {
     const { result } = renderHook(() => useSearch(documents));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual(documents);
   });
   it('should return an empty array when there are no relevant items', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'fajsgsdgsdgsd')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'fajsgsdgsdgsd'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
   });
   it('should return an empty array when relevant field is not indexed', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Anastasia', {
         indexing: {
           fields: ['lastName'], // missing 'firstName'
@@ -72,38 +63,31 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
   });
   it('should return a single result when there is only one relevant item', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Anastasia')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Anastasia'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should return multiple results when there are multiple relevant items', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Kari')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Kari'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBeGreaterThanOrEqual(2);
 
     result.current.data.forEach((item) => {
@@ -112,43 +96,37 @@ describe('search', () => {
     });
   });
   it('should work with a partial query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'anast')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'anast'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should work with nested field if not explicitly stated', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Titanic')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Titanic'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with nested field if explicitly stated', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Titanic', {
         indexing: {
           fields: ['address.city'],
@@ -159,18 +137,17 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with nested ID', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
+    const { result } = renderHook(() =>
       useSearch(documents, 'Titanic', {
         indexing: {
           idKey: 'address.street',
@@ -181,55 +158,48 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult.address).values()).toContain('Titanic');
   });
   it('should work with indexed Greek characters and Latin query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Markos')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Markos'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Μάρκος');
   });
   it('should work with indexed Greek characters and Greek query', async () => {
-    const { result, waitForNextUpdate } = renderHook(() =>
-      useSearch(documents, 'Μάρκος')
-    );
+    const { result } = renderHook(() => useSearch(documents, 'Μάρκος'));
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Μάρκος');
   });
   it('should react to changes in the documents list', async () => {
     const emptyDocuments: typeof documents = [];
-    const { result, rerender, waitForNextUpdate } = renderHook(
+    const { result, rerender } = renderHook(
       ({ documents }) => useSearch(documents, 'Anastasia'),
       {
         initialProps: { documents: emptyDocuments },
@@ -238,8 +208,7 @@ describe('search', () => {
     expect(result.current.loading).toBe(false);
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data).toEqual([]);
 
     rerender({ documents });
@@ -249,18 +218,17 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual([]);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');
   });
   it('should react to changes in the search query', async () => {
-    const { result, rerender, waitForNextUpdate } = renderHook(
+    const { result, rerender } = renderHook(
       ({ query }) => useSearch(documents, query),
       {
         initialProps: { query: '' },
@@ -276,12 +244,11 @@ describe('search', () => {
     act(() => result.current.search());
     expect(result.current.loading).toBe(true);
     expect(result.current.data).toEqual(documents);
-    await waitForNextUpdate();
-    expect(result.current.loading).toBe(false);
+    await waitFor(() => expect(result.current.loading).toBe(false));
     expect(result.current.data.length).toBe(1);
 
     const firstResult = result.current.data[0] as NonNullable<
-      typeof result.current.data[0]
+      (typeof result.current.data)[0]
     >;
     expect(firstResult).toBeDefined();
     expect(Object.values(firstResult).values()).toContain('Anastasia');

package/src/search/lang/gr/encoder.ts

@@ -1,7 +1,7 @@
-import { greekToGreeklishMap } from './normalization-map';
+import { greekToGreeklishMap } from '@digigov/text-search/search/lang/gr/normalization-map';
 
-const whitespaceRegex = /[\p{Z}\p{S}\p{P}\p{C}]+/u;
-const diacriticsRegex = /[\u0300-\u036f]/g;
+const whitespaceRegex = new RegExp('[p{Z}p{S}p{P}p{C}]+', 'u');
+const diacriticsRegex = new RegExp('[\u0300-\u036f]', 'g');
 const greekCharsRegex = new RegExp(
   Object.keys(greekToGreeklishMap).join('|'),
   'igu'
@@ -22,6 +22,10 @@ export function encodeGreek(str: string) {
     .toLowerCase()
     .normalize('NFD')
     .replace(diacriticsRegex, '')
-    .replace(greekCharsRegex, (match) => (greekToGreeklishMap as any)[match])
+    .replace(greekCharsRegex, (match) =>
+      match in greekToGreeklishMap
+        ? greekToGreeklishMap[match as keyof typeof greekToGreeklishMap]
+        : match
+    )
     .split(whitespaceRegex);
 }