diff --git a/conftest.py b/conftest.py
index c0cc3a2..eebc2ff 100644
--- a/conftest.py
+++ b/conftest.py
@@ -37,14 +37,18 @@ def pytest_configure():
             },
         ],
         SECRET_KEY="this-is-a-secret",
-        ANGLES={},
+        ANGLES={
+            "IS_IN_UNIT_TEST": True,
+        },
     )
 
 
 @pytest.fixture(autouse=True)
 def reset_settings(settings):
     # Make sure that ANGLES is empty before every test
-    settings.ANGLES = {}
+    settings.ANGLES = {
+        "IS_IN_UNIT_TEST": True,
+    }
 
     # Clear the tag map before every test
     clear_tag_map()
diff --git a/example/www/templates/www/base.html b/example/www/templates/www/base.html
index 342c84b..57df86b 100644
--- a/example/www/templates/www/base.html
+++ b/example/www/templates/www/base.html
@@ -22,6 +22,8 @@ <h1>
       <ul>
         <li>
           <a class="{% if request.path == "/include" %}current{% endif %}" href="/include">include</a>
+          <a class="{% if request.path == "/error-boundaries" %}current{% endif %}"
+            href="/error-boundaries">error-boundaries</a>
           <a class="{% if request.path == "/bird" %}current{% endif %}" href="/bird">django-bird</a>
         </li>
       </ul>
@@ -30,7 +32,10 @@ <h1>
 
   <main>
     <dj-block name='content'>
-    </dj-block name='content'>
+    </dj-block>
+
+    <dj-block name='extra-content'>
+    </dj-block>
   </main>
 
   <footer>
diff --git a/example/www/templates/www/components/error-fallback.html b/example/www/templates/www/components/error-fallback.html
new file mode 100644
index 0000000..7152a70
--- /dev/null
+++ b/example/www/templates/www/components/error-fallback.html
@@ -0,0 +1,3 @@
+<p>
+  This is an error fallback template.
+</p>
\ No newline at end of file
diff --git a/example/www/templates/www/components/include-bad-sub.html b/example/www/templates/www/components/include-bad-sub.html
new file mode 100644
index 0000000..618e2b9
--- /dev/null
+++ b/example/www/templates/www/components/include-bad-sub.html
@@ -0,0 +1,3 @@
+<div>
+  {{ invalid variable }}
+</div>
\ No newline at end of file
diff --git a/example/www/templates/www/components/include-bad.html b/example/www/templates/www/components/include-bad.html
new file mode 100644
index 0000000..028b510
--- /dev/null
+++ b/example/www/templates/www/components/include-bad.html
@@ -0,0 +1 @@
+<dj-include src="www/components/include-bad-sub.html"></dj-include>
\ No newline at end of file
diff --git a/example/www/templates/www/components/include.html b/example/www/templates/www/components/include.html
index 5d3f244..60e375f 100644
--- a/example/www/templates/www/components/include.html
+++ b/example/www/templates/www/components/include.html
@@ -1,5 +1,5 @@
 <div>
   <p>
-    This is a regular include.
+    This is a regular include. {{ request }} {{ bad }}
   </p>
 </div>
\ No newline at end of file
diff --git a/example/www/templates/www/error-boundaries.html b/example/www/templates/www/error-boundaries.html
new file mode 100644
index 0000000..db9d5bc
--- /dev/null
+++ b/example/www/templates/www/error-boundaries.html
@@ -0,0 +1,29 @@
+<dj-extends parent='www/base.html' />
+
+<dj-block name='content' error-boundary>
+  <dj-include src="www/components/include-bad.html" />
+</dj-block>
+
+<dj-block name='extra-content'>
+  <dj-error-boundary default='www/components/error-fallback.html'>
+    <dj-include src="www/components/include-bad.html" />
+  </dj-error-boundary>
+
+  <dj-error-boundary default='This is an error fallback string'>
+    <dj-include src="www/components/include-bad.html" />
+  </dj-error-boundary>
+
+  <dj-error-boundary>
+    <dj-include src="www/components/include-bad.html" />
+  </dj-error-boundary>
+
+  <dj-error-boundary>
+    <dj-include src="missing.html" />
+  </dj-error-boundary>
+
+  <dj-error-boundary>
+    <dj-include src="www/components/include.html" />
+  </dj-error-boundary>
+
+  <dj-include src="www/components/include.html" />
+</dj-block>
\ No newline at end of file
diff --git a/src/dj_angles/attributes.py b/src/dj_angles/attributes.py
index e5128db..63ebd32 100644
--- a/src/dj_angles/attributes.py
+++ b/src/dj_angles/attributes.py
@@ -74,6 +74,15 @@ def parse(self):
                 self._attributes.append(attribute)
                 attribute_keys.add(attribute.key)
 
+    def has(self, name: str) -> bool:
+        """Whether or not an there is an :obj:`~dj_angles.attributes.Attribute` by name.
+
+        Args:
+            param name: The name of the attribute.
+        """
+
+        return self.get(name) is not None
+
     def get(self, name: str) -> Optional[Attribute]:
         """Get an :obj:`~dj_angles.attributes.Attribute` by name. Returns `None` if the attribute is missing.
 
diff --git a/src/dj_angles/caseconverter/caseconverter.py b/src/dj_angles/caseconverter/caseconverter.py
index 5cced20..d6deb29 100644
--- a/src/dj_angles/caseconverter/caseconverter.py
+++ b/src/dj_angles/caseconverter/caseconverter.py
@@ -29,7 +29,7 @@ def stripable_punctuation(delimiters):
 
 
 class CaseConverter:
-    def __init__(self, s, delimiters=DELIMITERS, strip_punctuation=True):  # noqa: FBT002
+    def __init__(self, s, delimiters=DELIMITERS, *, strip_punctuation=True):
         """Initialize a case conversion.
 
         On initialization, punctuation can be optionally stripped. If
diff --git a/src/dj_angles/mappers/include.py b/src/dj_angles/mappers/include.py
index ad67c2a..16ccffa 100644
--- a/src/dj_angles/mappers/include.py
+++ b/src/dj_angles/mappers/include.py
@@ -73,11 +73,8 @@ def map_include(tag: "Tag") -> str:
         extension_idx = template_file.index(".")
         template_file = template_file[0:colon_idx] + template_file[extension_idx:]
 
-    if template := get_template(template_file):
+    if template := get_template(template_file, raise_exception=False):
         template_file = f"'{template.template.name}'"
-    else:
-        # Ignore missing template because an exception will be thrown when the component is being rendered
-        pass
 
     replacement = ""
 
diff --git a/src/dj_angles/mappers/mapper.py b/src/dj_angles/mappers/mapper.py
index 49aef64..477e14f 100644
--- a/src/dj_angles/mappers/mapper.py
+++ b/src/dj_angles/mappers/mapper.py
@@ -29,6 +29,7 @@
     "templatetag": "templatetag",
     "image": map_image,
     "css": map_css,
+    "error-boundary": lambda tag: "",  # noqa: ARG005  # the inner_html gets handled in `regex_replacer`
 }
 """Default mappings for tag names to Django template tags."""
 
@@ -65,7 +66,7 @@ def add_custom_mappers(self) -> None:
     def add_default_mapper(self) -> None:
         """Add default mapper if in settings, or fallback to the default mapper."""
 
-        default_mapper = get_setting("default_mapper", "dj_angles.mappers.default_mapper")
+        default_mapper = get_setting("default_mapper", default="dj_angles.mappers.default_mapper")
 
         if default_mapper is not None:
             # Add the default with a magic key of `None`
diff --git a/src/dj_angles/regex_replacer.py b/src/dj_angles/regex_replacer.py
index 3b942fa..c4e2018 100644
--- a/src/dj_angles/regex_replacer.py
+++ b/src/dj_angles/regex_replacer.py
@@ -1,6 +1,8 @@
 import re
 from collections import deque
+from typing import Optional
 
+from django.template import Context, Origin, Template, TemplateDoesNotExist, TemplateSyntaxError
 from minestrone import HTML
 
 from dj_angles.exceptions import InvalidEndTagError
@@ -9,7 +11,81 @@
 from dj_angles.tags import Tag
 
 
-def get_replacements(html: str, *, raise_for_missing_start_tag: bool = True) -> list[tuple[str, str]]:
+def set_tag_inner_html(html, match, tag):
+    if (
+        not tag.is_self_closing
+        and not tag.is_end
+        and (tag.django_template_tag is None or tag.is_include or tag.is_error_boundary)
+    ):
+        match_end_idx = match.end()
+
+        try:
+            # Get next ending tag
+            # TODO: handle custom tag, not just /dj-
+            next_ending_tag_idx = html.index("</dj-", match_end_idx)
+
+            if tag.is_error_boundary:
+                # Get next error boundary; they cannot be nested
+                next_ending_tag_idx = html.index(f"</dj-{tag.tag_name}>", match_end_idx)
+
+            tag.inner_html = html[match_end_idx:next_ending_tag_idx].strip()
+        except ValueError as e:
+            raise
+
+
+def check_for_missing_start_tag(raise_for_missing_start_tag, tag, tag_queue):
+    if raise_for_missing_start_tag:
+        if tag.is_end:
+            last_tag: Tag = tag_queue.pop()
+
+            if last_tag.tag_name != tag.tag_name:
+                raise InvalidEndTagError(tag=tag, last_tag=last_tag)
+        elif not tag.is_self_closing:
+            tag_queue.append(tag)
+
+
+def get_replacements_for_error_boundaries(tag_regex, origin, tag, replacements):
+    matches_to_skip = 0
+
+    if get_setting(key_path="error_boundaries", setting_name="enabled", default=True) is True:
+        if tag.is_error_boundary and tag.inner_html:
+            matches_to_skip = len(re.findall(tag_regex, tag.inner_html))
+
+            try:
+                parsed_inner_html = replace_django_template_tags(tag.inner_html)
+
+                # Parse the inner HTML and create a template
+                inner_html_template = Template(parsed_inner_html, origin=origin)
+
+                # It would be nice to pass in the template context here, but cannot
+                # find access to it with this process, so it is empty
+                inner_html_template.render(context=Context())
+
+                replacements.append((tag.inner_html, parsed_inner_html))
+            except (TemplateDoesNotExist, TemplateSyntaxError) as e:
+                error_html = tag.get_error_html(e)
+
+                replacements.append((tag.inner_html, error_html))
+
+    return matches_to_skip
+
+
+def get_slots(tag, replacements):
+    slots = []
+
+    # Parse the inner HTML for includes to handle slots
+    if get_setting("slots_enabled", default=False) and tag.inner_html:
+        for element in HTML(tag.inner_html).elements:
+            if slot_name := element.attributes.get("slot"):
+                slots.append((slot_name, element))
+
+                # Remove slot from the current HTML because it will be injected into the include component
+                replacements.append((tag.inner_html, ""))
+
+
+def get_replacements(
+    html: str, *, origin: Origin = None, raise_for_missing_start_tag: bool = True
+) -> list[tuple[str, str]]:
     """Get a list of replacements (tuples that consists of 2 strings) based on the template HTML.
 
     Args:
@@ -27,9 +103,15 @@ def get_replacements(html: str, *, raise_for_missing_start_tag: bool = True) ->
 
     tag_map = get_tag_map()
 
-    map_explicit_tags_only = get_setting("map_explicit_tags_only", False)
+    map_explicit_tags_only = get_setting("map_explicit_tags_only", default=False)
+
+    matches_to_skip = 0
 
     for match in re.finditer(tag_regex, html):
+        if matches_to_skip > 0:
+            matches_to_skip -= 1
+            continue
+
         tag_html = html[match.start() : match.end()].strip()
         tag_name = match.group("tag_name").strip()
         template_tag_args = match.group("template_tag_args").strip()
@@ -45,51 +127,21 @@ def get_replacements(html: str, *, raise_for_missing_start_tag: bool = True) ->
             tag_queue=tag_queue,
         )
 
-        if raise_for_missing_start_tag:
-            if tag.is_end:
-                last_tag: Tag = tag_queue.pop()
-
-                if last_tag.tag_name != tag.tag_name:
-                    raise InvalidEndTagError(tag=tag, last_tag=last_tag)
-            elif not tag.is_self_closing:
-                tag_queue.append(tag)
-
-        slots = []
-
-        # Parse the inner HTML for includes to handle slots
-        if (
-            get_setting("slots_enabled", default=False)
-            and not tag.is_self_closing
-            and not tag.is_end
-            and (tag.django_template_tag is None or tag.is_include)
-        ):
-            end_of_include_tag = match.end()
-
-            try:
-                # TODO: handle custom tag, not just /dj-
-                next_ending_tag_idx = html.index("</dj-", end_of_include_tag)
-                inner_html = html[end_of_include_tag:next_ending_tag_idx].strip()
+        set_tag_inner_html(html, match, tag)
 
-                if inner_html:
-                    for element in HTML(inner_html).elements:
-                        if slot_name := element.attributes.get("slot"):
-                            slots.append((slot_name, element))
+        check_for_missing_start_tag(raise_for_missing_start_tag, tag, tag_queue)
 
-                            # Remove slot from the current HTML because it will be injected into the include component
-                            replacements.append((inner_html, ""))
-            except ValueError:
-                # Ending tag could not be found, so skip getting the inner html
-                pass
+        matches_to_skip = get_replacements_for_error_boundaries(tag_regex, origin, tag, replacements)
 
-        django_template_tag = tag.get_django_template_tag(slots=slots)
+        slots = get_slots(tag, replacements)
 
-        if django_template_tag:
+        if django_template_tag := tag.get_django_template_tag(slots=slots):
             replacements.append((tag.html, django_template_tag))
 
     return replacements
 
 
-def replace_django_template_tags(html: str) -> str:
+def replace_django_template_tags(html: str, origin: Optional[Origin] = None) -> str:
     """Gets a list of replacements based on template HTML, replaces the necessary strings, and returns the new string.
 
     Args:
@@ -99,7 +151,7 @@ def replace_django_template_tags(html: str) -> str:
         The converted template HTML.
     """
 
-    replacements = get_replacements(html=html)
+    replacements = get_replacements(html=html, origin=origin)
 
     for r in replacements:
         html = html.replace(
diff --git a/src/dj_angles/settings.py b/src/dj_angles/settings.py
index df4755e..58dc186 100644
--- a/src/dj_angles/settings.py
+++ b/src/dj_angles/settings.py
@@ -5,19 +5,28 @@
 from django.conf import settings
 
 
-def get_setting(setting_name: str, default=None) -> Any:
-    """Get a `dj-angles` setting from the `ANGLES` setting dictionary.
+def get_setting(setting_name: str, key_path: str = "", default: Any = None) -> Any:
+    """Get a setting from the `ANGLES` dictionary in settings.
 
     Args:
         param setting_name: The name of the setting.
+        param key_path: The name of the sub-dictionary under `ANGLES`.
         param default: The value that should be returned if the setting is missing.
     """
 
     if not hasattr(settings, "ANGLES"):
         settings.ANGLES = {}
 
-    if setting_name in settings.ANGLES:
-        return settings.ANGLES[setting_name]
+    data = settings.ANGLES
+
+    if key_path:
+        if key_path not in data:
+            data[key_path] = {}
+
+        data = data[key_path]
+
+    if setting_name in data:
+        return data[setting_name]
 
     return default
 
diff --git a/src/dj_angles/tags.py b/src/dj_angles/tags.py
index 8bb2809..c4db9b0 100644
--- a/src/dj_angles/tags.py
+++ b/src/dj_angles/tags.py
@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
+from django.conf import settings
 from minestrone import Element
 
 from dj_angles.attributes import Attributes
@@ -8,11 +9,20 @@
 from dj_angles.mappers.angles import map_angles_include
 from dj_angles.mappers.mapper import TagMap
 from dj_angles.settings import get_setting
+from dj_angles.strings import dequotify
+from dj_angles.templates import get_template
 
 if TYPE_CHECKING:
     from collections import deque
 
 
+SHADOW_ATTRIBUTE_KEY = "shadow"
+ERROR_FALLBACK_ATTRIBUTE_KEY = "default"
+
+ERROR_BOUNDARY_ATTRIBUTE_KEY = "error-boundary"
+ERROR_BOUNDARY_TAG_NAMES = ["block"]
+
+
 class Tag:
     """Encapsulates metadata and functionality for a tag that will be processed by `dj-angles`."""
 
@@ -42,6 +52,14 @@ class Tag:
     start_tag: Optional["Tag"] = None
     """The associated start tag. Only set for end tags."""
 
+    is_error_boundary: bool = False
+    """Whether or not the tag should handle errors."""
+
+    error_fallback: Optional[str] = ""
+    """What to display if there is an error. Can be a string or a template."""
+
+    inner_html: Optional[str] = None
+
     def __init__(
         self,
         tag_map: TagMap,
@@ -54,17 +72,26 @@ def __init__(
         self.tag_name = tag_name
 
         self._template_tag_args = template_tag_args
+        self.attributes = None
         self.parse_attributes()
 
         if self.tag_name.endswith("!"):
             self.tag_name = self.tag_name[:-1]
             self.is_shadow = True
-        else:
-            shadow_attribute = self.attributes.get("shadow")
-
-            if shadow_attribute:
+        elif self.attributes:
+            if self.attributes.has(SHADOW_ATTRIBUTE_KEY):
                 self.is_shadow = True
-                self.attributes.remove(shadow_attribute.key)
+                self.attributes.remove(SHADOW_ATTRIBUTE_KEY)
+
+        if self.tag_name == "error-boundary":
+            self.is_error_boundary = True
+        elif self.tag_name in ERROR_BOUNDARY_TAG_NAMES and self.attributes.has(ERROR_BOUNDARY_ATTRIBUTE_KEY):
+            self.is_error_boundary = True
+            self.attributes.remove(ERROR_BOUNDARY_ATTRIBUTE_KEY)
+
+        if self.is_error_boundary and self.attributes.has(ERROR_FALLBACK_ATTRIBUTE_KEY):
+            self.error_fallback = dequotify(self.attributes.get(ERROR_FALLBACK_ATTRIBUTE_KEY).value)
+            self.attributes.remove(ERROR_FALLBACK_ATTRIBUTE_KEY)
 
         if get_setting("lower_case_tag", default=False) is True:
             self.tag_name = self.tag_name.lower()
@@ -88,8 +115,84 @@ def __init__(
     def parse_attributes(self):
         """Creates `Attributes` based on the template tag arguments."""
 
+        # print("self._template_tag_args", self._template_tag_args)
         self.attributes = Attributes(self._template_tag_args)
 
+        if self.is_shadow and self.attributes.has(SHADOW_ATTRIBUTE_KEY):
+            self.attributes.remove(SHADOW_ATTRIBUTE_KEY)
+
+    def get_error_html(self, exception: Exception) -> str:
+        """Get HTML for the tag when there is an error."""
+
+        if self.error_fallback:
+            if fallback_template := get_template(self.error_fallback, raise_exception=False):
+                return fallback_template.render()
+
+            return self.error_fallback
+
+        html = ""
+
+        if hasattr(exception, "template_debug"):
+            template_debug = exception.template_debug
+            source = template_debug["name"]
+
+            if hasattr(settings, "BASE_DIR"):
+                original_source = source
+                source = source.replace(str(settings.BASE_DIR), "")
+
+                if original_source != source and source.startswith("/"):
+                    source = source[1:]
+
+            during = template_debug["during"]
+            during = during.replace("{", "&#123;").replace("}", "&#125;")
+            during = f"<pre><code>{{% verbatim %}}{during}{{% endverbatim %}}</code></pre>"
+
+            if source == "<unknown source>":
+                html = f"""<h2>
+  {template_debug["message"]}
+</h2>
+<p>
+  {during}
+</p>"""
+            else:
+                error = template_debug["message"]
+
+                if hasattr(exception, "tried"):
+                    error = f"Could not find the template: '{error}'"
+
+                    if exception.tried:
+                        error = f"{error}: {', '.join(exception.tried)}"
+
+                if not error.endswith("."):
+                    error = f"{error}."
+
+                html = f"""<h2>
+  {source}
+</h2>
+<p>
+  <em>{error}</em>
+</p>
+<p>
+  {during}
+</p>
+"""
+        else:
+            html = f"<em>{exception}</em>"
+
+        error_style = get_setting(
+            key_path="error_boundaries",
+            setting_name="style",
+            default="border: 1px red solid; padding: 0 24px 0 24px;",
+        )
+        error_class = get_setting(key_path="error_boundaries", setting_name="class", default="")
+
+        html = f"<div style='{error_style}' class='{error_class}'>{html}</div>"
+
+        if get_setting(key_path="error_boundaries", setting_name="shadow", default=True):
+            html = f'<div><template shadowrootmode="open">{html}</template></div>'
+
+        return html
+
     def get_django_template_tag(self, slots: Optional[list[tuple[str, Element]]] = None) -> str:
         """Generate the Django template tag.
 
diff --git a/src/dj_angles/template_loader.py b/src/dj_angles/template_loader.py
index 5472260..7f82e11 100644
--- a/src/dj_angles/template_loader.py
+++ b/src/dj_angles/template_loader.py
@@ -9,7 +9,7 @@
 
 class Loader(AppDirectoriesLoader):
     def _get_template_string(self, template_name):
-        """Get the string content a template."""
+        """Get the string content as a template."""
 
         try:
             with open(template_name, encoding=self.engine.file_charset) as f:
@@ -21,7 +21,7 @@ def get_contents(self, origin) -> str:
         """Gets the converted template contents."""
 
         template_string = self._get_template_string(origin.name)
-        converted_template_string = replace_django_template_tags(template_string)
+        converted_template_string = replace_django_template_tags(template_string, origin=origin)
 
         return converted_template_string
 
diff --git a/src/dj_angles/templates.py b/src/dj_angles/templates.py
index 0682b25..17622b8 100644
--- a/src/dj_angles/templates.py
+++ b/src/dj_angles/templates.py
@@ -7,11 +7,12 @@
 from dj_angles.strings import dequotify
 
 
-def get_template(template_file: str) -> Optional[Template]:
+def get_template(template_file: str, *, raise_exception: bool = False) -> Optional[Template]:
     """Check for the template file by looking for different template file variations.
 
-    Currently, the only other variation is looking for the template file with an underscore
-    in front (a typical convention for partials).
+    Variations:
+        - template file with an ".html" extension if there is no extension
+        - template file with an underscore in front (a typical convention for partials)
 
     Args:
         param template_file: The original template file name.
@@ -25,6 +26,9 @@ def get_template(template_file: str) -> Optional[Template]:
     template_file = dequotify(template_file)
     template_file_list = [template_file]
 
+    if "." not in template_file:
+        template_file_list.append(f"{template_file}.html")
+
     if not template_file.startswith("_"):
         if "/" in template_file:
             # Grab the last part and prepend an underscore to it, then reassemble the path
@@ -41,6 +45,7 @@ def get_template(template_file: str) -> Optional[Template]:
     try:
         template = select_template(template_file_list)
     except TemplateDoesNotExist:
-        pass
+        if raise_exception:
+            raise
 
     return template
diff --git a/tests/dj_angles/mappers/mapper/test_get_tag_map.py b/tests/dj_angles/mappers/mapper/test_get_tag_map.py
index b95453d..bcce40f 100644
--- a/tests/dj_angles/mappers/mapper/test_get_tag_map.py
+++ b/tests/dj_angles/mappers/mapper/test_get_tag_map.py
@@ -5,7 +5,7 @@ def test_default():
     expected = "default_mapper"
     actual = get_tag_map()
 
-    assert len(actual) == 21
+    assert len(actual) == 22
     assert actual[None].__name__ == expected
 
 
@@ -14,5 +14,5 @@ def test_none_default_mapper(settings):
 
     actual = get_tag_map()
 
-    assert len(actual) == 20
+    assert len(actual) == 21
     assert actual.get(None) is None
diff --git a/tests/dj_angles/regex_replacer/test_get_replacements.py b/tests/dj_angles/regex_replacer/test_get_replacements.py
index 59dc662..5209cbd 100644
--- a/tests/dj_angles/regex_replacer/test_get_replacements.py
+++ b/tests/dj_angles/regex_replacer/test_get_replacements.py
@@ -178,7 +178,7 @@ def test_no_extension(template_string, replacement_string):
     ),
 )
 def test_initial_tag_regex(template_string, replacement_string, settings):
-    settings.ANGLES = {"initial_tag_regex": r"(dj-|\$)"}
+    settings.ANGLES.update({"initial_tag_regex": r"(dj-|\$)"})
 
     expected = [
         (template_string, replacement_string),
@@ -198,11 +198,13 @@ def test_initial_tag_regex(template_string, replacement_string, settings):
     ),
 )
 def test_initial_tag_regex_for_react_style(template_string, replacement_string, settings):
-    settings.ANGLES = {
-        "initial_tag_regex": r"(dj-|(?=[A-Z]))",
-        "lower_case_tag": False,
-        "kebab_case_tag": False,
-    }
+    settings.ANGLES.update(
+        {
+            "initial_tag_regex": r"(dj-|(?=[A-Z]))",
+            "lower_case_tag": False,
+            "kebab_case_tag": False,
+        }
+    )
 
     expected = [
         (template_string, replacement_string),
@@ -222,7 +224,7 @@ def test_initial_tag_regex_for_react_style(template_string, replacement_string,
     ),
 )
 def test_lower_case_tag(template_string, replacement_string, settings):
-    settings.ANGLES = {"initial_tag_regex": r"(dj-|(?=[A-Z]))", "lower_case_tag": True}
+    settings.ANGLES.update({"initial_tag_regex": r"(dj-|(?=[A-Z]))", "lower_case_tag": True})
 
     expected = [
         (template_string, replacement_string),
@@ -246,7 +248,7 @@ def test_lower_case_tag(template_string, replacement_string, settings):
     ),
 )
 def test_kebab_case_tag(template_string, replacement_string, settings):
-    settings.ANGLES = {"initial_tag_regex": r"(?=[A-Z])", "kebab_case_tag": True}
+    settings.ANGLES.update({"initial_tag_regex": r"(?=[A-Z])", "kebab_case_tag": True})
 
     expected = [
         (template_string, replacement_string),
@@ -266,12 +268,14 @@ def test_kebab_case_tag(template_string, replacement_string, settings):
     ),
 )
 def test_mappers_string(template_string, replacement_string, settings):
-    settings.ANGLES = {
-        "initial_tag_regex": None,
-        "mappers": {
-            "blob": "include",
-        },
-    }
+    settings.ANGLES.update(
+        {
+            "initial_tag_regex": None,
+            "mappers": {
+                "blob": "include",
+            },
+        }
+    )
     clear_tag_map()
 
     expected = [
@@ -292,10 +296,12 @@ def test_mappers_string(template_string, replacement_string, settings):
     ),
 )
 def test_mappers_callable(template_string, replacement_string, settings):
-    settings.ANGLES = {
-        "initial_tag_regex": None,
-        "mappers": {"blob": lambda tag: "blob2"},  # noqa: ARG005
-    }
+    settings.ANGLES.update(
+        {
+            "initial_tag_regex": None,
+            "mappers": {"blob": lambda tag: "blob2"},  # noqa: ARG005
+        }
+    )
     clear_tag_map()
 
     expected = [
diff --git a/tests/dj_angles/regex_replacer/test_replace_django_template_tags.py b/tests/dj_angles/regex_replacer/test_replace_django_template_tags.py
index 1f0ade9..5c1703e 100644
--- a/tests/dj_angles/regex_replacer/test_replace_django_template_tags.py
+++ b/tests/dj_angles/regex_replacer/test_replace_django_template_tags.py
@@ -121,7 +121,7 @@ def test_short_include_shadow():
     assert actual == expected
 
 
-def test_short_include_self_closing_shadow():
+def test_short_include_self_closing_shadow_bang():
     expected = "<dj-partial><template shadowrootmode='open'>{% include 'partial.html' %}</template></dj-partial>"
 
     template = "<dj-partial! />"
@@ -130,6 +130,15 @@ def test_short_include_self_closing_shadow():
     assert actual == expected
 
 
+def test_short_include_self_closing_shadow():
+    expected = "<dj-partial><template shadowrootmode='open'>{% include 'partial.html' %}</template></dj-partial>"
+
+    template = "<dj-include template='partial.html' shadow />"
+    actual = replace_django_template_tags(template)
+
+    assert actual == expected
+
+
 def test_include_no_extension():
     expected = "<dj-partial>{% include 'partial.html' %}</dj-partial>"
 
@@ -307,3 +316,21 @@ def test_short_include_underscore_in_subdirectory():
     actual = replace_django_template_tags(template)
 
     assert actual == expected
+
+
+def test_with():
+    expected = '<dj-www-components-include>{% include "www/components/include.html" with request=request only %}</dj-www-components-include>'
+
+    template = '<dj-include src="www/components/include.html" with request=request only></dj-include>'
+    actual = replace_django_template_tags(template)
+
+    assert actual == expected
+
+
+def test_with_only():
+    expected = '<dj-www-components-include>{% include "www/components/include.html" with request=request %}</dj-www-components-include>'
+
+    template = '<dj-include src="www/components/include.html" with request=request></dj-include>'
+    actual = replace_django_template_tags(template)
+
+    assert actual == expected
diff --git a/tests/templates/invalid_variable.html b/tests/templates/invalid_variable.html
new file mode 100644
index 0000000..9e21ec9
--- /dev/null
+++ b/tests/templates/invalid_variable.html
@@ -0,0 +1 @@
+{{ invalid variable }}
\ No newline at end of file