diff --git a/src/__tests__/byDisplayValue.test.js b/src/__tests__/byDisplayValue.test.js
index 4bdc743d9..518ced57b 100644
--- a/src/__tests__/byDisplayValue.test.js
+++ b/src/__tests__/byDisplayValue.test.js
@@ -81,10 +81,10 @@ test('findBy queries work asynchronously', async () => {
   );
 
   await expect(
-    findByDisplayValue('Display Value', options)
+    findByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findAllByDisplayValue('Display Value', options)
+    findAllByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
 
   setTimeout(
diff --git a/src/__tests__/byTestId.test.js b/src/__tests__/byTestId.test.js
index 3f8363e5a..630c6e97e 100644
--- a/src/__tests__/byTestId.test.js
+++ b/src/__tests__/byTestId.test.js
@@ -115,8 +115,8 @@ test('getAllByTestId, queryAllByTestId', () => {
 test('findByTestId and findAllByTestId work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
   const { rerender, findByTestId, findAllByTestId } = render(<View />);
-  await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
+  await expect(findByTestId('aTestId', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByTestId('aTestId', {}, options)).rejects.toBeTruthy();
 
   setTimeout(
     () =>
diff --git a/src/__tests__/byText.test.js b/src/__tests__/byText.test.js
index 5b4ff36dd..b64b81c76 100644
--- a/src/__tests__/byText.test.js
+++ b/src/__tests__/byText.test.js
@@ -1,7 +1,14 @@
 // @flow
 import * as React from 'react';
-import { View, Text, TouchableOpacity, Image } from 'react-native';
-import { render } from '..';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  Image,
+  Button,
+  TextInput,
+} from 'react-native';
+import { render, getDefaultNormalizer } from '..';
 
 const MyButton = ({ children, onPress }) => (
   <TouchableOpacity onPress={onPress}>
@@ -88,8 +95,8 @@ test('getAllByText, queryAllByText', () => {
 test('findByText queries work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
   const { rerender, findByText, findAllByText } = render(<View />);
-  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
-  await expect(findAllByText('Some Text', options)).rejects.toBeTruthy();
+  await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
 
   setTimeout(
     () =>
@@ -105,6 +112,39 @@ test('findByText queries work asynchronously', async () => {
   await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
 }, 20000);
 
+describe('findBy options deprecations', () => {
+  let warnSpy;
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  test('findByText queries warn on deprecated use of WaitForOptions', async () => {
+    const options = { timeout: 10 };
+    // mock implementation to avoid warning in the test suite
+    const { rerender, findByText } = render(<View />);
+    await expect(findByText('Some Text', options)).rejects.toBeTruthy();
+
+    setTimeout(
+      () =>
+        rerender(
+          <View>
+            <Text>Some Text</Text>
+          </View>
+        ),
+      20
+    );
+
+    await expect(findByText('Some Text')).resolves.toBeTruthy();
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Use of option "timeout"')
+    );
+  }, 20000);
+});
+
 test.skip('getByText works properly with custom text component', () => {
   function BoldText({ children }) {
     return <Text>{children}</Text>;
@@ -181,7 +221,7 @@ test('queryByText not found', () => {
   ).toBeFalsy();
 });
 
-test('queryByText nested text across multiple <Text> in <Text>', () => {
+test('queryByText does not match nested text across multiple <Text> in <Text>', () => {
   const { queryByText } = render(
     <Text nativeID="1">
       Hello{' '}
@@ -192,7 +232,7 @@ test('queryByText nested text across multiple <Text> in <Text>', () => {
     </Text>
   );
 
-  expect(queryByText('Hello World!')?.props.nativeID).toBe('1');
+  expect(queryByText('Hello World!')).toBe(null);
 });
 
 test('queryByText with nested Text components return the closest Text', () => {
@@ -204,7 +244,7 @@ test('queryByText with nested Text components return the closest Text', () => {
 
   const { queryByText } = render(<NestedTexts />);
 
-  expect(queryByText('My text')?.props.nativeID).toBe('2');
+  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
 test('queryByText with nested Text components each with text return the lowest one', () => {
@@ -217,10 +257,10 @@ test('queryByText with nested Text components each with text return the lowest o
 
   const { queryByText } = render(<NestedTexts />);
 
-  expect(queryByText('My text')?.props.nativeID).toBe('2');
+  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
-test('queryByText nested <CustomText> in <Text>', () => {
+test('queryByText nested deep <CustomText> in <Text>', () => {
   const CustomText = ({ children }) => {
     return <Text>{children}</Text>;
   };
@@ -228,22 +268,171 @@ test('queryByText nested <CustomText> in <Text>', () => {
   expect(
     render(
       <Text>
-        Hello <CustomText>World!</CustomText>
+        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
       </Text>
     ).queryByText('Hello World!')
-  ).toBeTruthy();
+  ).toBe(null);
 });
 
-test('queryByText nested deep <CustomText> in <Text>', () => {
-  const CustomText = ({ children }) => {
-    return <Text>{children}</Text>;
-  };
+test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', () => {
+  const { queryByText: queryByTextFirstCase } = render(
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My </Text>
+      <Text nativeID="3">text</Text>
+    </Text>
+  );
+
+  const { queryByText: queryByTextSecondCase } = render(
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My text for test</Text>
+    </Text>
+  );
 
+  expect(queryByTextFirstCase('My text')).toBe(null);
   expect(
-    render(
-      <Text>
-        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
-      </Text>
-    ).queryByText('Hello World!')
-  ).toBeTruthy();
+    queryByTextSecondCase('My text', { exact: false })?.props.nativeID
+  ).toBe('2');
+});
+
+test('queryAllByText does not match several times the same text', () => {
+  const allMatched = render(
+    <Text nativeID="1">
+      Start
+      <Text nativeID="2">This is a long text</Text>
+    </Text>
+  ).queryAllByText('long text', { exact: false });
+  expect(allMatched.length).toBe(1);
+  expect(allMatched[0].props.nativeID).toBe('2');
+});
+
+test('queryAllByText matches all the matching nodes', () => {
+  const allMatched = render(
+    <Text nativeID="1">
+      Start
+      <Text nativeID="2">This is a long text</Text>
+      <Text nativeID="3">This is another long text</Text>
+    </Text>
+  ).queryAllByText('long text', { exact: false });
+  expect(allMatched.length).toBe(2);
+  expect(allMatched.map((node) => node.props.nativeID)).toEqual(['2', '3']);
+});
+
+describe('supports TextMatch options', () => {
+  test('getByText, getAllByText', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a detail"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('details', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByPlaceholderText, getAllByPlaceholderText', () => {
+    const { getByPlaceholderText, getAllByPlaceholderText } = render(
+      <View>
+        <TextInput placeholder={'Placeholder with details'} />
+        <TextInput placeholder={'Placeholder with a DETAIL'} />
+      </View>
+    );
+
+    expect(getByPlaceholderText('details', { exact: false })).toBeTruthy();
+    expect(getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByDisplayValue, getAllByDisplayValue', () => {
+    const { getByDisplayValue, getAllByDisplayValue } = render(
+      <View>
+        <TextInput value={'Value with details'} />
+        <TextInput value={'Value with a detail'} />
+      </View>
+    );
+
+    expect(getByDisplayValue('details', { exact: false })).toBeTruthy();
+    expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByTestId, getAllByTestId', () => {
+    const { getByTestId, getAllByTestId } = render(
+      <View>
+        <View testID="test" />
+        <View testID="tests id" />
+      </View>
+    );
+    expect(getByTestId('id', { exact: false })).toBeTruthy();
+    expect(getAllByTestId('test', { exact: false })).toHaveLength(2);
+  });
+
+  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a DeTAil"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('DeTaIlS', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+});
+
+describe('Supports normalization', () => {
+  test('trims and collapses whitespace by default', () => {
+    const { getByText } = render(
+      <View>
+        <Text>{`  Text     and
+
+
+        whitespace`}</Text>
+      </View>
+    );
+
+    expect(getByText('Text and whitespace')).toBeTruthy();
+  });
+
+  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
+    const testTextWithWhitespace = `  Text     and
+
+
+        whitespace`;
+    const { getByText } = render(
+      <View>
+        <Text>{testTextWithWhitespace}</Text>
+      </View>
+    );
+
+    expect(
+      getByText(testTextWithWhitespace, {
+        normalizer: getDefaultNormalizer({
+          trim: false,
+          collapseWhitespace: false,
+        }),
+      })
+    ).toBeTruthy();
+  });
+
+  test('normalizer function is customisable', () => {
+    const testText = 'A TO REMOVE text';
+    const normalizerFn = (textToNormalize) =>
+      textToNormalize.replace('TO REMOVE ', '');
+    const { getByText } = render(
+      <View>
+        <Text>{testText}</Text>
+      </View>
+    );
+
+    expect(getByText('A text', { normalizer: normalizerFn })).toBeTruthy();
+  });
 });
diff --git a/src/helpers/byDisplayValue.js b/src/helpers/byDisplayValue.js
index ebb473829..e92bb8fd0 100644
--- a/src/helpers/byDisplayValue.js
+++ b/src/helpers/byDisplayValue.js
@@ -1,19 +1,26 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
+import type { TextMatchOptions } from './byText';
 
-const getTextInputNodeByDisplayValue = (node, value) => {
+const getTextInputNodeByDisplayValue = (
+  node,
+  value,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
     const nodeValue =
       node.props.value !== undefined
         ? node.props.value
         : node.props.defaultValue;
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof value === 'string' ? value === nodeValue : value.test(nodeValue))
+      matches(value, nodeValue, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -22,10 +29,13 @@ const getTextInputNodeByDisplayValue = (node, value) => {
 
 const queryAllByDisplayValue = (
   instance: ReactTestInstance
-): ((displayValue: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByDisplayValueFn(displayValue) {
+): ((
+  displayValue: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByDisplayValueFn(displayValue, queryOptions) {
     return instance.findAll((node) =>
-      getTextInputNodeByDisplayValue(node, displayValue)
+      getTextInputNodeByDisplayValue(node, displayValue, queryOptions)
     );
   };
 
diff --git a/src/helpers/byPlaceholderText.js b/src/helpers/byPlaceholderText.js
index 0414dfb47..e024be4eb 100644
--- a/src/helpers/byPlaceholderText.js
+++ b/src/helpers/byPlaceholderText.js
@@ -1,17 +1,22 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
+import type { TextMatchOptions } from './byText';
 
-const getTextInputNodeByPlaceholderText = (node, placeholder) => {
+const getTextInputNodeByPlaceholderText = (
+  node,
+  placeholder,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof placeholder === 'string'
-        ? placeholder === node.props.placeholder
-        : placeholder.test(node.props.placeholder))
+      matches(placeholder, node.props.placeholder, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -20,10 +25,13 @@ const getTextInputNodeByPlaceholderText = (node, placeholder) => {
 
 const queryAllByPlaceholderText = (
   instance: ReactTestInstance
-): ((placeholder: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByPlaceholderFn(placeholder) {
+): ((
+  placeholder: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByPlaceholderFn(placeholder, queryOptions) {
     return instance.findAll((node) =>
-      getTextInputNodeByPlaceholderText(node, placeholder)
+      getTextInputNodeByPlaceholderText(node, placeholder, queryOptions)
     );
   };
 
diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index f053b2c65..0518448be 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -1,19 +1,23 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
+import type { TextMatchOptions } from './byText';
 
-const getNodeByTestId = (node, testID) => {
-  return typeof testID === 'string'
-    ? testID === node.props.testID
-    : testID.test(node.props.testID);
+const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
+  const { exact, normalizer } = options;
+  return matches(testID, node.props.testID, normalizer, exact);
 };
 
 const queryAllByTestId = (
   instance: ReactTestInstance
-): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByTestIdFn(testId) {
+): ((
+  testId: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByTestIdFn(testId, queryOptions) {
     const results = instance
-      .findAll((node) => getNodeByTestId(node, testId))
+      .findAll((node) => getNodeByTestId(node, testId, queryOptions))
       .filter((element) => typeof element.type === 'string');
 
     return results;
diff --git a/src/helpers/byText.js b/src/helpers/byText.js
index 4d48611b5..11de1113c 100644
--- a/src/helpers/byText.js
+++ b/src/helpers/byText.js
@@ -1,11 +1,19 @@
 // @flow
 import * as React from 'react';
+import { matches } from '../matches';
+import type { NormalizerFn } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
 
-const getChildrenAsText = (children, TextComponent, textContent = []) => {
+export type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+
+const getChildrenAsText = (children, TextComponent) => {
+  const textContent = [];
   React.Children.forEach(children, (child) => {
     if (typeof child === 'string') {
       textContent.push(child);
@@ -26,14 +34,18 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
         return;
       }
 
-      getChildrenAsText(child.props.children, TextComponent, textContent);
+      getChildrenAsText(child.props.children, TextComponent);
     }
   });
 
   return textContent;
 };
 
-const getNodeByText = (node, text: string | RegExp) => {
+const getNodeByText = (
+  node,
+  text: string | RegExp,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { Text } = require('react-native');
     const isTextComponent = filterNodeByType(node, Text);
@@ -41,9 +53,8 @@ const getNodeByText = (node, text: string | RegExp) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return typeof text === 'string'
-          ? text === textToTest
-          : text.test(textToTest);
+        const { exact, normalizer } = options;
+        return matches(text, textToTest, normalizer, exact);
       }
     }
     return false;
@@ -54,9 +65,14 @@ const getNodeByText = (node, text: string | RegExp) => {
 
 const queryAllByText = (
   instance: ReactTestInstance
-): ((text: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByTextFn(text) {
-    const results = instance.findAll((node) => getNodeByText(node, text));
+): ((
+  text: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByTextFn(text, queryOptions) {
+    const results = instance.findAll((node) =>
+      getNodeByText(node, text, queryOptions)
+    );
 
     return results;
   };
diff --git a/src/helpers/errors.js b/src/helpers/errors.js
index 264bbc483..8f4c74c9b 100644
--- a/src/helpers/errors.js
+++ b/src/helpers/errors.js
@@ -53,6 +53,7 @@ export function printDeprecationWarning(functionName: string) {
     return;
   }
 
+  // eslint-disable-next-line no-console
   console.warn(`
   Deprecation Warning:
   Use of ${functionName} is not recommended and will be deleted in future versions of @testing-library/react-native.
diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index dedbfce35..86750605d 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -1,5 +1,6 @@
 // @flow
 import type { WaitForOptions } from '../waitFor';
+import type { TextMatchOptions } from './byText';
 import { findAllByTestId, findByTestId } from './byTestId';
 import { findAllByText, findByText } from './byText';
 import {
@@ -12,36 +13,44 @@ import { throwRenamedFunctionError } from './errors';
 export type FindByAPI = {|
   findAllByDisplayValue: (
     value: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByPlaceholder: () => void,
   findAllByPlaceholderText: (
     placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByTestId: (
     testId: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByText: (
     text: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findByDisplayValue: (
     value: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByPlaceholder: () => void,
   findByPlaceholderText: (
     placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByTestId: (
     testId: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByText: (
     text: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
 |};
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 45f0965b3..c8f3ec918 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -14,18 +14,41 @@ import {
   getByPlaceholderText,
 } from './byPlaceholderText';
 import { getAllByDisplayValue, getByDisplayValue } from './byDisplayValue';
+import type { TextMatchOptions } from './byText';
 
 export type GetByAPI = {|
-  getByText: (text: string | RegExp) => ReactTestInstance,
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance,
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance,
-  getByTestId: (testID: string | RegExp) => ReactTestInstance,
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>,
+  getByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByPlaceholderText: (
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByTestId: (
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getAllByTestId: (
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  getAllByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  getAllByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => Array<ReactTestInstance>,
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>,
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance,
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 35aa7d4b7..5d0a4e1ce 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -2,14 +2,19 @@
 import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
+import type { TextMatchOptions } from './byText';
 
 type QueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
-) => (args: ArgType) => ReturnType;
+) => (args: ArgType, queryOptions?: TextMatchOptions) => ReturnType;
 
 type FindQueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
-) => (args: ArgType, waitForOptions?: WaitForOptions) => Promise<ReturnType>;
+) => (
+  args: ArgType,
+  queryOptions?: TextMatchOptions & WaitForOptions,
+  waitForOptions?: WaitForOptions
+) => Promise<ReturnType>;
 
 type QueryAllByQuery<QueryArg> = QueryFunction<
   QueryArg,
@@ -37,14 +42,43 @@ export type Queries<QueryArg> = {
   findAllBy: FindAllByQuery<QueryArg>,
 };
 
+// The WaitForOptions has been moved to the second option param of findBy* methods with the adding of TextMatchOptions
+// To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn
+const deprecatedKeys: $Keys<WaitForOptions>[] = [
+  'timeout',
+  'interval',
+  'stackTraceError',
+];
+const extractDeprecatedWaitForOptionUsage = (queryOptions?: WaitForOptions) => {
+  if (queryOptions) {
+    const waitForOptions: WaitForOptions = {
+      timeout: queryOptions.timeout,
+      interval: queryOptions.interval,
+      stackTraceError: queryOptions.stackTraceError,
+    };
+    deprecatedKeys.forEach((key) => {
+      if (queryOptions[key]) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `Use of option "${key}" in a findBy* query's second parameter, TextMatchOptions, is deprecated. Please pass this option in the third, WaitForOptions, parameter. 
+Example: 
+
+  findByText(text, {}, { ${key}: ${queryOptions[key].toString()} })`
+        );
+      }
+    });
+    return waitForOptions;
+  }
+};
+
 export function makeQueries<QueryArg>(
   queryAllByQuery: QueryAllByQuery<QueryArg>,
   getMissingError: (args: QueryArg) => string,
   getMultipleError: (args: QueryArg) => string
 ): Queries<QueryArg> {
   function getAllByQuery(instance: ReactTestInstance) {
-    return function getAllFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function getAllFn(args: QueryArg, queryOptions?: TextMatchOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length === 0) {
         throw new ErrorWithStack(getMissingError(args), getAllFn);
@@ -55,8 +89,11 @@ export function makeQueries<QueryArg>(
   }
 
   function queryByQuery(instance: ReactTestInstance) {
-    return function singleQueryFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function singleQueryFn(
+      args: QueryArg,
+      queryOptions?: TextMatchOptions
+    ) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new ErrorWithStack(getMultipleError(args), singleQueryFn);
@@ -71,8 +108,8 @@ export function makeQueries<QueryArg>(
   }
 
   function getByQuery(instance: ReactTestInstance) {
-    return function getFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function getFn(args: QueryArg, queryOptions?: TextMatchOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new ErrorWithStack(getMultipleError(args), getFn);
@@ -89,18 +126,32 @@ export function makeQueries<QueryArg>(
   function findAllByQuery(instance: ReactTestInstance) {
     return function findAllFn(
       args: QueryArg,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(() => getAllByQuery(instance)(args), waitForOptions);
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
+      );
+      return waitFor(() => getAllByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 
   function findByQuery(instance: ReactTestInstance) {
     return function findFn(
       args: QueryArg,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(() => getByQuery(instance)(args), waitForOptions);
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
+      );
+      return waitFor(() => getByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 
diff --git a/src/helpers/queryByAPI.js b/src/helpers/queryByAPI.js
index 80a8558df..064bb3cc8 100644
--- a/src/helpers/queryByAPI.js
+++ b/src/helpers/queryByAPI.js
@@ -1,5 +1,6 @@
 // @flow
 import * as React from 'react';
+import type { TextMatchOptions } from './byText';
 import {
   UNSAFE_getByType,
   UNSAFE_getByProps,
@@ -20,18 +21,32 @@ import {
 } from './errors';
 
 export type QueryByAPI = {|
-  queryByText: (name: string | RegExp) => ReactTestInstance | null,
+  queryByText: (
+    name: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance | null,
+  queryAllByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => ReactTestInstance | null,
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null,
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null,
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance>,
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => Array<ReactTestInstance>,
-  queryAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>,
+  queryByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance | null,
+  queryAllByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null,
+  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
 
   // Unsafe aliases
   UNSAFE_queryByType: <P>(
diff --git a/src/matches.js b/src/matches.js
new file mode 100644
index 000000000..b5cfcd74c
--- /dev/null
+++ b/src/matches.js
@@ -0,0 +1,41 @@
+// @flow
+export type NormalizerFn = (textToNormalize: string) => string;
+
+export function matches(
+  matcher: string | RegExp,
+  text: string,
+  normalizer?: NormalizerFn = getDefaultNormalizer(),
+  exact?: boolean = true
+): boolean {
+  if (typeof text !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(text);
+  if (typeof matcher === 'string') {
+    return exact
+      ? normalizedText === matcher
+      : normalizedText.toLowerCase().includes(matcher.toLowerCase());
+  } else {
+    return matcher.test(normalizedText);
+  }
+}
+
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+
+export function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true,
+}: NormalizerConfig = {}): NormalizerFn {
+  return (text: string) => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace
+      ? normalizedText.replace(/\s+/g, ' ')
+      : normalizedText;
+    return normalizedText;
+  };
+}
diff --git a/src/pure.js b/src/pure.js
index b36edc6aa..61d9c5414 100644
--- a/src/pure.js
+++ b/src/pure.js
@@ -8,6 +8,7 @@ import shallow from './shallow';
 import waitFor, { waitForElement } from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
+import { getDefaultNormalizer } from './matches';
 
 export { act };
 export { cleanup };
@@ -18,3 +19,4 @@ export { shallow };
 export { waitFor, waitForElement };
 export { waitForElementToBeRemoved };
 export { within, getQueriesForElement };
+export { getDefaultNormalizer };
diff --git a/typings/__tests__/index.test.tsx b/typings/__tests__/index.test.tsx
index 40341f84a..6cd6c558c 100644
--- a/typings/__tests__/index.test.tsx
+++ b/typings/__tests__/index.test.tsx
@@ -10,6 +10,7 @@ import {
   act,
   within,
   getQueriesForElement,
+  getDefaultNormalizer,
 } from '../..';
 
 interface HasRequiredProp {
@@ -133,19 +134,23 @@ const queryAllBy: ReactTestInstance[][] = [
 // findBy API
 const findBy: Promise<ReactTestInstance>[] = [
   tree.findByText('View'),
-  tree.findByText('View', { timeout: 10, interval: 10 }),
+  tree.findByText('View', {}, { timeout: 10, interval: 10 }),
   tree.findByText(/View/g),
-  tree.findByText(/View/g, { timeout: 10, interval: 5 }),
+  tree.findByText(/View/g, {}, { timeout: 10, interval: 5 }),
   tree.findByPlaceholderText('my placeholder'),
-  tree.findByPlaceholderText('my placeholder', { timeout: 10, interval: 5 }),
+  tree.findByPlaceholderText(
+    'my placeholder',
+    {},
+    { timeout: 10, interval: 5 }
+  ),
   tree.findByPlaceholderText(/placeholder/g),
-  tree.findByPlaceholderText(/placeholder/g, { timeout: 10, interval: 5 }),
+  tree.findByPlaceholderText(/placeholder/g, {}, { timeout: 10, interval: 5 }),
   tree.findByDisplayValue('my value'),
-  tree.findByDisplayValue('my value', { timeout: 10, interval: 10 }),
+  tree.findByDisplayValue('my value', {}, { timeout: 10, interval: 10 }),
   tree.findByDisplayValue(/value/g),
-  tree.findByDisplayValue(/value/g, { timeout: 10, interval: 10 }),
+  tree.findByDisplayValue(/value/g, {}, { timeout: 10, interval: 10 }),
   tree.findByTestId('test-id'),
-  tree.findByTestId(/test-id/, { timeout: 10, interval: 10 }),
+  tree.findByTestId(/test-id/, {}, { timeout: 10, interval: 10 }),
   tree.findByA11yLabel('label'),
   tree.findByA11yLabel('label', { timeout: 10, interval: 10 }),
   tree.findByLabelText('label'),
@@ -166,22 +171,30 @@ const findBy: Promise<ReactTestInstance>[] = [
 
 const findAllBy: Promise<ReactTestInstance[]>[] = [
   tree.findAllByText('View'),
-  tree.findAllByText('View', { timeout: 10, interval: 10 }),
+  tree.findAllByText('View', {}, { timeout: 10, interval: 10 }),
   tree.findAllByText(/View/g),
-  tree.findAllByText(/View/g, { timeout: 10, interval: 5 }),
+  tree.findAllByText(/View/g, { exact: false }, { timeout: 10, interval: 5 }),
   tree.findAllByPlaceholderText('my placeholder'),
-  tree.findAllByPlaceholderText('my placeholder', {
-    timeout: 10,
-    interval: 10,
-  }),
+  tree.findAllByPlaceholderText(
+    'my placeholder',
+    { exact: false },
+    {
+      timeout: 10,
+      interval: 10,
+    }
+  ),
   tree.findAllByPlaceholderText(/placeholder/g),
-  tree.findAllByPlaceholderText(/placeholder/g, { timeout: 10, interval: 10 }),
+  tree.findAllByPlaceholderText(
+    /placeholder/g,
+    {},
+    { timeout: 10, interval: 10 }
+  ),
   tree.findAllByDisplayValue('View'),
-  tree.findAllByDisplayValue('View', { timeout: 10, interval: 10 }),
+  tree.findAllByDisplayValue('View', {}, { timeout: 10, interval: 10 }),
   tree.findAllByDisplayValue(/View/g),
-  tree.findAllByDisplayValue(/View/g, { timeout: 10, interval: 10 }),
+  tree.findAllByDisplayValue(/View/g, {}, { timeout: 10, interval: 10 }),
   tree.findAllByTestId('test-id'),
-  tree.findAllByTestId(/test-id/, { timeout: 10, interval: 10 }),
+  tree.findAllByTestId(/test-id/, {}, { timeout: 10, interval: 10 }),
   tree.findAllByA11yLabel('label'),
   tree.findAllByA11yLabel('label', { timeout: 10, interval: 10 }),
   tree.findAllByLabelText('label'),
@@ -461,3 +474,13 @@ const withinFindAll: Promise<ReactTestInstance[]>[] = [
   getQueriesForElement(instance).findAllByA11yState({ busy: true }),
   getQueriesForElement(instance).findAllByA11yValue({ min: 10 }),
 ];
+
+// TextMatch
+const normalizer = getDefaultNormalizer({
+  trim: false,
+  collapseWhitespace: true,
+});
+tree.getByText('text', { exact: false, normalizer });
+tree.getByPlaceholderText('text', { exact: false, normalizer });
+tree.getByDisplayValue('text', { exact: true, normalizer });
+tree.getByTestId('text', { exact: false, normalizer });
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 2003c2272..c0b6ea4bf 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -14,17 +14,38 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
+type TextMatch = string | RegExp;
+
 interface GetByAPI {
-  getByText: (text: string | RegExp) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance;
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance;
-  getByTestId: (testID: string | RegExp) => ReactTestInstance;
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>;
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>;
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -64,19 +85,31 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: string | RegExp) => ReactTestInstance | null;
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => ReactTestInstance | null;
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null;
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null;
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance> | [];
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance> | [];
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
-    value: string | RegExp
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
 
   // Unsafe aliases
@@ -126,35 +159,43 @@ interface QueryByAPI {
 
 interface FindByAPI {
   findByText: (
-    text: string | RegExp,
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByText: (
-    text: string | RegExp,
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -169,54 +210,54 @@ export type A11yValue = {
 
 type A11yAPI = {
   // Label
-  getByA11yLabel: (matcher: string | RegExp) => GetReturn;
-  getByLabelText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yLabel: (matcher: string | RegExp) => GetAllReturn;
-  getAllByLabelText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yLabel: (matcher: string | RegExp) => QueryReturn;
-  queryByLabelText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yLabel: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByLabelText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yLabel: (matcher: TextMatch) => GetReturn;
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yLabel: (matcher: TextMatch) => GetAllReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yLabel: (matcher: TextMatch) => QueryReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yLabel: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: string | RegExp) => GetReturn;
-  getByHintText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yHint: (matcher: string | RegExp) => GetAllReturn;
-  getAllByHintText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yHint: (matcher: string | RegExp) => QueryReturn;
-  queryByHintText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yHint: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByHintText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yHint: (matcher: TextMatch) => GetReturn;
+  getByHintText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yHint: (matcher: TextMatch) => GetAllReturn;
+  getAllByHintText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yHint: (matcher: TextMatch) => QueryReturn;
+  queryByHintText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yHint: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByHintText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -334,6 +375,16 @@ export declare const render: (
 export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
+type NormalizerFn = (textToNormalize: string) => string;
+type NormalizerConfig = {
+  trim?: boolean;
+  collapseWhitespace?: boolean;
+};
+type TextMatchOptions = {
+  exact?: boolean;
+  normalizer?: NormalizerFn;
+};
+
 type WaitForOptions = {
   timeout?: number;
   interval?: number;
@@ -359,6 +410,10 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
+export declare const getDefaultNormalizer: (
+  normalizerConfig?: NormalizerConfig
+) => NormalizerFn;
+
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.
  */
diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 848de3cf9..1a0e29d8a 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -44,15 +44,19 @@ In order to properly use `findBy` and `findAllBy` queries you need at least Reac
 
 _Note: most methods like this one return a [`ReactTestInstance`](https://reactjs.org/docs/test-renderer.html#testinstance) with following properties that you may be interested in:_
 
-```jsx
+```typescript
 type ReactTestInstance = {
-  type: string | Function,
-  props: { [propName: string]: any },
-  parent: null | ReactTestInstance,
-  children: Array<ReactTestInstance | string>,
+  type: string | Function;
+  props: { [propName: string]: any };
+  parent: null | ReactTestInstance;
+  children: Array<ReactTestInstance | string>;
 };
 ```
 
+### Options
+
+Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](#TextMatch) for more info.
+
 ### `ByText`
 
 > getByText, getAllByText, queryByText, queryAllByText, findByText, findAllByText
@@ -203,6 +207,99 @@ const { getByA11yValue } = render(<Component />);
 const element = getByA11yValue({ min: 40 });
 ```
 
+## TextMatch
+
+Most of the query APIs take a `TextMatch` as an argument, which means the argument can be either a _string_ or _regex_.
+
+```typescript
+type TextMatchOptions = {
+  exact?: boolean;
+  normalizer?: (textToNormalize: string) => string;
+  trim?: boolean;
+  collapseWhitespace?: boolean;
+};
+```
+
+### Examples
+
+Given the following render:
+
+```jsx
+const { getByText } = render(<Text>Hello World</Text>);
+```
+
+Will **find a match**:
+
+```js
+// Matching a string:
+getByText('Hello World'); // full string match
+getByText('llo Worl', { exact: false }); // substring match
+getByText('hello world', { exact: false }); // ignore case-sensitivity
+
+// Matching a regex:
+getByText(/World/); // substring match
+getByText(/world/i); // substring match, ignore case
+getByText(/^hello world$/i); // full string match, ignore case-sensitivity
+getByText(/Hello W?oRlD/i); // advanced regex
+```
+
+Will **NOT find a match**
+
+```js
+// substring does not match
+getByText('llo Worl');
+// full string does not match
+getByText('Goodbye World');
+
+// case-sensitive regex with different case
+getByText(/hello world/);
+```
+
+### Precision
+
+Queries that take a `TextMatch` also accept an object as the final argument that can contain options that affect the precision of string matching:
+
+- `exact`: Defaults to `true`; matches full strings, case-sensitive. When false, matches substrings and is not case-sensitive.
+  - `exact` has no effect on regex argument.
+  - In most cases using a `regex` instead of a string gives you more control over fuzzy matching and should be preferred over `{ exact: false }`.
+- `normalizer`: An optional function which overrides normalization behavior. See [Normalization](#Normalization).
+
+`exact` option defaults to `true` but if you want to search for a text slice or make text matching case-insensitive you can override it. That being said we advise you to use regex in more complex scenarios.
+
+### Normalization
+
+Before running any matching logic against text, it is automatically normalized. By default, normalization consists of trimming whitespace from the start and end of text, and collapsing multiple adjacent whitespace characters into a single space.
+
+If you want to prevent that normalization, or provide alternative normalization (e.g. to remove Unicode control characters), you can provide a `normalizer` function in the options object. This function will be given a string and is expected to return a normalized version of that string.
+
+:::info
+Specifying a value for `normalizer` replaces the built-in normalization, but you can call `getDefaultNormalizer` to obtain a built-in normalizer, either to adjust that normalization or to call it from your own normalizer.
+:::
+
+`getDefaultNormalizer` take options object which allows the selection of behaviour:
+
+- `trim`: Defaults to `true`. Trims leading and trailing whitespace.
+- `collapseWhitespace`: Defaults to `true`. Collapses inner whitespace (newlines, tabs repeated spaces) into a single space.
+
+#### Normalization Examples
+
+To perform a match against text without trimming:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: getDefaultNormalizer({ trim: false }),
+});
+```
+
+To override normalization to remove some Unicode characters whilst keeping some (but not all) of the built-in normalization behavior:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: (str) =>
+    getDefaultNormalizer({ trim: false })(str).replace(/[\u200E-\u200F]*/g, ''),
+});
+```
+
 ## Unit testing helpers
 
 > Use sparingly and responsibly, escape hatches here