diff --git a/.gitignore b/.gitignore
index a56845c..f97a7cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,9 @@ package-lock.json
 /node_modules/
 /output/
 /generated-docs/
+/.pulp-cache/
+/.psc-package/
+/.psc*
+/.purs*
+/.psa*
+/.spago
diff --git a/src/Web/DOM/Attr.js b/src/Web/DOM/Attr.js
new file mode 100644
index 0000000..0a60b69
--- /dev/null
+++ b/src/Web/DOM/Attr.js
@@ -0,0 +1,13 @@
+export const _namespaceURI = (attr) => attr.namespaceURI;
+
+export const _prefix = (attr) => attr.prefix;
+
+export const localName = (attr) => attr.localName;
+
+export const getValue = (attr) => () => attr.value;
+
+export const setValue = (attr) => (value) => () => {
+  attr.value = value;
+};
+
+export const _ownerElement = (attr) => () => attr.ownerElement;
diff --git a/src/Web/DOM/Attr.purs b/src/Web/DOM/Attr.purs
new file mode 100644
index 0000000..6b6a34f
--- /dev/null
+++ b/src/Web/DOM/Attr.purs
@@ -0,0 +1,43 @@
+module Web.DOM.Attr
+  ( module Exports
+  , namespaceURI
+  , prefix
+  , localName
+  , getValue
+  , setValue
+  , ownerElement
+  ) where
+
+import Prelude
+
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import Effect (Effect)
+import Web.DOM.AttrName (AttrName)
+import Web.DOM.Internal.Types (Attr) as Exports
+import Web.DOM.Internal.Types (Attr, Element)
+import Web.DOM.NamespacePrefix (NamespacePrefix)
+import Web.DOM.NamespaceURI (NamespaceURI)
+
+foreign import _namespaceURI :: Attr -> Nullable NamespaceURI
+
+namespaceURI :: Attr -> Maybe NamespaceURI
+namespaceURI attr = toMaybe (_namespaceURI attr)
+
+foreign import _prefix :: Attr -> Nullable NamespacePrefix
+
+prefix :: Attr -> Maybe NamespacePrefix
+prefix attr = toMaybe (_prefix attr)
+
+foreign import localName :: Attr -> AttrName
+
+foreign import getValue :: Attr -> Effect String
+
+foreign import setValue :: Attr -> String -> Effect Unit
+
+foreign import _ownerElement :: Attr -> Effect (Nullable Element)
+
+-- | The element the attribute belongs to, unless the attribute is not (yet)
+-- | attached to an element.
+ownerElement :: Attr -> Effect (Maybe Element)
+ownerElement attr = map toMaybe (_ownerElement attr)
diff --git a/src/Web/DOM/AttrName.purs b/src/Web/DOM/AttrName.purs
new file mode 100644
index 0000000..52e5185
--- /dev/null
+++ b/src/Web/DOM/AttrName.purs
@@ -0,0 +1,12 @@
+module Web.DOM.AttrName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for attribute names.
+newtype AttrName = AttrName String
+
+derive instance newtypeAttrName :: Newtype AttrName _
+derive newtype instance eqAttrName :: Eq AttrName
+derive newtype instance ordAttrName :: Ord AttrName
diff --git a/src/Web/DOM/ClassName.purs b/src/Web/DOM/ClassName.purs
new file mode 100644
index 0000000..9657ec5
--- /dev/null
+++ b/src/Web/DOM/ClassName.purs
@@ -0,0 +1,12 @@
+module Web.DOM.ClassName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for strings which are used as CSS classes.
+newtype ClassName = ClassName String
+
+derive instance newtypeClassName :: Newtype ClassName _
+derive newtype instance eqClassName :: Eq ClassName
+derive newtype instance ordClassName :: Ord ClassName
diff --git a/src/Web/DOM/DOMTokenList.js b/src/Web/DOM/DOMTokenList.js
index 78b6ba8..0c4e759 100644
--- a/src/Web/DOM/DOMTokenList.js
+++ b/src/Web/DOM/DOMTokenList.js
@@ -1,23 +1,33 @@
-export function add(list) {
+export const length = (list) => () => list.length;
+
+export function _item(list) {
+  return function(index) {
+    return function() {
+      return list.item(index);
+    };
+  };
+}
+
+export function contains(list) {
   return function(token) {
     return function() {
-      return list.add(token);
+      return list.contains(token);
     };
   };
 }
 
-export function remove(list) {
+export function add(list) {
   return function(token) {
     return function() {
-      return list.remove(token);
+      return list.add(token);
     };
   };
 }
 
-export function contains(list) {
+export function remove(list) {
   return function(token) {
     return function() {
-      return list.contains(token);
+      return list.remove(token);
     };
   };
 }
@@ -40,10 +50,44 @@ export function toggleForce(list) {
   };
 }
 
-export function _item(list) {
-  return function(index) {
+export function replace(list) {
+  return function(token) {
+    return function(newToken) {
+      return function() {
+        return list.replace(token, newToken);
+      };
+    };
+  };
+}
+
+export function supports(list) {
+  return function(token) {
     return function() {
-      return list.item(index);
+      return list.supports(token);
+    };
+  };
+}
+
+export function getValue(list) {
+  return function() {
+    return list.value;
+  };
+}
+
+export function setValue(list) {
+  return function(token) {
+    return function() {
+      list.value = token;
     };
   };
 }
+
+export function tokens(list) {
+  return function () {
+    const result = [];
+    for (const token of list.tokens) {
+      result.push(token);
+    }
+    return result;
+  };
+}
diff --git a/src/Web/DOM/DOMTokenList.purs b/src/Web/DOM/DOMTokenList.purs
index 488597e..d2753d7 100644
--- a/src/Web/DOM/DOMTokenList.purs
+++ b/src/Web/DOM/DOMTokenList.purs
@@ -1,11 +1,17 @@
 module Web.DOM.DOMTokenList
   ( DOMTokenList
-  , add
-  , contains
+  , length
   , item
+  , contains
+  , add
   , remove
   , toggle
   , toggleForce
+  , replace
+  , supports
+  , getValue
+  , setValue
+  , tokens
   ) where
 
 import Prelude
@@ -16,17 +22,29 @@ import Data.Nullable (Nullable, toMaybe)
 
 foreign import data DOMTokenList :: Type
 
-foreign import add :: DOMTokenList -> String -> Effect Unit
+foreign import length :: DOMTokenList -> Effect Int
 
-foreign import remove :: DOMTokenList -> String -> Effect Unit
+foreign import _item :: DOMTokenList -> Int -> Effect (Nullable String)
+
+item :: DOMTokenList -> Int -> Effect (Maybe String)
+item index = map toMaybe <<< _item index
 
 foreign import contains :: DOMTokenList -> String -> Effect Boolean
 
+foreign import add :: DOMTokenList -> String -> Effect Unit
+
+foreign import remove :: DOMTokenList -> String -> Effect Unit
+
 foreign import toggle :: DOMTokenList -> String -> Effect Boolean
 
 foreign import toggleForce :: DOMTokenList -> String -> Boolean -> Effect Boolean
 
-foreign import _item :: DOMTokenList -> Int -> Effect (Nullable String)
+foreign import replace :: DOMTokenList -> String -> String -> Effect Unit
 
-item :: DOMTokenList -> Int -> Effect (Maybe String)
-item index = map toMaybe <<< _item index
+foreign import supports :: DOMTokenList -> String -> Effect Boolean
+
+foreign import getValue :: DOMTokenList -> Effect String
+
+foreign import setValue :: DOMTokenList -> String -> Effect Unit
+
+foreign import tokens :: DOMTokenList -> Effect (Array String)
diff --git a/src/Web/DOM/Document.js b/src/Web/DOM/Document.js
index 5b2d823..27244d7 100644
--- a/src/Web/DOM/Document.js
+++ b/src/Web/DOM/Document.js
@@ -9,7 +9,7 @@ var getEffProp = function (name) {
 export const url = getEffProp("URL");
 export const documentURI = getEffProp("documentURI");
 export const origin = getEffProp("origin");
-export const compatMode = getEffProp("compatMode");
+export const _compatMode = getEffProp("compatMode");
 export const characterSet = getEffProp("characterSet");
 export const contentType = getEffProp("contentType");
 export function _doctype(doc) {
diff --git a/src/Web/DOM/Document.purs b/src/Web/DOM/Document.purs
index 981f135..f108d49 100644
--- a/src/Web/DOM/Document.purs
+++ b/src/Web/DOM/Document.purs
@@ -39,16 +39,21 @@ module Web.DOM.Document
 
 import Prelude
 
-import Data.Maybe (Maybe)
+import Data.Maybe (Maybe, fromMaybe)
 import Data.Nullable (Nullable, toMaybe, toNullable)
 import Effect (Effect)
 import Unsafe.Coerce (unsafeCoerce)
+import Web.DOM.ClassName (ClassName)
 import Web.DOM.Comment (Comment)
+import Web.DOM.Document.CompatMode (CompatMode)
+import Web.DOM.Document.CompatMode as CompatMode
 import Web.DOM.DocumentFragment (DocumentFragment)
 import Web.DOM.DocumentType (DocumentType)
 import Web.DOM.Element (Element)
+import Web.DOM.ElementName (ElementName)
 import Web.DOM.HTMLCollection (HTMLCollection)
 import Web.DOM.Internal.Types (Node)
+import Web.DOM.NamespaceURI (NamespaceURI)
 import Web.DOM.NonElementParentNode (NonElementParentNode)
 import Web.DOM.ParentNode (ParentNode)
 import Web.DOM.ProcessingInstruction (ProcessingInstruction)
@@ -85,7 +90,12 @@ toEventTarget = unsafeCoerce
 foreign import url :: Document -> Effect String
 foreign import documentURI :: Document -> Effect String
 foreign import origin :: Document -> Effect String
-foreign import compatMode :: Document -> Effect String
+
+foreign import _compatMode :: Document -> Effect String
+
+compatMode :: Document -> Effect CompatMode
+compatMode doc = fromMaybe CompatMode.CSS1Compat <<< CompatMode.parse <$> _compatMode doc
+
 foreign import characterSet :: Document -> Effect String
 foreign import contentType :: Document -> Effect String
 
@@ -99,20 +109,20 @@ documentElement = map toMaybe <<< _documentElement
 
 foreign import _documentElement :: Document -> Effect (Nullable Element)
 
-foreign import getElementsByTagName :: String -> Document -> Effect HTMLCollection
+foreign import getElementsByTagName :: ElementName -> Document -> Effect HTMLCollection
 
-getElementsByTagNameNS :: Maybe String -> String -> Document -> Effect HTMLCollection
+getElementsByTagNameNS :: Maybe NamespaceURI -> ElementName -> Document -> Effect HTMLCollection
 getElementsByTagNameNS = _getElementsByTagNameNS <<< toNullable
 
-foreign import _getElementsByTagNameNS :: Nullable String -> String -> Document -> Effect HTMLCollection
-foreign import getElementsByClassName :: String -> Document -> Effect HTMLCollection
+foreign import _getElementsByTagNameNS :: Nullable NamespaceURI -> ElementName -> Document -> Effect HTMLCollection
+foreign import getElementsByClassName :: ClassName -> Document -> Effect HTMLCollection
 
-foreign import createElement :: String -> Document -> Effect Element
+foreign import createElement :: ElementName -> Document -> Effect Element
 
-createElementNS :: Maybe String -> String -> Document -> Effect Element
+createElementNS :: Maybe NamespaceURI -> ElementName -> Document -> Effect Element
 createElementNS = _createElementNS <<< toNullable
 
-foreign import _createElementNS :: Nullable String -> String -> Document -> Effect Element
+foreign import _createElementNS :: Nullable NamespaceURI -> ElementName -> Document -> Effect Element
 foreign import createDocumentFragment :: Document -> Effect DocumentFragment
 foreign import createTextNode :: String -> Document -> Effect Text
 foreign import createComment :: String -> Document -> Effect Comment
diff --git a/src/Web/DOM/Document/CompatMode.purs b/src/Web/DOM/Document/CompatMode.purs
new file mode 100644
index 0000000..355ee0d
--- /dev/null
+++ b/src/Web/DOM/Document/CompatMode.purs
@@ -0,0 +1,18 @@
+module Web.DOM.Document.CompatMode where
+
+import Data.Maybe (Maybe(..))
+
+data CompatMode
+  = BackCompat
+  | CSS1Compat
+
+parse ∷ String -> Maybe CompatMode
+parse = case _ of
+  "BackCompat" -> Just BackCompat
+  "CSS1Compat" -> Just CSS1Compat
+  _ -> Nothing
+
+print ∷ CompatMode -> String
+print = case _ of
+  BackCompat → "BackCompat"
+  CSS1Compat → "CSS1Compat"
diff --git a/src/Web/DOM/Element.js b/src/Web/DOM/Element.js
index 522403e..cf9800e 100644
--- a/src/Web/DOM/Element.js
+++ b/src/Web/DOM/Element.js
@@ -69,6 +69,8 @@ export function getElementsByClassName(classNames) {
   };
 }
 
+export const attributes = (element) => () => element.attributes;
+
 export function setAttribute(name) {
   return function (value) {
     return function (element) {
diff --git a/src/Web/DOM/Element.purs b/src/Web/DOM/Element.purs
index 4c66639..1914523 100644
--- a/src/Web/DOM/Element.purs
+++ b/src/Web/DOM/Element.purs
@@ -22,6 +22,7 @@ module Web.DOM.Element
   , getElementsByTagName
   , getElementsByTagNameNS
   , getElementsByClassName
+  , attributes
   , setAttribute
   , getAttribute
   , hasAttribute
@@ -42,26 +43,27 @@ module Web.DOM.Element
   , DOMRect
   , ShadowRootInit
   , attachShadow
-  , AttrName(..)
-  , ClassName(..)
-  , ElementId(..)
-  , PropName(..)
   ) where
 
 import Prelude
 
 import Data.Maybe (Maybe)
-import Data.Newtype (class Newtype)
 import Data.Nullable (Nullable, toMaybe, toNullable)
 import Effect (Effect)
 import Unsafe.Coerce (unsafeCoerce)
+import Web.DOM.AttrName (AttrName)
 import Web.DOM.ChildNode (ChildNode)
+import Web.DOM.ClassName (ClassName)
 import Web.DOM.DOMTokenList (DOMTokenList)
+import Web.DOM.ElementId (ElementId)
+import Web.DOM.ElementName (ElementName)
 import Web.DOM.Internal.Types (Element) as Exports
-import Web.DOM.Internal.Types (Element, HTMLCollection, Node)
+import Web.DOM.Internal.Types (Element, HTMLCollection, Node, NamedNodeMap)
+import Web.DOM.NamespacePrefix (NamespacePrefix)
+import Web.DOM.NamespaceURI (NamespaceURI)
 import Web.DOM.NonDocumentTypeChildNode (NonDocumentTypeChildNode)
-import Web.DOM.ParentNode (QuerySelector) as Exports
 import Web.DOM.ParentNode (ParentNode, QuerySelector)
+import Web.DOM.ParentNode (QuerySelector) as Exports
 import Web.DOM.ShadowRoot (ShadowRoot, ShadowRootMode)
 import Web.Event.EventTarget (EventTarget)
 import Web.Internal.FFI (unsafeReadProtoTagged)
@@ -96,16 +98,16 @@ toParentNode = unsafeCoerce
 toEventTarget :: Element -> EventTarget
 toEventTarget = unsafeCoerce
 
-namespaceURI :: Element -> Maybe String
+namespaceURI :: Element -> Maybe NamespaceURI
 namespaceURI = toMaybe <<< _namespaceURI
 
-prefix :: Element -> Maybe String
+prefix :: Element -> Maybe NamespacePrefix
 prefix = toMaybe <<< _prefix
 
-foreign import _namespaceURI :: Element -> Nullable String
-foreign import _prefix :: Element -> Nullable String
-foreign import localName :: Element -> String
-foreign import tagName :: Element -> String
+foreign import _namespaceURI :: Element -> Nullable NamespaceURI
+foreign import _prefix :: Element -> Nullable NamespacePrefix
+foreign import localName :: Element -> ElementName
+foreign import tagName :: Element -> ElementName
 
 foreign import id :: Element -> Effect ElementId
 foreign import setId :: ElementId -> Element -> Effect Unit
@@ -113,15 +115,17 @@ foreign import className :: Element -> Effect ClassName
 foreign import classList :: Element -> Effect DOMTokenList
 foreign import setClassName :: ClassName -> Element -> Effect Unit
 
-foreign import getElementsByTagName :: String -> Element -> Effect HTMLCollection
+foreign import getElementsByTagName :: ElementName -> Element -> Effect HTMLCollection
 
-getElementsByTagNameNS :: Maybe String -> String -> Element -> Effect HTMLCollection
+getElementsByTagNameNS :: Maybe NamespaceURI -> ElementName -> Element -> Effect HTMLCollection
 getElementsByTagNameNS = _getElementsByTagNameNS <<< toNullable
 
-foreign import _getElementsByTagNameNS :: Nullable String -> String -> Element -> Effect HTMLCollection
+foreign import _getElementsByTagNameNS :: Nullable NamespaceURI -> ElementName -> Element -> Effect HTMLCollection
 
 foreign import getElementsByClassName :: ClassName -> Element -> Effect HTMLCollection
 
+foreign import attributes :: Element -> Effect NamedNodeMap
+
 foreign import setAttribute :: AttrName -> String -> Element -> Effect Unit
 
 getAttribute :: AttrName -> Element -> Effect (Maybe String)
@@ -164,55 +168,23 @@ type DOMRect =
 
 foreign import getBoundingClientRect :: Element -> Effect DOMRect
 
-type ShadowRootInit = {
-  mode :: ShadowRootMode,
-  delegatesFocus :: Boolean
-}
+type ShadowRootInit =
+  { mode :: ShadowRootMode
+  , delegatesFocus :: Boolean
+  }
 
 attachShadow :: ShadowRootInit -> Element -> Effect ShadowRoot
 attachShadow = _attachShadow <<< initToProps
 
-type ShadowRootProps = {
-  mode :: String,
-  delegatesFocus :: Boolean
-}
+type ShadowRootProps =
+  { mode :: String
+  , delegatesFocus :: Boolean
+  }
 
 initToProps :: ShadowRootInit -> ShadowRootProps
-initToProps init = {
-  mode: show init.mode,
-  delegatesFocus: init.delegatesFocus
-}
+initToProps init =
+  { mode: show init.mode
+  , delegatesFocus: init.delegatesFocus
+  }
 
 foreign import _attachShadow :: ShadowRootProps -> Element -> Effect ShadowRoot
-
--- | A wrapper for property names.
--- |
--- | The phantom type `value` describes the type of value which this property
--- | requires.
-newtype PropName :: Type -> Type
-newtype PropName value = PropName String
-
-derive instance newtypePropName :: Newtype (PropName value) _
-derive newtype instance eqPropName :: Eq (PropName value)
-derive newtype instance ordPropName :: Ord (PropName value)
-
--- | A wrapper for attribute names.
-newtype AttrName = AttrName String
-
-derive instance newtypeAttrName :: Newtype AttrName _
-derive newtype instance eqAttrName :: Eq AttrName
-derive newtype instance ordAttrName :: Ord AttrName
-
--- | A wrapper for strings which are used as CSS classes.
-newtype ClassName = ClassName String
-
-derive instance newtypeClassName :: Newtype ClassName _
-derive newtype instance eqClassName :: Eq ClassName
-derive newtype instance ordClassName :: Ord ClassName
-
--- | A wrapper for strings which are used as element identifiers.
-newtype ElementId = ElementId String
-
-derive instance newtypeElementId :: Newtype ElementId _
-derive newtype instance eqElementId :: Eq ElementId
-derive newtype instance ordElementId :: Ord ElementId
\ No newline at end of file
diff --git a/src/Web/DOM/ElementId.purs b/src/Web/DOM/ElementId.purs
new file mode 100644
index 0000000..0a25e7d
--- /dev/null
+++ b/src/Web/DOM/ElementId.purs
@@ -0,0 +1,12 @@
+module Web.DOM.ElementId where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for strings which are used as element identifiers.
+newtype ElementId = ElementId String
+
+derive instance newtypeElementId :: Newtype ElementId _
+derive newtype instance eqElementId :: Eq ElementId
+derive newtype instance ordElementId :: Ord ElementId
diff --git a/src/Web/DOM/ElementName.purs b/src/Web/DOM/ElementName.purs
new file mode 100644
index 0000000..67b2672
--- /dev/null
+++ b/src/Web/DOM/ElementName.purs
@@ -0,0 +1,12 @@
+module Web.DOM.ElementName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for element names.
+newtype ElementName = ElementName String
+
+derive instance newtypeElementName :: Newtype ElementName _
+derive newtype instance eqElementName :: Eq ElementName
+derive newtype instance ordElementName :: Ord ElementName
diff --git a/src/Web/DOM/Internal/Types.purs b/src/Web/DOM/Internal/Types.purs
index 3aee62c..7c68a35 100644
--- a/src/Web/DOM/Internal/Types.purs
+++ b/src/Web/DOM/Internal/Types.purs
@@ -5,3 +5,6 @@ foreign import data NodeList :: Type
 
 foreign import data Element :: Type
 foreign import data HTMLCollection :: Type
+
+foreign import data NamedNodeMap :: Type
+foreign import data Attr :: Type
\ No newline at end of file
diff --git a/src/Web/DOM/MutationRecord.purs b/src/Web/DOM/MutationRecord.purs
index 98c7e4e..0709b54 100644
--- a/src/Web/DOM/MutationRecord.purs
+++ b/src/Web/DOM/MutationRecord.purs
@@ -15,11 +15,13 @@ module Web.DOM.MutationRecord
 
 import Prelude
 
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
 import Effect (Effect)
+import Web.DOM.AttrName (AttrName)
+import Web.DOM.NamespaceURI (NamespaceURI)
 import Web.DOM.Node (Node)
 import Web.DOM.NodeList (NodeList)
-import Data.Maybe (Maybe)
-import Data.Nullable (Nullable, toMaybe)
 
 foreign import data MutationRecord :: Type
 
@@ -54,14 +56,14 @@ foreign import _previousSibling :: MutationRecord -> Effect (Nullable Node)
 previousSibling :: MutationRecord -> Effect (Maybe Node)
 previousSibling = map toMaybe <<< _previousSibling
 
-foreign import _attributeName :: MutationRecord -> Effect (Nullable String)
+foreign import _attributeName :: MutationRecord -> Effect (Nullable AttrName)
 
-attributeName :: MutationRecord -> Effect (Maybe String)
+attributeName :: MutationRecord -> Effect (Maybe AttrName)
 attributeName = map toMaybe <<< _attributeName
 
-foreign import _attributeNamespace :: MutationRecord -> Effect (Nullable String)
+foreign import _attributeNamespace :: MutationRecord -> Effect (Nullable NamespaceURI)
 
-attributeNamespace :: MutationRecord -> Effect (Maybe String)
+attributeNamespace :: MutationRecord -> Effect (Maybe NamespaceURI)
 attributeNamespace = map toMaybe <<< _attributeNamespace
 
 foreign import _oldValue :: MutationRecord -> Effect (Nullable String)
diff --git a/src/Web/DOM/NamedNodeMap.js b/src/Web/DOM/NamedNodeMap.js
new file mode 100644
index 0000000..0b5f209
--- /dev/null
+++ b/src/Web/DOM/NamedNodeMap.js
@@ -0,0 +1,63 @@
+export const length = (namedNodeMap) => () => namedNodeMap.length;
+
+export function getAttributes(namedNodeMap) {
+  return function () {
+    const result = [];
+    for (const attr of namedNodeMap) {
+      result.push(attr);
+    }
+    return result;
+  };
+}
+
+export function getNamedItem(name) {
+  return function (namedNodeMap) {
+    return function () {
+      return namedNodeMap.getNamedItem(name);
+    };
+  };
+}
+
+export function getNamedItemNS(namespace) {
+  return function (name) {
+    return function (namedNodeMap) {
+      return function () {
+        return namedNodeMap.getNamedItemNS(namespace, name);
+      };
+    };
+  };
+}
+
+export function setNamedItem(name) {
+  return function (namedNodeMap) {
+    return function () {
+      return namedNodeMap.setNamedItem(name);
+    };
+  };
+}
+
+export function setNamedItemNS(name) {
+  return function (namedNodeMap) {
+    return function () {
+      return namedNodeMap.setNamedItemNS(name);
+    };
+  };
+}
+
+export function removeNamedItem(name) {
+  return function (namedNodeMap) {
+    return function () {
+      return namedNodeMap.removeNamedItem(name);
+    };
+  };
+}
+
+export function removeNamedItemNS(namespace) {
+  return function (namedNodeMap) {
+    return function (name) {
+      return function () {
+        return namedNodeMap.removeNamedItemNS(namespace, name);
+      };
+    };
+  };
+}
diff --git a/src/Web/DOM/NamedNodeMap.purs b/src/Web/DOM/NamedNodeMap.purs
new file mode 100644
index 0000000..2541f96
--- /dev/null
+++ b/src/Web/DOM/NamedNodeMap.purs
@@ -0,0 +1,35 @@
+module Web.DOM.NamedNodeMap
+  ( module Exports
+  , length
+  , getAttributes
+  , getNamedItem
+  , getNamedItemNS
+  , setNamedItem
+  , setNamedItemNS
+  , removeNamedItem
+  , removeNamedItemNS
+  ) where
+
+import Prelude
+
+import Effect (Effect)
+import Web.DOM.AttrName (AttrName)
+import Web.DOM.Internal.Types (NamedNodeMap) as Exports
+import Web.DOM.Internal.Types (NamedNodeMap, Attr)
+import Web.DOM.NamespaceURI (NamespaceURI)
+
+foreign import length :: NamedNodeMap -> Effect Int
+
+foreign import getAttributes :: NamedNodeMap -> Effect (Array Attr)
+
+foreign import getNamedItem :: AttrName -> NamedNodeMap -> Effect Attr
+
+foreign import getNamedItemNS :: NamespaceURI -> AttrName -> NamedNodeMap -> Effect Attr
+
+foreign import setNamedItem :: Attr -> NamedNodeMap -> Effect Unit
+
+foreign import setNamedItemNS :: Attr -> NamedNodeMap -> Effect Unit
+
+foreign import removeNamedItem :: AttrName -> NamedNodeMap -> Effect Unit
+
+foreign import removeNamedItemNS :: NamespaceURI -> AttrName -> NamedNodeMap -> Effect Unit
diff --git a/src/Web/DOM/NamespacePrefix.purs b/src/Web/DOM/NamespacePrefix.purs
new file mode 100644
index 0000000..5624d1e
--- /dev/null
+++ b/src/Web/DOM/NamespacePrefix.purs
@@ -0,0 +1,11 @@
+module Web.DOM.NamespacePrefix where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+newtype NamespacePrefix = NamespacePrefix String
+
+derive instance Newtype NamespacePrefix _
+derive newtype instance Eq NamespacePrefix
+derive newtype instance Ord NamespacePrefix
diff --git a/src/Web/DOM/NamespaceURI.purs b/src/Web/DOM/NamespaceURI.purs
new file mode 100644
index 0000000..45122be
--- /dev/null
+++ b/src/Web/DOM/NamespaceURI.purs
@@ -0,0 +1,11 @@
+module Web.DOM.NamespaceURI where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+newtype NamespaceURI = NamespaceURI String
+
+derive instance Newtype NamespaceURI _
+derive newtype instance Eq NamespaceURI
+derive newtype instance Ord NamespaceURI
diff --git a/src/Web/DOM/Node.purs b/src/Web/DOM/Node.purs
index 46d60cd..034dca6 100644
--- a/src/Web/DOM/Node.purs
+++ b/src/Web/DOM/Node.purs
@@ -45,6 +45,8 @@ import Web.DOM.Document (Document)
 import Web.DOM.Element (Element)
 import Web.DOM.Internal.Types (Node) as Exports
 import Web.DOM.Internal.Types (Node, NodeList)
+import Web.DOM.NamespacePrefix (NamespacePrefix)
+import Web.DOM.NamespaceURI (NamespaceURI)
 import Web.DOM.NodeType (NodeType)
 import Web.Event.EventTarget (EventTarget)
 import Web.Internal.FFI (unsafeReadProtoTagged)
@@ -163,17 +165,17 @@ foreign import compareDocumentPositionBits :: Node -> Node -> Effect Int
 -- | Checks whether the second node is contained within the first
 foreign import contains :: Node -> Node -> Effect Boolean
 
-lookupPrefix :: String -> Node -> Effect (Maybe String)
+lookupPrefix :: NamespaceURI -> Node -> Effect (Maybe NamespacePrefix)
 lookupPrefix p = map toMaybe <<< _lookupPrefix p
 
-foreign import _lookupPrefix :: String -> Node -> Effect (Nullable String)
+foreign import _lookupPrefix :: NamespaceURI -> Node -> Effect (Nullable NamespacePrefix)
 
-lookupNamespaceURI :: String -> Node -> Effect (Maybe String)
+lookupNamespaceURI :: NamespacePrefix -> Node -> Effect (Maybe NamespaceURI)
 lookupNamespaceURI ns = map toMaybe <<< _lookupNamespaceURI ns
 
-foreign import _lookupNamespaceURI :: String -> Node -> Effect (Nullable String)
+foreign import _lookupNamespaceURI :: NamespacePrefix -> Node -> Effect (Nullable NamespaceURI)
 
-foreign import isDefaultNamespace :: String -> Node -> Effect Boolean
+foreign import isDefaultNamespace :: NamespaceURI -> Node -> Effect Boolean
 
 -- | Inserts the first node before the second as a child of the third node.
 foreign import insertBefore :: Node -> Node -> Node -> Effect Unit
diff --git a/src/Web/DOM/NonElementParentNode.purs b/src/Web/DOM/NonElementParentNode.purs
index 72bd340..c069694 100644
--- a/src/Web/DOM/NonElementParentNode.purs
+++ b/src/Web/DOM/NonElementParentNode.purs
@@ -8,7 +8,8 @@ import Prelude
 import Data.Maybe (Maybe)
 import Data.Nullable (Nullable, toMaybe)
 import Effect (Effect)
-import Web.DOM.Element (Element, ElementId)
+import Web.DOM.Element (Element)
+import Web.DOM.ElementId (ElementId)
 
 foreign import data NonElementParentNode :: Type
 
diff --git a/src/Web/DOM/PropName.purs b/src/Web/DOM/PropName.purs
new file mode 100644
index 0000000..5024849
--- /dev/null
+++ b/src/Web/DOM/PropName.purs
@@ -0,0 +1,16 @@
+module Web.DOM.PropName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for property names.
+-- |
+-- | The phantom type `value` describes the type of value which this property
+-- | requires.
+newtype PropName :: Type -> Type
+newtype PropName value = PropName String
+
+derive instance newtypePropName :: Newtype (PropName value) _
+derive newtype instance eqPropName :: Eq (PropName value)
+derive newtype instance ordPropName :: Ord (PropName value)