diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..048ee8d
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,103 @@
+name: Run Python Tests
+on: push
+
+jobs:
+  build-macos:
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    runs-on: "macos-latest"
+    steps:
+      - name: Install md5sha1sum
+        run: brew install md5sha1sum
+      - uses: actions/checkout@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.5.1
+          virtualenvs-in-project: true
+      - name: Install dependencies
+        run: poetry install --no-interaction --no-root
+      - name: Install library
+        run: poetry install --no-interaction
+      - name: Run tests
+        run: poetry run make tests
+      - uses: psf/black@stable
+        with:
+          options: "--check --verbose"
+          src: "./"
+          version: "23.3"
+      - uses: isort/isort-action@v1
+  build-linux:
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: Install libxml2
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2 libxml2-dev libxslt1-dev
+      - uses: actions/checkout@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.5.1
+          virtualenvs-in-project: true
+      - name: Install dependencies
+        run: poetry install --no-interaction --no-root
+      - name: Install library
+        run: poetry install --no-interaction
+      - name: Run tests
+        run: poetry run make tests
+      - uses: psf/black@stable
+        with:
+          options: "--check --verbose"
+          src: "./"
+          version: "23.3"
+      - uses: isort/isort-action@v1
+  build-windows:
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    runs-on: "windows-latest"
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.5.1
+          virtualenvs-in-project: true
+      - name: Install dependencies
+        run: poetry install --no-interaction --no-root
+      - name: Install library
+        run: poetry install --no-interaction
+      - name: Run tests
+        run: poetry run make tests
+      - uses: psf/black@stable
+        with:
+          options: "--check --verbose"
+          src: "./"
+          version: "23.3"
+      # - uses: isort/isort-action@v1
diff --git a/.gitignore b/.gitignore
index 7f90a96..1a4195c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,5 @@ mf2py.egg-info/
 nbproject/
 venv/
 *~
+poetry.lock
+site/
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index e69de29..0000000
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 4e942d3..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-language: python
-python:
-  - "2.7"
-  - "3.3"
-  - "3.4"
-  - "3.5"
-  - "3.6"
-  - "pypy"
-  - "pypy3"
-sudo: false
-# command to install dependencies
-install: "pip install -r requirements.txt"
-# command to run tests
-script: nosetests --exclude=test_suite
diff --git a/AUTHORS b/AUTHORS
deleted file mode 100644
index 3e99d23..0000000
--- a/AUTHORS
+++ /dev/null
@@ -1,5 +0,0 @@
-Tom Morris <tom@tommorris.org> http://tommorris.org/
-Barnaby Walters http://waterpigs.co.uk
-Kartik Prabhu <me@kartikprabhu.com> https://kartikprabhu.com
-Kyle Mahan <kyle@kylewm.com> https://kylewm.com
-Kevin Marks  <kevinmarks@gmail.com> http://www.kevinmarks.com/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b78ecc8..1d4404b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,48 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 2.0.1 - 2023-12-07
+The mf2py library is excited to transition into 2.0. This version increase incorporates months of work from contributors, informed by active discussions among implementers and users.
+
+This release officially deprecates support for versions of Python lower than 3.8.
+
+Below are the changes we have made in this release.
+
+### New Features
+- Enable `img_with_alt` by default (#184)
+- Add timezone offset normalisation (#206)
+- Add option for exposing DOM for embedded properties (#208)
+- Add srcset support (#209)
+- Add language support (#210)
+- Add option for filtering root class names (#211)
+- Add option for metaformats support (#213)
+
+### Changes
+- Remove `img_with_alt` option entirely (#200)
+- Resolve implied photo relative paths (#205)
+- Make relative URLs in embedded properties absolute (#201)
+- Fix whitespace in plaintext conversion (#207)
+- Replace `dict_class` with standard `dict` (#196)
+
+### Tests, Library and Documentation Maintenance
+- Update tests to include alt texts by default (#190)
+- Add Windows and macOS tests (#198)
+- Use poetry for dependency management (#189)
+- Deprecate Python 2 support (#179)
+- Lint code with `black` and `isort`
+- Add linting CI actions (#193)
+- Move from `nosetests` to `pytest` (#186)
+- Add 3.11, 3.12 and drop pypy from test matrix; upgrade poetry action (#204)
+- Prepare tests to test options (#214)
+- Bring README doctests up-to-date (#215)
+
+## 1.1.3 - 2022-06-28
+- reduce instances where photo is implied (#135)
+- always do relative URL resolution (#138)
+- VCP now handles tz offsets without leading zeros (#142)
+- implement id parsing (#143)
+- fix outdated syntax causing SyntaxWarning (#157)
+
 ## 1.1.2 - 2018-08-08
 - add parsing for iframe.u-*[src] (#116)
 - bug fix: reduced implied urls (#117)
@@ -10,9 +52,8 @@ All notable changes to this project will be documented in this file.
 - misc performance improvements
 
 ## 1.1.1 - 2018-06-15
-
 - streamline backcompat to use JSON only.
-- fix multiple mf1 root rel-tag parsing 
+- fix multiple mf1 root rel-tag parsing
 - correct url and photo for hreview.
 - add rules for nested hreview. update backcompat to use multiple matches in old properties.
 - fix `rel-tag` to `p-category` conversion so that other classes are not lost.
@@ -22,16 +63,15 @@ All notable changes to this project will be documented in this file.
 - fix `parse` method to use default html parser.
 - always use the first value for attributes for rels.
 - correct AM/PM conversion in datetime value class pattern.
- - add ordinal date parsing to datetimes value class pattern. ordinal date is normalised to YYYY-MM-DD
+- add ordinal date parsing to datetimes value class pattern. ordinal date is normalised to YYYY-MM-DD
 - remove hack for html tag classes since that is fixed in new BS
 - better whitespace algorithm for `name` and `html.value` parsing
 - experimental flag for including `alt` in `u-photo` parsing
 - make a copy of the BeautifulSoup given by user to work on for parsing to prevent changes to original doc
-- bump version to 1.1.1 
+- bump version to 1.1.1
 
 ## 1.1.0 - 2018-03-16
-
-- bump version to 1.1.0 since it is a "major" change 
+- bump version to 1.1.0 since it is a "major" change
 - added tests for new implied name rules
 - modified earlier tests to accommodate new rules
 - use space separator instead of "T"
@@ -44,22 +84,20 @@ All notable changes to this project will be documented in this file.
 - reorganise tests
 - remove Heroku frontend, point to mf2py-web and python.microformats.io instead in README.
 - remove Flask and gunicorn requirements
-- add debug info with description, version, url and the html parser used 
+- add debug info with description, version, url and the html parser used
 
 ## 1.0.6 - 2018-03-04
-
 - strip leading/trailing white space for `e-*[html]`. update the corresponding tests
-- blank values explicitly authored are allowed as property values 
+- blank values explicitly authored are allowed as property values
 - include `alt` or `src` from `<img>` in parsing for `p-*` and `e-*[value]`
-- parse `title` from `<link>` for `p-*` resolves #84 
-- and `poster` from `<video>` for `u-*` resolves #76 
+- parse `title` from `<link>` for `p-*` resolves #84
+- and `poster` from `<video>` for `u-*` resolves #76
 - use `html5lib` as default parser
-- use the final redirect URL resolves #62 
+- use the final redirect URL resolves #62
 - update requirements to use BS4 v4.6.0 and html5lib v1.0.1
 - drop support for Python 2.6 as html5lib dropped support
 
 ## 1.0.5 - 2016-05-09
-
 - Implied property checks now ignore alt="", treating it the same as
   if no alt value is defined.
 - Support for using a custom dict implementation by setting
@@ -67,17 +105,14 @@ All notable changes to this project will be documented in this file.
   output for hosted parsers.
 
 ## 1.0.4 - 2016-03-21
-### Changed
 - Performance improvement changing simple calls to soup.find_all to
   a manual iteration over .contents.
 
 ## 1.0.3 - 2016-02-05
-### Changed
 - Performance improvement by limiting number of calls to soup.find_all
   in backcompat module. Should not be any functional changes.
 
 ## 1.0.2 - 2016-01-26
-### Added
 - Backward compatibility parsing for rel=tag properties. These are now converted
   to p-category based on the last path segment of the tag URI as spec'd in
   http://microformats.org/wiki/h-entry#Parser_Compatibility
@@ -85,59 +120,47 @@ All notable changes to this project will be documented in this file.
   should use (e.g., "lxml" or "html5lib")
 
 ## 1.0.1 - 2015-12-11
-### Changed
 - `u-*` properties are now parsed from `<link>` elements per the updated spec
   http://microformats.org/wiki/microformats2-parsing-issues#link_elements_and_u-_parsing
 
 ## 1.0.0 - 2015-10-05
-### Changed
 - Version number bumped to 1.0.0 following community discussion.
 
 ## 0.2.8 - 2015-09-21
-### Changed
 - Stricter checks that Parser.__init__ params are actually None before
   ignoring them.
 
 ## 0.2.7 - 2015-08-03
-### Changed
 - Now produces unicode strings for every key and value, no more byte
   strings anywhere.
 - Do not add 'T' between date and time when normalizing dates
-### Added
 - Unit tests for running the microformats test suite
 
 ## 0.2.6 - 2015-05-06
-### Added
 - New top-level "rel-urls" entry, contains rich data parsed from rel
   links, organized by URL.
 
 ## 0.2.5 - 2015-03-01
-### Added
 - convenience method `mf2py.parse` that takes the same arguments as Parser
   and returns a dict.
-### Changed
 - nested h-* classes now parse their "value" based on the property
   they represent (p-*, u-*, dt-*), so for example "p-in-reply-to
   h-cite" would have a name as its value and "u-in-reply-to h-cite"
   will have a URL.
 
 ## 0.2.4 - 2015-02-13
-### Added
 - Add rel=bookmark to backward compat parsing rules based (translated
   to u-url in mf2)
-### Changed
 - Parser constructor now takes explicit named arguments instead of
   **kwargs, for saner behavior when called with unnamed arguments.
 - Bugfix: Empty href="" attributes are now properly interpreted as
   the current document's URL.
 
 ## 0.2.3 - 2015-02-07
-### Changed
 - Minor Py3 compatibility fix
 - Correct typo `test_requires` -> `tests_require` in setup.py
 
 ## 0.2.2 - 2015-02-05
-### Changed
 - Started keeping a changelog!
 - Use a better method for extracting HTML for an e-* property
 - Correct BeautifulSoup4 dependency in setup.py to fix error with
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..4da8ff5
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,56 @@
+# Contributing to mf2py 🛠️
+
+Thank you for your interest in contributing to mf2py! In this document, we outline all you need to know to submit a contribution to the mf2py project.
+
+## Contribution Guidelines
+
+We welcome contributions to:
+
+1. Add new parsing features to the library (see *Adding Parsing Features* below for more information).
+2. Improve documentation.
+3. Report bugs and issues.
+4. Submit a request for a new feature.
+5. Add more test cases.
+
+We encourage you to submit an Issue to discuss any new feature requests before submitting a PR.
+
+### Adding Parsing Features
+
+As the official `mf2py` parser, we will only implement new parsing features after they have been ratified into the Microformats parsing standard, or have achieved sufficient support among contributors to parsing discussions and requires implementations. The [microformats2 parsing](https://github.com/microformats/microformats2-parsing/issues) repository is the offical home to all issues pertaining to microformats2 parsing.
+
+## How to Contribute Changes
+
+First, fork this repository to your own GitHub account. Create a new branch that describes your changes (i.e. `line-counter-docs`). Push your changes to the branch on your fork and then submit a pull request to this repository.
+
+When creating new functions, please ensure you have the following:
+
+1. Docstrings for the function and all parameters.
+2. Unit tests for the function.
+3. Examples in the documentation for any public functions.
+4. Created an entry in our docs to autogenerate the documentation for the function, if the function is public.
+
+All pull requests will be reviewed by the maintainers of the project. We will provide feedback and ask for changes if necessary.
+
+PRs must pass all tests and linting requirements before they can be merged.
+
+## Code Quality
+
+Before you submit a PR to `mf2py`, run the following command in the base directory of the project:
+
+```bash
+make lint
+```
+
+This will format your code using the linters configured with the project.
+
+## Tests
+
+Before you submit a PR, please run the `mf2py` test suite on your code. You can do so using the following command:
+
+```bash
+make test
+```
+
+## Join the Microformats Community
+
+Have a question about microformats or mf2py? Join the `#microformats` disussion on Slack, Discord, or IRC. Guidance on how to join the community is available on the [IndieWeb wiki](https://indieweb.org/discuss).
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
new file mode 100644
index 0000000..e9c1d39
--- /dev/null
+++ b/CONTRIBUTORS.md
@@ -0,0 +1,11 @@
+# Contributors
+
+- Tom Morris <tom@tommorris.org> https://tommorris.org
+- Barnaby Walters https://waterpigs.co.uk
+- Kartik Prabhu <me@kartikprabhu.com> https://kartikprabhu.com
+- Kyle Mahan https://github.com/kylewm
+- Kevin Marks <kevinmarks@gmail.com> https://www.kevinmarks.com
+- James <jamesg@jamesg.blog> https://jamesg.blog
+- Angelo Gladding <angelo@ragt.ag> https://ragt.ag
+- Paweł Miech https://pawelmhm.github.io
+- Sven Knebel https://www.svenknebel.de
diff --git a/Makefile b/Makefile
index 951eeb4..e3b90f4 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,13 @@
-all:
-	pip install -r requirements.txt
-test:
-	nosetests
+install:
+	poetry install
+tests:
+	poetry run pytest -s -vv --doctest-modules --doctest-glob README*
+lint:
+	poetry run black .
+	poetry run isort .
+docs_dev:
+	poetry run mkdocs serve
+docs_deploy:
+	poetry run mkdocs gh-deploy
+publish:
+	poetry publish --build
diff --git a/README.md b/README.md
index aed7788..be0ccb6 100644
--- a/README.md
+++ b/README.md
@@ -1,82 +1,148 @@
-mf2py
-=====
+![mf2py banner](https://microformats.github.io/mf2py/banner.png)
 
-[![Build Status](https://travis-ci.org/microformats/mf2py.svg?branch=master)](https://travis-ci.org/microformats/mf2py)
+[![version](https://badge.fury.io/py/mf2py.svg?)](https://badge.fury.io/py/mf2py)
+[![downloads](https://img.shields.io/pypi/dm/mf2py)](https://pypistats.org/packages/mf2py)
+[![license](https://img.shields.io/pypi/l/mf2py?)](https://github.com/microformats/mf2py/blob/main/LICENSE)
+[![python-version](https://img.shields.io/pypi/pyversions/mf2py)](https://badge.fury.io/py/mf2py)
 
-[![Can I Use Python 3?](https://caniusepython3.com/project/mf2py.svg)](https://caniusepython3.com/project/mf2py)
+## Welcome 👋
 
-Python parser for [microformats 2](http://microformats.org/wiki/Microformats2).
+`mf2py` is a Python [microformats](https://microformats.org/wiki/microformats) parser with full support for `microformats2`, backwards-compatible support for `microformats1` and experimental support for `metaformats`.
 
-Current status: Full-featured and mostly stable. Implements the full
-mf2 spec, including backward compatibility with microformats1.
+## Installation 💻
 
-Documentation, code tidying and so on is rather lacking.    
+To install `mf2py` run the following command:
 
-License: [MIT](http://opensource.org/licenses/mit-license.php)
+```bash
+$ pip install mf2py
 
-Install
--------
+```
 
-`pip install mf2py`
+## Quickstart 🚀
 
-Usage
------
+Import the library:
 
-Import the parser using
+```pycon
+>>> import mf2py
 
-    import mf2py
+```
 
-Parse a file containing the content
+### Parse an HTML Document from a file or string
 
-    with open('file/content.html','r') as file:
-        obj = mf2py.parse(doc=file)
+```pycon
+>>> with open("test/examples/eras.html") as fp:
+...     mf2json = mf2py.parse(doc=fp)
+>>> mf2json
+{'items': [{'type': ['h-entry'],
+            'properties': {'name': ['Excited for the Taylor Swift Eras Tour'],
+                           'author': [{'type': ['h-card'],
+                                       'properties': {'name': ['James'],
+                                                      'url': ['https://example.com/']},
+                                       'value': 'James',
+                                       'lang': 'en-us'}],
+                           'published': ['2023-11-30T19:08:09'],
+                           'featured': [{'value': 'https://example.com/eras.jpg',
+                                         'alt': 'Eras tour poster'}],
+                           'content': [{'value': "I can't decide which era is my favorite.",
+                                        'lang': 'en-us',
+                                        'html': "<p>I can't decide which era is my favorite.</p>"}],
+                           'category': ['music', 'Taylor Swift']},
+            'lang': 'en-us'}],
+ 'rels': {'webmention': ['https://example.com/mentions']},
+ 'rel-urls': {'https://example.com/mentions': {'text': '',
+                                               'rels': ['webmention']}},
+ 'debug': {'description': 'mf2py - microformats2 parser for python',
+           'source': 'https://github.com/microformats/mf2py',
+           'version': '2.0.1',
+           'markup parser': 'html5lib'}}
 
-Parse string containing content
+```
 
-    content = '<article class="h-entry"><h1 class="p-name">Hello</h1></article>'
-    obj = mf2py.parse(doc=content)
+```pycon
+>>> mf2json = mf2py.parse(doc="<a class=h-card href=https://example.com>James</a>")
+>>> mf2json["items"]
+[{'type': ['h-card'],
+  'properties': {'name': ['James'],
+                 'url': ['https://example.com']}}]
 
-Parse content from a URL
+```
 
-    obj = mf2py.parse(url="http://tommorris.org/")
+### Parse an HTML Document from a URL
 
-`parse` is a convenience method that actually delegates to
-`mf2py.Parser` to do the real work. More sophisticated behaviors are
-available by invoking the object directly.
+```pycon
+>>> mf2json = mf2py.parse(url="https://events.indieweb.org")
+>>> mf2json["items"][0]["type"]
+['h-feed']
+>>> mf2json["items"][0]["children"][0]["type"]
+['h-event']
 
-Get parsed microformat in a variety of formats
+```
 
-    p = mf2py.Parser(...)
-    p.to_dict()  # returns a python dictionary
-    p.to_json()  # returns a JSON string
+## Experimental Options
 
-Filter by microformat type
+The following options can be invoked via keyword arguments to `parse()` and `Parser()`.
 
-    p.to_dict(filter_by_type="h-entry")
-    p.to_json(filter_by_type="h-entry")
+### `expose_dom`
 
-Experimental features
----------------------
-- pass the optional argument `img_with_alt=True` to either the `Parser` object or to the `parse` method to enable parsing of the `alt` attribute of `<img>` tags according to [issue: image alt text is lost during parsing](https://github.com/microformats/microformats2-parsing/issues/2). By default this is `False` to be backwards compatible.
+Use `expose_dom=True` to expose the DOM of embedded properties.
 
-FAQ
----
+### `metaformats`
 
-* I passed `mf2py.parse()` a BeautifulSoup document, and it got modified!
+Use `metaformats=True` to include any [metaformats](https://microformats.org/wiki/metaformats)
+found.
 
-Yes, mf2py currently does that. We're working on preventing it! Hopefully soon.
+### `filter_roots`
 
-Frontends
--------------
+Use `filter_roots=True` to filter known conflicting user names (e.g. Tailwind).
+Otherwise provide a custom list to filter instead.
 
-A basic web interface for mf2py and [mf2util](https://github.com/kylewm/mf2util) is available at [mf2py-web](https://github.com/kylewm/mf2py-web).
+## Advanced Usage
 
-A hosted live version can be found at [python.microformats.io](https://python.microformats.io).
+`parse` is a convenience function for `Parser`. More sophisticated behaviors are
+available by invoking the parser object directly.
 
-Contributions
--------------
+```pycon
+>>> with open("test/examples/festivus.html") as fp:
+...     mf2parser = mf2py.Parser(doc=fp)
 
-We welcome contributions and bug reports via Github, and on the microformats wiki.
+```
 
-We try to follow the [IndieWebCamp code of conduct](http://indiewebcamp.com/code-of-conduct). Please be respectful of other contributors, and forge a spirit of positive co-operation without discrimination or disrespect.
+#### Filter by Microformat Type
 
+```pycon
+>>> mf2json = mf2parser.to_dict()
+>>> len(mf2json["items"])
+7
+>>> len(mf2parser.to_dict(filter_by_type="h-card"))
+3
+>>> len(mf2parser.to_dict(filter_by_type="h-entry"))
+4
+
+```
+
+#### JSON Output
+
+```pycon
+>>> json = mf2parser.to_json()
+>>> json_cards = mf2parser.to_json(filter_by_type="h-card")
+
+```
+
+## Breaking Changes in `mf2py` 2.0
+
+- Image `alt` support is now on by default.
+
+## Notes 📝
+
+- If you pass a BeautifulSoup document it may be modified.
+- A hosted version of `mf2py` is available at [python.microformats.io](https://python.microformats.io).
+
+## Contributing 🛠️
+
+We welcome contributions and bug reports via GitHub.
+
+This project follows the [IndieWeb code of conduct](https://indieweb.org/code-of-conduct). Please be respectful of other contributors and forge a spirit of positive co-operation without discrimination or disrespect.
+
+## License 🧑‍⚖️
+
+`mf2py` is licensed under an MIT License.
diff --git a/doc/source/conf.py b/doc/source/conf.py
deleted file mode 100644
index 82b8c4d..0000000
--- a/doc/source/conf.py
+++ /dev/null
@@ -1,260 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# mf2py documentation build configuration file, created by
-# sphinx-quickstart on Sun Jan 18 09:39:25 2015.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import sys
-import os
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.autodoc',
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix of source filenames.
-source_suffix = '.rst'
-
-# The encoding of source files.
-#source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = u'mf2py'
-copyright = u'2015, Tom Morris'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '0.2.1'
-# The full version, including alpha/beta/rc tags.
-release = '0.2.1'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = []
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-#default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-# If true, keep warnings as "system message" paragraphs in the built documents.
-#keep_warnings = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-html_theme = 'default'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#html_extra_path = []
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_domain_indices = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'mf2pydoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
-
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
-
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-  ('index', 'mf2py.tex', u'mf2py Documentation',
-   u'Tom Morris', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# If true, show page references after internal links.
-#latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_domain_indices = True
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    ('index', 'mf2py', u'mf2py Documentation',
-     [u'Tom Morris'], 1)
-]
-
-# If true, show URL addresses after external links.
-#man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-  ('index', 'mf2py', u'mf2py Documentation',
-   u'Tom Morris', 'mf2py', 'One line description of project.',
-   'Miscellaneous'),
-]
-
-# Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
-
-# If false, no module index is generated.
-#texinfo_domain_indices = True
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#texinfo_no_detailmenu = False
diff --git a/doc/source/index.rst b/doc/source/index.rst
deleted file mode 100644
index 24146cc..0000000
--- a/doc/source/index.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-.. mf2py documentation master file, created by
-   sphinx-quickstart on Sun Jan 18 09:39:25 2015.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-mf2py API reference
-=================================
-
-.. automodule:: mf2py
-   :members:
diff --git a/docs/banner.png b/docs/banner.png
new file mode 100644
index 0000000..e2f9314
Binary files /dev/null and b/docs/banner.png differ
diff --git a/docs/changelog.md b/docs/changelog.md
new file mode 120000
index 0000000..04c99a5
--- /dev/null
+++ b/docs/changelog.md
@@ -0,0 +1 @@
+../CHANGELOG.md
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
new file mode 120000
index 0000000..32d46ee
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1 @@
+../README.md
\ No newline at end of file
diff --git a/docs/parser.md b/docs/parser.md
new file mode 100644
index 0000000..8386e9f
--- /dev/null
+++ b/docs/parser.md
@@ -0,0 +1,3 @@
+# Parser Object
+
+:::mf2py.Parser
diff --git a/docs/stylesheets/styles.css b/docs/stylesheets/styles.css
new file mode 100644
index 0000000..5e2a553
--- /dev/null
+++ b/docs/stylesheets/styles.css
@@ -0,0 +1,3 @@
+:root {
+    --md-primary-fg-color:        #6CA300;
+}
\ No newline at end of file
diff --git a/dumpout.py b/dumpout.py
deleted file mode 100644
index 997b528..0000000
--- a/dumpout.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# coding: utf-8
-
-from mf2py import Parser
-import os.path
-import glob
-import json
-
-allfiles = glob.glob(os.path.join('.', 'tests', 'tests', '**', '**', '*.json'))
-for jsonfile in allfiles:
-    htmlfile = jsonfile[:-4] + 'html'
-    with open(htmlfile) as f:
-        p = json.loads(Parser(doc=f).to_json(pretty_print=True))
diff --git a/mf2py/__init__.py b/mf2py/__init__.py
index e8a6a2e..7c37637 100644
--- a/mf2py/__init__.py
+++ b/mf2py/__init__.py
@@ -5,9 +5,8 @@
 dictionary.
 """
 
-from .version import __version__
-from .parser import Parser, parse
 from .mf_helpers import get_url
+from .parser import Parser, parse
+from .version import __version__
 
-
-__all__ = ['Parser', 'parse', 'get_url', '__version__']
+__all__ = ["Parser", "parse", "get_url", "__version__"]
diff --git a/mf2py/backcompat-rules/hentry.json b/mf2py/backcompat-rules/hentry.json
index aa7b8be..4eaa52d 100644
--- a/mf2py/backcompat-rules/hentry.json
+++ b/mf2py/backcompat-rules/hentry.json
@@ -11,10 +11,7 @@
         ], 
         "published": [
             "dt-published"
-        ], 
-        "latitude": [
-            "p-latitude"
-        ], 
+        ],
         "entry-content": [
             "e-content"
         ], 
@@ -31,9 +28,6 @@
         ], 
         "updated": [
             "dt-updated"
-        ], 
-        "longitude": [
-            "p-longitude"
         ]
     },
     "rels": {
diff --git a/mf2py/backcompat.py b/mf2py/backcompat.py
index 38d0d13..49a866e 100644
--- a/mf2py/backcompat.py
+++ b/mf2py/backcompat.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 """Looks for classic microformats class names and augments them with
 microformats2 names. Ported and adapted from php-mf2.
 
@@ -24,52 +23,52 @@
 
 """
 
-from __future__ import unicode_literals, print_function
-from .dom_helpers import get_children
-from .mf_helpers import unordered_list
-from . import mf2_classes
-import bs4
-import copy
-import os
 import codecs
+import copy
 import json
+import os
+from urllib.parse import unquote
 
-import sys
-if sys.version < '3':
-    from urllib import unquote
-else:
-    from urllib.parse import unquote
+import bs4
+
+from . import mf2_classes
+from .dom_helpers import get_children
+from .mf_helpers import unordered_list
 
 # Classic map
 _CLASSIC_MAP = {}
 
 # populate backcompat rules from JSON files
 
-_RULES_LOC = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backcompat-rules')
+_RULES_LOC = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "backcompat-rules"
+)
 
 for filename in os.listdir(_RULES_LOC):
     file_path = os.path.join(_RULES_LOC, filename)
     root = os.path.splitext(filename)[0]
-    with codecs.open(file_path, 'r', 'utf-8') as f:
+    with codecs.open(file_path, "r", "utf-8") as f:
         rules = json.load(f)
 
-    _CLASSIC_MAP[root] = rules 
+    _CLASSIC_MAP[root] = rules
 
 
 def _make_classes_rule(old_classes, new_classes):
     """Builds a rule for augmenting an mf1 class with its mf2
     equivalent(s).
     """
+
     def f(child, **kwargs):
         child_original = child.original or copy.copy(child)
-        child_classes = child.get('class', [])[:]
+        child_classes = child.get("class", [])[:]
         if all(cl in child_classes for cl in old_classes):
             child_classes.extend([cl for cl in new_classes if cl not in child_classes])
-            child['class'] = child_classes
+            child["class"] = child_classes
 
             # if any new class is e-* attach original to parse originally authored HTML
             if mf2_classes.has_embedded_class(child_classes) and child.original is None:
                 child.original = child_original
+
     return f
 
 
@@ -80,62 +79,71 @@ def _rel_tag_to_category_rule(child, html_parser, **kwargs):
     <data class="p-category" value="cat"></data>
     """
 
-    href = child.get('href', '')
-    rels = child.get('rel', [])
-    if 'tag' in rels and href:
-        segments = [seg for seg in href.split('/') if seg]
+    href = child.get("href", "")
+    rels = child.get("rel", [])
+    if "tag" in rels and href:
+        segments = [seg for seg in href.split("/") if seg]
         if segments:
             if html_parser:
-                soup = bs4.BeautifulSoup('', features=html_parser)
+                soup = bs4.BeautifulSoup("", features=html_parser)
             else:
-                soup = bs4.BeautifulSoup('')
+                soup = bs4.BeautifulSoup("")
 
-            data = soup.new_tag('data')
+            data = soup.new_tag("data")
             # this does not use what's given in the JSON
             # but that is not a problem currently
             # use mf1 class so it doesn't get removed later
-            data['class'] = ['p-category']
-            data['value'] = unquote(segments[-1])
+            data["class"] = ["p-category"]
+            data["value"] = unquote(segments[-1])
             child.insert_before(data)
             # remove tag from rels to avoid repeat
             # new list created, original not modifed -> safe on incomplete copy
-            child['rel'] = [r for r in rels if r != 'tag']
+            child["rel"] = [r for r in rels if r != "tag"]
 
 
 def _make_rels_rule(old_rels, new_classes, html_parser):
-    """Builds a rule for augmenting an mf1 rel with its mf2 class equivalent(s).
-    """
+    """Builds a rule for augmenting an mf1 rel with its mf2 class equivalent(s)."""
 
     # need to special case rel=tag as it operates differently
 
     def f(child, **kwargs):
-        child_rels = child.get('rel', [])
-        child_classes = child.get('class', [])[:]
+        child_rels = child.get("rel", [])
+        child_classes = child.get("class", [])[:]
         if all(r in child_rels for r in old_rels):
-            if 'tag' in old_rels:
+            if "tag" in old_rels:
                 _rel_tag_to_category_rule(child, html_parser, **kwargs)
             else:
-                child_classes.extend([cl for cl in new_classes if cl not in child_classes])
-                child['class'] = child_classes
+                child_classes.extend(
+                    [cl for cl in new_classes if cl not in child_classes]
+                )
+                child["class"] = child_classes
+
     return f
 
 
 def _get_rules(old_root, html_parser):
-    """ for given mf1 root get the rules as a list of functions to act on children """
-
-    class_rules = [_make_classes_rule(old_classes.split(), new_classes)
-                for old_classes, new_classes in _CLASSIC_MAP[old_root].get('properties', {}).items()]
-    rel_rules = [_make_rels_rule(old_rels.split(), new_classes, html_parser)
-                for old_rels, new_classes in _CLASSIC_MAP[old_root].get('rels', {}).items()]
+    """for given mf1 root get the rules as a list of functions to act on children"""
+
+    class_rules = [
+        _make_classes_rule(old_classes.split(), new_classes)
+        for old_classes, new_classes in _CLASSIC_MAP[old_root]
+        .get("properties", {})
+        .items()
+    ]
+    rel_rules = [
+        _make_rels_rule(old_rels.split(), new_classes, html_parser)
+        for old_rels, new_classes in _CLASSIC_MAP[old_root].get("rels", {}).items()
+    ]
 
     return class_rules + rel_rules
 
+
 def root(classes):
-    """get all backcompat root classnames
-    """
+    """get all backcompat root classnames"""
     return unordered_list([c for c in classes if c in _CLASSIC_MAP])
 
-def apply_rules(el, html_parser):
+
+def apply_rules(el, html_parser, filtered_roots):
     """add modern classnames for older mf1 classnames
 
     returns a copy of el and does not modify the original
@@ -144,28 +152,28 @@ def apply_rules(el, html_parser):
     el_copy = copy.copy(el)
 
     def apply_prop_rules_to_children(parent, rules):
-
         for child in get_children(parent):
-            classes = child.get('class',[])[:]
+            classes = child.get("class", [])[:]
             # find existing mf2 properties if any and delete them
-            child['class'] = [cl for cl in classes if not mf2_classes.is_property_class(cl)]
+            child["class"] = [
+                cl for cl in classes if not mf2_classes.is_property_class(cl)
+            ]
 
             # apply rules to change mf1 to mf2
             for rule in rules:
                 rule(child)
 
             # recurse if it's not a nested mf1 or mf2 root
-            if not (mf2_classes.root(classes) or root(classes)):
+            if not (mf2_classes.root(classes, filtered_roots) or root(classes)):
                 apply_prop_rules_to_children(child, rules)
 
     # add mf2 root equivalent
-    classes = el_copy.get('class', [])[:]
+    classes = el_copy.get("class", [])[:]
     old_roots = root(classes)
     for old_root in old_roots:
-        new_roots = _CLASSIC_MAP[old_root]['type']
+        new_roots = _CLASSIC_MAP[old_root]["type"]
         classes.extend(new_roots)
-    el_copy['class'] = classes
-
+    el_copy["class"] = classes
 
     # add mf2 prop equivalent to descendents and remove existing mf2 props
     rules = []
diff --git a/mf2py/datetime_helpers.py b/mf2py/datetime_helpers.py
index 02b5321..9f4328b 100644
--- a/mf2py/datetime_helpers.py
+++ b/mf2py/datetime_helpers.py
@@ -1,62 +1,62 @@
-'''helper functions to deal wit datetime strings'''
-from __future__ import unicode_literals, print_function
+"""helper functions to deal wit datetime strings"""
 
 import re
 from datetime import datetime
 
 # REGEX!
 
-DATE_RE = r'(\d{4}-\d{2}-\d{2})|(\d{4}-\d{3})'
-SEC_RE = r'(:(?P<second>\d{2})(\.\d+)?)'
-RAWTIME_RE = r'(?P<hour>\d{1,2})(:(?P<minute>\d{2})%s?)?' % (SEC_RE)
-AMPM_RE = r'am|pm|a\.m\.|p\.m\.|AM|PM|A\.M\.|P\.M\.'
-TIMEZONE_RE = r'Z|[+-]\d{2}:?\d{2}?'
-TIME_RE = (r'(?P<rawtime>%s)( ?(?P<ampm>%s))?( ?(?P<tz>%s))?' %
-           (RAWTIME_RE, AMPM_RE, TIMEZONE_RE))
-DATETIME_RE = (r'(?P<date>%s)(?P<separator>[T ])(?P<time>%s)'
-               % (DATE_RE, TIME_RE))
+DATE_RE = r"(\d{4}-\d{2}-\d{2})|(\d{4}-\d{3})"
+SEC_RE = r"(:(?P<second>\d{2})(\.\d+)?)"
+RAWTIME_RE = r"(?P<hour>\d{1,2})(:(?P<minute>\d{2})%s?)?" % (SEC_RE)
+AMPM_RE = r"am|pm|a\.m\.|p\.m\.|AM|PM|A\.M\.|P\.M\."
+TIMEZONE_RE = r"Z|[+-]\d{1,2}:?\d{2}?"
+TIME_RE = r"(?P<rawtime>%s)( ?(?P<ampm>%s))?( ?(?P<tz>%s))?" % (
+    RAWTIME_RE,
+    AMPM_RE,
+    TIMEZONE_RE,
+)
+DATETIME_RE = r"(?P<date>%s)(?P<separator>[T ])(?P<time>%s)" % (DATE_RE, TIME_RE)
+
 
 def normalize_datetime(dtstr, match=None):
-        """Try to normalize a datetime string.
-        1. Convert 12-hour time to 24-hour time
-
-        pass match in if we have already calculated it to avoid rework
-        """
-        match = match or (dtstr and re.match(DATETIME_RE + '$', dtstr))
-        if match:
-            datestr = match.group('date')
-            hourstr = match.group('hour')
-            minutestr = match.group('minute') or '00'
-            secondstr = match.group('second')
-            ampmstr = match.group('ampm')
-            separator = match.group('separator')
-
-            # convert ordinal date YYYY-DDD to YYYY-MM-DD
-            try:
-                datestr = datetime.strptime(datestr, '%Y-%j').strftime('%Y-%m-%d')
-            except ValueError:
-                # datestr was not in YYYY-DDD format
-                pass
-
-            # 12 to 24 time conversion
-            if ampmstr:
-                hourstr = match.group('hour')
-                hourint = int(hourstr)
-
-                if (ampmstr.startswith('a') or ampmstr.startswith('A')) and hourint == 12:
-                    hourstr = '00'
-
-                if (ampmstr.startswith('p') or ampmstr.startswith('P')) and hourint < 12:
-                    hourstr = str(hourint + 12)
-
-
-            dtstr = '%s%s%s:%s' % (
-                datestr, separator, hourstr, minutestr)
-
-            if secondstr:
-                dtstr += ':'+secondstr
-
-            tzstr = match.group('tz')
-            if tzstr:
-                dtstr += tzstr
-        return dtstr
+    """Try to normalize a datetime string.
+    1. Convert 12-hour time to 24-hour time
+
+    pass match in if we have already calculated it to avoid rework
+    """
+    match = match or (dtstr and re.match(DATETIME_RE + "$", dtstr))
+    if match:
+        datestr = match.group("date")
+        hourstr = match.group("hour")
+        minutestr = match.group("minute") or "00"
+        secondstr = match.group("second")
+        ampmstr = match.group("ampm")
+        separator = match.group("separator")
+
+        # convert ordinal date YYYY-DDD to YYYY-MM-DD
+        try:
+            datestr = datetime.strptime(datestr, "%Y-%j").strftime("%Y-%m-%d")
+        except ValueError:
+            # datestr was not in YYYY-DDD format
+            pass
+
+        # 12 to 24 time conversion
+        if ampmstr:
+            hourstr = match.group("hour")
+            hourint = int(hourstr)
+
+            if (ampmstr.startswith("a") or ampmstr.startswith("A")) and hourint == 12:
+                hourstr = "00"
+
+            if (ampmstr.startswith("p") or ampmstr.startswith("P")) and hourint < 12:
+                hourstr = hourint + 12
+
+        dtstr = "%s%s%s:%s" % (datestr, separator, hourstr, minutestr)
+
+        if secondstr:
+            dtstr += ":" + secondstr
+
+        tzstr = match.group("tz")
+        if tzstr:
+            dtstr += tzstr.replace(":", "")
+    return dtstr
diff --git a/mf2py/dom_helpers.py b/mf2py/dom_helpers.py
index 8b10f43..f3b87ad 100644
--- a/mf2py/dom_helpers.py
+++ b/mf2py/dom_helpers.py
@@ -1,21 +1,8 @@
-from __future__ import unicode_literals
-
-import sys
-import bs4
 import re
+from urllib.parse import urljoin
 
-from bs4.element import Tag, NavigableString, Comment
-
-if sys.version < '3':
-    from urlparse import urljoin
-    text_type = unicode
-    binary_type = str
-else:
-    from urllib.parse import urljoin
-    text_type = str
-    binary_type = bytes
-    basestring = str
-
+import bs4
+from bs4.element import Comment, NavigableString, Tag
 
 _whitespace_to_space_regex = re.compile(r"[\n\t\r]+")
 _reduce_spaces_regex = re.compile(r" {2,}")
@@ -46,56 +33,71 @@ def get_attr(el, attr, check_name=None):
     """
     if check_name is None:
         return el.get(attr)
-    if isinstance(check_name, basestring) and el.name == check_name:
+    if isinstance(check_name, str) and el.name == check_name:
         return el.get(attr)
     if isinstance(check_name, (tuple, list)) and el.name in check_name:
         return el.get(attr)
 
 
-def get_img_src_alt(img, dict_class, img_with_alt, base_url=''):
-    """given a img element, returns both src and alt attributes as a list of tuples if alt exists, else returns the src as a string
-    use for alt parsing with img
-    """
+def parse_srcset(srcset, base_url):
+    """Return a dictionary of sources found in srcset."""
+    sources = {}
+    for url, descriptor in re.findall(
+        r"(\S+)\s*([\d.]+[xw])?\s*,?\s*",
+        srcset,
+        re.MULTILINE,
+    ):
+        if not descriptor:
+            descriptor = "1x"
+        if descriptor not in sources:
+            sources[descriptor] = try_urljoin(base_url, url.strip(","))
+    return sources
 
-    alt = get_attr(img, "alt", check_name="img")
-    src = get_attr(img, "src", check_name="img")
 
-    if src is not None:
-        src = try_urljoin(base_url, src)
+def get_img(img, base_url):
+    """Return a dictionary with src and alt/srcset if present, else just string src."""
+    src = get_attr(img, "src", check_name="img")
+    if src is None:
+        return
+    src = try_urljoin(base_url, src)
+    alt = get_attr(img, "alt", check_name="img")
+    srcset = get_attr(img, "srcset", check_name="img")
+    if alt is not None or srcset:
+        prop_value = {"value": src}
+        if alt is not None:
+            prop_value["alt"] = alt
+        if srcset:
+            prop_value["srcset"] = parse_srcset(srcset, base_url)
+        return prop_value
+    else:
+        return src
 
-        if alt is None or not img_with_alt:
-            return text_type(src)
-        else:
-            return dict_class([
-                                ("value", text_type(src)),
-                                ("alt", text_type(alt))
-                            ])
 
 def get_children(node):
     """An iterator over the immediate children tags of this tag"""
     for child in node.children:
-        if isinstance(child, bs4.Tag) and child.name != 'template':
+        if isinstance(child, bs4.Tag) and child.name != "template":
             yield child
 
 
 def get_descendents(node):
     """An iterator over the all children tags (descendants) of this tag"""
     for desc in node.descendants:
-        if isinstance(desc, bs4.Tag) and desc.name != 'template':
+        if isinstance(desc, bs4.Tag) and desc.name != "template":
             yield desc
 
-def get_textContent(el, replace_img=False, img_to_src=True, base_url=''):
-    """ Get the text content of an element, replacing images by alt or src
-    """
 
-    DROP_TAGS = ('script', 'style',  'template')
-    PRE_TAGS = ('pre',)
+def get_textContent(el, replace_img=False, img_to_src=True, base_url=""):
+    """Get the text content of an element, replacing images by alt or src"""
+
+    DROP_TAGS = ("script", "style", "template")
+    PRE_TAGS = ("pre",)
     P_BREAK_BEFORE = 1
     P_BREAK_AFTER = 0
     PRE_BEFORE = 2
     PRE_AFTER = 3
 
-    def text_collection(el, replace_img=False, img_to_src=True, base_url=''):
+    def text_collection(el, replace_img=False, img_to_src=True, base_url=""):
         # returns array of strings or integers
 
         items = []
@@ -105,95 +107,96 @@ def text_collection(el, replace_img=False, img_to_src=True, base_url=''):
             items = []
 
         elif isinstance(el, NavigableString):
-            value = text_type(el)
+            value = el
             # replace \t \n \r by space
-            value = _whitespace_to_space_regex.sub(' ', value)
+            value = _whitespace_to_space_regex.sub(" ", value)
             # replace multiple spaces with one space
-            items = [_reduce_spaces_regex.sub(' ', value)]
+            items = [_reduce_spaces_regex.sub(" ", value)]
 
         # don't do anything special for PRE-formatted tags defined above
         elif el.name in PRE_TAGS:
             items = [PRE_BEFORE, el.get_text(), PRE_AFTER]
 
-        elif el.name == 'img' and replace_img:
-            value = el.get('alt')
+        elif el.name == "img" and replace_img:
+            value = el.get("alt")
             if value is None and img_to_src:
-                value = el.get('src')
+                value = el.get("src")
                 if value is not None:
                     value = try_urljoin(base_url, value)
 
             if value is not None:
-                items = [' ', text_type(value), ' ']
+                items = [" ", value, " "]
 
-        elif el.name == 'br':
-            items = ['\n']
+        elif el.name == "br":
+            items = ["\n"]
 
         else:
             for child in el.children:
-
                 child_items = text_collection(child, replace_img, img_to_src, base_url)
                 items.extend(child_items)
 
-            if el.name == 'p':
-                items = [P_BREAK_BEFORE] + items
-                items.append(P_BREAK_AFTER)
-
+            if el.name == "p":
+                items = [P_BREAK_BEFORE] + items + [P_BREAK_AFTER, "\n"]
 
         return items
 
-    results = [t for t in text_collection(el, replace_img, img_to_src, base_url) if t is not '']
+    results = [
+        t for t in text_collection(el, replace_img, img_to_src, base_url) if t != ""
+    ]
 
     if results:
         # remove <space> if it is first and last or if it is preceded by a <space> or <p> open/close
         length = len(results)
         for i in range(0, length):
-            if (results[i] == ' ' and
-                    (i == 0 or
-                    i == length - 1 or
-                    results[i-1] == ' ' or
-                    results[i-1] in (P_BREAK_BEFORE, P_BREAK_AFTER) or
-                    results[i+1] == ' ' or
-                    results[i+1] in (P_BREAK_BEFORE, P_BREAK_AFTER)
-                    )
-                ):
-                results[i] = ''
+            if results[i] == " " and (
+                i == 0
+                or i == length - 1
+                or results[i - 1] == " "
+                or results[i - 1] in (P_BREAK_BEFORE, P_BREAK_AFTER)
+                or results[i + 1] == " "
+                or results[i + 1] in (P_BREAK_BEFORE, P_BREAK_AFTER)
+            ):
+                results[i] = ""
 
     if results:
         # remove leading whitespace and <int> i.e. next lines
-        while ((isinstance(results[0], basestring) and (results[0] == '' or results[0].isspace())) or
-               results[0] in (P_BREAK_BEFORE, P_BREAK_AFTER)):
+        while (
+            isinstance(results[0], str) and (results[0] == "" or results[0].isspace())
+        ) or results[0] in (P_BREAK_BEFORE, P_BREAK_AFTER):
             results.pop(0)
             if not results:
                 break
 
     if results:
         # remove trailing whitespace and <int> i.e. next lines
-        while ((isinstance(results[-1], basestring) and (results[-1] == '' or results[-1].isspace())) or
-               results[-1] in (P_BREAK_BEFORE, P_BREAK_AFTER)):
+        while (
+            isinstance(results[-1], str)
+            and (results[-1] == "" or results[-1].isspace())
+        ) or results[-1] in (P_BREAK_BEFORE, P_BREAK_AFTER):
             results.pop(-1)
             if not results:
                 break
 
     # trim leading and trailing non-<pre> whitespace
     if results:
-        if isinstance(results[0], basestring):
+        if isinstance(results[0], str):
             results[0] = results[0].lstrip()
-        if isinstance(results[-1], basestring):
+        if isinstance(results[-1], str):
             results[-1] = results[-1].rstrip()
 
     # create final string by concatenating replacing consecutive sequence of <int> by largest value number of \n
-    text = ''
+    text = ""
     count = 0
     last = None
     for t in results:
         if t in (P_BREAK_BEFORE, P_BREAK_AFTER):
             count = max(t, count)
         elif t == PRE_BEFORE:
-            text = text.rstrip(' ')
+            text = text.rstrip(" ")
         elif not isinstance(t, int):
-            if count or last == '\n':
-                t = t.lstrip(' ')
-            text = ''.join([text, '\n'*count , t])
+            if count or last == "\n":
+                t = t.lstrip(" ")
+            text = "".join([text, "\n" * count, t])
             count = 0
         last = t
 
diff --git a/mf2py/implied_properties.py b/mf2py/implied_properties.py
index e963e97..4c538f3 100644
--- a/mf2py/implied_properties.py
+++ b/mf2py/implied_properties.py
@@ -1,17 +1,8 @@
-from __future__ import unicode_literals, print_function
 from . import mf2_classes
-from .dom_helpers import get_attr, get_img_src_alt, get_children, get_textContent, try_urljoin
-import sys
+from .dom_helpers import get_attr, get_children, get_img, get_textContent, try_urljoin
 
-if sys.version < '3':
-    text_type = unicode
-    binary_type = str
-else:
-    text_type = str
-    binary_type = bytes
 
-
-def name(el, base_url=''):
+def name(el, base_url, filtered_roots):
     """Find an implied name property
 
     Args:
@@ -20,20 +11,21 @@ def name(el, base_url=''):
     Returns:
       string: the implied name value
     """
+
     def non_empty(val):
         """If alt or title is empty, we don't want to use it as the implied
         name"""
-        return val is not None and val != ''
+        return val is not None and val != ""
 
     # if image or area use alt text if not empty
     prop_value = get_attr(el, "alt", check_name=("img", "area"))
     if non_empty(prop_value):
-        return text_type(prop_value)
+        return prop_value
 
     # if abbreviation use the title if not empty
     prop_value = get_attr(el, "title", check_name="abbr")
     if non_empty(prop_value):
-        return text_type(prop_value)
+        return prop_value
 
     # find candidate child or grandchild
     poss_child = None
@@ -42,7 +34,7 @@ def non_empty(val):
         poss_child = children[0]
 
         # ignore if mf2 root
-        if mf2_classes.root(poss_child.get('class',[])):
+        if mf2_classes.root(poss_child.get("class", []), filtered_roots):
             poss_child = None
 
         # if it is not img, area, abbr then find grandchild
@@ -52,7 +44,9 @@ def non_empty(val):
             if len(grandchildren) == 1:
                 poss_child = grandchildren[0]
                 # if it is not img, area, abbr or is mf2 root then no possible child
-                if poss_child.name not in ("img", "area", "abbr") or mf2_classes.root(poss_child.get('class',[])):
+                if poss_child.name not in ("img", "area", "abbr") or mf2_classes.root(
+                    poss_child.get("class", []), filtered_roots
+                ):
                     poss_child = None
 
     # if a possible child was found
@@ -60,12 +54,12 @@ def non_empty(val):
         # use alt if possible child is img or area
         prop_value = get_attr(poss_child, "alt", check_name=("img", "area"))
         if non_empty(prop_value):
-            return text_type(prop_value)
+            return prop_value
 
         # use title if possible child is abbr
         prop_value = get_attr(poss_child, "title", check_name="abbr")
         if non_empty(prop_value):
-            return text_type(prop_value)
+            return prop_value
 
     # use text if all else fails
     # replace images with alt but not with src in implied name
@@ -73,13 +67,11 @@ def non_empty(val):
     return get_textContent(el, replace_img=True, img_to_src=False, base_url=base_url)
 
 
-def photo(el, dict_class, img_with_alt, base_url=''):
+def photo(el, base_url, filtered_roots):
     """Find an implied photo property
 
     Args:
       el (bs4.element.Tag): a DOM element
-      dict_class: a python class used as a dictionary (set by the Parser object)
-      img_with_alt: a flag to enable experimental parsing of alt attribute with img (set by the Parser object)
       base_url (string): the base URL to use, to reconcile relative URLs
 
     Returns:
@@ -91,29 +83,34 @@ def get_photo_child(children):
 
         # if element has one image child use source if exists and img is
         # not root class
-        poss_imgs = [c for c in children if c.name == 'img']
+        poss_imgs = [c for c in children if c.name == "img"]
         if len(poss_imgs) == 1:
             poss_img = poss_imgs[0]
-            if not mf2_classes.root(poss_img.get('class', [])):
+            if not mf2_classes.root(poss_img.get("class", []), filtered_roots):
                 return poss_img
 
         # if element has one object child use data if exists and object is
         # not root class
-        poss_objs = [c for c in children if c.name == 'object']
+        poss_objs = [c for c in children if c.name == "object"]
         if len(poss_objs) == 1:
             poss_obj = poss_objs[0]
-            if not mf2_classes.root(poss_obj.get('class', [])):
+            if not mf2_classes.root(poss_obj.get("class", []), filtered_roots):
                 return poss_obj
 
-    # if element is an img use source if exists
-    prop_value = get_img_src_alt(el, dict_class, img_with_alt, base_url)
-    if prop_value is not None:
+    def resolve_relative_url(prop_value):
+        if isinstance(prop_value, dict):
+            prop_value["value"] = try_urljoin(base_url, prop_value["value"])
+        else:
+            prop_value = try_urljoin(base_url, prop_value)
         return prop_value
 
+    # if element is an img use source if exists
+    if prop_value := get_img(el, base_url):
+        return resolve_relative_url(prop_value)
+
     # if element is an object use data if exists
-    prop_value = get_attr(el, "data", check_name="object")
-    if prop_value is not None:
-        return text_type(prop_value)
+    if prop_value := get_attr(el, "data", check_name="object"):
+        return resolve_relative_url(prop_value)
 
     # find candidate child or grandchild
     poss_child = None
@@ -122,25 +119,26 @@ def get_photo_child(children):
     poss_child = get_photo_child(children)
 
     # if no possible child found then look for grandchild if only one child which is not not mf2 root
-    if poss_child is None and len(children) == 1 and not mf2_classes.root(children[0].get('class', [])): 
-
+    if (
+        poss_child is None
+        and len(children) == 1
+        and not mf2_classes.root(children[0].get("class", []), filtered_roots)
+    ):
         grandchildren = list(get_children(children[0]))
         poss_child = get_photo_child(grandchildren)
 
     # if a possible child was found parse
     if poss_child is not None:
         # img get src
-        prop_value = get_img_src_alt(poss_child, dict_class, img_with_alt, base_url)
-        if prop_value is not None:
-            return prop_value
+        if prop_value := get_img(poss_child, base_url):
+            return resolve_relative_url(prop_value)
 
         # object get data
-        prop_value = get_attr(poss_child, "data", check_name="object")
-        if prop_value is not None:
-            return text_type(prop_value)
+        if prop_value := get_attr(poss_child, "data", check_name="object"):
+            return resolve_relative_url(prop_value)
 
 
-def url(el, base_url=''):
+def url(el, base_url, filtered_roots):
     """Find an implied url property
 
     Args:
@@ -155,24 +153,23 @@ def get_url_child(children):
         "take a list of children and finds a valid child for url property"
 
         # if element has one <a> child use if not root class
-        poss_as = [c for c in children if c.name == 'a']
+        poss_as = [c for c in children if c.name == "a"]
         if len(poss_as) == 1:
             poss_a = poss_as[0]
-            if not mf2_classes.root(poss_a.get('class', [])):
+            if not mf2_classes.root(poss_a.get("class", []), filtered_roots):
                 return poss_a
 
         # if element has one area child use if not root class
-        poss_areas = [c for c in children if c.name == 'area']
+        poss_areas = [c for c in children if c.name == "area"]
         if len(poss_areas) == 1:
             poss_area = poss_areas[0]
-            if not mf2_classes.root(poss_area.get('class', [])):
+            if not mf2_classes.root(poss_area.get("class", []), filtered_roots):
                 return poss_area
 
-
     # if element is a <a> or area use its href if exists
     prop_value = get_attr(el, "href", check_name=("a", "area"))
     if prop_value is not None:  # an empty href is valid
-        return text_type(try_urljoin(base_url, prop_value))
+        return try_urljoin(base_url, prop_value)
 
     # find candidate child or grandchild
     poss_child = None
@@ -181,8 +178,11 @@ def get_url_child(children):
     poss_child = get_url_child(children)
 
     # if no possible child found then look for grandchild if only one child which is not mf2 root
-    if poss_child is None and len(children) == 1 and not mf2_classes.root(children[0].get('class', [])): 
-
+    if (
+        poss_child is None
+        and len(children) == 1
+        and not mf2_classes.root(children[0].get("class", []), filtered_roots)
+    ):
         grandchildren = list(get_children(children[0]))
         poss_child = get_url_child(grandchildren)
 
@@ -190,4 +190,4 @@ def get_url_child(children):
     if poss_child is not None:
         prop_value = get_attr(poss_child, "href", check_name=("a", "area"))
         if prop_value is not None:  # an empty href is valid
-            return text_type(try_urljoin(base_url, prop_value))
+            return try_urljoin(base_url, prop_value)
diff --git a/mf2py/metaformats.py b/mf2py/metaformats.py
new file mode 100644
index 0000000..2260918
--- /dev/null
+++ b/mf2py/metaformats.py
@@ -0,0 +1,89 @@
+"""Metaformats parser.
+
+https://microformats.org/wiki/metaformats
+
+TODO:
+* explicit mf2 classes on meta tags
+  https://microformats.org/wiki/metaformats#parsing_an_element_for_properties
+"""
+from .dom_helpers import try_urljoin
+from .mf2_classes import filter_classes
+
+METAFORMAT_TO_MF2 = [
+    # in priority order, descending
+    # OGP
+    ("property", "article:author", "author"),
+    ("property", "article:published_time", "published"),
+    ("property", "article:modified_time", "updated"),
+    ("property", "og:audio", "audio"),
+    ("property", "og:description", "summary"),
+    ("property", "og:image", "photo"),
+    ("property", "og:title", "name"),
+    ("property", "og:video", "video"),
+    # Twitter
+    ("name", "twitter:title", "name"),
+    ("name", "twitter:description", "summary"),
+    ("name", "twitter:image", "photo"),
+    # HTML standard meta names
+    # https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta/name
+    ("name", "description", "summary"),
+]
+OGP_TYPE_TO_MF2 = {
+    "article": "h-entry",
+    "movie": "h-cite",
+    "music": "h-cite",
+    "profile": "h-card",
+}
+URL_PROPERTIES = {
+    "article:author",
+    "og:audio",
+    "og:image",
+    "og:video",
+    "twitter:image",
+}
+
+
+def parse(soup, url=None):
+    """Extracts and returns a metaformats item from a BeautifulSoup parse tree.
+
+    Args:
+      soup (bs4.BeautifulSoup): parsed HTML
+      url (str): URL of document
+
+    Returns:
+      dict: mf2 item, or None if the input is not eligible for metaformats
+    """
+    if not soup.head:
+        return None
+
+    # Is there a microformat2 root class on the html element?
+    if filter_classes(soup.get("class", []))["h"]:
+        return None
+
+    parsed = {"properties": {}, "source": "metaformats"}
+    props = parsed["properties"]
+
+    # Properties
+    for attr, meta, mf2 in METAFORMAT_TO_MF2:
+        if val := soup.head.find("meta", attrs={attr: meta}):
+            if content := val.get("content"):
+                if meta in URL_PROPERTIES:
+                    content = try_urljoin(url, content)
+                props.setdefault(mf2, [content])
+
+    if soup.head.title:
+        if text := soup.head.title.text:
+            props.setdefault("name", [text])
+
+    if not props:
+        # No OGP or Twitter properties
+        return None
+
+    # type from OGP or default to h-entry
+    parsed["type"] = ["h-entry"]
+    if ogp_type := soup.head.find("meta", property="og:type"):
+        if content := ogp_type.get("content"):
+            if mf2_type := OGP_TYPE_TO_MF2.get(content.split(".")[0]):
+                parsed["type"] = [mf2_type]
+
+    return parsed
diff --git a/mf2py/mf2_classes.py b/mf2py/mf2_classes.py
index 715c181..c48b9ad 100644
--- a/mf2py/mf2_classes.py
+++ b/mf2py/mf2_classes.py
@@ -1,5 +1,3 @@
-from __future__ import unicode_literals, print_function
-
 import re
 
 _mf2_classes_re = re.compile("(p|e|u|dt|h)-((:?[a-z0-9]+-)?[a-z]+(:?-[a-z]+)*)$")
@@ -7,26 +5,32 @@
 _mf2_properties_re = re.compile("(p|e|u|dt)-(:?[a-z0-9]+-)?[a-z]+(:?-[a-z]+)*$")
 _mf2_e_properties_re = re.compile("e-(:?[a-z0-9]+-)?[a-z]+(:?-[a-z]+)*$")
 
+CONFLICTING_ROOTS_TAILWIND = {"auto", "fit", "full", "max", "min", "px", "screen"}
+
 
 def filter_classes(classes, regex=_mf2_classes_re):
     """detect classes that are valid names for mf2, sort in dictionary by prefix"""
 
-    types = {x: set() for x in ('u', 'p', 'dt', 'e', 'h')}
+    types = {x: set() for x in ("u", "p", "dt", "e", "h")}
     for c in classes:
         match = regex.match(c)
         if match:
             if c[0] == "h":
-                types['h'].add(c)
+                types["h"].add(c)
             else:
                 types[match.group(1)].add(match.group(2))
     return types
 
 
-def root(classes):
-    return {c for c in classes if _mf2_roots_re.match(c)}
+def root(classes, filtered_roots):
+    return {
+        c for c in classes if _mf2_roots_re.match(c) and c[2:] not in filtered_roots
+    }
+
 
 def is_property_class(class_):
     return _mf2_properties_re.match(class_)
 
+
 def has_embedded_class(classes):
-    return any(_mf2_e_properties_re.match(c) for c in classes)
\ No newline at end of file
+    return any(_mf2_e_properties_re.match(c) for c in classes)
diff --git a/mf2py/mf_helpers.py b/mf2py/mf_helpers.py
index 65eeea3..d6a9985 100644
--- a/mf2py/mf_helpers.py
+++ b/mf2py/mf_helpers.py
@@ -1,5 +1,6 @@
 # don't need anymore defer to mf2util instead (mf2util does not have this functionality)
 
+
 def get_url(mf):
     """Given a property value that may be a list of simple URLs or complex
     h-* dicts (with a url property), extract a list of URLs. This is useful
@@ -14,14 +15,16 @@ def get_url(mf):
 
     urls = []
     for item in mf:
-        if isinstance(item, basestring):
+        if isinstance(item, str):
             urls.append(item)
-        elif (isinstance(item, dict)
-              and any(x.startswith('h-') for x in item.get('type', []))):
-            urls.extend(item.get('properties', {}).get('url', []))
+        elif isinstance(item, dict) and any(
+            x.startswith("h-") for x in item.get("type", [])
+        ):
+            urls.extend(item.get("properties", {}).get("url", []))
 
     return urls
 
+
 def unordered_list(l):
     """given a list, returns another list with unique and alphabetically sorted elements.
     use for HTML attributes that have no semantics to their order e.g. class, rel.
diff --git a/mf2py/parse_property.py b/mf2py/parse_property.py
index 2d72259..3d2222b 100644
--- a/mf2py/parse_property.py
+++ b/mf2py/parse_property.py
@@ -1,21 +1,13 @@
 """functions to parse the properties of elements"""
-from __future__ import unicode_literals, print_function
 
-from .dom_helpers import get_attr, get_img_src_alt, get_textContent, try_urljoin
-from .datetime_helpers import normalize_datetime, DATETIME_RE, TIME_RE
-from . import value_class_pattern
-
-import sys
 import re
 
-if sys.version < '3':
-    text_type = unicode
-    binary_type = str
-else:
-    text_type = str
-    binary_type = bytes
+from . import value_class_pattern
+from .datetime_helpers import DATETIME_RE, TIME_RE, normalize_datetime
+from .dom_helpers import get_attr, get_img, get_textContent, try_urljoin
+
 
-def text(el, base_url=''):
+def text(el, base_url=""):
     """Process p-* properties"""
 
     # handle value-class-pattern
@@ -34,36 +26,35 @@ def text(el, base_url=''):
     return prop_value
 
 
-def url(el, dict_class, img_with_alt, base_url=''):
+def url(el, base_url=""):
     """Process u-* properties"""
 
     prop_value = get_attr(el, "href", check_name=("a", "area", "link"))
     if prop_value is None:
-        prop_value = get_img_src_alt(el, dict_class, img_with_alt, base_url)
+        prop_value = get_img(el, base_url)
         if prop_value is not None:
             return prop_value
     if prop_value is None:
-        prop_value = get_attr(el, "src", check_name=("audio", "video", "source", "iframe"))
+        prop_value = get_attr(
+            el, "src", check_name=("audio", "video", "source", "iframe")
+        )
     if prop_value is None:
         prop_value = get_attr(el, "poster", check_name="video")
     if prop_value is None:
         prop_value = get_attr(el, "data", check_name="object")
 
-    if prop_value is not None:
-        return try_urljoin(base_url, prop_value)
-
-    # handle value-class-pattern
-    prop_value = value_class_pattern.text(el)
-    if prop_value is not None:
-        return prop_value
+    if prop_value is None:
+        # handle value-class-pattern
+        prop_value = value_class_pattern.text(el)
 
-    prop_value = get_attr(el, "title", check_name="abbr")
+    if prop_value is None:
+        prop_value = get_attr(el, "title", check_name="abbr")
     if prop_value is None:
         prop_value = get_attr(el, "value", check_name=("data", "input"))
     if prop_value is None:
         prop_value = get_textContent(el)
 
-    return prop_value
+    return try_urljoin(base_url, prop_value)
 
 
 def datetime(el, default_date=None):
@@ -87,23 +78,39 @@ def datetime(el, default_date=None):
     if prop_value is None:
         prop_value = get_attr(el, "value", check_name=("data", "input"))
     if prop_value is None:
-        prop_value = get_textContent(el) 
+        prop_value = get_textContent(el)
 
     # if this is just a time, augment with default date
-    match = re.match(TIME_RE + '$', prop_value)
+    match = re.match(TIME_RE + "$", prop_value)
     if match and default_date:
-        prop_value = '%s %s' % (default_date, prop_value)
+        prop_value = "%s %s" % (default_date, prop_value)
         return normalize_datetime(prop_value), default_date
 
     # otherwise, treat it as a full date
-    match = re.match(DATETIME_RE + '$', prop_value)
-    return (normalize_datetime(prop_value, match=match),
-            match and match.group('date'),)
+    match = re.match(DATETIME_RE + "$", prop_value)
+    return (
+        normalize_datetime(prop_value, match=match),
+        match and match.group("date"),
+    )
 
 
-def embedded(el, base_url=''):
+def embedded(el, base_url, root_lang, document_lang, expose_dom):
     """Process e-* properties"""
-    return {
-        'html': el.decode_contents().strip(),    # secret bs4 method to get innerHTML
-        'value': get_textContent(el, replace_img=True, base_url=base_url)
+    for tag in el.find_all():
+        for attr in ("href", "src", "cite", "data", "poster"):
+            if attr in tag.attrs:
+                tag.attrs[attr] = try_urljoin(base_url, tag.attrs[attr])
+    prop_value = {
+        "value": get_textContent(el, replace_img=True, base_url=base_url),
     }
+    if lang := el.attrs.get("lang"):
+        prop_value["lang"] = lang
+    elif root_lang:
+        prop_value["lang"] = root_lang
+    elif document_lang:
+        prop_value["lang"] = document_lang
+    if expose_dom:
+        prop_value["dom"] = el
+    else:
+        prop_value["html"] = el.decode_contents().strip()
+    return prop_value
diff --git a/mf2py/parser.py b/mf2py/parser.py
index 1cf07b1..f099c69 100644
--- a/mf2py/parser.py
+++ b/mf2py/parser.py
@@ -1,112 +1,148 @@
-# coding: utf-8
-from __future__ import unicode_literals, print_function
+import copy
+import json
+from urllib.parse import urlparse
 
+import requests
 from bs4 import BeautifulSoup, FeatureNotFound
 from bs4.element import Tag
 
-from . import backcompat, mf2_classes, implied_properties, parse_property
-from . import temp_fixes
-from .version import __version__
+from . import (
+    backcompat,
+    implied_properties,
+    metaformats,
+    mf2_classes,
+    parse_property,
+    temp_fixes,
+)
 from .dom_helpers import get_attr, get_children, get_descendents, try_urljoin
 from .mf_helpers import unordered_list
-
-import json
-import requests
-import sys
-import copy
-
-if sys.version < '3':
-    from urlparse import urlparse
-    text_type = unicode
-    binary_type = str
-else:
-    from urllib.parse import urlparse
-    text_type = str
-    binary_type = bytes
+from .version import __version__
 
 
-def parse(doc=None, url=None, html_parser=None, img_with_alt=False):
+def parse(
+    doc=None,
+    url=None,
+    html_parser=None,
+    expose_dom=False,
+    metaformats=False,
+    filter_roots=False,
+):
     """
-    Parse a microformats2 document or url and return a json dictionary.
+    Parse a document or URL for microformats and return a dictionary in mf2json format.
 
     Args:
-      doc (file or string or BeautifulSoup doc): file handle, text of content
-        to parse, or BeautifulSoup document. If None, it will be fetched from
-        given url
-      url (string): url of the file to be processed. Optionally extracted from
-        base-element of given doc
-      html_parser (string): optional, select a specific HTML parser. Valid
-        options from the BeautifulSoup documentation are:
-        "html", "xml", "html5", "lxml", "html5lib", and "html.parser"
-
-    Return: a json dict represented the structured data in this document.
+      doc (file, string or BeautifulSoup doc): file handle, text of content
+        to parse, or BeautifulSoup document. If None it will be fetched from
+        given URL.
+      url (string): URL of the file to be processed. If None it will be
+        extracted from the `<base>` element of given doc.
+      html_parser (string): optional, select a specific HTML parser. Valid options
+        from the BeautifulSoup documentation are: "html", "xml","html5", "lxml",
+        "html5lib", and "html.parser".
+      expose_dom (boolean): optional, expose the DOM of embedded properties.
+      metaformats (boolean): optional, include metaformats extracted from OGP
+        and Twitter card data: https://microformats.org/wiki/metaformats
+      filter_roots (boolean or list): optional, filter root class names. Use
+        True to filter known conflicting classes, otherwise filter given list.
+
+    Return: a mf2json dict representing the structured data in the document
+
     """
-    return Parser(doc, url, html_parser, img_with_alt).to_dict()
+    return Parser(
+        doc,
+        url,
+        html_parser,
+        expose_dom=expose_dom,
+        metaformats=metaformats,
+        filter_roots=filter_roots,
+    ).to_dict()
 
 
 class Parser(object):
-    """Object to parse a document for microformats and return them in
-    appropriate formats.
+    """
+    Parser to parse a document or URL for microformats and output in various formats.
 
     Args:
-      doc (file or string or BeautifulSoup doc): file handle, text of content
-        to parse, or BeautifulSoup document. If None, it will be fetched from
-        given url
-      url (string): url of the file to be processed. Optionally extracted from
-        base-element of given doc
-      html_parser (string): optional, select a specific HTML parser. Valid
-        options from the BeautifulSoup documentation are:
-        "html", "xml", "html5", "lxml", "html5lib", and "html.parser"
-        defaults to "html5lib"
+      doc (file, string or BeautifulSoup doc): file handle, text of content
+        to parse, or BeautifulSoup document. If None it will be fetched from
+        given URL.
+      url (string): URL of the file to be processed. If None it will be
+        extracted from the `<base>` element of given doc.
+      html_parser (string): optional, select a specific HTML parser. Valid options
+        from the BeautifulSoup documentation are: "html", "xml","html5", "lxml",
+        "html5lib", and "html.parser".
+      expose_dom (boolean): optional, expose the DOM of embedded properties.
+      metaformats (boolean): optional, include metaformats extracted from OGP
+        and Twitter card data: https://microformats.org/wiki/metaformats
+      filter_roots (boolean or list): optional, filter root class names. Use
+        True to filter known conflicting classes, otherwise filter given list.
 
     Attributes:
       useragent (string): the User-Agent string for the Parser
+
     """
 
-    ua_desc = 'mf2py - microformats2 parser for python'
+    ua_desc = "mf2py - microformats2 parser for python"
     ua_url = "https://github.com/microformats/mf2py"
-    useragent = '{0} - version {1} - {2}'.format(ua_desc, __version__, ua_url)
-
-    dict_class = dict
-
-    def __init__(self, doc=None, url=None, html_parser=None, img_with_alt=False):
+    useragent = "{0} - version {1} - {2}".format(ua_desc, __version__, ua_url)
+
+    def __init__(
+        self,
+        doc=None,
+        url=None,
+        html_parser=None,
+        expose_dom=False,
+        metaformats=False,
+        filter_roots=False,
+    ):
         self.__url__ = None
         self.__doc__ = None
         self._preserve_doc = False
-        self.__parsed__ = self.dict_class([
-            ('items', []),
-            ('rels', self.dict_class()),
-            ('rel-urls', self.dict_class()),
-            ('debug', self.dict_class([
-                ('description', self.ua_desc),
-                ('source', self.ua_url),
-                ('version', text_type(__version__))
-            ]))
-        ])
-        self.__img_with_alt__ = img_with_alt
+        self.__parsed__ = {
+            "items": [],
+            "rels": {},
+            "rel-urls": {},
+            "debug": {
+                "description": self.ua_desc,
+                "source": self.ua_url,
+                "version": __version__,
+            },
+        }
+        self.lang = None
+        self.expose_dom = expose_dom
+        self.__metaformats = metaformats
+        try:
+            self.filtered_roots = set(filter_roots)
+        except TypeError:
+            if filter_roots:
+                self.filtered_roots = mf2_classes.CONFLICTING_ROOTS_TAILWIND
+            else:
+                self.filtered_roots = []
 
         # use default parser if none specified
-        self.__html_parser__ = html_parser or 'html5lib'
+        self.__html_parser__ = html_parser or "html5lib"
 
         if url is not None:
             self.__url__ = url
 
             if doc is None:
-                data = requests.get(self.__url__, headers={
-                    'User-Agent': self.useragent,
-                })
+                data = requests.get(
+                    self.__url__,
+                    headers={
+                        "User-Agent": self.useragent,
+                    },
+                )
 
                 # update to final URL after redirects
                 self.__url__ = data.url
 
                 # HACK: check for character encodings and use 'correct' data
-                if 'charset' in data.headers.get('content-type', ''):
+                if "charset" in data.headers.get("content-type", ""):
                     doc = data.text
                 else:
                     doc = data.content
 
         if doc is not None:
-
             if isinstance(doc, BeautifulSoup) or isinstance(doc, Tag):
                 self.__doc__ = doc
                 self._preserve_doc = True
@@ -128,11 +164,11 @@ def __init__(self, doc=None, url=None, html_parser=None, img_with_alt=False):
 
         # check for <base> tag
         if self.__doc__:
-
-            poss_base = next((el for el in get_descendents(self.__doc__)
-                              if el.name == 'base'), None)
+            poss_base = next(
+                (el for el in get_descendents(self.__doc__) if el.name == "base"), None
+            )
             if poss_base:
-                poss_base_url = poss_base.get('href')  # try to get href
+                poss_base_url = poss_base.get("href")  # try to get href
                 if poss_base_url:
                     if urlparse(poss_base_url).netloc:
                         # base specifies an absolute path
@@ -142,10 +178,12 @@ def __init__(self, doc=None, url=None, html_parser=None, img_with_alt=False):
                         self.__url__ = try_urljoin(self.__url__, poss_base_url)
 
         if self.__doc__ is not None:
+            if document := self.__doc__.find("html"):
+                self.lang = document.attrs.get("lang")
             # parse!
-            self.parse()
+            self._parse()
 
-    def parse(self):
+    def _parse(self):
         """Does the work of actually parsing the document. Done automatically
         on initialization.
         """
@@ -157,23 +195,37 @@ def parse(self):
         # see value-class-pattern#microformats2_parsers on wiki.
         # see also the implied_relative_datetimes testcase.
 
-        def handle_microformat(root_class_names, el, value_property=None,
-                               simple_value=None, backcompat_mode=False):
-            """Handles a (possibly nested) microformat, i.e. h-*
-            """
-            properties = self.dict_class()
+        def handle_microformat(
+            root_class_names,
+            el,
+            value_property=None,
+            simple_value=None,
+            backcompat_mode=False,
+        ):
+            """Handles a (possibly nested) microformat, i.e. h-*"""
+            properties = {}
             children = []
             self._default_date = None
             # for processing implied properties: collects if property types (p, e, u, d(t)) or children (h) have been processed
             parsed_types_aggregation = set()
 
             if backcompat_mode:
-                el = backcompat.apply_rules(el, self.__html_parser__)
-                root_class_names = mf2_classes.root(el.get('class', []))
+                el = backcompat.apply_rules(
+                    el, self.__html_parser__, self.filtered_roots
+                )
+                root_class_names = mf2_classes.root(
+                    el.get("class", []), self.filtered_roots
+                )
+
+            root_lang = el.attrs.get("lang")
 
             # parse for properties and children
             for child in get_children(el):
-                child_props, child_children, child_parsed_types_aggregation = parse_props(child)
+                (
+                    child_props,
+                    child_children,
+                    child_parsed_types_aggregation,
+                ) = parse_props(child, root_lang)
                 for key, new_value in child_props.items():
                     prop_value = properties.get(key, [])
                     prop_value.extend(new_value)
@@ -189,38 +241,50 @@ def handle_microformat(root_class_names, el, value_property=None,
             # if some properties not already found find in implied ways unless in backcompat mode
             if not backcompat_mode:
                 # stop implied name if any p-*, e-*, h-* is already found
-                if "name" not in properties and parsed_types_aggregation.isdisjoint("peh"):
-                    properties["name"] = [implied_properties.name(el, base_url=self.__url__)]
-
-                if "photo" not in properties:
-                    x = implied_properties.photo(el, self.dict_class, self.__img_with_alt__, base_url=self.__url__)
+                if "name" not in properties and parsed_types_aggregation.isdisjoint(
+                    "peh"
+                ):
+                    properties["name"] = [
+                        implied_properties.name(el, self.__url__, self.filtered_roots)
+                    ]
+
+                if "photo" not in properties and parsed_types_aggregation.isdisjoint(
+                    "uh"
+                ):
+                    x = implied_properties.photo(el, self.__url__, self.filtered_roots)
                     if x is not None:
                         properties["photo"] = [x]
 
                 # stop implied url if any u-* or h-* is already found
-                if "url" not in properties and parsed_types_aggregation.isdisjoint("uh"):
-                    x = implied_properties.url(el, base_url=self.__url__)
+                if "url" not in properties and parsed_types_aggregation.isdisjoint(
+                    "uh"
+                ):
+                    x = implied_properties.url(el, self.__url__, self.filtered_roots)
                     if x is not None:
                         properties["url"] = [x]
 
             # build microformat with type and properties
-            microformat = self.dict_class([
-                ("type", [text_type(class_name)
-                          for class_name in sorted(root_class_names)]),
-                ("properties", properties),
-            ])
-            if str(el.name) == "area":
-                shape = get_attr(el, 'shape')
+            microformat = {
+                "type": [class_name for class_name in sorted(root_class_names)],
+                "properties": properties,
+            }
+            if el.name == "area":
+                shape = get_attr(el, "shape")
                 if shape is not None:
-                    microformat['shape'] = text_type(shape)
+                    microformat["shape"] = shape
 
-                coords = get_attr(el, 'coords')
+                coords = get_attr(el, "coords")
                 if coords is not None:
-                    microformat['coords'] = text_type(coords)
+                    microformat["coords"] = coords
 
             # insert children if any
             if children:
                 microformat["children"] = children
+
+            Id = get_attr(el, "id")
+            if Id:
+                microformat["id"] = Id
+
             # simple value is the parsed property value if it were not
             # an h-* class
             if simple_value is not None:
@@ -231,14 +295,17 @@ def handle_microformat(root_class_names, el, value_property=None,
                     # details: https://github.com/microformats/mf2py/issues/35
                     microformat.update(simple_value)
                 else:
-                    microformat["value"] = text_type(simple_value)
+                    microformat["value"] = simple_value
 
+            if root_lang:
+                microformat["lang"] = root_lang
+            elif self.lang:
+                microformat["lang"] = self.lang
             return microformat
 
-        def parse_props(el):
-            """Parse the properties from a single element
-            """
-            props = self.dict_class()
+        def parse_props(el, root_lang):
+            """Parse the properties from a single element"""
+            props = {}
             children = []
             # for processing implied properties: collects if property types (p, e, u, d(t)) or children (h) have been processed
             parsed_types_aggregation = set()
@@ -246,7 +313,7 @@ def parse_props(el):
             classes = el.get("class", [])
             filtered_classes = mf2_classes.filter_classes(classes)
             # Is this element a microformat2 root?
-            root_class_names = filtered_classes['h']
+            root_class_names = filtered_classes["h"]
             backcompat_mode = False
 
             # Is this element a microformat1 root?
@@ -255,80 +322,96 @@ def parse_props(el):
                 backcompat_mode = True
 
             if root_class_names:
-                parsed_types_aggregation.add('h')
-            
+                parsed_types_aggregation.add("h")
+
             # Is this a property element (p-*, u-*, etc.) flag
             # False is default
             is_property_el = False
 
             # Parse plaintext p-* properties.
             p_value = None
-            for prop_name in filtered_classes['p']:
+            for prop_name in filtered_classes["p"]:
                 is_property_el = True
-                parsed_types_aggregation.add('p')
+                parsed_types_aggregation.add("p")
                 prop_value = props.setdefault(prop_name, [])
 
                 # if value has not been parsed then parse it
                 if p_value is None:
-                    p_value = text_type(parse_property.text(el, base_url=self.__url__))
+                    p_value = parse_property.text(el, base_url=self.__url__)
 
                 if root_class_names:
-                    prop_value.append(handle_microformat(
-                        root_class_names, el, value_property="name",
-                        simple_value=p_value, backcompat_mode=backcompat_mode))
+                    prop_value.append(
+                        handle_microformat(
+                            root_class_names,
+                            el,
+                            value_property="name",
+                            simple_value=p_value,
+                            backcompat_mode=backcompat_mode,
+                        )
+                    )
                 else:
                     prop_value.append(p_value)
 
             # Parse URL u-* properties.
             u_value = None
-            for prop_name in filtered_classes['u']:
+            for prop_name in filtered_classes["u"]:
                 is_property_el = True
-                parsed_types_aggregation.add('u')
+                parsed_types_aggregation.add("u")
                 prop_value = props.setdefault(prop_name, [])
 
                 # if value has not been parsed then parse it
                 if u_value is None:
-                    u_value = parse_property.url(el, self.dict_class, self.__img_with_alt__, base_url=self.__url__)
+                    u_value = parse_property.url(el, base_url=self.__url__)
 
                 if root_class_names:
-                    prop_value.append(handle_microformat(
-                        root_class_names, el, value_property="url",
-                        simple_value=u_value, backcompat_mode=backcompat_mode))
+                    prop_value.append(
+                        handle_microformat(
+                            root_class_names,
+                            el,
+                            value_property="url",
+                            simple_value=u_value,
+                            backcompat_mode=backcompat_mode,
+                        )
+                    )
                 else:
-                    if isinstance(u_value, self.dict_class):
+                    if isinstance(u_value, dict):
                         prop_value.append(u_value)
                     else:
-                        prop_value.append(text_type(u_value))
+                        prop_value.append(u_value)
 
             # Parse datetime dt-* properties.
             dt_value = None
-            for prop_name in filtered_classes['dt']:
+            for prop_name in filtered_classes["dt"]:
                 is_property_el = True
-                parsed_types_aggregation.add('d')
+                parsed_types_aggregation.add("d")
                 prop_value = props.setdefault(prop_name, [])
 
                 # if value has not been parsed then parse it
                 if dt_value is None:
-                    dt_value, new_date = parse_property.datetime(
-                        el, self._default_date)
+                    dt_value, new_date = parse_property.datetime(el, self._default_date)
                     # update the default date
                     if new_date:
                         self._default_date = new_date
 
                 if root_class_names:
                     stops_implied_name = True
-                    prop_value.append(handle_microformat(
-                        root_class_names, el,
-                        simple_value=text_type(dt_value), backcompat_mode=backcompat_mode))
+                    prop_value.append(
+                        handle_microformat(
+                            root_class_names,
+                            el,
+                            simple_value=dt_value,
+                            backcompat_mode=backcompat_mode,
+                        )
+                    )
                 else:
                     if dt_value is not None:
-                        prop_value.append(text_type(dt_value))
+                        prop_value.append(dt_value)
 
             # Parse embedded markup e-* properties.
             e_value = None
-            for prop_name in filtered_classes['e']:
+            for prop_name in filtered_classes["e"]:
                 is_property_el = True
-                parsed_types_aggregation.add('e')
+                parsed_types_aggregation.add("e")
                 prop_value = props.setdefault(prop_name, [])
 
                 # if value has not been parsed then parse it
@@ -341,23 +424,39 @@ def parse_props(el):
                     if self._preserve_doc:
                         embedded_el = copy.copy(embedded_el)
                     temp_fixes.rm_templates(embedded_el)
-                    e_value = parse_property.embedded(embedded_el, base_url=self.__url__)
+                    e_value = parse_property.embedded(
+                        embedded_el, self.__url__, root_lang, self.lang, self.expose_dom
+                    )
 
                 if root_class_names:
                     stops_implied_name = True
-                    prop_value.append(handle_microformat(
-                        root_class_names, el, simple_value=e_value, backcompat_mode=backcompat_mode))
+                    prop_value.append(
+                        handle_microformat(
+                            root_class_names,
+                            el,
+                            simple_value=e_value,
+                            backcompat_mode=backcompat_mode,
+                        )
+                    )
                 else:
                     prop_value.append(e_value)
 
             # if this is not a property element, but it is a h-* microformat,
             # add it to our list of children
             if not is_property_el and root_class_names:
-                children.append(handle_microformat(root_class_names, el, backcompat_mode=backcompat_mode))
+                children.append(
+                    handle_microformat(
+                        root_class_names, el, backcompat_mode=backcompat_mode
+                    )
+                )
             # parse child tags, provided this isn't a microformat root-class
             if not root_class_names:
                 for child in get_children(el):
-                    child_properties, child_microformats, child_parsed_types_aggregation = parse_props(child)
+                    (
+                        child_properties,
+                        child_microformats,
+                        child_parsed_types_aggregation,
+                    ) = parse_props(child, root_lang)
                     for prop_name in child_properties:
                         v = props.get(prop_name, [])
                         v.extend(child_properties[prop_name])
@@ -367,19 +466,17 @@ def parse_props(el):
             return props, children, parsed_types_aggregation
 
         def parse_rels(el):
-            """Parse an element for rel microformats
-            """
-            rel_attrs = [text_type(rel) for rel in get_attr(el, 'rel')]
+            """Parse an element for rel microformats"""
+            rel_attrs = get_attr(el, "rel")
             # if rel attributes exist
             if rel_attrs is not None:
                 # find the url and normalise it
-                url = try_urljoin(self.__url__, el.get('href', ''))
-                value_dict = self.__parsed__["rel-urls"].get(url,
-                                                             self.dict_class())
+                url = try_urljoin(self.__url__, el.get("href", ""))
+                value_dict = self.__parsed__["rel-urls"].get(url, {})
 
                 # 1st one wins
                 if "text" not in value_dict:
-                    value_dict["text"] = el.get_text().strip()  
+                    value_dict["text"] = el.get_text().strip()
 
                 url_rels = value_dict.get("rels", [])
                 value_dict["rels"] = url_rels
@@ -388,7 +485,7 @@ def parse_rels(el):
                     x = get_attr(el, knownattr)
                     # 1st one wins
                     if x is not None and knownattr not in value_dict:
-                        value_dict[knownattr] = text_type(x)
+                        value_dict[knownattr] = x
 
                 self.__parsed__["rel-urls"][url] = value_dict
 
@@ -402,27 +499,25 @@ def parse_rels(el):
                     self.__parsed__["rels"][rel_value] = value_list
                 if "alternate" in rel_attrs:
                     alternate_list = self.__parsed__.get("alternates", [])
-                    alternate_dict = self.dict_class()
+                    alternate_dict = {}
                     alternate_dict["url"] = url
-                    x = " ".join(
-                        [r for r in rel_attrs if not r == "alternate"])
-                    if x is not "":
+                    x = " ".join([r for r in rel_attrs if not r == "alternate"])
+                    if x != "":
                         alternate_dict["rel"] = x
-                    alternate_dict["text"] = text_type(el.get_text().strip())
+                    alternate_dict["text"] = el.get_text().strip()
                     for knownattr in ("media", "hreflang", "type", "title"):
                         x = get_attr(el, knownattr)
                         if x is not None:
-                            alternate_dict[knownattr] = text_type(x)
+                            alternate_dict[knownattr] = x
                     alternate_list.append(alternate_dict)
                     self.__parsed__["alternates"] = alternate_list
 
         def parse_el(el, ctx):
-            """Parse an element for microformats
-            """
+            """Parse an element for microformats"""
             classes = el.get("class", [])
 
             # find potential microformats in root classnames h-*
-            potential_microformats = mf2_classes.root(classes)
+            potential_microformats = mf2_classes.root(classes, self.filtered_roots)
 
             # if potential microformats found parse them
             if potential_microformats:
@@ -432,7 +527,9 @@ def parse_el(el, ctx):
                 # find backcompat root classnames
                 potential_microformats = backcompat.root(classes)
                 if potential_microformats:
-                    result = handle_microformat(potential_microformats, el, backcompat_mode=True)
+                    result = handle_microformat(
+                        potential_microformats, el, backcompat_mode=True
+                    )
                     ctx.append(result)
                 else:
                     # parse child tags
@@ -440,27 +537,34 @@ def parse_el(el, ctx):
                         parse_el(child, ctx)
 
         ctx = []
+
+        if self.__metaformats:
+            # extract out a metaformats item, if available
+            self.__metaformats_item = metaformats.parse(self.__doc__, url=self.__url__)
+
         # start parsing at root element of the document
         parse_el(self.__doc__, ctx)
         self.__parsed__["items"] = ctx
+        if self.__metaformats and self.__metaformats_item:
+            self.__parsed__["items"].append(self.__metaformats_item)
 
         # parse for rel values
         for el in get_descendents(self.__doc__):
-            if el.name in ('a', 'area', 'link') and el.has_attr('rel'):
+            if el.name in ("a", "area", "link") and el.has_attr("rel"):
                 parse_rels(el)
 
         # sort the rels array in rel-urls since this should be unordered set
         for url in self.__parsed__["rel-urls"]:
-            if 'rels' in self.__parsed__["rel-urls"][url]:
-                rels = self.__parsed__["rel-urls"][url]['rels']
-                self.__parsed__["rel-urls"][url]['rels'] =  unordered_list(rels)
+            if "rels" in self.__parsed__["rel-urls"][url]:
+                rels = self.__parsed__["rel-urls"][url]["rels"]
+                self.__parsed__["rel-urls"][url]["rels"] = unordered_list(rels)
 
         # add actual parser used to debug
         # uses builder.NAME from BeautifulSoup
         if self.__html_parser__:
-            self.__parsed__["debug"]["markup parser"] = text_type(self.__html_parser__)
+            self.__parsed__["debug"]["markup parser"] = self.__html_parser__
         else:
-            self.__parsed__["debug"]["markup parser"] = text_type('unknown')
+            self.__parsed__["debug"]["markup parser"] = "unknown"
 
     def to_dict(self, filter_by_type=None):
         """Get a dictionary version of the parsed microformat document.
@@ -475,8 +579,7 @@ def to_dict(self, filter_by_type=None):
         if filter_by_type is None:
             return self.__parsed__
         else:
-            return [x for x in self.__parsed__['items']
-                    if filter_by_type in x['type']]
+            return [x for x in self.__parsed__["items"] if filter_by_type in x["type"]]
 
     def to_json(self, pretty_print=False, filter_by_type=None):
         """Get a json-encoding string version of the parsed microformats document
@@ -492,7 +595,8 @@ def to_json(self, pretty_print=False, filter_by_type=None):
         """
 
         if pretty_print:
-            return json.dumps(self.to_dict(filter_by_type), indent=4,
-                              separators=(', ', ': '))
+            return json.dumps(
+                self.to_dict(filter_by_type), indent=4, separators=(", ", ": ")
+            )
         else:
             return json.dumps(self.to_dict(filter_by_type))
diff --git a/mf2py/temp_fixes.py b/mf2py/temp_fixes.py
index 6d7da25..56c428e 100644
--- a/mf2py/temp_fixes.py
+++ b/mf2py/temp_fixes.py
@@ -1,3 +1,3 @@
 def rm_templates(doc):
-    for el in doc.find_all('template'):
+    for el in doc.find_all("template"):
         el.extract()
diff --git a/mf2py/value_class_pattern.py b/mf2py/value_class_pattern.py
index 7bc5b21..42ad964 100644
--- a/mf2py/value_class_pattern.py
+++ b/mf2py/value_class_pattern.py
@@ -1,53 +1,61 @@
 """functions to parse the properties of elements according to the value class pattern http://microformats.org/wiki/value-class-pattern """
 
-from __future__ import unicode_literals, print_function
+import re
 
+from .datetime_helpers import (
+    DATE_RE,
+    DATETIME_RE,
+    TIME_RE,
+    TIMEZONE_RE,
+    normalize_datetime,
+)
 from .dom_helpers import get_children
-from .datetime_helpers import normalize_datetime, DATETIME_RE, TIME_RE, DATE_RE, TIMEZONE_RE
 
-import re
 
 def _get_vcp_value(el):
-    if 'value-title' in el.get('class', []):
-        return el.get('title')
+    if "value-title" in el.get("class", []):
+        return el.get("title")
     return el.get_text()
 
 
 def _get_vcp_children(el):
-    return [c for c in get_children(el) if c.has_attr('class')
-            and ('value' in c['class'] or 'value-title' in c['class'])]
+    return [
+        c
+        for c in get_children(el)
+        if c.has_attr("class")
+        and ("value" in c["class"] or "value-title" in c["class"])
+    ]
 
-def text(el):
 
+def text(el):
     value_els = _get_vcp_children(el)
     if value_els:
-        return ''.join(_get_vcp_value(el) for el in value_els)
+        return "".join(_get_vcp_value(el) for el in value_els)
 
 
 def datetime(el, default_date=None):
-
     value_els = _get_vcp_children(el)
     if value_els:
         date_parts = []
         for value_el in value_els:
-            if 'value-title' in value_el.get('class', []):
-                title = el.get('title')
+            if "value-title" in value_el.get("class", []):
+                title = el.get("title")
                 if title:
                     date_parts.append(title.strip())
-            elif value_el.name in ('img', 'area'):
-                alt = value_el.get('alt') or value_el.get_text()
+            elif value_el.name in ("img", "area"):
+                alt = value_el.get("alt") or value_el.get_text()
                 if alt:
                     date_parts.append(alt.strip())
-            elif value_el.name == 'data':
-                val = value_el.get('value') or value_el.get_text()
+            elif value_el.name == "data":
+                val = value_el.get("value") or value_el.get_text()
                 if val:
                     date_parts.append(val.strip())
-            elif value_el.name == 'abbr':
-                title = value_el.get('title') or value_el.get_text()
+            elif value_el.name == "abbr":
+                title = value_el.get("title") or value_el.get_text()
                 if title:
                     date_parts.append(title.strip())
-            elif value_el.name in ('del', 'ins', 'time'):
-                dt = value_el.get('datetime') or value_el.get_text()
+            elif value_el.name in ("del", "ins", "time"):
+                dt = value_el.get("datetime") or value_el.get_text()
                 if dt:
                     date_parts.append(dt.strip())
             else:
@@ -58,18 +66,18 @@ def datetime(el, default_date=None):
         date_part = time_part = tz_part = None
 
         for part in date_parts:
-            match = re.match(DATETIME_RE + '$', part)
+            match = re.match(DATETIME_RE + "$", part)
             if match:
                 # if it's a full datetime, then we're done
-                date_part = match.group('date')
+                date_part = match.group("date")
                 return normalize_datetime(part, match=match), date_part
 
             # only use first found value
-            if re.match(TIME_RE + '$', part) and time_part is None:
+            if re.match(TIME_RE + "$", part) and time_part is None:
                 time_part = part
-            elif re.match(DATE_RE + '$', part) and date_part is None:
+            elif re.match(DATE_RE + "$", part) and date_part is None:
                 date_part = part
-            elif re.match(TIMEZONE_RE + '$', part) and tz_part is None:
+            elif re.match(TIMEZONE_RE + "$", part) and tz_part is None:
                 tz_part = part
 
         # use default date
@@ -77,8 +85,7 @@ def datetime(el, default_date=None):
             date_part = default_date
 
         if date_part and time_part:
-            date_time_value = '%s %s' % (date_part,
-                                         time_part)
+            date_time_value = "%s %s" % (date_part, time_part)
         else:
             date_time_value = date_part or time_part
 
@@ -86,4 +93,3 @@ def datetime(el, default_date=None):
             date_time_value += tz_part
 
         return normalize_datetime(date_time_value), date_part
-
diff --git a/mf2py/version.py b/mf2py/version.py
index cde4178..4adb557 100644
--- a/mf2py/version.py
+++ b/mf2py/version.py
@@ -1,4 +1,7 @@
 # Define the version number. This class is exec'd by setup.py to read
 # the value without loading mf2py (loading mf2py is bad if its dependencies
 # haven't been installed yet, which is common during setup)
-__version__ = '1.1.2'
+
+import importlib.metadata
+
+__version__ = importlib.metadata.metadata("mf2py")["Version"]
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000..e45b5e8
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,46 @@
+site_name: mf2py
+site_url: https://microformats.github.io/mf2py
+site_author: Microformats
+site_description: A microformats2 parser written in Python.
+repo_name: microformats/mf2py
+repo_url: https://github.com/microformats/mf2py
+edit_uri: https://github.com/microformats/mf2py/tree/main/docs
+copyright: MIT License
+
+extra_css:
+  - stylesheets/styles.css
+
+nav:
+  - Home: index.md
+  - Parser Object: parser.md
+  - Change Log: changelog.md
+
+theme:
+  name: 'material'
+  logo: https://microformats.org/microformats-logo.png
+  favicon: https://microformats.org/microformats-logo.png
+  palette:
+    # Palette for light mode
+    - scheme: default
+      primary: 'custom'
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+  font:
+    text: Roboto
+    code: Roboto Mono
+
+plugins:
+  - mkdocstrings
+  - search
+
+markdown_extensions:
+  - admonition
+  - pymdownx.details
+  - pymdownx.superfences
+  - attr_list
+  - md_in_html
+  - pymdownx.tabbed:
+      alternate_style: true
+  - toc:
+      permalink: true
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..bc5edd6
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,38 @@
+[tool.poetry]
+name = "mf2py"
+version = "2.0.1"
+description = "Microformats parser"
+readme = "README.md"
+authors = ["Tom Morris <tom@tommorris.org>"]
+license = "MIT"
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Text Processing :: Markup :: HTML"
+]
+
+[tool.poetry.dependencies]
+python = ">=3.8"
+html5lib = "^1.1"
+requests = "^2.28.2"
+beautifulsoup4 = "^4.11.1"
+
+[tool.poetry.group.dev.dependencies]
+lxml = "^4.9.2"
+pytest = "^7.2.1"
+black = "^23.3.0"
+isort = "^5.12.0"
+mkdocs = "^1.5.3"
+mkdocs-material = "^9.5.0"
+mkdocstrings = {extras = ["python"], version = "^0.24.0"}
+
+[tool.pytest.ini_options]
+doctest_optionflags = "NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL"
+
+[tool.isort]
+profile = "black"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 85b8953..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# Keep in sync with setup.py's install_requires!
-html5lib==1.0.1
-nose==1.3.0
-mock==1.3.0
-lxml==4.2.4
-requests==2.18.4
-BeautifulSoup4==4.6.0
--e .
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 42b3148..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,2 +0,0 @@
-[nosetests]
-exclude=test_suite
diff --git a/setup.py b/setup.py
deleted file mode 100644
index ac6277a..0000000
--- a/setup.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python
-
-from setuptools import setup
-import os.path
-
-ns = {}
-with open(os.path.join(os.path.dirname(__file__), 'mf2py/version.py'))\
-        as version_file:
-    exec(version_file.read(), ns)
-
-
-setup(name='mf2py',
-      version=ns['__version__'],
-      description='Python Microformats2 parser',
-      long_description=open('README.md').read(),
-      long_description_content_type='text/markdown',
-      author='Tom Morris',
-      author_email='tom@tommorris.org',
-      url='http://microformats.org/wiki/mf2py',
-      install_requires=[
-          # Keep in sync with requirements.txt!
-          'html5lib>=1.0.1',
-          'requests>=2.18.4',
-          'BeautifulSoup4>=4.6.0',
-      ],
-      tests_require=[
-          'lxml',
-          'mock',
-          'nose',
-      ],
-      packages=['mf2py'],
-      package_data={'mf2py': ['backcompat-rules/*.json']},
-      test_suite='nose.collector',
-      classifiers=[
-          'Development Status :: 4 - Beta',
-          'Intended Audience :: Developers',
-          'License :: OSI Approved :: MIT License',
-          'Natural Language :: English',
-          'Programming Language :: Python :: 2.7',
-          'Programming Language :: Python :: 3',
-          'Topic :: Text Processing :: Markup :: HTML'
-      ])
diff --git a/test/examples/datetimes.html b/test/examples/datetimes.html
index cfd9f57..3e1deb1 100644
--- a/test/examples/datetimes.html
+++ b/test/examples/datetimes.html
@@ -140,5 +140,38 @@ <h1 class="p-name">Ordinal date</h1>
    </p>
  </div>
 
+ <div class="h-entry">
+   <!-- wiki event with UTC offset without leading zero -->
+   <span class="dt-start">
+     <span class="value" title="June 1, 2014">2014-06-01</span>
+     <span class="value" title="12:30">12:30<span style="display: none;">-6:00</span></span>
+   </span>
+ </div>
+
+ <div class="h-entry">
+   <!-- wiki event with positive UTC offset without leading zero-->
+   <span class="dt-start">
+     <span class="value" title="June 1, 2014">2014-06-01</span>
+     <span class="value" title="12:30">12:30<span style="display: none;">+6:00</span></span>
+   </span>
+ </div>
+
+<div class="h-entry">
+   <!-- wiki event with Zulu time-->
+   <span class="dt-start">
+     <span class="value" title="June 1, 2014">2014-06-01</span>
+     <span class="value" title="12:30">12:30<span style="display: none;">Z</span></span>
+   </span>
+ </div>
+
+ <div class="h-entry">
+   <!-- with UTC offset without leading zero in extra value part -->
+   <span class="dt-start">
+     <span class="value" title="June 1, 2014">2014-06-01</span>
+     <span class="value" title="12:30">12:30</span><span class="value">-6:00</span></span>
+   </span>
+ </div>
+
+
 </body>
 </html>
diff --git a/test/examples/eras.html b/test/examples/eras.html
new file mode 100644
index 0000000..ad5dcc9
--- /dev/null
+++ b/test/examples/eras.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang=en-us>
+<head>
+<base href=https://example.com>
+<link rel=webmention href=/mentions>
+</head>
+<body>
+<div class=h-entry>
+  <h1 class=p-name>Excited for the Taylor Swift Eras Tour</h1>
+  <p>Published by <a class="p-author h-card" href=/>James</a>
+    <time class=dt-published datetime=2023-11-30T19:08:09>Thursday, November 30</time></p>
+  <div><img class=u-featured alt="Eras tour poster" src=/eras.jpg></div>
+  <div class=e-content><p>I can't decide which era is my favorite.</p></div>
+  <p><span class=p-category>music</span>, <span class=p-category>Taylor Swift</span></p>
+</div>
+</body>
+</html>
diff --git a/test/examples/festivus.html b/test/examples/festivus.html
new file mode 100644
index 0000000..11d94f7
--- /dev/null
+++ b/test/examples/festivus.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<h2 class=h-card>Jerry</h2>
+<p class=h-entry><q class=p-content>Happy Festivus!</q></p>
+<h2 class=h-card>Frank</h2>
+<p class=h-entry><q class=p-content>It's time for the Festivus feats of
+strength.</q></p>
+<p class=h-entry><q class=p-content>The tradition of Festivus begins with
+the airing of grievances.</q></p>
+<h2 class=h-card>Cosmo</h2>
+<p class=h-entry><q class=p-content>It's a Festivus miracle!</q></p>
diff --git a/test/examples/filter_roots.html b/test/examples/filter_roots.html
new file mode 100644
index 0000000..ce72889
--- /dev/null
+++ b/test/examples/filter_roots.html
@@ -0,0 +1,9 @@
+<h2>Tailwind root filter</h2>
+<div class=h-card>fnord</div>
+<div class=h-auto>fnord</div>
+<div class=h-fit>fnord</div>
+<div class=h-full>fnord</div>
+<div class=h-max>fnord</div>
+<div class=h-min>fnord</div>
+<div class=h-px>fnord</div>
+<div class=h-screen>fnord</div>
diff --git a/test/examples/filter_roots_custom.html b/test/examples/filter_roots_custom.html
new file mode 100644
index 0000000..4ff79de
--- /dev/null
+++ b/test/examples/filter_roots_custom.html
@@ -0,0 +1,6 @@
+<h2>Custom root filter</h2>
+<div class=h-card>fnord</div>
+<div class=h-foo>fnord</div>
+<div class=h-bar>fnord</div>
+<div class=h-bat>fnord</div>
+<div class=h-baz>fnord</div>
diff --git a/test/examples/experimental/img_with_alt.html b/test/examples/img_with_alt.html
similarity index 100%
rename from test/examples/experimental/img_with_alt.html
rename to test/examples/img_with_alt.html
diff --git a/test/examples/img_with_srcset.html b/test/examples/img_with_srcset.html
new file mode 100644
index 0000000..88f33c5
--- /dev/null
+++ b/test/examples/img_with_srcset.html
@@ -0,0 +1,77 @@
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy-480w.jpg 480w,
+               elva-fairy-800w.jpg 800w"
+       sizes="(max-width: 600px) 480px,
+              800px"
+       src="elva-fairy-800w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy-320w.jpg,
+               elva-fairy-480w.jpg 1.5x,
+               elva-fairy-640w.jpg 2x,
+               elva-fairy-1.5w.jpg 1.5x,
+               elva-fairy-2w.jpg 2x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg, elva-fairy,480w.jpg 1.5x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg ,elva-fairy,480w.jpg 1.5x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg 1x,elva-fairy,480w.jpg 1.5x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg 1x ,elva-fairy,480w.jpg 1.5x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg 1x , elva-fairy,480w.jpg 1.5x"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy,320w.jpg"
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="
+           elva-fairy,320w.jpg,
+               elva-fairy,480w.jpg
+       1.5x,
+               elva-fairy,640w.jpg 2x   ,
+
+               elva-fairy,1.5w.jpg     1.5x     ,
+               elva-fairy,2w.jpg 2x
+       "
+       src="elva-fairy-320w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
diff --git a/test/examples/img_with_srcset_with_base.html b/test/examples/img_with_srcset_with_base.html
new file mode 100644
index 0000000..467b428
--- /dev/null
+++ b/test/examples/img_with_srcset_with_base.html
@@ -0,0 +1,11 @@
+<base href="https://example.com">
+
+<div class="h-entry">
+  <img class="u-photo"
+       srcset="elva-fairy-480w.jpg 480w,
+               elva-fairy-800w.jpg 800w"
+       sizes="(max-width: 600px) 480px,
+              800px"
+       src="elva-fairy-800w.jpg"
+       alt="Elva dressed as a fairy">
+</div>
diff --git a/test/examples/implied_properties/implied_photo_relative_url.html b/test/examples/implied_properties/implied_photo_relative_url.html
new file mode 100644
index 0000000..f9db03f
--- /dev/null
+++ b/test/examples/implied_properties/implied_photo_relative_url.html
@@ -0,0 +1,5 @@
+<html>
+<base href="http://example.com">
+<img class="h-card" alt="Jane Doe" src="jane-img.jpeg">
+<object class="h-card" data="jane-object.jpeg">Jane Doe</object>
+</html>
diff --git a/test/examples/language.html b/test/examples/language.html
new file mode 100644
index 0000000..79273ee
--- /dev/null
+++ b/test/examples/language.html
@@ -0,0 +1,15 @@
+<html lang="it">
+  <div class="h-card">
+    <h1 class="p-name">Romero</h1>
+  </div>
+  <div class="h-entry">
+    <h1 class="p-name">Un titolo italiano</h1>
+    <div class="e-content" lang="en">With an <em>english</em> summary</div>
+    <div class="e-content">Con un riassunto <em>italiano</em></div>
+  </div>
+  <div class="h-entry" lang="sv">
+    <h1 class="p-name">En svensk titel</h1>
+    <div class="e-content" lang="en">With an <em>english</em> summary</div>
+    <div class="e-content">Och <em>svensk</em> huvudtext</div>
+  </div>
+</html>
diff --git a/test/examples/metaformats_html_meta.html b/test/examples/metaformats_html_meta.html
new file mode 100644
index 0000000..25f251e
--- /dev/null
+++ b/test/examples/metaformats_html_meta.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Hello World</title>
+  <base href="http://tantek.com/" />
+  <meta name="description" content="Descrypshun bar" />
+</head>
+<body>
+  <p>Hello world!</p>
+</body>
+</html>
diff --git a/test/examples/metaformats_ogp.html b/test/examples/metaformats_ogp.html
new file mode 100644
index 0000000..a865469
--- /dev/null
+++ b/test/examples/metaformats_ogp.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Hello World</title>
+  <base href="http://tantek.com/" />
+  <meta property="og:type" content="article" />
+  <meta property="og:title" content="Titull foo" />
+  <meta property="og:description" content="Descrypshun bar" />
+  <meta property="og:image" content="http://example.com/baz.jpg" />
+  <meta property="og:audio" content="http://example.com/biff.mp3" />
+  <meta property="og:video" content="http://example.com/boff.mov" />
+  <meta property="article:author" content="/me" />
+  <meta property="article:published_time" content="2023-01-02T03:04Z" />
+  <meta property="article:modified_time" content="2023-01-02T05:06Z" />
+</head>
+<body>
+  <p>Hello world!</p>
+</body>
+</html>
diff --git a/test/examples/metaformats_twitter.html b/test/examples/metaformats_twitter.html
new file mode 100644
index 0000000..9ad9495
--- /dev/null
+++ b/test/examples/metaformats_twitter.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Hello World</title>
+  <base href="http://tantek.com/" />
+  <meta name="twitter:title" content="Titull foo" />
+  <meta name="twitter:description" content="Descrypshun bar" />
+  <meta name="twitter:image" content="/baz.jpg" />
+</head>
+<body>
+  <p>Hello world!</p>
+</body>
+</html>
diff --git a/test/examples/parse_id.html b/test/examples/parse_id.html
new file mode 100644
index 0000000..0584846
--- /dev/null
+++ b/test/examples/parse_id.html
@@ -0,0 +1,6 @@
+<div class="h-feed" id="recentArticles">
+    <h2 class="p-name">Recent Articles</h2>
+    <div class="hentry" id="article">Lorem Ipsum</div>
+    <div class="hentry" id="">empty id is invalid and should not be parsed</div>
+    <div class="p-author h-card" id="theAuthor">Max Mustermann</div>
+</div>
\ No newline at end of file
diff --git a/test/examples/plaintext_img_whitespace.html b/test/examples/plaintext_img_whitespace.html
new file mode 100644
index 0000000..7929b4b
--- /dev/null
+++ b/test/examples/plaintext_img_whitespace.html
@@ -0,0 +1,19 @@
+<base href="https://example.com">
+
+<div class="h-entry">
+  <div class="e-content">
+    <img src="/photo.jpg" alt="selfie">At some tourist spot
+  </div>
+</div>
+
+<div class="h-entry">
+  <div class="e-content">
+    <img src="/photo.jpg" alt="">At another tourist spot
+  </div>
+</div>
+
+<div class="h-entry">
+  <div class="e-content">
+    <img src="/photo.jpg">At yet another tourist spot
+  </div>
+</div>
diff --git a/test/examples/plaintext_p_whitespace.html b/test/examples/plaintext_p_whitespace.html
new file mode 100644
index 0000000..22ad75e
--- /dev/null
+++ b/test/examples/plaintext_p_whitespace.html
@@ -0,0 +1,17 @@
+<div class="h-entry">
+  <div class="e-content">
+    <p>foo</p><img src="pic.png" alt="bar">baz
+  </div>
+</div>
+
+<div class="h-entry">
+  <div class="e-content">
+    <p>foo</p>bar baz
+  </div>
+</div>
+
+<div class="h-entry">
+  <div class="e-content">
+    foo bar<p>baz</p>
+  </div>
+</div>
diff --git a/test/examples/relative_url_in_e.html b/test/examples/relative_url_in_e.html
new file mode 100644
index 0000000..19f19ed
--- /dev/null
+++ b/test/examples/relative_url_in_e.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Relative URLs in e-content</title>
+  <base href="http://example.com/" />
+</head>
+<body>
+<div class="h-entry">
+<div class="e-content"><p><a href=/cat.html>Cat <img src=cat.jpg></a></p></div>
+</div>
+</body>
+</html>
diff --git a/test/examples/u_all_cases.html b/test/examples/u_all_cases.html
new file mode 100644
index 0000000..dedd056
--- /dev/null
+++ b/test/examples/u_all_cases.html
@@ -0,0 +1,48 @@
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>Hello World</title>
+  <base href="http://example.com/" />
+</head>
+<body>
+<article class="h-entry">
+    <h1><a  class="p-name">Testing variations of u-properties</a></h1>
+        <ul>
+            <!--if a.u-x[href] or area.u-x[href] or link.u-x[href], then get the href attribute -->
+            <li><a class="u-url" href="/test"></a></li>
+            <li><a class="u-url" href="http://example.com/test"></a></li>
+            <li><area class="u-url" href="/test"></li>
+            <li><area class="u-url" href="http://example.com/test"></li>
+            <li><link class="u-url" href="/test"></li>
+            <li><link class="u-url" href="http://example.com/test"></li>
+            <!--else if img.u-x[src] or audio.u-x[src] or video.u-x[src] or source.u-x[src] or iframe.u-x[src], then get the src attribute-->
+            <li><img class="u-url" src="/test"></li>
+            <li><img class="u-url" src="http://example.com/test"></li>
+            <li><audio class="u-url" src="/test"></audio></li>
+            <li><audio class="u-url" src="http://example.com/test"></audio></li>
+            <li><video class="u-url" src="/test"><source class="u-url" src="/test"></video></li>
+            <li><video class="u-url" src="http://example.com/test"><source class="u-url" src="http://example.com/test"></video></li>
+            <!--else if video.u-x[poster], then get the poster attribute-->
+            <li><video class="u-url" poster="/test"></video></li>
+            <li><video class="u-url" poster="http://example.com/test"></video></li>
+            <!--else if object.u-x[data], then get the data attribute-->
+            <li><object class="u-url" data="/test"></object></li>
+            <li><object class="u-url" data="http://example.com/test"></object></li>
+            <!-- else parse the element for the value-class-pattern. If a value is found, get it-->
+            <!-- no test case -->
+            <!-- else if abbr.u-x[title], then get the title attribute-->
+            <li><abbr class="u-url" title="/test">CHEESE</abbr></li>
+            <li><abbr class="u-url" title="http://example.com/test">CHEESE</abbr></li>
+            <!-- else if data.u-x[value] or input.u-x[value], then get the value attribute-->
+            <li><data class="u-url" value="/test"></data></li>
+            <li><data class="u-url" value="http://example.com/test"></data></li>
+            <li><input class="u-url" value="/test"></li>
+            <li><input class="u-url" value="http://example.com/test"></li>
+            <!-- else get the textContent of the element after removing all leading/trailing whitespace and nested <script> & <style> elements-->
+            <li><p class="u-url">/test</p></li>
+            <li><p class="u-url">http://example.com/test</p></li>
+            <li><p class="u-url">       /test        </p></li>
+            <li><p class="u-url">       /test<script>dsjfskjflkds</script>        </p></li>
+        </ul>
+</article>
+</body>
diff --git a/test/examples/value_name_whitespace.html b/test/examples/value_name_whitespace.html
index 33aca40..ce8b3f3 100644
--- a/test/examples/value_name_whitespace.html
+++ b/test/examples/value_name_whitespace.html
@@ -22,10 +22,6 @@
 World</p></div>
 </div>
 
-<div class="h-entry">
-  <div class="e-content p-name"><p>Hello</p><p>World</p></div>
-</div>
-
 <div class="h-entry">
   <div class="e-content p-name">Hello<br>
     World</div>
@@ -36,11 +32,7 @@
 </div>
 
 <div class="h-entry">
-  <div class="e-content p-name">
-    <p>One</p>
-    <p>Two</p>
-    <p>Three</p>
-  </div>
+  <div class="e-content p-name"><p>Hello</p><p>World</p></div>
 </div>
 
 <div class="h-entry">
@@ -51,6 +43,14 @@
   </div>
 </div>
 
+<div class="h-entry">
+  <div class="e-content p-name">
+    <p>One</p>
+    <p>Two</p>
+    <p>Three</p>
+  </div>
+</div>
+
 <div class="h-entry">
   <div class="e-content p-name">
     Hello World
diff --git a/test/test_parser.py b/test/test_parser.py
index 505a4be..bcfd2c6 100644
--- a/test/test_parser.py
+++ b/test/test_parser.py
@@ -1,189 +1,168 @@
-from __future__ import unicode_literals, print_function
-
 import os
 import re
 import sys
+from unittest import TestCase, mock
 
-import mock
-from nose.tools import assert_equal, assert_true, assert_false
-from mf2py import Parser
+import bs4
 from bs4 import BeautifulSoup
-from unittest import TestCase
+
+from mf2py import Parser
 
 TestCase.maxDiff = None
 
 
-if sys.version < '3':
-    text_type = unicode
-    binary_type = str
-else:
-    text_type = str
-    binary_type = bytes
+TEST_DIR = "test/examples/"
 
-TEST_DIR = 'test/examples/'
 
-def parse_fixture(path, url=None):
+def parse_fixture(path, **kwargs):
     with open(os.path.join(TEST_DIR, path)) as f:
-        p = Parser(doc=f, url=url, html_parser='html5lib')
+        p = Parser(doc=f, html_parser="html5lib", **kwargs)
         return p.to_dict()
 
 
 def test_empty():
     p = Parser()
-    assert_true(type(p) is not None)
-    assert_true(type(p.to_dict()) is dict)
+    assert type(p) is not None
+    assert type(p.to_dict()) is dict
 
 
 def test_open_file():
-    with open(os.path.join(TEST_DIR, 'empty.html')) as f:
+    with open(os.path.join(TEST_DIR, "empty.html")) as f:
         p = Parser(doc=f)
 
-    assert_true(p.__doc__ is not None)
-    assert_true(type(p) is not None)
-    assert_true(type(p.to_dict()) is dict)
+    assert p.__doc__ is not None
+    assert type(p) is not None
+    assert type(p.to_dict()) is dict
+
 
 def test_doc_tag():
     # test that strings, BS doc and BS tags are all parsed
-    doc = '''<article class="h-entry"></article>'''
-    soup = BeautifulSoup(doc)
+    doc = """<article class="h-entry"></article>"""
+    soup = BeautifulSoup(doc, "html5lib")
     parse_string = Parser(doc).to_dict()
-    assert 'h-entry' in parse_string['items'][0]['type']
+    assert "h-entry" in parse_string["items"][0]["type"]
     parse_doc = Parser(soup).to_dict()
-    assert 'h-entry' in parse_doc['items'][0]['type']
+    assert "h-entry" in parse_doc["items"][0]["type"]
     parse_tag = Parser(soup.article).to_dict()
-    assert 'h-entry' in parse_tag['items'][0]['type']
+    assert "h-entry" in parse_tag["items"][0]["type"]
+
 
-@mock.patch('requests.get')
+@mock.patch("requests.get")
 def test_user_agent(getter):
-    ua_expect = 'mf2py - microformats2 parser for python'
-    assert_true(Parser.useragent.startswith(ua_expect))
+    ua_expect = "mf2py - microformats2 parser for python"
+    assert Parser.useragent.startswith(ua_expect)
 
     resp = mock.MagicMock()
-    resp.content = b''
-    resp.text = ''
+    resp.content = b""
+    resp.text = ""
     resp.headers = {}
     getter.return_value = resp
 
-    Parser(url='http://example.com')
-    getter.assert_called_with('http://example.com', headers={
-        'User-Agent': Parser.useragent
-    })
+    Parser(url="http://example.com")
+    getter.assert_called_with(
+        "http://example.com", headers={"User-Agent": Parser.useragent}
+    )
 
-    Parser.useragent = 'something else'
-    assert_equal(Parser.useragent, 'something else')
+    Parser.useragent = "something else"
+    assert Parser.useragent == "something else"
     # set back to default. damn stateful classes
-    Parser.useragent = 'mf2py - microformats2 parser for python'
+    Parser.useragent = "mf2py - microformats2 parser for python"
 
 
 def test_base():
-    with open(os.path.join(TEST_DIR, 'base.html')) as f:
+    with open(os.path.join(TEST_DIR, "base.html")) as f:
         p = Parser(doc=f)
 
-    assert_equal(p.__url__, "http://tantek.com/")
+    assert p.__url__ == "http://tantek.com/"
 
 
 def test_simple_parse():
     result = parse_fixture("simple_person_reference.html")
-    assert_equal(result["items"][0]["properties"],
-                 {'name': ['Frances Berriman']})
+    assert result["items"][0]["properties"] == {"name": ["Frances Berriman"]}
 
 
 def test_simple_person_reference_same_element():
     result = parse_fixture("simple_person_reference_same_element.html")
-    assert_equal(result["items"][0]["properties"],
-                 {'name': ['Frances Berriman']})
+    assert result["items"][0]["properties"] == {"name": ["Frances Berriman"]}
 
 
 def test_person_with_url():
     result = parse_fixture("person_with_url.html")
-    assert_equal(result["items"][0]["properties"]["name"],
-                 ['Tom Morris'])
-    assert_equal(result["items"][0]["properties"]["url"],
-                 ['http://tommorris.org/'])
+    assert result["items"][0]["properties"]["name"] == ["Tom Morris"]
+    assert result["items"][0]["properties"]["url"] == ["http://tommorris.org/"]
 
 
 def test_vcp():
     result = parse_fixture("value_class_person.html")
-    assert_equal(result["items"][0]["properties"]["tel"], ['+44 1234 567890'])
+    assert result["items"][0]["properties"]["tel"] == ["+44 1234 567890"]
 
 
 def test_multiple_root_classnames():
     result = parse_fixture("nested_multiple_classnames.html")
     # order does not matter
-    assert_equal(len(result["items"]), 1)
-    assert_equal(set(result["items"][0]["type"]),
-                 set(["h-entry", "h-as-note"]))
+    assert len(result["items"]) == 1
+    assert set(result["items"][0]["type"]) == set(["h-entry", "h-as-note"])
 
 
 def test_property_nested_microformat():
     result = parse_fixture("nested_multiple_classnames.html")
 
-    assert_equal(len(result["items"]), 1)
+    assert len(result["items"]) == 1
     assert "author" in result["items"][0]["properties"]
-    assert_equal(
-        result["items"][0]["properties"]["author"][0]["properties"]["name"][0],
-        "Tom Morris")
-    assert_equal(
-        result["items"][0]["properties"]["reviewer"][0]
-        ["properties"]["name"][0],
-        "Tom Morris")
-    assert_equal(
-        result["items"][0]["properties"]["author"][0]
-        ["properties"]["adr"][0]["properties"]["city"][0],
-        "London")
+    assert (
+        result["items"][0]["properties"]["author"][0]["properties"]["name"][0]
+        == "Tom Morris"
+    )
+    assert (
+        result["items"][0]["properties"]["reviewer"][0]["properties"]["name"][0]
+        == "Tom Morris"
+    )
+    assert (
+        result["items"][0]["properties"]["author"][0]["properties"]["adr"][0][
+            "properties"
+        ]["city"][0]
+        == "London"
+    )
 
 
 def test_plain_child_microformat():
     result = parse_fixture("nested_multiple_classnames.html")
 
-    assert_equal(len(result["items"]), 1)
-    assert_true("children" in result["items"][0])
-    assert_equal(len(result["items"][0]["children"]), 1)
-    assert_equal(
-        result["items"][0]["children"][0]["properties"]["name"][0],
-        "Some Citation")
+    assert len(result["items"]) == 1
+    assert "children" in result["items"][0]
+    assert len(result["items"][0]["children"]) == 1
+    assert result["items"][0]["children"][0]["properties"]["name"][0] == "Some Citation"
 
 
 def test_datetime_parsing():
     result = parse_fixture("datetimes.html")
-    assert_equal(result["items"][0]["properties"]["start"][0],
-                 "2014-01-01T12:00:00+00:00")
-    assert_equal(result["items"][0]["properties"]["end"][0],
-                 "3014-01-01T18:00:00+00:00")
-    assert_equal(result["items"][0]["properties"]["duration"][0],
-                 "P1000Y")
-    assert_equal(result["items"][0]["properties"]["updated"][0],
-                 "2011-08-26T00:01:21+00:00")
-    assert_equal(result["items"][0]["properties"]["updated"][1],
-                 "2011-08-26T00:01:21+00:00")
+    assert result["items"][0]["properties"]["start"][0] == "2014-01-01T12:00:00+0000"
+    assert result["items"][0]["properties"]["end"][0] == "3014-01-01T18:00:00+0000"
+    assert result["items"][0]["properties"]["duration"][0] == "P1000Y"
+    assert result["items"][0]["properties"]["updated"][0] == "2011-08-26T00:01:21+0000"
+    assert result["items"][0]["properties"]["updated"][1] == "2011-08-26T00:01:21+0000"
 
 
 def test_datetime_vcp_parsing():
     result = parse_fixture("datetimes.html")
-    assert_equal(result["items"][1]["properties"]["published"][0],
-                 "3014-01-01 01:21Z")
-    assert_equal(result["items"][2]["properties"]["updated"][0],
-                 "2014-03-11 09:55")
-    assert_equal(result["items"][3]["properties"]["published"][0],
-                 "2014-01-30 15:28")
-    assert_equal(result["items"][4]["properties"]["published"][0],
-                 "9999-01-14T11:52+08:00")
-    assert_equal(result["items"][5]["properties"]["published"][0],
-                 "2014-06-01 12:30-06:00")
-    assert_equal(result["items"][8]["properties"]["start"][0],
-                 "2014-06-01 12:30-06:00")
-    assert_equal(result["items"][9]["properties"]["start"][0],
-                 "2014-06-01 12:30-06:00")
-    assert_equal(result["items"][10]["properties"]["start"][0],
-                 "2014-06-01 00:30-06:00")
-    assert_equal(result["items"][10]["properties"]["end"][0],
-                 "2014-06-01 12:15")
-    assert_equal(result["items"][10]["properties"]["start"][1],
-                 "2014-06-01 00:30-06:00")
-    assert_equal(result["items"][10]["properties"]["end"][1],
-                 "2014-06-01 12:15")
-    assert_equal(result["items"][11]["properties"]["start"][0],
-                 "2016-03-02 00:30-06:00")
+    assert len(result["items"]) == 16
+    assert result["items"][1]["properties"]["published"][0] == "3014-01-01 01:21Z"
+    assert result["items"][2]["properties"]["updated"][0] == "2014-03-11 09:55"
+    assert result["items"][3]["properties"]["published"][0] == "2014-01-30 15:28"
+    assert result["items"][4]["properties"]["published"][0] == "9999-01-14T11:52+0800"
+    assert result["items"][5]["properties"]["published"][0] == "2014-06-01 12:30-0600"
+    assert result["items"][8]["properties"]["start"][0] == "2014-06-01 12:30-0600"
+    assert result["items"][9]["properties"]["start"][0] == "2014-06-01 12:30-0600"
+    assert result["items"][10]["properties"]["start"][0] == "2014-06-01 00:30-0600"
+    assert result["items"][10]["properties"]["end"][0] == "2014-06-01 12:15"
+    assert result["items"][10]["properties"]["start"][1] == "2014-06-01 00:30-0600"
+    assert result["items"][10]["properties"]["end"][1] == "2014-06-01 12:15"
+    assert result["items"][11]["properties"]["start"][0] == "2016-03-02 00:30-0600"
+    assert result["items"][12]["properties"]["start"][0] == "2014-06-01 12:30-600"
+    assert result["items"][13]["properties"]["start"][0] == "2014-06-01 12:30+600"
+    assert result["items"][14]["properties"]["start"][0] == "2014-06-01 12:30Z"
+    assert result["items"][15]["properties"]["start"][0] == "2014-06-01 12:30-600"
+
 
 def test_dt_end_implied_date():
     """Test that events with dt-start and dt-end use the implied date rule
@@ -192,187 +171,208 @@ def test_dt_end_implied_date():
     result = parse_fixture("datetimes.html")
 
     event_wo_tz = result["items"][6]
-    assert_equal(event_wo_tz["properties"]["start"][0],
-                 "2014-05-21 18:30")
-    assert_equal(event_wo_tz["properties"]["end"][0],
-                 "2014-05-21 19:30")
+    assert event_wo_tz["properties"]["start"][0] == "2014-05-21 18:30"
+    assert event_wo_tz["properties"]["end"][0] == "2014-05-21 19:30"
 
     event_w_tz = result["items"][7]
-    assert_equal(event_w_tz["properties"]["start"][0],
-                 "2014-06-01 12:30-06:00")
-    assert_equal(event_w_tz["properties"]["end"][0],
-                 "2014-06-01 19:30-06:00")
-
+    assert event_w_tz["properties"]["start"][0] == "2014-06-01 12:30-0600"
+    assert event_w_tz["properties"]["end"][0] == "2014-06-01 19:30-0600"
 
 
 def test_embedded_parsing():
     result = parse_fixture("embedded.html")
-    assert_equal(
-        result["items"][0]["properties"]["content"][0]["html"],
-        '<p>Blah blah blah blah blah.</p>\n' +
-        '   <p>Blah.</p>\n   <p>Blah blah blah.</p>')
-    assert_equal(
-        result["items"][0]["properties"]["content"][0]["value"],
-        'Blah blah blah blah blah.\nBlah.\nBlah blah blah.')
+    assert (
+        result["items"][0]["properties"]["content"][0]["html"]
+        == "<p>Blah blah blah blah blah.</p>\n   <p>Blah.</p>\n   <p>Blah blah blah.</p>"
+    )
+    assert (
+        result["items"][0]["properties"]["content"][0]["value"]
+        == "Blah blah blah blah blah.\n\nBlah.\n\nBlah blah blah."
+    )
+
+
+def test_embedded_exposed_dom():
+    result = parse_fixture("embedded.html", expose_dom=True)
+    content = result["items"][0]["properties"]["content"][0]
+    assert "html" not in content
+    assert isinstance(content["dom"], bs4.element.Tag)
 
 
 def test_hoisting_nested_hcard():
     result = parse_fixture("nested_hcards.html")
     expected = [
-            {
-                'properties': {
-                    'author': [
-                        {
-                            'properties': {'name': ['KP1']},
-                            'type': ['h-card'],
-                            'value': 'KP1'
-                        }
-                    ],
-                    'in-reply-to': [
-                        {
-                            'properties': {'name': ['KP']},
-                            'type': ['h-cite'],
-                            'value': 'KP'
-                        }
-                    ],
-                },
-                'type': ['h-entry']
-            }
-        ]
-    assert_equal(expected, result['items'])
+        {
+            "properties": {
+                "author": [
+                    {
+                        "properties": {"name": ["KP1"]},
+                        "type": ["h-card"],
+                        "value": "KP1",
+                    }
+                ],
+                "in-reply-to": [
+                    {"properties": {"name": ["KP"]}, "type": ["h-cite"], "value": "KP"}
+                ],
+            },
+            "type": ["h-entry"],
+        }
+    ]
+    assert expected == result["items"]
 
 
 def test_html_tag_class():
     result = parse_fixture("hfeed_on_html_tag.html")
-    assert_equal(['h-feed'], result['items'][0]['type'])
+    assert ["h-feed"] == result["items"][0]["type"]
 
-    assert_equal(['entry1'], result['items'][0]['children'][0]
-                 ['properties']['name'])
-    assert_equal(['entry2'], result['items'][0]['children'][1]
-                 ['properties']['name'])
+    assert ["entry1"] == result["items"][0]["children"][0]["properties"]["name"]
+    assert ["entry2"] == result["items"][0]["children"][1]["properties"]["name"]
 
 
 def test_string_strip():
     result = parse_fixture("string_stripping.html")
-    assert_equal('Tom Morris', result["items"][0]["properties"]["name"][0])
+    assert "Tom Morris" == result["items"][0]["properties"]["name"][0]
 
 
 def test_template_parse():
     result = parse_fixture("template_tag.html")
-    assert_equal(0, len(result["items"]))
+    assert 0 == len(result["items"])
+
 
 def test_template_tag_inside_e_value():
     result = parse_fixture("template_tag_inside_e_value.html")
-    assert_equal("This is a Test with a <code>template</code> tag after this:",
-                 result['items'][0]['properties']['content'][0]['html'])
-    assert_equal("This is a Test with a template tag after this:",
-                 result['items'][0]['properties']['content'][0]['value'])
+    assert (
+        "This is a Test with a <code>template</code> tag after this:"
+        == result["items"][0]["properties"]["content"][0]["html"]
+    )
+    assert (
+        "This is a Test with a template tag after this:"
+        == result["items"][0]["properties"]["content"][0]["value"]
+    )
+
 
 def test_ordering_dedup():
-    ''' test that classes are dedeuped and alphabetically ordered '''
+    """test that classes are dedeuped and alphabetically ordered"""
 
     result = parse_fixture("ordering_dedup.html")
-    item = result['items'][0]
-    assert_equal(['h-entry', 'h-feed', 'h-product', 'h-x-test'], item['type'])
-    assert_equal(['example.com', 'example.com/2'], item['properties']['url'])
-    assert_equal(['name', 'URL name'], item['properties']['name'])
-    assert_equal(['author', 'bookmark', 'me'], result['rel-urls']['example.com/rel']['rels'])
-    assert_equal('de', result['rel-urls']['example.com/lang']['hreflang'])
+    item = result["items"][0]
+    assert ["h-entry", "h-feed", "h-product", "h-x-test"] == item["type"]
+    assert ["example.com", "example.com/2"] == item["properties"]["url"]
+    assert ["name", "URL name"] == item["properties"]["name"]
+    assert ["author", "bookmark", "me"] == result["rel-urls"]["example.com/rel"]["rels"]
+    assert "de" == result["rel-urls"]["example.com/lang"]["hreflang"]
+
 
 def test_class_names_format():
-    ''' test that only classes with letters and possibly numbers in the vendor prefix part are used '''
+    """test that only classes with letters and possibly numbers in the vendor prefix part are used"""
 
     result = parse_fixture("class_names_format.html")
-    item = result['items'][0]
-    assert_equal(['h-feed', 'h-p3k-entry', 'h-x-test'], item['type'])
-    assert 'url' in item['properties']
-    assert 'p3k-url' in item['properties']
-    assert 'Url' not in item['properties']
-    assert '-url' not in item['properties']
-    assert 'url-' not in item['properties']
-
-    assert 'name' in item['properties']
-    assert 'p3k-name' in item['properties']
-    assert 'nAme' not in item['properties']
-    assert '-name' not in item['properties']
-    assert 'name-' not in item['properties']
+    item = result["items"][0]
+    assert ["h-feed", "h-p3k-entry", "h-x-test"] == item["type"]
+    assert "url" in item["properties"]
+    assert "p3k-url" in item["properties"]
+    assert "Url" not in item["properties"]
+    assert "-url" not in item["properties"]
+    assert "url-" not in item["properties"]
+
+    assert "name" in item["properties"]
+    assert "p3k-name" in item["properties"]
+    assert "nAme" not in item["properties"]
+    assert "-name" not in item["properties"]
+    assert "name-" not in item["properties"]
+
 
 def test_area_uparsing():
     result = parse_fixture("area.html")
-    assert_equal({
-        'url': ['http://suda.co.uk'], 'name': ['Brian Suda']}, result["items"][0]["properties"])
-    assert 'shape' in result["items"][0]
-    assert 'coords' in result["items"][0]
+    assert {"url": ["http://suda.co.uk"], "name": ["Brian Suda"]} == result["items"][0][
+        "properties"
+    ]
+    assert "shape" in result["items"][0]
+    assert "coords" in result["items"][0]
 
 
 def test_src_equiv():
     result = parse_fixture("test_src_equiv.html")
     for item in result["items"]:
-        assert 'x-example' in item['properties']
-        assert_equal('http://example.org/', item['properties']['x-example'][0])
+        assert "x-example" in item["properties"]
+        assert "http://example.org/" == item["properties"]["x-example"][0]
 
 
 def test_rels():
     result = parse_fixture("rel.html")
-    assert_equal({
-        u'in-reply-to': [u'http://example.com/1', u'http://example.com/2'],
-        u'author': [u'http://example.com/a', u'http://example.com/b'],
-        u'alternate': [u'http://example.com/fr'],
-        u'home': [u'http://example.com/fr'],
-    }, result['rels'])
-    assert_equal({
-        u'http://example.com/1': {'text': u"post 1", "rels": [u'in-reply-to']},
-        u'http://example.com/2': {'text': u"post 2", "rels": [u'in-reply-to']},
-        u'http://example.com/a': {'text': u"author a", "rels": [u'author']},
-        u'http://example.com/b': {'text': u"author b", "rels": [u'author']},
-        u'http://example.com/fr': {'text': u'French mobile homepage',
-                                   u'media': u'handheld',
-                                   u'rels': [u'alternate', u'home'],
-                                   u'hreflang': u'fr'}
-    }, result['rel-urls'])
+    assert {
+        "in-reply-to": ["http://example.com/1", "http://example.com/2"],
+        "author": ["http://example.com/a", "http://example.com/b"],
+        "alternate": ["http://example.com/fr"],
+        "home": ["http://example.com/fr"],
+    } == result["rels"]
+    assert {
+        "http://example.com/1": {"text": "post 1", "rels": ["in-reply-to"]},
+        "http://example.com/2": {"text": "post 2", "rels": ["in-reply-to"]},
+        "http://example.com/a": {"text": "author a", "rels": ["author"]},
+        "http://example.com/b": {"text": "author b", "rels": ["author"]},
+        "http://example.com/fr": {
+            "text": "French mobile homepage",
+            "media": "handheld",
+            "rels": ["alternate", "home"],
+            "hreflang": "fr",
+        },
+    } == result["rel-urls"]
 
 
 def test_alternates():
     result = parse_fixture("rel.html")
-    assert_equal([{
-        'url': 'http://example.com/fr', 'media': 'handheld',
-        'text': 'French mobile homepage',
-        'rel': 'home', 'hreflang': 'fr'
-    }], result['alternates'])
+    assert [
+        {
+            "url": "http://example.com/fr",
+            "media": "handheld",
+            "text": "French mobile homepage",
+            "rel": "home",
+            "hreflang": "fr",
+        }
+    ] == result["alternates"]
 
 
 def test_enclosures():
     result = parse_fixture("rel_enclosure.html")
-    assert_equal({'enclosure': ['http://example.com/movie.mp4']}, result['rels'])
-    assert_equal({'http://example.com/movie.mp4': {
-        'rels': ['enclosure'],
-        'text': 'my movie',
-        'type': 'video/mpeg'}
-    }, result['rel-urls'])
+    assert {"enclosure": ["http://example.com/movie.mp4"]} == result["rels"]
+    assert {
+        "http://example.com/movie.mp4": {
+            "rels": ["enclosure"],
+            "text": "my movie",
+            "type": "video/mpeg",
+        }
+    } == result["rel-urls"]
 
 
 def test_empty_href():
-    result = parse_fixture("hcard_with_empty_url.html", "http://foo.com")
+    result = parse_fixture("hcard_with_empty_url.html", url="http://foo.com")
 
-    for hcard in result['items']:
-        assert_equal(['http://foo.com'], hcard['properties']['url'])
+    for hcard in result["items"]:
+        assert ["http://foo.com"] == hcard["properties"]["url"]
 
 
 def test_link_with_u_url():
-    result = parse_fixture("link_with_u-url.html", "http://foo.com")
-    assert_equal({
+    result = parse_fixture("link_with_u-url.html", url="http://foo.com")
+    assert {
         "type": ["h-card"],
         "properties": {
             "name": [""],
             "url": ["http://foo.com/"],
         },
-    }, result["items"][0])
+    } == result["items"][0]
+
 
 def test_broken_url():
-    result = parse_fixture("broken_url.html", "http://example.com")
-    assert_equal(result["items"][0]["properties"]["relative"][0], "http://example.com/foo.html")
-    assert_equal(result["items"][0]["properties"]["url"][0], "http://www.[w3.org/")
-    assert_equal(result["items"][0]["properties"]["photo"][0], "http://www.w3].org/20[08/site/images/logo-w3c-mobile-lg")
+    result = parse_fixture("broken_url.html", url="http://example.com")
+    assert (
+        result["items"][0]["properties"]["relative"][0] == "http://example.com/foo.html"
+    )
+    assert result["items"][0]["properties"]["url"][0] == "http://www.[w3.org/"
+    assert (
+        result["items"][0]["properties"]["photo"][0]
+        == "http://www.w3].org/20[08/site/images/logo-w3c-mobile-lg"
+    )
+
 
 def test_complex_e_content():
     """When parsing h-* e-* properties, we should fold {"value":..., "html":...}
@@ -381,21 +381,29 @@ def test_complex_e_content():
     """
     result = parse_fixture("complex_e_content.html")
 
-    assert_equal({
+    assert {
         "type": ["h-entry"],
         "properties": {
-            "content": [{
-                "type": [
-                    "h-card"
-                ],
-                "properties": {
-                    "name": ["Hello"]
-                },
-                "html": "<p>Hello</p>",
-                "value": "Hello"
-            }],
-        }
-    }, result["items"][0])
+            "content": [
+                {
+                    "type": ["h-card"],
+                    "properties": {"name": ["Hello"]},
+                    "html": "<p>Hello</p>",
+                    "value": "Hello",
+                }
+            ],
+        },
+    } == result["items"][0]
+
+
+def test_relative_url_in_e():
+    """When parsing e-* properties, make relative URLs absolute."""
+    result = parse_fixture("relative_url_in_e.html")
+
+    assert (
+        '<p><a href="http://example.com/cat.html">Cat '
+        '<img src="http://example.com/cat.jpg"/></a></p>'
+    ) == result["items"][0]["properties"]["content"][0]["html"]
 
 
 def test_nested_values():
@@ -404,117 +412,141 @@ def test_nested_values():
     result = parse_fixture("nested_values.html")
     entry = result["items"][0]
 
-    assert_equal({
-        'properties': {
-            'name': ['Kyle'],
-            'url': ['http://about.me/kyle'],
+    assert {
+        "properties": {
+            "name": ["Kyle"],
+            "url": ["http://about.me/kyle"],
         },
-        'value': 'Kyle',
-        'type': ['h-card'],
-    }, entry["properties"]["author"][0])
-
-    assert_equal({
-        'properties': {
-            'name': ['foobar'],
-            'url': ['http://example.com/foobar'],
+        "value": "Kyle",
+        "type": ["h-card"],
+    } == entry["properties"]["author"][0]
+
+    assert {
+        "properties": {
+            "name": ["foobar"],
+            "url": ["http://example.com/foobar"],
         },
-        'value': 'http://example.com/foobar',
-        'type': ['h-cite'],
-    }, entry["properties"]["like-of"][0])
-
-    assert_equal({
-        'properties': {
-            'name': ['George'],
-            'url': ['http://people.com/george'],
+        "value": "http://example.com/foobar",
+        "type": ["h-cite"],
+    } == entry["properties"]["like-of"][0]
+
+    assert {
+        "properties": {
+            "name": ["George"],
+            "url": ["http://people.com/george"],
         },
-        'type': ['h-card'],
-    }, entry["children"][0])
+        "type": ["h-card"],
+    } == entry["children"][0]
 
 
 # implied properties tests
 
+
 def test_implied_name():
     result = parse_fixture("implied_properties/implied_properties.html")
 
     for i in range(7):
-        assert_equal(result["items"][i]["properties"]["name"][0], "Tom Morris")
+        assert result["items"][i]["properties"]["name"][0] == "Tom Morris"
 
 
 def test_implied_url():
-    result = parse_fixture("implied_properties/implied_properties.html", url="http://foo.com/")
-    assert_equal(
-        result["items"][1]["properties"]["url"][0], "http://tommorris.org/")
+    result = parse_fixture(
+        "implied_properties/implied_properties.html", url="http://foo.com/"
+    )
+    assert result["items"][1]["properties"]["url"][0] == "http://tommorris.org/"
     # img should not have a "url" property
-    assert_true("url" not in result["items"][4]["properties"])
+    assert "url" not in result["items"][4]["properties"]
     # href="" is relative to the base url
-    assert_equal(result["items"][5]["properties"]["url"][0], "http://foo.com/")
+    assert result["items"][5]["properties"]["url"][0] == "http://foo.com/"
 
-def test_implied_photo():
 
+def test_implied_photo():
     result = parse_fixture("implied_properties/implied_photo.html")
 
     for i in range(12):
         photos = result["items"][i]["properties"]["photo"]
-        assert_equal(len(photos), 1)
-        assert_equal(photos[0], "http://example.com/photo.jpg")
+        assert len(photos) == 1
+        assert photos[0] == "http://example.com/photo.jpg"
 
     # tests for no photo
     for i in range(12, 23):
-        assert_false("photo" in result["items"][i]["properties"])
+        assert "photo" not in result["items"][i]["properties"]
 
-def test_implied_url():
+    result = parse_fixture("implied_properties/implied_photo_relative_url.html")
+
+    assert (
+        result["items"][0]["properties"]["photo"][0]["value"]
+        == "http://example.com/jane-img.jpeg"
+    )
+    assert (
+        result["items"][1]["properties"]["photo"][0]
+        == "http://example.com/jane-object.jpeg"
+    )
 
+
+def test_implied_url():
     result = parse_fixture("implied_properties/implied_url.html")
 
     for i in range(12):
         urls = result["items"][i]["properties"]["url"]
-        assert_equal(len(urls), 1)
-        assert_equal(urls[0], "http://example.com")
+        assert len(urls) == 1
+        assert urls[0] == "http://example.com"
 
     # tests for no url
     for i in range(12, 23):
-        assert_false("url" in result["items"][i]["properties"])
+        assert "url" not in result["items"][i]["properties"]
+
 
 def test_stop_implied_url():
     """testing that explicit properties case implied url-parsing to be aborted"""
 
     result = parse_fixture("implied_properties/stop_implied_url.html")
 
-    assert_false("url" in result["items"][0]["properties"])
-    assert_false("url" in result["items"][1]["properties"])
-    assert_false("url" in result["items"][2]["properties"])
-    assert_false("url" in result["items"][3]["properties"])
-    assert_false("url" in result["items"][4]["properties"])
-    assert_false("url" in result["items"][5]["properties"])
+    assert "url" not in result["items"][0]["properties"]
+    assert "url" not in result["items"][1]["properties"]
+    assert "url" not in result["items"][2]["properties"]
+    assert "url" not in result["items"][3]["properties"]
+    assert "url" not in result["items"][4]["properties"]
+    assert "url" not in result["items"][5]["properties"]
+
+    assert result["items"][6]["properties"]["url"] == ["http://example.com/"]
+    assert result["items"][7]["properties"]["url"] == ["http://example.com/"]
+    assert result["items"][8]["properties"]["url"] == ["http://example.com/"]
+    assert result["items"][9]["properties"]["url"] == ["http://example.com/"]
 
-    assert_equal(result["items"][6]["properties"]["url"], ["http://example.com/"])
-    assert_equal(result["items"][7]["properties"]["url"], ["http://example.com/"])
-    assert_equal(result["items"][8]["properties"]["url"], ["http://example.com/"])
-    assert_equal(result["items"][9]["properties"]["url"], ["http://example.com/"])
 
 def test_implied_nested_photo():
-    result = parse_fixture("implied_properties/implied_properties.html", url="http://bar.org")
-    assert_equal(result["items"][2]["properties"]["photo"][0],
-                 "http://tommorris.org/photo.png")
-    assert_equal(result["items"][3]["properties"]["photo"][0],
-                 "http://tommorris.org/photo.png")
-    assert_equal(result["items"][4]["properties"]["photo"][0],
-                 "http://tommorris.org/photo.png")
+    result = parse_fixture(
+        "implied_properties/implied_properties.html", url="http://bar.org"
+    )
+    assert result["items"][2]["properties"]["photo"][0] == {
+        "alt": "",
+        "value": "http://tommorris.org/photo.png",
+    }
+    assert (
+        result["items"][3]["properties"]["photo"][0] == "http://tommorris.org/photo.png"
+    )
+    assert result["items"][4]["properties"]["photo"][0] == {
+        "alt": "Tom Morris",
+        "value": "http://tommorris.org/photo.png",
+    }
     # src="" is relative to the base url
-    assert_equal(result["items"][6]["properties"]["photo"][0],
-                 "http://bar.org")
+    assert result["items"][6]["properties"]["photo"][0] == "http://bar.org"
 
 
 def test_implied_nested_photo_alt_name():
     result = parse_fixture("implied_properties/implied_properties.html")
-    assert_equal(result["items"][3]["properties"]["name"][0], "Tom Morris")
+    assert result["items"][3]["properties"]["name"][0] == "Tom Morris"
 
 
 def test_implied_image():
     result = parse_fixture("implied_properties/implied_properties.html")
-    assert_equal(result["items"][4]["properties"]["photo"][0],
-                 "http://tommorris.org/photo.png")
-    assert_equal(result["items"][4]["properties"]["name"][0], "Tom Morris")
+    assert result["items"][4]["properties"]["photo"][0] == {
+        "alt": "Tom Morris",
+        "value": "http://tommorris.org/photo.png",
+    }
+    assert result["items"][4]["properties"]["name"][0] == "Tom Morris"
+
 
 def test_implied_name_empty_alt():
     """An empty alt text should not prevent us from including other
@@ -522,360 +554,530 @@ def test_implied_name_empty_alt():
     """
 
     result = parse_fixture("implied_properties/implied_name_empty_alt.html")
-    hcard = result['items'][0]
-
-    assert_equal({
-        'type': ['h-card'],
-        'properties': {
-            'name': ['@kylewmahan'],
-            'url': ['https://twitter.com/kylewmahan'],
-            'photo': ['https://example.org/test.jpg'],
+    hcard = result["items"][0]
+
+    assert {
+        "type": ["h-card"],
+        "properties": {
+            "name": ["@kylewmahan"],
+            "url": ["https://twitter.com/kylewmahan"],
+            "photo": [{"alt": "", "value": "https://example.org/test.jpg"}],
         },
-    }, hcard)
+    } == hcard
+
 
 def test_relative_datetime():
     result = parse_fixture("implied_properties/implied_relative_datetimes.html")
-    assert_equal(result[u'items'][0][u'properties'][u'updated'][0],
-                 '2015-01-02 05:06')
+    assert result["items"][0]["properties"]["updated"][0] == "2015-01-02 05:06"
+
 
 def test_stop_implied_name_nested_h():
     result = parse_fixture("implied_properties/stop_implied_name_nested_h.html")
-    assert_true('name' not in
-                 result[u'items'][0][u'properties'])
+    assert "name" not in result["items"][0]["properties"]
+
 
 def test_stop_implied_name_e_content():
     result = parse_fixture("implied_properties/stop_implied_name_e_content.html")
-    assert_true('name' not in
-                 result[u'items'][0][u'properties'])
+    assert "name" not in result["items"][0]["properties"]
+
 
 def test_stop_implied_name_p_content():
     result = parse_fixture("implied_properties/stop_implied_name_p_content.html")
-    assert_true('name' not in
-                 result[u'items'][0][u'properties'])
+    assert "name" not in result["items"][0]["properties"]
+
 
 def test_implied_properties_silo_pub():
-    result = parse_fixture('implied_properties/implied_properties_silo_pub.html')
-    item = result['items'][0]
+    result = parse_fixture("implied_properties/implied_properties_silo_pub.html")
+    item = result["items"][0]
 
-    #implied_name = item['properties']['name'][0]
-    #implied_name = re.sub('\s+', ' ', implied_name).strip()
-    #assert_equal('@kylewmahan on Twitter', implied_name)
+    # implied_name = item['properties']['name'][0]
+    # implied_name = re.sub('\s+', ' ', implied_name).strip()
+    # assert '@kylewmahan on Twitter', implied_name)
 
     # no implied name expected under new rules
 
-    assert_true('name' not in
-                 item[u'properties'])
+    assert "name" not in item["properties"]
+
 
 def test_simple_person_reference_implied():
     result = parse_fixture("implied_properties/simple_person_reference_implied.html")
-    assert_equal(result["items"][0]["properties"],
-                 {'name': ['Frances Berriman']})
+    assert result["items"][0]["properties"] == {"name": ["Frances Berriman"]}
 
 
 def test_implied_name_alt():
     result = parse_fixture("implied_properties/implied_name_alt.html")
-    assert_equal(result["items"][0]["children"][0],
-                 {'type': ['h-card'],
-                  'properties': {'name': ['Avatar of Stephen'],
-                                 'photo': ['avatar.jpg']}})
+    assert result["items"][0]["children"][0] == {
+        "type": ["h-card"],
+        "properties": {
+            "name": ["Avatar of Stephen"],
+            "photo": [{"alt": "Avatar of", "value": "avatar.jpg"}],
+        },
+    }
 
 
 def test_value_name_whitespace():
     result = parse_fixture("value_name_whitespace.html")
 
     for i in range(3):
-        assert_equal(result["items"][i]["properties"]["content"][0]["value"], "Hello World")
-        assert_equal(result["items"][i]["properties"]["name"][0], "Hello World")
+        assert result["items"][i]["properties"]["content"][0]["value"] == "Hello World"
+        assert result["items"][i]["properties"]["name"][0] == "Hello World"
+
+    for i in range(3, 7):
+        assert result["items"][i]["properties"]["content"][0]["value"] == "Hello\nWorld"
+        assert result["items"][i]["properties"]["name"][0] == "Hello\nWorld"
+
+    assert result["items"][7]["properties"]["content"][0]["value"] == "Hello\n\nWorld"
+    assert result["items"][7]["properties"]["name"][0] == "Hello\n\nWorld"
+
+    assert result["items"][8]["properties"]["content"][0]["value"] == "One\nTwo\nThree"
+    assert result["items"][8]["properties"]["name"][0] == "One\nTwo\nThree"
 
-    for i in range(3, 8):
-        assert_equal(result["items"][i]["properties"]["content"][0]["value"], "Hello\nWorld")
-        assert_equal(result["items"][i]["properties"]["name"][0], "Hello\nWorld")
+    assert (
+        result["items"][9]["properties"]["content"][0]["value"] == "One\n\nTwo\n\nThree"
+    )
+    assert result["items"][9]["properties"]["name"][0] == "One\n\nTwo\n\nThree"
 
-    for i in range(8, 10):
-        assert_equal(result["items"][i]["properties"]["content"][0]["value"], "One\nTwo\nThree")
-        assert_equal(result["items"][i]["properties"]["name"][0], "One\nTwo\nThree")
+    assert (
+        result["items"][10]["properties"]["content"][0]["value"]
+        == "Hello World      one\n      two\n      three\n    "
+    )
+    assert (
+        result["items"][10]["properties"]["name"][0]
+        == "Hello World      one\n      two\n      three\n    "
+    )
 
-    assert_equal(result["items"][10]["properties"]["content"][0]["value"], "Hello World      one\n      two\n      three\n    ")
-    assert_equal(result["items"][10]["properties"]["name"][0], "Hello World      one\n      two\n      three\n    ")
+    assert (
+        result["items"][11]["properties"]["content"][0]["value"]
+        == "Correct name Correct summary"
+    )
+    assert result["items"][11]["properties"]["name"][0] == "Correct name"
 
-    assert_equal(result["items"][11]["properties"]["content"][0]["value"], "Correct name Correct summary")
-    assert_equal(result["items"][11]["properties"]["name"][0], "Correct name")
 
 # backcompat tests
 
+
 def test_backcompat_hentry():
     result = parse_fixture("backcompat/hentry.html")
-    assert_true('h-entry' in result['items'][0]['type'])
-    assert_equal('Tom Morris',
-                 result['items'][0]['properties']
-                 ['author'][0]['properties']['name'][0])
-    assert_equal('A Title',
-                 result['items'][0]['properties']['name'][0])
-    assert_equal('Some Content',
-                 result['items'][0]['properties']['content'][0]['value'])
+    assert "h-entry" in result["items"][0]["type"]
+    assert (
+        "Tom Morris"
+        == result["items"][0]["properties"]["author"][0]["properties"]["name"][0]
+    )
+    assert "A Title" == result["items"][0]["properties"]["name"][0]
+    assert "Some Content" == result["items"][0]["properties"]["content"][0]["value"]
+
 
 def test_backcompat_hproduct():
     result = parse_fixture("backcompat/hproduct.html")
-    assert_equal(1, len(result["items"]))
-    assert_equal(["h-product"], result["items"][0]["type"])
-    assert_equal(['bullshit'], result["items"][0]["properties"]["category"])
-    assert_equal(['Quacktastic Products'], result["items"][0]["properties"]["brand"])
-    assert_equal(['#BULLSHIT-001'], result["items"][0]["properties"]["identifier"])
-    assert_equal("Magical tasty sugar pills that don't do anything.", result["items"][0]["properties"]['description'][0]) 
-    assert_equal(["Tom's Magical Quack Tincture"], result["items"][0]["properties"]["name"])
+    assert 1 == len(result["items"])
+    assert ["h-product"] == result["items"][0]["type"]
+    assert ["bullshit"] == result["items"][0]["properties"]["category"]
+    assert ["Quacktastic Products"] == result["items"][0]["properties"]["brand"]
+    assert ["#BULLSHIT-001"] == result["items"][0]["properties"]["identifier"]
+    assert (
+        "Magical tasty sugar pills that don't do anything."
+        == result["items"][0]["properties"]["description"][0]
+    )
+    assert ["Tom's Magical Quack Tincture"] == result["items"][0]["properties"]["name"]
 
 
 def test_backcompat_hproduct_nested_hreview():
     result = parse_fixture("backcompat/hproduct_hreview_nested.html")
-    assert_equal(['h-review'], result["items"][0]["children"][0]['type'])
+    assert ["h-review"] == result["items"][0]["children"][0]["type"]
+
 
 def test_backcompat_hreview_nested_card_event_product():
     result = parse_fixture("backcompat/hreview_nested_card_event_product.html")
-    assert_equal(['h-review'], result["items"][0]['type'])
-    items = result["items"][0]["properties"]['item']
-    assert_equal(3, len(items))
+    assert ["h-review"] == result["items"][0]["type"]
+    items = result["items"][0]["properties"]["item"]
+    assert 3 == len(items)
 
     event = items[0]
-    assert_equal(['h-event'], event['type'])
-    assert_equal(['http://example.com/event-url'], event['properties']['url'])
-    assert_equal(['event name'], event['properties']['name'])
+    assert ["h-event"] == event["type"]
+    assert ["http://example.com/event-url"] == event["properties"]["url"]
+    assert ["event name"] == event["properties"]["name"]
 
     card = items[1]
-    assert_equal(['h-card'], card['type'])
-    assert_equal(['http://example.com/card-url'], card['properties']['url'])
-    assert_equal(['card name'], card['properties']['name'])
+    assert ["h-card"] == card["type"]
+    assert ["http://example.com/card-url"] == card["properties"]["url"]
+    assert ["card name"] == card["properties"]["name"]
 
     product = items[2]
-    assert_equal(['h-product'], product['type'])
-    assert_equal(['http://example.com/product-url'], product['properties']['url'])
-    assert_equal(['product name'], product['properties']['name'])
+    assert ["h-product"] == product["type"]
+    assert ["http://example.com/product-url"] == product["properties"]["url"]
+    assert ["product name"] == product["properties"]["name"]
 
 
 def test_backcompat_rel_bookmark():
     """Confirm that rel=bookmark inside of an h-entry is converted
     to u-url.
     """
-    result = parse_fixture('backcompat/feed_with_rel_bookmark.html')
-    for ii, url in enumerate((
-            '/2014/11/24/jump-rope',
-            '/2014/11/23/graffiti',
-            '/2014/11/21/earth',
-            '/2014/11/19/labor',
-    )):
-        assert_equal(['h-entry'], result['items'][ii]['type'])
-        assert_equal([url], result['items'][ii]['properties']['url'])
+    result = parse_fixture("backcompat/feed_with_rel_bookmark.html")
+    for ii, url in enumerate(
+        (
+            "/2014/11/24/jump-rope",
+            "/2014/11/23/graffiti",
+            "/2014/11/21/earth",
+            "/2014/11/19/labor",
+        )
+    ):
+        assert ["h-entry"] == result["items"][ii]["type"]
+        assert [url] == result["items"][ii]["properties"]["url"]
+
 
 def test_backcompat_rel_bookmark():
     """Confirm that rel=bookmark inside of an hentry and hreview is converted
     to a u-url and original u-url is ignored
     """
 
-    tests = ['backcompat/hentry_with_rel_bookmark.html', 'backcompat/hreview_with_rel_tag_bookmark.html']
+    tests = [
+        "backcompat/hentry_with_rel_bookmark.html",
+        "backcompat/hreview_with_rel_tag_bookmark.html",
+    ]
 
     results = [parse_fixture(x) for x in tests]
 
     for result in results:
-        assert_equal(['https://example.com/bookmark', 'https://example.com/bookmark-url'], result['items'][0]['properties']['url'])
+        assert [
+            "https://example.com/bookmark",
+            "https://example.com/bookmark-url",
+        ] == result["items"][0]["properties"]["url"]
+
 
 def test_backcompat_rel_tag():
     """Confirm that rel=tag inside of an hentry is converted
     to a p-category and the last path segment of the href is used.
     """
 
-    tests = ['backcompat/hentry_with_rel_tag.html', 'backcompat/hfeed_with_rel_tag.html', 'backcompat/hrecipe_with_rel_tag.html', 'backcompat/hreview_with_rel_tag_bookmark.html']
+    tests = [
+        "backcompat/hentry_with_rel_tag.html",
+        "backcompat/hfeed_with_rel_tag.html",
+        "backcompat/hrecipe_with_rel_tag.html",
+        "backcompat/hreview_with_rel_tag_bookmark.html",
+    ]
 
     results = [parse_fixture(x) for x in tests]
     for result in results:
-        assert_equal(['cat', 'dog', 'mountain lion', 'mouse', 'meerkat'], result['items'][0]['properties']['category'])
+        assert ["cat", "dog", "mountain lion", "mouse", "meerkat"] == result["items"][
+            0
+        ]["properties"]["category"]
+
 
 def test_backcompat_rel_tag_entry_title():
-    """Confirm that other backcompat properties on a rel=tag are parsed
-    """
+    """Confirm that other backcompat properties on a rel=tag are parsed"""
+
+    result = parse_fixture("backcompat/hentry_with_rel_tag_entry_title.html")
+    assert ["cat"] == result["items"][0]["properties"]["category"]
+    assert ["rhinoceros"] == result["items"][0]["properties"]["name"]
 
-    result = parse_fixture('backcompat/hentry_with_rel_tag_entry_title.html')
-    assert_equal(['cat'], result['items'][0]['properties']['category'])
-    assert_equal(['rhinoceros'], result['items'][0]['properties']['name'])
 
 def test_backcompat_rel_multiple_root():
     """Confirm that rel=tag and rel=bookmark inside of an hentry+hreview is parsed correctly"""
 
-    result = parse_fixture('backcompat/hreview_hentry_with_rel_tag_bookmark.html')
+    result = parse_fixture("backcompat/hreview_hentry_with_rel_tag_bookmark.html")
 
-    assert_equal(len(result['items']), 1)
-    assert_true('h-entry' in result['items'][0]['type'])
-    assert_true('h-review' in result['items'][0]['type'])
+    assert len(result["items"]) == 1
+    assert "h-entry" in result["items"][0]["type"]
+    assert "h-review" in result["items"][0]["type"]
+
+    assert ["cat", "dog", "mountain lion", "mouse", "meerkat"] == result["items"][0][
+        "properties"
+    ]["category"]
+    assert [
+        "https://example.com/bookmark",
+        "https://example.com/bookmark-url",
+    ] == result["items"][0]["properties"]["url"]
 
-    assert_equal(['cat', 'dog', 'mountain lion', 'mouse', 'meerkat'], result['items'][0]['properties']['category'])
-    assert_equal(['https://example.com/bookmark', 'https://example.com/bookmark-url'], result['items'][0]['properties']['url'])
 
 def test_backcompat_ignore_mf1_root_if_mf2_present():
-    """Confirm that mf1 root class is ignored if another mf2 root class is present.
-    """
-    result = parse_fixture('backcompat/ignore_mf1_root_if_mf2_present.html')
-    assert_true('h-entry' not in result['items'][0]['type'])
-    assert_true('h-event' in result['items'][0]['type'])
+    """Confirm that mf1 root class is ignored if another mf2 root class is present."""
+    result = parse_fixture("backcompat/ignore_mf1_root_if_mf2_present.html")
+    assert "h-entry" not in result["items"][0]["type"]
+    assert "h-event" in result["items"][0]["type"]
+
 
 def test_backcompat_no_implied_properties_mf1_root():
-    """Confirm that mf1 root class does not have implied properties
-    """
-    result = parse_fixture('backcompat/ignore_mf1_root_if_mf2_present.html')
-    assert_true('h-entry' not in result['items'][0]['properties'])
-    assert_true('name' not in result['items'][0]['type'])
-    assert_true('url' not in result['items'][0]['properties'])
-    assert_true('photo' not in result['items'][0]['properties'])
+    """Confirm that mf1 root class does not have implied properties"""
+    result = parse_fixture("backcompat/ignore_mf1_root_if_mf2_present.html")
+    assert "h-entry" not in result["items"][0]["properties"]
+    assert "name" not in result["items"][0]["type"]
+    assert "url" not in result["items"][0]["properties"]
+    assert "photo" not in result["items"][0]["properties"]
+
 
 def test_backcompat_ignore_mf2_properties_in_mf1_root():
-    """Confirm that mf2 properties are ignored in mf1 root class
-    """
-    result = parse_fixture('backcompat/ignore_mf2_properties_in_mf1_root.html')
-    assert_equal('Correct name', result['items'][0]['properties']['name'][0])
-    assert_equal('Correct summary', result['items'][0]['properties']['summary'][0])
+    """Confirm that mf2 properties are ignored in mf1 root class"""
+    result = parse_fixture("backcompat/ignore_mf2_properties_in_mf1_root.html")
+    assert "Correct name" == result["items"][0]["properties"]["name"][0]
+    assert "Correct summary" == result["items"][0]["properties"]["summary"][0]
+
 
 def test_backcompat_ignore_mf1_properties_in_mf2_root():
-    """Confirm that mf1 properties are ignored in mf2 root class
-    """
-    result = parse_fixture('backcompat/ignore_mf1_properties_in_mf2_root.html')
-    assert_equal('Correct name', result['items'][0]['properties']['name'][0])
-    assert_equal('Correct summary', result['items'][0]['properties']['summary'][0])
+    """Confirm that mf1 properties are ignored in mf2 root class"""
+    result = parse_fixture("backcompat/ignore_mf1_properties_in_mf2_root.html")
+    assert "Correct name" == result["items"][0]["properties"]["name"][0]
+    assert "Correct summary" == result["items"][0]["properties"]["summary"][0]
+
 
 def test_backcompat_nested_mf2_in_mf1():
-    """Confirm that mf2 roots nested inside mf1 root are parsed
-    """
-    result = parse_fixture('backcompat/nested_mf2_in_mf1.html')
-    assert_equal('h-feed', result['items'][0]['type'][0])
-    assert_equal('h-entry', result['items'][0]['children'][0]['type'][0])
-    assert_equal('Correct name', result['items'][0]['children'][0]['properties']['name'][0])
-    assert_equal('Correct summary', result['items'][0]['children'][0]['properties']['summary'][0])
+    """Confirm that mf2 roots nested inside mf1 root are parsed"""
+    result = parse_fixture("backcompat/nested_mf2_in_mf1.html")
+    assert "h-feed" == result["items"][0]["type"][0]
+    assert "h-entry" == result["items"][0]["children"][0]["type"][0]
+    assert "Correct name" == result["items"][0]["children"][0]["properties"]["name"][0]
+    assert (
+        "Correct summary"
+        == result["items"][0]["children"][0]["properties"]["summary"][0]
+    )
+
 
 def test_backcompat_nested_mf1_in_mf2():
-    """Confirm that mf1 roots nested inside mf2 root are parsed
-    """
-    result = parse_fixture('backcompat/nested_mf1_in_mf2.html')
-    assert_equal('h-feed', result['items'][0]['type'][0])
-    assert_equal('h-entry', result['items'][0]['children'][0]['type'][0])
-    assert_equal('Correct name', result['items'][0]['children'][0]['properties']['name'][0])
-    assert_equal('Correct summary', result['items'][0]['children'][0]['properties']['summary'][0])
+    """Confirm that mf1 roots nested inside mf2 root are parsed"""
+    result = parse_fixture("backcompat/nested_mf1_in_mf2.html")
+    assert "h-feed" == result["items"][0]["type"][0]
+    assert "h-entry" == result["items"][0]["children"][0]["type"][0]
+    assert "Correct name" == result["items"][0]["children"][0]["properties"]["name"][0]
+    assert (
+        "Correct summary"
+        == result["items"][0]["children"][0]["properties"]["summary"][0]
+    )
+
 
 def test_backcompat_nested_mf1_in_mf2_e_content():
-    """Confirm that mf1 roots nested inside mf2 root e-content are parsed as authored
-    """
-    result = parse_fixture('backcompat/nested_mf1_in_mf2_e_content.html')
+    """Confirm that mf1 roots nested inside mf2 root e-content are parsed as authored"""
+    result = parse_fixture("backcompat/nested_mf1_in_mf2_e_content.html")
 
-    mf2_entry = result['items'][0]
-    mf1_entry = mf2_entry['children'][0]
+    mf2_entry = result["items"][0]
+    mf1_entry = mf2_entry["children"][0]
 
-    assert_equal('<div class="hentry">\n<span class="entry-title">Correct name</span>\n\n<span class="entry-summary">Correct summary</span>\n</div>', mf2_entry['properties']['content'][0]['html'])
+    assert (
+        '<div class="hentry">\n<span class="entry-title">Correct name</span>\n\n<span class="entry-summary">Correct summary</span>\n</div>'
+        == mf2_entry["properties"]["content"][0]["html"]
+    )
 
-    assert_equal('Correct name Correct summary', mf2_entry['properties']['content'][0]['value'])
+    assert (
+        "Correct name Correct summary" == mf2_entry["properties"]["content"][0]["value"]
+    )
+
+    assert "h-entry" == mf1_entry["type"][0]
+    assert "Correct name" == mf1_entry["properties"]["name"][0]
+    assert "Correct summary" == mf1_entry["properties"]["summary"][0]
 
-    assert_equal('h-entry', mf1_entry['type'][0])
-    assert_equal('Correct name', mf1_entry['properties']['name'][0])
-    assert_equal('Correct summary', mf1_entry['properties']['summary'][0])
 
 def test_backcompat_hentry_content_html():
-    """Confirm that mf1 entry-content html is parsed as authored without mf2 replacements
-    """
-    result = parse_fixture('backcompat/hentry_content_html.html')
+    """Confirm that mf1 entry-content html is parsed as authored without mf2 replacements"""
+    result = parse_fixture("backcompat/hentry_content_html.html")
 
-    entry = result['items'][0]
+    entry = result["items"][0]
+
+    assert (
+        '<p class="entry-summary">This is a summary</p> \n        <p>This is <a href="/tags/mytag" rel="tag">mytag</a> inside content. </p>'
+        == entry["properties"]["content"][0]["html"]
+    )
 
-    assert_equal('<p class="entry-summary">This is a summary</p> \n        <p>This is <a href="/tags/mytag" rel="tag">mytag</a> inside content. </p>', entry['properties']['content'][0]['html'])
 
 def test_whitespace_with_tags_inside_property():
     """Whitespace should only be trimmed at the ends of textContent, not inside.
 
     https://github.com/microformats/mf2py/issues/112
     """
-    result = parse_fixture('tag_whitespace_inside_p_value.html')
-    assert_equal(result['items'][0]['properties'],
-                 {'name': ['foo bar']})
+    result = parse_fixture("tag_whitespace_inside_p_value.html")
+    assert result["items"][0]["properties"] == {"name": ["foo bar"]}
+
+
+def test_plaintext_p_whitespace():
+    result = parse_fixture("plaintext_p_whitespace.html")
+    assert result["items"][0]["properties"]["content"][0]["value"] == "foo\nbar baz"
+    assert result["items"][1]["properties"]["content"][0]["value"] == "foo\nbar baz"
+    assert result["items"][2]["properties"]["content"][0]["value"] == "foo bar\nbaz"
 
 
-# experimental features tests
+def test_plaintext_img_whitespace():
+    result = parse_fixture("plaintext_img_whitespace.html")
+    assert (
+        result["items"][0]["properties"]["content"][0]["value"]
+        == "selfie At some tourist spot"
+    )
+    assert (
+        result["items"][1]["properties"]["content"][0]["value"]
+        == "At another tourist spot"
+    )
+    assert (
+        result["items"][2]["properties"]["content"][0]["value"]
+        == "https://example.com/photo.jpg At yet another tourist spot"
+    )
+
 
 def test_photo_with_alt():
-    """Confirm that alt text in img is parsed with feature flag img_with_alt under as a u-* property and implied photo
-    """
+    """Confirm that alt text in img is parsed as a u-* property and implied photo"""
 
-    path = 'experimental/img_with_alt.html'
+    path = "img_with_alt.html"
 
-    # without flag
     result = parse_fixture(path)
 
-    # experimental img_with_alt=True
     with open(os.path.join(TEST_DIR, path)) as f:
-        exp_result = Parser(doc=f, html_parser='html5lib', img_with_alt=True).to_dict()
+        exp_result = Parser(doc=f, html_parser="html5lib").to_dict()
 
     # simple img with u-*
-    assert_equal('/photo.jpg', result['items'][0]['properties']['photo'][0])
-    assert_equal('/photo.jpg', exp_result['items'][0]['properties']['photo'][0])
+    assert "/photo.jpg" == result["items"][0]["properties"]["photo"][0]
+    assert "/photo.jpg" == exp_result["items"][0]["properties"]["photo"][0]
+
+    assert {"alt": "alt text", "value": "/photo.jpg"} == result["items"][1][
+        "properties"
+    ]["url"][0]
+    assert "/photo.jpg" == exp_result["items"][1]["properties"]["url"][0]["value"]
+    assert "alt text" == exp_result["items"][1]["properties"]["url"][0]["alt"]
+
+    assert {"alt": "", "value": "/photo.jpg"} == result["items"][2]["properties"][
+        "in-reply-to"
+    ][0]
+    assert (
+        "/photo.jpg" == exp_result["items"][2]["properties"]["in-reply-to"][0]["value"]
+    )
+    assert "" == exp_result["items"][2]["properties"]["in-reply-to"][0]["alt"]
 
-    assert_equal('/photo.jpg', result['items'][1]['properties']['url'][0])
-    assert_equal('/photo.jpg', exp_result['items'][1]['properties']['url'][0]['value'])
-    assert_equal('alt text', exp_result['items'][1]['properties']['url'][0]['alt'])
+    # img with u-* and h-* example
+    assert "h-cite" in result["items"][3]["properties"]["in-reply-to"][0]["type"]
+    assert (
+        "/photo.jpg"
+        == result["items"][3]["properties"]["in-reply-to"][0]["properties"]["photo"][0]
+    )
+    assert "/photo.jpg" == result["items"][3]["properties"]["in-reply-to"][0]["value"]
+    assert "alt" not in result["items"][3]["properties"]["in-reply-to"][0]
+
+    assert "h-cite" in exp_result["items"][3]["properties"]["in-reply-to"][0]["type"]
+    assert (
+        "/photo.jpg"
+        == exp_result["items"][3]["properties"]["in-reply-to"][0]["properties"][
+            "photo"
+        ][0]
+    )
+    assert (
+        "/photo.jpg" == exp_result["items"][3]["properties"]["in-reply-to"][0]["value"]
+    )
+    assert "alt" not in exp_result["items"][3]["properties"]["in-reply-to"][0]
+
+    assert "h-cite" in result["items"][4]["properties"]["in-reply-to"][0]["type"]
+    assert {"alt": "alt text", "value": "/photo.jpg"} == result["items"][4][
+        "properties"
+    ]["in-reply-to"][0]["properties"]["photo"][0]
+    assert "/photo.jpg" == result["items"][4]["properties"]["in-reply-to"][0]["value"]
+    assert "alt" in result["items"][4]["properties"]["in-reply-to"][0]
+
+    assert "h-cite" in exp_result["items"][4]["properties"]["in-reply-to"][0]["type"]
+    assert (
+        "/photo.jpg"
+        == exp_result["items"][4]["properties"]["in-reply-to"][0]["properties"][
+            "photo"
+        ][0]["value"]
+    )
+    assert (
+        "/photo.jpg" == exp_result["items"][4]["properties"]["in-reply-to"][0]["value"]
+    )
+    assert (
+        "alt text"
+        == exp_result["items"][4]["properties"]["in-reply-to"][0]["properties"][
+            "photo"
+        ][0]["alt"]
+    )
+    assert "alt text" == exp_result["items"][4]["properties"]["in-reply-to"][0]["alt"]
+
+    assert "h-cite" in result["items"][5]["properties"]["in-reply-to"][0]["type"]
+    assert {"alt": "", "value": "/photo.jpg"} == result["items"][5]["properties"][
+        "in-reply-to"
+    ][0]["properties"]["photo"][0]
+    assert "/photo.jpg" == result["items"][5]["properties"]["in-reply-to"][0]["value"]
+    assert "alt" in result["items"][5]["properties"]["in-reply-to"][0]
+
+    assert "h-cite" in exp_result["items"][5]["properties"]["in-reply-to"][0]["type"]
+    assert (
+        "/photo.jpg"
+        == exp_result["items"][5]["properties"]["in-reply-to"][0]["properties"][
+            "photo"
+        ][0]["value"]
+    )
+    assert (
+        "/photo.jpg" == exp_result["items"][5]["properties"]["in-reply-to"][0]["value"]
+    )
+    assert (
+        ""
+        == exp_result["items"][5]["properties"]["in-reply-to"][0]["properties"][
+            "photo"
+        ][0]["alt"]
+    )
+    assert "" == exp_result["items"][5]["properties"]["in-reply-to"][0]["alt"]
+
+
+def test_photo_with_srcset():
+    result = parse_fixture("img_with_srcset.html")
+
+    assert result["items"][0]["properties"]["photo"][0]["srcset"] == {
+        "480w": "elva-fairy-480w.jpg",
+        "800w": "elva-fairy-800w.jpg",
+    }
+    assert result["items"][1]["properties"]["photo"][0]["srcset"] == {
+        "1x": "elva-fairy-320w.jpg",
+        "1.5x": "elva-fairy-480w.jpg",
+        "2x": "elva-fairy-640w.jpg",
+    }
+    assert (
+        result["items"][1]["properties"]["photo"][0]["srcset"]["2x"]
+        != "elva-fairy-2w.jpg"
+    )
+    for i in range(2, 7):
+        assert result["items"][i]["properties"]["photo"][0]["srcset"] == {
+            "1x": "elva-fairy,320w.jpg",
+            "1.5x": "elva-fairy,480w.jpg",
+        }
+    assert result["items"][7]["properties"]["photo"][0]["srcset"] == {
+        "1x": "elva-fairy,320w.jpg",
+    }
+    assert result["items"][8]["properties"]["photo"][0]["srcset"] == {
+        "1x": "elva-fairy,320w.jpg",
+        "1.5x": "elva-fairy,480w.jpg",
+        "2x": "elva-fairy,640w.jpg",
+    }
 
-    assert_equal('/photo.jpg', result['items'][2]['properties']['in-reply-to'][0])
-    assert_equal('/photo.jpg', exp_result['items'][2]['properties']['in-reply-to'][0]['value'])
-    assert_equal('', exp_result['items'][2]['properties']['in-reply-to'][0]['alt'])
+    result = parse_fixture("img_with_srcset_with_base.html")
+
+    assert result["items"][0]["properties"]["photo"][0]["srcset"] == {
+        "480w": "https://example.com/elva-fairy-480w.jpg",
+        "800w": "https://example.com/elva-fairy-800w.jpg",
+    }
+
+
+def test_parse_id():
+    result = parse_fixture("parse_id.html")
+    assert "recentArticles" == result["items"][0]["id"]
+    assert "article" == result["items"][0]["children"][0]["id"]
+    assert "id" not in result["items"][0]["children"][1]
+    assert "theAuthor" == result["items"][0]["properties"]["author"][0]["id"]
 
-    # img with u-* and h-* example
-    assert_true('h-cite' in result['items'][3]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', result['items'][3]['properties']['in-reply-to'][0]['properties']['photo'][0])
-    assert_equal('/photo.jpg', result['items'][3]['properties']['in-reply-to'][0]['value'])
-    assert_false('alt' in result['items'][3]['properties']['in-reply-to'][0])
-
-    assert_true('h-cite' in exp_result['items'][3]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', exp_result['items'][3]['properties']['in-reply-to'][0]['properties']['photo'][0])
-    assert_equal('/photo.jpg', exp_result['items'][3]['properties']['in-reply-to'][0]['value'])
-    assert_false('alt' in exp_result['items'][3]['properties']['in-reply-to'][0])
-
-    assert_true('h-cite' in result['items'][4]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', result['items'][4]['properties']['in-reply-to'][0]['properties']['photo'][0])
-    assert_equal('/photo.jpg', result['items'][4]['properties']['in-reply-to'][0]['value'])
-    assert_false('alt' in result['items'][4]['properties']['in-reply-to'][0])
-
-    assert_true('h-cite' in exp_result['items'][4]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', exp_result['items'][4]['properties']['in-reply-to'][0]['properties']['photo'][0]['value'])
-    assert_equal('/photo.jpg', exp_result['items'][4]['properties']['in-reply-to'][0]['value'])
-    assert_equal('alt text', exp_result['items'][4]['properties']['in-reply-to'][0]['properties']['photo'][0]['alt'])
-    assert_equal('alt text', exp_result['items'][4]['properties']['in-reply-to'][0]['alt'])
-
-    assert_true('h-cite' in result['items'][5]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', result['items'][5]['properties']['in-reply-to'][0]['properties']['photo'][0])
-    assert_equal('/photo.jpg', result['items'][5]['properties']['in-reply-to'][0]['value'])
-    assert_false('alt' in result['items'][5]['properties']['in-reply-to'][0])
-
-    assert_true('h-cite' in exp_result['items'][5]['properties']['in-reply-to'][0]['type'])
-    assert_equal('/photo.jpg', exp_result['items'][5]['properties']['in-reply-to'][0]['properties']['photo'][0]['value'])
-    assert_equal('/photo.jpg', exp_result['items'][5]['properties']['in-reply-to'][0]['value'])
-    assert_equal('', exp_result['items'][5]['properties']['in-reply-to'][0]['properties']['photo'][0]['alt'])
-    assert_equal('', exp_result['items'][5]['properties']['in-reply-to'][0]['alt'])
 
 # unicode tests
 
-def get_all_files():
 
+def get_all_files():
     all_files = []
 
     for dir_, _, files in os.walk(TEST_DIR):
         for filename in files:
             rel_dir = os.path.relpath(dir_, TEST_DIR)
-            all_files.append( os.path.join(rel_dir, filename))
+            all_files.append(os.path.join(rel_dir, filename))
 
     return all_files
 
+
 def assert_unicode_everywhere(obj):
     if isinstance(obj, dict):
         for k, v in obj.items():
-            assert_false(isinstance(k, binary_type),
-                         'key=%r; type=%r' % (k, type(k)))
+            assert not isinstance(k, bytes), "key=%r; type=%r" % (k, type(k))
             assert_unicode_everywhere(v)
     elif isinstance(obj, list):
         for v in obj:
             assert_unicode_everywhere(v)
 
-    assert_false(isinstance(obj, binary_type),
-                 'value=%r; type=%r' % (obj, type(obj)))
+    assert not isinstance(obj, bytes), "value=%r; type=%r" % (obj, type(obj))
 
 
 def check_unicode(filename, jsonblob):
@@ -883,26 +1085,145 @@ def check_unicode(filename, jsonblob):
 
 
 def test_unicode_everywhere():
-    """ make sure everything is unicode """
+    """make sure everything is unicode"""
 
-    for h in get_all_files()  :
+    for h in get_all_files():
         result = parse_fixture(h)
-        yield check_unicode, h, result
+        check_unicode(h, result)
 
 
 def test_input_tree_integrity():
-    """ make sure that if we parse a BS4 soup, our modifications do not leak into the document represented by it """
+    """make sure that if we parse a BS4 soup, our modifications do not leak into the document represented by it"""
 
     for path in get_all_files():
         with open(os.path.join(TEST_DIR, path)) as f:
-            soup = BeautifulSoup(f,features='lxml')
+            soup = BeautifulSoup(f, features="lxml")
             html1 = soup.prettify()
-            p = Parser(doc=soup, html_parser='lxml')
+            p = Parser(doc=soup, html_parser="lxml")
             html2 = soup.prettify()
-        yield make_labelled_cmp("tree_integrity_" + path), html1, html2
+        make_labelled_cmp("tree_integrity_" + path)(html1, html2)
 
 
 def make_labelled_cmp(label):
-    f = lambda html1, html2: assert_equal(html1,html2)
+    def f(html1, html2):
+        assert html1 == html2
+
     f.description = label
-    return f
\ No newline at end of file
+    return f
+
+
+def test_all_u_cases():
+    """test variations of u- parsing and that relative urls are always resolved"""
+
+    URL_COUNT = 28
+    result = parse_fixture("u_all_cases.html")
+
+    assert URL_COUNT == len(result["items"][0]["properties"]["url"])
+    for i in range(URL_COUNT):
+        make_labelled_cmp("all_u_cases_" + str(i))(
+            "http://example.com/test", result["items"][0]["properties"]["url"][i]
+        )
+
+
+def test_filtered_roots():
+    result = parse_fixture("filter_roots.html")
+    assert len(result["items"]) == 8
+
+    result = parse_fixture("filter_roots.html", filter_roots=True)
+    assert len(result["items"]) == 1
+
+    result = parse_fixture(
+        "filter_roots_custom.html", filter_roots={"foo", "bar", "bat", "baz"}
+    )
+    assert len(result["items"]) == 1
+
+
+def test_metaformats_flag_false():
+    result = parse_fixture("metaformats_ogp.html")
+    assert result["items"] == []
+
+
+def test_metaformats_title_only():
+    result = parse_fixture("base.html", metaformats=True)
+    assert result["items"] == [
+        {
+            "type": ["h-entry"],
+            "properties": {
+                "name": ["Hello World"],
+            },
+            "source": "metaformats",
+        }
+    ]
+
+
+def test_metaformats_ogp():
+    result = parse_fixture("metaformats_ogp.html", metaformats=True)
+    assert result["items"] == [
+        {
+            "type": ["h-entry"],
+            "properties": {
+                "name": ["Titull foo"],
+                "summary": ["Descrypshun bar"],
+                "photo": ["http://example.com/baz.jpg"],
+                "audio": ["http://example.com/biff.mp3"],
+                "video": ["http://example.com/boff.mov"],
+                "author": ["http://tantek.com/me"],
+                "published": ["2023-01-02T03:04Z"],
+                "updated": ["2023-01-02T05:06Z"],
+            },
+            "source": "metaformats",
+        }
+    ]
+
+
+def test_metaformats_twitter():
+    result = parse_fixture("metaformats_twitter.html", metaformats=True)
+    assert result["items"] == [
+        {
+            "type": ["h-entry"],
+            "properties": {
+                "name": ["Titull foo"],
+                "summary": ["Descrypshun bar"],
+                "photo": ["http://tantek.com/baz.jpg"],
+            },
+            "source": "metaformats",
+        }
+    ]
+
+
+def test_metaformats_html_meta():
+    result = parse_fixture("metaformats_html_meta.html", metaformats=True)
+    assert result["items"] == [
+        {
+            "type": ["h-entry"],
+            "properties": {
+                "name": ["Hello World"],
+                "summary": ["Descrypshun bar"],
+            },
+            "source": "metaformats",
+        }
+    ]
+
+
+def test_language():
+    result = parse_fixture("language.html")
+    assert result["items"][0]["lang"] == "it"
+    assert result["items"][1]["lang"] == "it"
+    assert result["items"][1]["properties"]["content"][0]["lang"] == "en"
+    assert result["items"][1]["properties"]["content"][1]["lang"] == "it"
+    assert result["items"][2]["lang"] == "sv"
+    assert result["items"][2]["properties"]["content"][0]["lang"] == "en"
+    assert result["items"][2]["properties"]["content"][1]["lang"] == "sv"
+
+
+def test_parser_object():
+    with open(os.path.join(TEST_DIR, "festivus.html")) as f:
+        p = Parser(doc=f)
+    assert len(p.to_dict(filter_by_type="h-card")) == 3
+    assert len(p.to_dict(filter_by_type="h-entry")) == 4
+    assert (
+        p.to_json(filter_by_type="h-card")
+        == '[{"type": ["h-card"], "properties": {"name": ["Jerry"]}}, {"type": '
+        '["h-card"], "properties": {"name": ["Frank"]}}, {"type": ["h-card"], '
+        '"properties": {"name": ["Cosmo"]}}]'
+    )
diff --git a/test/test_suite.py b/test/test_suite.py
index 1201625..4c4a89c 100644
--- a/test/test_suite.py
+++ b/test/test_suite.py
@@ -1,32 +1,28 @@
-from __future__ import unicode_literals, print_function
-from nose.tools import assert_equal
 import glob
 import json
-import mf2py
 import os.path
 import sys
-from test_parser import check_unicode
 
+from test_parser import check_unicode
 
-assert_equal.__self__.maxDiff = None
+import mf2py
 
 
 def test_mf2tests():
-    allfiles = glob.glob(
-        os.path.join('.', 'testsuite', 'tests', '*', '*', '*.json'))
+    allfiles = glob.glob(os.path.join(".", "testsuite", "tests", "*", "*", "*.json"))
     for jsonfile in allfiles:
-        htmlfile = jsonfile[:-4] + 'html'
+        htmlfile = jsonfile[:-4] + "html"
         with open(htmlfile) as f:
-            p = mf2py.parse(doc=f, url='http://example.com')
-            yield check_unicode, htmlfile, p
+            p = mf2py.parse(doc=f, url="http://example.com")
+            check_unicode(htmlfile, p)
         with open(jsonfile) as jsonf:
             try:
                 s = json.load(jsonf)
             except:
                 s = "bad file: " + jsonfile + sys.exc_info()[0]
-        yield check_mf2, htmlfile, p, s
+        check_mf2(htmlfile, p, s)
 
 
 def check_mf2(htmlfile, p, s):
     # TODO ignore extra keys in p that are not in s
-    assert_equal(p, s)
+    assert p == s