diff --git a/.travis.yml b/.travis.yml
index c610dfd76..fc61f43dd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,44 +1,20 @@
 language: python
 
 python:
-  - '2.7'
+  - '3.7'
 
 branches:
   except:
   - gh-pages
 
-before_install:
-  - echo "Checking for java"
-  - java -version
-  - openssl aes-256-cbc -K $encrypted_f18bb5b3c3d4_key -iv $encrypted_f18bb5b3c3d4_iv -in publish-key.enc -out ~/.ssh/publish-key -d
-  - chmod u=rw,og= ~/.ssh/publish-key
-  - echo "Host github.com" >> ~/.ssh/config
-  - echo "    IdentityFile ~/.ssh/publish-key" >> ~/.ssh/config
-  - sudo apt-get -qq update
-  - sudo apt-get install graphviz
-  - git --version
-  - git remote set-url origin git@github.com:ebu/ebu-tt-live-toolkit.git
-  - git fetch origin -f gh-pages:gh-pages
-
 install:
-  - pip install pip==9.0.1
-  - make
-  - python setup.py develop
-  - pip install coveralls
-  - pip install ghp-import
+  - pip install -U pip
+  - make init
 
 script:
-  - pyxbgen --binding-root=./ebu_tt_live/bindings -m __init__ --schema-root=./ebu_tt_live/xsd/ -r -u ebutt_all.xsd
-  - python setup.py test
-  - export PR=https://api.github.com/repos/$TRAVIS_REPO_SLUG/pulls/$TRAVIS_PULL_REQUEST
-  - export BRANCH=$(if [ "$TRAVIS_PULL_REQUEST" == "false" ]; then echo $TRAVIS_BRANCH; else echo `curl -s $PR | jq -r .head.ref`; fi)
-  - echo "TRAVIS_BRANCH=$TRAVIS_BRANCH, PR=$PR, BRANCH=$BRANCH"
-
-after_success:
-  - coveralls
+  - make test
+  - echo "Compiling documentation"
+  - make
+  - sudo apt-get -qq update
+  - sudo apt-get install graphviz
   - python setup.py build_sphinx
-  - if [ $BRANCH == "master" ]; then ghp-import -n -p -m "Update gh-pages." docs/build; fi
-
-notifications:
-  slack:
-    secure: RLs+ufYg4HcZfaTl73tTKKVja8DJ9LGk1WO+7B1qa4Fgpv0c/3uXcM+6tvDXllTlqcfLHgum0vbzvE4yapo0em0g/m75t1pEfkh5Pfrcas8IKAM9jg/xycWdYoAkKLRvNOcS4amO29FlzOHFaSSjX+V8JK8Mpm+QM2eGnqIbJokaXgBf/bQxHqGSRvYCeSisEG0f79Mn/0v5OOlbvmetFfvcQVNZDtgpA1CDbvK99F/vQT3qZ04Rh/vRnlcZyH9PEp/TEEJ0yX0NhHYEDnuBKPc86Ack/YCQpT12Ej2xTWjgoUrqv1pcr+h0ltYPXnnCyETrlbeLgNIMUsGW579MThqXekBZ7byRK2DMfjyL5+UgPSmTOIzEg7Qbc1u0r1bUuEi7nsJ5Vf65QeIAcewVASOUKmda9ag0MidTR/VoAsMtf5MzbDifSa1aBHRxZJToshNJVY9V8/lJLdwsbqsG2H+8v8ZuzyRLNiaFhNQTZQWpRXMipvbTDnnVxwpeFiLAqAwEKO9KIyGijqv2yeVvi4WtYvwzM7/1y/ycu7kTDFemKKuKmW2rzzBKJ30vo79ufMQCmn0riKkpaNxBf8R3EUEr86A9yuFpo6/Qc47i3PkeD7MszDqhEAfxl1+sQssWXOdVy6ALFb7RZ6EczpPvAjYLLO0aPa8OPaZjy3aJr+8=
diff --git a/docs/source/configurator.rst b/docs/source/configurator.rst
index 93f63c54d..00ddc8737 100644
--- a/docs/source/configurator.rst
+++ b/docs/source/configurator.rst
@@ -125,6 +125,9 @@ Node type dependent options for [nodeN] : ::
 
    type="distributor" : No options
 
+   type="denester"
+   └─sequence_identifier : sequence identifier, default "Denester1"
+
 Output carriage type dependent options for "carriage": ::
 
    type="direct"
diff --git a/docs/source/denesting.rst b/docs/source/denesting.rst
new file mode 100644
index 000000000..a673e5b24
--- /dev/null
+++ b/docs/source/denesting.rst
@@ -0,0 +1,37 @@
+Denesting of EBU-TT-Live documents
+======================================
+
+DenesterNode should be used when a EBU-TT-3 document has a div that contains
+other divs, or a span contains another span, and those nested elements need
+to be flattened, for example before conversion to EBU-TT-D. These elements
+are not able to be nested inside each other in EBU-TT-D documents.
+
+When documents are Denested, any nested elements must be removed from
+their parent elements, while retaining attributes they would have inherited.
+To address this, the DenesterNode node processes the
+document(s) with the
+:py:func:`ebu_tt_live.node.denester.DenesterNode.recurse` and
+:py:func:`ebu_tt_live.node.denester.DenesterNode.recurse_span`
+functions. These will iterate through the file to locate the deepest
+nested element, and create a new copy of it with its content and
+expected inherited attributes. The end result is a file containing
+these newly created divs/spans in place of the nested ones.
+
+Once the new divs and spans are created, divs that are sequential in
+the list of divs and have the same attributes are combined into a single
+div. This is done by the
+:py:func:`ebu_tt_live.node.denester.DenesterNode.combine_divs`
+function to reduce the number of divs in the resulting file.
+
+In the combined divs, every p element should have the same region
+as its parent div. Any p elements that specify a different region
+to their inherited region are removed here: as per TTML semantics,
+such p elements are never presented.
+The
+:py:func:`ebu_tt_live.node.denester.DenesterNode.check_p_regions`
+function iterates through the divs that have an assigned region and
+removes any p where its region does not match.
+It then removes the region attribute from any remaining p, as it will
+inhert the region of its parent div and the attribute is unnecessary.
+It will also remove any now-empty divs that exist as a result of having
+their p elements removed.
diff --git a/docs/source/ebu_tt_live.node.rst b/docs/source/ebu_tt_live.node.rst
index fdd249b2f..9d4527776 100644
--- a/docs/source/ebu_tt_live.node.rst
+++ b/docs/source/ebu_tt_live.node.rst
@@ -80,3 +80,11 @@ node Package
     :members:
     :undoc-members:
     :show-inheritance:
+
+:mod:`denester` Module
+----------------------
+
+.. automodule:: ebu_tt_live.node.denester
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/inode.puml b/docs/source/inode.puml
index 280a86b31..e1d039eab 100644
--- a/docs/source/inode.puml
+++ b/docs/source/inode.puml
@@ -70,6 +70,11 @@ class BufferDelayNode {
   +process_document()
 }
 
+class DenesterNode{
+  ..methods..
+  +process_document()
+}
+
 class RetimingDelayNode{
   ..methods..
   +process_document()
diff --git a/docs/source/overview.rst b/docs/source/overview.rst
index 13c353908..408143760 100644
--- a/docs/source/overview.rst
+++ b/docs/source/overview.rst
@@ -18,4 +18,5 @@ The components mimic the nodes and carriage mechanisms defined in the specificat
     timing_resolution
     segmentation
     deduplication
+    denesting
     conversion
diff --git a/docs/source/scripts_and_their_functions.rst b/docs/source/scripts_and_their_functions.rst
index 75ea12d8a..c0b0a4e0b 100644
--- a/docs/source/scripts_and_their_functions.rst
+++ b/docs/source/scripts_and_their_functions.rst
@@ -107,6 +107,17 @@ attributes are duplicated.
 For the default configuration of the node, see:
 ``ebu-run --admin.conf=ebu_tt_live/examples/config/deduplicator_fs.json``
 
+Denester Node
+-------------
+This node flattens nested ``div`` and ``span`` elements such that no
+``div`` ends up containing a ``div`` and no ``span`` ends up containing
+a ``span``. It also removes any ``p`` elements that specify a ``region``
+attribute that differs from a specified region on an ancester element.
+
+If nested ``div`` or ``span`` elements might be present in a document, the
+Denester node should be used to flatten them before passing them to the
+EBU-TT-D Encoder, because EBU-TT-D does not permit such nested elements.
+
 Retiming Delay Node
 -------------------
 This script modifies the times within each Document and issues them without
diff --git a/ebu_tt_live/bindings/__init__.py b/ebu_tt_live/bindings/__init__.py
index 8bc81f397..82f4a0212 100644
--- a/ebu_tt_live/bindings/__init__.py
+++ b/ebu_tt_live/bindings/__init__.py
@@ -100,6 +100,24 @@ class style_type(StyledElementMixin, IDMixin, SizingValidationMixin, SemanticVal
     }
     _default_attrs = None
 
+    def check_equal(self, other):
+        return (self.backgroundColor == other.backgroundColor and
+            self.padding == other.padding and
+            self.unicodeBidi == other.unicodeBidi and
+            self.color == other.color and
+            self.direction == other.direction and
+            self.fontFamily == other.fontFamily and
+            self.fontStyle == other.fontStyle and
+            self.fontWeight == other.fontWeight and
+            self.linePadding == other.linePadding and
+            self.multiRowAlign == other.multiRowAlign and
+            self.textAlign == other.textAlign and
+            self.textDecoration == other.textDecoration and
+            self.fontSize == other.fontSize and
+            self.lineHeight == other.lineHeight and
+            self.wrapOption == other.wrapOption)
+            
+
     def __repr__(self):
         return '<style ID: {id} at {addr}>'.format(
             id=self.id,
@@ -620,6 +638,7 @@ def _semantic_before_traversal(self, dataset, element_content=None, parent_bindi
         # attributes.
         dataset['timing_begin_stack'] = []
         dataset['timing_end_stack'] = []
+        dataset['div_stack'] = []
         dataset['timing_syncbase'] = timedelta()
         dataset['tt_element'] = self
         dataset['styles_stack'] = []
@@ -886,6 +905,9 @@ def __copy__(self):
         )
         return copied_div
 
+    def merge(self, elem):
+        return self
+
     def _semantic_before_traversal(self, dataset, element_content=None, parent_binding=None):
         self._semantic_register_id(dataset=dataset)
         self._semantic_timebase_validation(
@@ -922,6 +944,8 @@ def _semantic_after_subtree_copy(self, copied_instance, dataset, element_content
             copied_instance=copied_instance, dataset=dataset, element_content=element_content)
         self._semantic_copy_verify_referenced_styles(dataset=dataset)
         self._semantic_copy_verify_referenced_region(dataset=dataset)
+    
+
 
 
 raw.div_type._SetSupersedingClass(div_type)
diff --git a/ebu_tt_live/bindings/_ebuttdt.py b/ebu_tt_live/bindings/_ebuttdt.py
index cb721d955..0702f2eb0 100644
--- a/ebu_tt_live/bindings/_ebuttdt.py
+++ b/ebu_tt_live/bindings/_ebuttdt.py
@@ -326,8 +326,12 @@ def as_timedelta(cls, instance):
         :param instance:
         :return:
         """
-        hours, minutes, seconds, milliseconds = [cls._int_or_none(x) for x in cls._groups_regex.match(instance).groups()]
-        return timedelta(hours=hours, minutes=minutes, seconds=seconds, milliseconds=milliseconds)
+        hours_str, minutes_str, seconds_str, seconds_fraction_str = [x for x in cls._groups_regex.match(instance).groups()]
+        milliseconds = seconds_fraction_str and cls._int_or_none('{:0<3}'.format(seconds_fraction_str)[:3]) or 0
+        return timedelta(hours=cls._int_or_none(hours_str), 
+            minutes=cls._int_or_none(minutes_str), 
+            seconds=cls._int_or_none(seconds_str), 
+            milliseconds=milliseconds)
 
     @classmethod
     def from_timedelta(cls, instance):
@@ -374,8 +378,13 @@ def as_timedelta(cls, instance):
         :param instance:
         :return:
         """
-        hours, minutes, seconds, milliseconds = [cls._int_or_none(x) for x in cls._groups_regex.match(instance).groups()]
-        return timedelta(hours=hours, minutes=minutes, seconds=seconds, milliseconds=milliseconds)
+        hours_str, minutes_str, seconds_str, seconds_fraction_str = [x for x in cls._groups_regex.match(instance).groups()]
+        milliseconds = seconds_fraction_str and cls._int_or_none('{:0<3}'.format(seconds_fraction_str)[:3]) or 0
+        return timedelta(hours=cls._int_or_none(hours_str), 
+            minutes=cls._int_or_none(minutes_str), 
+            seconds=cls._int_or_none(seconds_str), 
+            milliseconds=milliseconds)
+        
 
     @classmethod
     def from_timedelta(cls, instance):
diff --git a/ebu_tt_live/bindings/converters/ebutt3_ebuttd.py b/ebu_tt_live/bindings/converters/ebutt3_ebuttd.py
index 7d9aeac96..7c72b97f6 100644
--- a/ebu_tt_live/bindings/converters/ebutt3_ebuttd.py
+++ b/ebu_tt_live/bindings/converters/ebutt3_ebuttd.py
@@ -294,6 +294,8 @@ def convert_body(self, body_in, dataset):
         return new_elem
 
     def convert_div(self, div_in, dataset):
+        if len(div_in.orderedContent()) == 0:
+            return None
         new_elem = d_div_type(
             *self.convert_children(div_in, dataset),
             id=div_in.id,
diff --git a/ebu_tt_live/bindings/test/test_times.py b/ebu_tt_live/bindings/test/test_times.py
new file mode 100644
index 000000000..11664f9c5
--- /dev/null
+++ b/ebu_tt_live/bindings/test/test_times.py
@@ -0,0 +1,72 @@
+
+from unittest import TestCase
+from unittest import skip, SkipTest
+from datetime import timedelta
+from ebu_tt_live.bindings import ebuttdt
+from pyxb import SimpleTypeValueError, SimpleFacetValueError
+
+class TestTimecountTimingType(TestCase):
+
+    _test_cases = {
+        '1.3s': timedelta(seconds = 1, milliseconds = 300),
+        '1.03s': timedelta(seconds = 1, milliseconds = 30),
+        '1.30s': timedelta(seconds = 1, milliseconds = 300),
+        '1s': timedelta(seconds = 1),
+        '1.3m': timedelta(minutes = 1, seconds = 18),
+        '1.03m': timedelta(minutes = 1, seconds = 1, milliseconds = 800),
+        '1.30m': timedelta(minutes = 1, seconds = 18),
+        '1m': timedelta(minutes = 1),
+        '1.3h': timedelta(hours = 1, minutes = 18),
+        '1.03h': timedelta(hours = 1, minutes = 1, seconds = 48),
+        '1.30h': timedelta(hours = 1, minutes = 18),
+        '1h': timedelta(hours = 1),
+        '1.3ms': timedelta(milliseconds = 1, microseconds = 300),
+        '1.03ms': timedelta(milliseconds = 1, microseconds = 30),
+        '1.30ms': timedelta(milliseconds = 1, microseconds = 300),
+        '1ms': timedelta(milliseconds = 1),
+    }
+
+    _type_class = ebuttdt.TimecountTimingType
+
+    def test_as_timedelta(self):
+        for t, td in self._test_cases.items() :
+            test_instance = self._type_class(t)
+            self.assertEqual(test_instance.timedelta, td)
+            assert test_instance == t
+
+
+
+class TestFullClockTimingType(TestCase):
+
+    _test_cases = {
+        '111:22:33': timedelta(hours = 111, minutes = 22, seconds = 33),
+        '111:22:33.4': timedelta(hours = 111, minutes = 22, seconds = 33, milliseconds = 400),
+        '111:22:33.04': timedelta(hours = 111, minutes = 22, seconds = 33, milliseconds = 40),
+        '111:22:33.40': timedelta(hours = 111, minutes = 22, seconds = 33, milliseconds = 400),
+    }
+
+    _type_class = ebuttdt.FullClockTimingType
+
+    def test_as_timedelta(self):
+        for t, td in self._test_cases.items() :
+            test_instance = self._type_class(t)
+            self.assertEqual(test_instance.timedelta, td)
+            assert test_instance == t
+
+
+class TestLimitedClockTimingType(TestCase):
+
+    _test_cases = {
+        '11:22:33': timedelta(hours = 11, minutes = 22, seconds = 33),
+        '11:22:33.4': timedelta(hours = 11, minutes = 22, seconds = 33, milliseconds = 400),
+        '11:22:33.04': timedelta(hours = 11, minutes = 22, seconds = 33, milliseconds = 40),
+        '11:22:33.40': timedelta(hours = 11, minutes = 22, seconds = 33, milliseconds = 400),
+    }
+    
+    _type_class = ebuttdt.LimitedClockTimingType
+
+    def test_as_timedelta(self):
+        for t, td in self._test_cases.items() :
+            test_instance = self._type_class(t)
+            self.assertEqual(test_instance.timedelta, td)
+            assert test_instance == t
diff --git a/ebu_tt_live/bindings/validation/presentation.py b/ebu_tt_live/bindings/validation/presentation.py
index d065fc8fc..ac4ddc15d 100644
--- a/ebu_tt_live/bindings/validation/presentation.py
+++ b/ebu_tt_live/bindings/validation/presentation.py
@@ -32,6 +32,7 @@ class StyledElementMixin(object):
     """
     _compatible_style_type = None
     _referenced_styles = None
+    _referenced_divs = None
     _inherited_styles = None
     _region_styles = None
     _validated_styles = None
diff --git a/ebu_tt_live/bindings/validation/timing.py b/ebu_tt_live/bindings/validation/timing.py
index 61c080fcc..ca206b587 100644
--- a/ebu_tt_live/bindings/validation/timing.py
+++ b/ebu_tt_live/bindings/validation/timing.py
@@ -109,7 +109,12 @@ def _post_calculate_begin(self, children):
         earliest_child_computed_begin = min(children_computed_begin_times)
         if earliest_child_computed_begin > self._computed_begin_time:
             # Adjustment scenario
-            self._computed_begin_time = earliest_child_computed_begin
+            # If no parent element specified a begin time, then we have found
+            # a case for the "earliest specified computed begin time" as per the
+            # specification and we can adjust the begin time to match the
+            # children's begin time.
+            if len(self._semantic_dataset['timing_begin_stack']) == 0:
+                self._computed_begin_time = earliest_child_computed_begin
 
     def _semantic_preprocess_timing(self, dataset, element_content):
         """
@@ -395,6 +400,35 @@ def _post_pop_end(self):
 
         return end_timedelta
 
+    def _post_calculate_begin(self, children):
+        """
+        The computed begin time shall be moved down to match that of the earliest child begin time in case the container
+        does not specify a begin time itself. NOTE: This does not modify the syncbase.
+
+        :param children:
+        :return:
+        """
+
+        if not children:
+            if 'availability_time' in self._semantic_dataset:
+                if self.begin is None:
+                    self._computed_begin_time = self._semantic_dataset['availability_time']
+                if self.end is None and self.dur is not None:
+                    self._computed_end_time = self._computed_begin_time + self._dur_timedelta
+            return
+
+        children_computed_begin_times = [item.computed_begin_time for item in children]
+
+        earliest_child_computed_begin = min(children_computed_begin_times)
+        if 'availability_time' in self._semantic_dataset:
+            earliest_child_computed_begin = max(earliest_child_computed_begin, self._semantic_dataset['availability_time'])
+        
+        if earliest_child_computed_begin > self._computed_begin_time:
+            # Adjustment scenario
+            self._computed_begin_time = earliest_child_computed_begin
+            if self.dur is not None and self.begin is None:
+                self._computed_end_time = self._computed_begin_time + self._dur_timedelta
+
     def _semantic_timebase_validation(self, dataset, element_content):
 
         super(BodyTimingValidationMixin, self)._semantic_timebase_validation(dataset, element_content)
diff --git a/ebu_tt_live/config/node.py b/ebu_tt_live/config/node.py
index b484cc63b..a4e3e3b4b 100644
--- a/ebu_tt_live/config/node.py
+++ b/ebu_tt_live/config/node.py
@@ -192,6 +192,20 @@ def __init__(self, config, local_config):
         self._create_input(config)
         self._create_output(config)
 
+class Denester(ConsumerMixin, ProducerMixin, NodeBase):
+    required_config = Namespace()
+
+    def _create_component(self, config):
+        self.component = processing_node.DenesterNode(
+            node_id=self.config.id
+        )
+
+    def __init__(self, config, local_config):
+        super(RetimingDelay, self).__init__(config, local_config)
+        self._create_component(config)
+        self._create_input(config)
+        self._create_output(config)
+
 
 class SimpleProducer(ProducerMixin, NodeBase):
     required_config = Namespace()
diff --git a/ebu_tt_live/documents/converters.py b/ebu_tt_live/documents/converters.py
index 132631158..4c48788f5 100644
--- a/ebu_tt_live/documents/converters.py
+++ b/ebu_tt_live/documents/converters.py
@@ -1,6 +1,7 @@
 
 from ebu_tt_live.bindings.converters.ebutt3_ebuttd import EBUTT3EBUTTDConverter
 from ebu_tt_live.documents.ebuttd import EBUTTDDocument
+from ebu_tt_live.documents.ebutt3 import EBUTT3Document
 from subprocess import Popen, PIPE
 import tempfile
 import os
@@ -16,8 +17,16 @@ def ebutt3_to_ebuttd(ebutt3_in, media_clock):
     :param ebutt3_in:
     :return:
     """
+
     converter = EBUTT3EBUTTDConverter(media_clock=media_clock)
-    ebuttd_bindings = converter.convert_document(ebutt3_in.binding)
+    # Here we need a thing that makes sure that the times in the input 
+    # document do not depend on a body@dur attribute, and that they are
+    # absolutised, so a body with no begin or end time but with a dur
+    # gets fixed into a body with an end time, which gives the
+    # denester an easier job.
+    doc_xml = ebutt3_in.get_xml()
+    ebutt3_doc = EBUTT3Document.create_from_xml(doc_xml)
+    ebuttd_bindings = converter.convert_document(ebutt3_doc.binding)
     ebuttd_document = EBUTTDDocument.create_from_raw_binding(ebuttd_bindings)
     ebuttd_document.validate()
     return ebuttd_document
diff --git a/ebu_tt_live/documents/test/converter_ericsson1.xml b/ebu_tt_live/documents/test/converter_ericsson1.xml
index d01c3fdaa..f702a0ed8 100644
--- a/ebu_tt_live/documents/test/converter_ericsson1.xml
+++ b/ebu_tt_live/documents/test/converter_ericsson1.xml
@@ -53,7 +53,8 @@
     </tt:head>
 
     
-<tt:body dur="5s" ttm:role="caption">
+<!-- <tt:body dur="5s" ttm:role="caption"> -->
+<tt:body ttm:role="caption">
         <tt:div>
             <tt:metadata>
                 <ebuttm:facet expresses="has">Subtitle_Source_Facet is of type VOICE</ebuttm:facet>
diff --git a/ebu_tt_live/node/__init__.py b/ebu_tt_live/node/__init__.py
index b28f08e51..0e768ae04 100644
--- a/ebu_tt_live/node/__init__.py
+++ b/ebu_tt_live/node/__init__.py
@@ -3,6 +3,7 @@
 from .producer import SimpleProducer
 from .consumer import SimpleConsumer, ReSequencer
 from .encoder import EBUTTDEncoder
+from .denester import DenesterNode
 from .delay import BufferDelayNode, RetimingDelayNode
 from .distributing import DistributingNode
 from .handover import HandoverNode
diff --git a/ebu_tt_live/node/denester.py b/ebu_tt_live/node/denester.py
new file mode 100644
index 000000000..560a0dda9
--- /dev/null
+++ b/ebu_tt_live/node/denester.py
@@ -0,0 +1,332 @@
+from .base import AbstractCombinedNode
+from ebu_tt_live.documents.ebutt3 import EBUTT3Document
+from pyxb.binding.basis import NonElementContent, ElementContent
+from ebu_tt_live.bindings import div_type, p_type, span_type, ebuttdt, style_type
+from ebu_tt_live.bindings._ebuttm import divMetadata_type
+import copy
+import re
+from datetime import timedelta
+
+class DenesterNode(AbstractCombinedNode):
+    """
+    This class contains methods for unnesting elements of an EBUTT3Document that cannot be nested in EBUTTD
+    """
+
+    _expects = EBUTT3Document
+    _provides = EBUTT3Document
+
+    def __init__(self, node_id, consumer_carriage=None, producer_carriage=None):
+        super(DenesterNode, self).__init__(
+            node_id=node_id,
+            producer_carriage=producer_carriage,
+            consumer_carriage=consumer_carriage
+        )
+
+    def process_document(self, document, **kwargs):
+        divs = document.binding.body.div
+        unnested_divs = []
+        dataset = {}
+        if document.binding.head.styling is not None:
+            dataset["styles"] = document.binding.head.styling.style
+        else:
+            dataset["styles"] = []
+        dataset["document"] = document.binding
+        for div in divs:
+            unnested_divs.extend(DenesterNode.recurse(div,dataset))
+        unnested_divs = DenesterNode.combine_divs(unnested_divs)
+        unnested_divs = DenesterNode.check_p_regions(unnested_divs)
+        document.binding.body.div = unnested_divs
+        return document
+
+    
+    def check_p_regions(divs):
+        """
+        Keeps only P elements where the region matches the div region or is None
+        Then removes region from remaining P elements as it will be the same as the div region
+        """
+
+        for div in divs:
+            if div.region is not None:
+                div.p = [p for p in div.p if p.region == div.region or p.region == None]
+                for p in div.p:
+                    p.region = None
+
+        # Removes divs that no longer contain any P elements
+        divs = [div for div in divs if len(div.p) != 0]
+
+        return divs
+
+
+    def combine_divs(divs):
+        """
+        Takes the list of unnested divs, where one was created to contain each P elements, and attempts to combine them.
+
+        A list of new divs is created, the first element being the first div in the list of divs passed in
+        Iterating through the passed in divs, where a div has the same attributes as the previous one,
+        add its P list to the current new div's P list.
+        
+        Where the current div does not match, add it to the list of new divs and increment j, making it the current new div
+        """
+        new_divs = []
+        if len(divs) != 0:
+            new_divs.append(divs[0])
+            i = 1
+            j = 0
+            while i < len(divs):
+                if DenesterNode.div_attr(divs[i]) == DenesterNode.div_attr(divs[i-1]):
+                    new_divs[j].p.extend(divs[i].p)
+                else:
+                    j += 1
+                    new_divs.append(divs[i])
+                i += 1
+        return new_divs
+
+
+    def div_attr(div):
+        """
+        Converts a specific subset of div attributes to an array
+        """
+        div_attributes =  {}
+        div_attributes["styles"] = div.style
+        div_attributes["lang"] = div.lang
+        div_attributes["region"] = div.region
+        div_attributes["begin"] = div.begin
+        div_attributes["end"] = div.end
+        return div_attributes
+
+
+    def merge_attr(parent_attr, div_attributes):
+        """
+        Merges two sets of attributes to ensure they are correctly inherited in the final div
+        """
+        merged_attributes ={ "styles": [], "begin": None, "end": None, "lang": None, "region": None }
+
+        if not isinstance(parent_attr["begin"], timedelta) and parent_attr["begin"] is not None:
+            parent_attr["begin"] = parent_attr["begin"].timedelta
+        if not isinstance(parent_attr["end"], timedelta) and parent_attr["end"] is not None:
+            parent_attr["end"] = parent_attr["end"].timedelta
+        if not isinstance(div_attributes["begin"], timedelta) and div_attributes["begin"] is not None:
+            div_attributes["begin"] = div_attributes["begin"].timedelta
+        if not isinstance(div_attributes["end"], timedelta) and div_attributes["end"] is not None:
+            div_attributes["end"] = div_attributes["end"].timedelta
+
+        if div_attributes["styles"] is not None:
+                merged_attributes["styles"] = div_attributes["styles"] + parent_attr["styles"]
+        else:
+            merged_attributes["styles"] = parent_attr["styles"]
+        if div_attributes["lang"] is not None:
+            merged_attributes["lang"] = div_attributes["lang"]
+        else:
+            merged_attributes["lang"] = parent_attr["lang"]
+        if parent_attr["region"] is not None:
+            merged_attributes["region"] = parent_attr["region"]
+        elif div_attributes["region"] is not None:
+            merged_attributes["region"] = div_attributes["region"]
+        if parent_attr["begin"] is not None and div_attributes["begin"] is not None:
+            merged_attributes["begin"] = parent_attr["begin"] + div_attributes["begin"]
+        elif parent_attr["begin"] is not None and div_attributes["begin"] is None:
+            merged_attributes["begin"] = parent_attr["begin"]
+        elif parent_attr["begin"] is None and div_attributes["begin"] is None:
+            merged_attributes["begin"] = None
+        else:
+            merged_attributes["begin"] = div_attributes["begin"] if parent_attr["begin"] is None else parent_attr["begin"]
+        if parent_attr["end"] is not None and div_attributes["end"] is not None:
+            merged_attributes["end"] = parent_attr["end"] - div_attributes["end"]
+        elif parent_attr["end"] is not None and div_attributes["end"] is None:
+            merged_attributes["end"] = parent_attr["end"]
+        else:
+            merged_attributes["end"] = DenesterNode.calculate_end_times(parent_attr, div_attributes, parent_attr["begin"])
+        return merged_attributes
+
+
+    def calculate_end_times(parent_attr, child_attr, time_sync):
+        if child_attr["end"] is not None and parent_attr["end"] is None and time_sync is not None:
+            return time_sync+child_attr["end"]
+        elif parent_attr["end"] is not None and child_attr["end"] is not None:
+            return parent_attr["end"]-child_attr["end"]
+        else:
+            return child_attr["end"]
+
+
+    def process_timing_from_timedelta(timing_type):
+        if timing_type is None:
+            return None
+        return ebuttdt.FullClockTimingType.from_timedelta(timing_type)
+
+
+    def recurse(div, dataset, merged_attr={ "styles": [], "begin": None, "end": None, "lang": None, "region": None }):
+        merged_attr = DenesterNode.merge_attr(merged_attr, DenesterNode.div_attr(div))
+        new_divs = []
+        for c in div.orderedContent():
+            if isinstance(c.value,div_type):
+                if(div.region != c.value.region and c.value.region !=None and div.region !=None):
+                    continue
+                new_divs.extend(DenesterNode.recurse(c.value, dataset, merged_attr))
+            elif isinstance(c.value,divMetadata_type):
+                continue
+            else:
+                new_spans = []
+                for ic in c.value.orderedContent():
+                    if isinstance(ic.value,span_type):
+                        new_spans.extend(DenesterNode.recurse_span(ic.value,dataset))
+                c.value.span = new_spans
+                for span in c.value.span:
+                    # The following lines address some test cases but are not a
+                    # general solution, so commented out, however see comments
+                    # on line immediately below.
+                    # if c.value.begin is not None:
+                    #     p_time = c.value.computed_begin_time
+                    # else:
+                    #     p_time = div.computed_begin_time
+
+                    # The following line fails if the parent p element's computed 
+                    # begin time has
+                    # been advanced to its earliest child's computed begin time
+                    # and the p's parent div has a different computed begin time.
+                    # This situation arises especially when the body element has
+                    # a dur but no begin or end times. This may well be some kind
+                    # of bug or incorrect behaviour, but it's hard to sort out
+                    # without breaking a bunch of stuff.
+                    p_time = c.value.computed_begin_time
+                    
+                    span.compBegin = span.compBegin - p_time
+                    span.compEnd = span.compEnd - p_time
+
+                    span.begin = ebuttdt.FullClockTimingType(span.compBegin)
+                    span.end = ebuttdt.FullClockTimingType(span.compEnd)
+
+                new_div = div_type(
+                    id=div.id,
+                    style=None if len(merged_attr["styles"]) == 0  else merged_attr["styles"],
+                    begin=DenesterNode.process_timing_from_timedelta(merged_attr["begin"]) if merged_attr["begin"] is not None else merged_attr["begin"],
+                    end=DenesterNode.process_timing_from_timedelta(merged_attr["end"]) if merged_attr["end"] is not None else merged_attr["end"],
+                    lang=merged_attr["lang"],
+                    region=merged_attr["region"],
+                )   
+                new_div.p.append(c.value)
+                new_divs.append(new_div)
+        
+        return new_divs
+
+
+    def recurse_span(span, dataset, span_styles = []):
+        if span.style is not None:
+            span_styles = span_styles+span.style
+        new_spans = []
+        for sc in span.orderedContent():
+            if isinstance(sc.value,span_type):
+                new_spans.extend(DenesterNode.recurse_span(sc.value, dataset, span_styles))
+            else:
+                new_span = span_type(
+                    sc.value
+                )
+                
+                new_span.compBegin = span.computed_begin_time
+                new_span.compEnd = span.computed_end_time
+
+                if len(span_styles) != 0:
+                    new_span.style = DenesterNode.compute_span_merged_styles(span_styles, dataset).id if len(span_styles) >1 else span_styles
+                else:
+                    new_span.style = None
+                new_spans.append(new_span)
+        return new_spans
+                
+
+    def compute_span_merged_styles(span_styles, dataset):
+        """
+        Combines all the nested styles of the span to create a new one
+        """
+        new_style = None
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        new_style = style_type(
+            id="".join(span_styles),
+            backgroundColor=DenesterNode.get_value_from_style(styles, "backgroundColor"),
+            color=DenesterNode.get_value_from_style(styles, "color"),
+            fontFamily=DenesterNode.get_value_from_style(styles, "fontFamily"),
+            fontSize=DenesterNode.calculate_font_size(styles),
+            fontWeight=DenesterNode.get_value_from_style(styles, "fontWeight"),
+            lineHeight=DenesterNode.get_value_from_style(styles, "lineHeight"),
+            linePadding=DenesterNode.get_value_from_style(styles, "linePadding"),
+            padding=DenesterNode.get_value_from_style(styles, "padding"),
+            style=DenesterNode.get_value_from_style(styles, "style"),
+            textAlign=DenesterNode.get_value_from_style(styles, "textAlign"),
+            textDecoration=DenesterNode.get_value_from_style(styles, "textDecoration")
+        )
+        new_style = DenesterNode.create_new_style(new_style, dataset)
+        return new_style
+
+
+    def create_new_style(new_style, dataset):
+        """
+        Checks if the style it has received is the same in attributes or name as an
+        existing style. If not, a new style is created and added to the dataset
+        """
+        for style in dataset["styles"]:
+            if new_style.id == style.id:
+                return new_style
+            if new_style.check_equal(style):
+                new_style.id = style.id
+                return new_style
+        dataset["styles"].append(new_style)
+        return new_style
+
+
+    def calculate_font_size(styles):
+        """
+        Calculates font size for a merged style, using the sizes of the styles it combines
+        """
+        font_size = None
+
+        for style in styles:
+            if font_size is None: # No existing font size
+                font_size = style.fontSize
+
+            elif isinstance(style.fontSize, ebuttdt.percentageFontSizeType) == False and style.fontSize is not None: # Font size is in c/px
+                font_size = style.fontSize
+
+            elif isinstance(style.fontSize, ebuttdt.percentageFontSizeType) and font_size is not None:
+                # Font size in percent, there is an existing font size (may not be percent)
+                font_size = DenesterNode.calculate_percentage_font_size(font_size, style.fontSize)
+
+        return font_size
+
+            
+    def calculate_percentage_font_size(current_font_size, nested_font_size):
+        """
+        Calculates percentage of another font size, ie 50% of 25%, or 30% of 100px
+        """
+        if isinstance(current_font_size, ebuttdt.percentageFontSizeType):
+            stripped_current_font_size = current_font_size.strip("%")
+            stripped_nested_font_size = nested_font_size.strip("%")
+            calculated_font_size = float(stripped_nested_font_size) * (float(stripped_current_font_size)/100)
+
+            return ebuttdt.percentageFontSizeType('{0:g}%'.format(calculated_font_size))
+        elif isinstance(current_font_size, str):
+            if current_font_size[-1:] == "x":
+                stripped_current_font_size = current_font_size.strip("px")
+                stripped_nested_font_size = nested_font_size.strip("%")
+                calculated_font_size = float(stripped_nested_font_size) * (float(stripped_current_font_size)/100)
+
+                return '{0:g}px'.format(calculated_font_size)
+            else: #current_font_size[-1:] == "c":
+                stripped_current_font_size = current_font_size.strip("c")
+                stripped_nested_font_size = nested_font_size.strip("%")
+                calculated_font_size = float(stripped_nested_font_size) * (float(stripped_current_font_size)/100)
+
+                return '{0:g}c'.format(calculated_font_size)
+
+
+    def get_value_from_style(styles, style_name):
+        """
+        Iterates through the styles of the span, keeping the value from the deepest-nested style (highest priority) 
+        for each attribute
+        """
+        value = None
+        for style in styles: # list in reverse-priority order, so last item (most important) values inherited
+            if getattr(style, style_name) is not None:
+                value = getattr(style, style_name)
+        return value
diff --git a/ebu_tt_live/node/test/test_denester.py b/ebu_tt_live/node/test/test_denester.py
new file mode 100644
index 000000000..f472dc57f
--- /dev/null
+++ b/ebu_tt_live/node/test/test_denester.py
@@ -0,0 +1,389 @@
+from unittest import TestCase
+from ebu_tt_live.documents.ebutt3 import EBUTT3Document
+from ebu_tt_live.node.denester import DenesterNode
+from ebu_tt_live.bindings import div_type, p_type, span_type, style_type
+from ebu_tt_live.bindings._ebuttm import divMetadata_type
+from ebu_tt_live.bindings._ebuttdt import FullClockTimingType
+import re
+from datetime import timedelta
+
+class TestDenesterNode(TestCase):
+    # Given a div within a div, only a single div is returned
+
+    def setUp(self):
+        xml_file = "testing/bdd/templates/nested_elements_hardcoded.xml"
+        with open(xml_file, 'r') as in_file:
+           input_xml = in_file.read()
+        input_xml = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", input_xml)
+        self.actual_doc = EBUTT3Document.create_from_xml(input_xml)
+        
+        xml_file_2 = "testing/bdd/templates/unnested_elements_hardcoded.xml"
+        with open(xml_file_2, 'r') as in_file:
+            expected_xml = in_file.read()
+        expected_xml = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", expected_xml)
+        self.expected_doc = EBUTT3Document.create_from_xml(expected_xml)
+
+        xml_file_3 = "testing/bdd/templates/many_nested_elements_hardcoded.xml"
+        with open(xml_file_3, 'r') as in_file:
+            input_xml_2 = in_file.read()
+        input_xml_2 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", input_xml_2)
+        self.actual_doc_2 = EBUTT3Document.create_from_xml(input_xml_2)
+
+        xml_file_4 = "testing/bdd/templates/many_unnested_elements_hardcoded.xml"
+        with open(xml_file_4, 'r') as in_file:
+            expected_xml_2 = in_file.read()
+        expected_xml_2 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", expected_xml_2)
+        self.expected_doc_2 = EBUTT3Document.create_from_xml(expected_xml_2)
+
+        xml_file_5 = "testing/bdd/templates/regions_nested_elements_hardcoded.xml"
+        with open(xml_file_5, 'r') as in_file:
+            input_xml_3 = in_file.read()
+        input_xml_3 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", input_xml_3)
+        self.actual_doc_3 = EBUTT3Document.create_from_xml(input_xml_3)
+
+        xml_file_6 = "testing/bdd/templates/regions_unnested_elements_hardcoded.xml"
+        with open(xml_file_6, 'r') as in_file:
+            expected_xml_3 = in_file.read()
+        expected_xml_3 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", expected_xml_3)
+        self.expected_doc_3 = EBUTT3Document.create_from_xml(expected_xml_3)
+
+        xml_file_7 = "testing/bdd/templates/nested_spans_hardcoded.xml"
+        with open(xml_file_7, 'r') as in_file:
+            input_xml_4 = in_file.read()
+        input_xml_4 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", input_xml_4)
+        self.actual_doc_4 = EBUTT3Document.create_from_xml(input_xml_4)
+
+        xml_file_8 = "testing/bdd/templates/unnested_spans_hardcoded.xml"
+        with open(xml_file_8, 'r') as in_file:
+            expected_xml_4 = in_file.read()
+        expected_xml_4 = re.sub(r"(<ebuttm:documentStartOfProgramme>[^<]*</ebuttm:documentStartOfProgramme>)", r"<!-- \1 -->", expected_xml_4)
+        self.expected_doc_4 = EBUTT3Document.create_from_xml(expected_xml_4)
+        
+
+    def test_merged_attr_styles_(self):
+        excepted_div_attr = {
+            "styles" : ["S1","S2"],
+        }
+        parent_attr = {
+            "styles" : ["S2"],
+            "lang": None,
+            "region": None,
+            "begin": None,
+            "end":None
+        }
+        actual_div = self.actual_doc_2.binding.body.div[0].div[0]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        assert excepted_div_attr["styles"] == actual_divs_attr["styles"]
+    
+
+    def test_recurse_many_child(self):
+        expected_divs = self.expected_doc_2.binding.body.div
+        nested_divs =  self.actual_doc_2.binding.body.div
+        dataset={}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        unnested_divs =  []
+        for nested_div in nested_divs:
+            unnested_divs.extend((DenesterNode.combine_divs(DenesterNode.recurse(nested_div, dataset))))
+        assert len(unnested_divs) == len(expected_divs)
+
+    def test_merged_attr_lang_only_on_child(self):
+        expected_div_attr = {
+            "styles": ["S1","S2"],
+            "lang": "fr"
+        }
+        parent_attr = {
+            "styles": ["S2"],
+            "lang": None,
+            "region": None,
+            "begin": None,
+            "end": None
+        }
+        actual_div = self.actual_doc_2.binding.body.div[0].div[0]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        assert expected_div_attr["lang"] == actual_divs_attr["lang"]
+    
+    def test_merged_attr_lang_only_on_parent(self):
+        expected_div_attr = {
+            "styles": ["S1","S2"],
+            "lang": "fr"
+        }
+        parent_attr = {
+            "styles": ["S2"],
+            "lang": "fr",
+            "region": None,
+            "begin":  None,
+            "end": None
+        }
+        actual_div = self.actual_doc.binding.body.div[0].div[0]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        assert expected_div_attr["lang"] == actual_divs_attr["lang"]
+
+    def test_merged_attr_lang_only_on_both_child_and_parent(self):
+        expected_div_attr = {
+            "styles": ["S1","S2"],
+            "lang": "en-GB"
+        }
+        parent_attr = {
+            "styles": ["S2"],
+            "lang": "fr",
+            "region": None,
+            "begin": None,
+            "end": None
+        }
+        actual_div = self.actual_doc.binding.body.div[0].div[1]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        assert expected_div_attr["lang"] == actual_divs_attr["lang"] 
+
+    def test_merged_attr_begin_end_times_on_child_and_parent(self):
+        expected_div_attr = {
+            "styles": ["S1","S2"],
+            "region": None,
+            "lang": "fr",
+            "begin": FullClockTimingType("00:00:11"),
+            "end": FullClockTimingType("00:00:15")
+        }
+        parent_attr = {
+            "styles": ["S2"],
+            "lang": "fr",
+            "region": None,
+            "begin": FullClockTimingType("00:00:10"),
+            "end": FullClockTimingType("00:00:20")
+        }
+        actual_div = self.actual_doc.binding.body.div[0].div[0]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        actual_begin_time = actual_divs_attr["begin"]
+        expected_begin_time = expected_div_attr["begin"].timedelta
+        assert expected_begin_time == actual_begin_time
+        actual_end_time = actual_divs_attr["end"]
+        expected_end_time = expected_div_attr["end"].timedelta
+        assert expected_begin_time == actual_begin_time
+        assert expected_end_time == actual_end_time
+    
+    def test_merged_attr_begin_end_times_on_child_no_end_on_parent(self):
+        expected_div_attr = {
+            "styles": ["S1","S2"],
+            "region": None,
+            "lang": "fr",
+            "begin": FullClockTimingType("00:00:11"),
+            "end": FullClockTimingType("00:00:15")
+        }
+        parent_attr = {
+            "styles": ["S2"],
+            "lang": "fr",
+            "region": None,
+            "begin": FullClockTimingType("00:00:10"),
+            "end": None
+        }
+        actual_div = self.actual_doc.binding.body.div[0].div[0]
+        actual_divs_attr = DenesterNode.merge_attr(parent_attr, DenesterNode.div_attr(actual_div))
+        actual_begin_time = actual_divs_attr["begin"]
+        expected_begin_time = expected_div_attr["begin"].timedelta
+        assert expected_begin_time == actual_begin_time
+        actual_end_time = actual_divs_attr["end"]
+        expected_end_time = expected_div_attr["end"].timedelta
+        assert expected_begin_time == actual_begin_time
+        assert expected_end_time == actual_end_time
+
+    def test_merged_attr_different_region(self):
+        expected_divs = self.expected_doc_3.binding.body.div
+        nested_divs =  self.actual_doc_3.binding.body.div
+        dataset={}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling
+        unnested_divs =  []
+        for nested_div in nested_divs:
+            unnested_divs.extend((DenesterNode.combine_divs(DenesterNode.recurse(nested_div, dataset))))
+        assert len(expected_divs)== len(unnested_divs)
+
+    def test_merged_attr_same_region(self):
+        expected_divs = self.expected_doc_3.binding.body.div
+        nested_divs =  self.actual_doc_3.binding.body.div
+        dataset={}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        unnested_divs =  []
+        for nested_div in nested_divs:
+            unnested_divs.extend((DenesterNode.combine_divs(DenesterNode.recurse(nested_div, dataset))))
+        assert unnested_divs[0].region == expected_divs[0].region
+
+    def test_combine_same_divs(self):
+        expected_divs = self.expected_doc_2.binding.body.div
+        dataset={}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        nested_divs =  self.actual_doc_2.binding.body.div
+        unnested_divs =  []
+        for nested_div in nested_divs:
+            unnested_divs.extend(DenesterNode.combine_divs(DenesterNode.recurse(nested_div, dataset)))
+        assert len(unnested_divs) == len(expected_divs)
+
+    def test_nested_spans(self):
+        expected_spans = self.expected_doc_4.binding.body.div[0].p[0].span
+        nested_spans =  self.actual_doc_4.binding.body.div[0].p[0].span
+        unnested_spans =  []
+        dataset={}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        for nested_span in nested_spans:
+            unnested_spans.extend(DenesterNode.recurse_span(nested_span, dataset))
+        assert len(expected_spans) == len(unnested_spans)
+
+    def test_compute_spans_have_valid_styles(self):
+        nested_spans = self.actual_doc_4.binding.body.div[0].p[0].span
+        dataset={}
+        unnested_spans =  []
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        dataset["document"] = self.actual_doc_4.binding
+        for nested_span in nested_spans:
+            unnested_spans.extend(DenesterNode.recurse_span(nested_span, dataset))
+        self.expected_doc_4.binding.body.div[0].p[0].span = unnested_spans
+        expected_styles = [style.id for style in self.expected_doc_4.binding.head.styling.style]
+        for span in unnested_spans:
+            assert span.style[0] in expected_styles
+
+
+    # yet to remove unused styles, but that is outside scope of denester
+    def test_should_create_new_span_style(self):
+        expected_style = style_type (
+            id="outerinnerYellow",
+            backgroundColor="#000000",
+            color="#ffff00",
+        )
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        span_styles =['outer', 'innerYellow']
+        actual_style = DenesterNode.compute_span_merged_styles(span_styles, dataset)
+        assert expected_style.id == actual_style.id
+
+
+    def test_three_styles_should_create_new_span_style(self):
+        expected_style = style_type (
+            id="outerinnerYellowinnerWhite",
+            backgroundColor="#000000",
+            color="#FFFFFF",
+        )
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        span_styles =['outer', 'innerYellow', 'innerWhite']
+        actual_style = DenesterNode.compute_span_merged_styles(span_styles, dataset)
+        assert expected_style.id == actual_style.id
+        
+
+    def test_span_computed_font_size_both_parent_child_have_percentages(self):
+        expected_style_font_size = "300%"
+        span_styles = ["outer", "innerWhite"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size 
+
+    def test_span_computed_font_size_only_child_has_percentage(self):
+        expected_style_font_size = "200%"
+        span_styles = ["outer", "innerYellow"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    #assuming that child fontsize if absolute it doesn't change
+    def test_span_computed_font_size_both_have_absolute_fontsize(self):
+        expected_style_font_size = "2c"
+        span_styles = ["outerGreen", "innerRed"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    def test_span_computed_font_size_only_parent_has_absolute_fontsize(self):
+        expected_style_font_size = "1.5c"
+        span_styles = ["outerGreen", "innerYellow"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    
+    def test_span_computed_font_size_only_child_has_absolute_fontsize(self):
+        expected_style_font_size = "2c"
+        span_styles = ["outer", "innerRed"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    def test_nesting_within_absolute_fontsize_c(self):
+        expected_style_font_size = "4c"
+        span_styles = ["innerRed", "outer"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    def test_nesting_within_absolute_fontsize_px(self):
+        expected_style_font_size = "750px"
+        style1 = style_type (
+            id="style1",
+            fontSize="500px"
+        )
+        style2 = style_type (
+            id="style2",
+            fontSize="150%"
+        )
+        styles = [style1, style2]
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    def test_nesting_around_absolute_fontsize_px(self):
+        expected_style_font_size = "750px"
+        style1 = style_type (
+            id="style1",
+            fontSize="500px"
+        )
+        style2 = style_type (
+            id="style2",
+            fontSize="150%"
+        )
+        style3 = style_type (
+            id="style2",
+            fontSize="300%"
+        )
+        styles = [style3, style1, style2]
+        actual_style_font_size = DenesterNode.calculate_font_size(styles)
+        assert expected_style_font_size == actual_style_font_size
+
+    def test_duplicate_styles_are_not_created(self):
+        span_styles = ["nest", "nest"]
+        dataset = {}
+        dataset["styles"] = self.actual_doc_4.binding.head.styling.style
+        styles = []
+        for style_name in span_styles: # go through styles in xml
+            for style in dataset["styles"]:
+                if style.id == style_name:
+                    styles.append(style)
+        assert DenesterNode.compute_span_merged_styles(span_styles, dataset).id == "nest"
\ No newline at end of file
diff --git a/ebu_tt_live/xsd/ebutt_live.xsd b/ebu_tt_live/xsd/ebutt_live.xsd
index 1c026ddf3..c18d26511 100644
--- a/ebu_tt_live/xsd/ebutt_live.xsd
+++ b/ebu_tt_live/xsd/ebutt_live.xsd
@@ -193,6 +193,12 @@ Please note that the EBU-TT XML Schema is a helping document and NOT normative b
 					application.</xs:documentation>
 			</xs:annotation>
 		</xs:attribute>
+		<xs:attribute ref="xml:lang">
+			<xs:annotation>
+				<xs:documentation>Language identifier that overwrites the language identification of
+					the enclosed subtitle content.</xs:documentation>
+			</xs:annotation>
+		</xs:attribute>
 		<xs:attribute name="region" type="xs:IDREF">
 			<xs:annotation>
 				<xs:documentation>Application of layout and style information through reference of a
diff --git a/testing/bdd/conftest.py b/testing/bdd/conftest.py
index 46ddb9dc3..60f117be0 100644
--- a/testing/bdd/conftest.py
+++ b/testing/bdd/conftest.py
@@ -3,6 +3,7 @@
 from ebu_tt_live.documents import EBUTT3Document, EBUTT3DocumentSequence, EBUTTDDocument
 from ebu_tt_live.documents.converters import EBUTT3EBUTTDConverter
 from ebu_tt_live.clocks.local import LocalMachineClock
+from ebu_tt_live.node.denester import DenesterNode
 from ebu_tt_live.clocks.media import MediaClock
 from ebu_tt_live.bindings._ebuttdt import FullClockTimingType, LimitedClockTimingType, CellFontSizeType, lineHeightType
 from datetime import timedelta
@@ -10,6 +11,9 @@
 import os
 import unittest
 
+denester_node = DenesterNode(
+    node_id = "denester_node"
+);
 
 @given('an xml file <xml_file>')
 def template_file(xml_file):
@@ -62,13 +66,13 @@ def valid_doc(template_file, template_dict):
     assert isinstance(document, EBUTT3Document)
 
 @then('the first document is valid')
-def valid_doc(template_file_one, template_dict):
+def valid_doc_1(template_file_one, template_dict):
     xml_file_1 = template_file_one.render(template_dict)
     document = EBUTT3Document.create_from_xml(xml_file_1)
     assert isinstance(document, EBUTT3Document)
 
 @then('the second document is valid')
-def valid_doc(template_file_two, template_dict):
+def valid_doc_2(template_file_two, template_dict):
     xml_file_2 = template_file_two.render(template_dict)
     document = EBUTT3Document.create_from_xml(xml_file_2)
     assert isinstance(document, EBUTT3Document)
@@ -84,7 +88,10 @@ def invalid_doc(template_file, template_dict):
 def gen_document(template_file, template_dict):
     # TODO: This is legacy and to be removed when tests are refactored
     xml_file = template_file.render(template_dict)
-    document = EBUTT3Document.create_from_xml(xml_file)
+    if 'availability_time' in template_dict:
+        document = EBUTT3Document.create_from_xml(xml_file, template_dict['availability_time'])
+    else:
+        document = EBUTT3Document.create_from_xml(xml_file)
     document.validate()
     return document
 
@@ -92,7 +99,10 @@ def gen_document(template_file, template_dict):
 def when_doc_generated(test_context, template_dict, template_file):
     # This is a more standard-compliant way to do this
     xml_file = template_file.render(template_dict)
-    document = EBUTT3Document.create_from_xml(xml_file)
+    if 'availability_time' in template_dict:
+        document = EBUTT3Document.create_from_xml(xml_file, template_dict['availability_time'])
+    else:
+        document = EBUTT3Document.create_from_xml(xml_file)
     test_context['document'] = document
 
 
@@ -120,10 +130,16 @@ def gen_second_document(test_context, template_dict, template_file_two):
 def gen_second_document_fixture(test_context, template_dict, template_file_two):
     return gen_second_document(test_context, template_dict, template_file_two)
 
+@when('the EBU-TT-Live document is denested')
+def convert_to_ebuttd(test_context):
+    test_context["document"] = denester_node.process_document(test_context["document"])
+
 @when('the EBU-TT-Live document is converted to EBU-TT-D')
 def convert_to_ebuttd(test_context):
     ebuttd_converter = EBUTT3EBUTTDConverter(None)
-    converted_bindings = ebuttd_converter.convert_document(test_context['document'].binding)
+    doc_xml = test_context["document"].get_xml()
+    ebutt3_doc = EBUTT3Document.create_from_xml(doc_xml)
+    converted_bindings = ebuttd_converter.convert_document(ebutt3_doc.binding)
     ebuttd_document = EBUTTDDocument.create_from_raw_binding(converted_bindings)
     test_context['ebuttd_document'] = ebuttd_document
 
@@ -176,17 +192,25 @@ def when_p_end(p_end, template_dict):
     template_dict['p_end'] = p_end
 
 @when('it has p1 begin time <p1_begin>')
-def when_p_begin(p1_begin, template_dict):
+def when_p1_begin(p1_begin, template_dict):
     template_dict['p1_begin'] = p1_begin
 
 @when('it has p1 end time <p1_end>')
-def when_p_end(p1_end, template_dict):
+def when_p1_end(p1_end, template_dict):
     template_dict['p1_end'] = p1_end
 
 @when('it has span1 begin time <span1_begin>')
 def when_span1_begin(span1_begin, template_dict):
     template_dict['span1_begin'] = span1_begin
 
+@when('it has nestedSpan begin time <nestedSpan_begin>')
+def when_nestedSpan_begin(nestedSpan_begin, template_dict):
+    template_dict['nestedSpan_begin'] = nestedSpan_begin
+
+@when('it has nestedSpan end time <nestedSpan_end>')
+def when_nestedSpan_end(nestedSpan_end, template_dict):
+    template_dict['nestedSpan_end'] = nestedSpan_end
+
 @when('it has span1 end time <span1_end>')
 def when_span1_end(span1_end, template_dict):
     template_dict['span1_end'] = span1_end
@@ -207,6 +231,18 @@ def when_span2_begin(span3_begin, template_dict):
 def when_span3_end(span3_end, template_dict):
     template_dict['span3_end'] = span3_end
 
+@when('it has div_region <div_region>')
+def when_div_region(div_region, template_dict):
+    template_dict['div_region'] = div_region
+
+@when('it has p1_region <p1_region>')
+def when_p1_region(p1_region, template_dict):
+    template_dict['p1_region'] = p1_region
+
+@when('it has p2_region <p2_region>')
+def when_p2_region(p2_region, template_dict):
+    template_dict['p2_region'] = p2_region
+
 @then('it has computed end time <computed_end>')
 def valid_computed_end_time(computed_end, gen_document):
     if computed_end:
diff --git a/testing/bdd/features/metadata/ebuttd_required_metadata.feature b/testing/bdd/features/metadata/ebuttd_required_metadata.feature
index 3496950b4..9fcecf4a0 100644
--- a/testing/bdd/features/metadata/ebuttd_required_metadata.feature
+++ b/testing/bdd/features/metadata/ebuttd_required_metadata.feature
@@ -4,6 +4,7 @@ Feature: Converted EBUTTD file contains required metadata elements
   Scenario: It adds two conformsToStandard elements to the EBU-TT-D metadata
     Given an xml file <xml_file>
     When the document is generated
+    And the EBU-TT-Live document is denested
     And the EBU-TT-Live document is converted to EBU-TT-D
     Then EBUTTD document is valid
     And the EBUTTD document contains a documentMetadata element <element_name> with value <element_value>
diff --git a/testing/bdd/features/nesting/ebuttd_nested_elements.feature b/testing/bdd/features/nesting/ebuttd_nested_elements.feature
new file mode 100644
index 000000000..ad2eda5a0
--- /dev/null
+++ b/testing/bdd/features/nesting/ebuttd_nested_elements.feature
@@ -0,0 +1,105 @@
+Feature: Merging nested elements
+
+
+    Scenario: If a div contains no tt:p elements it is discarded
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And all divs contain at least one p element
+
+        Examples:
+            | xml_file                      |
+            | nested_elements_hardcoded.xml |
+
+    Scenario: No div should contain any other divs
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And no div contains any other divs
+
+        Examples:
+            | xml_file                      |
+            | nested_elements_hardcoded.xml |
+
+    Scenario: When the P region matches the div region, remove p region
+        Given an xml file <xml_file>
+        When it has div_region <div_region>
+        And it has p1_region <p1_region>
+        And the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And p elements do not have a region
+
+        Examples:
+            | xml_file                      | div_region | p1_region |
+            | p_regions_nested_elements.xml | R1         | R1        |
+
+    Scenario: When the P region does not match the div region, remove p
+        Given an xml file <xml_file>
+        When it has div_region <div_region>
+        And it has p1_region <p1_region>
+        And it has p2_region <p2_region>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And there is one div containing one p
+
+        Examples:
+            | xml_file                      | div_region | p1_region | p2_region |
+            | p_regions_nested_elements.xml | R1         | R1        | R2        |
+
+    Scenario: No span should contain any other span
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And no span contains any other spans
+
+        Examples:
+            | xml_file                   |
+            | nested_spans_hardcoded.xml |
+
+    Scenario: Nested spans with styles should create new, combined styles
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And the second span's style is outerinnerYellow
+
+        Examples:
+            | xml_file                   |
+            | nested_spans_hardcoded.xml |
+
+    Scenario: New styles are not created where the values of the new style match an existing one
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And there is no style named "nestnest"
+
+        Examples:
+            | xml_file                   |
+            | nested_spans_hardcoded.xml |
+
+    Scenario: Nested styles with percentage sizes are correctly calculated
+        Given an xml file <xml_file>
+        When the document is generated
+        And the EBU-TT-Live document is denested
+        And the EBU-TT-Live document is converted to EBU-TT-D
+        Then EBUTTD document is valid
+        And any span with the style "nestSizing" also has the style "autogenFontStyle_None_50.0"
+        And any span with the style "nestSizingnestSizing" also has the style "autogenFontStyle_None_25.0"
+        And any span with the style "nestSizingnestSizingnestSizing" also has the style "autogenFontStyle_None_12.5"
+
+        Examples:
+            | xml_file                   |
+            | nested_spans_hardcoded.xml |
\ No newline at end of file
diff --git a/testing/bdd/features/styles/ebuttd_style_references.feature b/testing/bdd/features/styles/ebuttd_style_references.feature
index 794df738f..8bcbd79c1 100644
--- a/testing/bdd/features/styles/ebuttd_style_references.feature
+++ b/testing/bdd/features/styles/ebuttd_style_references.feature
@@ -21,6 +21,7 @@ Feature: Remove style elements that refer to other style elements
     And   style "s_top" has attribute "color" set to "yellow"
     And   it contains some text with style "s_top"
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  the ebu_tt_d document contains style "s_top" with attribute "fontFamily" set to "monospace"
     And   the ebu_tt_d document contains style "s_top" with attribute "color" set to "#ffff00ff"
@@ -37,6 +38,7 @@ Feature: Remove style elements that refer to other style elements
     And   region "r1" has attribute "padding" set to "5px"
     And   it contains some text with region "r1"
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   the ebu_tt_d document contains style "s1" without a "padding" attribute
@@ -52,6 +54,7 @@ Feature: Remove style elements that refer to other style elements
     And   region "r1" has attribute "style" set to "s1"
     And   it contains some text with region "r1"
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   the ebu_tt_d document contains style "s1" without a "padding" attribute
@@ -69,6 +72,7 @@ Feature: Remove style elements that refer to other style elements
     And   region "r1" has attribute "style" set to "s1 s2"
     And   it contains some text with region "r1"
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   the ebu_tt_d document contains region "r1" with attribute "padding" set to "5px"
@@ -88,6 +92,7 @@ Feature: Remove style elements that refer to other style elements
     And   region "r1" has attribute "style" set to "s1 s3"
     And   it contains some text with region "r1"
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   the ebu_tt_d document contains region "r1" with attribute "padding" set to "5px"
diff --git a/testing/bdd/features/timing/ebuttd_resolved_timings_on_elements.feature b/testing/bdd/features/timing/ebuttd_resolved_timings_on_elements.feature
index c90b261be..271bccdbd 100644
--- a/testing/bdd/features/timing/ebuttd_resolved_timings_on_elements.feature
+++ b/testing/bdd/features/timing/ebuttd_resolved_timings_on_elements.feature
@@ -7,24 +7,50 @@ Feature: Resolving timings on elements
 
   Scenario: Timings present on both p and span elements
     Given an xml file <xml_file>
-    When   it has p begin time <p_begin>
+    When  it has p begin time <p_begin>
     And   it has p end time <p_end>
     And   it has span1 begin time <span1_begin>
     And   it has span1 end time <span1_end>
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   span1 resulted begin time is <span1_resulted_begin_time>
     And   span1 resulted end time is <span1_resulted_end_time>
     And   no timings present on p
 
-
     Examples:
       | p_begin  | p_end    | span1_begin | span1_end | span1_resulted_begin_time | span1_resulted_end_time |
       | 00:00:05 |          | 00:00:02    | 00:00:08  | 00:00:07                  | 00:00:13                |
       | 00:00:10 | 00:00:15 | 00:00:01    | 00:00:02  | 00:00:11                  | 00:00:12                |
       | 00:00:10 | 00:00:13 |             | 00:00:04  | 00:00:10                  | 00:00:13                |
 
+
+  Scenario: Timings present on both p and nested span elements
+    Given an xml file <xml_file>
+    When  it has p begin time <p_begin>
+    And   it has p end time <p_end>
+    And   it has span1 begin time <span1_begin>
+    And   it has span1 end time <span1_end>
+    And   it has nestedSpan begin time <nestedSpan_begin>
+    And   it has nestedSpan end time <nestedSpan_end>
+    When  the document is generated
+    And   the EBU-TT-Live document is denested
+    And   the EBU-TT-Live document is converted to EBU-TT-D
+    Then  EBUTTD document is valid
+    And   span1 resulted begin time is <span1_resulted_begin_time>
+    And   span1 resulted end time is <span1_resulted_end_time>
+    And   nestedSpan resulted begin time is <nestedSpan_resulted_begin_time>
+    And   nestedSpan resulted end time is <nestedSpan_resulted_end_time>
+    And   no timings present on p
+
+    Examples:
+      | p_begin  | p_end    | span1_begin | span1_end | nestedSpan_begin | nestedSpan_end | span1_resulted_begin_time | span1_resulted_end_time | nestedSpan_resulted_begin_time | nestedSpan_resulted_end_time |
+      | 00:00:05 |          | 00:00:02    | 00:00:08  | 00:00:01         | 00:00:02       | 00:00:07                  | 00:00:13                | 00:00:08                       | 00:00:09                     |
+      | 00:00:05 |          | 00:00:02    | 00:00:08  | 00:00:03         | 00:00:05       | 00:00:07                  | 00:00:13                | 00:00:10                       | 00:00:12                     |
+      | 00:00:05 |          | 00:00:02    | 00:00:08  | 00:00:03         |                | 00:00:07                  | 00:00:13                | 00:00:10                       | 00:00:13                     |
+      | 00:00:05 |          | 00:00:02    | 00:00:08  |                  | 00:00:06       | 00:00:07                  | 00:00:13                | 00:00:07                       | 00:00:13                     |
+
   Scenario: Timings specified on div, body and p shall be removed
     Given an xml file <xml_file>
     When  it has div begin time <div_begin>
@@ -36,6 +62,7 @@ Feature: Resolving timings on elements
     And   it has span1 begin time <span1_begin>
     And   it has span1 end time <span1_end>
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  EBUTTD document is valid
     And   span1 resulted begin time is <span1_resulted_begin_time>
@@ -60,6 +87,7 @@ Feature: Resolving timings on elements
     And   it has p begin time <p_begin>
     And   it has p end time <p_end>
     When  the document is generated
+    And   the EBU-TT-Live document is denested
     And   the EBU-TT-Live document is converted to EBU-TT-D
     Then  p resulted begin time is <p_resulted_begin_time>
     And   p resulted end time is <p_resulted_end_time>
diff --git a/testing/bdd/features/timing/elements_active_times.feature b/testing/bdd/features/timing/elements_active_times.feature
index 030f30fe6..b4335cfe9 100644
--- a/testing/bdd/features/timing/elements_active_times.feature
+++ b/testing/bdd/features/timing/elements_active_times.feature
@@ -145,8 +145,8 @@ Feature: Computed element active begin and end times
     And it has body end time <body_end>
     And it has div begin time <div_begin>
     And it has div end time <div_end>
-    And the document is generated
     And it is available at <availability_time>
+    And the document is generated
     Then body active begin time is <body_active_begin>
     And body active end time is <body_active_end>
     And div active begin time is <div_active_begin>
@@ -159,3 +159,8 @@ Feature: Computed element active begin and end times
     |            | 00:01:00 |          |           |          |                   | 00:00:00          | 00:01:00        | 00:00:00         | 00:01:00       |
     |            | 00:01:00 |          |           |          | 00:00:05          | 00:00:05          | 00:01:05        | 00:00:05         | 00:01:05       |
     |            | 00:01:00 | 00:00:50 |           |          |                   | 00:00:00          | 00:00:50        | 00:00:00         | 00:00:50       |
+@skip
+# Skipping tests where body has dur and there's a div with times because denester doesn't deal with them yet.
+    |            | 00:00:05 |          | 01:00:00  |          |                   | 01:00:00          | 01:00:05        | 01:00:00         | 01:00:05       |
+    |            | 00:00:05 |          | 00:00:05  | 00:00:12 |                   | 00:00:05          | 00:00:10        | 00:00:05         | 00:00:10       |
+    
diff --git a/testing/bdd/features/timing/elements_active_times_empty_body.feature b/testing/bdd/features/timing/elements_active_times_empty_body.feature
index 584836d2c..97cf8547d 100644
--- a/testing/bdd/features/timing/elements_active_times_empty_body.feature
+++ b/testing/bdd/features/timing/elements_active_times_empty_body.feature
@@ -39,8 +39,8 @@ Feature: Computed element active begin and end times
     And it has body begin time <body_begin>
     And it has body duration <body_dur>
     And it has body end time <body_end>
-    And the document is generated
     And it is available at <availability_time>
+    And the document is generated
     Then body active begin time is <body_active_begin>
     And body active end time is <body_active_end>
 
diff --git a/testing/bdd/features/timing/retimingDelayNode.feature b/testing/bdd/features/timing/retimingDelayNode.feature
index bd765797c..8a9641c8e 100644
--- a/testing/bdd/features/timing/retimingDelayNode.feature
+++ b/testing/bdd/features/timing/retimingDelayNode.feature
@@ -49,7 +49,7 @@ Feature: Delay of a document sequence
     |            |              |           |          | 00:00:05 | 00:00:08 |            |          |             |           | 00:00:10 | 00:00:15           | 00:00:18         | 00:00:15          | 00:00:18        | 00:00:15        | 00:00:18      | 00:00:15           | 00:00:18         | 00:00:15            | 00:00:18          |          |
     | 00:00:05   | 00:00:20     | 00:00:03  |          |          |          |            |          |             |           | 00:00:05 | 00:00:10           | 00:00:25         | 00:00:13          | 00:00:25        | 00:00:13        | 00:00:25      | 00:00:13           | 00:00:25         | 00:00:13            | 00:00:25          |          |
     | 00:00:05   | 00:00:20     | 00:00:03  |          | 00:00:04 |          |            |          |             |           | 00:00:05 | 00:00:10           | 00:00:25         | 00:00:13          | 00:00:25        | 00:00:17        | 00:00:25      | 00:00:17           | 00:00:25         | 00:00:17            | 00:00:25          |          |
-    | 00:00:10   | 00:00:10.500 |           |          | 00:00:03 | 00:00:06 |            |          |             |           | 01:00:00 | 01:00:10           | 01:00:10.500     | 01:00:13          | 01:00:10.500    | 01:00:13        | 01:00:10.500  | 01:00:13           | 01:00:10.500     | 01:00:13            | 01:00:10.500      |          |
+    | 00:00:10   | 00:00:10.500 |           |          | 00:00:03 | 00:00:06 |            |          |             |           | 01:00:00 | 01:00:10           | 01:00:10.500     | 01:00:10          | 01:00:10.500    | 01:00:13        | 01:00:10.500  | 01:00:13           | 01:00:10.500     | 01:00:13            | 01:00:10.500      |          |
     |            |              | 00:00:10  | 00:00:20 | 00:00:05 | 00:00:07 |            |          |             |           | 00:00:01 | 00:00:11           | 00:00:21         | 00:00:11          | 00:00:21        | 00:00:16        | 00:00:18      | 00:00:16           | 00:00:18         | 00:00:16            | 00:00:18          |          |
     |            |              |           | 00:00:20 |          | 00:00:10 |            |          |             |           | 00:00:15 | 00:00:15           | 00:00:35         | 00:00:15          | 00:00:35        | 00:00:15        | 00:00:25      | 00:00:15           | 00:00:25         | 00:00:15            | 00:00:25          |          |
     |            |              | 00:00:20  |          |          | 00:00:10 |            |          |             |           | 00:00:15 | 00:00:35           | 00:00:45         | 00:00:35          | 00:00:45        | 00:00:35        | 00:00:45      | 00:00:35           | 00:00:45         | 00:00:35            | 00:00:45          |          |
diff --git a/testing/bdd/features/unit_conversion/ebuttd_colour_conversion.feature b/testing/bdd/features/unit_conversion/ebuttd_colour_conversion.feature
index daf4e1f7a..70d7baca3 100644
--- a/testing/bdd/features/unit_conversion/ebuttd_colour_conversion.feature
+++ b/testing/bdd/features/unit_conversion/ebuttd_colour_conversion.feature
@@ -12,6 +12,7 @@ Feature: EBU-TT-D colour conversion
         And style "s1" has attribute "color" set to <ebu_tt_live_value>
         And it contains some text with style "s1"
         When the document is generated
+        And the EBU-TT-Live document is denested
         And the EBU-TT-Live document is converted to EBU-TT-D
         Then the ebu_tt_d document contains style "s1" with attribute "color" set to <ebu_tt_d_value>
 
diff --git a/testing/bdd/features/unit_conversion/ebuttd_line_height_conversion.feature b/testing/bdd/features/unit_conversion/ebuttd_line_height_conversion.feature
index c42010082..347fc75a7 100644
--- a/testing/bdd/features/unit_conversion/ebuttd_line_height_conversion.feature
+++ b/testing/bdd/features/unit_conversion/ebuttd_line_height_conversion.feature
@@ -13,6 +13,7 @@ Feature: EBU-TT-D lineHeight conversion
         And style "s1" has attribute "fontSize" set to <fontSize>
         And it contains some text with style "s1"
         When the document is generated
+        And the EBU-TT-Live document is denested
         And the EBU-TT-Live document is converted to EBU-TT-D
         Then the ebu_tt_d document contains style "autogenFontStyle_None_200.0" with attribute "lineHeight" set to <ebu_tt_d_value>
 
diff --git a/testing/bdd/features/unit_conversion/ebuttd_origin_extent_conversion.feature b/testing/bdd/features/unit_conversion/ebuttd_origin_extent_conversion.feature
index 3fd831ec1..0b8ee812a 100644
--- a/testing/bdd/features/unit_conversion/ebuttd_origin_extent_conversion.feature
+++ b/testing/bdd/features/unit_conversion/ebuttd_origin_extent_conversion.feature
@@ -15,6 +15,7 @@ Feature: EBU-TT-D origin and extent conversion
         And region "r1" has attribute "extent" set to "14c 4c"
         And it contains some text with region "r1"
         When the document is generated
+        And the EBU-TT-Live document is denested
         And the EBU-TT-Live document is converted to EBU-TT-D
         Then the ebu_tt_d document contains region "r1" with attribute "origin" set to "31.25% 66.67%"
         And the ebu_tt_d document contains region "r1" with attribute "extent" set to "43.75% 26.67%"
@@ -27,6 +28,7 @@ Feature: EBU-TT-D origin and extent conversion
         And region "r1" has attribute "extent" set to "220px 100px"
         And it contains some text with region "r1"
         When the document is generated
+        And the EBU-TT-Live document is denested
         And the EBU-TT-Live document is converted to EBU-TT-D
         Then the ebu_tt_d document contains region "r1" with attribute "origin" set to "31.25% 75.0%"
         And the ebu_tt_d document contains region "r1" with attribute "extent" set to "34.38% 20.83%"
diff --git a/testing/bdd/templates/many_nested_elements_hardcoded.xml b/testing/bdd/templates/many_nested_elements_hardcoded.xml
new file mode 100644
index 000000000..dc967aea8
--- /dev/null
+++ b/testing/bdd/templates/many_nested_elements_hardcoded.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" ?>
+<tt:tt ebuttp:sequenceIdentifier="TestSequence" ebuttp:sequenceNumber="1" ttp:timeBase="media" xmlns:ebuttm="urn:ebu:tt:metadata" xmlns:ebuttp="urn:ebu:tt:parameters" xmlns:tt="http://www.w3.org/ns/ttml" xmlns:ttp="http://www.w3.org/ns/ttml#parameter" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:f="urn:foreign" xmlns:tts="http://www.w3.org/ns/ttml#styling" xmlns:ebutts="urn:ebu:tt:style" xml:lang="it">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata />
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center" />
+      <tt:style xml:id="S2" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center" />
+      <tt:style xml:id="S5" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center" />
+    </tt:styling>
+    <tt:layout />
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+    <tt:div xml:id="d1" style="S2">
+      <tt:metadata>
+        <ebuttm:facet expresses="has">Subtitle_Source_Facet is of type CUE</ebuttm:facet>
+      </tt:metadata>
+      <tt:div xml:id="d2" style="S1" xml:lang="fr">
+        <tt:p xml:id="p1">
+          <tt:span>text</tt:span>
+        </tt:p>
+        <tt:p xml:id="p3">
+          <tt:span>text</tt:span>
+        </tt:p>
+      </tt:div>
+
+      <tt:div>
+        <tt:p xml:id="p2">
+          <tt:span>text2</tt:span>
+        </tt:p>
+      </tt:div>
+    </tt:div>
+  </tt:body>
+</tt:tt>
\ No newline at end of file
diff --git a/testing/bdd/templates/many_unnested_elements_hardcoded.xml b/testing/bdd/templates/many_unnested_elements_hardcoded.xml
new file mode 100644
index 000000000..a69f3d4ec
--- /dev/null
+++ b/testing/bdd/templates/many_unnested_elements_hardcoded.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:f="urn:foreign"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xml:lang="it" >
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+      <tt:style xml:id="S2" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout/>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+      <tt:div xml:id="d2" style="S1 S2" >
+          <tt:metadata>
+              <ebuttm:facet expresses="has">Subtitle_Source_Facet is of type CUE</ebuttm:facet>
+            </tt:metadata>
+        <tt:p xml:id="p1">
+                <tt:span>text</tt:span>
+        </tt:p>
+      </tt:div>
+
+      <tt:div xml:id="d3" style="S1 S2" >
+          <tt:metadata>
+              <ebuttm:facet expresses="has">Subtitle_Source_Facet is of type CUE</ebuttm:facet>
+            </tt:metadata>
+        <tt:p xml:id="p2">
+                <tt:span>text2</tt:span>
+        </tt:p>
+      </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/nested_elements.xml b/testing/bdd/templates/nested_elements.xml
new file mode 100644
index 000000000..7d19ebcb3
--- /dev/null
+++ b/testing/bdd/templates/nested_elements.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xml:lang="en-GB"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:f="urn:foreign">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+      <f:foreignMetadata>Fake metadata</f:foreignMetadata>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c"  tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout/>
+  </tt:head>
+  <tt:body >
+      {% if divs %}
+    {% for div in divs %}
+     
+          <div {% if div.id %} xml:id ="{{div.id}}" {% endif %} begin="10s" end="12s" style="S1">
+                
+          </div>
+     {% endfor %}
+     {% endif %}
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/nested_elements_hardcoded.xml b/testing/bdd/templates/nested_elements_hardcoded.xml
new file mode 100644
index 000000000..a361f6940
--- /dev/null
+++ b/testing/bdd/templates/nested_elements_hardcoded.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:f="urn:foreign"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xml:lang="it" >
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout/>
+  </tt:head>
+  <tt:body >
+      <tt:div xml:id="d1" xml:lang="fr" begin="00:00:10" end="00:00:20">
+        <tt:div xml:id="d2" style="S1" begin="00:00:01" end="00:00:05" >
+          <tt:p xml:id="p1">
+                 <tt:span>text</tt:span>
+          </tt:p>
+        </tt:div>
+        <tt:div xml:id="d5" style="S1" xml:lang="en-GB" >
+            <tt:p xml:id="p3">
+                   <tt:span>text</tt:span>
+            </tt:p>
+          </tt:div>
+      </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/nested_elements_hardcoded_no_divs.xml b/testing/bdd/templates/nested_elements_hardcoded_no_divs.xml
new file mode 100644
index 000000000..82120bafc
--- /dev/null
+++ b/testing/bdd/templates/nested_elements_hardcoded_no_divs.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:f="urn:foreign"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xml:lang="it" >
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout/>
+  </tt:head>
+  <tt:body >
+    <tt:div xml:id="d1" style="S1"  >
+
+    </tt:div>
+    <tt:div xml:id="d2" style="S1"  >
+        <tt:p xml:id="p3">
+
+        </tt:p>
+      </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/nested_spans_hardcoded.xml b/testing/bdd/templates/nested_spans_hardcoded.xml
new file mode 100644
index 000000000..6333e4dd5
--- /dev/null
+++ b/testing/bdd/templates/nested_spans_hardcoded.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" ?>
+<tt:tt ebuttp:sequenceIdentifier="TestSequence" ebuttp:sequenceNumber="1" ttp:clockMode="local" ttp:timeBase="clock" xmlns:ebuttm="urn:ebu:tt:metadata" tts:extent="800px 600px" xmlns:ebuttp="urn:ebu:tt:parameters" xmlns:tt="http://www.w3.org/ns/ttml" xmlns:ttp="http://www.w3.org/ns/ttml#parameter" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:f="urn:foreign" xmlns:tts="http://www.w3.org/ns/ttml#styling" xmlns:ebutts="urn:ebu:tt:style" xml:lang="it">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata />
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="nest" tts:color="#614a3a" />
+      <tt:style xml:id="nestSizing" tts:color="#614a3a" tts:fontSize="50%" />
+      <tt:style xml:id="innerYellow" tts:color="#FFFF00" />
+      <tt:style xml:id="innerWhite" tts:color="#FFFFFF" tts:fontSize="150%" />
+      <tt:style xml:id="outer" tts:backgroundColor="#000000" tts:fontSize="200%" />
+      <tt:style xml:id="outerGreen" tts:backgroundColor="#00FF00" tts:fontSize="1.5c" />
+      <tt:style xml:id="innerRed" tts:color="#FF0000" tts:fontSize="2c" />
+    </tt:styling>
+    <tt:layout>
+      <tt:region xml:id="R1" tts:origin="14% 60%" tts:extent="71.25% 24%" style="outer" />
+    </tt:layout>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+    <tt:div xml:id="d1" xml:lang="fr" region="R1">
+      <tt:p xml:id="p1">
+        <tt:span xml:id="sp0" style="outer">
+          Parent text
+          <tt:span xml:id="sp1" style="innerYellow">text1</tt:span>
+          <tt:span xml:id="sp2" style="innerYellow">text133</tt:span>
+          <tt:span xml:id="sp3" style="innerWhite">text2</tt:span>
+          <tt:span xml:id="sp4">text3</tt:span>
+          <tt:span xml:id="sp5" style="innerRed">text 7</tt:span>
+        </tt:span>
+        <tt:span xml:id="s6" style="outerGreen">
+          <tt:span xml:id="sp7" style="innerRed">text 17</tt:span>
+          <tt:span style="innerYellow">ff</tt:span>
+        </tt:span>
+        <tt:span xml:id="sp8" style="nest">
+            <tt:span xml:id="sp9" style="nest">qwertyuiop</tt:span>
+        </tt:span>
+        <tt:span xml:id="sp10" style="nestSizing">
+            <tt:span xml:id="sp11" style="nestSizing">
+                <tt:span xml:id="sp12" style="nestSizing">qwertyuiop</tt:span>
+            </tt:span>
+        </tt:span>
+      </tt:p>
+    </tt:div>
+  </tt:body>
+</tt:tt>
\ No newline at end of file
diff --git a/testing/bdd/templates/p_regions_nested_elements.xml b/testing/bdd/templates/p_regions_nested_elements.xml
new file mode 100644
index 000000000..5dc9d862f
--- /dev/null
+++ b/testing/bdd/templates/p_regions_nested_elements.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:f="urn:foreign"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xml:lang="it" >
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:layout>
+        <tt:region xml:id="R1" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R2" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R3" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R4" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R5" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+      </tt:layout>
+  </tt:head>
+  <tt:body begin="123ms" dur="00:00:05">
+    <tt:div xml:id="D1"
+    {% if div_region != "*empty?*" %}
+    region="{{ div_region }}"
+    {% endif %}
+    >
+
+      <tt:p xml:id="P1"
+      {% if p1_region != "*empty?*" %}
+      region="{{ p1_region }}"
+      {% endif %}
+      >
+      hello
+      </tt:p>
+
+      {% if p2_region %}
+      <tt:p xml:id="P2" region="{{ p2_region }}" >
+      hello2
+      </tt:p>
+      {% endif %}
+    </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/regions_nested_elements_hardcoded.xml b/testing/bdd/templates/regions_nested_elements_hardcoded.xml
new file mode 100644
index 000000000..7b13aded6
--- /dev/null
+++ b/testing/bdd/templates/regions_nested_elements_hardcoded.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:f="urn:foreign"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xml:lang="it" >
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout>
+        <tt:region xml:id="R1" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R2" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+      </tt:layout>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+      <tt:div xml:id="d1" xml:lang="fr" region="R2">
+        <tt:div xml:id="d2" style="S1" region="R1" >
+          <tt:p xml:id="p1">
+                 <tt:span>text</tt:span>
+          </tt:p>
+        </tt:div>
+        <tt:div xml:id="d5" style="S1" xml:lang="en-GB" region="R2" >
+            <tt:p xml:id="p3">
+                   <tt:span>text</tt:span>
+            </tt:p>
+          </tt:div>
+      </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/regions_unnested_elements_hardcoded.xml b/testing/bdd/templates/regions_unnested_elements_hardcoded.xml
new file mode 100644
index 000000000..6e1c7c6fd
--- /dev/null
+++ b/testing/bdd/templates/regions_unnested_elements_hardcoded.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xml:lang="en-GB"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xmlns:f="urn:foreign">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout>
+        <tt:region xml:id="R1" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+        <tt:region xml:id="R2" tts:origin="14% 60%" tts:extent="71.25% 24%" />
+      </tt:layout>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+      <tt:div xml:id="d5" style="S1" xml:lang="en-GB"  region="R2">
+          <tt:p xml:id="p3">
+                 <tt:span>text</tt:span>
+          </tt:p>
+        </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/resolved_time_elements.xml b/testing/bdd/templates/resolved_time_elements.xml
index 96e79c7f4..b2874bd7f 100644
--- a/testing/bdd/templates/resolved_time_elements.xml
+++ b/testing/bdd/templates/resolved_time_elements.xml
@@ -98,6 +98,29 @@
 {% endif %}
               >
               Some example text...
+              {% if nestedSpan_begin or nestedSpan_end %}
+              <tt:span
+                {% if nestedSpan_begin %}
+                  {% if nestedSpan_begin == "*?Empty?*" %}
+                                begin=""
+                  {% else %}
+                                begin="{{ nestedSpan_begin }}"
+                  {% endif %}
+                {% endif %}
+                {% if nestedSpan_end %}
+                  {% if nestedSpan_end == "*?Empty?*" %}
+                                end=""
+                  {% else %}
+                                end="{{ nestedSpan_end }}"
+                  {% endif%}
+                {% endif %}
+                              >
+                              Some example text...
+                
+                              
+                            </tt:span>
+                {% endif %}
+
             </tt:span>
 {% endif %}
 
diff --git a/testing/bdd/templates/unnested_elements_hardcoded.xml b/testing/bdd/templates/unnested_elements_hardcoded.xml
new file mode 100644
index 000000000..38e24f710
--- /dev/null
+++ b/testing/bdd/templates/unnested_elements_hardcoded.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" ?>
+<tt:tt
+        ebuttp:sequenceIdentifier="TestSequence"
+        ebuttp:sequenceNumber="1"
+        ttp:clockMode="local"
+        ttp:timeBase="clock"
+        xml:lang="en-GB"
+        xmlns:ebuttm="urn:ebu:tt:metadata"
+        xmlns:ebuttp="urn:ebu:tt:parameters"
+        xmlns:tt="http://www.w3.org/ns/ttml"
+        xmlns:ttp="http://www.w3.org/ns/ttml#parameter"
+        xmlns:xml="http://www.w3.org/XML/1998/namespace"
+        xmlns:tts="http://www.w3.org/ns/ttml#styling"
+        xmlns:ebutts="urn:ebu:tt:style"
+        xmlns:f="urn:foreign">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata/>
+    </tt:metadata>
+    <tt:styling>
+      <tt:style xml:id="S1" tts:fontSize="1c 2c" ebutts:linePadding="1c" tts:lineHeight="2c" tts:textAlign="center"/>
+    </tt:styling>
+    <tt:layout/>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+      <tt:div xml:id="d2" style="S1">
+          <tt:p xml:id="p1">
+                 <tt:span>text</tt:span>
+          </tt:p>
+      </tt:div>
+  </tt:body>
+</tt:tt>
diff --git a/testing/bdd/templates/unnested_spans_hardcoded.xml b/testing/bdd/templates/unnested_spans_hardcoded.xml
new file mode 100644
index 000000000..606623a3a
--- /dev/null
+++ b/testing/bdd/templates/unnested_spans_hardcoded.xml
@@ -0,0 +1,65 @@
+<?xml version="1.0" ?>
+<tt:tt ebuttp:sequenceIdentifier="TestSequence" tts:extent="800px 600px" ebuttp:sequenceNumber="1" ttp:clockMode="local" ttp:timeBase="clock" xmlns:ebuttm="urn:ebu:tt:metadata" xmlns:ebuttp="urn:ebu:tt:parameters" xmlns:tt="http://www.w3.org/ns/ttml" xmlns:ttp="http://www.w3.org/ns/ttml#parameter" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:f="urn:foreign" xmlns:tts="http://www.w3.org/ns/ttml#styling" xmlns:ebutts="urn:ebu:tt:style" xml:lang="it">
+  <tt:head>
+    <tt:metadata>
+      <ebuttm:documentMetadata />
+    </tt:metadata>
+    <tt:styling>
+        <tt:style xml:id="nest" tts:color="#614a3a" />
+        <tt:style xml:id="nestSizing" tts:color="#614a3a" />
+        <tt:style xml:id="nestSizingnestSizing" tts:color="#614a3a" />
+        <tt:style xml:id="nestSizingnestSizingnestSizing" tts:color="#614a3a" />
+        <tt:style xml:id="innerYellow" tts:color="#FFFF00" />
+        <tt:style xml:id="innerRed" tts:color="#FF0000" />
+        <tt:style xml:id="innerWhite" tts:color="#FFFFFF" />
+        <tt:style tts:backgroundColor="#000000" xml:id="outer" />
+        <tt:style tts:backgroundColor="#000000" tts:color="#FFFF00" xml:id="outerinnerYellow" />
+        <tt:style tts:backgroundColor="#000000" tts:color="#FFFFFF" xml:id="outerinnerWhite" />
+        <tt:style xml:id="outerGreen" tts:backgroundColor="#00FF00" />
+        <tt:style xml:id="outerGreeninnerRed" tts:color="#FF0000" />
+        <tt:style xml:id="outerGreeninnerYellow" tts:color="#FFFF00" />
+        <tt:style xml:id="outerinnerRed" tts:backgroundColor="#000000" tts:color="#FF0000" />
+        <tt:style tts:fontSize="200.0%" xml:id="autogenFontStyle_None_200.0"/>
+        <tt:style tts:fontSize="300.0%" xml:id="autogenFontStyle_None_300.0"/>
+        <tt:style tts:fontSize="75.0%" xml:id="autogenFontStyle_None_75.0"/>
+        <tt:style tts:fontSize="50.0%" xml:id="autogenFontStyle_None_50.0"/>
+        <tt:style tts:fontSize="25.0%" xml:id="autogenFontStyle_None_25.0"/>
+        <tt:style tts:fontSize="12.5%" xml:id="autogenFontStyle_None_12.5"/>
+    </tt:styling>
+    <tt:layout>
+        <tt:region xml:id="R1" tts:origin="14% 60%" tts:extent="71.25% 24%" style="outer"/>
+      </tt:layout>
+  </tt:head>
+  <tt:body begin="500ms" dur="00:00:05">
+    <tt:div xml:id="d1" xml:lang="fr">
+      <tt:p style="autogenFontStyle_None_200.0" xml:id="p1">
+        <tt:span style="autogenFontStyle_None_200.0 outer">
+            Parent text
+        </tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outerinnerYellow">text1</tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer"></tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outerinnerYellow">text133</tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer"></tt:span>
+        <tt:span style="autogenFontStyle_None_300.0 outerinnerWhite">text2</tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer"></tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer">text3</tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer"></tt:span>
+        <tt:span style="outerinnerRed"></tt:span>
+        <tt:span style="autogenFontStyle_None_200.0 outer">text 7</tt:span>
+        <tt:span style="autogenFontStyle_None_75.0 outerGreen"></tt:span>
+        <tt:span xml:id="sp7" style="outerGreeninnerRed">text 17</tt:span>
+        <tt:span style="outerGreen"></tt:span>
+        <tt:span style="outerGreeninnerYellow">text 17</tt:span>
+        <tt:span style="outerGreen"></tt:span>
+        <tt:span xml:id="sp8" style="nest"></tt:span>
+        <tt:span xml:id="sp9" style="nest"></tt:span>
+        <tt:span style="nest"></tt:span>
+        <tt:span xml:id="sp10" style="autogenFontStyle_None_50.0 nestSizing"></tt:span>
+        <tt:span xml:id="sp11" style="autogenFontStyle_None_25.0 nestSizingnestSizing"></tt:span>
+        <tt:span xml:id="sp12" style="autogenFontStyle_None_12.5 nestSizingnestSizingnestSizing"></tt:span>
+        <tt:span style="autogenFontStyle_None_25.0 nestSizingnestSizing"></tt:span>
+        <tt:span style="autogenFontStyle_None_50.0 nestSizing"></tt:span>
+      </tt:p>
+    </tt:div>
+  </tt:body>
+</tt:tt>
\ No newline at end of file
diff --git a/testing/bdd/test_ebuttd_nested_elements.py b/testing/bdd/test_ebuttd_nested_elements.py
new file mode 100644
index 000000000..56d03d414
--- /dev/null
+++ b/testing/bdd/test_ebuttd_nested_elements.py
@@ -0,0 +1,107 @@
+import xml.etree.ElementTree as ET
+from pytest_bdd import scenarios, given, when, then, parsers
+
+scenarios('features/nesting/ebuttd_nested_elements.feature')
+
+@then('p elements do not have a region')
+def then_p_has_no_region(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div')
+    for element in elements:
+        for item in list(element):
+            if item.tag == "{http://www.w3.org/ns/ttml}p":
+                assert item.get("region") == None
+
+
+@then('there is one div containing one p')
+def then_p_has_been_removed(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div')
+    assert len(elements) == 1
+    assert len(elements[0]) == 1
+    assert elements[0][0].tag == "{http://www.w3.org/ns/ttml}p"
+
+@then('all divs contain at least one p element')
+def then_it_contains_no_divs(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body//{http://www.w3.org/ns/ttml}div')
+    for element in elements:
+        assert len(list(element)) != 0
+        p_count = 0
+        for p in list(element):
+            if p.tag == "{http://www.w3.org/ns/ttml}p":
+                p_count += 1
+        assert p_count > 0
+
+@then('no div contains any other divs')
+def then_div_contains_no_divs(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div')
+    for element in elements:
+        for child in list(element): 
+            assert child.tag != "{http://www.w3.org/ns/ttml}div"
+
+@then('no span contains any other spans')
+def then_span_contains_no_spans(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div/{http://www.w3.org/ns/ttml}p/{http://www.w3.org/ns/ttml}span')
+    for element in elements:
+        for tmp in list(element):
+            assert tmp.tag != "{http://www.w3.org/ns/ttml}span"
+
+@then('the second span\'s style is outerinnerYellow')
+def combine_span_styles(test_context):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div/{http://www.w3.org/ns/ttml}p/{http://www.w3.org/ns/ttml}span')
+    assert elements[1].get("style") == "autogenFontStyle_None_200.0 outerinnerYellow"
+
+@then(parsers.parse('there is no style named "{style_name}"'))
+def no_duplicate_styles(test_context, style_name):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}head/{http://www.w3.org/ns/ttml}styling/{http://www.w3.org/ns/ttml}style')
+    for element in elements:
+        assert element.get("{http://www.w3.org/XML/1998/namespace}id") != style_name
+
+
+@then(parsers.parse('any span with the style "{style_name}" also has the style "{size_style}"'))
+def percentage_size_for_nested_styles(test_context, style_name, size_style):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div/{http://www.w3.org/ns/ttml}p/{http://www.w3.org/ns/ttml}span')
+    for element in elements:
+        styles = element.get("style").split(" ")
+        if style_name in styles:
+            assert size_style in styles
+
+@when(parsers.parse('it contains a div with id "{div_id}"'))
+def given_div(test_context, template_dict, div_id):
+    if 'divs' not in template_dict:
+        template_dict['divs'] = list()
+    div = {"id": div_id}
+    template_dict['divs'].append(div)
+    test_context[div_id] = div
+      
+@when(parsers.parse('it has p_element "{p_id}"'))
+def when_it_contains_p_element(test_context, template_dict, p_id):
+    if 'p_elements' not in template_dict:
+        template_dict['p_elements'] = list()
+    p_element = {"id": p_id}
+    template_dict['p_elements'].append(p_element)
+    test_context[p_id] = p_element
+
+@when(parsers.parse('div "{div_id}" has element "{p_id}"'))
+def given_div_has_p_element(test_context, template_dict, div_id, p_id):
+    for i,div in enumerate(template_dict['divs']):
+        if div['id'] == div_id:
+            index = i
+    if 'p_elements' not in template_dict['divs'][index]:
+         template_dict['divs'][index]['p_elements'] = list()
+    p_element = test_context[p_id]
+    template_dict['divs'][index]['p_elements'].append(p_element)
diff --git a/testing/bdd/test_ebuttd_resolved_timings_on_elements.py b/testing/bdd/test_ebuttd_resolved_timings_on_elements.py
index 9918502c4..07eb0310d 100644
--- a/testing/bdd/test_ebuttd_resolved_timings_on_elements.py
+++ b/testing/bdd/test_ebuttd_resolved_timings_on_elements.py
@@ -22,6 +22,21 @@ def then_it_has_p_resulted_end_time(test_context, p_resulted_end_time):
     else:
         assert p_resulted_end_time == document_generated_p_end_time
 
+@then('nestedSpan resulted begin time is <nestedSpan_resulted_begin_time>')
+def then_it_has_nestedSpan_resulted_begin_time(test_context, nestedSpan_resulted_begin_time):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div/{http://www.w3.org/ns/ttml}p/{http://www.w3.org/ns/ttml}span')
+    document_generated_span_begin_time = elements[1].get('begin')
+    assert nestedSpan_resulted_begin_time == document_generated_span_begin_time
+
+@then('nestedSpan resulted end time is <nestedSpan_resulted_end_time>')
+def then_it_has_nestedSpan_resulted_end_time(test_context, nestedSpan_resulted_end_time):
+    document = test_context['ebuttd_document']
+    tree = ET.fromstring(document.get_xml())
+    elements = tree.findall('{http://www.w3.org/ns/ttml}body/{http://www.w3.org/ns/ttml}div/{http://www.w3.org/ns/ttml}p/{http://www.w3.org/ns/ttml}span')
+    document_generated_span_end_time = elements[1].get('end')
+    assert nestedSpan_resulted_end_time == document_generated_span_end_time
 
 @then('span1 resulted begin time is <span1_resulted_begin_time>')
 def then_it_has_span1_resulted_begin_time(test_context, span1_resulted_begin_time):
diff --git a/testing/bdd/test_elements_active_times.py b/testing/bdd/test_elements_active_times.py
index d824c5ada..ff2727523 100644
--- a/testing/bdd/test_elements_active_times.py
+++ b/testing/bdd/test_elements_active_times.py
@@ -20,9 +20,9 @@ def when_sequence_number(sequence_number, template_dict):
     template_dict['sequence_number'] = sequence_number
 
 @when('it is available at <availability_time>')
-def when_doc_available(test_context, availability_time):
+def when_doc_available(test_context, availability_time, template_dict):
     if availability_time:
-        test_context['document'].availability_time = FullClockTimingType(availability_time).timedelta
+        template_dict['availability_time'] = FullClockTimingType(availability_time).timedelta
 
 
 @then('body active begin time is <body_active_begin>')