diff --git a/setup.py b/setup.py
index 4c33b98..26c13ec 100644
--- a/setup.py
+++ b/setup.py
@@ -27,8 +27,8 @@ def read(filename):
     packages=find_packages(exclude=('tests', 'cache', 'workdir')),
 
     install_requires=[
-        "requests", # needed for fetching xml files from the internet
-        "urllib3" # needed for http retries
+        "requests",  # needed for fetching xml files from the internet
+        "urllib3"  # needed for http retries
     ],
 
     classifiers=[
diff --git a/tests/data/example.html b/tests/data/example.html
index 593cfa1..7e65049 100644
--- a/tests/data/example.html
+++ b/tests/data/example.html
@@ -7,7 +7,8 @@
       xmlns:link="http://www.xbrl.org/2003/linkbase"
       xmlns:xbrli="http://www.xbrl.org/2003/instance"
       xmlns:iso4217="http://www.xbrl.org/2003/iso4217"
-      xmlns:example="http://www.example.com/20210101">
+      xmlns:example="http://www.example.com/20210101"
+      xmlns:ixt="http://www.xbrl.org/inlineXBRL/transformation/2015-02-26">
 <head>
     <title>Sample iXBRL file</title>
     <style>* {
diff --git a/tests/test_transformation.py b/tests/test_transformation.py
index d868f88..b0e5627 100644
--- a/tests/test_transformation.py
+++ b/tests/test_transformation.py
@@ -9,8 +9,7 @@
 import sys
 import unittest
 
-from xbrl.helper.transformation import transform_ixt, transform_ixt_sec
-from xbrl.transformations import normalize
+from xbrl.transformations import normalize, TransformationException
 
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 
@@ -21,9 +20,8 @@
 
         ['booleantrue', 'yeah', 'true'],
 
-        ['datedaymonth', '2.12', '--12-02'],
-        ['datedaymonth', '1.1', '--01-01'],
-        ['datedaymonth', '12.11', '--11-12'],
+        ['datedaymonth', '11.12', '--12-11'],
+        ['datedaymonth', '1.2', '--02-01'],
 
         ['datedaymonthen', '2. December', '--12-02'],
         ['datedaymonthen', '2 Sept.', '--09-02'],
@@ -177,8 +175,15 @@ def test_normalize(self):
         for namespace in testTransforms:
             for i, testCase in enumerate(testTransforms[namespace]):
                 formatCode, testInput, expected = testCase
-                testOutput = normalize(namespace, formatCode, testInput)
-                self.assertEqual(expected, testOutput, msg=f'Failed at test elem {i} of registry {namespace}')
+                if expected == 'exception':
+                    try:
+                        testOutput = normalize(namespace, formatCode, testInput)
+                        self.fail('Expected Transformation Exception, received ' + testOutput)
+                    except TransformationException:
+                        pass
+                else:
+                    testOutput = normalize(namespace, formatCode, testInput)
+                    self.assertEqual(expected, testOutput, msg=f'Failed at test elem {i} of registry {namespace}')
 
 
 if __name__ == '__main__':
diff --git a/xbrl/helper/transformation.py b/xbrl/helper/transformation.py
deleted file mode 100644
index 845d0df..0000000
--- a/xbrl/helper/transformation.py
+++ /dev/null
@@ -1,174 +0,0 @@
-import logging
-import re
-from time import strptime
-from xbrl.helper.text2num import text2num, NumberException
-
-
-
-
-
-def transform_ixt(value: str, transform_format: str) -> str:
-    """
-    Takes a transformed value and returns a normalized value.
-    The transformation rules are listed here:
-    https://www.xbrl.org/Specification/inlineXBRL-transformationRegistry/REC-2015-02-26/inlineXBRL-transformationRegistry-REC-2015-02-26.html#d1e167
-
-    In short: this function will perform the following normalizations:
-    - Numbers: float value with a dot (.) as fraction separator. All thousands separators will be removed
-    - Full Date: YYYY-DD-MM
-    - Month-Day: --MM-DD
-    - Year-Month: YYYY-MM
-    - boolean: "true" or "false"
-    :param value: the raw text value
-    :param transform_format: the transformation format
-    :return:
-    """
-    value = value.lower().strip().replace(u'\xa0', u' ')
-    # remove dashes in the transformation format (num-dot-decimal -> numdotdecimal)
-    transform_format = transform_format.replace('-', '')
-
-    if transform_format == 'booleanfalse':
-        # * -> false
-        return 'false'
-
-    elif transform_format == 'booleantrue':
-        # * -> true
-        return 'true'
-
-    elif transform_format == 'zerodash':
-        # - -> 0
-        return '0'
-
-    elif transform_format == 'nocontent':
-        # any string -> ''
-        return ''
-
-    elif transform_format.startswith('date'):
-        # replace dashes, dots etc. (Dec. 2021 -> Dec  2021)
-        value = re.sub(r'[,\-\._/]', ' ', value)
-        # remove unnecessary spaces (Dec  2021 -> Dec 2021)
-        value = re.sub(r'\s{2,}', ' ', value)
-        seg = value.split(' ')
-
-        if transform_format == 'datedaymonth':
-            # (D)D*(M)M -> --MM-DD
-            return f"--{seg[1].zfill(2)}-{seg[0].zfill(2)}"
-
-        elif transform_format == 'datedaymonthen':
-            # (D)D*Mon(th) -> --MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]}', '%d %b') if len(seg[1]) == 3 \
-                else strptime(f'{seg[0]} {seg[1]}', '%d %B')
-            return f'--{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}'
-
-        elif transform_format == 'datedaymonthyear':
-            # (D)D*(M)M*(Y)Y(YY) -> YYYY-MM-DD
-            return f"{seg[2].zfill(2)}-{seg[1].zfill(2)}-{seg[0].zfill(2)}"
-
-        elif transform_format == 'datedaymonthyearen':
-            # (D)D*Mon(th)*(Y)Y(YY) -> YYYY-MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%d %b %Y') if len(seg[1]) == 3 \
-                else strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%d %B %Y')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}"
-
-        elif transform_format == 'datemonthday':
-            # (M)M*(D)D -> --MM-DD
-            return f"--{seg[0].zfill(2)}-{seg[1].zfill(2)}"
-
-        elif transform_format == 'datemonthdayen':
-            # Mon(th)*(D)D -> --MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]}', '%b %d') if len(seg[0]) == 3 \
-                else strptime(f'{seg[0]} {seg[1]}', '%B %d')
-            return f'--{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}'
-
-        elif transform_format == 'datemonthdayyear':
-            # (M)M*(D)D*(Y)Y(YY) -> YYYY-MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%m %d %Y')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}"
-
-        elif transform_format == 'datemonthdayyearen':
-            # Mon(th)*(D)D*(Y)Y(YY) -> YYYY-MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%b %d %Y') if len(seg[0]) <= 3 \
-                else strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%B %d %Y')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}"
-
-        elif transform_format == 'dateyearmonthday':
-            # (Y)Y(YY)*(M)M*(D)D -> YYYY-MM-DD
-            parsed_date = strptime(f'{seg[0]} {seg[1]} {seg[2]}', '%Y %m %d')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}-{str(parsed_date.tm_mday).zfill(2)}"
-
-        elif transform_format == 'datemonthyear':
-            # (M)M*(Y)Y(YY) -> YYYY-MM
-            return f"{seg[1]}-{seg[0].zfill(2)}"
-
-        elif transform_format == 'datemonthyearen':
-            # Mon(th)*(Y)Y(YY) -> YYYY-MM
-            parsed_date = strptime(f'{seg[0]} {seg[1]}', '%B %Y')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}"
-
-        elif transform_format == 'dateyearmonthen':
-            # (Y)Y(YY)*Mon(th) -> YYYY-MM
-            parsed_date = strptime(f'{seg[0]} {seg[1]}', '%Y %B')
-            return f"{parsed_date.tm_year}-{str(parsed_date.tm_mon).zfill(2)}"
-
-    elif transform_format.startswith('num'):
-        if transform_format == 'numcommadecimal':
-            # nnn*nnn*nnn,n -> nnnnnnnnn.n
-            value = re.sub(r'(\s|-|\.)', '', value)
-            return value.replace(',', '.')
-        if transform_format == 'numdotdecimal':
-            # nnn*nnn*nnn.n -> nnnnnnnnn.n
-            return re.sub(r'(\s|-|,)', '', value)
-
-    raise TransformationException('Unknown fact transformation {}'.format(transform_format))
-
-
-def transform_ixt_sec(value: str, transform_format: str) -> str:
-    """
-    Transforms the value according to the SEC Transformation rules
-    https://www.sec.gov/info/edgar/edgarfm-vol2-v50.pdf
-    https://www.sec.gov/info/edgar/specifications/edgarfm-vol2-v51_d.pdf
-    :param value:
-    :param transform_format:
-    :return:
-    """
-
-    value = value.lower().strip().replace(u'\xa0', u' ')
-
-    # replace dashes, dots etc. (Dec. 2021 -> Dec  2021)
-    value = re.sub(r'[,\-\._/]', ' ', value)
-    # remove unnecessary spaces (Dec  2021 -> Dec 2021)
-    value = re.sub(r'\s{2,}', ' ', value)
-
-    if transform_format == 'numwordsen':
-        if value == 'no' or value == 'none':
-            return '0'
-        else:
-            value = value.replace(' and ', ' ')
-            return str(text2num(value))
-    elif transform_format == 'boolballotbox':
-        if value == '☐':
-            return 'false'
-        else:
-            return 'true'
-    elif transform_format == 'durwordsen':
-        value = replace_text_numbers(value)
-        years, months, days = 0, 0, 0
-        words: [str] = value.split(' ')
-        for x in range(len(words) - 1):
-            if not words[x].isnumeric():
-                continue
-            if 'year' in words[x + 1]:
-                years = int(words[x])
-            elif 'month' in words[x + 1]:
-                months = int(words[x])
-            elif 'day' in words[x + 1]:
-                days = int(words[x])
-        return f'P{years}Y{months}M{days}D'
-
-    # raise TransformationException('Unknown fact transformation {}'.format(transform_format))
-    logging.info(f"The transformation rule ixt-sec:{transform_format} is currently not supported by this parser. "
-                 f"The value for the fact will not be transformed")
-    return value
-
-
-
diff --git a/xbrl/instance.py b/xbrl/instance.py
index f425428..adb2d35 100644
--- a/xbrl/instance.py
+++ b/xbrl/instance.py
@@ -14,10 +14,10 @@
 
 from xbrl import TaxonomyNotFound, InstanceParseException
 from xbrl.cache import HttpCache
-from xbrl.helper import transformation
 from xbrl.taxonomy import Concept, TaxonomySchema, parse_taxonomy, parse_common_taxonomy, parse_taxonomy_url
 from xbrl.helper.uri_helper import resolve_uri
 from xbrl.helper.xml_parser import parse_file
+from xbrl.transformations import normalize, TransformationException, TransformationNotImplemented
 
 logger = logging.getLogger(__name__)
 LINK_NS: str = "{http://www.xbrl.org/2003/linkbase}"
@@ -450,8 +450,6 @@ def _extract_non_numeric_value(fact_elem: ET.Element) -> str:
     """
     This function parses a ix:nonNumeric fact as defined in:
     https://www.xbrl.org/Specification/inlineXBRL-part1/PWD-2013-02-13/inlineXBRL-part1-PWD-2013-02-13.html#d1e6391
-
-
     :param fact_elem:
     :return:
     """
@@ -463,12 +461,16 @@ def _extract_non_numeric_value(fact_elem: ET.Element) -> str:
 
     fact_format = fact_elem.attrib['format'] if 'format' in fact_elem.attrib else None
     if fact_format:
+        # extract transformation registry namespace and transformation rule code
+        registryPrefix, formatCode = fact_format.split(':')
+        registryNS: str = fact_elem.attrib['ns_map'][registryPrefix]
         try:
-            if fact_format.startswith('ixt:'):
-                fact_value = transformation.transform_ixt(fact_value, fact_format.split(':')[1])
-            elif fact_format.startswith('ixt-sec'):
-                fact_value = transformation.transform_ixt_sec(fact_value, fact_format.split(':')[1])
-        except Exception:
+            fact_value = normalize(registryNS, formatCode, fact_value)
+        except TransformationNotImplemented:
+            logging.info(f'Transformation rule {formatCode} of registry {registryPrefix} is not supported. '
+                         f'The parser will just parse the value as it is and not transform it according to the rule.')
+            return fact_value
+        except TransformationException:
             logging.warning(f'Could not transform value "{fact_value}" with format {fact_format}')
             return fact_value
     return fact_value
@@ -495,14 +497,18 @@ def _extract_non_fraction_value(fact_elem: ET.Element) -> float or None or str:
     value_sign: str or None = fact_elem.attrib['sign'] if 'sign' in fact_elem.attrib else None
 
     if fact_format:
+        # extract transformation registry namespace and transformation rule code
+        registryPrefix, formatCode = fact_format.split(':')
+        registryNS: str = fact_elem.attrib['ns_map'][registryPrefix]
         try:
-            if fact_format.startswith('ixt:'):
-                fact_value = transformation.transform_ixt(fact_value, fact_format.split(':')[1])
-            elif fact_format.startswith('ixt-sec'):
-                fact_value = transformation.transform_ixt_sec(fact_value, fact_format.split(':')[1])
-        except Exception:
+            fact_value = normalize(registryNS, formatCode, fact_value)
+        except TransformationNotImplemented:
+            logging.info(f'Transformation rule {formatCode} of registry {registryPrefix} is not supported. '
+                         f'The parser will just parse the value as it is and not transform it according to the rule.')
+            return fact_value
+        except TransformationException:
             logging.warning(f'Could not transform value "{fact_value}" with format {fact_format}')
-            # return fact_value
+            return fact_value
 
     scaled_value = float(fact_value) * pow(10, value_scale)
     # Floating-point error mitigation
@@ -515,6 +521,7 @@ def _extract_non_fraction_value(fact_elem: ET.Element) -> float or None or str:
 
 def _extract_text_value(element: ET.Element) -> str:
     text = '' if element.text is None else element.text
+    if element.tail: text += element.tail
     for children in element:
         text += _extract_text_value(children)
     return text
