New Upstream Snapshot - python-strictyaml

Ready changes

Summary

Merged new upstream version: 1.6.2+git20221022.1.1b89a05 (was: 1.6.1).

Resulting package

Built on 2022-12-30T17:29 (took 5m5s)

The resulting binary packages can be installed (if you have the apt repository enabled) by running one of:

apt install -t fresh-snapshots python3-strictyaml

Lintian Result

Diff

diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 1323c52..0000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,505 +0,0 @@
-# Changelog
-
-
-### Latest
-
-* BUG: Don't check indentation consistency when allowing flow.
-
-
-### 1.6.0
-
-
-No relevant code changes.
-
-### 1.5.0
-
-* FEATURE: HexInt scalar validator. Parses hex integers case insensitively while preserving style for "round tripping". (#157)
-
-
-
-### 1.4.4
-
-
-No relevant code changes.
-
-### 1.4.3
-
-* FEATURE : Regression testing on python 2.7.14. This is probably the last release which will support Python 2.
-* FEATURE : Bundle last propertly working ruamel.yaml version in with strictyaml.
-
-
-### 1.4.2
-
-* BUGFIX : Ensure strictyaml continues to work -- updated temporary fix.
-
-
-### 1.4.1
-
-* BUGFIX : Ensure strictyaml continues to work.
-* FEATURE : NullNone - parse 'null' as None like YAML 1.2 does.
-
-
-### 1.3.2
-
-* BUGFIX : Fix for #135 hat tip @eulores.
-
-
-### 1.3.1
-
-* BUGFIX : Fix for faulty Url validator.
-
-
-### 1.3.0
-
-* BUGFIX : Fixes to ensure python 2.7.14 compatibility. This is probably the last time I will do this.
-* FEATURE : Use dict instead of OrderedDict for Python 3.7+
-* BUGFIX : Require Regex to be a full match
-* FEATURE: Support underscores in int and decimal
-
-
-### 1.2.0
-
-* FEATURE : #129 : Optional keys in mappings and set value to None - with thanks to @wwoods.
-
-
-### 1.1.1
-
-
-No relevant code changes.
-
-### 1.1.0
-
-* FEATURE: Add support for NaN and infinity representations (#122)
-
-
-
-### 1.0.7
-
-* BUGFIX: Fix for #116 - handle Enum or integers errors
-* BUGFIX : Fix accidental python 2 breakage.
-* BUGFIX : Accidental misrecognition of boolean values as numbers - cause of #85.
-* BUGFIX : Fix for #86 - handle changing multiline strings.
-* BUGFIX: handle deprecated collections import in the parser (#82)
-
-* bugfix - handle deprecated collections import in the parser
-
-* import sys
-
-
-### 1.0.5
-
-* BUGFIX : Fixed python 2 bug introduced when fixing #72.
-* BUG: issue #72.  Now __setitem__ uses schema.
-
-Before this commit, schemas could be violated when assigning to
-Map/Sequence members.  Now, modifications to the data must fit the
-data's schema.
-
-Furthermore, if the node on which __setitem__ is called has a compound
-schema, the selected validator within the compound schema may change
-correctly.
-
-
-### 1.0.4
-
-* FEATURE : Include tests / stories in package.
-* BUG: issue #72.  Now __setitem__ uses schema.
-
-Before this commit, schemas could be violated when assigning to
-Map/Sequence members.  Now, modifications to the data must fit the
-data's schema.
-
-
-### 1.0.3
-
-* BUGFIX : Fix for #64 integer value on YAML object being interpreted as string.
-
-
-### 1.0.2
-
-* BUGFIX : #63 CommaSeparated should recognize a blank string as a valid empty list.
-* BUGFIX : #61 fix for exception when parsing MapPattern with a non-string (float) as a key - hat tip @dgg5503.
-* BUGFIX : Fix deprecation warning on Iterable from collections raised by #60 - hat tip @dthonon.
-* FEATURE : Raise exception if more than one sequence validators are combined.
-
-
-### 1.0.1
-
-* FEATURE : #51 - OrValidation with multiple Map validators does not work effectively - raise exception if user tries to use more than one.
-
-
-### 1.0.0
-
-
-No relevant code changes.
-
-### 0.15.4
-
-* BUGFIX : If revalidating a subschema with an Or validator and then changing the contents of the parsed data, a cryptic error was raised.
-
-
-### 0.15.3
-
-* BUGFIX : Fix for #46 - prevent Enum parsed values from becoming YAML objects.
-
-
-### 0.15.2
-
-* BUGFIX : Modifying YAML via __getitem__ where the YAML was validated using an OR operator failed - or validators didn't have a key_validator.
-
-
-### 0.15.1
-
-* BUGFIX : Make optional values parsed using Optional appear at the *end* of the ordered dict.
-* BUGFIX : Prevent YAML objects from appearing in .data.
-* BUGFIX : Fix for bug caused by revalidation with Optional default values.
-
-
-### 0.15.0
-
-* FEATURE : Raise exception when invalid default data is used is used in Optionals.
-* FEATURE : Do not output defaults from Optional() to YAML and ignore parsed defaults where the parsed data is equal to the default specified in Optional().
-* BUGFIX : Include README.md.
-
-
-### 0.14.0
-
-* BUGFIX : Made comma separated serializer serialize correctly.
-* BUGFIX : Fixed the way serialization of empty lists, dicts, None and datetimes is handled.
-* BUGFIX : Float - fixed transformation in to YAML.
-* BUGFIX : Proper serialization for floats.
-* BUGFIX : Proper serialization for regexes.
-* BUGFIX : Comma separated serialization.
-* BUGFIX : Enum - fixed transformation in to YAML.
-* BUGFIX : Stricter validation on the serialization of dicts.
-* BUGFIX : Stricter validation on the serialization of sequences.
-* BUGFIX : Streamlined and fixed the way that serialization of data to YAML is performed so that both complex changes to YAML documents can be made and complex YAML documents can be assembled from scratch.
-* BUGFIX : Stop dumping empty dicts / lists.
-* BUGFIX : Fixed content encoding on README.
-
-
-### 0.13.0
-
-* FEATURE : Allow flow style to be parsed with a dirty_load method.
-
-
-### 0.12.0
-
-* FEATURE : Implement mapping abstract base class as per #39.
-
-
-### 0.11.10
-
-* BUGFIX : #15 - fix for regression caused by the release of ruamel.yaml 0.15.48.
-* FEATURE : Handle building documents a bit more sensibly - build the document from strings, floats, dicts, lists, etc. only.
-
-
-### 0.11.8
-
-* FEATURE : Include LICENSE.txt in package - #34 - hat tip @mcs07.
-* BUGFIX : Fix for #32 hat tip @NoahTheDuke - render given sections on variations in documentation.
-
-
-### 0.11.7
-
-* FEATURE : Replaced read in README.rst with read in README.md in setup.py.
-
-
-### 0.11.6
-
-* FEATURE : Replaced link in setup.py to new website.
-
-
-### 0.11.5
-
-* MINOR BUGFIX : #31 hat tip @karantan - validator was being set incorrectly on YAML objects after parse.
-
-
-### 0.11.4
-
-* BUGFIX : Fix bug where changing items in the YAML after revalidation failed.
-
-
-### 0.11.3
-
-* PATCH BUGFIX : Ensure that revalidation keeps the validator.
-
-
-### 0.11.2
-
-* BUGFIX : When using YAML objects as keys on other YAML objects, it should just use the value.
-
-
-### 0.11.1
-
-* BUGFIX PATCH : Fix the behavior of getting and deleting items on a YAML object where the key have gone through a validator.
-* PATCH BUGFIX : Allow setting of properties using __setitem__ when a key validator was used.
-* PATCH REFACTOR : Sequence and Mapping validators now inherit from SeqValidator and MapValidator.
-* PATCH REFACTOR : Added some docstrings and removed unnecessary method.
-* PATCH REFACTOR : Added docstrings and clarified variable names.
-* PATCH REFACTOR : Moved YAMLPointer class into its own file.
-* PATCH REFACTOR : Refactored the processing code.
-* BUGFIX PATCH : Fix revalidation when using mappings that process keys.
-* MINOR : FEATURE : Throw exception on inconsistent indents.
-* PATCH : REFACTOR : Cleaned up stories.
-* PATCH : REFACTOR : Changes to enable documentation generation.
-* PATCH : REFACTOR : Upgraded hitchstory and strictyaml in hitch environment.
-
-
-### 0.10.0
-
-* MINOR : FEATURE : Optionally specify minimum_keys and maximum_keys in MapPattern.
-
-
-### 0.9.0
-
-* MINOR : FEATURE : Revalidation of code parsed with any (to make it work with scalar values).
-* PATCH : REFACTOR : Renamed defer validation -> revalidation.
-* MINOR : FEATURE : Revalidation of code parsed with Any.
-* PATCH : REFACTOR : Added more useful YAMLChunk methods.
-* PATCH : REFACTOR : Fixed type assertions.
-* PATCH : FEATURE : Added assert for or validators.
-* PATCH : FEATURE : Clearer error messages for non-matching scalars.
-* PATCH : REFACTOR : Made linter happy.
-* MINOR : FEATURE : Made clearer exception messages and prevented invalid validators from being used in compound validators.
-* PATCH : REFACTOR : Reworked the way YAML objects are created.
-* PATCH : REFACTOR : Reworked the way mapping, sequence, 'or' and scalar validators work.
-* PATCH : REFACTOR : Add doctests to the regression suite.
-* PATCH : REFACTOR : Clean up Map() class so it interacts only via chunk.process().
-* PATCH : REFACTOR : Cleaned up some stories.
-* PATCH : REFACTOR : Make linter happy.
-* PATCH : REFACTOR : Moved more validation functionality into the chunk object.
-* PATCH : REFACTOR : Clean up validator code.
-* PATCH : REFACTOR : Move more core code away from validators into YAMLChunk.
-
-
-### 0.8.0
-
-* MINOR : FEATURE : Enum with item validators.
-* MINOR : FEATURE : Mappings with key validators.
-* MINOR : FEATURE : Key validation using Map().
-* PATCH : PERFORMANCE IMPROVEMENTS : Avoided the use of deepcopy() every time a validator is used.
-* MINOR BUGFIX : Roundtripping failure fixes.
-* PATCH : REFACTOR : Only use chunk object in scalar validators.
-* PATCH : REFACTOR : Removed dependency on two variables being fed in to the validate_scalar method.
-
-
-### 0.7.3
-
-* PERFORMANCE : Improved performance of dumping by restricting the number of times deepcopy() is called.
-* FEATURE : Performance improvements.
-* FEATURE : Create dumpable YAML documents from simple dicts/lists of python data.
-* FEATURE : Create documents from scratch.
-* FEATURE : Create YAML documents directly.
-* FEATURE : Merging of YAML documents.
-* BUGFIX : Handle roundtripping changing indexed elements in sequences.
-* BUGFIX : Fix for scalar value roundtripping.
-* FEATURE : Set sequences using lists.
-* FEATURE : Use 'yes' and 'no' as default boolean values.
-* FEATURE : Set nested mappings that get correctly validated using __setitem__ interface on YAML() objects.
-* BUGFIX : Don't futz with the ordering of keys when setting vars via __setitem__.
-
-
-### 0.7.2
-
-* BUGFIX : Decimal point representer does not work with decimal.Decimal() object, so using float instead.
-* BUGFIX : In python 2.x, the __ne__ magic method is called on != rather than negating the result of the __eq__ method. This caused undesired behavior in python 2.x.
-* FEATURE : Parser errors will have the correct label attached.
-* FEATURE : .data now returns ordereddicts.
-* BUG : Boolean 'y' and 'n' values ought to resolve to True and False.
-* BUG : Map keys were accidentally optional by default.
-* BUG : Disallowed exceptions were previously not labeled.
-* BUG : Duplicate key exceptions were previously not labeled.
-* BUG : Fix for roundtripping multiline strings in python 2.
-* FEATURE : Label parsed YAML and have the label appear in exceptions.
-* BUG : Fix the way that data is roundtrip loaded into the yaml object via __setitem__.
-* BUG : Fixed roundtripping without using load()
-
-
-### 0.7.0
-
-* FEATURE : Modified the way that roundtripping works.
-
-
-### 0.6.2
-
-* FEATURE : Added version number accessible from __init__.py
-* BUG : Fixed the miscounting of list lines when getting start_line/end_line.
-
-
-### 0.6.0
-
-* BUG : Fixed import issues.
-* FEATURE : Added email and url validators.
-* FEATURE : Added Regex validator.
-
-
-### 0.5.9
-
-
-No relevant code changes.
-
-### 0.5.8
-
-* BUG : Fixed boolean error.
-
-
-### 0.5.7
-
-* BUG : Fixed MapPattern errors caused when editing items.
-
-
-### 0.5.6
-
-* FEATURE : Strict type checking when setting values.
-
-
-### 0.5.5
-
-* BUG : Fix roundtripping when using non-ascii characters.
-* BUG : Fixed unicode roundtripping error.
-
-
-### 0.5.4
-
-* BUG : Fix mishandling of special characters in mappings.
-* BUG : Handle invalid keys which are non-ascii characters gracefully
-* BUG : Fix for character encoding issues that occur when non-string scalars see invalid input.
-
-
-### 0.5.3
-
-* BUG : Third fix for character encoding issues (#18: hat tip @jpscaletti)
-* BUG : Second fix for character encoding issues (#18: hat tip Juan Pablo-Scaletti)
-* BUG : Fix for #18 (hat tip Juan Pablo-Scaletti)
-
-
-### 0.5.2
-
-* BUG : Fix for #17 (hat tip @kshpytsya)
-
-
-### 0.5.1
-
-* FEATURE : YAML object importable directly from module.
-
-
-### 0.5.0
-
-* BUG : Fixed some broken elements of roundtripping.
-* BUG : .data representations did not give keys as strings.
-* BUG : Fixed bool(x) overriding in python 2.
-* FEATURE : Greater than / less than implemented along with better post-representation assignment to mappings.
-* FEATURE : Better repr()
-* BUG : Keys are now represented as YAML() objects with full access to the location of the key in the YAML document.
-* FEATURE : Added is_[scalar|mapping|sequence] methods.
-* FEATURE : .values() on YAML object.
-* FEATURE : Added .value property to YAML object.
-* FEATURE : Implemented __contains__ so the 'in' method can be used.
-* FEATURE : Added .get(val) and .keys() so mapping YAML objects can be treated like dicts.
-* FEATURE : Added .items() to YAML object.
-* FEATURE : Handle srting casting for integers.
-* FEATURE : Raise TypeError when trying to cast a string to bool.
-* FEATURE : Raise TypeError when attempting to cast YAML(bool) to string.
-* FEATURE : Get lines for a specific YAML value, lines before it and lines after.
-* FEATURE : Print line numbers of YAML elements.
-* FEATURE : Any validator.
-* FEATURE : Fixed length sequence validation.
-* BUG : Fixed roundtripping.
-* FEATURE : Rountripped YAML with modifications.
-* BUG : Fixed ruamel.yaml version at a higher level.
-* FEATURE : Parse YAML into roundtrippable YAML object.
-
-
-### 0.4.2
-
-
-No relevant code changes.
-
-### 0.4.1
-
-* BUG : Fixed comma separated validator - now removes trailing spaces when parsing "a, b, c" so it does not parse as "a", " b", " c".
-
-
-### 0.4.0
-
-* FEATURE: Comma separated values.
-
-
-### 0.3.9
-
-* FEATURE : Added import for CommentedYAML type.
-
-
-### 0.3.8
-
-* FEATURE : Empty property validation.
-
-
-### 0.3.7
-
-* BUG : Fixed ruamel.yaml importing so that it works with earlier versions too.
-
-
-### 0.3.6
-
-* BUG : Fixed 13.1 ruamel.yaml issue.
-
-
-### 0.3.5
-
-* BUG : Stray print statement.
-
-
-### 0.3.3
-
-* BUG : Disallow flow style was failing with sequences.
-
-
-### 0.3.2
-
-
-No relevant code changes.
-
-### 0.3.1
-
-* BUG : Fixed mis-parsing caused by 'null' and non-strings in dictionary keys.
-
-
-### 0.3
-
-* FEATURE : Datetime parsing.
-* BUG : When loading a blank string using 'Any' it returned None by accident.
-
-
-### 0.2
-
-* FEATURE : YAMLValidationError now inherits from and uses the same mechanism as MarkedYAMLError.
-
-
-### 0.1.6
-
-
-No relevant code changes.
-
-### 0.1.5
-
-* FEATURE : Duplicate keys disallowed.
-
-
-### 0.1.4
-
-* FEATURE : Made the default to parse all scalars to string (Any validator) and added validator that returns CommentedSeq/CommentedMap.
-
-
-### 0.1.3
-
-* FEATURE : Clearer exception messages.
-* BUG : Fixed bug in sequence validator.
-
-
-### 0.1.2
-
-* BUG : Single value YAML documents now allowed.
-* BUG : Raise type error if it isn't a string passed through.
-
diff --git a/PKG-INFO b/PKG-INFO
new file mode 100644
index 0000000..43dd3c8
--- /dev/null
+++ b/PKG-INFO
@@ -0,0 +1,341 @@
+Metadata-Version: 2.1
+Name: strictyaml
+Version: 1.6.2
+Summary: Strict, typed YAML parser
+Home-page: http://hitchdev.com/strictyaml
+Author: Colm O'Connor
+Author-email: colm.oconnor.github@gmail.com
+License: MIT
+Keywords: yaml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# StrictYAML
+
+StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
+that parses and validates a [restricted subset](https://hitchdev.com/strictyaml/features-removed) of the [YAML](https://hitchdev.com/strictyaml/what-is-yaml)
+specification.
+
+Priorities:
+
+- Beautiful API
+- Refusing to parse [the ugly, hard to read and insecure features of YAML](https://hitchdev.com/strictyaml/features-removed) like [the Norway problem](https://hitchdev.com/strictyaml/why/implicit-typing-removed).
+- Strict validation of markup and straightforward type casting.
+- Clear, readable exceptions with **code snippets** and **line numbers**.
+- Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
+- Ability to read in YAML, make changes and write it out again with comments preserved.
+- [Not speed](https://hitchdev.com/strictyaml/why/speed-not-a-priority), currently.
+
+
+Simple example:
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 42
+possessions:
+- Towel
+
+```
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError
+
+```
+
+
+
+
+
+Default parse result:
+
+
+```python
+>>> load(yaml_snippet)
+YAML({'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']})
+```
+
+
+
+All data is string, list or OrderedDict:
+
+
+```python
+>>> load(yaml_snippet).data
+{'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']}
+```
+
+
+
+Quickstart with schema:
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError
+
+schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
+
+```
+
+
+
+
+
+42 is now parsed as an integer:
+
+
+```python
+>>> person = load(yaml_snippet, schema)
+>>> person.data
+{'name': 'Ford Prefect', 'age': 42, 'possessions': ['Towel']}
+```
+
+
+
+A YAMLError will be raised if there are syntactic problems, violations of your schema or use of disallowed YAML features:
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 42
+
+```
+
+
+
+
+
+
+For example, a schema violation:
+
+
+```python
+try:
+    person = load(yaml_snippet, schema)
+except YAMLError as error:
+    print(error)
+
+```
+
+```yaml
+while parsing a mapping
+  in "<unicode string>", line 1, column 1:
+    # All about the character
+     ^ (line: 1)
+required key(s) 'possessions' not found
+  in "<unicode string>", line 3, column 1:
+    age: '42'
+    ^ (line: 3)
+```
+
+
+
+
+
+If parsed correctly:
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError, as_document
+
+schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
+
+```
+
+
+
+
+
+You can modify values and write out the YAML with comments preserved:
+
+
+```python
+person = load(yaml_snippet, schema)
+person['age'] = 43
+print(person.as_yaml())
+
+```
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 43
+possessions:
+- Towel
+```
+
+
+
+
+
+As well as look up line numbers:
+
+
+```python
+>>> person = load(yaml_snippet, schema)
+>>> person['possessions'][0].start_line
+5
+```
+
+
+
+And construct YAML documents from dicts or lists:
+
+
+```python
+print(as_document({"x": 1}).as_yaml())
+
+```
+
+```yaml
+x: 1
+```
+
+
+
+
+
+
+
+## Install
+
+```sh
+$ pip install strictyaml
+```
+
+
+## Why StrictYAML?
+
+There are a number of formats and approaches that can achieve more or
+less the same purpose as StrictYAML. I've tried to make it the best one.
+Below is a series of documented justifications:
+
+- [Why avoid using environment variables as configuration?](https://hitchdev.com/strictyaml/why-not/environment-variables-as-config)
+- [Why not use HJSON?](https://hitchdev.com/strictyaml/why-not/hjson)
+- [Why not HOCON?](https://hitchdev.com/strictyaml/why-not/hocon)
+- [Why not use INI files?](https://hitchdev.com/strictyaml/why-not/ini)
+- [Why not use JSON Schema for validation?](https://hitchdev.com/strictyaml/why-not/json-schema)
+- [Why not JSON for simple configuration files?](https://hitchdev.com/strictyaml/why-not/json)
+- [Why not JSON5?](https://hitchdev.com/strictyaml/why-not/json5)
+- [Why not use the YAML 1.2 standard? - we don't need a new standard!](https://hitchdev.com/strictyaml/why-not/ordinary-yaml)
+- [Why not use kwalify with standard YAML to validate my YAML?](https://hitchdev.com/strictyaml/why-not/pykwalify)
+- [Why not use Python's schema library (or similar) for validation?](https://hitchdev.com/strictyaml/why-not/python-schema)
+- [Why not use SDLang?](https://hitchdev.com/strictyaml/why-not/sdlang)
+- [What is wrong with TOML?](https://hitchdev.com/strictyaml/why-not/toml)
+- [Why shouldn't I just use Python code for configuration?](https://hitchdev.com/strictyaml/why-not/turing-complete-code)
+- [Why not use XML for configuration or DSLs?](https://hitchdev.com/strictyaml/why-not/xml)
+
+
+
+## Using StrictYAML
+
+How to:
+
+- [Build a YAML document from scratch in code](https://hitchdev.com/strictyaml/using/alpha/howto/build-yaml-document)
+- [Either/or schema validation of different, equally valid different kinds of YAML](https://hitchdev.com/strictyaml/using/alpha/howto/either-or-validation)
+- [Labeling exceptions](https://hitchdev.com/strictyaml/using/alpha/howto/label-exceptions)
+- [Merge YAML documents](https://hitchdev.com/strictyaml/using/alpha/howto/merge-yaml-documents)
+- [Revalidate an already validated document](https://hitchdev.com/strictyaml/using/alpha/howto/revalidation)
+- [Reading in YAML, editing it and writing it back out](https://hitchdev.com/strictyaml/using/alpha/howto/roundtripping)
+- [Get line numbers of YAML elements](https://hitchdev.com/strictyaml/using/alpha/howto/what-line)
+- [Parsing YAML without a schema](https://hitchdev.com/strictyaml/using/alpha/howto/without-a-schema)
+
+
+Compound validators:
+
+- [Fixed length sequences (FixedSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/fixed-length-sequences)
+- [Mappings combining defined and undefined keys (MapCombined)](https://hitchdev.com/strictyaml/using/alpha/compound/map-combined)
+- [Mappings with arbitrary key names (MapPattern)](https://hitchdev.com/strictyaml/using/alpha/compound/map-pattern)
+- [Mapping with defined keys and a custom key validator (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-with-slug-keys)
+- [Using a YAML object of a parsed mapping](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-yaml-object)
+- [Mappings with defined keys (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping)
+- [Optional keys with defaults (Map/Optional)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys-with-defaults)
+- [Validating optional keys in mappings (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys)
+- [Sequences of unique items (UniqueSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences-of-unique-items)
+- [Sequence/list validator (Seq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences)
+- [Updating document with a schema](https://hitchdev.com/strictyaml/using/alpha/compound/update)
+
+
+Scalar validators:
+
+- [Boolean (Bool)](https://hitchdev.com/strictyaml/using/alpha/scalar/boolean)
+- [Parsing comma separated items (CommaSeparated)](https://hitchdev.com/strictyaml/using/alpha/scalar/comma-separated)
+- [Datetimes (Datetime)](https://hitchdev.com/strictyaml/using/alpha/scalar/datetime)
+- [Decimal numbers (Decimal)](https://hitchdev.com/strictyaml/using/alpha/scalar/decimal)
+- [Email and URL validators](https://hitchdev.com/strictyaml/using/alpha/scalar/email-and-url)
+- [Empty key validation](https://hitchdev.com/strictyaml/using/alpha/scalar/empty)
+- [Enumerated scalars (Enum)](https://hitchdev.com/strictyaml/using/alpha/scalar/enum)
+- [Floating point numbers (Float)](https://hitchdev.com/strictyaml/using/alpha/scalar/float)
+- [Hexadecimal Integers (HexInt)](https://hitchdev.com/strictyaml/using/alpha/scalar/hexadecimal-integer)
+- [Integers (Int)](https://hitchdev.com/strictyaml/using/alpha/scalar/integer)
+- [Validating strings with regexes (Regex)](https://hitchdev.com/strictyaml/using/alpha/scalar/regular-expressions)
+- [Parsing strings (Str)](https://hitchdev.com/strictyaml/using/alpha/scalar/string)
+
+
+Restrictions:
+
+- [Disallowed YAML](https://hitchdev.com/strictyaml/using/alpha/restrictions/disallowed-yaml)
+- [Duplicate keys](https://hitchdev.com/strictyaml/using/alpha/restrictions/duplicate-keys)
+- [Dirty load](https://hitchdev.com/strictyaml/using/alpha/restrictions/loading-dirty-yaml)
+
+
+
+## Design justifications
+
+There are some design decisions in StrictYAML which are controversial
+and/or not obvious. Those are documented here:
+
+- [What is wrong with duplicate keys?](https://hitchdev.com/strictyaml/why/duplicate-keys-disallowed)
+- [What is wrong with explicit tags?](https://hitchdev.com/strictyaml/why/explicit-tags-removed)
+- [What is wrong with flow-style YAML?](https://hitchdev.com/strictyaml/why/flow-style-removed)
+- [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](https://hitchdev.com/strictyaml/why/implicit-typing-removed)
+- [What is wrong with node anchors and references?](https://hitchdev.com/strictyaml/why/node-anchors-and-references-removed)
+- [Why does StrictYAML not parse direct representations of Python objects?](https://hitchdev.com/strictyaml/why/not-parse-direct-representations-of-python-objects)
+- [Why does StrictYAML only parse from strings and not files?](https://hitchdev.com/strictyaml/why/only-parse-strings-not-files)
+- [Why is parsing speed not a high priority for StrictYAML?](https://hitchdev.com/strictyaml/why/speed-not-a-priority)
+- [What is syntax typing?](https://hitchdev.com/strictyaml/why/syntax-typing-bad)
+- [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](https://hitchdev.com/strictyaml/why/turing-complete-schema)
+
+
+
+## Star Contributors
+
+- @wwoods
+- @chrisburr
+- @jnichols0
+
+## Other Contributors
+
+- @eulores
+- @WaltWoods
+- @ChristopherGS
+- @gvx
+- @AlexandreDecan
+- @lots0logs
+- @tobbez
+- @jaredsampson
+- @BoboTIG
+
+StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.
+
+## Contributing
+
+- Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
+- Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
+- All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.
diff --git a/VERSION b/VERSION
index 2eda823..fdd3be6 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.6.1
\ No newline at end of file
+1.6.2
diff --git a/debian/changelog b/debian/changelog
index eddbffc..4a6b0bb 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+python-strictyaml (1.6.2+git20221022.1.1b89a05-1) UNRELEASED; urgency=low
+
+  * New upstream snapshot.
+
+ -- Debian Janitor <janitor@jelmer.uk>  Fri, 30 Dec 2022 17:25:53 -0000
+
 python-strictyaml (1.6.1-2) unstable; urgency=medium
 
   * Introduce basic autopkgtest
diff --git a/docs/public/changelog.md b/docs/public/changelog.md
deleted file mode 100644
index 1323c52..0000000
--- a/docs/public/changelog.md
+++ /dev/null
@@ -1,505 +0,0 @@
-# Changelog
-
-
-### Latest
-
-* BUG: Don't check indentation consistency when allowing flow.
-
-
-### 1.6.0
-
-
-No relevant code changes.
-
-### 1.5.0
-
-* FEATURE: HexInt scalar validator. Parses hex integers case insensitively while preserving style for "round tripping". (#157)
-
-
-
-### 1.4.4
-
-
-No relevant code changes.
-
-### 1.4.3
-
-* FEATURE : Regression testing on python 2.7.14. This is probably the last release which will support Python 2.
-* FEATURE : Bundle last propertly working ruamel.yaml version in with strictyaml.
-
-
-### 1.4.2
-
-* BUGFIX : Ensure strictyaml continues to work -- updated temporary fix.
-
-
-### 1.4.1
-
-* BUGFIX : Ensure strictyaml continues to work.
-* FEATURE : NullNone - parse 'null' as None like YAML 1.2 does.
-
-
-### 1.3.2
-
-* BUGFIX : Fix for #135 hat tip @eulores.
-
-
-### 1.3.1
-
-* BUGFIX : Fix for faulty Url validator.
-
-
-### 1.3.0
-
-* BUGFIX : Fixes to ensure python 2.7.14 compatibility. This is probably the last time I will do this.
-* FEATURE : Use dict instead of OrderedDict for Python 3.7+
-* BUGFIX : Require Regex to be a full match
-* FEATURE: Support underscores in int and decimal
-
-
-### 1.2.0
-
-* FEATURE : #129 : Optional keys in mappings and set value to None - with thanks to @wwoods.
-
-
-### 1.1.1
-
-
-No relevant code changes.
-
-### 1.1.0
-
-* FEATURE: Add support for NaN and infinity representations (#122)
-
-
-
-### 1.0.7
-
-* BUGFIX: Fix for #116 - handle Enum or integers errors
-* BUGFIX : Fix accidental python 2 breakage.
-* BUGFIX : Accidental misrecognition of boolean values as numbers - cause of #85.
-* BUGFIX : Fix for #86 - handle changing multiline strings.
-* BUGFIX: handle deprecated collections import in the parser (#82)
-
-* bugfix - handle deprecated collections import in the parser
-
-* import sys
-
-
-### 1.0.5
-
-* BUGFIX : Fixed python 2 bug introduced when fixing #72.
-* BUG: issue #72.  Now __setitem__ uses schema.
-
-Before this commit, schemas could be violated when assigning to
-Map/Sequence members.  Now, modifications to the data must fit the
-data's schema.
-
-Furthermore, if the node on which __setitem__ is called has a compound
-schema, the selected validator within the compound schema may change
-correctly.
-
-
-### 1.0.4
-
-* FEATURE : Include tests / stories in package.
-* BUG: issue #72.  Now __setitem__ uses schema.
-
-Before this commit, schemas could be violated when assigning to
-Map/Sequence members.  Now, modifications to the data must fit the
-data's schema.
-
-
-### 1.0.3
-
-* BUGFIX : Fix for #64 integer value on YAML object being interpreted as string.
-
-
-### 1.0.2
-
-* BUGFIX : #63 CommaSeparated should recognize a blank string as a valid empty list.
-* BUGFIX : #61 fix for exception when parsing MapPattern with a non-string (float) as a key - hat tip @dgg5503.
-* BUGFIX : Fix deprecation warning on Iterable from collections raised by #60 - hat tip @dthonon.
-* FEATURE : Raise exception if more than one sequence validators are combined.
-
-
-### 1.0.1
-
-* FEATURE : #51 - OrValidation with multiple Map validators does not work effectively - raise exception if user tries to use more than one.
-
-
-### 1.0.0
-
-
-No relevant code changes.
-
-### 0.15.4
-
-* BUGFIX : If revalidating a subschema with an Or validator and then changing the contents of the parsed data, a cryptic error was raised.
-
-
-### 0.15.3
-
-* BUGFIX : Fix for #46 - prevent Enum parsed values from becoming YAML objects.
-
-
-### 0.15.2
-
-* BUGFIX : Modifying YAML via __getitem__ where the YAML was validated using an OR operator failed - or validators didn't have a key_validator.
-
-
-### 0.15.1
-
-* BUGFIX : Make optional values parsed using Optional appear at the *end* of the ordered dict.
-* BUGFIX : Prevent YAML objects from appearing in .data.
-* BUGFIX : Fix for bug caused by revalidation with Optional default values.
-
-
-### 0.15.0
-
-* FEATURE : Raise exception when invalid default data is used is used in Optionals.
-* FEATURE : Do not output defaults from Optional() to YAML and ignore parsed defaults where the parsed data is equal to the default specified in Optional().
-* BUGFIX : Include README.md.
-
-
-### 0.14.0
-
-* BUGFIX : Made comma separated serializer serialize correctly.
-* BUGFIX : Fixed the way serialization of empty lists, dicts, None and datetimes is handled.
-* BUGFIX : Float - fixed transformation in to YAML.
-* BUGFIX : Proper serialization for floats.
-* BUGFIX : Proper serialization for regexes.
-* BUGFIX : Comma separated serialization.
-* BUGFIX : Enum - fixed transformation in to YAML.
-* BUGFIX : Stricter validation on the serialization of dicts.
-* BUGFIX : Stricter validation on the serialization of sequences.
-* BUGFIX : Streamlined and fixed the way that serialization of data to YAML is performed so that both complex changes to YAML documents can be made and complex YAML documents can be assembled from scratch.
-* BUGFIX : Stop dumping empty dicts / lists.
-* BUGFIX : Fixed content encoding on README.
-
-
-### 0.13.0
-
-* FEATURE : Allow flow style to be parsed with a dirty_load method.
-
-
-### 0.12.0
-
-* FEATURE : Implement mapping abstract base class as per #39.
-
-
-### 0.11.10
-
-* BUGFIX : #15 - fix for regression caused by the release of ruamel.yaml 0.15.48.
-* FEATURE : Handle building documents a bit more sensibly - build the document from strings, floats, dicts, lists, etc. only.
-
-
-### 0.11.8
-
-* FEATURE : Include LICENSE.txt in package - #34 - hat tip @mcs07.
-* BUGFIX : Fix for #32 hat tip @NoahTheDuke - render given sections on variations in documentation.
-
-
-### 0.11.7
-
-* FEATURE : Replaced read in README.rst with read in README.md in setup.py.
-
-
-### 0.11.6
-
-* FEATURE : Replaced link in setup.py to new website.
-
-
-### 0.11.5
-
-* MINOR BUGFIX : #31 hat tip @karantan - validator was being set incorrectly on YAML objects after parse.
-
-
-### 0.11.4
-
-* BUGFIX : Fix bug where changing items in the YAML after revalidation failed.
-
-
-### 0.11.3
-
-* PATCH BUGFIX : Ensure that revalidation keeps the validator.
-
-
-### 0.11.2
-
-* BUGFIX : When using YAML objects as keys on other YAML objects, it should just use the value.
-
-
-### 0.11.1
-
-* BUGFIX PATCH : Fix the behavior of getting and deleting items on a YAML object where the key have gone through a validator.
-* PATCH BUGFIX : Allow setting of properties using __setitem__ when a key validator was used.
-* PATCH REFACTOR : Sequence and Mapping validators now inherit from SeqValidator and MapValidator.
-* PATCH REFACTOR : Added some docstrings and removed unnecessary method.
-* PATCH REFACTOR : Added docstrings and clarified variable names.
-* PATCH REFACTOR : Moved YAMLPointer class into its own file.
-* PATCH REFACTOR : Refactored the processing code.
-* BUGFIX PATCH : Fix revalidation when using mappings that process keys.
-* MINOR : FEATURE : Throw exception on inconsistent indents.
-* PATCH : REFACTOR : Cleaned up stories.
-* PATCH : REFACTOR : Changes to enable documentation generation.
-* PATCH : REFACTOR : Upgraded hitchstory and strictyaml in hitch environment.
-
-
-### 0.10.0
-
-* MINOR : FEATURE : Optionally specify minimum_keys and maximum_keys in MapPattern.
-
-
-### 0.9.0
-
-* MINOR : FEATURE : Revalidation of code parsed with any (to make it work with scalar values).
-* PATCH : REFACTOR : Renamed defer validation -> revalidation.
-* MINOR : FEATURE : Revalidation of code parsed with Any.
-* PATCH : REFACTOR : Added more useful YAMLChunk methods.
-* PATCH : REFACTOR : Fixed type assertions.
-* PATCH : FEATURE : Added assert for or validators.
-* PATCH : FEATURE : Clearer error messages for non-matching scalars.
-* PATCH : REFACTOR : Made linter happy.
-* MINOR : FEATURE : Made clearer exception messages and prevented invalid validators from being used in compound validators.
-* PATCH : REFACTOR : Reworked the way YAML objects are created.
-* PATCH : REFACTOR : Reworked the way mapping, sequence, 'or' and scalar validators work.
-* PATCH : REFACTOR : Add doctests to the regression suite.
-* PATCH : REFACTOR : Clean up Map() class so it interacts only via chunk.process().
-* PATCH : REFACTOR : Cleaned up some stories.
-* PATCH : REFACTOR : Make linter happy.
-* PATCH : REFACTOR : Moved more validation functionality into the chunk object.
-* PATCH : REFACTOR : Clean up validator code.
-* PATCH : REFACTOR : Move more core code away from validators into YAMLChunk.
-
-
-### 0.8.0
-
-* MINOR : FEATURE : Enum with item validators.
-* MINOR : FEATURE : Mappings with key validators.
-* MINOR : FEATURE : Key validation using Map().
-* PATCH : PERFORMANCE IMPROVEMENTS : Avoided the use of deepcopy() every time a validator is used.
-* MINOR BUGFIX : Roundtripping failure fixes.
-* PATCH : REFACTOR : Only use chunk object in scalar validators.
-* PATCH : REFACTOR : Removed dependency on two variables being fed in to the validate_scalar method.
-
-
-### 0.7.3
-
-* PERFORMANCE : Improved performance of dumping by restricting the number of times deepcopy() is called.
-* FEATURE : Performance improvements.
-* FEATURE : Create dumpable YAML documents from simple dicts/lists of python data.
-* FEATURE : Create documents from scratch.
-* FEATURE : Create YAML documents directly.
-* FEATURE : Merging of YAML documents.
-* BUGFIX : Handle roundtripping changing indexed elements in sequences.
-* BUGFIX : Fix for scalar value roundtripping.
-* FEATURE : Set sequences using lists.
-* FEATURE : Use 'yes' and 'no' as default boolean values.
-* FEATURE : Set nested mappings that get correctly validated using __setitem__ interface on YAML() objects.
-* BUGFIX : Don't futz with the ordering of keys when setting vars via __setitem__.
-
-
-### 0.7.2
-
-* BUGFIX : Decimal point representer does not work with decimal.Decimal() object, so using float instead.
-* BUGFIX : In python 2.x, the __ne__ magic method is called on != rather than negating the result of the __eq__ method. This caused undesired behavior in python 2.x.
-* FEATURE : Parser errors will have the correct label attached.
-* FEATURE : .data now returns ordereddicts.
-* BUG : Boolean 'y' and 'n' values ought to resolve to True and False.
-* BUG : Map keys were accidentally optional by default.
-* BUG : Disallowed exceptions were previously not labeled.
-* BUG : Duplicate key exceptions were previously not labeled.
-* BUG : Fix for roundtripping multiline strings in python 2.
-* FEATURE : Label parsed YAML and have the label appear in exceptions.
-* BUG : Fix the way that data is roundtrip loaded into the yaml object via __setitem__.
-* BUG : Fixed roundtripping without using load()
-
-
-### 0.7.0
-
-* FEATURE : Modified the way that roundtripping works.
-
-
-### 0.6.2
-
-* FEATURE : Added version number accessible from __init__.py
-* BUG : Fixed the miscounting of list lines when getting start_line/end_line.
-
-
-### 0.6.0
-
-* BUG : Fixed import issues.
-* FEATURE : Added email and url validators.
-* FEATURE : Added Regex validator.
-
-
-### 0.5.9
-
-
-No relevant code changes.
-
-### 0.5.8
-
-* BUG : Fixed boolean error.
-
-
-### 0.5.7
-
-* BUG : Fixed MapPattern errors caused when editing items.
-
-
-### 0.5.6
-
-* FEATURE : Strict type checking when setting values.
-
-
-### 0.5.5
-
-* BUG : Fix roundtripping when using non-ascii characters.
-* BUG : Fixed unicode roundtripping error.
-
-
-### 0.5.4
-
-* BUG : Fix mishandling of special characters in mappings.
-* BUG : Handle invalid keys which are non-ascii characters gracefully
-* BUG : Fix for character encoding issues that occur when non-string scalars see invalid input.
-
-
-### 0.5.3
-
-* BUG : Third fix for character encoding issues (#18: hat tip @jpscaletti)
-* BUG : Second fix for character encoding issues (#18: hat tip Juan Pablo-Scaletti)
-* BUG : Fix for #18 (hat tip Juan Pablo-Scaletti)
-
-
-### 0.5.2
-
-* BUG : Fix for #17 (hat tip @kshpytsya)
-
-
-### 0.5.1
-
-* FEATURE : YAML object importable directly from module.
-
-
-### 0.5.0
-
-* BUG : Fixed some broken elements of roundtripping.
-* BUG : .data representations did not give keys as strings.
-* BUG : Fixed bool(x) overriding in python 2.
-* FEATURE : Greater than / less than implemented along with better post-representation assignment to mappings.
-* FEATURE : Better repr()
-* BUG : Keys are now represented as YAML() objects with full access to the location of the key in the YAML document.
-* FEATURE : Added is_[scalar|mapping|sequence] methods.
-* FEATURE : .values() on YAML object.
-* FEATURE : Added .value property to YAML object.
-* FEATURE : Implemented __contains__ so the 'in' method can be used.
-* FEATURE : Added .get(val) and .keys() so mapping YAML objects can be treated like dicts.
-* FEATURE : Added .items() to YAML object.
-* FEATURE : Handle srting casting for integers.
-* FEATURE : Raise TypeError when trying to cast a string to bool.
-* FEATURE : Raise TypeError when attempting to cast YAML(bool) to string.
-* FEATURE : Get lines for a specific YAML value, lines before it and lines after.
-* FEATURE : Print line numbers of YAML elements.
-* FEATURE : Any validator.
-* FEATURE : Fixed length sequence validation.
-* BUG : Fixed roundtripping.
-* FEATURE : Rountripped YAML with modifications.
-* BUG : Fixed ruamel.yaml version at a higher level.
-* FEATURE : Parse YAML into roundtrippable YAML object.
-
-
-### 0.4.2
-
-
-No relevant code changes.
-
-### 0.4.1
-
-* BUG : Fixed comma separated validator - now removes trailing spaces when parsing "a, b, c" so it does not parse as "a", " b", " c".
-
-
-### 0.4.0
-
-* FEATURE: Comma separated values.
-
-
-### 0.3.9
-
-* FEATURE : Added import for CommentedYAML type.
-
-
-### 0.3.8
-
-* FEATURE : Empty property validation.
-
-
-### 0.3.7
-
-* BUG : Fixed ruamel.yaml importing so that it works with earlier versions too.
-
-
-### 0.3.6
-
-* BUG : Fixed 13.1 ruamel.yaml issue.
-
-
-### 0.3.5
-
-* BUG : Stray print statement.
-
-
-### 0.3.3
-
-* BUG : Disallow flow style was failing with sequences.
-
-
-### 0.3.2
-
-
-No relevant code changes.
-
-### 0.3.1
-
-* BUG : Fixed mis-parsing caused by 'null' and non-strings in dictionary keys.
-
-
-### 0.3
-
-* FEATURE : Datetime parsing.
-* BUG : When loading a blank string using 'Any' it returned None by accident.
-
-
-### 0.2
-
-* FEATURE : YAMLValidationError now inherits from and uses the same mechanism as MarkedYAMLError.
-
-
-### 0.1.6
-
-
-No relevant code changes.
-
-### 0.1.5
-
-* FEATURE : Duplicate keys disallowed.
-
-
-### 0.1.4
-
-* FEATURE : Made the default to parse all scalars to string (Any validator) and added validator that returns CommentedSeq/CommentedMap.
-
-
-### 0.1.3
-
-* FEATURE : Clearer exception messages.
-* BUG : Fixed bug in sequence validator.
-
-
-### 0.1.2
-
-* BUG : Single value YAML documents now allowed.
-* BUG : Raise type error if it isn't a string passed through.
-
diff --git a/docs/public/comparison/table.yml b/docs/public/comparison/table.yml
deleted file mode 100644
index c7a2590..0000000
--- a/docs/public/comparison/table.yml
+++ /dev/null
@@ -1,62 +0,0 @@
-json:
-  syntax to data ratio:
-  % length of JSON: 100
-  syntax typing: yes
-  well defined: yes
-  comments: no
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: no
-  meaningful whitespace: no
-  complex features: no
-
-strictyaml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: yes
-  comments: yes
-  syntactic noise ratio:
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: yes
-  meaningful whitespace: yes
-  complex features: no
-
-yaml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: yes
-  well defined: yes
-  comments: yes
-  hierarchical: yes
-  duplicate keys: yes
-  multiline strings: yes
-  meaningful whitespace: no
-  complex features: yes
-
-ini:
-  syntactic noise ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: no
-  comments: yes
-  hierarchical: no
-  duplicate keys: yes
-  multiline strings: no
-  meaningful whitespace: no
-  complex features: no
-
-toml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: no
-  comments: yes
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: yes
-  meaningful whitespace: no
-  complex features: yes
-
-json5:
diff --git a/docs/public/features-removed.md b/docs/public/features-removed.md
deleted file mode 100644
index d3b7617..0000000
--- a/docs/public/features-removed.md
+++ /dev/null
@@ -1,147 +0,0 @@
----
-title: What YAML features does StrictYAML remove?
----
-
-StrictYAML restricts you from parsing a number of things which
-the YAML specification says should be parsed. An issue has
-been [raised](https://github.com/yaml/YAML2/issues/8) by
-[David Seaward](https://inkwell.za.net/) about this critique
-on the official YAML repository.
-
-This document lists those of those features:
-
-
-## Implicit Typing ([Why?](../why/implicit-typing-removed))
-
-```yaml
-x: yes
-y: null
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {"x": True, "y": None}
-```
-
-Example StrictYAML without schema:
-
-```python
-load(yaml) == {"x": "yes", "y": "null"}
-```
-
-Example StrictYAML with schema:
-
-```python
-load(yaml, Map({"x": Bool(), "y": Str()})) == {"x": True, "y": "null"}
-```
-
-
-## Direct representations of objects ([Why?](../why/not-parse-direct-representations-of-python-objects))
-
-```yaml
---- !python/hash:UnsafeUserObject
-email: evilhacker@hacker.com
-password: passwordtoset
-type: admin
-```
-
-Example pyyaml/ruamel:
-
-```python
-load(yaml) == {'evil': b'z\xf8\xa5u\xabZ'}
-```
-
-Example StrictYAML
-
-```python
-raises TagTokenDisallowed
-```
-
-
-## Duplicate Keys Disallowed ([Why?](../why/duplicate-keys-disallowed))
-
-```yaml
-x: 1
-x: 2
-```
-
-Example pyyaml/poyo:
-
-```python
-load(yaml) == {'x': 2}
-```
-
-Example StrictYAML
-
-```python
-raises DuplicateKeysDisallowed
-```
-
-
-## Explicit tags ([Why?](../why/explicit-tags-removed))
-
-```yaml
-x: !!int 5
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == load(yaml) == {"x": 5}
-```
-
-Example StrictYAML
-
-```python
-raises TagTokenDisallowed
-```
-
-
-## Node anchors and refs ([Why?](../why/node-anchors-and-references-removed))
-
-```yaml
-x: &id001
-  a: 1
-y: *id001
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {'x': {'a': 1}, 'y': {'a': 1}}
-```
-
-Example StrictYAML
-
-```python
-raises NodeAnchorDisallowed
-```
-
-To parse the above YAML *literally* in StrictYAML do:
-
-```yaml
-x: '&id001'
-  a: 1
-y: '*id001'
-```
-
-
-## Flow style ([Why?](../why/flow-style-removed))
-
-```yaml
-x: 1
-b: {c: 3, d: 4}
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {'x': 1, 'b': {'c': 3, 'd': 4}}
-```
-
-Example StrictYAML
-
-```python
-raises FlowStyleDisallowed
-```
diff --git a/docs/public/index.md b/docs/public/index.md
deleted file mode 100644
index fa11d63..0000000
--- a/docs/public/index.md
+++ /dev/null
@@ -1,319 +0,0 @@
----
-title: StrictYAML
----
-
-{{< github-stars user="crdoconnor" project="strictyaml" >}}
-
-
-StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
-that parses and validates a [restricted subset](features-removed) of the [YAML](what-is-yaml)
-specification.
-
-Priorities:
-
-- Beautiful API
-- Refusing to parse [the ugly, hard to read and insecure features of YAML](features-removed) like [the Norway problem](why/implicit-typing-removed).
-- Strict validation of markup and straightforward type casting.
-- Clear, readable exceptions with **code snippets** and **line numbers**.
-- Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
-- Ability to read in YAML, make changes and write it out again with comments preserved.
-- [Not speed](why/speed-not-a-priority), currently.
-
-
-Simple example:
-
-```yaml
-# All about the character
-name: Ford Prefect
-age: 42
-possessions:
-- Towel
-
-```
-
-
-```python
-from strictyaml import load, Map, Str, Int, Seq, YAMLError
-
-```
-
-
-
-
-
-Default parse result:
-
-
-```python
->>> load(yaml_snippet)
-YAML({'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']})
-```
-
-
-
-All data is string, list or OrderedDict:
-
-
-```python
->>> load(yaml_snippet).data
-{'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']}
-```
-
-
-
-Quickstart with schema:
-
-
-```python
-from strictyaml import load, Map, Str, Int, Seq, YAMLError
-
-schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
-
-```
-
-
-
-
-
-42 is now parsed as an integer:
-
-
-```python
->>> person = load(yaml_snippet, schema)
->>> person.data
-{'name': 'Ford Prefect', 'age': 42, 'possessions': ['Towel']}
-```
-
-
-
-A YAMLError will be raised if there are syntactic problems, violations of your schema or use of disallowed YAML features:
-
-```yaml
-# All about the character
-name: Ford Prefect
-age: 42
-
-```
-
-
-
-
-
-
-For example, a schema violation:
-
-
-```python
-try:
-    person = load(yaml_snippet, schema)
-except YAMLError as error:
-    print(error)
-
-```
-
-```yaml
-while parsing a mapping
-  in "<unicode string>", line 1, column 1:
-    # All about the character
-     ^ (line: 1)
-required key(s) 'possessions' not found
-  in "<unicode string>", line 3, column 1:
-    age: '42'
-    ^ (line: 3)
-```
-
-
-
-
-
-If parsed correctly:
-
-
-```python
-from strictyaml import load, Map, Str, Int, Seq, YAMLError, as_document
-
-schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
-
-```
-
-
-
-
-
-You can modify values and write out the YAML with comments preserved:
-
-
-```python
-person = load(yaml_snippet, schema)
-person['age'] = 43
-print(person.as_yaml())
-
-```
-
-```yaml
-# All about the character
-name: Ford Prefect
-age: 43
-possessions:
-- Towel
-```
-
-
-
-
-
-As well as look up line numbers:
-
-
-```python
->>> person = load(yaml_snippet, schema)
->>> person['possessions'][0].start_line
-5
-```
-
-
-
-And construct YAML documents from dicts or lists:
-
-
-```python
-print(as_document({"x": 1}).as_yaml())
-
-```
-
-```yaml
-x: 1
-```
-
-
-
-
-
-
-
-## Install
-
-```sh
-$ pip install strictyaml
-```
-
-
-## Why StrictYAML?
-
-There are a number of formats and approaches that can achieve more or
-less the same purpose as StrictYAML. I've tried to make it the best one.
-Below is a series of documented justifications:
-
-- [Why avoid using environment variables as configuration?](why-not/environment-variables-as-config)
-- [Why not use HJSON?](why-not/hjson)
-- [Why not HOCON?](why-not/hocon)
-- [Why not use INI files?](why-not/ini)
-- [Why not use JSON Schema for validation?](why-not/json-schema)
-- [Why not JSON for simple configuration files?](why-not/json)
-- [Why not JSON5?](why-not/json5)
-- [Why not use the YAML 1.2 standard? - we don't need a new standard!](why-not/ordinary-yaml)
-- [Why not use kwalify with standard YAML to validate my YAML?](why-not/pykwalify)
-- [Why not use Python's schema library (or similar) for validation?](why-not/python-schema)
-- [Why not use SDLang?](why-not/sdlang)
-- [What is wrong with TOML?](why-not/toml)
-- [Why shouldn't I just use Python code for configuration?](why-not/turing-complete-code)
-- [Why not use XML for configuration or DSLs?](why-not/xml)
-
-
-
-## Using StrictYAML
-
-How to:
-
-- [Build a YAML document from scratch in code](using/alpha/howto/build-yaml-document)
-- [Either/or schema validation of different, equally valid different kinds of YAML](using/alpha/howto/either-or-validation)
-- [Labeling exceptions](using/alpha/howto/label-exceptions)
-- [Merge YAML documents](using/alpha/howto/merge-yaml-documents)
-- [Revalidate an already validated document](using/alpha/howto/revalidation)
-- [Reading in YAML, editing it and writing it back out](using/alpha/howto/roundtripping)
-- [Get line numbers of YAML elements](using/alpha/howto/what-line)
-- [Parsing YAML without a schema](using/alpha/howto/without-a-schema)
-
-
-Compound validators:
-
-- [Fixed length sequences (FixedSeq)](using/alpha/compound/fixed-length-sequences)
-- [Mappings combining defined and undefined keys (MapCombined)](using/alpha/compound/map-combined)
-- [Mappings with arbitrary key names (MapPattern)](using/alpha/compound/map-pattern)
-- [Mapping with defined keys and a custom key validator (Map)](using/alpha/compound/mapping-with-slug-keys)
-- [Using a YAML object of a parsed mapping](using/alpha/compound/mapping-yaml-object)
-- [Mappings with defined keys (Map)](using/alpha/compound/mapping)
-- [Optional keys with defaults (Map/Optional)](using/alpha/compound/optional-keys-with-defaults)
-- [Validating optional keys in mappings (Map)](using/alpha/compound/optional-keys)
-- [Sequences of unique items (UniqueSeq)](using/alpha/compound/sequences-of-unique-items)
-- [Sequence/list validator (Seq)](using/alpha/compound/sequences)
-- [Updating document with a schema](using/alpha/compound/update)
-
-
-Scalar validators:
-
-- [Boolean (Bool)](using/alpha/scalar/boolean)
-- [Parsing comma separated items (CommaSeparated)](using/alpha/scalar/comma-separated)
-- [Datetimes (Datetime)](using/alpha/scalar/datetime)
-- [Decimal numbers (Decimal)](using/alpha/scalar/decimal)
-- [Email and URL validators](using/alpha/scalar/email-and-url)
-- [Empty key validation](using/alpha/scalar/empty)
-- [Enumerated scalars (Enum)](using/alpha/scalar/enum)
-- [Floating point numbers (Float)](using/alpha/scalar/float)
-- [Hexadecimal Integers (HexInt)](using/alpha/scalar/hexadecimal-integer)
-- [Integers (Int)](using/alpha/scalar/integer)
-- [Validating strings with regexes (Regex)](using/alpha/scalar/regular-expressions)
-- [Parsing strings (Str)](using/alpha/scalar/string)
-
-
-Restrictions:
-
-- [Disallowed YAML](using/alpha/restrictions/disallowed-yaml)
-- [Duplicate keys](using/alpha/restrictions/duplicate-keys)
-- [Dirty load](using/alpha/restrictions/loading-dirty-yaml)
-
-
-
-## Design justifications
-
-There are some design decisions in StrictYAML which are controversial
-and/or not obvious. Those are documented here:
-
-- [What is wrong with duplicate keys?](why/duplicate-keys-disallowed)
-- [What is wrong with explicit tags?](why/explicit-tags-removed)
-- [What is wrong with flow-style YAML?](why/flow-style-removed)
-- [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](why/implicit-typing-removed)
-- [What is wrong with node anchors and references?](why/node-anchors-and-references-removed)
-- [Why does StrictYAML not parse direct representations of Python objects?](why/not-parse-direct-representations-of-python-objects)
-- [Why does StrictYAML only parse from strings and not files?](why/only-parse-strings-not-files)
-- [Why is parsing speed not a high priority for StrictYAML?](why/speed-not-a-priority)
-- [What is syntax typing?](why/syntax-typing-bad)
-- [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](why/turing-complete-schema)
-
-
-
-## Star Contributors
-
-- @wwoods
-- @chrisburr
-- @jnichols0
-
-## Other Contributors
-
-- @eulores
-- @WaltWoods
-- @ChristopherGS
-- @gvx
-- @AlexandreDecan
-- @lots0logs
-- @tobbez
-- @jaredsampson
-- @BoboTIG
-
-StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.
-
-## Contributing
-
-- Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
-- Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
-- All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.
\ No newline at end of file
diff --git a/docs/public/redirects.yml b/docs/public/redirects.yml
deleted file mode 100644
index abfeba9..0000000
--- a/docs/public/redirects.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-/why-not/syntax-typing: /why/syntax-typing-bad
-/new-faq: /
-/using/alpha/compound/either-or-validation: /using/alpha/howto/either-or-validation/
-/why/care-about-yaml: /why
-/why/binary-data-removed: /why/not-parse-direct-representations-of-python-objects
diff --git a/docs/public/using/alpha/compound/fixed-length-sequences.md b/docs/public/using/alpha/compound/fixed-length-sequences.md
deleted file mode 100644
index a40f4c4..0000000
--- a/docs/public/using/alpha/compound/fixed-length-sequences.md
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: Fixed length sequences (FixedSeq)
-type: using
----
-
-
-Sequences of fixed length can be validated with a series
-of different (or the same) types.
-
-
-
-
-```python
-from strictyaml import FixedSeq, Str, Map, Int, Float, YAMLValidationError, load
-from ensure import Ensure
-
-schema = FixedSeq([Int(), Map({"x": Str()}), Float()])
-
-```
-
-
-
-Equivalent list:
-
-```yaml
-- 1
-- x: 5
-- 2.5
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals([1, {"x": "5"}, 2.5, ])
-
-```
-
-
-
-
-Invalid list 1:
-
-```yaml
-a: 1
-b: 2
-c: 3
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a sequence of 3 elements
-  in "<unicode string>", line 1, column 1:
-    a: '1'
-     ^ (line: 1)
-found a mapping
-  in "<unicode string>", line 3, column 1:
-    c: '3'
-    ^ (line: 3)
-```
-
-
-
-
-Invalid list 2:
-
-```yaml
-- 2
-- a
-- a:
-  - 1
-  - 2
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a mapping
-found arbitrary text
-  in "<unicode string>", line 2, column 1:
-    - a
-    ^ (line: 2)
-```
-
-
-
-
-Invalid list 3:
-
-```yaml
-- 1
-- a
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a sequence of 3 elements
-  in "<unicode string>", line 1, column 1:
-    - '1'
-     ^ (line: 1)
-found a sequence of 2 elements
-  in "<unicode string>", line 2, column 1:
-    - a
-    ^ (line: 2)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/fixed-sequence.story">fixed-sequence.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/index.md b/docs/public/using/alpha/compound/index.md
deleted file mode 100644
index 1f87d12..0000000
--- a/docs/public/using/alpha/compound/index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Compound StrictYAML Validators
----
-
-- [Fixed length sequences (FixedSeq)](fixed-length-sequences)
-- [Mappings combining defined and undefined keys (MapCombined)](map-combined)
-- [Mappings with arbitrary key names (MapPattern)](map-pattern)
-- [Mapping with defined keys and a custom key validator (Map)](mapping-with-slug-keys)
-- [Using a YAML object of a parsed mapping](mapping-yaml-object)
-- [Mappings with defined keys (Map)](mapping)
-- [Optional keys with defaults (Map/Optional)](optional-keys-with-defaults)
-- [Validating optional keys in mappings (Map)](optional-keys)
-- [Sequences of unique items (UniqueSeq)](sequences-of-unique-items)
-- [Sequence/list validator (Seq)](sequences)
-- [Updating document with a schema](update)
diff --git a/docs/public/using/alpha/compound/map-combined.md b/docs/public/using/alpha/compound/map-combined.md
deleted file mode 100644
index 9adb2de..0000000
--- a/docs/public/using/alpha/compound/map-combined.md
+++ /dev/null
@@ -1,189 +0,0 @@
----
-title: Mappings combining defined and undefined keys (MapCombined)
-type: using
----
-
-{{< warning title="Experimental" >}}
-This feature is in alpha. The API may change on a minor version increment.
-{{< /warning >}}
-
-
-When you wish to support arbitrary optional keys in
-some mappings (i.e. to specify some required keys in
-the schema, but allow any additional ones on top of
-that), you use a MapCombined.
-
-See https://github.com/crdoconnor/strictyaml/issues/148#issuecomment-861007657
-
-
-
-
-```python
-from strictyaml import Any, Int, MapCombined, Optional, Str, load
-from ensure import Ensure
-
-schema = MapCombined(
-  {
-    "required": Str(),
-    Optional("foo"): Int(),
-  },
-  Str(),
-  Any(),
-)
-
-```
-
-
-
-Optional is present:
-
-```yaml
-required: Hello World
-foo: 42
-bar: 42
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals(
-    {
-        "required": "Hello World",
-        "foo": 42,
-        "bar": "42",
-    }
-)
-
-```
-
-
-
-
-Optional is absent:
-
-```yaml
-required: Hello World
-bar: 42
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals(
-    {
-        "required": "Hello World",
-        "bar": "42",
-    }
-)
-
-```
-
-
-
-
-Multiple undefined:
-
-```yaml
-required: Hello World
-bar: 42
-baz: forty two
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals(
-    {
-        "required": "Hello World",
-        "bar": "42",
-        "baz": "forty two",
-    }
-)
-
-```
-
-
-
-
-Required is absent:
-
-```yaml
-bar: 42
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-required key(s) 'required' not found
-  in "<unicode string>", line 1, column 1:
-    bar: '42'
-     ^ (line: 1)
-```
-
-
-
-
-Undefined of invalid type:
-
-```yaml
-required: Hello World
-bar: forty two
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 2, column 1:
-    bar: forty two
-    ^ (line: 2)
-```
-
-
-
-
-Invalid key type:
-
-```yaml
-1: Hello World
-not_an_integer: 42
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 2, column 1:
-    not_an_integer: '42'
-    ^ (line: 2)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map-combined.story">map-combined.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/map-pattern.md b/docs/public/using/alpha/compound/map-pattern.md
deleted file mode 100644
index 0f3f7c2..0000000
--- a/docs/public/using/alpha/compound/map-pattern.md
+++ /dev/null
@@ -1,249 +0,0 @@
----
-title: Mappings with arbitrary key names (MapPattern)
-type: using
----
-
-
-When you do not wish to let the user define the key
-names in a mapping and and only specify what type the
-keys are, use a MapPattern.
-
-When you wish to specify the exact key name, use the
-'Map' validator instead.
-
-
-
-
-```python
-from strictyaml import MapPattern, Int, Float, Str, Any, Seq, YAMLValidationError, load
-from ensure import Ensure
-
-schema = MapPattern(Str(), Int())
-
-```
-
-
-
-Equivalence 1:
-
-```yaml
-â: 1
-b: 2
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({u"â": 1, "b": 2})
-
-```
-
-
-
-
-Equivalence 2:
-
-```yaml
-a: 1
-c: 3
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1, "c": 3})
-
-```
-
-
-
-
-Equivalence 3:
-
-```yaml
-a: 1
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1, })
-
-```
-
-
-
-
-With floats and ints:
-
-```yaml
-10.25: 23
-20.33: 76
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, MapPattern(Float(), Int())).data).equals({10.25: 23, 20.33: 76})
-
-```
-
-
-
-
-With Int and List:
-
-```yaml
-1:
-- ABC
-2:
-- DEF
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, MapPattern(Int(), Seq(Str()))).data).equals({1: ["ABC"], 2: ["DEF"]})
-
-```
-
-
-
-
-Invalid 1:
-
-```yaml
-b: b
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    b: b
-     ^ (line: 1)
-```
-
-
-
-
-Invalid 2:
-
-```yaml
-a: a
-b: 2
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: a
-     ^ (line: 1)
-```
-
-
-
-
-More than the maximum number of keys:
-
-```yaml
-â: 1
-b: 2
-
-```
-
-
-```python
-load(yaml_snippet, MapPattern(Str(), Int(), maximum_keys=1))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-  in "<unicode string>", line 1, column 1:
-    "\xE2": '1'
-     ^ (line: 1)
-expected a maximum of 1 key, found 2.
-  in "<unicode string>", line 2, column 1:
-    b: '2'
-    ^ (line: 2)
-```
-
-
-
-
-Fewer than the minimum number of keys:
-
-```yaml
-â: 1
-
-```
-
-
-```python
-load(yaml_snippet, MapPattern(Str(), Int(), minimum_keys=2))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-expected a minimum of 2 keys, found 1.
-  in "<unicode string>", line 1, column 1:
-    "\xE2": '1'
-     ^ (line: 1)
-```
-
-
-
-
-Invalid with non-ascii:
-
-```yaml
-a: 1
-b: yâs
-c: 3
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 2, column 1:
-    b: "y\xE2s"
-    ^ (line: 2)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/mappattern.story">mappattern.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/mapping-with-slug-keys.md b/docs/public/using/alpha/compound/mapping-with-slug-keys.md
deleted file mode 100644
index 0296c3d..0000000
--- a/docs/public/using/alpha/compound/mapping-with-slug-keys.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Mapping with defined keys and a custom key validator (Map)
-type: using
----
-
-{{< warning title="Experimental" >}}
-This feature is in alpha. The API may change on a minor version increment.
-{{< /warning >}}
-
-
-A typical mapping except that the key values are determined
-by the value provided by the validator.
-
-
-Example yaml_snippet:
-
-```yaml
-Name: United Kingdom
-country-code: GB
-DIAL CODE: +44
-official languages:
-- English
-- Welsh
-
-```
-
-
-```python
-from collections import OrderedDict
-from strictyaml import Map, Optional, Str, Seq, load, ScalarValidator
-from ensure import Ensure
-
-# This example uses slugify from the "python-slugify" package
-from slugify import slugify
-
-class Slug(ScalarValidator):
-    def validate_scalar(self, chunk):
-        return slugify(unicode(chunk.contents))
-
-schema = Map({
-    "name": Str(),
-    Optional("country-code"): Str(),
-    "dial-code": Str(),
-    "official-languages": Seq(Str())
-}, key_validator=Slug())
-
-```
-
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals(
-    {
-        "name": "United Kingdom",
-        "country-code": "GB",
-        "dial-code": "+44",
-        "official-languages": ["English", "Welsh"],
-    }
-)
-
-```
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map-with-key-validator.story">map-with-key-validator.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/mapping-yaml-object.md b/docs/public/using/alpha/compound/mapping-yaml-object.md
deleted file mode 100644
index 4b3a31a..0000000
--- a/docs/public/using/alpha/compound/mapping-yaml-object.md
+++ /dev/null
@@ -1,165 +0,0 @@
----
-title: Using a YAML object of a parsed mapping
-type: using
----
-
-
-When a YAML document with mappings is parsed, it is not parsed
-as a dict but as a YAML object which behaves very similarly to
-a dict, but with some extra capabilities.
-
-You can use .items(), .keys(), .values(), look up items with
-square bracket notation, .get(key, with_default_if_nonexistent)
-and use "x in y" notation to determine key membership.
-
-To retrieve the equivalent dict (containing just other dicts, lists
-and strings/ints/etc.) use .data.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1
-b: 2
-c: 3
-
-```
-
-
-```python
-from strictyaml import Map, Int, load
-from ensure import Ensure
-
-schema = Map({"a": Int(), "b": Int(), "c": Int()})
-
-```
-
-
-
-.is_mapping():
-
-
-```python
-Ensure(load(yaml_snippet, schema).is_mapping()).is_true()
-
-```
-
-
-
-
-Equivalence with equivalent plain dict:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1, "b": 2, "c": 3})
-
-```
-
-
-
-
-.items():
-
-
-```python
-Ensure(load(yaml_snippet, schema).items()).equals([("a", 1), ("b", 2), ("c", 3)])
-
-```
-
-
-
-
-Use in to detect presence of a key:
-
-
-```python
-Ensure("a" in load(yaml_snippet, schema)).is_true()
-
-```
-
-
-
-
-.values():
-
-
-```python
-Ensure(load(yaml_snippet, schema).values()).equals([1, 2, 3])
-
-```
-
-
-
-
-.keys():
-
-
-```python
-Ensure(load(yaml_snippet, schema).keys()).equals(["a", "b", "c"])
-
-```
-
-
-
-
-Key lookup:
-
-
-```python
-yaml = load(yaml_snippet, schema)
-Ensure(yaml[yaml.keys()[0]]).equals(1)
-
-```
-
-
-
-
-Dict lookup:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["a"]).equals(1)
-
-```
-
-
-
-
-.get():
-
-
-```python
-Ensure(load(yaml_snippet, schema).get("a")).equals(1)
-
-```
-
-
-
-
-.get() nonexistent:
-
-
-```python
-Ensure(load(yaml_snippet, schema).get("nonexistent")).equals(None)
-
-```
-
-
-
-
-len():
-
-
-```python
-Ensure(len(load(yaml_snippet, schema))).equals(3)
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/mapping-representation.story">mapping-representation.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/mapping.md b/docs/public/using/alpha/compound/mapping.md
deleted file mode 100644
index 113fe86..0000000
--- a/docs/public/using/alpha/compound/mapping.md
+++ /dev/null
@@ -1,274 +0,0 @@
----
-title: Mappings with defined keys (Map)
-type: using
----
-
-
-Mappings of one value to another are represented by : in YAML
-and parsed as python dicts.
-
-Using StrictYAML's 'Map' you can validate that a mapping
-contains the right keys and the right *type* of values.
-
-Note: for mappings where you don't know the exact names of
-the keys in advance but you do know the type, use MapPattern.
-
-
-Example yaml_snippet:
-
-```yaml
-â: 1
-b: 2
-c: 3
-
-```
-
-
-```python
-from collections import OrderedDict
-from strictyaml import Map, Int, load, as_document
-from collections import OrderedDict
-from ensure import Ensure
-
-schema = Map({"a": Int(), "b": Int(), "c": Int()})
-
-schema_2 = Map({u"â": Int(), "b": Int(), "c": Int()})
-
-```
-
-
-
-one key mapping:
-
-```yaml
-x: 1
-```
-
-
-```python
-Ensure(load(yaml_snippet, Map({"x": Int()})).data).equals(OrderedDict([('x', 1)]))
-
-```
-
-
-
-
-key value:
-
-
-```python
-Ensure(load(yaml_snippet, schema_2)[u'â']).equals(1)
-
-```
-
-
-
-
-get item key not found:
-
-
-```python
-load(yaml_snippet, schema_2)['keynotfound']
-```
-
-
-```python
-:
-'keynotfound'
-```
-
-
-
-
-cannot use .text:
-
-
-```python
-load(yaml_snippet, schema_2).text
-```
-
-
-```python
-builtins.TypeError:YAML({'â': 1, 'b': 2, 'c': 3}) is a mapping, has no text value.:
-```
-
-
-
-
-parse snippet where key is not found in schema:
-
-```yaml
-a: 1
-b: 2
-â: 3 
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-unexpected key not in schema 'â'
-  in "<unicode string>", line 3, column 1:
-    "\xE2": '3'
-    ^ (line: 3)
-```
-
-
-
-
-sequence not expected when parsing:
-
-```yaml
-- 1
-- 2
-- 3 
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a mapping
-  in "<unicode string>", line 1, column 1:
-    - '1'
-     ^ (line: 1)
-found a sequence
-  in "<unicode string>", line 3, column 1:
-    - '3'
-    ^ (line: 3)
-```
-
-
-
-
-List not expected when serializing:
-
-
-```python
-as_document([1, 2, 3], schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Expected a dict, found '[1, 2, 3]'
-```
-
-
-
-
-Empty dict not valid when serializing:
-
-
-```python
-as_document({}, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Expected a non-empty dict, found an empty dict.
-Use EmptyDict validator to serialize empty dicts.
-```
-
-
-
-
-Unexpected key:
-
-```yaml
-a: 1
-b: 2
-c: 3
-d: 4
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-unexpected key not in schema 'd'
-  in "<unicode string>", line 4, column 1:
-    d: '4'
-    ^ (line: 4)
-```
-
-
-
-
-required key not found:
-
-```yaml
-a: 1
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-required key(s) 'b', 'c' not found
-  in "<unicode string>", line 1, column 1:
-    a: '1'
-     ^ (line: 1)
-```
-
-
-
-
-iterator:
-
-```yaml
-a: 1
-b: 2
-c: 3
-
-```
-
-
-```python
-assert [item for item in load(yaml_snippet, schema)] == ["a", "b", "c"]
-
-```
-
-
-
-
-serialize:
-
-
-```python
-assert as_document(OrderedDict([(u"â", 1), ("b", 2), ("c", 3)]), schema_2).as_yaml() == yaml_snippet
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map.story">map.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/optional-keys-with-defaults.md b/docs/public/using/alpha/compound/optional-keys-with-defaults.md
deleted file mode 100644
index 76160b8..0000000
--- a/docs/public/using/alpha/compound/optional-keys-with-defaults.md
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: Optional keys with defaults (Map/Optional)
-type: using
----
-
-{{< warning title="Experimental" >}}
-This feature is in alpha. The API may change on a minor version increment.
-{{< /warning >}}
-
-
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1
-
-```
-
-
-```python
-from strictyaml import Map, Int, Str, Bool, EmptyNone, Optional, load, as_document
-from collections import OrderedDict
-from ensure import Ensure
-
-schema = Map({"a": Int(), Optional("b", default=False): Bool(), })
-
-```
-
-
-
-When parsed the result will include the optional value:
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals(OrderedDict([("a", 1), ("b", False)]))
-
-```
-
-
-
-
-If parsed and then output to YAML again the default data won't be there:
-
-
-```python
-print(load(yaml_snippet, schema).as_yaml())
-```
-
-```yaml
-a: 1
-```
-
-
-
-
-When default data is output to YAML it is removed:
-
-
-```python
-print(as_document({"a": 1, "b": False}, schema).as_yaml())
-
-```
-
-```yaml
-a: 1
-```
-
-
-
-
-When you want a key to stay and default to None:
-
-
-```python
-schema = Map({"a": Int(), Optional("b", default=None, drop_if_none=False): EmptyNone() | Bool(), })
-Ensure(load(yaml_snippet, schema).data).equals(OrderedDict([("a", 1), ("b", None)]))
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/optional-with-defaults.story">optional-with-defaults.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/optional-keys.md b/docs/public/using/alpha/compound/optional-keys.md
deleted file mode 100644
index e522a0a..0000000
--- a/docs/public/using/alpha/compound/optional-keys.md
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: Validating optional keys in mappings (Map)
-type: using
----
-
-
-Not every key in a YAML mapping will be required. If
-you use the "Optional('key')" validator with YAML,
-you can signal that a key/value pair is not required.
-
-
-
-
-```python
-from strictyaml import Map, Int, Str, Bool, Optional, load
-from ensure import Ensure
-
-schema = Map({"a": Int(), Optional("b"): Bool(), })
-
-```
-
-
-
-Valid example 1:
-
-```yaml
-a: 1
-b: yes
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1, "b": True})
-
-```
-
-
-
-
-Valid example 2:
-
-```yaml
-a: 1
-b: no
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1, "b": False})
-
-```
-
-
-
-
-Valid example missing key:
-
-```yaml
-a: 1
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1})
-
-```
-
-
-
-
-Invalid 1:
-
-```yaml
-a: 1
-b: 2
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a boolean value (one of "yes", "true", "on", "1", "y", "no", "false", "off", "0", "n")
-found an arbitrary integer
-  in "<unicode string>", line 2, column 1:
-    b: '2'
-    ^ (line: 2)
-```
-
-
-
-
-Invalid 2:
-
-```yaml
-a: 1
-b: yes
-c: 3
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-unexpected key not in schema 'c'
-  in "<unicode string>", line 3, column 1:
-    c: '3'
-    ^ (line: 3)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/optional.story">optional.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/sequences-of-unique-items.md b/docs/public/using/alpha/compound/sequences-of-unique-items.md
deleted file mode 100644
index a67c87c..0000000
--- a/docs/public/using/alpha/compound/sequences-of-unique-items.md
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: Sequences of unique items (UniqueSeq)
-type: using
----
-
-
-UniqueSeq validates sequences which contain no duplicate
-values.
-
-
-Example yaml_snippet:
-
-```yaml
-- A
-- B
-- C
-
-```
-
-
-```python
-from strictyaml import UniqueSeq, Str, load, as_document
-from ensure import Ensure
-
-schema = UniqueSeq(Str())
-
-```
-
-
-
-Valid:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals(["A", "B", "C", ])
-
-```
-
-
-
-
-Parsing with one dupe raises an exception:
-
-```yaml
-- A
-- B
-- B
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a sequence
-  in "<unicode string>", line 1, column 1:
-    - A
-     ^ (line: 1)
-duplicate found
-  in "<unicode string>", line 3, column 1:
-    - B
-    ^ (line: 3)
-```
-
-
-
-
-Parsing all dupes raises an exception:
-
-```yaml
-- 3
-- 3
-- 3
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a sequence
-  in "<unicode string>", line 1, column 1:
-    - '3'
-     ^ (line: 1)
-duplicate found
-  in "<unicode string>", line 3, column 1:
-    - '3'
-    ^ (line: 3)
-```
-
-
-
-
-Serializing with dupes raises an exception:
-
-
-```python
-as_document(["A", "B", "B"], schema)
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Expecting all unique items, but duplicates were found in '['A', 'B', 'B']'.
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/unique-sequence.story">unique-sequence.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/sequences.md b/docs/public/using/alpha/compound/sequences.md
deleted file mode 100644
index 4e43ed0..0000000
--- a/docs/public/using/alpha/compound/sequences.md
+++ /dev/null
@@ -1,233 +0,0 @@
----
-title: Sequence/list validator (Seq)
-type: using
----
-
-
-Sequences in YAML are denoted by a series of dashes ('-')
-and parsed as a list in python.
-
-Validating sequences of a particular type can be done with
-the Seq validator, specifying the type.
-
-See also [UniqueSeq](../sequences-of-unique-items) and
-[FixedSeq](../fixed-length-sequences) for other types of sequence
-validation.
-
-
-Example yaml_snippet:
-
-```yaml
-- 1
-- 2
-- 3
-
-```
-
-
-```python
-from strictyaml import Seq, Str, Int, load
-from ensure import Ensure
-
-```
-
-
-
-Valid Parsed:
-
-
-```python
-Ensure(load(yaml_snippet, Seq(Str()))).equals(["1", "2", "3", ])
-
-```
-
-
-
-
-Is sequence:
-
-
-```python
-assert load(yaml_snippet, Seq(Str())).is_sequence()
-
-```
-
-
-
-
-Iterator:
-
-
-```python
-assert [x for x in load(yaml_snippet, Seq(Str()))] == ["1", "2", "3"]
-
-```
-
-
-
-
-Lists of lists:
-
-```yaml
--
-  - a
-  - b
-  - c
--
-  - d
-  - e
-  - f
-
-```
-
-
-```python
-assert load(yaml_snippet, Seq(Seq(Str()))) == [["a", "b", "c"], ["d", "e", "f"]]
-
-```
-
-
-
-
-.text is nonsensical:
-
-```yaml
-- â
-- 2
-- 3
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Str())).text
-```
-
-
-```python
-builtins.TypeError:YAML(['â', '2', '3']) is a sequence, has no text value.:
-```
-
-
-
-
-Invalid mapping instead:
-
-```yaml
-a: 1
-b: 2
-c: 3
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Str()))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a sequence
-  in "<unicode string>", line 1, column 1:
-    a: '1'
-     ^ (line: 1)
-found a mapping
-  in "<unicode string>", line 3, column 1:
-    c: '3'
-    ^ (line: 3)
-```
-
-
-
-
-Invalid nested structure instead:
-
-```yaml
-- 2
-- 3
-- a:
-  - 1
-  - 2
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Str()))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a str
-  in "<unicode string>", line 3, column 1:
-    - a:
-    ^ (line: 3)
-found a mapping
-  in "<unicode string>", line 5, column 1:
-      - '2'
-    ^ (line: 5)
-```
-
-
-
-
-Invalid item in sequence:
-
-```yaml
-- 1.1
-- 1.2
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Int()))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found an arbitrary number
-  in "<unicode string>", line 1, column 1:
-    - '1.1'
-     ^ (line: 1)
-```
-
-
-
-
-One invalid item in sequence:
-
-```yaml
-- 1
-- 2
-- 3.4
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Int()))
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found an arbitrary number
-  in "<unicode string>", line 3, column 1:
-    - '3.4'
-    ^ (line: 3)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/sequence.story">sequence.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/compound/update.md b/docs/public/using/alpha/compound/update.md
deleted file mode 100644
index c450a6f..0000000
--- a/docs/public/using/alpha/compound/update.md
+++ /dev/null
@@ -1,143 +0,0 @@
----
-title: Updating document with a schema
-type: using
----
-
-
-When StrictYAML loads a document with a schema, it checks that future
-updates to that document follow the original schema.
-
-
-
-
-```python
-import strictyaml as s
-from ensure import Ensure
-
-```
-
-
-
-GitHub \#72:
-
-
-```python
-doc = s.load('a: 9', s.Map({
-  'a': s.Str(),
-  s.Optional('b'): s.Int(),
-}))
-doc['b'] = 9
-assert doc['b'] == 9
-```
-
-
-
-
-Works on empty mapping:
-
-
-```python
-doc = s.load('', s.EmptyDict() | s.Map({
-  'a': s.Int(),
-}))
-doc['a'] = 9
-assert doc['a'] == 9, doc.as_yaml()
-```
-
-
-
-
-Works on complex types:
-
-
-```python
-doc = s.load('a: 8', s.Map({'a': s.Int() | s.Float()}))
-assert type(doc['a'].data) == int, repr(doc.data)
-doc['a'] = '5.'
-assert type(doc['a'].data) == float, repr(doc.data)
-assert doc['a'] == 5.
-```
-
-
-
-
-Will not work on empty sequence:
-
-
-```python
-doc = s.load('', s.EmptyList() | s.Seq(s.Int()))
-doc[0] = 9
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-cannot extend list via __setitem__.  Instead, replace whole list on parent node.
-```
-
-
-
-
-Works on map with setting, updating, and then setting multiple keys (regression):
-
-
-```python
-doc = s.load('', s.EmptyDict() | s.MapPattern(
-  s.Str(),
-  s.EmptyDict() | s.Map({
-    s.Optional('b'): s.Seq(s.Int()),
-  })
-))
-doc['a'] = {}
-doc['a']['b'] = ['9']
-assert doc.data == {'a': {'b': [9]}}, doc.data
-assert doc.as_yaml() == 'a:\n  b:\n  - 9\n', doc.as_yaml()
-# Second assignment doesn't occur...
-doc['a']['b'] = ['9', '10']
-assert doc.data == {'a': {'b': [9, 10]}}, doc.data
-assert doc.as_yaml() == 'a:\n  b:\n  - 9\n  - 10\n', doc.as_yaml()
-# If and only if another node is overwritten.  This was a bug due
-# to mismatched _ruamelparsed objects.
-doc['b'] = {'b': ['11']}
-assert doc['a']['b'].data == [9, 10], doc.data
-assert doc['b']['b'].data == [11], doc.data
-assert doc.as_yaml() == 'a:\n  b:\n  - 9\n  - 10\nb:\n  b:\n  - 11\n', doc.as_yaml()
-
-```
-
-
-
-
-For empty sequence, must instead assign whole sequence as key:
-
-
-```python
-doc = s.load('a:', s.Map({'a': s.EmptyList() | s.Seq(s.Int())}))
-doc['a'] = [1, 2, 3]
-assert doc['a'].data == [1, 2, 3], repr(doc.data)
-```
-
-
-
-
-Can assign from string:
-
-
-```python
-doc = s.load('a: 9', s.Map({
-  'a': s.Str(),
-  s.Optional('b'): s.Int(),
-}))
-doc['b'] = '9'
-assert doc['b'] == 9
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/update-with-schema.story">update-with-schema.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/build-yaml-document.md b/docs/public/using/alpha/howto/build-yaml-document.md
deleted file mode 100644
index 1850c7d..0000000
--- a/docs/public/using/alpha/howto/build-yaml-document.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: Build a YAML document from scratch in code
-type: using
----
-
-
-YAML documents can be built from combinations of dicts,
-lists and strings if no schema is used.
-
-
-
-
-```python
-from ensure import Ensure
-from strictyaml import as_document
-from collections import OrderedDict
-
-# Can also use regular dict if an arbitrary ordering is ok
-yaml = as_document(OrderedDict(
-    [(u"â", 'yes'), ("b", "hâllo"), ("c", ["1", "2", "3"])]
-))
-
-```
-
-
-
-Then dump:
-
-
-```python
-print(yaml.as_yaml())
-```
-
-```yaml
-â: yes
-b: hâllo
-c:
-- 1
-- 2
-- 3
-```
-
-
-
-
-However, any type that is not a string, dict or list cannot be parsed without a schema:
-
-
-```python
-class RandomClass(object):
-    def __repr__(self):
-        return 'some random object'
-
-as_document({"x": RandomClass()})
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-'some random object' is not a string
-```
-
-
-
-
-Empty dicts also cannot be serialized without a schema:
-
-
-```python
-as_document({'hello': {}})
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Empty dicts are not serializable to StrictYAML unless schema is used.
-```
-
-
-
-
-Neither can lists:
-
-
-```python
-as_document({'hello': []})
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Empty lists are not serializable to StrictYAML unless schema is used.
-```
-
-
-
-
-You can grab line numbers from the object that is serialized:
-
-
-```python
-Ensure(yaml.start_line).equals(1)
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/build-yaml-document-from-scratch.story">build-yaml-document-from-scratch.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/either-or-validation.md b/docs/public/using/alpha/howto/either-or-validation.md
deleted file mode 100644
index 4e744ef..0000000
--- a/docs/public/using/alpha/howto/either-or-validation.md
+++ /dev/null
@@ -1,161 +0,0 @@
----
-title: Either/or schema validation of different, equally valid different kinds of YAML
-type: using
----
-
-
-StrictYAML can be directed to parse two different elements or
-blocks of YAML.
-
-If the first thing does not parse correctly, it attempts to
-parse the second. If the second does not parse correctly,
-it raises an exception.
-
-
-
-
-```python
-from strictyaml import Map, Seq, Bool, Int, Str, YAMLValidationError, load
-from ensure import Ensure
-
-schema = Str() | Map({"a": Bool() | Int()})
-
-```
-
-
-
-Boolean first choice true:
-
-```yaml
-a: yes
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": True})
-
-```
-
-
-
-
-Boolean first choice false:
-
-```yaml
-a: no
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": False})
-
-```
-
-
-
-
-Int second choice:
-
-```yaml
-a: 5
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 5})
-
-```
-
-
-
-
-Invalid not bool or int:
-
-```yaml
-a: A
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: A
-     ^ (line: 1)
-```
-
-
-
-
-Invalid combinations of more than one map:
-
-```yaml
-a: x
-```
-
-
-```python
-load(yaml_snippet, Map({"a": Str()}) | Map({"b": Str()}))
-
-```
-
-
-```python
-strictyaml.exceptions.InvalidValidatorError:
-You tried to Or ('|') together 2 Map validators. Try using revalidation instead.
-```
-
-
-
-
-Invalid combinations of more than one seq:
-
-```yaml
-- 1
-- 2
-
-```
-
-
-```python
-load(yaml_snippet, Seq(Int()) | Seq(Str()))
-
-```
-
-
-```python
-strictyaml.exceptions.InvalidValidatorError:
-You tried to Or ('|') together 2 Seq validators. Try using revalidation instead.
-```
-
-
-
-
-Change item after validated:
-
-```yaml
-a: yes
-```
-
-
-```python
-yaml = load(yaml_snippet, schema)
-yaml['a'] = 5
-assert yaml['a'] == 5
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/or.story">or.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/index.md b/docs/public/using/alpha/howto/index.md
deleted file mode 100644
index 58edf57..0000000
--- a/docs/public/using/alpha/howto/index.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: How to...
----
-
-- [Build a YAML document from scratch in code](build-yaml-document)
-- [Either/or schema validation of different, equally valid different kinds of YAML](either-or-validation)
-- [Labeling exceptions](label-exceptions)
-- [Merge YAML documents](merge-yaml-documents)
-- [Revalidate an already validated document](revalidation)
-- [Reading in YAML, editing it and writing it back out](roundtripping)
-- [Get line numbers of YAML elements](what-line)
-- [Parsing YAML without a schema](without-a-schema)
diff --git a/docs/public/using/alpha/howto/label-exceptions.md b/docs/public/using/alpha/howto/label-exceptions.md
deleted file mode 100644
index aeb310a..0000000
--- a/docs/public/using/alpha/howto/label-exceptions.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: Labeling exceptions
-type: using
----
-
-
-When raising exceptions, you can add a label that will replace
-<unicode string> with whatever you want.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1
-b:
-  - 1
-  - 2
-
-```
-
-
-```python
-from strictyaml import Map, Int, load, YAMLValidationError
-
-```
-
-
-
-Label myfilename:
-
-
-```python
-load(yaml_snippet, Map({"a": Int(), "b": Map({"x": Int(), "y": Int()})}), label="myfilename")
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a mapping
-  in "myfilename", line 2, column 1:
-    b:
-    ^ (line: 2)
-found a sequence
-  in "myfilename", line 4, column 1:
-    - '2'
-    ^ (line: 4)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/handle-exceptions.story">handle-exceptions.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/merge-yaml-documents.md b/docs/public/using/alpha/howto/merge-yaml-documents.md
deleted file mode 100644
index 29421db..0000000
--- a/docs/public/using/alpha/howto/merge-yaml-documents.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Merge YAML documents
-type: using
----
-
-
-Loaded YAML can be combined and dumped with the comments intact.
-
-
-
-
-```python
-from strictyaml import Map, MapPattern, Str, Seq, Int, load
-
-schema_1 = Map({
-    "a": Str(),
-    "b": Map({"x": Int(), "y": Int()}),
-    "c": Seq(MapPattern(Str(), Str())),
-})
-
-schema_2 = Map({"x": Int(), "y": Int()})
-
-yaml_1 = load(yaml_snippet_1, schema_1)
-yaml_2 = load(yaml_snippet_2, schema_2)
-
-yaml_1['b'] = yaml_2
-
-```
-
-
-
-```python
-print(yaml_1.as_yaml())
-```
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 8
-
-# y is now 9
-  y: 9
-c:
-- a: 1
-- b: 2
-```
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/merge-documents.story">merge-documents.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/revalidation.md b/docs/public/using/alpha/howto/revalidation.md
deleted file mode 100644
index 0a35075..0000000
--- a/docs/public/using/alpha/howto/revalidation.md
+++ /dev/null
@@ -1,105 +0,0 @@
----
-title: Revalidate an already validated document
-type: using
----
-
-
-When parsing a YAML document you may wish to do more than one validation
-pass over a document.
-
-This is needed when:
-
-* It simplifies your code to apply validation in stages.
-* You want to validate recursively.
-* One part of the document validation depends upon another (this is the example given below).
-
-
-Example yaml_snippet:
-
-```yaml
-capitals:
-  UK: 1
-  Germany: 2
-countries:
-  - Germany
-  - UK
-
-```
-
-
-```python
-from strictyaml import Str, Int, Map, Seq, Any, load
-from ensure import Ensure
-
-overall_schema = Map({"capitals": Any(), "countries": Seq(Str())})
-parsed = load(yaml_snippet, overall_schema)
-
-```
-
-
-
-Reparse mapping:
-
-
-```python
-Ensure(parsed.data['capitals']['UK']).equals("1")
-parsed['capitals'].revalidate(Map({capital: Int() for capital in parsed.data['countries']}))
-Ensure(parsed.data['capitals']['UK']).equals(1)
-
-```
-
-
-
-
-Reparse scalar:
-
-
-```python
-Ensure(parsed.data['capitals']['UK']).equals("1")
-parsed['capitals']['UK'].revalidate(Int())
-
-Ensure(parsed.data['capitals']['UK']).equals(1)
-Ensure(parsed['capitals']['UK'].data).is_an(int)
-
-```
-
-
-
-
-Parse error:
-
-```yaml
-capitals:
-  UK: 1
-  Germany: 2
-  France: 3
-countries:
-  - Germany
-  - UK
-
-```
-
-
-```python
-parsed['capitals'].revalidate(Map({capital: Int() for capital in parsed.data['countries']}))
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-while parsing a mapping
-unexpected key not in schema 'France'
-  in "<unicode string>", line 4, column 1:
-      France: '3'
-    ^ (line: 4)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/revalidation.story">revalidation.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/roundtripping.md b/docs/public/using/alpha/howto/roundtripping.md
deleted file mode 100644
index 38ab847..0000000
--- a/docs/public/using/alpha/howto/roundtripping.md
+++ /dev/null
@@ -1,222 +0,0 @@
----
-title: Reading in YAML, editing it and writing it back out
-type: using
----
-
-
-Loaded YAML can be modified and dumped out again with
-comments preserved using .as_yaml().
-
-Note that due to some bugs in the library (ruamel.yaml)
-underlying StrictYAML, while the data parsed should
-be precisely the same, the exact syntax (newlines, comment
-locations, etc.) may not be identical.
-
-
-Example yaml_snippet:
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 4
-  y: 5
-c:
-- a: 1
-- b: 2
-
-```
-
-
-```python
-from strictyaml import Map, MapPattern, EmptyDict, Str, Seq, Int, load
-from ensure import Ensure
-
-schema = Map({
-    "a": Str(),
-    "b": Map({"x": Int(), "y": Int()}),
-    "c": EmptyDict() | Seq(MapPattern(Str(), Str())),
-})
-
-```
-
-
-
-Commented:
-
-
-```python
-Ensure(load(yaml_snippet, schema).as_yaml()).equals(yaml_snippet)
-
-```
-
-
-
-
-Modified with invalid variable:
-
-
-```python
-to_modify = load(yaml_snippet, schema)
-to_modify['b']['x'] = 2
-to_modify['c'][0]['a'] = '3'
-to_modify['b']['x'] = 'not an integer'
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-'not an integer' not an integer.
-```
-
-
-
-
-Modified with float:
-
-
-```python
-to_modify = load(yaml_snippet, schema)
-to_modify['c'][0]['a'] = "1.0001"
-print(to_modify.as_yaml())
-
-```
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 4
-  y: 5
-c:
-- a: 1.0001
-- b: 2
-```
-
-
-
-
-Modify multi line string:
-
-```yaml
-a: some
-b: |
-  text
-
-```
-
-
-```python
-schema = Map({"a": Str(), "b": Str()})
-to_modify = load(yaml_snippet, schema)
-to_modify['a'] = 'changed'
-print(to_modify.as_yaml())
-
-```
-
-```yaml
-a: changed
-b: |
-  text
-```
-
-
-
-
-Modified with one variable:
-
-
-```python
-to_modify = load(yaml_snippet, schema)
-to_modify['b']['x'] = 2
-to_modify['c'][0]['a'] = '3'
-print(to_modify.as_yaml())
-
-```
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 2
-  y: 5
-c:
-- a: 3
-- b: 2
-```
-
-
-
-
-Text across lines:
-
-
-```python
-to_modify = load(yaml_snippet, schema)
-
-to_modify['c'][0]['a'] = "text\nacross\nlines"
-print(to_modify.as_yaml())
-
-```
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 4
-  y: 5
-c:
-- a: |-
-    text
-    across
-    lines
-- b: 2
-```
-
-
-
-
-With empty dict:
-
-
-```python
-to_modify = load(yaml_snippet, schema)
-
-to_modify['c'] = {}
-print(to_modify.as_yaml())
-
-```
-
-```yaml
-# Some comment
-
-a: â # value comment
-
-# Another comment
-b:
-  x: 4
-  y: 5
-c:
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/roundtrip.story">roundtrip.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/what-line.md b/docs/public/using/alpha/howto/what-line.md
deleted file mode 100644
index d9b9d9e..0000000
--- a/docs/public/using/alpha/howto/what-line.md
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: Get line numbers of YAML elements
-type: using
----
-
-
-Line numbers, the text of an item and text of surrounding lines
-can be grabbed from returned YAML objects - using .start_line,
-.end_line, lines(), lines_before(x) and lines_after(x).
-
-
-Example yaml_snippet:
-
-```yaml
-y: p
-# Some comment
-    
-a: |
-  x
-
-# Another comment
-b: y
-c: a
-
-d: b
-
-```
-
-
-```python
-from strictyaml import Map, Str, YAMLValidationError, load
-from ensure import Ensure
-
-schema = Map({"y": Str(), "a": Str(), "b": Str(), "c": Str(), "d": Str()})
-
-snippet = load(yaml_snippet, schema)
-
-```
-
-
-
-If there is preceding comment for an item the start line includes it:
-
-
-```python
-Ensure(snippet["a"].start_line).equals(3)
-Ensure(snippet["d"].start_line).equals(9)
-
-```
-
-
-
-
-If there is a trailing comment the end line includes it:
-
-
-```python
-Ensure(snippet["a"].end_line).equals(6)
-Ensure(snippet["d"].end_line).equals(10)
-
-```
-
-
-
-
-You can grab the start line of a key:
-
-
-```python
-Ensure(snippet.keys()[1].start_line).equals(3)
-
-```
-
-
-
-
-Start line and end line of whole snippet:
-
-
-```python
-Ensure(snippet.start_line).equals(1)
-Ensure(snippet.end_line).equals(10)
-
-```
-
-
-
-
-Grabbing a line before an item:
-
-
-```python
-Ensure(snippet['a'].lines_before(1)).equals("# Some comment")
-
-```
-
-
-
-
-Grabbing a line after an item:
-
-
-```python
-Ensure(snippet['a'].lines_after(4)).equals("b: y\nc: a\n\nd: b")
-
-```
-
-
-
-
-Grabbing the lines of an item including surrounding comments:
-
-
-```python
-print(load(yaml_snippet, schema)['a'].lines())
-
-```
-
-```yaml
-a: |
-  x
-
-# Another comment
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/whatline.story">whatline.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/howto/without-a-schema.md b/docs/public/using/alpha/howto/without-a-schema.md
deleted file mode 100644
index e9bfa58..0000000
--- a/docs/public/using/alpha/howto/without-a-schema.md
+++ /dev/null
@@ -1,78 +0,0 @@
----
-title: Parsing YAML without a schema
-type: using
----
-
-
-When using strictyaml you do not have to specify a schema. If
-you do this, the validator "Any" is used which will accept any
-mapping and any list and any scalar values (which will always be
-interpreted as a string, unlike regular YAML).
-
-This is the recommended approach when rapidly prototyping and the
-desired schema is fluid.
-
-When your prototype code is parsing YAML that has a more fixed
-structure, we recommend that you 'lock it down' with a schema.
-
-The Any validator can be used inside fixed structures as well.
-
-
-Example yaml_snippet:
-
-```yaml
-a:
-  x: 9
-  y: 8
-b: 2
-c: 3
-
-```
-
-
-```python
-from strictyaml import Str, Any, MapPattern, load
-from ensure import Ensure
-
-```
-
-
-
-Parse without validator:
-
-
-```python
-Ensure(load(yaml_snippet)).equals({"a": {"x": "9", "y": "8"}, "b": "2", "c": "3"})
-
-```
-
-
-
-
-Parse with any validator - equivalent:
-
-
-```python
-Ensure(load(yaml_snippet, Any())).equals({"a": {"x": "9", "y": "8"}, "b": "2", "c": "3"})
-
-```
-
-
-
-
-Fix higher levels of schema:
-
-
-```python
-Ensure(load(yaml_snippet, MapPattern(Str(), Any()))).equals({"a": {"x": "9", "y": "8"}, "b": "2", "c": "3"})
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/non-schema-validation.story">non-schema-validation.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/index.md b/docs/public/using/alpha/index.md
deleted file mode 100644
index c57b396..0000000
--- a/docs/public/using/alpha/index.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Using StrictYAML v0.x.x
----
\ No newline at end of file
diff --git a/docs/public/using/alpha/restrictions/disallowed-yaml.md b/docs/public/using/alpha/restrictions/disallowed-yaml.md
deleted file mode 100644
index 726732c..0000000
--- a/docs/public/using/alpha/restrictions/disallowed-yaml.md
+++ /dev/null
@@ -1,215 +0,0 @@
----
-title: Disallowed YAML
-type: using
----
-
-
-StrictYAML parses an opinionated subset of the YAML
-specification which refuses to parse features which
-are otherwise valid in standard YAML.
-
-For an explanation as to why these features are stripped
-out of StrictYAML, see the FAQ.
-
-Disallowed YAML features raise Disallowed exceptions
-while syntactically invalid YAML raises ScannerError
-or ComposerError.
-
-Every error inherits from YAMLError.
-
-
-
-
-```python
-from strictyaml import Map, Int, Any, load
-from strictyaml import TagTokenDisallowed, FlowMappingDisallowed, AnchorTokenDisallowed
-
-schema = Map({"x": Map({"a": Any(), "b": Any(), "c": Any()})})
-
-```
-
-
-
-Tag tokens:
-
-```yaml
-x:
-  a: !!str yes
-  b: !!str 3.5
-  c: !!str yes
-
-```
-
-
-```python
-load(yaml_snippet, schema, label="disallowed")
-```
-
-
-```python
-strictyaml.exceptions.TagTokenDisallowed:
-While scanning
-  in "disallowed", line 2, column 11:
-      a: !!str yes
-              ^ (line: 2)
-Found disallowed tag tokens (do not specify types in markup)
-  in "disallowed", line 2, column 6:
-      a: !!str yes
-         ^ (line: 2)
-```
-
-
-
-
-Flow style sequence:
-
-```yaml
-[a, b]: [x, y]
-
-```
-
-
-```python
-load(yaml_snippet, schema, label="disallowed")
-```
-
-
-```python
-strictyaml.exceptions.FlowMappingDisallowed:
-While scanning
-  in "disallowed", line 1, column 1:
-    [a, b]: [x, y]
-    ^ (line: 1)
-Found ugly disallowed JSONesque flow mapping (surround with ' and ' to make text appear literally)
-  in "disallowed", line 1, column 2:
-    [a, b]: [x, y]
-     ^ (line: 1)
-```
-
-
-
-
-Flow style mapping:
-
-```yaml
-x: { a: 1, b: 2, c: 3 }
-
-```
-
-
-```python
-load(yaml_snippet, schema, label="disallowed")
-```
-
-
-```python
-strictyaml.exceptions.FlowMappingDisallowed:
-While scanning
-  in "disallowed", line 1, column 4:
-    x: { a: 1, b: 2, c: 3 }
-       ^ (line: 1)
-Found ugly disallowed JSONesque flow mapping (surround with ' and ' to make text appear literally)
-  in "disallowed", line 1, column 5:
-    x: { a: 1, b: 2, c: 3 }
-        ^ (line: 1)
-```
-
-
-
-
-Node anchors and references:
-
-```yaml
-x: 
-  a: &node1 3.5
-  b: 1
-  c: *node1
-
-```
-
-
-```python
-load(yaml_snippet, schema, label="disallowed")
-```
-
-
-```python
-strictyaml.exceptions.AnchorTokenDisallowed:
-While scanning
-  in "disallowed", line 2, column 6:
-      a: &node1 3.5
-         ^ (line: 2)
-Found confusing disallowed anchor token (surround with ' and ' to make text appear literally)
-  in "disallowed", line 2, column 12:
-      a: &node1 3.5
-               ^ (line: 2)
-```
-
-
-
-
-Syntactically invalid YAML:
-
-```yaml
-- invalid
-string
-
-```
-
-
-```python
-load(yaml_snippet, schema, label="disallowed")
-```
-
-
-```python
-strictyaml.ruamel.scanner.ScannerError:
-while scanning a simple key
-  in "disallowed", line 2, column 1:
-    string
-    ^ (line: 2)
-could not find expected ':'
-  in "disallowed", line 3, column 1:
-    
-    ^ (line: 3)
-```
-
-
-
-
-Mixed space indentation:
-
-```yaml
-item:
-  two space indent: 2
-item two:
-    four space indent: 2
-
-```
-
-
-```python
-load(yaml_snippet, label="disallowed")
-```
-
-
-```python
-strictyaml.exceptions.InconsistentIndentationDisallowed:
-While parsing
-  in "disallowed", line 4, column 5:
-        four space indent: 2
-        ^ (line: 4)
-Found mapping with indentation inconsistent with previous mapping
-  in "disallowed", line 5, column 1:
-    
-    ^ (line: 5)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/disallow.story">disallow.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/restrictions/duplicate-keys.md b/docs/public/using/alpha/restrictions/duplicate-keys.md
deleted file mode 100644
index b34cf6c..0000000
--- a/docs/public/using/alpha/restrictions/duplicate-keys.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: Duplicate keys
-type: using
----
-
-
-Duplicate keys are allowed in regular YAML - as parsed by pyyaml, ruamel.yaml and poyo:
-
-Not only is it unclear whether x should be "cow" or "bull" (the parser will decide 'bull', but did you know that?),
-if there are 200 lines between x: cow and x: bull, a user might very likely change the *first* x and erroneously believe
-that the resulting value of x has been changed - when it has not.
-
-In order to avoid all possible confusion, StrictYAML will simply refuse to parse this and will only accept associative
-arrays where all of the keys are unique. It will throw a DuplicateKeysDisallowed exception.
-
-
-Example yaml_snippet:
-
-```yaml
-a: cow
-a: bull
-
-```
-
-
-```python
-from strictyaml import load, DuplicateKeysDisallowed
-
-```
-
-
-
-Nameless exception:
-
-
-```python
-load(yaml_snippet)
-```
-
-
-```python
-strictyaml.exceptions.DuplicateKeysDisallowed:
-While parsing
-  in "<unicode string>", line 2, column 1:
-    a: bull
-    ^ (line: 2)
-Duplicate key 'a' found
-  in "<unicode string>", line 2, column 2:
-    a: bull
-     ^ (line: 2)
-```
-
-
-
-
-Named exception:
-
-
-```python
-load(yaml_snippet, label="mylabel")
-```
-
-
-```python
-strictyaml.exceptions.DuplicateKeysDisallowed:
-While parsing
-  in "mylabel", line 2, column 1:
-    a: bull
-    ^ (line: 2)
-Duplicate key 'a' found
-  in "mylabel", line 2, column 2:
-    a: bull
-     ^ (line: 2)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/duplicatekeys.story">duplicatekeys.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/restrictions/index.md b/docs/public/using/alpha/restrictions/index.md
deleted file mode 100644
index 8af68fd..0000000
--- a/docs/public/using/alpha/restrictions/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Restrictions
----
-
-- [Disallowed YAML](disallowed-yaml)
-- [Duplicate keys](duplicate-keys)
-- [Dirty load](loading-dirty-yaml)
diff --git a/docs/public/using/alpha/restrictions/loading-dirty-yaml.md b/docs/public/using/alpha/restrictions/loading-dirty-yaml.md
deleted file mode 100644
index 3ef4966..0000000
--- a/docs/public/using/alpha/restrictions/loading-dirty-yaml.md
+++ /dev/null
@@ -1,48 +0,0 @@
----
-title: Dirty load
-type: using
----
-
-
-StrictYAML refuses to parse flow style and node anchors
-by default, but since there have since been
-[some requests](https://github.com/crdoconnor/strictyaml/issues/38)
-to parse flow style, this now allowed with the "dirty_load" method.
-If allow_flow_style is True, Map indentation is not checked for
-consistency, as the indentation level is dependent on the map key length.
-
-
-
-
-```python
-from strictyaml import Map, Int, MapPattern, Seq, Str, Any, dirty_load
-
-schema = Map({"foo": Map({"a": Any(), "b": Any(), "c": Any()}), "y": MapPattern(Str(), Str()), "z": Seq(Str())})
-
-```
-
-
-
-Flow style mapping:
-
-```yaml
-foo: { a: 1, b: 2, c: 3 }
-y: {}
-z: []
-
-```
-
-
-```python
-assert dirty_load(yaml_snippet, schema, allow_flow_style=True) == {"foo": {"a": "1", "b": "2", "c": "3"}, "y": {}, "z": []}
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/dirty-load.story">dirty-load.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/boolean.md b/docs/public/using/alpha/scalar/boolean.md
deleted file mode 100644
index 96909df..0000000
--- a/docs/public/using/alpha/scalar/boolean.md
+++ /dev/null
@@ -1,171 +0,0 @@
----
-title: Boolean (Bool)
-type: using
----
-
-
-Boolean values can be parsed using a Bool validator.
-
-It case-insensitively interprets "yes", "true", "1", "on" as "True", "y"
-and their opposites as False.
-
-Different values will trigger a validation error.
-
-When updating boolean values on a YAML object with True or False, the roundtripped
-string version is set to "yes" and "no".
-
-To have your boolean values updated to a different yes/no string, update
-with a string instead - e.g. "on" or "off".
-
-
-Example yaml_snippet:
-
-```yaml
-a: yes
-b: true
-c: on
-d: 1
-e: True
-f: Y
-
-u: n
-v: False
-w: 0
-x: Off
-y: FALSE
-z: no
-
-```
-
-
-```python
-from strictyaml import Bool, Str, MapPattern, load
-from ensure import Ensure
-
-schema = MapPattern(Str(), Bool())
-
-```
-
-
-
-Parse to YAML object:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({
-    "a": True, "b": True, "c": True, "d": True, "e": True, "f": True,
-    "u": False, "v": False, "w": False, "x": False, "y": False, "z": False,
-})
-
-```
-
-
-
-
-YAML object should resolve to True or False:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["w"]).equals(False)
-
-```
-
-
-
-
-Using .data you can get the actual boolean value parsed:
-
-
-```python
-assert load(yaml_snippet, schema)["a"].data is True
-
-```
-
-
-
-
-.text returns the text of the boolean YAML:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["y"].text).equals("FALSE")
-
-```
-
-
-
-
-Update boolean values with string and bool type:
-
-
-```python
-yaml = load(yaml_snippet, schema)
-yaml['a'] = 'no'
-yaml['b'] = False
-yaml['c'] = True
-print(yaml.as_yaml())
-
-```
-
-```yaml
-a: no
-b: no
-c: yes
-d: 1
-e: True
-f: Y
-
-u: n
-v: False
-w: 0
-x: Off
-y: FALSE
-z: no
-```
-
-
-
-
-Cannot cast boolean to string:
-
-
-```python
-str(load(yaml_snippet, schema)["y"])
-```
-
-
-```python
-builtins.TypeError:
-Cannot cast 'YAML(False)' to str.
-Use str(yamlobj.data) or str(yamlobj.text) instead.
-```
-
-
-
-
-Different uninterpretable values raise validation error:
-
-
-```python
-load('a: yâs', schema)
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a boolean value (one of "yes", "true", "on", "1", "y", "no", "false", "off", "0", "n")
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: "y\xE2s"
-     ^ (line: 1)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/boolean.story">boolean.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/comma-separated.md b/docs/public/using/alpha/scalar/comma-separated.md
deleted file mode 100644
index 16f4cf9..0000000
--- a/docs/public/using/alpha/scalar/comma-separated.md
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: Parsing comma separated items (CommaSeparated)
-type: using
----
-
-
-Comma-separated values can be validated and parsed
-using the CommaSeparated validator.
-
-Note that the space following the commas is stripped by
-default when parsed.
-
-
-
-
-```python
-from strictyaml import CommaSeparated, Int, Str, Map, load, as_document
-from ensure import Ensure
-
-int_schema = Map({"a": CommaSeparated(Int())})
-
-str_schema = Map({"a": CommaSeparated(Str())})
-
-```
-
-
-
-Parse as int:
-
-```yaml
-a: 1, 2, 3
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, int_schema)).equals({"a": [1, 2, 3]})
-
-```
-
-
-
-
-Parse as string:
-
-```yaml
-a: 1, 2, 3
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, str_schema)).equals({"a": ["1", "2", "3"]})
-
-```
-
-
-
-
-Parse empty comma separated string:
-
-```yaml
-a: 
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, str_schema)).equals({"a": []})
-
-```
-
-
-
-
-Invalid int comma separated sequence:
-
-```yaml
-a: 1, x, 3
-
-```
-
-
-```python
-load(yaml_snippet, int_schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an integer
-  in "<unicode string>", line 2, column 1:
-    
-    ^ (line: 2)
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: 1, x, 3
-     ^ (line: 1)
-```
-
-
-
-
-Serialize list to comma separated sequence:
-
-
-```python
-print(as_document({"a": [1, 2, 3]}, int_schema).as_yaml())
-
-```
-
-```yaml
-a: 1, 2, 3
-```
-
-
-
-
-Serialize valid string to comma separated sequence:
-
-
-```python
-print(as_document({"a": "1,2,3"}, int_schema).as_yaml())
-
-```
-
-```yaml
-a: 1,2,3
-```
-
-
-
-
-Serialize empty list to comma separated sequence:
-
-
-```python
-print(as_document({"a": []}, int_schema).as_yaml())
-
-```
-
-```yaml
-a:
-```
-
-
-
-
-Serialize invalid string to comma separated sequence:
-
-
-```python
-print(as_document({"a": "1,x,3"}, int_schema).as_yaml())
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-'x' not an integer.
-```
-
-
-
-
-Attempt to serialize neither list nor string raises exception:
-
-
-```python
-as_document({"a": 1}, int_schema)
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-expected string or list, got '1' of type 'int'
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/commaseparated.story">commaseparated.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/datetime.md b/docs/public/using/alpha/scalar/datetime.md
deleted file mode 100644
index d78a86f..0000000
--- a/docs/public/using/alpha/scalar/datetime.md
+++ /dev/null
@@ -1,168 +0,0 @@
----
-title: Datetimes (Datetime)
-type: using
----
-
-
-Datetime validator parses using the python-dateutil library and
-returns a python datetime object.
-
-
-Example yaml_snippet:
-
-```yaml
-date: 2016-10-22
-datetime1: 2016-10-22T14:23:12+00:00
-datetime2: 2016-10-22T14:23:12Z
-datetime3: 20161022T142312Z
-
-```
-
-
-```python
-from strictyaml import Map, Datetime, YAMLValidationError, load, as_document
-from collections import OrderedDict
-from dateutil.tz.tz import tzutc
-from datetime import datetime
-from ensure import Ensure
-
-schema = Map({
-    "date": Datetime(),
-    "datetime1": Datetime(),
-    "datetime2": Datetime(),
-    "datetime3": Datetime(),
-})
-
-equivalent_data = OrderedDict([
-    ("date", datetime(2016, 10, 22, 0, 0)),
-    ("datetime1", datetime(2016, 10, 22, 14, 23, 12, tzinfo=tzutc())),
-    ("datetime2", datetime(2016, 10, 22, 14, 23, 12, tzinfo=tzutc())),
-    ("datetime3", datetime(2016, 10, 22, 14, 23, 12, tzinfo=tzutc())),
-])
-
-```
-
-
-
-Each of the four datetimes are valid and parsed:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals(equivalent_data)
-
-```
-
-
-
-
-.text still returns the original text:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["date"].text).equals("2016-10-22")
-
-```
-
-
-
-
-Non datetimes raise an exception:
-
-```yaml
-date: 1
-datetime1: â
-datetime2: b
-datetime3: c
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a datetime
-found arbitrary text
-  in "<unicode string>", line 2, column 1:
-    datetime1: "\xE2"
-    ^ (line: 2)
-```
-
-
-
-
-Datetime objects serialize directly to ISO-8601 format YAML strings:
-
-
-```python
-print(as_document(equivalent_data, schema).as_yaml())
-
-```
-
-```yaml
-date: 2016-10-22T00:00:00
-datetime1: 2016-10-22T14:23:12+00:00
-datetime2: 2016-10-22T14:23:12+00:00
-datetime3: 2016-10-22T14:23:12+00:00
-```
-
-
-
-
-Valid datetime strings serialize to YAML:
-
-
-```python
-print(as_document({"a": "2016-10-22"}, Map({"a": Datetime()})).as_yaml())
-
-```
-
-```yaml
-a: 2016-10-22
-```
-
-
-
-
-Serializing invalid datetime string raises exception:
-
-
-```python
-as_document({"a": "x"}, Map({"a": Datetime()}))
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-expected a datetime, got 'x'
-```
-
-
-
-
-Serializing non-string and non-datetime object raises exception:
-
-
-```python
-as_document({"a": 55}, Map({"a": Datetime()}))
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-expected a datetime, got '55' of type 'int'
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/datetime.story">datetime.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/decimal.md b/docs/public/using/alpha/scalar/decimal.md
deleted file mode 100644
index f0a0d61..0000000
--- a/docs/public/using/alpha/scalar/decimal.md
+++ /dev/null
@@ -1,150 +0,0 @@
----
-title: Decimal numbers (Decimal)
-type: using
----
-
-
-StrictYAML parses to a YAML object representing
-a decimal, not the value directly to give you more
-flexibility and control over what you can do with the
-YAML.
-
-This is what that can object can do - in many
-cases if parsed as a decimal, it will behave in
-the same way.
-
-To get a python decimal.Decimal object, use .data.
-
-Parsing and validating as a Decimal is best for
-values which require precision, like prices.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1.00000000000000000001
-b: 5.4135
-
-```
-
-
-```python
-from strictyaml import Map, Decimal, load
-from decimal import Decimal as Dec
-from ensure import Ensure
-
-schema = Map({"a": Decimal(), "b": Decimal()})
-
-```
-
-
-
-.data to get Decimal object:
-
-
-```python
-Ensure(type(load(yaml_snippet, schema)["a"].data) is Dec).is_true()
-```
-
-
-
-
-Valid:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": Dec('1.00000000000000000001'), "b": Dec('5.4135')})
-
-```
-
-
-
-
-Cast to str:
-
-
-```python
-Ensure(str(load(yaml_snippet, schema)['a'])).equals("1.00000000000000000001")
-```
-
-
-
-
-Cast to float:
-
-
-```python
-Ensure(float(load(yaml_snippet, schema)["a"])).equals(1.0)
-```
-
-
-
-
-Greater than:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["a"] > Dec('1.0')).is_true()
-```
-
-
-
-
-Less than which would not work for float:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["a"] < Dec('1.00000000000000000002')).is_true()
-```
-
-
-
-
-Cannot cast to bool:
-
-
-```python
-bool(load(yaml_snippet, schema)['a'])
-```
-
-
-```python
-:
-Cannot cast 'YAML(1.00000000000000000001)' to bool.
-Use bool(yamlobj.data) or bool(yamlobj.text) instead.
-```
-
-
-
-
-Invalid:
-
-```yaml
-a: string
-b: 2
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a decimal
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: string
-     ^ (line: 1)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/decimal.story">decimal.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/email-and-url.md b/docs/public/using/alpha/scalar/email-and-url.md
deleted file mode 100644
index 0db5fdf..0000000
--- a/docs/public/using/alpha/scalar/email-and-url.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-title: Email and URL validators
-type: using
----
-
-
-StrictYAML can validate emails (using a simplified regex) and
-URLs.
-
-
-
-
-```python
-from strictyaml import Email, Url, Map, load
-from ensure import Ensure
-
-schema = Map({"a": Email(), "b": Url()})
-
-```
-
-
-
-Parsed:
-
-```yaml
-a: billg@microsoft.com
-b: http://www.twitter.com/@realDonaldTrump
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": "billg@microsoft.com", "b": "http://www.twitter.com/@realDonaldTrump"})
-
-```
-
-
-
-
-Exception:
-
-```yaml
-a: notanemail
-b: notaurl
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an email address
-found non-matching string
-  in "<unicode string>", line 1, column 1:
-    a: notanemail
-     ^ (line: 1)
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/email-url.story">email-url.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/empty.md b/docs/public/using/alpha/scalar/empty.md
deleted file mode 100644
index 5869bda..0000000
--- a/docs/public/using/alpha/scalar/empty.md
+++ /dev/null
@@ -1,185 +0,0 @@
----
-title: Empty key validation
-type: using
----
-
-
-Sometimes you may wish to not specify a value or specify
-that it does not exist.
-
-Using StrictYAML you can accept this as a valid value and
-have it parsed to one of three things - None, {} (empty dict),
-or [] (empty list).
-
-
-Example yaml_snippet:
-
-```yaml
-a:
-```
-
-
-```python
-from strictyaml import Map, Str, Enum, EmptyNone, EmptyDict, EmptyList, NullNone, load, as_document
-from ensure import Ensure
-
-```
-
-
-
-EmptyNone with empty value:
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": EmptyNone() | Enum(["A", "B",])}))).equals({"a": None})
-
-```
-
-
-
-
-EmptyDict:
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": EmptyDict() | Enum(["A", "B",])}))).equals({"a": {}})
-
-```
-
-
-
-
-EmptyList:
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": EmptyList() | Enum(["A", "B",])}))).equals({"a": []})
-
-```
-
-
-
-
-NullNone:
-
-
-```python
-Ensure(load("a: null", Map({"a": NullNone() | Enum(["A", "B",])}))).equals({"a": None})
-
-```
-
-
-
-
-EmptyNone no empty value:
-
-```yaml
-a: A
-```
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": EmptyNone() | Enum(["A", "B",])}))).equals({"a": "A"})
-
-```
-
-
-
-
-Combine Str with EmptyNone and Str is evaluated first:
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": Str() | EmptyNone()}))).equals({"a": ""})
-
-```
-
-
-
-
-Combine EmptyNone with Str and Str is evaluated last:
-
-
-```python
-Ensure(load(yaml_snippet, Map({"a": EmptyNone() | Str()}))).equals({"a": None})
-
-```
-
-
-
-
-Non-empty value:
-
-```yaml
-a: C
-```
-
-
-```python
-load(yaml_snippet, Map({"a": Enum(["A", "B",]) | EmptyNone()}))
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting an empty value
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: C
-     ^ (line: 1)
-```
-
-
-
-
-Serialize empty dict:
-
-
-```python
-print(as_document({"a": {}}, Map({"a": EmptyDict() | Str()})).as_yaml())
-
-```
-
-```yaml
-a:
-```
-
-
-
-
-Serialize empty list:
-
-
-```python
-print(as_document({"a": []}, Map({"a": EmptyList() | Str()})).as_yaml())
-
-```
-
-```yaml
-a:
-```
-
-
-
-
-Serialize None:
-
-
-```python
-print(as_document({"a": None}, Map({"a": EmptyNone() | Str()})).as_yaml())
-
-```
-
-```yaml
-a:
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/empty.story">empty.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/enum.md b/docs/public/using/alpha/scalar/enum.md
deleted file mode 100644
index f56acad..0000000
--- a/docs/public/using/alpha/scalar/enum.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: Enumerated scalars (Enum)
-type: using
----
-
-
-StrictYAML allows you to ensure that a scalar
-value can only be one of a set number of items.
-
-It will throw an exception if any strings not
-in the list are found.
-
-
-
-
-```python
-from strictyaml import Map, Enum, MapPattern, YAMLValidationError, load
-from collections import OrderedDict
-from ensure import Ensure
-
-schema = Map({"a": Enum(["A", "B", "C"])})
-
-```
-
-
-
-Valid because it contains 'A':
-
-```yaml
-a: A
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": "A"})
-
-```
-
-
-
-
-Get .data from enum:
-
-```yaml
-a: A
-```
-
-
-```python
-assert isinstance(load(yaml_snippet, schema)['a'].data, str)
-
-```
-
-
-
-
-Valid because it contains 'B':
-
-```yaml
-a: B
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": "B"})
-
-```
-
-
-
-
-Valid because it contains 'C':
-
-```yaml
-a: C
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": "C"})
-
-```
-
-
-
-
-Invalid because D is not in enum:
-
-```yaml
-a: D
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting one of: A, B, C
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: D
-     ^ (line: 1)
-```
-
-
-
-
-Invalid because blank string is not in enum:
-
-```yaml
-a:
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting one of: A, B, C
-found a blank string
-  in "<unicode string>", line 1, column 1:
-    a: ''
-     ^ (line: 1)
-```
-
-
-
-
-Successful serialization:
-
-```yaml
-a: A
-```
-
-
-```python
-yaml = load(yaml_snippet, schema)
-yaml['a'] = "B"
-print(yaml.as_yaml())
-
-```
-
-```yaml
-a: B
-```
-
-
-
-
-Invalid serialization:
-
-```yaml
-a: A
-```
-
-
-```python
-yaml = load(yaml_snippet, schema)
-yaml['a'] = "D"
-print(yaml.as_yaml())
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-Got 'D' when  expecting one of: A, B, C
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/enum.story">enum.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/float.md b/docs/public/using/alpha/scalar/float.md
deleted file mode 100644
index e666953..0000000
--- a/docs/public/using/alpha/scalar/float.md
+++ /dev/null
@@ -1,300 +0,0 @@
----
-title: Floating point numbers (Float)
-type: using
----
-
-
-StrictYAML parses to a YAML object representing
-a decimal - e.g. YAML(1.0000000000000001)
-
-To get a python float literal, use .data.
-
-Parsing and validating as a Decimal is best for
-values which require precision, but float is better
-for values for which precision is not required.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1.00000000000000000001
-b: 5.4135
-
-```
-
-
-```python
-from math import isnan, isinf
-
-from strictyaml import Map, MapPattern, Str, Float, Bool, load, as_document
-from collections import OrderedDict
-from ensure import Ensure
-
-schema = Map({"a": Float(), "b": Float()})
-
-```
-
-
-
-Use .data to get float type:
-
-
-```python
-Ensure(type(load(yaml_snippet, schema)["a"].data)).equals(float)
-
-```
-
-
-
-
-Equal to equivalent float which is different number:
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": 1.0, "b": 5.4135})
-
-```
-
-
-
-
-Cast to str:
-
-
-```python
-Ensure(str(load(yaml_snippet, schema)["a"])).equals("1.0")
-
-```
-
-
-
-
-Cast to float:
-
-
-```python
-Ensure(float(load(yaml_snippet, schema)["a"])).equals(1.0)
-
-```
-
-
-
-
-Greater than:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["a"] > 0).is_true()
-
-```
-
-
-
-
-Less than:
-
-
-```python
-Ensure(load(yaml_snippet, schema)["a"] < 0).is_false()
-
-```
-
-
-
-
-Has NaN values:
-
-```yaml
-a: nan
-b: .NaN
-
-```
-
-
-```python
-Ensure(isnan(load(yaml_snippet, schema)["a"].data)).is_true()
-Ensure(isnan(load(yaml_snippet, schema)["b"].data)).is_true()
-
-```
-
-
-
-
-Has infinity values:
-
-```yaml
-a: -.Inf
-b: INF
-
-```
-
-
-```python
-Ensure(isinf(load(yaml_snippet, schema)["a"].data)).is_true()
-Ensure(isinf(load(yaml_snippet, schema)["b"].data)).is_true()
-
-```
-
-
-
-
-Has underscores:
-
-```yaml
-a: 10_000_000.5
-b: 10_0_0.2_5
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals({"a": 10000000.5, "b": 1000.25})
-
-```
-
-
-
-
-Cannot cast to bool:
-
-
-```python
-bool(load(yaml_snippet, schema)['a'])
-```
-
-
-```python
-:
-Cannot cast 'YAML(1.0)' to bool.
-Use bool(yamlobj.data) or bool(yamlobj.text) instead.
-```
-
-
-
-
-Cannot parse non-float:
-
-```yaml
-a: string
-b: 2
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting a float
-found arbitrary text
-  in "<unicode string>", line 1, column 1:
-    a: string
-     ^ (line: 1)
-```
-
-
-
-
-Serialize successfully:
-
-
-```python
-print(as_document(OrderedDict([("a", 3.5), ("b", "2.1")]), schema).as_yaml())
-```
-
-```yaml
-a: 3.5
-b: 2.1
-```
-
-
-
-
-Serialize successfully with NaN:
-
-
-```python
-print(as_document(OrderedDict([("a", 3.5), ("b", float("nan"))]), schema).as_yaml())
-```
-
-```yaml
-a: 3.5
-b: nan
-```
-
-
-
-
-Serialize successfully with infinity:
-
-
-```python
-print(as_document(OrderedDict([("a", float("inf")), ("b", float("-inf"))]), schema).as_yaml())
-```
-
-```yaml
-a: inf
-b: -inf
-```
-
-
-
-
-Serialization failure:
-
-
-```python
-as_document(OrderedDict([("a", "x"), ("b", "2.1")]), schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-when expecting a float, got 'x'
-```
-
-
-
-
-Float as key:
-
-
-```python
-document = as_document(OrderedDict([("3.5", "a"), ("2.1", "c")]), MapPattern(Float(), Str()))
-print(document.data[3.5])
-print(document.data[2.1])
-
-```
-
-```yaml
-a
-c
-```
-
-
-
-
-Float or bool:
-
-
-```python
-document = as_document({"a": True}, Map({"a": Float() | Bool()}))
-print(document.as_yaml())
-
-```
-
-```yaml
-a: yes
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/float.story">float.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/hexadecimal-integer.md b/docs/public/using/alpha/scalar/hexadecimal-integer.md
deleted file mode 100644
index 217e74f..0000000
--- a/docs/public/using/alpha/scalar/hexadecimal-integer.md
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: Hexadecimal Integers (HexInt)
-type: using
----
-
-
-StrictYAML can interpret a hexadecimal integer
-preserving its value 
-
-
-Example yaml_snippet:
-
-```yaml
-x: 0x1a
-
-```
-
-
-```python
-from strictyaml import Map, HexInt, load
-from ensure import Ensure
-
-schema = Map({"x": HexInt()})
-
-parsed = load(yaml_snippet, schema)
-
-```
-
-
-
-Parsed correctly:
-
-
-```python
-Ensure(parsed).equals({"x": 26})
-Ensure(parsed.as_yaml()).equals("x: 0x1a\n")
-
-```
-
-
-
-
-Uppercase:
-
-```yaml
-x: 0X1A
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals({"x": 26})
-Ensure(load(yaml_snippet, schema).as_yaml()).equals("x: 0X1A\n")
-
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/scalar-hexadecimal-integer.story">scalar-hexadecimal-integer.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/index.md b/docs/public/using/alpha/scalar/index.md
deleted file mode 100644
index 8315a82..0000000
--- a/docs/public/using/alpha/scalar/index.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Scalar StrictYAML Validators
----
-
-- [Boolean (Bool)](boolean)
-- [Parsing comma separated items (CommaSeparated)](comma-separated)
-- [Datetimes (Datetime)](datetime)
-- [Decimal numbers (Decimal)](decimal)
-- [Email and URL validators](email-and-url)
-- [Empty key validation](empty)
-- [Enumerated scalars (Enum)](enum)
-- [Floating point numbers (Float)](float)
-- [Hexadecimal Integers (HexInt)](hexadecimal-integer)
-- [Integers (Int)](integer)
-- [Validating strings with regexes (Regex)](regular-expressions)
-- [Parsing strings (Str)](string)
diff --git a/docs/public/using/alpha/scalar/integer.md b/docs/public/using/alpha/scalar/integer.md
deleted file mode 100644
index 6f6e9fe..0000000
--- a/docs/public/using/alpha/scalar/integer.md
+++ /dev/null
@@ -1,136 +0,0 @@
----
-title: Integers (Int)
-type: using
----
-
-
-StrictYAML parses to a YAML object, not
-the value directly to give you more flexibility
-and control over what you can do with the YAML.
-
-This is what that can object can do - in many
-cases if parsed as a integer, it will behave in
-the same way.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1
-b: 5
-
-```
-
-
-```python
-from strictyaml import Map, Int, load
-from ensure import Ensure
-
-schema = Map({"a": Int(), "b": Int()})
-
-parsed = load(yaml_snippet, schema)
-
-```
-
-
-
-Parsed correctly:
-
-
-```python
-Ensure(parsed).equals({"a": 1, "b": 5})
-
-```
-
-
-
-
-Has underscores:
-
-```yaml
-a: 10_000_000
-b: 10_0_0
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema).data).equals({"a": 10000000, "b": 1000})
-
-```
-
-
-
-
-Cast with str:
-
-
-```python
-Ensure(str(parsed["a"])).equals("1")
-```
-
-
-
-
-Cast with float:
-
-
-```python
-Ensure(float(parsed["a"])).equals(1.0)
-```
-
-
-
-
-Greater than:
-
-
-```python
-Ensure(parsed["a"] > 0).equals(True)
-```
-
-
-
-
-Less than:
-
-
-```python
-Ensure(parsed["a"] < 2).equals(True)
-```
-
-
-
-
-To get actual int, use .data:
-
-
-```python
-Ensure(type(load(yaml_snippet, schema)["a"].data) is int).equals(True)
-```
-
-
-
-
-Cannot cast to bool:
-
-
-```python
-bool(load(yaml_snippet, schema)['a'])
-```
-
-
-```python
-:
-Cannot cast 'YAML(1)' to bool.
-Use bool(yamlobj.data) or bool(yamlobj.text) instead.
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/scalar-integer.story">scalar-integer.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/regular-expressions.md b/docs/public/using/alpha/scalar/regular-expressions.md
deleted file mode 100644
index f200dce..0000000
--- a/docs/public/using/alpha/scalar/regular-expressions.md
+++ /dev/null
@@ -1,148 +0,0 @@
----
-title: Validating strings with regexes (Regex)
-type: using
----
-
-
-StrictYAML can validate regular expressions and return a
-string. If the regular expression does not match, an
-exception is raised.
-
-
-
-
-```python
-from strictyaml import Regex, Map, load, as_document
-from collections import OrderedDict
-from ensure import Ensure
-
-schema = Map({"a": Regex(u"[1-4]"), "b": Regex(u"[5-9]")})
-
-```
-
-
-
-Parsed correctly:
-
-```yaml
-a: 1
-b: 5
-
-```
-
-
-```python
-Ensure(load(yaml_snippet, schema)).equals({"a": "1", "b": "5"})
-
-```
-
-
-
-
-Non-matching:
-
-```yaml
-a: 5
-b: 5
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting string matching [1-4]
-found non-matching string
-  in "<unicode string>", line 1, column 1:
-    a: '5'
-     ^ (line: 1)
-```
-
-
-
-
-Non-matching suffix:
-
-```yaml
-a: 1 Hello
-b: 5
-
-```
-
-
-```python
-load(yaml_snippet, schema)
-```
-
-
-```python
-strictyaml.exceptions.YAMLValidationError:
-when expecting string matching [1-4]
-found non-matching string
-  in "<unicode string>", line 1, column 1:
-    a: 1 Hello
-     ^ (line: 1)
-```
-
-
-
-
-Serialized successfully:
-
-
-```python
-print(as_document(OrderedDict([("a", "1"), ("b", "5")]), schema).as_yaml())
-
-```
-
-```yaml
-a: 1
-b: 5
-```
-
-
-
-
-Serialization failure non matching regex:
-
-
-```python
-as_document(OrderedDict([("a", "x"), ("b", "5")]), schema)
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-when expecting string matching [1-4] found 'x'
-```
-
-
-
-
-Serialization failure not a string:
-
-
-```python
-as_document(OrderedDict([("a", 1), ("b", "5")]), schema)
-
-```
-
-
-```python
-strictyaml.exceptions.YAMLSerializationError:
-when expecting string matching [1-4] got '1' of type int.
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/regexp.story">regexp.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/alpha/scalar/string.md b/docs/public/using/alpha/scalar/string.md
deleted file mode 100644
index 5cbc602..0000000
--- a/docs/public/using/alpha/scalar/string.md
+++ /dev/null
@@ -1,95 +0,0 @@
----
-title: Parsing strings (Str)
-type: using
----
-
-
-StrictYAML parses to a YAML object, not
-the value directly to give you more flexibility
-and control over what you can do with the YAML.
-
-This is what that can object can do - in most
-cases if parsed as a string, it will behave in
-the same way.
-
-
-Example yaml_snippet:
-
-```yaml
-a: 1
-b: yes
-c: â string
-d: |
-  multiline string
-
-```
-
-
-```python
-from strictyaml import Str, Map, load
-from ensure import Ensure
-
-schema = Map({"a": Str(), "b": Str(), "c": Str(), "d": Str()})
-
-parsed = load(yaml_snippet, schema)
-
-```
-
-
-
-Parses correctly:
-
-
-```python
-Ensure(parsed).equals(
-    {"a": "1", "b": "yes", "c": u"â string", "d": "multiline string\n"}
-)
-
-```
-
-
-
-
-Dict lookup cast to string:
-
-
-```python
-Ensure(str(parsed["a"])).equals("1")
-```
-
-
-
-
-Dict lookup cast to int:
-
-
-```python
-Ensure(int(parsed["a"])).equals(1)
-
-```
-
-
-
-
-Dict lookup cast to bool impossible:
-
-
-```python
-bool(parsed["a"])
-```
-
-
-```python
-:
-Cannot cast 'YAML(1)' to bool.
-Use bool(yamlobj.data) or bool(yamlobj.text) instead.
-```
-
-
-
-
-
-
-{{< note title="Executable specification" >}}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/scalar-string.story">scalar-string.story</a>.
-{{< /note >}}
\ No newline at end of file
diff --git a/docs/public/using/index.md b/docs/public/using/index.md
deleted file mode 100644
index e94ed08..0000000
--- a/docs/public/using/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
----
-title: Using StrictYAML
----
-
-How to:
-
-- [Build a YAML document from scratch in code](alpha/howto/build-yaml-document)
-- [Either/or schema validation of different, equally valid different kinds of YAML](alpha/howto/either-or-validation)
-- [Labeling exceptions](alpha/howto/label-exceptions)
-- [Merge YAML documents](alpha/howto/merge-yaml-documents)
-- [Revalidate an already validated document](alpha/howto/revalidation)
-- [Reading in YAML, editing it and writing it back out](alpha/howto/roundtripping)
-- [Get line numbers of YAML elements](alpha/howto/what-line)
-- [Parsing YAML without a schema](alpha/howto/without-a-schema)
-
-
-Compound validators:
-
-- [Fixed length sequences (FixedSeq)](alpha/compound/fixed-length-sequences)
-- [Mappings combining defined and undefined keys (MapCombined)](alpha/compound/map-combined)
-- [Mappings with arbitrary key names (MapPattern)](alpha/compound/map-pattern)
-- [Mapping with defined keys and a custom key validator (Map)](alpha/compound/mapping-with-slug-keys)
-- [Using a YAML object of a parsed mapping](alpha/compound/mapping-yaml-object)
-- [Mappings with defined keys (Map)](alpha/compound/mapping)
-- [Optional keys with defaults (Map/Optional)](alpha/compound/optional-keys-with-defaults)
-- [Validating optional keys in mappings (Map)](alpha/compound/optional-keys)
-- [Sequences of unique items (UniqueSeq)](alpha/compound/sequences-of-unique-items)
-- [Sequence/list validator (Seq)](alpha/compound/sequences)
-- [Updating document with a schema](alpha/compound/update)
-
-
-Scalar validators:
-
-- [Boolean (Bool)](alpha/scalar/boolean)
-- [Parsing comma separated items (CommaSeparated)](alpha/scalar/comma-separated)
-- [Datetimes (Datetime)](alpha/scalar/datetime)
-- [Decimal numbers (Decimal)](alpha/scalar/decimal)
-- [Email and URL validators](alpha/scalar/email-and-url)
-- [Empty key validation](alpha/scalar/empty)
-- [Enumerated scalars (Enum)](alpha/scalar/enum)
-- [Floating point numbers (Float)](alpha/scalar/float)
-- [Hexadecimal Integers (HexInt)](alpha/scalar/hexadecimal-integer)
-- [Integers (Int)](alpha/scalar/integer)
-- [Validating strings with regexes (Regex)](alpha/scalar/regular-expressions)
-- [Parsing strings (Str)](alpha/scalar/string)
-
-Restrictions:
-
-- [Disallowed YAML](alpha/restrictions/disallowed-yaml)
-- [Duplicate keys](alpha/restrictions/duplicate-keys)
-- [Dirty load](alpha/restrictions/loading-dirty-yaml)
diff --git a/docs/public/what-is-yaml.md b/docs/public/what-is-yaml.md
deleted file mode 100644
index f784a14..0000000
--- a/docs/public/what-is-yaml.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: What is YAML?
----
-
-YAML is a simple, human readable format for representing associative and hierarchical data.
-
-Example from wikipedia page on YAML:
-
-```yaml
-receipt: Oz-Ware Purchase Invoice
-date: 2012-08-06
-customer:
-  first name: Harry
-  family name: Potter
-address: |-
-  4 Privet Drive,
-  Little Whinging,
-  England
-items:
-- part_no: A4786
-  description: Water Bucket (Filled)
-  price: 1.47
-  quantity:  4
-
-- part_no: E1628
-  description: High Heeled "Ruby" Slippers
-  size: 8
-  price: 133.7
-  quantity: 1
-```
-
-Key features:
-
-- Things which are associated with other things - delimited by the colon (:).
-- Ordered lists of things - delimited by the prepended dash (-).
-- Multi-line strings - delimited by the bar (|) if there is another newline at the end of the string, or bar + dash (|-) if not.
-- Indentation describing the hierarchy of data.
-- Maps directly to data types common to most high level languages - lists, dicts, scalars.
-
-You don't need to know much more than this.
diff --git a/docs/public/when-to-use-validators.md b/docs/public/when-to-use-validators.md
deleted file mode 100644
index 438080f..0000000
--- a/docs/public/when-to-use-validators.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: When should I use a validator and when should I not?
----
-
-When starting out on greenfield projects it's much quicker not to create a validator. In such cases it's often more prudent to just parse the YAML and convert the strings explicitly on the fly (e.g. int(yaml['key'])).
-
-If the YAML is also going to be largely under the control of the developer it also might not make sense to write a validator either.
-
-If you have written software that is going to parse YAML from a source you do *not* control - especially by somebody who might make a mistake - then it probably does make sense to write a validator.
-
-You can start off without using a validator and then add one later.
diff --git a/docs/public/why-not/environment-variables-as-config.md b/docs/public/why-not/environment-variables-as-config.md
deleted file mode 100644
index 29ebc18..0000000
--- a/docs/public/why-not/environment-variables-as-config.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: Why avoid using environment variables as configuration?
----
-
-The use of "environment variables as configuration" is recommended by
-"[12 factor](https://12factor.net/config)". While this is a common
-practice and often leads to few or no problems, calling it a best
-practice is a bit much.
-
-The reason cited by the 12 factor website for using them is:
-
->The twelve-factor app stores config in environment variables (often shortened to env vars or env). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such as Java System Properties, they are a language- and OS-agnostic standard.
-
-Two of these are fine reasons. It is true that these are both good reasons:
-
-- Easy to change between deploys.
-- Language and OS agnostic.
-
-However, neither of these things requires that config be stored in environment variables.
-It's easy enough to create language and OS agnostic configuration files
-(INI, YAML, etc.) and it's usually straightforward to make files easy to change
-between deployments too - e.g. if a deployment is containerized, by mounting the file.
-
-It is less true that environment variables are inherently "easier" to change between
-deployments - writing a file is not intrinsically difficult unless it is *made*
-difficult (e.g. a file is baked in to a container image rather than being mounted), it
-isn't hard to change.
-
-Moreover, there are several disadvantages to using environment variables
-that tend to exhibit themselves nastily when the size of the configuration grows beyond
-a certain point.
-
-
-## Environment variables are global state
-
-Environment variables are a form of global state. Every variable
-is associated only with the environment. The variables will be shared with many
-other variables which have a multitude of different uses:
-
-- The chances of variable cross contamination is high - accidentally naming one variable the same as another which is unknowingly used for a different purpose (e.g. PATH) is elevated, and this can have both weird, hard to debug and terrible effects.
-- If you need to inspect environment variables e.g. to find one that you thought was there and it actually missing, tracking it down is a pain.
-
-Global state in and of itself isn't a "bad thing" but *too much* global
-state is a very bad thing. A small amount of configuration (e.g. less than
-10 variables) can often be placed in to environment variables with very
-little harm, but as soon as the amount grows the danger of the global
-state grows.
-
-
-## Environment variable values cannot handle structures more complex than a string
-
-Environment variables are a set of key-value pairs where the key is almost always an
-uppercase string and the value is always a string.
-
-While this is more than sufficient for many purposes, there are many kinds of situations
-where the configuration data that needs to be stored requires something a bit more
-complicated than just a string.
-
-Where developers run in to this limitation they have a tendency to create an ugly substructure with
-cryptic codes within the string.
-
-The way that LS_COLORS is used is a good example:
-
-```
-rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.wim=01;31:*.swm=01;31:*.dwm=01;31:*.esd=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:
-```
-
-Clear as mud, right?
-
-(This isn't actually an example of 12 factor being followed assiduously, but I have seen many examples
-just like it where it was).
-
-In [StrictYAML](https://hitchdev.com/strictyaml) the following could be represented as:
-
-```yaml
-# Special
-
-di: 01;34      # directory is blue
-
-# Extensions
-
-*.tz: 01;31    # red
-*.flv: 01;35   # purple
-```
-
-While the codes are cryptic and probably should be changed (e.g. directory: blue), the cryptic nature
-can at least be easily explained with comments.
-
-
-## Creating naming conventions to handle the inability to handle
-
-A common example:
-
->PERSONNEL_DATABASE_HOST, PERSONNEL_DATABASE_PORT, PERSONNEL_DATABASE_NAME, PERSONNEL_DATABASE_PASSWORD, FACTORY_DATABASE_HOST, FACTORY_DATABASE_PORT, FACTORY_DATABASE_NAME, FACTORY_DATABASE_PASSWORD,
-HOTEL_BACKUP_DATABASE_HOST, HOTEL_BACKUP_DATABASE_USERNAME, HOTEL_BACKUP_DATABASE_PASSWORD, HOTEL_DATABASE_HOST, HOTEL_DATABASE_PORT, HOTEL_DATABASE_NAME, HOTEL_DATABASE_PASSWORD
-
-Did you spot the accidentally missed variable in the list above which caused the critical bug?
-
-[StrictYAML](https://hitchdev.com/strictyaml) version:
-
-```yaml
-database:
-  personnel:
-    host: xxx
-    port: xxx
-    name: xxx
-    password: xxx
-
-  factory:
-    host: xxx
-    port: xxx
-    name: xxx
-    password: xxx
-
-  hotel backup:
-    host: xxx
-    name: xxx
-    password: xxx
-
-  hotel:
-    host: xxx
-    name: xxx
-    port: xxx
-    password: xxx
-```
-
-What about now?
diff --git a/docs/public/why-not/hjson.md b/docs/public/why-not/hjson.md
deleted file mode 100644
index f7f346c..0000000
--- a/docs/public/why-not/hjson.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Why not use HJSON?
----
-
-{{< note title="No longer supported" >}}
-HJSON is no longer supported.
-{{< /note >}}
-
-[HJSON](http://hjson.org/) is an attempt at fixing the aforementioned lack of readability of JSON.
-
-It has the following criticisms of YAML:
-
-- JSON is easier to explain (compare the JSON and YAML specs).
-
-- JSON is not bloated (it does not have anchors, substitutions or concatenation).
-
-As with TOML's criticism, these are spot on. However, strictyaml fixes this by *cutting out those parts of the spec*, leaving something that is actually simpler than HJSON.
-
-It has another criticism:
-
-- JSON does not suffer from significant whitespace.
-
-This is not a valid criticism.
-
-Whitespace and indentation is meaningful to people parsing any kind of code and markup (why else would code which *doesn't* have meaningful whitespace use indentation as well?) so it *should* be meaningful to computers parsing.
-
-There is an initial 'usability hump' for first time users of languages which have significant whitespace *that were previously not used to significant whitespace* but this isn't especially hard to overcome - especially if you have a propery configured decent editor which is explicit about the use of whitespace.
-
-Python users often report this being a problem, but after using the language for a while usually come to prefer it since it keeps the code shorter and makes its intent clearer.
diff --git a/docs/public/why-not/hocon.md b/docs/public/why-not/hocon.md
deleted file mode 100644
index c0ad88a..0000000
--- a/docs/public/why-not/hocon.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Why not HOCON?
----
-
-[HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md) is another "redesigned" JSON, ironically enough, taking JSON and making it even more complicated.
-
-Along with JSON's [syntax typing](../../why/syntax-typing-bad) - a downside of most non-YAML alternatives, HOCON makes the following mistakes in its design:
-
-- It does not fail loudly on duplicate keys.
-- It has a confusing rules for deciding on concatenations and substitutions.
-- It has a mechanism for substitutions similar to [YAML's node anchor feature](../why/node-anchors-and-references-removed.md) - which, unless used extremely sparingly, can create confusing markup that, ironically, is *not* human optimized.
-
-In addition, its attempt at using "less pedantic" syntax creates a system of rules which makes the behavior of the parser much less obvious and edge cases more frequent.
diff --git a/docs/public/why-not/index.md b/docs/public/why-not/index.md
deleted file mode 100644
index 4fddd65..0000000
--- a/docs/public/why-not/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Why not X?
----
-
-There are a number of formats and approaches that can achieve more or
-less the same purpose as StrictYAML. Below is a series of comparisons
-with some of the more famous ones:
-
-- [Why avoid using environment variables as configuration?](environment-variables-as-config)
-- [Why not use HJSON?](hjson)
-- [Why not HOCON?](hocon)
-- [Why not use INI files?](ini)
-- [Why not use JSON Schema for validation?](json-schema)
-- [Why not JSON for simple configuration files?](json)
-- [Why not JSON5?](json5)
-- [Why not use the YAML 1.2 standard? - we don't need a new standard!](ordinary-yaml)
-- [Why not use kwalify with standard YAML to validate my YAML?](pykwalify)
-- [Why not use Python's schema library (or similar) for validation?](python-schema)
-- [Why not use SDLang?](sdlang)
-- [What is wrong with TOML?](toml)
-- [Why shouldn't I just use Python code for configuration?](turing-complete-code)
-- [Why not use XML for configuration or DSLs?](xml)
-
-
-If you'd like to write or link to a rebuttal to any argument raised
-here, feel free to raise a ticket.
\ No newline at end of file
diff --git a/docs/public/why-not/ini.md b/docs/public/why-not/ini.md
deleted file mode 100644
index ba2c97a..0000000
--- a/docs/public/why-not/ini.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Why not use INI files?
----
-
-INI is a very old and quite readable configuration format for small configuration files.
-It is still used by many programs today and it has some advantages due to this - e.g.
-python has inbuilt parser for it.
-
-Unfortunately it suffers from two major problems:
-
-- Different parsers will operate in subtly different ways that can lead to often obscure edge case bugs regarding the way whitespace is used, case sensitivity, comments and escape characters.
-- It doesn't let you represent hierarchical data.
-
-[TOML](../toml) is a configuration format designed to address these two concerns,
-although it also suffers from obscure edge case bugs.
diff --git a/docs/public/why-not/json-schema.md b/docs/public/why-not/json-schema.md
deleted file mode 100644
index 46b2b1e..0000000
--- a/docs/public/why-not/json-schema.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Why not use JSON Schema for validation?
----
-
-JSON schema can also be used to validate YAML. This presumes that
-you might want to use jsonschema and pyyaml/ruamel.yaml together.
-
-[ TODO Flesh out ]
-
-- Line numbers
-- Simpler errors in StrictYAML
-- StrictYAML is a more flexible schema
-- Turing incompleteness / inflexibility
diff --git a/docs/public/why-not/json.md b/docs/public/why-not/json.md
deleted file mode 100644
index a0cc6e4..0000000
--- a/docs/public/why-not/json.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Why not JSON for simple configuration files?
----
-
-JSON is an *ideal* format for REST APIs and other forms of data intended for machine exchange and it probably always will be because:
-
-- It's a simple spec.
-- It has all the basic types which map on to all programming languages - number, string, list, mapping, boolean *and no more*.
-- Its syntax contains a built in level of error detection - cut a JSON request in half and it is no longer still valid, eliminating an entire class of obscure and problematic bugs.
-- If pretty-printed correctly, it's more or less readable - for the purposes of debugging, anyway.
-
-However, while it is eminently suitable for REST APIs it is less suitable for configuration since:
-
-- The same syntax which gives it decent error detection (commas, curly brackets) makes it tricky for humans to edit.
-- It's not especially readable.
-- It doesn't allow comments.
diff --git a/docs/public/why-not/json5.md b/docs/public/why-not/json5.md
deleted file mode 100644
index 54591df..0000000
--- a/docs/public/why-not/json5.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Why not JSON5?
----
-
-[JSON5](http://json5.org/) is also a proposed extension to JSON to make it more readable.
-
-Its main criticism of YAML is::
-
-  There are other formats that are human-friendlier, like YAML, but changing from JSON to a completely different format is undesirable in many cases.
-
-This is, I believe, mistaken. It is better if a language is not subtly different if you are going to use it as such. Subtle differences invite mistakes brought on by confusion.
-
-JSON5 looks like a hybrid of YAML and JSON::
-
-```json
-{
-    foo: 'bar',
-    while: true,
-}
-```
-
-It has weaknesses similar to TOML:
-
-- The noisiness of the delimiters that supplant significant whitespace make it less readable and editable.
-- The use of [syntax typing](../../why/syntax-typing-bad) is neither necessary, nor an aid to stricter typing if you have a schema.
diff --git a/docs/public/why-not/ordinary-yaml.md b/docs/public/why-not/ordinary-yaml.md
deleted file mode 100644
index c55a369..0000000
--- a/docs/public/why-not/ordinary-yaml.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Why not use the YAML 1.2 standard? - we don't need a new standard!
----
-
-![Standards](https://imgs.xkcd.com/comics/standards.png "Fortunately the configuration one has been solved now that we have Strict uh... wait, no it hasn't...")
-
-StrictYAML is composed of two parts:
-
-- A new YAML specification which parses a restricted subset of the [YAML 1.2 specification](https://github.com/yaml/yaml-spec/tree/spec-1.2)
-  and *only* parses to ordered dict, list or string.
-- An optional validator (which will, as requested, validate and cast parse some of those scalar string values to ints, floats, datetimes, etc.).
-
-Note that StrictYAML is *not* a new standard. If you have a syntax highlighter or editor or anything else that recognizes
-or reads YAML it will recognize StrictYAML in the same way.
-
-While not all YAML output by other programs will be readable by StrictYAML (it is, after all, stricter), a lot will be.
-
-The features removed from the YAML spec, and their rationales are as follows:
-
-- [Implicit Typing](../../why/implicit-typing-removed)
-- [Direct representations of objects](../../why/not-parse-direct-representations-of-python-objects)
-- [Explicit tags](../../why/explicit-tags-removed)
-- [Node anchors and refs](../../why/node-anchors-and-references-removed)
-- [Flow style](../../why/flow-style-removed)
-- [Duplicate Keys Disallowed](../../why/duplicate-keys-disallowed)
-
diff --git a/docs/public/why-not/pykwalify.md b/docs/public/why-not/pykwalify.md
deleted file mode 100644
index 1f2acb9..0000000
--- a/docs/public/why-not/pykwalify.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Why not use kwalify with standard YAML to validate my YAML?
----
-
-Kwalify is a schema validation language that is written *in* YAML.
-
-It is a descriptive schema language suitable for validating simple YAML.
-
-Kwalify compiles to the strictyaml equivalent but is able to do less. You cannot, for example:
-
-- Plug generated lists that come from outside of the spec (e.g. a list of country code from pycountry).
-- Validate parts of the schema which can be either one thing *or* another - e.g. a list *or* a single string.
-- Plug sub-validators of a document into larger validators.
-
-If your schema is very simple and small, there is no point to using kwalify.
-
-If your schema needs to be shared with a 3rd party - especially a third party using another language, it may be helpful to use it.
-
-If your schema validation requirements are more complicated - e.g. like what is described above - it's best *not* to use it.
diff --git a/docs/public/why-not/python-schema.md b/docs/public/why-not/python-schema.md
deleted file mode 100644
index 985f8fd..0000000
--- a/docs/public/why-not/python-schema.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Why not use Python's schema library (or similar) for validation?
----
-
-Python's 'schema' (as well as similar libraries) can also be used to validate
-the structure of objects. Validating YAML is even [cited as a reason on their
-README](https://github.com/keleshev/schema).
-
-Using a schema for validation requires running the YAML through a parser
-first which and then taking the output (usually a data structure like a dict)
-and passing it through the schema.
-
-Unfortunately there are a number of problems with this approach:
-
-
-## You still have [the Norway Problem](../../why/implicit-typing-removed)
-
-If the standard YAML parser parses 'NO' as false or [empty string as
-None](https://github.com/Grokzen/pykwalify/issues/77) then it doesn't
-really matter if the schema says an empty string or the text 'NO' is
-okay, it will be seeing a 'None' or a 'False' which will cause a failure.
-
-
-## You can't get line numbers and snippets for the validation errors
-
-Assuming you've successfully circumvented the Norway problem, parsing
-and feeding the output to schema is still problematic. If you pass a
-parsed dict to schema, schema can't tell which line number the failure
-happened on and can't give you a code snippet highlighting where it
-happened.
-
-
-## Roundtripping becomes very very difficult if not impossible
-
-Due to the loss of metadata about parsed YAML being lost when it
-is fed into a generic schema validator, it also becomes impossible to
-to *change* the data and serialize it without losing critical
-details (i.e. mapping ordering, comments or validation structures).
diff --git a/docs/public/why-not/sdlang.md b/docs/public/why-not/sdlang.md
deleted file mode 100644
index db47d45..0000000
--- a/docs/public/why-not/sdlang.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: Why not use SDLang?
----
-
-[SDLang](http://sdlang.org/) or "simple declarative language" is a proposed configuration language with an XML-like structure inspired by C.
-
-Example:
-
-```
-// This is a node with a single string value
-title "Hello, World"
-
-// Multiple values are supported, too
-bookmarks 12 15 188 1234
-
-// Nodes can have attributes
-author "Peter Parker" email="peter@example.org" active=true
-
-// Nodes can be arbitrarily nested
-contents {
-    section "First section" {
-        paragraph "This is the first paragraph"
-        paragraph "This is the second paragraph"
-    }
-}
-
-// Anonymous nodes are supported
-"This text is the value of an anonymous node!"
-
-// This makes things like matrix definitions very convenient
-matrix {
-    1 0 0
-    0 1 0
-    0 0 1
-}
-```
-
-Advantages:
-
-- Relatively more straightforward than other serialization languages.
-
-Disadvantages:
-
-- Syntax typing - leading to noisy syntax.
-- The distinction between properties and values is not entirely clear.
-- Instead of having one obvious way to describe property:value mappings
-- Niche
diff --git a/docs/public/why-not/toml-indentation-1.png b/docs/public/why-not/toml-indentation-1.png
deleted file mode 100644
index 531a2b1..0000000
Binary files a/docs/public/why-not/toml-indentation-1.png and /dev/null differ
diff --git a/docs/public/why-not/toml.md b/docs/public/why-not/toml.md
deleted file mode 100644
index 982c947..0000000
--- a/docs/public/why-not/toml.md
+++ /dev/null
@@ -1,170 +0,0 @@
----
-title: What is wrong with TOML?
----
-
-```yaml
-# This is a TOML document.
-
-title = "TOML Example"
-
-[owner]
-name = "Tom Preston-Werner"
-dob = 1979-05-27T07:32:00-08:00 # First class dates
-```
-
-[TOML](https://github.com/toml-lang/toml) is a configuration designed as a sort
-of "improved" [INI file](../ini). It's analogous to this project -
-[StrictYAML](https://github.com/crdoconnor/strictyaml), a similar attempt
-to [fix YAML's flaws](../../features-removed):
-
-```yaml
-# All about the character
-name: Ford Prefect
-age: 42
-possessions:
-- Towel
-```
-
-I'm not going to argue here that TOML is the *worst* file format out there -
-if you use it infrequently on small and simple files it does its job fine.
-
-It's a warning though: as you scale up its usage, many bad warts start to appear.
-
-Martin Vejnár, the author of PyTOML
-[argued exactly this](https://github.com/avakar/pytoml/issues/15#issuecomment-217739462).
-He initially built a TOML parser out of enthusiasm for this new format but later abandoned
-it. When asked if he would like to see his library used as a dependency for pip as
-part of [PEP-518](https://www.python.org/dev/peps/pep-0518/), he said no - and
-explained why he abandoned the project:
-
->TOML is a bad file format. **It looks good at first glance**, and for really really
->trivial things it is probably good. But once I started using it and the
->configuration schema became more complex, I found the syntax ugly and hard to read.
-
-Despite this, PyPA still went ahead and used TOML for PEP-518. Fortunately
-pyproject.toml *is* fairly trivial and appears just once per project
-so the problems he alludes to aren't that pronounced.
-
-StrictYAML, by contrast, was designed to be a language to write
-[readable 'story' tests](../../../hitchstory) where there will be *many* files
-per project with more complex hierarchies, a use case where TOML starts
-to really suck.
-
-So what specifically *is* wrong with TOML when you scale it up?
-
-
-## 1. It's very verbose. It's not DRY. It's syntactically noisy.
-
-In [this example of a StrictYAML story](https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map.story)
-and [its equivalent serialized TOML](https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map.toml)
-the latter ends up [spending](https://www.goodreads.com/quotes/775257-my-point-today-is-that-if-we-wish-to-count)
-**50% more** characters to represent the exact same data.
-
-This is largely due to the design decision to have the full name of every key being
-associated with every value which is **not** [DRY](../../../code-quality/least-code).
-
-It is also partly due to the large numbers of syntactic cruft - quotation marks
-and square brackets dominate TOML documents whereas in the StrictYAML example they are
-absent.
-
-Shortening program lengths (and DRYing code), all other things being equal,
-[reduces the number of bugs significantly](https://blog.codinghorror.com/diseconomies-of-scale-and-lines-of-code/)
-because maintenance becomes easier and deriving intent from the code becomes clearer.
-What goes for Turing-complete code also applies to configuration code.
-
-
-## 2. TOML's hierarchies are difficult to infer from syntax alone
-
-Mapping hierarchy in TOML is determined by dots. This is simple enough for
-parsers to read and understand but this alone makes it difficult to perceive
-the relationships between data.
-
-This has been recognized by [many](https://github.com/leereilly/csi/blob/567e5b55f766847c9dcc7de482c0fd241fa7377a/lib/data/master.toml) TOML [writers](https://github.com/CzarSimon/simonlindgren.info/blob/a391a6345b16f2d8093f6d4c5f422399b4b901eb/simon-cv/config.toml) who have adopted a method that
-will be quite familiar to a lot of programmers - indentation that the parser ignores:
-
-[![Non-meaningful indentation](toml-indentation-1.png)](https://github.com/gazreese/gazreese.com/blob/c4c3fa7d576a4c316f11f0f7a652ca11ab23586d/Hugo/config.toml)
-
-This parallels the way indentation is added in *lots* of programming languages that have syntactic markers
-like brackets - e.g.  JSON, Javascript or Java are all commonly rendered with non-parsed indentation to make it
-easier for humans to understand them.
-
-But not Python.
-
-Python, has long been a stand out exception in how it was designed -
-syntactic markers are *not* necessary to infer program structure because indentation *is* the marker
-that determines program structure.
-
-This argument over the merits of meaningful indentation in Python has been going on for decades, and [not everybody agrees with this](https://www.quora.com/Do-you-think-that-indentation-in-Python-is-annoying), but it's generally
-considered a good idea - usually for [the reasons argued in this stack exchange question](https://softwareengineering.stackexchange.com/questions/313034/why-should-a-language-prefer-indentation-over-explicit-markers-for-blocks):
-
-1. Python inherited the significant indentation from the (now obsolete) predecessor language ABC. ABC is one of the very few programming languages which have used usability testing to direct the design. So while discussions about syntax usually comes down to subjective opinions and personal preferences, the choice of significant indentation actually has a sounder foundation.
-
-2. Guido van Rossum came across subtle bugs where the indentation disagreed with the syntactic grouping. Meaningful indentation fixed this class of bug. Since there are no begin/end brackets there cannot be a disagreement between grouping perceived by the parser and the human reader.
-
-3. Having symbols delimiting blocks and indentation violates the DRY principle.
-
-4. It does away with the typical religious C debate of "where to put the curly braces" (although TOML is not yet popular enough to inspire such religious wars over indentation... yet).
-
-
-## 3. Overcomplication: Like YAML, TOML has too many features
-
-Somewhat ironically, TOML's creator quite rightly
-[criticizes YAML for not aiming for simplicity](https://github.com/toml-lang/toml#comparison-with-other-formats)
-and then falls into the same trap itself - albeit not quite as deeply.
-
-One way it does this is by trying to include date and time parsing which imports
-*all* of the inherent complications associated with dates and times.
-
-Dates and times, as many more experienced programmers are probably aware is an unexpectedly deep rabbit hole
-of [complications and quirky, unexpected, headache and bug inducing edge cases](https://infiniteundo.com/post/25326999628/falsehoods-programmers-believe-about-time). TOML experiences [many](https://github.com/uiri/toml/issues/55) [of these](https://github.com/uiri/toml/issues/196) [edge cases](https://github.com/uiri/toml/issues/202) because of this.
-
-The best way to deal with [essential complexity](https://simplicable.com/new/accidental-complexity-vs-essential-complexity) like these is to decouple, isolate the complexity and *delegate* it to a
-[specialist tool that is good at handling that specific problem](https://en.wikipedia.org/wiki/Unix_philosophy)
-which you can swap out later if required.
-
-This the approach that JSON took (arguably a good decision) and it's the approach that StrictYAML takes too.
-
-StrictYAML the library (as opposed to the format) has a validator that uses
-[Python's most popular date/time parsing library](https://dateutil.readthedocs.io/en/stable/) although
-developers are not obliged or even necessarily encouraged to use this. StrictYAML parses everything as a
-string by default and whatever validation occurs later is considered to be outside of its purview.
-
-
-## 4. Syntax typing
-
-Like most other markup languages TOML has [syntax typing](../../why/syntax-typing-bad) -
-the *writer* of the markup decides if, for example, something should be parsed as a number
-or a string:
-
-```toml
-flt2 = 3.1415
-string = "hello"
-```
-
-Programmers will feel at home maintaining this, but non programmers tend to find the
-difference between "1.5" and 1.5 needlessly confusing.
-
-StrictYAML does not require quotes around any value to infer a data type because the
-schema is assumed to be the single source of truth for type information:
-
-```yaml
-flt2: 3.1415
-string: hello
-```
-
-In the above example it just removes two characters, but in larger documents with more
-complex data, pushing type parsing decision to the schema (or assuming strings)
-removes an enormous amount of syntactic noise.
-
-The lack of syntax typing combined with the use of indentation instead of square brackets
-to denote hierarchies makes equivalent StrictYAML documents 10-20% shorter, cleaner
-and ultimately more readable.
-
-
-## Advantages of TOML still has over StrictYAML
-
-There are currently still a few:
-
-- StrictYAML does not currently have an "official spec". The spec is currently just "YAML 1.2 with [features removed](../../features-removed)". This has some advantages (e.g. YAML syntax highlighting in editors works just fine) but also some disadvantages (some documents will render differently).
-- StrictYAML does not yet have parsers in languages other than Python. If you'd like to write one for your language (if you don't also do validation it actually wouldn't be very complicated), contact me, I'd love to help you in any way I can - including doing a test suite and documentation.
-- Popularity.
diff --git a/docs/public/why-not/turing-complete-code.md b/docs/public/why-not/turing-complete-code.md
deleted file mode 100644
index fc01416..0000000
--- a/docs/public/why-not/turing-complete-code.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Why shouldn't I just use Python code for configuration?
----
-
-It is relatively common for many applications to avoid the use of a different
-markup language for configuration and simply allow configuration to be
-done using code. One famous and unapologetic example of this is
-[Django](https://docs.djangoproject.com/en/1.10/ref/settings), which
-requires all configuration to be in a "settings.py" or similar file.
-
-This seems like a great idea from the outset - Python is more flexible
-than any configuration language, so, for instance, if you wanted to
-use a list comprehension or read a file or call an API to fill a value,
-you can.
-
-However, with this flexibility comes many traps and unsightly
-pitfalls. The Django pitfalls in particular are
-[cogently summed up by Ned Bachelder on
-his blog](http://nedbatchelder.com/blog/201112/duplicitous_django_settings.html) -
-pitfalls which have been the cause of countless bugs over the
-years.
-
-The language expressiveness trade off applies at every level in code
-
-- [We need less powerful languages](http://lukeplant.me.uk/blog/posts/less-powerful-languages/).
-- [Rule of least power (wikipedia)](https://en.wikipedia.org/wiki/Rule_of_least_power).
-- [Principle of least power by Tim Berners Lee](https://www.w3.org/DesignIssues/Principles.html#PLP).
-- [Principle of least power by Jeff Atwood (coding horror blogger / stack overflow founder)](https://blog.codinghorror.com/the-principle-of-least-power/).
-
-A good way of refactoring, in fact, is to take a large chunk of Turing-complete Python code that *can* be transformed directly into StrictYAML with no loss in expressiveness and and to transform it - for example, a list of translation strings, countries or parameters.
-
-It also makes it easier to have the markup generated by another program or a templating language.
-While you technically *can* do this with Turing-complete code, it will often lead to a debugging nightmare - [just ask C++ programmers](https://stackoverflow.com/questions/622659/what-are-the-good-and-bad-points-of-c-templates>)!
diff --git a/docs/public/why-not/xml.md b/docs/public/why-not/xml.md
deleted file mode 100644
index 6fd4fa4..0000000
--- a/docs/public/why-not/xml.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Why not use XML for configuration or DSLs?
----
-
-XML suffers from overcomplication much like vanilla YAML does - although to an ever greater degree, thanks to the committee-driven design.
-Doctypes and namespaces are horrendous additions to the language, for instance.
-XML is not only not really human readable (beyond a very basic subset of the language), it's often barely *programmer* readable despite being less expressive than most Turing-complete languages.
-It's a flagrant violation of the [rule of least power](https://en.wikipedia.org/wiki/Rule_of_least_power).
-
-The language was, in fact, *so* overcomplicated that it ended up increasing the attack surface of the parser itself to the point that it led to parsers with [security vulnerabilities](https://en.wikipedia.org/wiki/Billion_laughs).
-
-Unlike JSON and YAML, XML's structure also does not map well on to the default data types used by most languages, often requiring a *third* language to act as a go between - e.g. either XQuery or XPath.
-
-XML's decline in favor of JSON as a default API format is largely due to these complications and the lack of any real benefit drawn from them.
-The associated technologies (e.g. XSLT) also suffered from design by committee.
-
-Using it as a configuration language will all but ensure that you need to write extra boilerplate code to manage its quirks.
diff --git a/docs/public/why/duplicate-keys-disallowed.md b/docs/public/why/duplicate-keys-disallowed.md
deleted file mode 100644
index 5349ac0..0000000
--- a/docs/public/why/duplicate-keys-disallowed.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: What is wrong with duplicate keys?
----
-
-Duplicate keys are allowed in regular YAML - as parsed by pyyaml, ruamel.yaml and poyo:
-
-```yaml
-x: cow
-y: dog
-x: bull
-```
-
-Not only is it unclear whether x should be "cow" or "bull" (the parser will decide 'bull', but did you know that?),
-if there are 200 lines between x: cow and x: bull, a user might very likely change the *first* x and erroneously believe that the resulting value of x has been changed - when it hasn't.
-
-In order to avoid all possible confusion, StrictYAML will simply refuse to parse this and will *only* accept associative arrays where all of the keys are unique. It will throw a DuplicateKeysDisallowed exception.
diff --git a/docs/public/why/explicit-tags-removed.md b/docs/public/why/explicit-tags-removed.md
deleted file mode 100644
index d0b86ca..0000000
--- a/docs/public/why/explicit-tags-removed.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: What is wrong with explicit tags?
----
-
-Explicit tags are tags that have an explicit type attached that is used to determine what type to convert the data to when it is parsed.
-
-For example, if it were to be applied to "fix" the Godfather movie script parsing issue described above, it would look like this:
-
-```yaml
-- Don Corleone: Do you have faith in my judgment?
-- Clemenza: !!str Yes
-- Don Corleone: Do I have your loyalty?
-```
-
-Explicit typecasts in YAML markup are slightly confusing for non-programmers, much like the concept of 'types' in general. StrictYAML's philosophy is that types should be kept strictly separated from data, so this 'feature' of YAML is switched off.
-
-If tags are seen in a YAML file it will raise a special TagTokenDisallowed exception.
-
-
-## Counterpoints
-
-- [Valid usage in AWS cloudformation syntax?](https://github.com/crdoconnor/strictyaml/issues/37)
diff --git a/docs/public/why/flow-style-removed.md b/docs/public/why/flow-style-removed.md
deleted file mode 100644
index 7f00947..0000000
--- a/docs/public/why/flow-style-removed.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: What is wrong with flow-style YAML?
----
-
-Flow style is essentially JSON embedded in YAML - making use of curly { } and square brackets to denote lists and mappings.
-
-Example:
-
-```yaml
-a: 1
-b: {c: 3, d: 4}
-```
-
-This use of JSONesque { and } is also ugly and hampers readability - *especially* when { and } are used for other purposes (e.g. templating) and the human reader/writer of YAML has to give themselves a headache figuring out what *kind* of curly bracket it is.
-
-The *first* question in the FAQ of pyyaml actually subtly indicates that this feature wasn't a good idea - see "[why does my YAML look wrong?](http://pyyaml.org/wiki/PyYAMLDocumentation#Dictionarieswithoutnestedcollectionsarenotdumpedcorrectly)".
-
-To take a real life example, use of flow style in [this saltstack YAML definition](https://github.com/saltstack-formulas/mysql-formula/blob/master/mysql/server.sls#L27) which blurs the distinction between flow style and jinja2,
-confusing the reader.
-
-
-## Parsing 'dirty' YAML with flow style
-
-To parse YAML with flow style, you can use [dirty load](../../using/alpha/restrictions/loading-dirty-yaml).
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/20>
-- <https://github.com/crdoconnor/strictyaml/issues/38>
diff --git a/docs/public/why/implicit-typing-removed.md b/docs/public/why/implicit-typing-removed.md
deleted file mode 100644
index e50a8b2..0000000
--- a/docs/public/why/implicit-typing-removed.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-title: The Norway Problem - why StrictYAML refuses to do implicit typing and so should you
----
-
-A while back I met an old coworker and he started telling me about this
-interesting bug he faced:
-
-"So, we started internationalizing the website by creating a config
-file. We added the UK, Ireland, France and Germany at first."
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-```
-
-"This was all fine. However, one day after a quick configuration change
-all hell broke loose. It turned out that while the UK, France and
-Germany were all fine, *Norway* was *not*..."
-
-"While the website went down and we were losing money we chased down
-a number of loose ends until finally finding the root cause."
-
-"If turned out that if feed this configuration file into
-[pyyaml](http://pyyaml.org):"
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-- NO
-```
-
-"This is what you got in return:"
-
-```python
->>> from pyyaml import load
->>> load(the_configuration)
-{'countries': ['GB', 'IE', 'FR', 'DE', False]}
-```
-
-It snows a *lot* in False.
-
-When this is fed to code that expects a string of the form 'NO',
-then the code will usually break, often with a cryptic error,
-Typically it would be a KeyError when trying to use 'False'
-as a key in a dict when no such key exists.
-
-It can be "quick fixed" by using quotes - a fix for sure, but
-kind of a hack - and by that time the damage is done:
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-- 'NO'
-```
-
-The most tragic aspect of this bug, however, is that it is
-*intended* behavior according to the [YAML 1.2 specification](https://github.com/yaml/yaml-spec/tree/spec-1.2).
-The real fix requires explicitly disregarding the spec - which
-is why most YAML parsers have it.
-
-StrictYAML sidesteps this problem by ignoring key parts of the
-spec, in an attempt to create a "zero surprises" parser.
-
-*Everything* is a string by default:
-
-```python
->>> from strictyaml import load
->>> load(the_configuration).data
-{'countries': ['GB', 'IE', 'FR', 'DE', 'NO']}
-```
-
-
-## String or float?
-
-Norway is just the tip of the iceberg. The first time this problem hit me
-I was maintaining a configuration file of application versions. I had
-a file like this initially - which caused no issues:
-
-```yaml
-python: 3.5.3
-postgres: 9.3.0
-```
-
-However, if I changed it *very* slightly:
-
-```yaml
-python: 3.5.3
-postgres: 9.3
-```
-
-I started getting type errors because it was parsed like this:
-
-```python
->>> from ruamel.yaml import load
->>> load(versions) == [{"python": "3.5.3", "postgres": 9.3}]    # oops those *both* should have been strings
-```
-
-Again, this led to type errors in my code. Again, I 'quick fixed' it with quotes.
-However, the solution I really wanted was:
-
-```python
->>> from strictyaml import load
->>> load(versions) == [{"python": "3.5.3", "postgres": "9.3"}]    # that's better
-```
-
-
-## The world's most buggy name
-
-[Christopher Null](http://www.wired.com/2015/11/null) has a name that is
-notorious for breaking software code - airlines, banks, every bug caused
-by a programmer who didn't know a type from their elbow has hit him.
-
-YAML, sadly, is no exception:
-
-```yaml
-first name: Christopher
-surname: Null
-```
-
-```python
-# Is it okay if we just call you Christopher None instead?
->>> load(name) == {"first name": "Christopher", "surname": None}
-```
-
-With StrictYAML:
-
-```python
->>> from strictyaml import load
->>> load(name) == {"first name": "Christopher", "surname": "Null"}
-```
-
-
-## Type theoretical concerns
-
-Type theory is a popular topic with regards to programming languages,
-where a well designed type system is regarded (rightly) as a yoke that
-can catch bugs at an early stage of development while *poorly*
-designed type systems provide fertile breeding ground for edge case
-bugs.
-
-(it's equally true that extremely strict type systems require a lot
-more upfront and the law of diminishing returns applies to type
-strictness - a cogent answer to the question "why is so little
-software written in haskell?").
-
-A less popular, although equally true idea is the notion that markup
-languages like YAML have the same issues with types - as demonstrated
-above.
-
-
-## User Experience
-
-In a way, type systems can be considered both a mathematical concern
-and a UX device.
-
-In the above, and in most cases, implicit typing represents a major violation
-of the UX [principle of least astonishment](https://en.wikipedia.org/wiki/Principle_of_least_astonishment).
diff --git a/docs/public/why/index.md b/docs/public/why/index.md
deleted file mode 100644
index a4f260e..0000000
--- a/docs/public/why/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Design Justifications
----
-
-StrictYAML is the result of some carefully considered, although
-controversial design decisions. These are justified here.
-
-- [What is wrong with duplicate keys?](duplicate-keys-disallowed)
-- [What is wrong with explicit tags?](explicit-tags-removed)
-- [What is wrong with flow-style YAML?](flow-style-removed)
-- [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](implicit-typing-removed)
-- [What is wrong with node anchors and references?](node-anchors-and-references-removed)
-- [Why does StrictYAML not parse direct representations of Python objects?](not-parse-direct-representations-of-python-objects)
-- [Why does StrictYAML only parse from strings and not files?](only-parse-strings-not-files)
-- [Why is parsing speed not a high priority for StrictYAML?](speed-not-a-priority)
-- [What is syntax typing?](syntax-typing-bad)
-- [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](turing-complete-schema)
-
-
-If you have seen a relevant counterargument to you'd like to link
-to addressed at StrictYAML, please create a pull request and
-link to it in the relevant document.
-
-If you'd like to write your own rebuttal to any argument raised
-here, raise a ticket and issue a pull request linking to it at
-the end of the document.
\ No newline at end of file
diff --git a/docs/public/why/node-anchors-and-references-removed.md b/docs/public/why/node-anchors-and-references-removed.md
deleted file mode 100644
index 56ea660..0000000
--- a/docs/public/why/node-anchors-and-references-removed.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: What is wrong with node anchors and references?
----
-
-An example of a snippet of YAML that uses node anchors and references is described on the [YAML wikipedia page](https://en.wikipedia.org/wiki/YAML#Advanced_components):
-
-```yaml
-# sequencer protocols for Laser eye surgery
----
-- step:  &id001                  # defines anchor label &id001
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-
-- step: &id002
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step: *id001                   # refers to the first step (with anchor &id001)
-- step: *id002                   # refers to the second step
-- step:
-    <<: *id001
-    spotSize: 2mm                # redefines just this key, refers rest from &id001
-- step: *id002
-```
-
-While the intent of the feature is obvious (it lets you deduplicate code), the effect is to make the markup
-more or less unreadable to non-programmers.
-
-The example above could be refactored to be clearly as follows:
-
-```yaml
-# sequencer protocols for Laser eye surgery
----
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-```
-
-The intent of this document is a lot clearer than the version above - *especially* for
-non-programmers. However, it comes at a cost of increased repetition.
-
-Between the node/anchor version and this I would prefer this.
-
-However, it is still repetitive and ideally it should be non-repetitive and still
-clear. This can be done by refactoring the *structure* of the document and changing
-the way the application interprets it.
-
-For example, instead of representing using the schema above, a schema that separates
-step definitions from actual steps could be used. For example:
-
-```yaml
-step definitions:
-  large:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-  medium:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-steps:
-- step: large
-- step: medium
-- step: large
-- step: medium
-- step:
-    from: large
-    except:
-      spotSize: 2mm
-- step: large
-```
-
-The above document has an entirely different and slightly complex schema but it
-fundamentally represents the same data as the node/anchor version above, in a clearer
-manner, without duplication.
diff --git a/docs/public/why/not-parse-direct-representations-of-python-objects.md b/docs/public/why/not-parse-direct-representations-of-python-objects.md
deleted file mode 100644
index c5a4f73..0000000
--- a/docs/public/why/not-parse-direct-representations-of-python-objects.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Why does StrictYAML not parse direct representations of Python objects?
----
-
-Regular YAML allows the direct representation of Python objects.
-
-For example:
-
-```yaml
---- !python/hash:UserObject
-email: evilhacker@hacker.com
-password: passwordtoset
-type: admin
-```
-
-If we load this YAML formatted string in, we get a user object. This was
-how YAML was intended to work since it allows the ability to write objects
-to and read them from, say, a database.
-
-By itself, this behavior isn't necessarily capable of enacting a successful
-attack, so not all code that parses untrusted YAML is insecure,
-but it can be used, especially in conjunction with metaprogramming to execute
-arbitrary code on your system.
-
-This shares a lot in common with the pickle module's behavior, which is why
-its use with [untrusted input is strongly recommended against in the Python
-docs](https://docs.python.org/3/library/pickle.html).
-
-This anti-feature led to Ruby on Rails' spectacular [security fail](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/).
diff --git a/docs/public/why/only-parse-strings-not-files.md b/docs/public/why/only-parse-strings-not-files.md
deleted file mode 100644
index 6da7724..0000000
--- a/docs/public/why/only-parse-strings-not-files.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Why does StrictYAML only parse from strings and not files?
----
-
-While other parsers will take strings, file handles and file names,
-StrictYAML will only parse YAML strings.
-
-This is done deliberately to reduce the module's remit, with the
-intention of reducing both the potential bug surface and the number
-of exceptions that StrictYAML has to deal with - things like
-nonexistent files, file system errors, bad reads, unknown file
-extensions, etc. become the problem of some other module - ideally
-one more focused on handling those kinds of issues.
-
-If you want a quick and easy one liner way to get text from a file,
-I recommend that you pip install path.py and and use .text() on the
-Path object:
-
-```python
->>> from path import Path
->>> from strictyaml import load
->>> parsed_data = load(Path("myfile.yaml").text()).data
->>> print(parsed_data)
-[ parsed yaml ]
-```
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/5>
diff --git a/docs/public/why/speed-not-a-priority.md b/docs/public/why/speed-not-a-priority.md
deleted file mode 100644
index 1d3d9b1..0000000
--- a/docs/public/why/speed-not-a-priority.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Why is parsing speed not a high priority for StrictYAML?
----
-
-JSON and StrictYAML are essentially complementary formats. They both allow
-a relatively loose representation of data that just contains, mappings and
-sequences. They are serialization formats that are relatively straightforward
-for both humans and machines to read and write.
-
-The main difference is simply one of degree:
-
-JSON is primarily optimized for *machine* readability and writability, while
-still maintaining human readability.
-
-YAML is optimized for *human* readability and writability, while maintaining
-machine readability and writability.
-
-This means that the two formats are better suited to slightly different applications.
-For instance, JSON is better suited as a format for use with REST APIs while
-YAML is better suited as a format for use by configuration languages and DSLs.
-
-If you are using YAML primarily as a readable medium to express a markup language
-or represent configuration in, this probably means that 1) what you are reading is
-probably relatively short (e.g. < 1,000 lines) and 2) it will be read/written
-infrequently (e.g. once, when a program starts).
-
-For this reason, it is assumed that for most StrictYAML applications, parsing
-speed is of a lower importance than strictness, readability and ease of use.
-
-That being said, any requests that improve parsing or writing speed are welcome.
diff --git a/docs/public/why/syntax-typing-bad.md b/docs/public/why/syntax-typing-bad.md
deleted file mode 100644
index 4c9a24f..0000000
--- a/docs/public/why/syntax-typing-bad.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: What is syntax typing?
----
-
-Explicit syntax typing is the use of syntax to designate the type of some data.
-It is a feature of the design of most programming languages.
-
-```python
-x = "11" # this is a string
-y = 11   # this isn't
-```
-
-It it isn't limited to programming languages though. It's a common feature of
-serialization formats like JSON:
-
-```json
-{"x": "11", "y": 42}
-```
-
-But not others, like INI:
-
-```ini
-server=192.0.2.62
-port=143
-```
-
-Or CSV:
-
-```ini
-server,port
-192.0.2.62,143
-```
-
-Or StrictYAML:
-
-```yaml
-server: 192.0.2.62
-port: 143
-```
-
-In those cases, it's up to the program - in another file - to decide what part
-of that data is and what part is an integer.
-
-
-## What does it mean to attach syntax typing to data?
-
-Syntax typing the explicit prioritization of cohesion over terseness. It
-puts type information right next to the data, but in the process this
-means that if the data appears a *lot*
-
-
-## When would you sacrifice terseness?
-
-Let's return to Python for a second and imagine that
-
-```python
-x = "11" # this is a string
-y = 11   # this isn't
-```
-
-This helps distinguish the types for the parser, which is useful for JSON, but it also comes with two disadvantages:
-
-- The distinction is subtle and not particularly clear to *non-programmers*, who will not necessarily understand that a directive needs to be given to the parser to avoid it being misinterpreted.
-- It's not necessary if the type structure is maintained outside of the markup.
-- Verbosity - two extra characters per string makes the markup longer and noisier.
-
-In JSON when being used as a REST API, syntax typing is often an *advantage* - it is explicit to the machine reading the JSON that "string" and "age" is an integer and it can convert accordingly *in the absence of a schema*.
-
-StrictYAML assumes all values are strings unless the schema explicitly indicates otherwise (e.g. Map(Int(), Int())).
-
-StrictYAML does not require quotation marks for strings that are implicitly converted to other types (e.g. yes or 1.5), but it does require quotation marks for strings that are syntactically confusing (e.g. "{ text in curly brackets }")
-
-Standard YAML has explicit syntax typing to explicitly declare strings, although it's confusing as hell to know when it's required and when it is not. For example:
-
-```yaml
-a: text               # not necessary
-b: "yes"              # necessary
-c: "0"                # necessary
-d: "3.5"              # necessary
-e: in                 # not necessary
-f: out                # not necessary
-g: shake it all about # not necessary
-h: "on"               # necessary
-```
-
-Most other configuration language formats also make use of syntax typing. For example:
-
-- [TOML](../../why-not/toml)
-- [JSON5](../../why-not/json5)
-- [HJSON](../../why-not/hjson)
-- [SDLang](../../why-not/sdlang)
-- [HOCON](../../why-not/hocon)
-
-[INI](../../why-not/ini) does not have explicit syntax typing however.
diff --git a/docs/public/why/turing-complete-schema.md b/docs/public/why/turing-complete-schema.md
deleted file mode 100644
index 9a96d44..0000000
--- a/docs/public/why/turing-complete-schema.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Why does StrictYAML make you define a schema in Python - a Turing-complete language?
----
-
-StrictYAML defines schemas in Python (i.e. Turing-complete) code. For example:
-
-```python
-Map({"name": Str(), "email": Str()})
-```
-
-Instead of:
-
-```yaml
-type:       map
-mapping:
-"name":
-    type:      str
-    required:  yes
-"email":
-    type:      str
-    required:  yes
-```
-
-There are some trade offs here:
-
-Schema definition in a non-Turing-complete language like YAML makes
-the schema programming language independent and gives it more
-potential for being read and understood by non-programmers.
-
-However, schema definition in a non-Turing-complete language also
-restricts and makes certain use cases impossible or awkward.
-
-Some use cases I came across included:
-
-- Being able to import pycountry's country list and restrict "country: " to valid country names.
-- Being able to implement a schema that validated date/time scalar values against the specific date/time parser I wanted.
-- Being able to revalidate sections of the document on a 'second pass' that used new data - e.g. a list in one part of the document is restricted to items which come from another part.
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/16>
diff --git a/docs/src/comparison/table.yml b/docs/src/comparison/table.yml
deleted file mode 100644
index c7a2590..0000000
--- a/docs/src/comparison/table.yml
+++ /dev/null
@@ -1,62 +0,0 @@
-json:
-  syntax to data ratio:
-  % length of JSON: 100
-  syntax typing: yes
-  well defined: yes
-  comments: no
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: no
-  meaningful whitespace: no
-  complex features: no
-
-strictyaml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: yes
-  comments: yes
-  syntactic noise ratio:
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: yes
-  meaningful whitespace: yes
-  complex features: no
-
-yaml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: yes
-  well defined: yes
-  comments: yes
-  hierarchical: yes
-  duplicate keys: yes
-  multiline strings: yes
-  meaningful whitespace: no
-  complex features: yes
-
-ini:
-  syntactic noise ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: no
-  comments: yes
-  hierarchical: no
-  duplicate keys: yes
-  multiline strings: no
-  meaningful whitespace: no
-  complex features: no
-
-toml:
-  syntax to data ratio:
-  % length of JSON:
-  syntax typing: no
-  well defined: no
-  comments: yes
-  hierarchical: yes
-  duplicate keys: no
-  multiline strings: yes
-  meaningful whitespace: no
-  complex features: yes
-
-json5:
diff --git a/docs/src/dirtemplate.yml b/docs/src/dirtemplate.yml
deleted file mode 100644
index 14e16b2..0000000
--- a/docs/src/dirtemplate.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-base templates: template
-templated:
-- template/story.jinja2:
-    content: yes
-    filename: yes
-- why/index.md:
-    content: yes
-- why-not/index.md:
-    content: yes
-- using/alpha/compound/index.md:
-    content: yes
-- using/alpha/howto/index.md:
-    content: yes
-- using/alpha/restrictions/index.md:
-    content: yes
-- using/alpha/scalar/index.md:
-    content: yes
-- using/index.md:
-    content: yes
-- using/alpha/index.md:
-    content: yes
-- using/alpha/index.md:
-    content: yes
-- index.md:
-    content: yes
diff --git a/docs/src/features-removed.md b/docs/src/features-removed.md
deleted file mode 100644
index d3b7617..0000000
--- a/docs/src/features-removed.md
+++ /dev/null
@@ -1,147 +0,0 @@
----
-title: What YAML features does StrictYAML remove?
----
-
-StrictYAML restricts you from parsing a number of things which
-the YAML specification says should be parsed. An issue has
-been [raised](https://github.com/yaml/YAML2/issues/8) by
-[David Seaward](https://inkwell.za.net/) about this critique
-on the official YAML repository.
-
-This document lists those of those features:
-
-
-## Implicit Typing ([Why?](../why/implicit-typing-removed))
-
-```yaml
-x: yes
-y: null
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {"x": True, "y": None}
-```
-
-Example StrictYAML without schema:
-
-```python
-load(yaml) == {"x": "yes", "y": "null"}
-```
-
-Example StrictYAML with schema:
-
-```python
-load(yaml, Map({"x": Bool(), "y": Str()})) == {"x": True, "y": "null"}
-```
-
-
-## Direct representations of objects ([Why?](../why/not-parse-direct-representations-of-python-objects))
-
-```yaml
---- !python/hash:UnsafeUserObject
-email: evilhacker@hacker.com
-password: passwordtoset
-type: admin
-```
-
-Example pyyaml/ruamel:
-
-```python
-load(yaml) == {'evil': b'z\xf8\xa5u\xabZ'}
-```
-
-Example StrictYAML
-
-```python
-raises TagTokenDisallowed
-```
-
-
-## Duplicate Keys Disallowed ([Why?](../why/duplicate-keys-disallowed))
-
-```yaml
-x: 1
-x: 2
-```
-
-Example pyyaml/poyo:
-
-```python
-load(yaml) == {'x': 2}
-```
-
-Example StrictYAML
-
-```python
-raises DuplicateKeysDisallowed
-```
-
-
-## Explicit tags ([Why?](../why/explicit-tags-removed))
-
-```yaml
-x: !!int 5
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == load(yaml) == {"x": 5}
-```
-
-Example StrictYAML
-
-```python
-raises TagTokenDisallowed
-```
-
-
-## Node anchors and refs ([Why?](../why/node-anchors-and-references-removed))
-
-```yaml
-x: &id001
-  a: 1
-y: *id001
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {'x': {'a': 1}, 'y': {'a': 1}}
-```
-
-Example StrictYAML
-
-```python
-raises NodeAnchorDisallowed
-```
-
-To parse the above YAML *literally* in StrictYAML do:
-
-```yaml
-x: '&id001'
-  a: 1
-y: '*id001'
-```
-
-
-## Flow style ([Why?](../why/flow-style-removed))
-
-```yaml
-x: 1
-b: {c: 3, d: 4}
-```
-
-Example pyyaml/ruamel/poyo:
-
-```python
-load(yaml) == {'x': 1, 'b': {'c': 3, 'd': 4}}
-```
-
-Example StrictYAML
-
-```python
-raises FlowStyleDisallowed
-```
diff --git a/docs/src/index.md b/docs/src/index.md
deleted file mode 100644
index d704890..0000000
--- a/docs/src/index.md
+++ /dev/null
@@ -1,127 +0,0 @@
-{% if readme -%}
-# StrictYAML
-{%- else -%}
----
-title: StrictYAML
----
-
-{% raw %}{{< github-stars user="crdoconnor" project="strictyaml" >}}{% endraw %}
-{% endif %}
-
-StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
-that parses and validates a [restricted subset](features-removed) of the [YAML](what-is-yaml)
-specification.
-
-Priorities:
-
-- Beautiful API
-- Refusing to parse [the ugly, hard to read and insecure features of YAML](features-removed) like [the Norway problem](why/implicit-typing-removed).
-- Strict validation of markup and straightforward type casting.
-- Clear, readable exceptions with **code snippets** and **line numbers**.
-- Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
-- Ability to read in YAML, make changes and write it out again with comments preserved.
-- [Not speed](why/speed-not-a-priority), currently.
-
-{% for story in quickstart %}
-{{ story.name }}:
-{% if 'yaml_snippet' in story.data['given'] %}
-```yaml
-{{ story.given['yaml_snippet'] }}
-```
-{% endif %}
-{% if 'setup' in story.data['given'] %}
-```python
-{{ story.given['setup'] }}
-```
-{% endif %}
-
-
-{% for variation in story.variations %}
-
-{{ variation.child_name }}:
-
-{% with step = variation.steps[0] %}{% include "step.jinja2" %}{% endwith %}
-{% endfor %}
-{% endfor %}
-
-
-## Install
-
-```sh
-$ pip install strictyaml
-```
-
-
-## Why StrictYAML?
-
-There are a number of formats and approaches that can achieve more or
-less the same purpose as StrictYAML. I've tried to make it the best one.
-Below is a series of documented justifications:
-
-{% for dirfile in (subdir("why-not").ext("md") - subdir("why-not").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](why-not/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-
-## Using StrictYAML
-
-How to:
-
-{% for dirfile in (subdir("using/alpha/howto/").ext("md") - subdir("using/alpha/howto/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](using/alpha/howto/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-Compound validators:
-
-{% for dirfile in (subdir("using/alpha/compound/").ext("md") - subdir("using/alpha/compound/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](using/alpha/compound/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-Scalar validators:
-
-{% for dirfile in (subdir("using/alpha/scalar/").ext("md") - subdir("using/alpha/scalar/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](using/alpha/scalar/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-Restrictions:
-
-{% for dirfile in (subdir("using/alpha/restrictions/").ext("md") - subdir("using/alpha/restrictions/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](using/alpha/restrictions/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-
-## Design justifications
-
-There are some design decisions in StrictYAML which are controversial
-and/or not obvious. Those are documented here:
-
-{% for dirfile in (subdir("why").ext("md") - subdir("why").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](why/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-
-## Star Contributors
-
-- @wwoods
-- @chrisburr
-- @jnichols0
-
-## Other Contributors
-
-- @eulores
-- @WaltWoods
-- @ChristopherGS
-- @gvx
-- @AlexandreDecan
-- @lots0logs
-- @tobbez
-- @jaredsampson
-- @BoboTIG
-
-StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.
-
-## Contributing
-
-- Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
-- Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
-- All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.
diff --git a/docs/src/redirects.yml b/docs/src/redirects.yml
deleted file mode 100644
index abfeba9..0000000
--- a/docs/src/redirects.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-/why-not/syntax-typing: /why/syntax-typing-bad
-/new-faq: /
-/using/alpha/compound/either-or-validation: /using/alpha/howto/either-or-validation/
-/why/care-about-yaml: /why
-/why/binary-data-removed: /why/not-parse-direct-representations-of-python-objects
diff --git a/docs/src/template/step.jinja2 b/docs/src/template/step.jinja2
deleted file mode 100644
index e5014e0..0000000
--- a/docs/src/template/step.jinja2
+++ /dev/null
@@ -1,29 +0,0 @@
-{% if step['in_interpreter'] %}
-```python
-{% for line in step['code'].rstrip('\n').split('\n') %}>>> {{ line }}
-{% endfor -%}
-{{ step['will_output'] }}
-```
-{% else %}
-```python
-{{ step['code'] }}
-```
-{% if 'will_output' in step %}
-```yaml
-{{ step['will_output'] }}
-```
-{% endif %}
-{% if 'raises' in step %}
-```python
-{% if 'in python 3' in step['raises']['type'] -%}
-{{ step['raises']['type']['in python 3'] }}:
-{%- else %}{{ step['raises']['type'] }}:{% endif -%}
-{%- if 'in python 3' in step['raises']['message'] -%}
-{{ step['raises']['message']['in python 3']  }}:
-```
-{% else %}
-{{ step['raises']['message'] }}
-```
-{% endif %}
-{% endif %}
-{% endif %}
diff --git a/docs/src/template/story.jinja2 b/docs/src/template/story.jinja2
deleted file mode 100644
index 0512160..0000000
--- a/docs/src/template/story.jinja2
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: {{ story.name }}
-type: using
----
-{% if story.info['experimental'] %}{% raw %}
-{{< warning title="Experimental" >}}
-This feature is in alpha. The API may change on a minor version increment.
-{{< /warning >}}
-{% endraw %}{% endif %}
-
-{{ story.info['description'] }}
-
-{% if 'yaml_snippet' in story.given %}Example yaml_snippet:
-
-```yaml
-{{ story.given['yaml_snippet'] }}
-```
-{% endif %}
-
-{% if 'setup' in story.given -%}
-```python
-{{ story.given['setup'] }}
-```
-{%- endif %}
-
-{% if story.variations %}
-{% for variation in story.variations %}
-{{ variation.child_name }}:
-{% if'yaml_snippet' in variation.data.get('given', {}).keys() %}
-```yaml
-{{ variation.given['yaml_snippet'] }}
-```
-{% endif %}
-{% with step = variation.steps[0] %}{% include "step.jinja2" %}{% endwith %}
-{% endfor %}
-{% else %}
-{% with step = story.steps[0] %}{% include "step.jinja2" %}{% endwith %}
-{% endif %}
-
-{% raw %}{{< note title="Executable specification" >}}{% endraw %}
-Page automatically generated from <a href="https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/{{ story.filename.basename() }}">{{ story.filename.basename() }}</a>.
-{% raw %}{{< /note >}}{% endraw %}
diff --git a/docs/src/using/alpha/compound/index.md b/docs/src/using/alpha/compound/index.md
deleted file mode 100644
index 68c51d6..0000000
--- a/docs/src/using/alpha/compound/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Compound StrictYAML Validators
----
-
-{% for dirfile in (thisdir.is_not_dir() - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.name.splitext()[0] }})
-{% endfor %}
diff --git a/docs/src/using/alpha/howto/index.md b/docs/src/using/alpha/howto/index.md
deleted file mode 100644
index d2fbfcf..0000000
--- a/docs/src/using/alpha/howto/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: How to...
----
-
-{% for dirfile in (thisdir.is_not_dir() - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.name.splitext()[0] }})
-{% endfor %}
diff --git a/docs/src/using/alpha/index.md b/docs/src/using/alpha/index.md
deleted file mode 100644
index 3dcaf98..0000000
--- a/docs/src/using/alpha/index.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Using StrictYAML v0.x.x
----
diff --git a/docs/src/using/alpha/restrictions/index.md b/docs/src/using/alpha/restrictions/index.md
deleted file mode 100644
index cde39a5..0000000
--- a/docs/src/using/alpha/restrictions/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Restrictions
----
-
-{% for dirfile in (thisdir.is_not_dir() - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.name.splitext()[0] }})
-{% endfor %}
diff --git a/docs/src/using/alpha/scalar/index.md b/docs/src/using/alpha/scalar/index.md
deleted file mode 100644
index 359c3c9..0000000
--- a/docs/src/using/alpha/scalar/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Scalar StrictYAML Validators
----
-
-{% for dirfile in (thisdir.is_not_dir() - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.name.splitext()[0] }})
-{% endfor %}
diff --git a/docs/src/using/index.md b/docs/src/using/index.md
deleted file mode 100644
index 415c104..0000000
--- a/docs/src/using/index.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Using StrictYAML
----
-
-How to:
-
-{% for dirfile in (subdir("using/alpha/howto/").is_not_dir() - subdir("using/alpha/howto/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](alpha/howto/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-Compound validators:
-
-{% for dirfile in (subdir("using/alpha/compound/").is_not_dir() - subdir("using/alpha/compound/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](alpha/compound/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-Scalar validators:
-
-{% for dirfile in (subdir("using/alpha/scalar/").is_not_dir() - subdir("using/alpha/scalar/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](alpha/scalar/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
-Restrictions:
-
-{% for dirfile in (subdir("using/alpha/restrictions/").is_not_dir() - subdir("using/alpha/restrictions/").named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}](alpha/restrictions/{{ dirfile.name.splitext()[0] }})
-{% endfor %}
diff --git a/docs/src/what-is-yaml.md b/docs/src/what-is-yaml.md
deleted file mode 100644
index f784a14..0000000
--- a/docs/src/what-is-yaml.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: What is YAML?
----
-
-YAML is a simple, human readable format for representing associative and hierarchical data.
-
-Example from wikipedia page on YAML:
-
-```yaml
-receipt: Oz-Ware Purchase Invoice
-date: 2012-08-06
-customer:
-  first name: Harry
-  family name: Potter
-address: |-
-  4 Privet Drive,
-  Little Whinging,
-  England
-items:
-- part_no: A4786
-  description: Water Bucket (Filled)
-  price: 1.47
-  quantity:  4
-
-- part_no: E1628
-  description: High Heeled "Ruby" Slippers
-  size: 8
-  price: 133.7
-  quantity: 1
-```
-
-Key features:
-
-- Things which are associated with other things - delimited by the colon (:).
-- Ordered lists of things - delimited by the prepended dash (-).
-- Multi-line strings - delimited by the bar (|) if there is another newline at the end of the string, or bar + dash (|-) if not.
-- Indentation describing the hierarchy of data.
-- Maps directly to data types common to most high level languages - lists, dicts, scalars.
-
-You don't need to know much more than this.
diff --git a/docs/src/when-to-use-validators.md b/docs/src/when-to-use-validators.md
deleted file mode 100644
index 438080f..0000000
--- a/docs/src/when-to-use-validators.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: When should I use a validator and when should I not?
----
-
-When starting out on greenfield projects it's much quicker not to create a validator. In such cases it's often more prudent to just parse the YAML and convert the strings explicitly on the fly (e.g. int(yaml['key'])).
-
-If the YAML is also going to be largely under the control of the developer it also might not make sense to write a validator either.
-
-If you have written software that is going to parse YAML from a source you do *not* control - especially by somebody who might make a mistake - then it probably does make sense to write a validator.
-
-You can start off without using a validator and then add one later.
diff --git a/docs/src/why-not/environment-variables-as-config.md b/docs/src/why-not/environment-variables-as-config.md
deleted file mode 100644
index 29ebc18..0000000
--- a/docs/src/why-not/environment-variables-as-config.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: Why avoid using environment variables as configuration?
----
-
-The use of "environment variables as configuration" is recommended by
-"[12 factor](https://12factor.net/config)". While this is a common
-practice and often leads to few or no problems, calling it a best
-practice is a bit much.
-
-The reason cited by the 12 factor website for using them is:
-
->The twelve-factor app stores config in environment variables (often shortened to env vars or env). Env vars are easy to change between deploys without changing any code; unlike config files, there is little chance of them being checked into the code repo accidentally; and unlike custom config files, or other config mechanisms such as Java System Properties, they are a language- and OS-agnostic standard.
-
-Two of these are fine reasons. It is true that these are both good reasons:
-
-- Easy to change between deploys.
-- Language and OS agnostic.
-
-However, neither of these things requires that config be stored in environment variables.
-It's easy enough to create language and OS agnostic configuration files
-(INI, YAML, etc.) and it's usually straightforward to make files easy to change
-between deployments too - e.g. if a deployment is containerized, by mounting the file.
-
-It is less true that environment variables are inherently "easier" to change between
-deployments - writing a file is not intrinsically difficult unless it is *made*
-difficult (e.g. a file is baked in to a container image rather than being mounted), it
-isn't hard to change.
-
-Moreover, there are several disadvantages to using environment variables
-that tend to exhibit themselves nastily when the size of the configuration grows beyond
-a certain point.
-
-
-## Environment variables are global state
-
-Environment variables are a form of global state. Every variable
-is associated only with the environment. The variables will be shared with many
-other variables which have a multitude of different uses:
-
-- The chances of variable cross contamination is high - accidentally naming one variable the same as another which is unknowingly used for a different purpose (e.g. PATH) is elevated, and this can have both weird, hard to debug and terrible effects.
-- If you need to inspect environment variables e.g. to find one that you thought was there and it actually missing, tracking it down is a pain.
-
-Global state in and of itself isn't a "bad thing" but *too much* global
-state is a very bad thing. A small amount of configuration (e.g. less than
-10 variables) can often be placed in to environment variables with very
-little harm, but as soon as the amount grows the danger of the global
-state grows.
-
-
-## Environment variable values cannot handle structures more complex than a string
-
-Environment variables are a set of key-value pairs where the key is almost always an
-uppercase string and the value is always a string.
-
-While this is more than sufficient for many purposes, there are many kinds of situations
-where the configuration data that needs to be stored requires something a bit more
-complicated than just a string.
-
-Where developers run in to this limitation they have a tendency to create an ugly substructure with
-cryptic codes within the string.
-
-The way that LS_COLORS is used is a good example:
-
-```
-rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.wim=01;31:*.swm=01;31:*.dwm=01;31:*.esd=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:
-```
-
-Clear as mud, right?
-
-(This isn't actually an example of 12 factor being followed assiduously, but I have seen many examples
-just like it where it was).
-
-In [StrictYAML](https://hitchdev.com/strictyaml) the following could be represented as:
-
-```yaml
-# Special
-
-di: 01;34      # directory is blue
-
-# Extensions
-
-*.tz: 01;31    # red
-*.flv: 01;35   # purple
-```
-
-While the codes are cryptic and probably should be changed (e.g. directory: blue), the cryptic nature
-can at least be easily explained with comments.
-
-
-## Creating naming conventions to handle the inability to handle
-
-A common example:
-
->PERSONNEL_DATABASE_HOST, PERSONNEL_DATABASE_PORT, PERSONNEL_DATABASE_NAME, PERSONNEL_DATABASE_PASSWORD, FACTORY_DATABASE_HOST, FACTORY_DATABASE_PORT, FACTORY_DATABASE_NAME, FACTORY_DATABASE_PASSWORD,
-HOTEL_BACKUP_DATABASE_HOST, HOTEL_BACKUP_DATABASE_USERNAME, HOTEL_BACKUP_DATABASE_PASSWORD, HOTEL_DATABASE_HOST, HOTEL_DATABASE_PORT, HOTEL_DATABASE_NAME, HOTEL_DATABASE_PASSWORD
-
-Did you spot the accidentally missed variable in the list above which caused the critical bug?
-
-[StrictYAML](https://hitchdev.com/strictyaml) version:
-
-```yaml
-database:
-  personnel:
-    host: xxx
-    port: xxx
-    name: xxx
-    password: xxx
-
-  factory:
-    host: xxx
-    port: xxx
-    name: xxx
-    password: xxx
-
-  hotel backup:
-    host: xxx
-    name: xxx
-    password: xxx
-
-  hotel:
-    host: xxx
-    name: xxx
-    port: xxx
-    password: xxx
-```
-
-What about now?
diff --git a/docs/src/why-not/hjson.md b/docs/src/why-not/hjson.md
deleted file mode 100644
index f7f346c..0000000
--- a/docs/src/why-not/hjson.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Why not use HJSON?
----
-
-{{< note title="No longer supported" >}}
-HJSON is no longer supported.
-{{< /note >}}
-
-[HJSON](http://hjson.org/) is an attempt at fixing the aforementioned lack of readability of JSON.
-
-It has the following criticisms of YAML:
-
-- JSON is easier to explain (compare the JSON and YAML specs).
-
-- JSON is not bloated (it does not have anchors, substitutions or concatenation).
-
-As with TOML's criticism, these are spot on. However, strictyaml fixes this by *cutting out those parts of the spec*, leaving something that is actually simpler than HJSON.
-
-It has another criticism:
-
-- JSON does not suffer from significant whitespace.
-
-This is not a valid criticism.
-
-Whitespace and indentation is meaningful to people parsing any kind of code and markup (why else would code which *doesn't* have meaningful whitespace use indentation as well?) so it *should* be meaningful to computers parsing.
-
-There is an initial 'usability hump' for first time users of languages which have significant whitespace *that were previously not used to significant whitespace* but this isn't especially hard to overcome - especially if you have a propery configured decent editor which is explicit about the use of whitespace.
-
-Python users often report this being a problem, but after using the language for a while usually come to prefer it since it keeps the code shorter and makes its intent clearer.
diff --git a/docs/src/why-not/hocon.md b/docs/src/why-not/hocon.md
deleted file mode 100644
index c0ad88a..0000000
--- a/docs/src/why-not/hocon.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Why not HOCON?
----
-
-[HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md) is another "redesigned" JSON, ironically enough, taking JSON and making it even more complicated.
-
-Along with JSON's [syntax typing](../../why/syntax-typing-bad) - a downside of most non-YAML alternatives, HOCON makes the following mistakes in its design:
-
-- It does not fail loudly on duplicate keys.
-- It has a confusing rules for deciding on concatenations and substitutions.
-- It has a mechanism for substitutions similar to [YAML's node anchor feature](../why/node-anchors-and-references-removed.md) - which, unless used extremely sparingly, can create confusing markup that, ironically, is *not* human optimized.
-
-In addition, its attempt at using "less pedantic" syntax creates a system of rules which makes the behavior of the parser much less obvious and edge cases more frequent.
diff --git a/docs/src/why-not/index.md b/docs/src/why-not/index.md
deleted file mode 100644
index 0fc23d4..0000000
--- a/docs/src/why-not/index.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Why not X?
----
-
-There are a number of formats and approaches that can achieve more or
-less the same purpose as StrictYAML. Below is a series of comparisons
-with some of the more famous ones:
-
-{% for dirfile in (thisdir.ext("md") - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.basename().splitext()[0] }})
-{% endfor %}
-
-If you'd like to write or link to a rebuttal to any argument raised
-here, feel free to raise a ticket.
diff --git a/docs/src/why-not/ini.md b/docs/src/why-not/ini.md
deleted file mode 100644
index ba2c97a..0000000
--- a/docs/src/why-not/ini.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Why not use INI files?
----
-
-INI is a very old and quite readable configuration format for small configuration files.
-It is still used by many programs today and it has some advantages due to this - e.g.
-python has inbuilt parser for it.
-
-Unfortunately it suffers from two major problems:
-
-- Different parsers will operate in subtly different ways that can lead to often obscure edge case bugs regarding the way whitespace is used, case sensitivity, comments and escape characters.
-- It doesn't let you represent hierarchical data.
-
-[TOML](../toml) is a configuration format designed to address these two concerns,
-although it also suffers from obscure edge case bugs.
diff --git a/docs/src/why-not/json-schema.md b/docs/src/why-not/json-schema.md
deleted file mode 100644
index 46b2b1e..0000000
--- a/docs/src/why-not/json-schema.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Why not use JSON Schema for validation?
----
-
-JSON schema can also be used to validate YAML. This presumes that
-you might want to use jsonschema and pyyaml/ruamel.yaml together.
-
-[ TODO Flesh out ]
-
-- Line numbers
-- Simpler errors in StrictYAML
-- StrictYAML is a more flexible schema
-- Turing incompleteness / inflexibility
diff --git a/docs/src/why-not/json.md b/docs/src/why-not/json.md
deleted file mode 100644
index a0cc6e4..0000000
--- a/docs/src/why-not/json.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Why not JSON for simple configuration files?
----
-
-JSON is an *ideal* format for REST APIs and other forms of data intended for machine exchange and it probably always will be because:
-
-- It's a simple spec.
-- It has all the basic types which map on to all programming languages - number, string, list, mapping, boolean *and no more*.
-- Its syntax contains a built in level of error detection - cut a JSON request in half and it is no longer still valid, eliminating an entire class of obscure and problematic bugs.
-- If pretty-printed correctly, it's more or less readable - for the purposes of debugging, anyway.
-
-However, while it is eminently suitable for REST APIs it is less suitable for configuration since:
-
-- The same syntax which gives it decent error detection (commas, curly brackets) makes it tricky for humans to edit.
-- It's not especially readable.
-- It doesn't allow comments.
diff --git a/docs/src/why-not/json5.md b/docs/src/why-not/json5.md
deleted file mode 100644
index 54591df..0000000
--- a/docs/src/why-not/json5.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: Why not JSON5?
----
-
-[JSON5](http://json5.org/) is also a proposed extension to JSON to make it more readable.
-
-Its main criticism of YAML is::
-
-  There are other formats that are human-friendlier, like YAML, but changing from JSON to a completely different format is undesirable in many cases.
-
-This is, I believe, mistaken. It is better if a language is not subtly different if you are going to use it as such. Subtle differences invite mistakes brought on by confusion.
-
-JSON5 looks like a hybrid of YAML and JSON::
-
-```json
-{
-    foo: 'bar',
-    while: true,
-}
-```
-
-It has weaknesses similar to TOML:
-
-- The noisiness of the delimiters that supplant significant whitespace make it less readable and editable.
-- The use of [syntax typing](../../why/syntax-typing-bad) is neither necessary, nor an aid to stricter typing if you have a schema.
diff --git a/docs/src/why-not/ordinary-yaml.md b/docs/src/why-not/ordinary-yaml.md
deleted file mode 100644
index c55a369..0000000
--- a/docs/src/why-not/ordinary-yaml.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Why not use the YAML 1.2 standard? - we don't need a new standard!
----
-
-![Standards](https://imgs.xkcd.com/comics/standards.png "Fortunately the configuration one has been solved now that we have Strict uh... wait, no it hasn't...")
-
-StrictYAML is composed of two parts:
-
-- A new YAML specification which parses a restricted subset of the [YAML 1.2 specification](https://github.com/yaml/yaml-spec/tree/spec-1.2)
-  and *only* parses to ordered dict, list or string.
-- An optional validator (which will, as requested, validate and cast parse some of those scalar string values to ints, floats, datetimes, etc.).
-
-Note that StrictYAML is *not* a new standard. If you have a syntax highlighter or editor or anything else that recognizes
-or reads YAML it will recognize StrictYAML in the same way.
-
-While not all YAML output by other programs will be readable by StrictYAML (it is, after all, stricter), a lot will be.
-
-The features removed from the YAML spec, and their rationales are as follows:
-
-- [Implicit Typing](../../why/implicit-typing-removed)
-- [Direct representations of objects](../../why/not-parse-direct-representations-of-python-objects)
-- [Explicit tags](../../why/explicit-tags-removed)
-- [Node anchors and refs](../../why/node-anchors-and-references-removed)
-- [Flow style](../../why/flow-style-removed)
-- [Duplicate Keys Disallowed](../../why/duplicate-keys-disallowed)
-
diff --git a/docs/src/why-not/pykwalify.md b/docs/src/why-not/pykwalify.md
deleted file mode 100644
index 1f2acb9..0000000
--- a/docs/src/why-not/pykwalify.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: Why not use kwalify with standard YAML to validate my YAML?
----
-
-Kwalify is a schema validation language that is written *in* YAML.
-
-It is a descriptive schema language suitable for validating simple YAML.
-
-Kwalify compiles to the strictyaml equivalent but is able to do less. You cannot, for example:
-
-- Plug generated lists that come from outside of the spec (e.g. a list of country code from pycountry).
-- Validate parts of the schema which can be either one thing *or* another - e.g. a list *or* a single string.
-- Plug sub-validators of a document into larger validators.
-
-If your schema is very simple and small, there is no point to using kwalify.
-
-If your schema needs to be shared with a 3rd party - especially a third party using another language, it may be helpful to use it.
-
-If your schema validation requirements are more complicated - e.g. like what is described above - it's best *not* to use it.
diff --git a/docs/src/why-not/python-schema.md b/docs/src/why-not/python-schema.md
deleted file mode 100644
index 985f8fd..0000000
--- a/docs/src/why-not/python-schema.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: Why not use Python's schema library (or similar) for validation?
----
-
-Python's 'schema' (as well as similar libraries) can also be used to validate
-the structure of objects. Validating YAML is even [cited as a reason on their
-README](https://github.com/keleshev/schema).
-
-Using a schema for validation requires running the YAML through a parser
-first which and then taking the output (usually a data structure like a dict)
-and passing it through the schema.
-
-Unfortunately there are a number of problems with this approach:
-
-
-## You still have [the Norway Problem](../../why/implicit-typing-removed)
-
-If the standard YAML parser parses 'NO' as false or [empty string as
-None](https://github.com/Grokzen/pykwalify/issues/77) then it doesn't
-really matter if the schema says an empty string or the text 'NO' is
-okay, it will be seeing a 'None' or a 'False' which will cause a failure.
-
-
-## You can't get line numbers and snippets for the validation errors
-
-Assuming you've successfully circumvented the Norway problem, parsing
-and feeding the output to schema is still problematic. If you pass a
-parsed dict to schema, schema can't tell which line number the failure
-happened on and can't give you a code snippet highlighting where it
-happened.
-
-
-## Roundtripping becomes very very difficult if not impossible
-
-Due to the loss of metadata about parsed YAML being lost when it
-is fed into a generic schema validator, it also becomes impossible to
-to *change* the data and serialize it without losing critical
-details (i.e. mapping ordering, comments or validation structures).
diff --git a/docs/src/why-not/sdlang.md b/docs/src/why-not/sdlang.md
deleted file mode 100644
index db47d45..0000000
--- a/docs/src/why-not/sdlang.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: Why not use SDLang?
----
-
-[SDLang](http://sdlang.org/) or "simple declarative language" is a proposed configuration language with an XML-like structure inspired by C.
-
-Example:
-
-```
-// This is a node with a single string value
-title "Hello, World"
-
-// Multiple values are supported, too
-bookmarks 12 15 188 1234
-
-// Nodes can have attributes
-author "Peter Parker" email="peter@example.org" active=true
-
-// Nodes can be arbitrarily nested
-contents {
-    section "First section" {
-        paragraph "This is the first paragraph"
-        paragraph "This is the second paragraph"
-    }
-}
-
-// Anonymous nodes are supported
-"This text is the value of an anonymous node!"
-
-// This makes things like matrix definitions very convenient
-matrix {
-    1 0 0
-    0 1 0
-    0 0 1
-}
-```
-
-Advantages:
-
-- Relatively more straightforward than other serialization languages.
-
-Disadvantages:
-
-- Syntax typing - leading to noisy syntax.
-- The distinction between properties and values is not entirely clear.
-- Instead of having one obvious way to describe property:value mappings
-- Niche
diff --git a/docs/src/why-not/toml-indentation-1.png b/docs/src/why-not/toml-indentation-1.png
deleted file mode 100644
index 531a2b1..0000000
Binary files a/docs/src/why-not/toml-indentation-1.png and /dev/null differ
diff --git a/docs/src/why-not/toml.md b/docs/src/why-not/toml.md
deleted file mode 100644
index 982c947..0000000
--- a/docs/src/why-not/toml.md
+++ /dev/null
@@ -1,170 +0,0 @@
----
-title: What is wrong with TOML?
----
-
-```yaml
-# This is a TOML document.
-
-title = "TOML Example"
-
-[owner]
-name = "Tom Preston-Werner"
-dob = 1979-05-27T07:32:00-08:00 # First class dates
-```
-
-[TOML](https://github.com/toml-lang/toml) is a configuration designed as a sort
-of "improved" [INI file](../ini). It's analogous to this project -
-[StrictYAML](https://github.com/crdoconnor/strictyaml), a similar attempt
-to [fix YAML's flaws](../../features-removed):
-
-```yaml
-# All about the character
-name: Ford Prefect
-age: 42
-possessions:
-- Towel
-```
-
-I'm not going to argue here that TOML is the *worst* file format out there -
-if you use it infrequently on small and simple files it does its job fine.
-
-It's a warning though: as you scale up its usage, many bad warts start to appear.
-
-Martin Vejnár, the author of PyTOML
-[argued exactly this](https://github.com/avakar/pytoml/issues/15#issuecomment-217739462).
-He initially built a TOML parser out of enthusiasm for this new format but later abandoned
-it. When asked if he would like to see his library used as a dependency for pip as
-part of [PEP-518](https://www.python.org/dev/peps/pep-0518/), he said no - and
-explained why he abandoned the project:
-
->TOML is a bad file format. **It looks good at first glance**, and for really really
->trivial things it is probably good. But once I started using it and the
->configuration schema became more complex, I found the syntax ugly and hard to read.
-
-Despite this, PyPA still went ahead and used TOML for PEP-518. Fortunately
-pyproject.toml *is* fairly trivial and appears just once per project
-so the problems he alludes to aren't that pronounced.
-
-StrictYAML, by contrast, was designed to be a language to write
-[readable 'story' tests](../../../hitchstory) where there will be *many* files
-per project with more complex hierarchies, a use case where TOML starts
-to really suck.
-
-So what specifically *is* wrong with TOML when you scale it up?
-
-
-## 1. It's very verbose. It's not DRY. It's syntactically noisy.
-
-In [this example of a StrictYAML story](https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map.story)
-and [its equivalent serialized TOML](https://github.com/crdoconnor/strictyaml/blob/master/hitch/story/map.toml)
-the latter ends up [spending](https://www.goodreads.com/quotes/775257-my-point-today-is-that-if-we-wish-to-count)
-**50% more** characters to represent the exact same data.
-
-This is largely due to the design decision to have the full name of every key being
-associated with every value which is **not** [DRY](../../../code-quality/least-code).
-
-It is also partly due to the large numbers of syntactic cruft - quotation marks
-and square brackets dominate TOML documents whereas in the StrictYAML example they are
-absent.
-
-Shortening program lengths (and DRYing code), all other things being equal,
-[reduces the number of bugs significantly](https://blog.codinghorror.com/diseconomies-of-scale-and-lines-of-code/)
-because maintenance becomes easier and deriving intent from the code becomes clearer.
-What goes for Turing-complete code also applies to configuration code.
-
-
-## 2. TOML's hierarchies are difficult to infer from syntax alone
-
-Mapping hierarchy in TOML is determined by dots. This is simple enough for
-parsers to read and understand but this alone makes it difficult to perceive
-the relationships between data.
-
-This has been recognized by [many](https://github.com/leereilly/csi/blob/567e5b55f766847c9dcc7de482c0fd241fa7377a/lib/data/master.toml) TOML [writers](https://github.com/CzarSimon/simonlindgren.info/blob/a391a6345b16f2d8093f6d4c5f422399b4b901eb/simon-cv/config.toml) who have adopted a method that
-will be quite familiar to a lot of programmers - indentation that the parser ignores:
-
-[![Non-meaningful indentation](toml-indentation-1.png)](https://github.com/gazreese/gazreese.com/blob/c4c3fa7d576a4c316f11f0f7a652ca11ab23586d/Hugo/config.toml)
-
-This parallels the way indentation is added in *lots* of programming languages that have syntactic markers
-like brackets - e.g.  JSON, Javascript or Java are all commonly rendered with non-parsed indentation to make it
-easier for humans to understand them.
-
-But not Python.
-
-Python, has long been a stand out exception in how it was designed -
-syntactic markers are *not* necessary to infer program structure because indentation *is* the marker
-that determines program structure.
-
-This argument over the merits of meaningful indentation in Python has been going on for decades, and [not everybody agrees with this](https://www.quora.com/Do-you-think-that-indentation-in-Python-is-annoying), but it's generally
-considered a good idea - usually for [the reasons argued in this stack exchange question](https://softwareengineering.stackexchange.com/questions/313034/why-should-a-language-prefer-indentation-over-explicit-markers-for-blocks):
-
-1. Python inherited the significant indentation from the (now obsolete) predecessor language ABC. ABC is one of the very few programming languages which have used usability testing to direct the design. So while discussions about syntax usually comes down to subjective opinions and personal preferences, the choice of significant indentation actually has a sounder foundation.
-
-2. Guido van Rossum came across subtle bugs where the indentation disagreed with the syntactic grouping. Meaningful indentation fixed this class of bug. Since there are no begin/end brackets there cannot be a disagreement between grouping perceived by the parser and the human reader.
-
-3. Having symbols delimiting blocks and indentation violates the DRY principle.
-
-4. It does away with the typical religious C debate of "where to put the curly braces" (although TOML is not yet popular enough to inspire such religious wars over indentation... yet).
-
-
-## 3. Overcomplication: Like YAML, TOML has too many features
-
-Somewhat ironically, TOML's creator quite rightly
-[criticizes YAML for not aiming for simplicity](https://github.com/toml-lang/toml#comparison-with-other-formats)
-and then falls into the same trap itself - albeit not quite as deeply.
-
-One way it does this is by trying to include date and time parsing which imports
-*all* of the inherent complications associated with dates and times.
-
-Dates and times, as many more experienced programmers are probably aware is an unexpectedly deep rabbit hole
-of [complications and quirky, unexpected, headache and bug inducing edge cases](https://infiniteundo.com/post/25326999628/falsehoods-programmers-believe-about-time). TOML experiences [many](https://github.com/uiri/toml/issues/55) [of these](https://github.com/uiri/toml/issues/196) [edge cases](https://github.com/uiri/toml/issues/202) because of this.
-
-The best way to deal with [essential complexity](https://simplicable.com/new/accidental-complexity-vs-essential-complexity) like these is to decouple, isolate the complexity and *delegate* it to a
-[specialist tool that is good at handling that specific problem](https://en.wikipedia.org/wiki/Unix_philosophy)
-which you can swap out later if required.
-
-This the approach that JSON took (arguably a good decision) and it's the approach that StrictYAML takes too.
-
-StrictYAML the library (as opposed to the format) has a validator that uses
-[Python's most popular date/time parsing library](https://dateutil.readthedocs.io/en/stable/) although
-developers are not obliged or even necessarily encouraged to use this. StrictYAML parses everything as a
-string by default and whatever validation occurs later is considered to be outside of its purview.
-
-
-## 4. Syntax typing
-
-Like most other markup languages TOML has [syntax typing](../../why/syntax-typing-bad) -
-the *writer* of the markup decides if, for example, something should be parsed as a number
-or a string:
-
-```toml
-flt2 = 3.1415
-string = "hello"
-```
-
-Programmers will feel at home maintaining this, but non programmers tend to find the
-difference between "1.5" and 1.5 needlessly confusing.
-
-StrictYAML does not require quotes around any value to infer a data type because the
-schema is assumed to be the single source of truth for type information:
-
-```yaml
-flt2: 3.1415
-string: hello
-```
-
-In the above example it just removes two characters, but in larger documents with more
-complex data, pushing type parsing decision to the schema (or assuming strings)
-removes an enormous amount of syntactic noise.
-
-The lack of syntax typing combined with the use of indentation instead of square brackets
-to denote hierarchies makes equivalent StrictYAML documents 10-20% shorter, cleaner
-and ultimately more readable.
-
-
-## Advantages of TOML still has over StrictYAML
-
-There are currently still a few:
-
-- StrictYAML does not currently have an "official spec". The spec is currently just "YAML 1.2 with [features removed](../../features-removed)". This has some advantages (e.g. YAML syntax highlighting in editors works just fine) but also some disadvantages (some documents will render differently).
-- StrictYAML does not yet have parsers in languages other than Python. If you'd like to write one for your language (if you don't also do validation it actually wouldn't be very complicated), contact me, I'd love to help you in any way I can - including doing a test suite and documentation.
-- Popularity.
diff --git a/docs/src/why-not/turing-complete-code.md b/docs/src/why-not/turing-complete-code.md
deleted file mode 100644
index fc01416..0000000
--- a/docs/src/why-not/turing-complete-code.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Why shouldn't I just use Python code for configuration?
----
-
-It is relatively common for many applications to avoid the use of a different
-markup language for configuration and simply allow configuration to be
-done using code. One famous and unapologetic example of this is
-[Django](https://docs.djangoproject.com/en/1.10/ref/settings), which
-requires all configuration to be in a "settings.py" or similar file.
-
-This seems like a great idea from the outset - Python is more flexible
-than any configuration language, so, for instance, if you wanted to
-use a list comprehension or read a file or call an API to fill a value,
-you can.
-
-However, with this flexibility comes many traps and unsightly
-pitfalls. The Django pitfalls in particular are
-[cogently summed up by Ned Bachelder on
-his blog](http://nedbatchelder.com/blog/201112/duplicitous_django_settings.html) -
-pitfalls which have been the cause of countless bugs over the
-years.
-
-The language expressiveness trade off applies at every level in code
-
-- [We need less powerful languages](http://lukeplant.me.uk/blog/posts/less-powerful-languages/).
-- [Rule of least power (wikipedia)](https://en.wikipedia.org/wiki/Rule_of_least_power).
-- [Principle of least power by Tim Berners Lee](https://www.w3.org/DesignIssues/Principles.html#PLP).
-- [Principle of least power by Jeff Atwood (coding horror blogger / stack overflow founder)](https://blog.codinghorror.com/the-principle-of-least-power/).
-
-A good way of refactoring, in fact, is to take a large chunk of Turing-complete Python code that *can* be transformed directly into StrictYAML with no loss in expressiveness and and to transform it - for example, a list of translation strings, countries or parameters.
-
-It also makes it easier to have the markup generated by another program or a templating language.
-While you technically *can* do this with Turing-complete code, it will often lead to a debugging nightmare - [just ask C++ programmers](https://stackoverflow.com/questions/622659/what-are-the-good-and-bad-points-of-c-templates>)!
diff --git a/docs/src/why-not/xml.md b/docs/src/why-not/xml.md
deleted file mode 100644
index 6fd4fa4..0000000
--- a/docs/src/why-not/xml.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Why not use XML for configuration or DSLs?
----
-
-XML suffers from overcomplication much like vanilla YAML does - although to an ever greater degree, thanks to the committee-driven design.
-Doctypes and namespaces are horrendous additions to the language, for instance.
-XML is not only not really human readable (beyond a very basic subset of the language), it's often barely *programmer* readable despite being less expressive than most Turing-complete languages.
-It's a flagrant violation of the [rule of least power](https://en.wikipedia.org/wiki/Rule_of_least_power).
-
-The language was, in fact, *so* overcomplicated that it ended up increasing the attack surface of the parser itself to the point that it led to parsers with [security vulnerabilities](https://en.wikipedia.org/wiki/Billion_laughs).
-
-Unlike JSON and YAML, XML's structure also does not map well on to the default data types used by most languages, often requiring a *third* language to act as a go between - e.g. either XQuery or XPath.
-
-XML's decline in favor of JSON as a default API format is largely due to these complications and the lack of any real benefit drawn from them.
-The associated technologies (e.g. XSLT) also suffered from design by committee.
-
-Using it as a configuration language will all but ensure that you need to write extra boilerplate code to manage its quirks.
diff --git a/docs/src/why/duplicate-keys-disallowed.md b/docs/src/why/duplicate-keys-disallowed.md
deleted file mode 100644
index 5349ac0..0000000
--- a/docs/src/why/duplicate-keys-disallowed.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: What is wrong with duplicate keys?
----
-
-Duplicate keys are allowed in regular YAML - as parsed by pyyaml, ruamel.yaml and poyo:
-
-```yaml
-x: cow
-y: dog
-x: bull
-```
-
-Not only is it unclear whether x should be "cow" or "bull" (the parser will decide 'bull', but did you know that?),
-if there are 200 lines between x: cow and x: bull, a user might very likely change the *first* x and erroneously believe that the resulting value of x has been changed - when it hasn't.
-
-In order to avoid all possible confusion, StrictYAML will simply refuse to parse this and will *only* accept associative arrays where all of the keys are unique. It will throw a DuplicateKeysDisallowed exception.
diff --git a/docs/src/why/explicit-tags-removed.md b/docs/src/why/explicit-tags-removed.md
deleted file mode 100644
index d0b86ca..0000000
--- a/docs/src/why/explicit-tags-removed.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: What is wrong with explicit tags?
----
-
-Explicit tags are tags that have an explicit type attached that is used to determine what type to convert the data to when it is parsed.
-
-For example, if it were to be applied to "fix" the Godfather movie script parsing issue described above, it would look like this:
-
-```yaml
-- Don Corleone: Do you have faith in my judgment?
-- Clemenza: !!str Yes
-- Don Corleone: Do I have your loyalty?
-```
-
-Explicit typecasts in YAML markup are slightly confusing for non-programmers, much like the concept of 'types' in general. StrictYAML's philosophy is that types should be kept strictly separated from data, so this 'feature' of YAML is switched off.
-
-If tags are seen in a YAML file it will raise a special TagTokenDisallowed exception.
-
-
-## Counterpoints
-
-- [Valid usage in AWS cloudformation syntax?](https://github.com/crdoconnor/strictyaml/issues/37)
diff --git a/docs/src/why/flow-style-removed.md b/docs/src/why/flow-style-removed.md
deleted file mode 100644
index 7f00947..0000000
--- a/docs/src/why/flow-style-removed.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: What is wrong with flow-style YAML?
----
-
-Flow style is essentially JSON embedded in YAML - making use of curly { } and square brackets to denote lists and mappings.
-
-Example:
-
-```yaml
-a: 1
-b: {c: 3, d: 4}
-```
-
-This use of JSONesque { and } is also ugly and hampers readability - *especially* when { and } are used for other purposes (e.g. templating) and the human reader/writer of YAML has to give themselves a headache figuring out what *kind* of curly bracket it is.
-
-The *first* question in the FAQ of pyyaml actually subtly indicates that this feature wasn't a good idea - see "[why does my YAML look wrong?](http://pyyaml.org/wiki/PyYAMLDocumentation#Dictionarieswithoutnestedcollectionsarenotdumpedcorrectly)".
-
-To take a real life example, use of flow style in [this saltstack YAML definition](https://github.com/saltstack-formulas/mysql-formula/blob/master/mysql/server.sls#L27) which blurs the distinction between flow style and jinja2,
-confusing the reader.
-
-
-## Parsing 'dirty' YAML with flow style
-
-To parse YAML with flow style, you can use [dirty load](../../using/alpha/restrictions/loading-dirty-yaml).
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/20>
-- <https://github.com/crdoconnor/strictyaml/issues/38>
diff --git a/docs/src/why/implicit-typing-removed.md b/docs/src/why/implicit-typing-removed.md
deleted file mode 100644
index e50a8b2..0000000
--- a/docs/src/why/implicit-typing-removed.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-title: The Norway Problem - why StrictYAML refuses to do implicit typing and so should you
----
-
-A while back I met an old coworker and he started telling me about this
-interesting bug he faced:
-
-"So, we started internationalizing the website by creating a config
-file. We added the UK, Ireland, France and Germany at first."
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-```
-
-"This was all fine. However, one day after a quick configuration change
-all hell broke loose. It turned out that while the UK, France and
-Germany were all fine, *Norway* was *not*..."
-
-"While the website went down and we were losing money we chased down
-a number of loose ends until finally finding the root cause."
-
-"If turned out that if feed this configuration file into
-[pyyaml](http://pyyaml.org):"
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-- NO
-```
-
-"This is what you got in return:"
-
-```python
->>> from pyyaml import load
->>> load(the_configuration)
-{'countries': ['GB', 'IE', 'FR', 'DE', False]}
-```
-
-It snows a *lot* in False.
-
-When this is fed to code that expects a string of the form 'NO',
-then the code will usually break, often with a cryptic error,
-Typically it would be a KeyError when trying to use 'False'
-as a key in a dict when no such key exists.
-
-It can be "quick fixed" by using quotes - a fix for sure, but
-kind of a hack - and by that time the damage is done:
-
-```yaml
-countries:
-- GB
-- IE
-- FR
-- DE
-- 'NO'
-```
-
-The most tragic aspect of this bug, however, is that it is
-*intended* behavior according to the [YAML 1.2 specification](https://github.com/yaml/yaml-spec/tree/spec-1.2).
-The real fix requires explicitly disregarding the spec - which
-is why most YAML parsers have it.
-
-StrictYAML sidesteps this problem by ignoring key parts of the
-spec, in an attempt to create a "zero surprises" parser.
-
-*Everything* is a string by default:
-
-```python
->>> from strictyaml import load
->>> load(the_configuration).data
-{'countries': ['GB', 'IE', 'FR', 'DE', 'NO']}
-```
-
-
-## String or float?
-
-Norway is just the tip of the iceberg. The first time this problem hit me
-I was maintaining a configuration file of application versions. I had
-a file like this initially - which caused no issues:
-
-```yaml
-python: 3.5.3
-postgres: 9.3.0
-```
-
-However, if I changed it *very* slightly:
-
-```yaml
-python: 3.5.3
-postgres: 9.3
-```
-
-I started getting type errors because it was parsed like this:
-
-```python
->>> from ruamel.yaml import load
->>> load(versions) == [{"python": "3.5.3", "postgres": 9.3}]    # oops those *both* should have been strings
-```
-
-Again, this led to type errors in my code. Again, I 'quick fixed' it with quotes.
-However, the solution I really wanted was:
-
-```python
->>> from strictyaml import load
->>> load(versions) == [{"python": "3.5.3", "postgres": "9.3"}]    # that's better
-```
-
-
-## The world's most buggy name
-
-[Christopher Null](http://www.wired.com/2015/11/null) has a name that is
-notorious for breaking software code - airlines, banks, every bug caused
-by a programmer who didn't know a type from their elbow has hit him.
-
-YAML, sadly, is no exception:
-
-```yaml
-first name: Christopher
-surname: Null
-```
-
-```python
-# Is it okay if we just call you Christopher None instead?
->>> load(name) == {"first name": "Christopher", "surname": None}
-```
-
-With StrictYAML:
-
-```python
->>> from strictyaml import load
->>> load(name) == {"first name": "Christopher", "surname": "Null"}
-```
-
-
-## Type theoretical concerns
-
-Type theory is a popular topic with regards to programming languages,
-where a well designed type system is regarded (rightly) as a yoke that
-can catch bugs at an early stage of development while *poorly*
-designed type systems provide fertile breeding ground for edge case
-bugs.
-
-(it's equally true that extremely strict type systems require a lot
-more upfront and the law of diminishing returns applies to type
-strictness - a cogent answer to the question "why is so little
-software written in haskell?").
-
-A less popular, although equally true idea is the notion that markup
-languages like YAML have the same issues with types - as demonstrated
-above.
-
-
-## User Experience
-
-In a way, type systems can be considered both a mathematical concern
-and a UX device.
-
-In the above, and in most cases, implicit typing represents a major violation
-of the UX [principle of least astonishment](https://en.wikipedia.org/wiki/Principle_of_least_astonishment).
diff --git a/docs/src/why/index.md b/docs/src/why/index.md
deleted file mode 100644
index a9d8807..0000000
--- a/docs/src/why/index.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Design Justifications
----
-
-StrictYAML is the result of some carefully considered, although
-controversial design decisions. These are justified here.
-
-{% for dirfile in (thisdir.is_not_dir() - thisdir.named("index.md"))|sort() -%}
-- [{{ title(dirfile) }}]({{ dirfile.name.splitext()[0] }})
-{% endfor %}
-
-If you have seen a relevant counterargument to you'd like to link
-to addressed at StrictYAML, please create a pull request and
-link to it in the relevant document.
-
-If you'd like to write your own rebuttal to any argument raised
-here, raise a ticket and issue a pull request linking to it at
-the end of the document.
diff --git a/docs/src/why/node-anchors-and-references-removed.md b/docs/src/why/node-anchors-and-references-removed.md
deleted file mode 100644
index 56ea660..0000000
--- a/docs/src/why/node-anchors-and-references-removed.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: What is wrong with node anchors and references?
----
-
-An example of a snippet of YAML that uses node anchors and references is described on the [YAML wikipedia page](https://en.wikipedia.org/wiki/YAML#Advanced_components):
-
-```yaml
-# sequencer protocols for Laser eye surgery
----
-- step:  &id001                  # defines anchor label &id001
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-
-- step: &id002
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step: *id001                   # refers to the first step (with anchor &id001)
-- step: *id002                   # refers to the second step
-- step:
-    <<: *id001
-    spotSize: 2mm                # redefines just this key, refers rest from &id001
-- step: *id002
-```
-
-While the intent of the feature is obvious (it lets you deduplicate code), the effect is to make the markup
-more or less unreadable to non-programmers.
-
-The example above could be refactored to be clearly as follows:
-
-```yaml
-# sequencer protocols for Laser eye surgery
----
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        2mm
-- step:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-```
-
-The intent of this document is a lot clearer than the version above - *especially* for
-non-programmers. However, it comes at a cost of increased repetition.
-
-Between the node/anchor version and this I would prefer this.
-
-However, it is still repetitive and ideally it should be non-repetitive and still
-clear. This can be done by refactoring the *structure* of the document and changing
-the way the application interprets it.
-
-For example, instead of representing using the schema above, a schema that separates
-step definitions from actual steps could be used. For example:
-
-```yaml
-step definitions:
-  large:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.4
-    pulseDuration:   12
-    repetition:      1000
-    spotSize:        1mm
-  medium:
-    instrument:      Lasik 2000
-    pulseEnergy:     5.0
-    pulseDuration:   10
-    repetition:      500
-    spotSize:        2mm
-steps:
-- step: large
-- step: medium
-- step: large
-- step: medium
-- step:
-    from: large
-    except:
-      spotSize: 2mm
-- step: large
-```
-
-The above document has an entirely different and slightly complex schema but it
-fundamentally represents the same data as the node/anchor version above, in a clearer
-manner, without duplication.
diff --git a/docs/src/why/not-parse-direct-representations-of-python-objects.md b/docs/src/why/not-parse-direct-representations-of-python-objects.md
deleted file mode 100644
index c5a4f73..0000000
--- a/docs/src/why/not-parse-direct-representations-of-python-objects.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-title: Why does StrictYAML not parse direct representations of Python objects?
----
-
-Regular YAML allows the direct representation of Python objects.
-
-For example:
-
-```yaml
---- !python/hash:UserObject
-email: evilhacker@hacker.com
-password: passwordtoset
-type: admin
-```
-
-If we load this YAML formatted string in, we get a user object. This was
-how YAML was intended to work since it allows the ability to write objects
-to and read them from, say, a database.
-
-By itself, this behavior isn't necessarily capable of enacting a successful
-attack, so not all code that parses untrusted YAML is insecure,
-but it can be used, especially in conjunction with metaprogramming to execute
-arbitrary code on your system.
-
-This shares a lot in common with the pickle module's behavior, which is why
-its use with [untrusted input is strongly recommended against in the Python
-docs](https://docs.python.org/3/library/pickle.html).
-
-This anti-feature led to Ruby on Rails' spectacular [security fail](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/).
diff --git a/docs/src/why/only-parse-strings-not-files.md b/docs/src/why/only-parse-strings-not-files.md
deleted file mode 100644
index 6da7724..0000000
--- a/docs/src/why/only-parse-strings-not-files.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Why does StrictYAML only parse from strings and not files?
----
-
-While other parsers will take strings, file handles and file names,
-StrictYAML will only parse YAML strings.
-
-This is done deliberately to reduce the module's remit, with the
-intention of reducing both the potential bug surface and the number
-of exceptions that StrictYAML has to deal with - things like
-nonexistent files, file system errors, bad reads, unknown file
-extensions, etc. become the problem of some other module - ideally
-one more focused on handling those kinds of issues.
-
-If you want a quick and easy one liner way to get text from a file,
-I recommend that you pip install path.py and and use .text() on the
-Path object:
-
-```python
->>> from path import Path
->>> from strictyaml import load
->>> parsed_data = load(Path("myfile.yaml").text()).data
->>> print(parsed_data)
-[ parsed yaml ]
-```
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/5>
diff --git a/docs/src/why/speed-not-a-priority.md b/docs/src/why/speed-not-a-priority.md
deleted file mode 100644
index 1d3d9b1..0000000
--- a/docs/src/why/speed-not-a-priority.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Why is parsing speed not a high priority for StrictYAML?
----
-
-JSON and StrictYAML are essentially complementary formats. They both allow
-a relatively loose representation of data that just contains, mappings and
-sequences. They are serialization formats that are relatively straightforward
-for both humans and machines to read and write.
-
-The main difference is simply one of degree:
-
-JSON is primarily optimized for *machine* readability and writability, while
-still maintaining human readability.
-
-YAML is optimized for *human* readability and writability, while maintaining
-machine readability and writability.
-
-This means that the two formats are better suited to slightly different applications.
-For instance, JSON is better suited as a format for use with REST APIs while
-YAML is better suited as a format for use by configuration languages and DSLs.
-
-If you are using YAML primarily as a readable medium to express a markup language
-or represent configuration in, this probably means that 1) what you are reading is
-probably relatively short (e.g. < 1,000 lines) and 2) it will be read/written
-infrequently (e.g. once, when a program starts).
-
-For this reason, it is assumed that for most StrictYAML applications, parsing
-speed is of a lower importance than strictness, readability and ease of use.
-
-That being said, any requests that improve parsing or writing speed are welcome.
diff --git a/docs/src/why/syntax-typing-bad.md b/docs/src/why/syntax-typing-bad.md
deleted file mode 100644
index 4c9a24f..0000000
--- a/docs/src/why/syntax-typing-bad.md
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: What is syntax typing?
----
-
-Explicit syntax typing is the use of syntax to designate the type of some data.
-It is a feature of the design of most programming languages.
-
-```python
-x = "11" # this is a string
-y = 11   # this isn't
-```
-
-It it isn't limited to programming languages though. It's a common feature of
-serialization formats like JSON:
-
-```json
-{"x": "11", "y": 42}
-```
-
-But not others, like INI:
-
-```ini
-server=192.0.2.62
-port=143
-```
-
-Or CSV:
-
-```ini
-server,port
-192.0.2.62,143
-```
-
-Or StrictYAML:
-
-```yaml
-server: 192.0.2.62
-port: 143
-```
-
-In those cases, it's up to the program - in another file - to decide what part
-of that data is and what part is an integer.
-
-
-## What does it mean to attach syntax typing to data?
-
-Syntax typing the explicit prioritization of cohesion over terseness. It
-puts type information right next to the data, but in the process this
-means that if the data appears a *lot*
-
-
-## When would you sacrifice terseness?
-
-Let's return to Python for a second and imagine that
-
-```python
-x = "11" # this is a string
-y = 11   # this isn't
-```
-
-This helps distinguish the types for the parser, which is useful for JSON, but it also comes with two disadvantages:
-
-- The distinction is subtle and not particularly clear to *non-programmers*, who will not necessarily understand that a directive needs to be given to the parser to avoid it being misinterpreted.
-- It's not necessary if the type structure is maintained outside of the markup.
-- Verbosity - two extra characters per string makes the markup longer and noisier.
-
-In JSON when being used as a REST API, syntax typing is often an *advantage* - it is explicit to the machine reading the JSON that "string" and "age" is an integer and it can convert accordingly *in the absence of a schema*.
-
-StrictYAML assumes all values are strings unless the schema explicitly indicates otherwise (e.g. Map(Int(), Int())).
-
-StrictYAML does not require quotation marks for strings that are implicitly converted to other types (e.g. yes or 1.5), but it does require quotation marks for strings that are syntactically confusing (e.g. "{ text in curly brackets }")
-
-Standard YAML has explicit syntax typing to explicitly declare strings, although it's confusing as hell to know when it's required and when it is not. For example:
-
-```yaml
-a: text               # not necessary
-b: "yes"              # necessary
-c: "0"                # necessary
-d: "3.5"              # necessary
-e: in                 # not necessary
-f: out                # not necessary
-g: shake it all about # not necessary
-h: "on"               # necessary
-```
-
-Most other configuration language formats also make use of syntax typing. For example:
-
-- [TOML](../../why-not/toml)
-- [JSON5](../../why-not/json5)
-- [HJSON](../../why-not/hjson)
-- [SDLang](../../why-not/sdlang)
-- [HOCON](../../why-not/hocon)
-
-[INI](../../why-not/ini) does not have explicit syntax typing however.
diff --git a/docs/src/why/turing-complete-schema.md b/docs/src/why/turing-complete-schema.md
deleted file mode 100644
index 9a96d44..0000000
--- a/docs/src/why/turing-complete-schema.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Why does StrictYAML make you define a schema in Python - a Turing-complete language?
----
-
-StrictYAML defines schemas in Python (i.e. Turing-complete) code. For example:
-
-```python
-Map({"name": Str(), "email": Str()})
-```
-
-Instead of:
-
-```yaml
-type:       map
-mapping:
-"name":
-    type:      str
-    required:  yes
-"email":
-    type:      str
-    required:  yes
-```
-
-There are some trade offs here:
-
-Schema definition in a non-Turing-complete language like YAML makes
-the schema programming language independent and gives it more
-potential for being read and understood by non-programmers.
-
-However, schema definition in a non-Turing-complete language also
-restricts and makes certain use cases impossible or awkward.
-
-Some use cases I came across included:
-
-- Being able to import pycountry's country list and restrict "country: " to valid country names.
-- Being able to implement a schema that validated date/time scalar values against the specific date/time parser I wanted.
-- Being able to revalidate sections of the document on a 'second pass' that used new data - e.g. a list in one part of the document is restricted to items which come from another part.
-
-
-## Counterarguments
-
-- <https://github.com/crdoconnor/strictyaml/issues/16>
diff --git a/hitch/Dockerfile-hitch b/hitch/Dockerfile-hitch
new file mode 100644
index 0000000..fdb19db
--- /dev/null
+++ b/hitch/Dockerfile-hitch
@@ -0,0 +1,30 @@
+FROM ubuntu:18.04
+
+
+RUN apt-get update
+RUN apt-get install libuv1-dev -y
+RUN apt-get install curl -y
+RUN apt-get install git -y
+RUN apt-get install libreadline-dev -y
+RUN apt-get install libffi-dev -y
+RUN apt-get install python3-virtualenv -y
+RUN apt-get install virtualenv -y
+RUN apt-get install build-essential -y
+RUN apt-get install python3-dev -y
+RUN apt-get install zlib1g-dev -y
+RUN apt-get install zlib1g -y
+RUN apt-get install libbz2-dev -y
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get install make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python-openssl -y
+
+
+# Isolate system python packages from those used in project
+RUN virtualenv --python=python3 /venv
+RUN mkdir /src
+
+WORKDIR /src
+COPY hitch/hitchreqs.txt /
+ENV LC_ALL=C.UTF-8
+ENV LANG=C.UTF-8
+RUN /venv/bin/pip install setuptools-rust
+RUN /venv/bin/pip install -r /hitchreqs.txt
diff --git a/hitch/engine.py b/hitch/engine.py
index 0a4f5b5..fcd047d 100644
--- a/hitch/engine.py
+++ b/hitch/engine.py
@@ -1,4 +1,10 @@
-from hitchstory import StoryCollection, BaseEngine, exceptions, validate, no_stacktrace_for
+from hitchstory import (
+    StoryCollection,
+    BaseEngine,
+    exceptions,
+    validate,
+    no_stacktrace_for,
+)
 from hitchstory import GivenDefinition, GivenProperty, InfoDefinition, InfoProperty
 from templex import Templex
 from strictyaml import Optional, Str, Map, Int, Bool, Enum, load
@@ -11,7 +17,6 @@ from hitchrunpy import (
 )
 
 
-
 CODE_TYPE = Map({"in python 2": Str(), "in python 3": Str()}) | Str()
 
 
@@ -20,27 +25,21 @@ class Engine(BaseEngine):
 
     given_definition = GivenDefinition(
         yaml_snippet=GivenProperty(
-            Str(),
-            document="yaml_snippet:\n```yaml\n{{ yaml_snippet }}\n```"
+            Str(), document="yaml_snippet:\n```yaml\n{{ yaml_snippet }}\n```"
         ),
         yaml_snippet_1=GivenProperty(
-            Str(),
-            document="yaml_snippet_1:\n```yaml\n{{ yaml_snippet_1 }}\n```"
+            Str(), document="yaml_snippet_1:\n```yaml\n{{ yaml_snippet_1 }}\n```"
         ),
         yaml_snippet_2=GivenProperty(
-            Str(),
-            document="yaml_snippet_2:\n```yaml\n{{ yaml_snippet_2 }}\n```"
+            Str(), document="yaml_snippet_2:\n```yaml\n{{ yaml_snippet_2 }}\n```"
         ),
         modified_yaml_snippet=GivenProperty(
             Str(),
-            document="modified_yaml_snippet:\n```yaml\n{{ modified_yaml_snippet }}\n```"
+            document="modified_yaml_snippet:\n```yaml\n{{ modified_yaml_snippet }}\n```",
         ),
         python_version=GivenProperty(Str()),
         ruamel_version=GivenProperty(Str()),
-        setup=GivenProperty(
-            Str(),
-            document="```python\n{{ setup }}\n```"
-        ),
+        setup=GivenProperty(Str(), document="```python\n{{ setup }}\n```"),
     )
 
     info_definition = InfoDefinition(
@@ -65,11 +64,11 @@ class Engine(BaseEngine):
             self.path.profile.mkdir()
 
         if not self._python_path:
-            self.pylibrary = hitchpylibrarytoolkit.PyLibraryBuild(
-                "strictyaml",
-                self.path
-            ).with_python_version(self.given["python version"])\
-             .with_packages({"ruamel.yaml": self.given["ruamel version"]})
+            self.pylibrary = (
+                hitchpylibrarytoolkit.PyLibraryBuild("strictyaml", self.path)
+                .with_python_version(self.given["python version"])
+                .with_packages({"ruamel.yaml": self.given["ruamel version"]})
+            )
             self.pylibrary.ensure_built()
             self.python = self.pylibrary.bin.python
         else:
@@ -79,9 +78,7 @@ class Engine(BaseEngine):
         self.example_py_code = (
             ExamplePythonCode(self.python, self.path.gen)
             .with_code(self.given.get("code", ""))
-            .with_setup_code(
-                self.given.get("setup", "")
-            )
+            .with_setup_code(self.given.get("setup", ""))
             .with_terminal_size(160, 100)
             .with_strings(
                 yaml_snippet_1=self.given.get("yaml_snippet_1"),
@@ -110,11 +107,13 @@ class Engine(BaseEngine):
         if in_interpreter:
             if self.given["python version"].startswith("3"):
                 code = "{0}\nprint(repr({1}))".format(
-                    "\n".join(code.strip().split("\n")[:-1]), code.strip().split("\n")[-1]
+                    "\n".join(code.strip().split("\n")[:-1]),
+                    code.strip().split("\n")[-1],
                 )
             else:
                 code = "{0}\nprint repr({1})".format(
-                    "\n".join(code.strip().split("\n")[:-1]), code.strip().split("\n")[-1]
+                    "\n".join(code.strip().split("\n")[:-1]),
+                    code.strip().split("\n")[-1],
                 )
 
         to_run = self.example_py_code.with_code(code)
diff --git a/hitch/hitchreqs.in b/hitch/hitchreqs.in
index f2fc0d5..4842ee0 100644
--- a/hitch/hitchreqs.in
+++ b/hitch/hitchreqs.in
@@ -1,2 +1,2 @@
+hitchpylibrarytoolkit==0.5.1
 hitchrun>=0.4.0
-hitchpylibrarytoolkit>=0.5.1
diff --git a/hitch/hitchreqs.txt b/hitch/hitchreqs.txt
index 73f5865..eb2a3db 100644
--- a/hitch/hitchreqs.txt
+++ b/hitch/hitchreqs.txt
@@ -1,20 +1,18 @@
-appdirs==1.4.4
-    # via black
 argcomplete==1.12.2
     # via hitchrun
 backcall==0.2.0
     # via ipython
-black==20.8b1
+black==21.11b1
     # via hitchpylibrarytoolkit
-bleach==3.2.1
+bleach==4.1.0
     # via readme-renderer
-certifi==2020.11.8
+certifi==2021.10.8
     # via requests
-cffi==1.14.4
+cffi==1.15.0
     # via cryptography
-chardet==3.0.4
+charset-normalizer==2.0.8
     # via requests
-click==7.1.2
+click==8.0.3
     # via
     #   black
     #   hitchrun
@@ -30,20 +28,18 @@ commandlib==0.3.5
     #   hitchbuildpy
     #   hitchrun
     #   icommandlib
-cryptography==3.2.1
+cryptography==36.0.0
     # via secretstorage
-decorator==4.4.2
+decorator==5.1.0
     # via ipython
 dirtemplate==0.4.0
     # via hitchpylibrarytoolkit
-docutils==0.16
+docutils==0.18.1
     # via readme-renderer
-flake8==3.8.4
+flake8==4.0.1
     # via hitchpylibrarytoolkit
-gitdb==4.0.5
+gitdb==4.0.9
     # via gitpython
-gitpython==3.1.11
-    # via hitchpylibrarytoolkit
 hitchbuild==0.6.3
     # via
     #   dirtemplate
@@ -56,25 +52,27 @@ hitchrun==0.4.0
     # via
     #   -r hitchreqs.in
     #   hitchpylibrarytoolkit
-hitchrunpy==0.10.0
+hitchrunpy==0.11.2
     # via hitchpylibrarytoolkit
 hitchstory==0.12.1
     # via hitchpylibrarytoolkit
 icommandlib==0.5.0
     # via hitchrunpy
-idna==2.10
+idna==3.3
     # via requests
-ipython==7.16.1
+importlib-metadata==3.10.0
+    # via
+    #   keyring
+    #   twine
+ipython==7.16.3
     # via hitchpylibrarytoolkit
-ipython-genutils==0.2.0
-    # via traitlets
-jedi==0.17.2
+jedi==0.17.1
     # via ipython
-jeepney==0.6.0
+jeepney==0.7.1
     # via
     #   keyring
     #   secretstorage
-jinja2==2.11.2
+jinja2==3.0.3
     # via
     #   dirtemplate
     #   hitchrunpy
@@ -82,19 +80,21 @@ jinja2==2.11.2
     #   prettystack
 kaching==0.4.2
     # via hitchpylibrarytoolkit
-keyring==21.5.0
+keyring==23.3.0
     # via twine
-markupsafe==1.1.1
+markupsafe==2.0.1
     # via jinja2
+matplotlib-inline==0.1.3
+    # via ipython
 mccabe==0.6.1
     # via flake8
 mypy-extensions==0.4.3
     # via black
-packaging==20.7
+packaging==21.3
     # via bleach
 parso==0.7.1
     # via jedi
-path==15.0.0
+path==16.2.0
     # via path.py
 path.py==12.5.0
     # via
@@ -110,9 +110,9 @@ pathquery==0.3.0
     #   hitchbuild
     #   hitchbuildpy
     #   hitchstory
-pathspec==0.8.1
+pathspec==0.9.0
     # via black
-peewee==3.14.0
+peewee==3.14.8
     # via hitchbuild
 pep517==0.12.0
     # via pip-tools
@@ -122,36 +122,38 @@ pickleshare==0.7.5
     # via ipython
 pip-tools==6.4.0
     # via hitchrun
-pkginfo==1.6.1
+pkginfo==1.8.1
     # via twine
+platformdirs==2.4.0
+    # via black
 prettystack==0.3.0
     # via
     #   hitchrun
     #   hitchrunpy
     #   hitchstory
-prompt-toolkit==3.0.8
+prompt-toolkit==3.0.23
     # via ipython
-psutil==5.7.3
+psutil==5.8.0
     # via icommandlib
-ptyprocess==0.6.0
+ptyprocess==0.7.0
     # via pexpect
-pycodestyle==2.6.0
+pycodestyle==2.8.0
     # via flake8
-pycparser==2.20
+pycparser==2.21
     # via cffi
-pyflakes==2.2.0
+pyflakes==2.4.0
     # via flake8
-pygments==2.7.2
+pygments==2.10.0
     # via
     #   ipython
     #   readme-renderer
-pyparsing==2.4.7
+pyparsing==3.0.6
     # via packaging
 pyte==0.8.0
     # via icommandlib
-python-dateutil==2.8.1
+python-dateutil==2.8.2
     # via strictyaml
-python-slugify==4.0.1
+python-slugify==5.0.2
     # via
     #   dirtemplate
     #   hitchbuild
@@ -160,29 +162,27 @@ pyuv==1.4.0
     # via icommandlib
 q==2.6
     # via hitchpylibrarytoolkit
-readme-renderer==28.0
+readme-renderer==30.0
     # via twine
-regex==2020.11.13
+regex==2021.11.10
     # via black
-requests==2.25.0
+requests==2.26.0
     # via
     #   requests-toolbelt
     #   twine
 requests-toolbelt==0.9.1
     # via twine
-rfc3986==1.4.0
+rfc3986==1.5.0
     # via twine
-secretstorage==3.3.0
+secretstorage==3.3.1
     # via keyring
-six==1.15.0
+six==1.16.0
     # via
     #   bleach
-    #   cryptography
     #   python-dateutil
-    #   readme-renderer
-smmap==3.0.4
+smmap==5.0.0
     # via gitdb
-strictyaml==1.5.0
+strictyaml==1.6.0
     # via
     #   dirtemplate
     #   hitchstory
@@ -190,23 +190,25 @@ templex==0.2.0
     # via hitchpylibrarytoolkit
 text-unidecode==1.3
     # via python-slugify
-toml==0.10.2
-    # via black
 tomli==1.2.2
-    # via pep517
-tqdm==4.54.0
+    # via
+    #   black
+    #   pep517
+tqdm==4.62.3
     # via twine
-traitlets==5.0.4
-    # via ipython
-twine==3.2.0
+traitlets==4.3.3
+    # via
+    #   ipython
+    #   matplotlib-inline
+twine==3.6.0
     # via hitchpylibrarytoolkit
-typed-ast==1.4.1
-    # via black
-typing-extensions==3.7.4.3
-    # via black
-urllib3==1.26.2
+typing-extensions==4.0.0
+    # via
+    #   black
+    #   gitpython
+urllib3==1.26.7
     # via requests
-uvloop==0.14.0
+uvloop==0.11.2
     # via icommandlib
 wcwidth==0.2.5
     # via
@@ -216,6 +218,8 @@ webencodings==0.5.1
     # via bleach
 wheel==0.37.0
     # via pip-tools
+zipp==3.6.0
+    # via importlib-metadata
 
 # The following packages are considered to be unsafe in a requirements file:
 # pip
diff --git a/hitch/key.py b/hitch/key.py
index 6e3411d..336bddc 100644
--- a/hitch/key.py
+++ b/hitch/key.py
@@ -1,12 +1,29 @@
-from hitchstory import HitchStoryException, StoryCollection
-from hitchrun import expected
-from commandlib import CommandError
+from hitchstory import StoryCollection
 from strictyaml import Str, Map, Bool, load
+from commandlib import Command, python
+from click import argument, group, pass_context
 from pathquery import pathquery
-from hitchrun import DIR
-import dirtemplate
 import hitchpylibrarytoolkit
 from engine import Engine
+from path import Path
+
+
+class Directories:
+    gen = Path("/gen")
+    key = Path("/src/hitch/")
+    project = Path("/src/")
+    share = Path("/gen")
+
+
+DIR = Directories()
+
+
+@group(invoke_without_command=True)
+@pass_context
+def cli(ctx):
+    """Integration test command line interface."""
+    pass
+
 
 PROJECT_NAME = "strictyaml"
 
@@ -67,8 +84,9 @@ RUNNABLE COMMANDS
 """
 
 
-@expected(HitchStoryException)
-def bdd(*keywords):
+@cli.command()
+@argument("keywords", nargs=-1)
+def bdd(keywords):
     """
     Run story matching keywords.
     """
@@ -77,8 +95,10 @@ def bdd(*keywords):
     ).only_uninherited().shortcut(*keywords).play()
 
 
-@expected(HitchStoryException)
-def tver(pyversion, *keywords):
+@cli.command()
+@argument("pyversion", nargs=1)
+@argument("keywords", nargs=-1)
+def tver(pyversion, keywords):
     """
     Run story against specific version of Python - e.g. tver 3.7.0 modify multi line
     """
@@ -87,8 +107,9 @@ def tver(pyversion, *keywords):
     ).only_uninherited().shortcut(*keywords).play()
 
 
-@expected(HitchStoryException)
-def rbdd(*keywords):
+@cli.command()
+@argument("keywords", nargs=-1)
+def rbdd(keywords):
     """
     Run story matching keywords and rewrite story if code changed.
     """
@@ -97,7 +118,8 @@ def rbdd(*keywords):
     ).only_uninherited().shortcut(*keywords).play()
 
 
-@expected(HitchStoryException)
+@cli.command()
+@argument("filename", nargs=1)
 def regressfile(filename):
     """
     Run all stories in filename 'filename' in python 3.7.
@@ -107,18 +129,20 @@ def regressfile(filename):
     ).ordered_by_name().play()
 
 
-@expected(HitchStoryException)
+@cli.command()
 def regression():
     """
     Run regression testing - lint and then run all tests.
     """
-    lint()
-    doctests()
+    _lint()
+    _doctests()
     storybook = _storybook().only_uninherited()
     storybook.with_params(**{"python version": "3.7.0"}).ordered_by_name().play()
 
 
-@expected(HitchStoryException)
+@cli.command()
+@argument("python_path", nargs=1)
+@argument("python_version", nargs=1)
 def regression_on_python_path(python_path, python_version):
     """
     Run regression tests - e.g. hk regression_on_python_path /usr/bin/python 3.7.0
@@ -128,7 +152,7 @@ def regression_on_python_path(python_path, python_version):
     ).only_uninherited().ordered_by_name().play()
 
 
-@expected(hitchpylibrarytoolkit.ToolkitError)
+@cli.command()
 def checks():
     """
     Run all checks ensure linter, code formatter, tests and docgen all run correctly.
@@ -137,13 +161,12 @@ def checks():
     """
     toolkit.validate_reformatting()
     toolkit.lint(exclude=["__init__.py", "ruamel"])
-    toolkit.validate_readmegen(Engine(DIR))
-    toolkit.validate_docgen(Engine(DIR))
-    doctests()
+    _doctests()
     storybook = _storybook().only_uninherited()
     storybook.with_params(**{"python version": "3.7.0"}).ordered_by_name().play()
 
 
+@cli.command()
 def reformat():
     """
     Reformat using black and then relint.
@@ -151,6 +174,7 @@ def reformat():
     toolkit.reformat()
 
 
+@cli.command()
 def ipython():
     """
     Run ipython in strictyaml virtualenv.
@@ -166,22 +190,45 @@ def ipython():
     ).run()
 
 
-@expected(CommandError)
+def _lint():
+    toolkit.lint(exclude=["__init__.py", "ruamel"])
+
+
+@cli.command()
 def lint():
     """
     Lint project code and hitch code.
     """
-    toolkit.lint(exclude=["__init__.py", "ruamel"])
+    _lint()
 
 
-def deploy(version):
+@cli.command()
+def deploy():
     """
     Deploy to pypi as specified version.
     """
-    toolkit.deploy(version)
+    git = Command("git")
+    git("clone", "git@github.com:crdoconnor/strictyaml.git").in_dir(DIR.gen).run()
+    project = DIR.gen / "strictyaml"
+    version = DIR.project.joinpath("VERSION").text().rstrip()
+    initpy = DIR.project.joinpath("strictyaml", "__init__.py")
+    original_initpy_contents = initpy.bytes().decode("utf8")
+    initpy.write_text(
+        original_initpy_contents.replace("DEVELOPMENT_VERSION", version)
+    )
+    python("setup.py", "sdist").in_dir(project).run()
+    initpy.write_text(original_initpy_contents)
+
+    # Upload to pypi
+    python(
+        "-m",
+        "twine",
+        "upload",
+        "dist/{0}-{1}.tar.gz".format("strictyaml", version),
+    ).in_dir(project).run()
 
 
-@expected(dirtemplate.exceptions.DirTemplateException)
+@cli.command()
 def docgen():
     """
     Build documentation.
@@ -189,7 +236,7 @@ def docgen():
     toolkit.docgen(Engine(DIR))
 
 
-@expected(dirtemplate.exceptions.DirTemplateException)
+@cli.command()
 def readmegen():
     """
     Build README.md and CHANGELOG.md.
@@ -197,11 +244,7 @@ def readmegen():
     toolkit.readmegen(Engine(DIR))
 
 
-@expected(CommandError)
-def doctests():
-    """
-    Run doctests in utils.py in python 2 and 3.
-    """
+def _doctests():
     for python_version in ["2.7.14", "3.7.0"]:
         pylibrary = hitchpylibrarytoolkit.PyLibraryBuild(
             "strictyaml",
@@ -212,7 +255,15 @@ def doctests():
         ).in_dir(DIR.project.joinpath(PROJECT_NAME)).run()
 
 
-@expected(CommandError)
+@cli.command()
+def doctests():
+    """
+    Run doctests in utils.py in python 2 and 3.
+    """
+    _doctests()
+
+
+@cli.command()
 def rerun():
     """
     Rerun last example code block with specified version of Python.
@@ -225,7 +276,7 @@ def rerun():
     ).in_dir(DIR.gen.joinpath("working")).run()
 
 
-@expected(CommandError)
+@cli.command()
 def bash():
     """
     Run bash
@@ -235,6 +286,7 @@ def bash():
     Command("bash").run()
 
 
+@cli.command()
 def build():
     import hitchpylibrarytoolkit
 
@@ -244,3 +296,7 @@ def build():
         "3.7.0",
         {"ruamel.yaml": "0.16.5"},
     )
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/hitch/story/email-url.story b/hitch/story/email-url.story
index 98c63f2..b897aaa 100644
--- a/hitch/story/email-url.story
+++ b/hitch/story/email-url.story
@@ -15,10 +15,10 @@ Email and URL validators:
       given:
         yaml_snippet: |
           a: billg@microsoft.com
-          b: http://www.twitter.com/@realDonaldTrump
+          b: https://user:pass@example.com:443/path?k=v#frag
       steps:
       - Run: |
-          Ensure(load(yaml_snippet, schema)).equals({"a": "billg@microsoft.com", "b": "http://www.twitter.com/@realDonaldTrump"})
+          Ensure(load(yaml_snippet, schema)).equals({"a": "billg@microsoft.com", "b": "https://user:pass@example.com:443/path?k=v#frag"})
 
     Exception:
       given:
diff --git a/hitch/todo.yml b/hitch/todo.yml
deleted file mode 100644
index 2e0f0ee..0000000
--- a/hitch/todo.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-- Create rules such that only certain map key combinations are allowed. x and y, x alone, c and y, c alone, etc.
-
-- Using YAML objects as keys causes infinite loop.
-
-- Add why not section on jsonschema and yaml/ruamel.yaml
-
-- Add why not section on kwalify and ruamel.yaml
-
-- Add why not section on schema and yaml/ruamel.yaml
-
-- Add scalar types AbsoluteUrl(), RelativeUrl(), Domain()
-
-- Consider adding scalar types PositiveInt and Base64.
-
-- Refactor so that custom scalar validators can be written.
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..8bfd5a1
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+
diff --git a/setup.py b/setup.py
index b71b48b..dea5647 100644
--- a/setup.py
+++ b/setup.py
@@ -11,40 +11,50 @@ import os
 def read(*parts):
     # intentionally *not* adding an encoding option to open
     # see here: https://github.com/pypa/virtualenv/issues/201#issuecomment-3145690
-    with codecs.open(os.path.join(os.path.abspath(os.path.dirname(__file__)), *parts)) as f:
+    with codecs.open(
+        os.path.join(os.path.abspath(os.path.dirname(__file__)), *parts)
+    ) as f:
         return f.read()
 
 
-setup(name="strictyaml",
-      version=read('VERSION').replace('\n', ''),
-      description="Strict, typed YAML parser",
-      long_description=read('README.md'),
-      long_description_content_type="text/markdown",
-      classifiers=[
-          'Development Status :: 4 - Beta',
-          'Intended Audience :: Developers',
-          'License :: OSI Approved :: MIT License',
-          'Topic :: Text Processing :: Markup',
-          'Topic :: Software Development :: Libraries',
-          'Natural Language :: English',
-          'Programming Language :: Python :: 2',
-          'Programming Language :: Python :: 2.6',
-          'Programming Language :: Python :: 2.7',
-          'Programming Language :: Python :: 3',
-          'Programming Language :: Python :: 3.1',
-          'Programming Language :: Python :: 3.2',
-          'Programming Language :: Python :: 3.3',
-          'Programming Language :: Python :: 3.4',
-          'Programming Language :: Python :: 3.5',
-      ],
-      keywords='yaml',
-      author='Colm O\'Connor',
-      author_email='colm.oconnor.github@gmail.com',
-      url='http://hitchdev.com/strictyaml',
-      license='MIT',
-      install_requires=["python-dateutil>=2.6.0", ],
-      packages=find_packages(exclude=["tests", "docs", ]),
-      package_data={},
-      zip_safe=False,
-      include_package_data=True,
+setup(
+    name="strictyaml",
+    version=read("VERSION").replace("\n", ""),
+    description="Strict, typed YAML parser",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Topic :: Text Processing :: Markup",
+        "Topic :: Software Development :: Libraries",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.6",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.1",
+        "Programming Language :: Python :: 3.2",
+        "Programming Language :: Python :: 3.3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+    ],
+    keywords="yaml",
+    author="Colm O'Connor",
+    author_email="colm.oconnor.github@gmail.com",
+    url="http://hitchdev.com/strictyaml",
+    license="MIT",
+    install_requires=[
+        "python-dateutil>=2.6.0",
+    ],
+    packages=find_packages(
+        exclude=[
+            "tests",
+            "docs",
+        ]
+    ),
+    package_data={},
+    zip_safe=False,
+    include_package_data=True,
 )
diff --git a/strictyaml.egg-info/PKG-INFO b/strictyaml.egg-info/PKG-INFO
new file mode 100644
index 0000000..43dd3c8
--- /dev/null
+++ b/strictyaml.egg-info/PKG-INFO
@@ -0,0 +1,341 @@
+Metadata-Version: 2.1
+Name: strictyaml
+Version: 1.6.2
+Summary: Strict, typed YAML parser
+Home-page: http://hitchdev.com/strictyaml
+Author: Colm O'Connor
+Author-email: colm.oconnor.github@gmail.com
+License: MIT
+Keywords: yaml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# StrictYAML
+
+StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
+that parses and validates a [restricted subset](https://hitchdev.com/strictyaml/features-removed) of the [YAML](https://hitchdev.com/strictyaml/what-is-yaml)
+specification.
+
+Priorities:
+
+- Beautiful API
+- Refusing to parse [the ugly, hard to read and insecure features of YAML](https://hitchdev.com/strictyaml/features-removed) like [the Norway problem](https://hitchdev.com/strictyaml/why/implicit-typing-removed).
+- Strict validation of markup and straightforward type casting.
+- Clear, readable exceptions with **code snippets** and **line numbers**.
+- Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
+- Ability to read in YAML, make changes and write it out again with comments preserved.
+- [Not speed](https://hitchdev.com/strictyaml/why/speed-not-a-priority), currently.
+
+
+Simple example:
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 42
+possessions:
+- Towel
+
+```
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError
+
+```
+
+
+
+
+
+Default parse result:
+
+
+```python
+>>> load(yaml_snippet)
+YAML({'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']})
+```
+
+
+
+All data is string, list or OrderedDict:
+
+
+```python
+>>> load(yaml_snippet).data
+{'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']}
+```
+
+
+
+Quickstart with schema:
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError
+
+schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
+
+```
+
+
+
+
+
+42 is now parsed as an integer:
+
+
+```python
+>>> person = load(yaml_snippet, schema)
+>>> person.data
+{'name': 'Ford Prefect', 'age': 42, 'possessions': ['Towel']}
+```
+
+
+
+A YAMLError will be raised if there are syntactic problems, violations of your schema or use of disallowed YAML features:
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 42
+
+```
+
+
+
+
+
+
+For example, a schema violation:
+
+
+```python
+try:
+    person = load(yaml_snippet, schema)
+except YAMLError as error:
+    print(error)
+
+```
+
+```yaml
+while parsing a mapping
+  in "<unicode string>", line 1, column 1:
+    # All about the character
+     ^ (line: 1)
+required key(s) 'possessions' not found
+  in "<unicode string>", line 3, column 1:
+    age: '42'
+    ^ (line: 3)
+```
+
+
+
+
+
+If parsed correctly:
+
+
+```python
+from strictyaml import load, Map, Str, Int, Seq, YAMLError, as_document
+
+schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})
+
+```
+
+
+
+
+
+You can modify values and write out the YAML with comments preserved:
+
+
+```python
+person = load(yaml_snippet, schema)
+person['age'] = 43
+print(person.as_yaml())
+
+```
+
+```yaml
+# All about the character
+name: Ford Prefect
+age: 43
+possessions:
+- Towel
+```
+
+
+
+
+
+As well as look up line numbers:
+
+
+```python
+>>> person = load(yaml_snippet, schema)
+>>> person['possessions'][0].start_line
+5
+```
+
+
+
+And construct YAML documents from dicts or lists:
+
+
+```python
+print(as_document({"x": 1}).as_yaml())
+
+```
+
+```yaml
+x: 1
+```
+
+
+
+
+
+
+
+## Install
+
+```sh
+$ pip install strictyaml
+```
+
+
+## Why StrictYAML?
+
+There are a number of formats and approaches that can achieve more or
+less the same purpose as StrictYAML. I've tried to make it the best one.
+Below is a series of documented justifications:
+
+- [Why avoid using environment variables as configuration?](https://hitchdev.com/strictyaml/why-not/environment-variables-as-config)
+- [Why not use HJSON?](https://hitchdev.com/strictyaml/why-not/hjson)
+- [Why not HOCON?](https://hitchdev.com/strictyaml/why-not/hocon)
+- [Why not use INI files?](https://hitchdev.com/strictyaml/why-not/ini)
+- [Why not use JSON Schema for validation?](https://hitchdev.com/strictyaml/why-not/json-schema)
+- [Why not JSON for simple configuration files?](https://hitchdev.com/strictyaml/why-not/json)
+- [Why not JSON5?](https://hitchdev.com/strictyaml/why-not/json5)
+- [Why not use the YAML 1.2 standard? - we don't need a new standard!](https://hitchdev.com/strictyaml/why-not/ordinary-yaml)
+- [Why not use kwalify with standard YAML to validate my YAML?](https://hitchdev.com/strictyaml/why-not/pykwalify)
+- [Why not use Python's schema library (or similar) for validation?](https://hitchdev.com/strictyaml/why-not/python-schema)
+- [Why not use SDLang?](https://hitchdev.com/strictyaml/why-not/sdlang)
+- [What is wrong with TOML?](https://hitchdev.com/strictyaml/why-not/toml)
+- [Why shouldn't I just use Python code for configuration?](https://hitchdev.com/strictyaml/why-not/turing-complete-code)
+- [Why not use XML for configuration or DSLs?](https://hitchdev.com/strictyaml/why-not/xml)
+
+
+
+## Using StrictYAML
+
+How to:
+
+- [Build a YAML document from scratch in code](https://hitchdev.com/strictyaml/using/alpha/howto/build-yaml-document)
+- [Either/or schema validation of different, equally valid different kinds of YAML](https://hitchdev.com/strictyaml/using/alpha/howto/either-or-validation)
+- [Labeling exceptions](https://hitchdev.com/strictyaml/using/alpha/howto/label-exceptions)
+- [Merge YAML documents](https://hitchdev.com/strictyaml/using/alpha/howto/merge-yaml-documents)
+- [Revalidate an already validated document](https://hitchdev.com/strictyaml/using/alpha/howto/revalidation)
+- [Reading in YAML, editing it and writing it back out](https://hitchdev.com/strictyaml/using/alpha/howto/roundtripping)
+- [Get line numbers of YAML elements](https://hitchdev.com/strictyaml/using/alpha/howto/what-line)
+- [Parsing YAML without a schema](https://hitchdev.com/strictyaml/using/alpha/howto/without-a-schema)
+
+
+Compound validators:
+
+- [Fixed length sequences (FixedSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/fixed-length-sequences)
+- [Mappings combining defined and undefined keys (MapCombined)](https://hitchdev.com/strictyaml/using/alpha/compound/map-combined)
+- [Mappings with arbitrary key names (MapPattern)](https://hitchdev.com/strictyaml/using/alpha/compound/map-pattern)
+- [Mapping with defined keys and a custom key validator (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-with-slug-keys)
+- [Using a YAML object of a parsed mapping](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-yaml-object)
+- [Mappings with defined keys (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping)
+- [Optional keys with defaults (Map/Optional)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys-with-defaults)
+- [Validating optional keys in mappings (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys)
+- [Sequences of unique items (UniqueSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences-of-unique-items)
+- [Sequence/list validator (Seq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences)
+- [Updating document with a schema](https://hitchdev.com/strictyaml/using/alpha/compound/update)
+
+
+Scalar validators:
+
+- [Boolean (Bool)](https://hitchdev.com/strictyaml/using/alpha/scalar/boolean)
+- [Parsing comma separated items (CommaSeparated)](https://hitchdev.com/strictyaml/using/alpha/scalar/comma-separated)
+- [Datetimes (Datetime)](https://hitchdev.com/strictyaml/using/alpha/scalar/datetime)
+- [Decimal numbers (Decimal)](https://hitchdev.com/strictyaml/using/alpha/scalar/decimal)
+- [Email and URL validators](https://hitchdev.com/strictyaml/using/alpha/scalar/email-and-url)
+- [Empty key validation](https://hitchdev.com/strictyaml/using/alpha/scalar/empty)
+- [Enumerated scalars (Enum)](https://hitchdev.com/strictyaml/using/alpha/scalar/enum)
+- [Floating point numbers (Float)](https://hitchdev.com/strictyaml/using/alpha/scalar/float)
+- [Hexadecimal Integers (HexInt)](https://hitchdev.com/strictyaml/using/alpha/scalar/hexadecimal-integer)
+- [Integers (Int)](https://hitchdev.com/strictyaml/using/alpha/scalar/integer)
+- [Validating strings with regexes (Regex)](https://hitchdev.com/strictyaml/using/alpha/scalar/regular-expressions)
+- [Parsing strings (Str)](https://hitchdev.com/strictyaml/using/alpha/scalar/string)
+
+
+Restrictions:
+
+- [Disallowed YAML](https://hitchdev.com/strictyaml/using/alpha/restrictions/disallowed-yaml)
+- [Duplicate keys](https://hitchdev.com/strictyaml/using/alpha/restrictions/duplicate-keys)
+- [Dirty load](https://hitchdev.com/strictyaml/using/alpha/restrictions/loading-dirty-yaml)
+
+
+
+## Design justifications
+
+There are some design decisions in StrictYAML which are controversial
+and/or not obvious. Those are documented here:
+
+- [What is wrong with duplicate keys?](https://hitchdev.com/strictyaml/why/duplicate-keys-disallowed)
+- [What is wrong with explicit tags?](https://hitchdev.com/strictyaml/why/explicit-tags-removed)
+- [What is wrong with flow-style YAML?](https://hitchdev.com/strictyaml/why/flow-style-removed)
+- [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](https://hitchdev.com/strictyaml/why/implicit-typing-removed)
+- [What is wrong with node anchors and references?](https://hitchdev.com/strictyaml/why/node-anchors-and-references-removed)
+- [Why does StrictYAML not parse direct representations of Python objects?](https://hitchdev.com/strictyaml/why/not-parse-direct-representations-of-python-objects)
+- [Why does StrictYAML only parse from strings and not files?](https://hitchdev.com/strictyaml/why/only-parse-strings-not-files)
+- [Why is parsing speed not a high priority for StrictYAML?](https://hitchdev.com/strictyaml/why/speed-not-a-priority)
+- [What is syntax typing?](https://hitchdev.com/strictyaml/why/syntax-typing-bad)
+- [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](https://hitchdev.com/strictyaml/why/turing-complete-schema)
+
+
+
+## Star Contributors
+
+- @wwoods
+- @chrisburr
+- @jnichols0
+
+## Other Contributors
+
+- @eulores
+- @WaltWoods
+- @ChristopherGS
+- @gvx
+- @AlexandreDecan
+- @lots0logs
+- @tobbez
+- @jaredsampson
+- @BoboTIG
+
+StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.
+
+## Contributing
+
+- Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
+- Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
+- All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.
diff --git a/strictyaml.egg-info/SOURCES.txt b/strictyaml.egg-info/SOURCES.txt
new file mode 100644
index 0000000..8003241
--- /dev/null
+++ b/strictyaml.egg-info/SOURCES.txt
@@ -0,0 +1,103 @@
+LICENSE.txt
+MANIFEST.in
+README.md
+VERSION
+setup.py
+hitch/Dockerfile-hitch
+hitch/asroot.sh
+hitch/debugrequirements.txt
+hitch/engine.py
+hitch/glossary.yml
+hitch/hitchreqs.in
+hitch/hitchreqs.txt
+hitch/key.py
+hitch/printstats.py
+hitch/story/boolean.story
+hitch/story/bugs.story
+hitch/story/build-yaml-document-from-scratch.story
+hitch/story/commaseparated.story
+hitch/story/datetime.story
+hitch/story/decimal.story
+hitch/story/dirty-load.story
+hitch/story/disallow.story
+hitch/story/duplicatekeys.story
+hitch/story/email-url.story
+hitch/story/empty.story
+hitch/story/enum-with-item-validation.story
+hitch/story/enum.story
+hitch/story/fixed-sequence.story
+hitch/story/float.story
+hitch/story/handle-exceptions.story
+hitch/story/map-combined.story
+hitch/story/map-with-key-validator.story
+hitch/story/map.story
+hitch/story/map.toml
+hitch/story/mappattern.story
+hitch/story/mapping-representation.story
+hitch/story/merge-documents.story
+hitch/story/nested-map.story
+hitch/story/non-schema-validation.story
+hitch/story/optional-with-defaults.story
+hitch/story/optional.story
+hitch/story/or.story
+hitch/story/quickstart.story
+hitch/story/regexp.story
+hitch/story/revalidation.story
+hitch/story/roundtrip.story
+hitch/story/scalar-hexadecimal-integer.story
+hitch/story/scalar-integer.story
+hitch/story/scalar-string.story
+hitch/story/sequence.story
+hitch/story/single-value.story
+hitch/story/strictyaml.story
+hitch/story/unique-sequence.story
+hitch/story/update-with-schema.story
+hitch/story/validator-repr.story
+hitch/story/whatline.story
+strictyaml/__init__.py
+strictyaml/any_validator.py
+strictyaml/compound.py
+strictyaml/constants.py
+strictyaml/dumper.py
+strictyaml/exceptions.py
+strictyaml/parser.py
+strictyaml/representation.py
+strictyaml/scalar.py
+strictyaml/utils.py
+strictyaml/validators.py
+strictyaml/yamllocation.py
+strictyaml/yamlpointer.py
+strictyaml.egg-info/PKG-INFO
+strictyaml.egg-info/SOURCES.txt
+strictyaml.egg-info/dependency_links.txt
+strictyaml.egg-info/not-zip-safe
+strictyaml.egg-info/requires.txt
+strictyaml.egg-info/top_level.txt
+strictyaml/ruamel/__init__.py
+strictyaml/ruamel/anchor.py
+strictyaml/ruamel/comments.py
+strictyaml/ruamel/compat.py
+strictyaml/ruamel/composer.py
+strictyaml/ruamel/configobjwalker.py
+strictyaml/ruamel/constructor.py
+strictyaml/ruamel/cyaml.py
+strictyaml/ruamel/dumper.py
+strictyaml/ruamel/emitter.py
+strictyaml/ruamel/error.py
+strictyaml/ruamel/events.py
+strictyaml/ruamel/loader.py
+strictyaml/ruamel/main.py
+strictyaml/ruamel/nodes.py
+strictyaml/ruamel/parser.py
+strictyaml/ruamel/reader.py
+strictyaml/ruamel/representer.py
+strictyaml/ruamel/resolver.py
+strictyaml/ruamel/scalarbool.py
+strictyaml/ruamel/scalarfloat.py
+strictyaml/ruamel/scalarint.py
+strictyaml/ruamel/scalarstring.py
+strictyaml/ruamel/scanner.py
+strictyaml/ruamel/serializer.py
+strictyaml/ruamel/timestamp.py
+strictyaml/ruamel/tokens.py
+strictyaml/ruamel/util.py
\ No newline at end of file
diff --git a/strictyaml.egg-info/dependency_links.txt b/strictyaml.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/strictyaml.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/strictyaml.egg-info/not-zip-safe b/strictyaml.egg-info/not-zip-safe
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/strictyaml.egg-info/not-zip-safe
@@ -0,0 +1 @@
+
diff --git a/strictyaml.egg-info/requires.txt b/strictyaml.egg-info/requires.txt
new file mode 100644
index 0000000..1f1bb30
--- /dev/null
+++ b/strictyaml.egg-info/requires.txt
@@ -0,0 +1 @@
+python-dateutil>=2.6.0
diff --git a/strictyaml.egg-info/top_level.txt b/strictyaml.egg-info/top_level.txt
new file mode 100644
index 0000000..35824b9
--- /dev/null
+++ b/strictyaml.egg-info/top_level.txt
@@ -0,0 +1 @@
+strictyaml
diff --git a/strictyaml/__init__.py b/strictyaml/__init__.py
index 6febcb3..827fb22 100644
--- a/strictyaml/__init__.py
+++ b/strictyaml/__init__.py
@@ -53,4 +53,4 @@ from strictyaml.exceptions import AnchorTokenDisallowed
 from strictyaml.exceptions import DuplicateKeysDisallowed
 from strictyaml import exceptions
 
-__version__ = "DEVELOPMENT_VERSION"
+__version__ = "1.6.2"
diff --git a/strictyaml/compound.py b/strictyaml/compound.py
index 5de73c1..10899be 100644
--- a/strictyaml/compound.py
+++ b/strictyaml/compound.py
@@ -19,7 +19,7 @@ class Optional(object):
 
     def __repr__(self):
         # TODO: Add default
-        return u'Optional("{0}")'.format(self.key)
+        return 'Optional("{0}")'.format(self.key)
 
 
 class MapPattern(MapValidator):
@@ -52,20 +52,20 @@ class MapPattern(MapValidator):
 
         if self._maximum_keys is not None and len(items) > self._maximum_keys:
             chunk.expecting_but_found(
-                u"while parsing a mapping",
-                u"expected a maximum of {0} key{1}, found {2}.".format(
+                "while parsing a mapping",
+                "expected a maximum of {0} key{1}, found {2}.".format(
                     self._maximum_keys,
-                    u"s" if self._maximum_keys > 1 else u"",
+                    "s" if self._maximum_keys > 1 else "",
                     len(items),
                 ),
             )
 
         if self._minimum_keys is not None and len(items) < self._minimum_keys:
             chunk.expecting_but_found(
-                u"while parsing a mapping",
-                u"expected a minimum of {0} key{1}, found {2}.".format(
+                "while parsing a mapping",
+                "expected a minimum of {0} key{1}, found {2}.".format(
                     self._minimum_keys,
-                    u"s" if self._minimum_keys > 1 else u"",
+                    "s" if self._minimum_keys > 1 else "",
                     len(items),
                 ),
             )
@@ -87,7 +87,7 @@ class MapPattern(MapValidator):
         )
 
     def __repr__(self):
-        return u"MapPattern({0}, {1})".format(
+        return "MapPattern({0}, {1})".format(
             repr(self._key_validator), repr(self._value_validator)
         )
 
@@ -138,7 +138,7 @@ class Map(MapValidator):
 
     def __repr__(self):
         # TODO : repr key_validator
-        return u"Map({{{0}}})".format(
+        return "Map({{{0}}})".format(
             ", ".join(
                 [
                     "{0}: {1}".format(repr(key), repr(value))
@@ -152,8 +152,8 @@ class Map(MapValidator):
 
     def unexpected_key(self, key, yaml_key, value, chunk):
         key.expecting_but_found(
-            u"while parsing a mapping",
-            u"unexpected key not in schema '{0}'".format(unicode(yaml_key.scalar)),
+            "while parsing a mapping",
+            "unexpected key not in schema '{0}'".format(unicode(yaml_key.scalar)),
         )
 
     def validate(self, chunk):
@@ -201,8 +201,8 @@ class Map(MapValidator):
 
         if not set(self._required_keys).issubset(found_keys):
             chunk.while_parsing_found(
-                u"a mapping",
-                u"required key(s) '{0}' not found".format(
+                "a mapping",
+                "required key(s) '{0}' not found".format(
                     "', '".join(
                         sorted(list(set(self._required_keys).difference(found_keys)))
                     )
diff --git a/strictyaml/constants.py b/strictyaml/constants.py
index 89598c6..ecc3d05 100644
--- a/strictyaml/constants.py
+++ b/strictyaml/constants.py
@@ -6,6 +6,4 @@ BOOL_VALUES = TRUE_VALUES + FALSE_VALUES
 
 REGEXES = {
     "email": r".+?\@.+?",
-    # https://urlregex.com/
-    "url": r"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+",
 }
diff --git a/strictyaml/exceptions.py b/strictyaml/exceptions.py
index c9fc661..4d48dcd 100644
--- a/strictyaml/exceptions.py
+++ b/strictyaml/exceptions.py
@@ -43,7 +43,7 @@ class YAMLValidationError(StrictYAMLError):
     def context_mark(self):
         context_line = self._chunk.start_line() - 1
         str_document = dump(self._chunk.whole_document, Dumper=RoundTripDumper)
-        context_index = len(u"\n".join(str_document.split(u"\n")[:context_line]))
+        context_index = len("\n".join(str_document.split("\n")[:context_line]))
         return StringMark(
             self._chunk.label,
             context_index,
@@ -57,7 +57,7 @@ class YAMLValidationError(StrictYAMLError):
     def problem_mark(self):
         problem_line = self._chunk.end_line() - 1
         str_document = dump(self._chunk.whole_document, Dumper=RoundTripDumper)
-        problem_index = len(u"\n".join(str_document.split(u"\n")[:problem_line]))
+        problem_index = len("\n".join(str_document.split("\n")[:problem_line]))
         return StringMark(
             self._chunk.label,
             problem_index,
diff --git a/strictyaml/parser.py b/strictyaml/parser.py
index 028d3b4..b19245b 100644
--- a/strictyaml/parser.py
+++ b/strictyaml/parser.py
@@ -135,51 +135,51 @@ class StrictYAMLConstructor(RoundTripConstructor):
 
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:null", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:null", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:bool", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:bool", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:int", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:int", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:float", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:float", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:binary", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:binary", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:timestamp", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:timestamp", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:omap", RoundTripConstructor.construct_yaml_omap
+    "tag:yaml.org,2002:omap", RoundTripConstructor.construct_yaml_omap
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:pairs", RoundTripConstructor.construct_yaml_pairs
+    "tag:yaml.org,2002:pairs", RoundTripConstructor.construct_yaml_pairs
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:set", RoundTripConstructor.construct_yaml_set
+    "tag:yaml.org,2002:set", RoundTripConstructor.construct_yaml_set
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:str", RoundTripConstructor.construct_yaml_str
+    "tag:yaml.org,2002:str", RoundTripConstructor.construct_yaml_str
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:seq", RoundTripConstructor.construct_yaml_seq
+    "tag:yaml.org,2002:seq", RoundTripConstructor.construct_yaml_seq
 )
 
 StrictYAMLConstructor.add_constructor(
-    u"tag:yaml.org,2002:map", RoundTripConstructor.construct_yaml_map
+    "tag:yaml.org,2002:map", RoundTripConstructor.construct_yaml_map
 )
 
 StrictYAMLConstructor.add_constructor(None, RoundTripConstructor.construct_undefined)
@@ -257,7 +257,7 @@ class StrictYAMLLoader(
         VersionedResolver.__init__(self, version, loader=self)
 
 
-def as_document(data, schema=None, label=u"<unicode string>"):
+def as_document(data, schema=None, label="<unicode string>"):
     """
     Translate dicts/lists and scalar (string/bool/float/int/etc.) values into a
     YAML object which can be dumped out.
@@ -269,7 +269,7 @@ def as_document(data, schema=None, label=u"<unicode string>"):
 
 
 def generic_load(
-    yaml_string, schema=None, label=u"<unicode string>", allow_flow_style=False
+    yaml_string, schema=None, label="<unicode string>", allow_flow_style=False
 ):
     if not utils.is_string(yaml_string):
         raise TypeError("StrictYAML can only read a string of valid YAML.")
@@ -302,7 +302,7 @@ def generic_load(
 
 
 def dirty_load(
-    yaml_string, schema=None, label=u"<unicode string>", allow_flow_style=False
+    yaml_string, schema=None, label="<unicode string>", allow_flow_style=False
 ):
     """
     Parse the first YAML document in a string
@@ -315,7 +315,7 @@ def dirty_load(
     )
 
 
-def load(yaml_string, schema=None, label=u"<unicode string>"):
+def load(yaml_string, schema=None, label="<unicode string>"):
     """
     Parse the first YAML document in a string
     and produce corresponding YAML object.
diff --git a/strictyaml/representation.py b/strictyaml/representation.py
index a0d8dcf..25a4342 100644
--- a/strictyaml/representation.py
+++ b/strictyaml/representation.py
@@ -22,7 +22,6 @@ if sys.version_info[:2] < (3, 7):
                 + "}"
             )
 
-
 else:
     OrderedDict = dict
 
@@ -176,7 +175,7 @@ class YAML(object):
         return float(self._value)
 
     def __repr__(self):
-        return u"YAML({0})".format(self.data)
+        return "YAML({0})".format(self.data)
 
     def __bool__(self):
         if isinstance(self._value, bool):
diff --git a/strictyaml/ruamel/py.typed b/strictyaml/ruamel/py.typed
deleted file mode 100644
index e69de29..0000000
diff --git a/strictyaml/scalar.py b/strictyaml/scalar.py
index 8f45524..cb6e33f 100644
--- a/strictyaml/scalar.py
+++ b/strictyaml/scalar.py
@@ -10,6 +10,7 @@ import dateutil.parser
 import decimal
 import sys
 import re
+import urllib.parse
 from strictyaml.ruamel.scalarstring import PreservedScalarString
 
 
@@ -70,7 +71,7 @@ class Enum(ScalarValidator):
 
     def __repr__(self):
         # TODO : item_validator
-        return u"Enum({0})".format(repr(self._restricted_to))
+        return "Enum({0})".format(repr(self._restricted_to))
 
 
 class CommaSeparated(ScalarValidator):
@@ -144,10 +145,24 @@ class Email(Regex):
         self._matching_message = "when expecting an email address"
 
 
-class Url(Regex):
-    def __init__(self):
-        super(Url, self).__init__(constants.REGEXES["url"])
-        self._matching_message = "when expecting a url"
+class Url(ScalarValidator):
+    def __is_absolute_url(self, raw):
+        try:
+            ret = urllib.parse.urlparse(raw)
+            return ret.scheme != "" and ret.netloc != ""
+        except ValueError:
+            return False
+
+    def validate_scalar(self, chunk):
+        if not self.__is_absolute_url(chunk.contents):
+            chunk.expecting_but_found("when expecting a URL")
+        return chunk.contents
+
+    def to_yaml(self, data):
+        self.should_be_string(data, "expected a URL,")
+        if not self.__is_absolute_url(data):
+            raise YAMLSerializationError("'{}' is not a URL".format(data))
+        return data
 
 
 class Str(ScalarValidator):
@@ -216,7 +231,7 @@ class Bool(ScalarValidator):
             else:
                 raise YAMLSerializationError("Not a boolean")
         else:
-            return u"yes" if data else u"no"
+            return "yes" if data else "no"
 
 
 class Float(ScalarValidator):
@@ -292,7 +307,7 @@ class NullNone(ScalarValidator):
 
     def to_yaml(self, data):
         if data is None:
-            return u"null"
+            return "null"
         raise YAMLSerializationError("expected None, got '{}'")
 
 
@@ -309,7 +324,7 @@ class EmptyNone(ScalarValidator):
 
     def to_yaml(self, data):
         if data is None:
-            return u""
+            return ""
         raise YAMLSerializationError("expected None, got '{}'")
 
 
@@ -319,7 +334,7 @@ class EmptyDict(EmptyNone):
 
     def to_yaml(self, data):
         if data == {}:
-            return u""
+            return ""
         raise YAMLSerializationError("Not an empty dict")
 
 
@@ -329,5 +344,5 @@ class EmptyList(EmptyNone):
 
     def to_yaml(self, data):
         if data == []:
-            return u""
+            return ""
         raise YAMLSerializationError("expected empty list, got '{}'")
diff --git a/strictyaml/utils.py b/strictyaml/utils.py
index c653fe8..32ce5e0 100644
--- a/strictyaml/utils.py
+++ b/strictyaml/utils.py
@@ -240,7 +240,7 @@ def ruamel_structure(data, validator=None):
             )
         return CommentedSeq([ruamel_structure(item) for item in data])
     elif isinstance(data, bool):
-        return u"yes" if data else u"no"
+        return "yes" if data else "no"
     elif isinstance(data, (int, float)):
         return str(data)
     else:
diff --git a/strictyaml/validators.py b/strictyaml/validators.py
index 4362618..b63643b 100644
--- a/strictyaml/validators.py
+++ b/strictyaml/validators.py
@@ -18,7 +18,7 @@ class Validator(object):
         return YAML(chunk, validator=self)
 
     def __repr__(self):
-        return u"{0}()".format(self.__class__.__name__)
+        return "{0}()".format(self.__class__.__name__)
 
 
 class MapValidator(Validator):
@@ -115,4 +115,4 @@ class OrValidator(Validator):
             return result
 
     def __repr__(self):
-        return u"{0} | {1}".format(repr(self._validator_a), repr(self._validator_b))
+        return "{0} | {1}".format(repr(self._validator_a), repr(self._validator_b))
diff --git a/strictyaml/yamllocation.py b/strictyaml/yamllocation.py
index a81c9d7..cdffa1d 100644
--- a/strictyaml/yamllocation.py
+++ b/strictyaml/yamllocation.py
@@ -88,17 +88,17 @@ class YAMLChunk(object):
 
     def found(self):
         if self.is_sequence():
-            return u"a sequence"
+            return "a sequence"
         elif self.is_mapping():
-            return u"a mapping"
-        elif self.contents == u"":
-            return u"a blank string"
+            return "a mapping"
+        elif self.contents == "":
+            return "a blank string"
         elif utils.is_integer(self.contents):
-            return u"an arbitrary integer"
+            return "an arbitrary integer"
         elif utils.is_decimal(self.contents):
-            return u"an arbitrary number"
+            return "an arbitrary number"
         else:
-            return u"arbitrary text"
+            return "arbitrary text"
 
     def expect_sequence(self, expecting="when expecting a sequence"):
         if not self.is_sequence():

More details

Full run details