/[suikacvs]/markup/html/whatpm/Whatpm/ContentChecker.pm

Diff of /markup/html/whatpm/Whatpm/ContentChecker.pm

Parent Directory | Revision Log | View Patch Patch

-revision 1.26 by wakaba,
Sat Jun 23 02:26:51 2007 UTC
+revision 1.97 by wakaba,
Sun Sep 21 09:45:02 2008 UTC
 Line 1
  package Whatpm::ContentChecker;
  use strict;
+ our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
  require Whatpm::URIChecker;
  ## ISSUE: How XML and XML Namespaces conformance can (or cannot)
  ## be applied to an in-memory representation (i.e. DOM)?
+ ## TODO: Conformance of an HTML document with non-html root element.
+ ## Stability
+ sub FEATURE_STATUS_REC () { 0b1 } ## Interoperable standard
+ sub FEATURE_STATUS_CR () { 0b10 } ## Call for implementation
+ sub FEATURE_STATUS_LC () { 0b100 } ## Last call for comments
+ sub FEATURE_STATUS_WD () { 0b1000 } ## Working or editor's draft
+ ## Deprecated
+ sub FEATURE_DEPRECATED_SHOULD () { 0b100000 } ## SHOULD-level
+ sub FEATURE_DEPRECATED_INFO () { 0b1000000 } ## Does not affect conformance
+ ## Conformance
+ sub FEATURE_ALLOWED () { 0b10000 }
+ my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
  my $XML_NS = q<http://www.w3.org/XML/1998/namespace>;
  my $XMLNS_NS = q<http://www.w3.org/2000/xmlns/>;
- my $AttrChecker = {
+ my $Namespace = {
+   '' => {loaded => 1},
+   q<http://www.w3.org/2005/Atom> => {module => 'Whatpm::ContentChecker::Atom'},
+   q<http://purl.org/syndication/history/1.0>
+       => {module => 'Whatpm::ContentChecker::Atom'},
+   q<http://purl.org/syndication/threading/1.0>
+       => {module => 'Whatpm::ContentChecker::Atom'},
+   $HTML_NS => {module => 'Whatpm::ContentChecker::HTML'},
+   $XML_NS => {loaded => 1},
+   $XMLNS_NS => {loaded => 1},
+   q<http://www.w3.org/1999/02/22-rdf-syntax-ns#> => {loaded => 1},
+ };
+ sub load_ns_module ($) {
+   my $nsuri = shift; # namespace URI or ''
+   unless ($Namespace->{$nsuri}->{loaded}) {
+     if ($Namespace->{$nsuri}->{module}) {
+       eval qq{ require $Namespace->{$nsuri}->{module} } or die $@;
+     } else {
+       $Namespace->{$nsuri}->{loaded} = 1;
+     }
+   }
+ } # load_ns_module
+ our $AttrChecker = {
    $XML_NS => {
      space => sub {
        my ($self, $attr) = @_;
-Line 18 
 my $AttrChecker = {
+Line 59 
 my $AttrChecker = {
          #
        } else {
          ## NOTE: An XML "error"
-         $self->{onerror}->(node => $attr,
+         $self->{onerror}->(node => $attr, level => $self->{level}->{xml_error},
-                            type => 'XML error:invalid xml:space value');
+                            type => 'invalid attribute value');
        }
      },
      lang => sub {
+       my ($self, $attr) = @_;
+       my $value = $attr->value;
+       if ($value eq '') {
+         #
+       } else {
+         require Whatpm::LangTag;
+         Whatpm::LangTag->check_rfc3066_language_tag ($value, sub {
+           $self->{onerror}->(@_, node => $attr);
+         }, $self->{level});
+       }
        ## NOTE: "The values of the attribute are language identifiers
        ## as defined by [IETF RFC 3066], Tags for the Identification
        ## of Languages, or its successor; in addition, the empty string
        ## may be specified." ("may" in lower case)
-       ## TODO: xml:lang MUST NOT in HTML document
+       ## NOTE: Is an RFC 3066-valid (but RFC 4646-invalid) language tag
+       ## allowed today?
+       ## TODO: test data
+       my $nsuri = $attr->owner_element->namespace_uri;
+       if (defined $nsuri and $nsuri eq $HTML_NS) {
+         my $lang_attr = $attr->owner_element->get_attribute_node_ns
+             (undef, 'lang');
+         if ($lang_attr) {
+           my $lang_attr_value = $lang_attr->value;
+           $lang_attr_value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
+           my $value = $value;
+           $value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
+           if ($lang_attr_value ne $value) {
+             ## NOTE: HTML5 Section "The |lang| and |xml:lang| attributes"
+             $self->{onerror}->(node => $attr,
+                                type => 'xml:lang ne lang',
+                                level => $self->{level}->{must});
+           }
+         }
+       }
+       if ($attr->owner_document->manakai_is_html) { # MUST NOT
+         $self->{onerror}->(node => $attr, type => 'in HTML:xml:lang',
+                            level => $self->{level}->{must});
+ ## TODO: Test data...
+       }
      },
      base => sub {
        my ($self, $attr) = @_;
        my $value = $attr->value;
        if ($value =~ /[^\x{0000}-\x{10FFFF}]/) { ## ISSUE: Should we disallow noncharacters?
          $self->{onerror}->(node => $attr,
-                            type => 'syntax error');
+                            type => 'invalid attribute value',
+                            level => $self->{level}->{fact}, ## TODO: correct?
+                           );
        }
        ## NOTE: Conformance to URI standard is not checked since there is
        ## no author requirement on conformance in the XML Base specification.
-Line 48 
 my $AttrChecker = {
+Line 129 
 my $AttrChecker = {
        ## TODO: NCName in XML 1.0 or 1.1
        ## TODO: declared type is ID?
        if ($self->{id}->{$value}) {
-         $self->{onerror}->(node => $attr, type => 'xml:id error:duplicate ID');
+         $self->{onerror}->(node => $attr,
+                            type => 'duplicate ID',
+                            level => $self->{level}->{xml_id_error});
+         push @{$self->{id}->{$value}}, $attr;
        } else {
-         $self->{id}->{$value} = 1;
+         $self->{id}->{$value} = [$attr];
        }
      },
    },
-Line 62 
 my $AttrChecker = {
+Line 146 
 my $AttrChecker = {
        if ($value eq $XML_NS and $ln ne 'xml') {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xml');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        } elsif ($value eq $XMLNS_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xmlns');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        }
        if ($ln eq 'xml' and $value ne $XML_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:xmlns:xml=');
+              type => 'Reserved Prefixes and Namespace Names:Prefix',
+              text => $ln,
+              level => $self->{level}->{nc});
        } elsif ($ln eq 'xmlns') {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:xmlns:xmlns=');
+              type => 'Reserved Prefixes and Namespace Names:Prefix',
+              text => $ln,
+              level => $self->{level}->{nc});
        }
        ## TODO: If XML 1.0 and empty
      },
-Line 88 
 my $AttrChecker = {
+Line 180 
 my $AttrChecker = {
        if ($value eq $XML_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xml');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        } elsif ($value eq $XMLNS_NS) {
          $self->{onerror}
            ->(node => $attr,
-              type => 'NC:Reserved Prefixes and Namespace Names:=xmlns');
+              type => 'Reserved Prefixes and Namespace Names:Name',
+              text => $value,
+              level => $self->{level}->{nc});
        }
      },
    },
-Line 101 
 my $AttrChecker = {
+Line 197 
 my $AttrChecker = {
  ## ISSUE: Should we really allow these attributes?
  $AttrChecker->{''}->{'xml:space'} = $AttrChecker->{$XML_NS}->{space};
  $AttrChecker->{''}->{'xml:lang'} = $AttrChecker->{$XML_NS}->{lang};
+     ## NOTE: Checker for (null, "xml:lang") attribute is shadowed for
+     ## HTML elements in Whatpm::ContentChecker::HTML.
  $AttrChecker->{''}->{'xml:base'} = $AttrChecker->{$XML_NS}->{base};
  $AttrChecker->{''}->{'xml:id'} = $AttrChecker->{$XML_NS}->{id};
- ## ANY
+ our $AttrStatus;
- my $AnyChecker = sub {
-   my ($self, $todo) = @_;
-   my $el = $todo->{node};
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
-   while (@nodes) {
-     my $node = shift @nodes;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       if ($self->{minuses}->{$node_ns}->{$node_ln}) {
-         $self->{onerror}->(node => $node, type => 'element not allowed');
-       }
-       push @$new_todos, {type => 'element', node => $node};
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   return ($new_todos);
- }; # $AnyChecker
- my $ElementDefault = {
+ for (qw/space lang base id/) {
-   checker => sub {
+   $AttrStatus->{$XML_NS}->{$_} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
-     my ($self, $todo) = @_;
+   $AttrStatus->{''}->{"xml:$_"} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
-     $self->{onerror}->(node => $todo->{node}, type => 'element not supported');
+   ## XML 1.0: FEATURE_STATUS_CR
-     return $AnyChecker->($self, $todo);
+   ## XML 1.1: FEATURE_STATUS_REC
-   },
+   ## XML Namespaces 1.0: FEATURE_STATUS_CR
-   attrs_checker => sub {
+   ## XML Namespaces 1.1: FEATURE_STATUS_REC
-     my ($self, $todo) = @_;
+   ## XML Base: FEATURE_STATUS_REC
-     for my $attr (@{$todo->{node}->attributes}) {
+   ## xml:id: FEATURE_STATUS_REC
+ }
+ $AttrStatus->{$XMLNS_NS}->{''} = FEATURE_STATUS_REC | FEATURE_ALLOWED;
+ ## TODO: xsi:schemaLocation for XHTML2 support (very, very low priority)
+ our %AnyChecker = (
+   check_start => sub { },
+   check_attrs => sub {
+     my ($self, $item, $element_state) = @_;
+     for my $attr (@{$item->{node}->attributes}) {
        my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
+       if (defined $attr_ns) {
+         load_ns_module ($attr_ns);
+       } else {
+         $attr_ns = '';
+       }
        my $attr_ln = $attr->manakai_local_name;
        my $checker = $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
+           || $AttrChecker->{$attr_ns}->{''};
+       my $status = $AttrStatus->{$attr_ns}->{$attr_ln}
+           || $AttrStatus->{$attr_ns}->{''};
+       if (not defined $status) {
+         $status = FEATURE_ALLOWED;
+         ## NOTE: FEATURE_ALLOWED for all attributes, since the element
+         ## is not supported and therefore "attribute not defined" error
+         ## should not raised (too verbose) and global attributes should be
+         ## allowed anyway (if a global attribute has its specified creteria
+         ## for where it may be specified, then it should be checked in it's
+         ## checker function).
+       }
        if ($checker) {
          $checker->($self, $attr);
        } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
+         $self->{onerror}->(node => $attr,
+                            type => 'unknown attribute',
+                            level => $self->{level}->{uncertain});
        }
+       $self->_attr_status_info ($attr, $status);
      }
    },
- };
+   check_child_element => sub {
+     my ($self, $item, $child_el, $child_nsuri, $child_ln,
- my $Element = {};
+         $child_is_transparent, $element_state) = @_;
+     if ($self->{minus_elements}->{$child_nsuri}->{$child_ln}) {
- my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
+       $self->{onerror}->(node => $child_el,
+                          type => 'element not allowed:minus',
- my $HTMLMetadataElements = {
+                          level => $self->{level}->{must});
-   $HTML_NS => {
+     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
-     qw/link 1 meta 1 style 1 script 1 event-source 1 command 1 base 1 title 1/,
+       #
+     } else {
+       #
+     }
    },
- };
+   check_child_text => sub { },
+   check_end => sub {
- my $HTMLSectioningElements = {
+     my ($self, $item, $element_state) = @_;
-   $HTML_NS => {qw/body 1 section 1 nav 1 article 1 blockquote 1 aside 1/},
+     ## NOTE: There is a modified copy of the code below for |html:ruby|.
- };
+     if ($element_state->{has_significant}) {
+       $item->{real_parent_state}->{has_significant} = 1;
- my $HTMLBlockLevelElements = {
+     }
-   $HTML_NS => {
+   },
-     qw/
+ );
-       section 1 nav 1 article 1 blockquote 1 aside 1
-       h1 1 h2 1 h3 1 h4 1 h5 1 h6 1 header 1 footer 1
+ our $ElementDefault = {
-       address 1 p 1 hr 1 dialog 1 pre 1 ol 1 ul 1 dl 1
+   %AnyChecker,
-       ins 1 del 1 figure 1 map 1 table 1 script 1 noscript 1
+   status => FEATURE_ALLOWED,
-       event-source 1 details 1 datagrid 1 menu 1 div 1 font 1
+       ## NOTE: No "element not defined" error - it is not supported anyway.
-     /,
+   check_start => sub {
+     my ($self, $item, $element_state) = @_;
+     $self->{onerror}->(node => $item->{node},
+                        type => 'unknown element',
+                        level => $self->{level}->{uncertain});
    },
  };
- my $HTMLStrictlyInlineLevelElements = {
+ our $HTMLEmbeddedContent = {
+   ## NOTE: All embedded content is also phrasing content.
    $HTML_NS => {
-     qw/
+     img => 1, iframe => 1, embed => 1, object => 1, video => 1, audio => 1,
-       br 1 a 1 q 1 cite 1 em 1 strong 1 small 1 m 1 dfn 1 abbr 1
+     canvas => 1,
-       time 1 meter 1 progress 1 code 1 var 1 samp 1 kbd 1
-       sub 1 sup 1 span 1 i 1 b 1 bdo 1 ins 1 del 1 img 1
-       iframe 1 embed 1 object 1 video 1 audio 1 canvas 1 area 1
-       script 1 noscript 1 event-source 1 command 1 font 1
-     /,
    },
- };
+   q<http://www.w3.org/1998/Math/MathML> => {math => 1},
+   q<http://www.w3.org/2000/svg> => {svg => 1},
- my $HTMLStructuredInlineLevelElements = {
+   ## NOTE: Foreign elements with content (but no metadata) are
-   $HTML_NS => {qw/blockquote 1 pre 1 ol 1 ul 1 dl 1 table 1 menu 1/},
+   ## embedded content.
  };
- my $HTMLInteractiveElements = {
+ our $IsInHTMLInteractiveContent = sub {
-   $HTML_NS => {a => 1, details => 1, datagrid => 1},
+   my ($el, $nsuri, $ln) = @_;
- };
- ## NOTE: |html:a| and |html:datagrid| are not allowed as a descendant
+   ## NOTE: This CODE returns whether an element that is conditionally
- ## of interactive elements
+   ## categorizzed as an interactive content is currently in that
+   ## condition or not.  See $HTMLInteractiveContent list defined in
+   ## Whatpm::ContentChecler::HTML for the list of all (conditionally
+   ## or permanently) interactive content.
+   if ($nsuri eq $HTML_NS and ($ln eq 'video' or $ln eq 'audio')) {
+     return $el->has_attribute ('controls');
+   } elsif ($nsuri eq $HTML_NS and $ln eq 'menu') {
+     my $value = $el->get_attribute ('type');
+     $value =~ tr/A-Z/a-z/; # ASCII case-insensitive
+     return ($value eq 'toolbar');
+   } else {
+     return 1;
+   }
+ }; # $IsInHTMLInteractiveContent
  my $HTMLTransparentElements = {
-   $HTML_NS => {qw/ins 1 font 1 noscript 1/},
+   $HTML_NS => {qw/ins 1 del 1 font 1 noscript 1 canvas 1 a 1/},
-   ## NOTE: |html:noscript| is transparent if scripting is disabled.
+   ## NOTE: |html:noscript| is transparent if scripting is disabled
- };
+   ## and not in |head|.
+ };
- #my $HTMLSemiTransparentElements = {
- #  $HTML_NS => {qw/video 1 audio 1/},
+ my $HTMLSemiTransparentElements = {
- #};
+   $HTML_NS => {object => 1, video => 1, audio => 1},
+ };
- my $HTMLEmbededElements = {
-   $HTML_NS => {qw/img 1 iframe 1 embed 1 object 1 video 1 audio 1 canvas 1/},
+ our $Element = {};
- };
+ $Element->{q<http://www.w3.org/1999/02/22-rdf-syntax-ns#>}->{RDF} = {
- ## Empty
+   %AnyChecker,
- my $HTMLEmptyChecker = sub {
+   status => FEATURE_STATUS_REC | FEATURE_ALLOWED,
-   my ($self, $todo) = @_;
+   is_root => 1, ## ISSUE: Not explicitly allowed for non application/rdf+xml
-   my $el = $todo->{node};
+   check_start => sub {
-   my $new_todos = [];
+     my ($self, $item, $element_state) = @_;
-   my @nodes = (@{$el->child_nodes});
+     my $triple = [];
+     push @{$self->{return}->{rdf}}, [$item->{node}, $triple];
-   while (@nodes) {
+     require Whatpm::RDFXML;
-     my $node = shift @nodes;
+     my $rdf = Whatpm::RDFXML->new;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+     ## TODO: Should we make bnodeid unique in a document?
+     $rdf->{onerror} = $self->{onerror};
-     my $nt = $node->node_type;
+     $rdf->{level} = $self->{level};
-     if ($nt == 1) {
+     $rdf->{ontriple} = sub {
-       ## NOTE: |minuses| list is not checked since redundant
+       my %opt = @_;
-       $self->{onerror}->(node => $node, type => 'element not allowed');
+       push @$triple,
-       my ($sib, $ch) = $self->_check_get_children ($node);
+           [$opt{node}, $opt{subject}, $opt{predicate}, $opt{object}];
-       unshift @nodes, @$sib;
+       if (defined $opt{id}) {
-       push @$new_todos, @$ch;
+         push @$triple,
-     } elsif ($nt == 3 or $nt == 4) {
+             [$opt{node},
-       if ($node->data =~ /[^\x09-\x0D\x20]/) {
+              $opt{id},
-         $self->{onerror}->(node => $node, type => 'character not allowed');
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#subject>},
-       }
+              $opt{subject}];
-     } elsif ($nt == 5) {
+         push @$triple,
-       unshift @nodes, @{$node->child_nodes};
+             [$opt{node},
-     }
+              $opt{id},
-   }
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate>},
-   return ($new_todos);
+              $opt{predicate}];
+         push @$triple,
+             [$opt{node},
+              $opt{id},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#object>},
+              $opt{object}];
+         push @$triple,
+             [$opt{node},
+              $opt{id},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>},
+              {uri => q<http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement>}];
+       }
+     };
+     $rdf->convert_rdf_element ($item->{node});
+   },
+ };
+ my $default_error_level = {
+   must => 'm',
+   should => 's',
+   warn => 'w',
+   good => 'w',
+   undefined => 'w',
+   info => 'i',
+   uncertain => 'u',
+   html4_fact => 'm',
+   html5_no_may => 'm',
+   xml_error => 'm', ## TODO: correct?
+   xml_id_error => 'm', ## TODO: ?
+   nc => 'm', ## XML Namespace Constraints ## TODO: correct?
+   ## |Whatpm::URIChecker|
+   uri_syntax => 'm',
+   uri_fact => 'm',
+   uri_lc_must => 'm',
+   uri_lc_should => 'w',
+   ## |Whatpm::IMTChecker|
+   mime_must => 'm', # lowercase "must"
+   mime_fact => 'm',
+   mime_strongly_discouraged => 'w',
+   mime_discouraged => 'w',
+   ## |Whatpm::LangTag|
+   langtag_fact => 'm',
+   ## |Whatpm::RDFXML|
+   rdf_fact => 'm',
+   rdf_grammer => 'm',
+   rdf_lc_must => 'm',
+   ## |Message::Charset::Info| and |Whatpm::Charset::DecodeHandle|
+   charset_variant => 'm',
+     ## An error caused by use of a variant charset that is not conforming
+     ## to the original charset (e.g. use of 0x80 in an ISO-8859-1 document
+     ## which is interpreted as a Windows-1252 document instead).
+   charset_fact => 'm',
+   iso_shall => 'm',
  };
- ## Text
+ sub check_document ($$$;$) {
- my $HTMLTextChecker = sub {
+   my ($self, $doc, $onerror, $onsubdoc) = @_;
-   my ($self, $todo) = @_;
+   $self = bless {}, $self unless ref $self;
-   my $el = $todo->{node};
+   $self->{onerror} = $onerror;
-   my $new_todos = [];
+   $self->{onsubdoc} = $onsubdoc || sub {
-   my @nodes = (@{$el->child_nodes});
+     warn "A subdocument is not conformance-checked";
+   };
-   while (@nodes) {
+   $self->{level} ||= $default_error_level;
-     my $node = shift @nodes;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       ## NOTE: |minuses| list is not checked since redundant
-       $self->{onerror}->(node => $node, type => 'element not allowed');
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   return ($new_todos);
- };
- ## Zero or more |html:style| elements,
+   ## TODO: If application/rdf+xml, RDF/XML mode should be invoked.
- ## followed by zero or more block-level elements
- my $HTMLStylableBlockChecker = sub {
-   my ($self, $todo) = @_;
-   my $el = $todo->{node};
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
-   my $has_non_style;
-   while (@nodes) {
-     my $node = shift @nodes;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       if ($node_ns eq $HTML_NS and $node_ln eq 'style') {
-         $not_allowed = 1 if $has_non_style;
-       } elsif ($HTMLBlockLevelElements->{$node_ns}->{$node_ln}) {
-         $has_non_style = 1;
-       } else {
-         $has_non_style = 1;
-         $not_allowed = 1;
-       }
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 3 or $nt == 4) {
-       if ($node->data =~ /[^\x09-\x0D\x20]/) {
-         $self->{onerror}->(node => $node, type => 'character not allowed');
-       }
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   return ($new_todos);
- }; # $HTMLStylableBlockChecker
- ## Zero or more block-level elements
+   my $docel = $doc->document_element;
- my $HTMLBlockChecker = sub {
+   unless (defined $docel) {
-   my ($self, $todo) = @_;
+     ## ISSUE: Should we check content of Document node?
-   my $el = $todo->{node};
+     $onerror->(node => $doc, type => 'no document element',
-   my $new_todos = [];
+                level => $self->{level}->{must});
-   my @nodes = (@{$el->child_nodes});
+     ## ISSUE: Is this non-conforming (to what spec)?  Or just a warning?
+     return {
-   while (@nodes) {
+             class => {},
-     my $node = shift @nodes;
+             id => {}, table => [], term => {},
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+            };
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 3 or $nt == 4) {
-       if ($node->data =~ /[^\x09-\x0D\x20]/) {
-         $self->{onerror}->(node => $node, type => 'character not allowed');
-       }
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
    }
-   return ($new_todos);
- }; # $HTMLBlockChecker
- ## Inline-level content
+   ## ISSUE: Unexpanded entity references and HTML5 conformance
- my $HTMLInlineChecker = sub {
-   my ($self, $todo) = @_;
-   my $el = $todo->{node};
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
-   while (@nodes) {
+   my $docel_nsuri = $docel->namespace_uri;
-     my $node = shift @nodes;
+   if (defined $docel_nsuri) {
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+     load_ns_module ($docel_nsuri);
+   } else {
-     my $nt = $node->node_type;
+     $docel_nsuri = '';
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-           $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   for (@$new_todos) {
-     $_->{inline} = 1;
    }
-   return ($new_todos);
+   my $docel_def = $Element->{$docel_nsuri}->{$docel->manakai_local_name} ||
- }; # $HTMLInlineChecker
+     $Element->{$docel_nsuri}->{''} ||
+     $ElementDefault;
- my $HTMLSignificantInlineChecker = $HTMLInlineChecker;
+   if ($docel_def->{is_root}) {
- ## TODO: check significant content
+     #
+   } elsif ($docel_def->{is_xml_root}) {
- ## Strictly inline-level content
+     unless ($doc->manakai_is_html) {
- my $HTMLStrictlyInlineChecker = sub {
+       #
-   my ($self, $todo) = @_;
+     } else {
-   my $el = $todo->{node};
+       $onerror->(node => $docel, type => 'element not allowed:root:xml',
-   my $new_todos = [];
+                  level => $self->{level}->{must});
-   my @nodes = (@{$el->child_nodes});
-   while (@nodes) {
-     my $node = shift @nodes;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       $not_allowed = 1
-         unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln};
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
      }
+   } else {
+     $onerror->(node => $docel, type => 'element not allowed:root',
+                level => $self->{level}->{must});
    }
-   for (@$new_todos) {
+   ## TODO: Check for other items other than document element
-     $_->{inline} = 1;
+   ## (second (errorous) element, text nodes, PI nodes, doctype nodes)
-     $_->{strictly_inline} = 1;
-   }
-   return ($new_todos);
- }; # $HTMLStrictlyInlineChecker
- my $HTMLSignificantStrictlyInlineChecker = $HTMLStrictlyInlineChecker;
- ## TODO: check significant content
- ## Inline-level or strictly inline-kevek content
- my $HTMLInlineOrStrictlyInlineChecker = sub {
-   my ($self, $todo) = @_;
-   my $el = $todo->{node};
-   my $new_todos = [];
-   my @nodes = (@{$el->child_nodes});
-   while (@nodes) {
-     my $node = shift @nodes;
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-     my $nt = $node->node_type;
-     if ($nt == 1) {
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       if ($todo->{strictly_inline}) {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln};
-       } else {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       }
-       $self->{onerror}->(node => $node, type => 'element not allowed')
-         if $not_allowed;
-       my ($sib, $ch) = $self->_check_get_children ($node);
-       unshift @nodes, @$sib;
-       push @$new_todos, @$ch;
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   for (@$new_todos) {
+   my $return = $self->check_element ($docel, $onerror, $onsubdoc);
-     $_->{inline} = 1;
-     $_->{strictly_inline} = 1;
-   }
-   return ($new_todos);
- }; # $HTMLInlineOrStrictlyInlineChecker
- my $HTMLSignificantInlineOrStrictlyInlineChecker
-     = $HTMLInlineOrStrictlyInlineChecker;
- ## TODO: check significant content
- my $HTMLBlockOrInlineChecker = sub {
+   ## TODO: Test for these checks are necessary.
-   my ($self, $todo) = @_;
+   my $charset_name = $doc->input_encoding;
-   my $el = $todo->{node};
+   if (defined $charset_name) {
-   my $new_todos = [];
+     require Message::Charset::Info;
-   my @nodes = (@{$el->child_nodes});
+     my $charset = $Message::Charset::Info::IANACharset->{$charset_name};
-   my $content = 'block-or-inline'; # or 'block' or 'inline'
+     if ($doc->manakai_is_html) {
-   my @block_not_inline;
+       if (not $doc->manakai_has_bom and
-   while (@nodes) {
+           not defined $doc->manakai_charset) {
-     my $node = shift @nodes;
+         unless ($charset->{is_html_ascii_superset}) {
-     $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+           $onerror->(node => $doc,
+                      level => $self->{level}->{must},
-     my $nt = $node->node_type;
+                      type => 'non ascii superset',
-     if ($nt == 1) {
+                      text => $charset_name);
-       my $node_ns = $node->namespace_uri;
-       $node_ns = '' unless defined $node_ns;
-       my $node_ln = $node->manakai_local_name;
-       my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-       if ($content eq 'block') {
-         $not_allowed = 1
-           unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-       } elsif ($content eq 'inline') {
-         $not_allowed = 1
-           unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-       } else {
-         my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         my $is_inline
-           = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-             $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         push @block_not_inline, $node
-           if $is_block and not $is_inline and not $not_allowed;
-         unless ($is_block) {
-           $content = 'inline';
-           for (@block_not_inline) {
-             $self->{onerror}->(node => $_, type => 'element not allowed');
-           }
-           $not_allowed = 1 unless $is_inline;
          }
-       }
-       $self->{onerror}->(node => $node, type => 'element not allowed')
+         if (not $self->{has_charset} and ## TODO: This does not work now.
-         if $not_allowed;
+             not $charset->{iana_names}->{'us-ascii'}) {
-       my ($sib, $ch) = $self->_check_get_children ($node);
+           $onerror->(node => $doc,
-       unshift @nodes, @$sib;
+                      level => $self->{level}->{must},
-       push @$new_todos, @$ch;
+                      type => 'no character encoding declaration',
-     } elsif ($nt == 3 or $nt == 4) {
+                      text => $charset_name);
-       if ($node->data =~ /[^\x09-\x0D\x20]/) {
-         if ($content eq 'block') {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         } else {
-           $content = 'inline';
-           for (@block_not_inline) {
-             $self->{onerror}->(node => $_, type => 'element not allowed');
-           }
          }
        }
-     } elsif ($nt == 5) {
-       unshift @nodes, @{$node->child_nodes};
-     }
-   }
-   if ($content eq 'inline') {
+       if ($charset->{iana_names}->{'utf-8'}) {
-     for (@$new_todos) {
+         #
-       $_->{inline} = 1;
+       } elsif ($charset->{iana_names}->{'jis_x0212-1990'} or
-     }
+                $charset->{iana_names}->{'x-jis0208'} or
+                $charset->{iana_names}->{'utf-32'} or ## ISSUE: UTF-32BE? UTF-32LE?
+                ($charset->{category} & Message::Charset::Info::CHARSET_CATEGORY_EBCDIC ())) {
+         $onerror->(node => $doc,
+                    type => 'bad character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{should},
+                    layer => 'encode');
+       } elsif ($charset->{iana_names}->{'cesu-8'} or
+                $charset->{iana_names}->{'utf-8'} or ## ISSUE: UNICODE-1-1-UTF-7?
+                $charset->{iana_names}->{'bocu-1'} or
+                $charset->{iana_names}->{'scsu'}) {
+         $onerror->(node => $doc,
+                    type => 'disallowed character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{must},
+                    layer => 'encode');
+       } else {
+         $onerror->(node => $doc,
+                    type => 'non-utf-8 character encoding',
+                    text => $charset_name,
+                    level => $self->{level}->{good},
+                    layer => 'encode');
+       }
+     }
+   } elsif ($doc->manakai_is_html) {
+     ## NOTE: MUST and SHOULD requirements above cannot be tested,
+     ## since the document has no input charset encoding information.
+     $onerror->(node => $doc,
+                type => 'character encoding unchecked',
+                level => $self->{level}->{info},
+                layer => 'encode');
    }
-   return ($new_todos);
- };
- ## Zero or more XXX element, then either block-level or inline-level
+   return $return;
- my $GetHTMLZeroOrMoreThenBlockOrInlineChecker = sub ($$) {
+ } # check_document
-   my ($elnsuri, $ellname) = @_;
-   return sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $has_non_style;
-     my $content = 'block-or-inline'; # or 'block' or 'inline'
-     my @block_not_inline;
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $elnsuri and $node_ln eq $ellname) {
-           $not_allowed = 1 if $has_non_style;
-         } elsif ($content eq 'block') {
-           $has_non_style = 1;
-           $not_allowed = 1
-             unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         } elsif ($content eq 'inline') {
-           $has_non_style = 1;
-           $not_allowed = 1
-             unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         } else {
-           $has_non_style = 1;
-           my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-           my $is_inline
-             = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-           push @block_not_inline, $node
-             if $is_block and not $is_inline and not $not_allowed;
-           unless ($is_block) {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-             $not_allowed = 1 unless $is_inline;
-           }
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $has_non_style = 1;
-           if ($content eq 'block') {
-             $self->{onerror}->(node => $node, type => 'character not allowed');
-           } else {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-           }
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     if ($content eq 'inline') {
+ ## Check an element.  The element is checked as if it is an orphan node (i.e.
-       for (@$new_todos) {
+ ## an element without a parent node).
-         $_->{inline} = 1;
+ sub check_element ($$$;$) {
-       }
+   my ($self, $el, $onerror, $onsubdoc) = @_;
-     }
+   $self = bless {}, $self unless ref $self;
-     return ($new_todos);
+   $self->{onerror} = $onerror;
+   $self->{onsubdoc} = $onsubdoc || sub {
+     warn "A subdocument is not conformance-checked";
    };
- }; # $GetHTMLZeroOrMoreThenBlockOrInlineChecker
- my $HTMLTransparentChecker = $HTMLBlockOrInlineChecker;
- my $GetHTMLEnumeratedAttrChecker = sub {
+   $self->{level} ||= $default_error_level;
-   my $states = shift; # {value => conforming ? 1 : -1}
-   return sub {
-     my ($self, $attr) = @_;
-     my $value = lc $attr->value; ## TODO: ASCII case insensitibility?
-     if ($states->{$value} > 0) {
-       #
-     } elsif ($states->{$value}) {
-       $self->{onerror}->(node => $attr,
-                          type => 'non-conforming enumerated attribute value');
-     } else {
-       $self->{onerror}->(node => $attr,
-                          type => 'invalid enumerated attribute value');
-     }
-   };
- }; # $GetHTMLEnumeratedAttrChecker
- my $GetHTMLBooleanAttrChecker = sub {
+   $self->{plus_elements} = {};
-   my $local_name = shift;
+   $self->{minus_elements} = {};
-   return sub {
+   $self->{id} = {};
-     my ($self, $attr) = @_;
+   $self->{form} = {};
-     my $value = $attr->value;
+   $self->{term} = {};
-     unless ($value eq $local_name or $value eq '') {
+   $self->{usemap} = [];
-       $self->{onerror}->(node => $attr,
+   $self->{ref} = []; # datetemplate data references
-                          type => 'invalid boolean attribute value');
+   $self->{template} = []; # datatemplate template references
-     }
+   $self->{contextmenu} = [];
+   $self->{map} = {};
+   $self->{menu} = {};
+   $self->{has_link_type} = {};
+   $self->{flag} = {};
+   #$self->{has_uri_attr};
+   #$self->{has_hyperlink_element};
+   #$self->{has_charset};
+   #$self->{has_base};
+   $self->{return} = {
+     class => {},
+     id => $self->{id},
+     table => [], # table objects returned by Whatpm::HTMLTable
+     term => $self->{term},
+     uri => {}, # URIs other than those in RDF triples
+                      ## TODO: xmlns="", SYSTEM "", atom:* src="", xml:base=""
+     rdf => [],
    };
- }; # $GetHTMLBooleanAttrChecker
- my $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker = sub {
-   my ($self, $attr) = @_;
-   my %word;
-   for my $word (grep {length $_} split /[\x09-\x0D\x20]/, $attr->value) {
-     unless ($word{$word}) {
-       $word{$word} = 1;
-     } else {
-       $self->{onerror}->(node => $attr, type => 'duplicate token:'.$word);
-     }
-   }
- }; # $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker
- ## |rel| attribute (unordered set of space separated tokens,
+   my @item = ({type => 'element', node => $el, parent_state => {}});
- ## whose allowed values are defined by the section on link types)
+   $item[-1]->{real_parent_state} = $item[-1]->{parent_state};
- my $HTMLLinkTypesAttrChecker = sub {
+   while (@item) {
-   my ($a_or_area, $self, $attr) = @_;
+     my $item = shift @item;
-   my %word;
+     if (ref $item eq 'ARRAY') {
-   for my $word (grep {length $_} split /[\x09-\x0D\x20]/, $attr->value) {
+       my $code = shift @$item;
-     unless ($word{$word}) {
+ next unless $code;## TODO: temp.
-       $word{$word} = 1;
+       $code->(@$item);
-     } else {
+     } elsif ($item->{type} eq 'element') {
-       $self->{onerror}->(node => $attr, type => 'duplicate token:'.$word);
+       my $el_nsuri = $item->{node}->namespace_uri;
-     }
+       if (defined $el_nsuri) {
-   }
+         load_ns_module ($el_nsuri);
-   ## NOTE: Case sensitive match (since HTML5 spec does not say link
+       } else {
-   ## types are case-insensitive and it says "The value should not
+         $el_nsuri = '';
-   ## be confusingly similar to any other defined value (e.g.
+       }
-   ## differing only in case).").
+       my $el_ln = $item->{node}->manakai_local_name;
-   ## NOTE: Though there is no explicit "MUST NOT" for undefined values,
-   ## "MAY"s and "only ... MAY" restrict non-standard non-registered
+       my $element_state = {};
-   ## values to be used conformingly.
+       my $eldef = $Element->{$el_nsuri}->{$el_ln} ||
-   require Whatpm::_LinkTypeList;
+           $Element->{$el_nsuri}->{''} ||
-   our $LinkType;
+           $ElementDefault;
-   for my $word (keys %word) {
+       my $content_def = $item->{transparent}
-     my $def = $LinkType->{$word};
+           ? $item->{parent_def} || $eldef : $eldef;
-     if (defined $def) {
+       my $content_state = $item->{transparent}
-       if ($def->{status} eq 'accepted') {
+           ? $item->{parent_def}
-         if (defined $def->{effect}->[$a_or_area]) {
+               ? $item->{parent_state} || $element_state : $element_state
-           #
+           : $element_state;
-         } else {
-           $self->{onerror}->(node => $attr,
+       unless ($eldef->{status} & FEATURE_STATUS_REC) {
-                              type => 'link type bad context:'.$word);
+         my $status = $eldef->{status} & FEATURE_STATUS_CR ? 'cr' :
-         }
+             $eldef->{status} & FEATURE_STATUS_LC ? 'lc' :
-       } elsif ($def->{status} eq 'proposal') {
+             $eldef->{status} & FEATURE_STATUS_WD ? 'wd' : 'non-standard';
-         $self->{onerror}->(node => $attr,
+         $self->{onerror}->(node => $item->{node},
-                            type => 'proposed link type:'.$word);
+                            type => 'status:'.$status.':element',
-       } else { # rejected or synonym
+                            level => $self->{level}->{info});
-         $self->{onerror}->(node => $attr,
+       }
-                            type => 'non-conforming link type:'.$word);
+       if (not ($eldef->{status} & FEATURE_ALLOWED)) {
-       }
+         $self->{onerror}->(node => $item->{node},
-       if ($def->{unique}) {
+                            type => 'element not defined',
-         unless ($self->{has_link_type}->{$word}) {
+                            level => $self->{level}->{must});
-           $self->{has_link_type}->{$word} = 1;
+       } elsif ($eldef->{status} & FEATURE_DEPRECATED_SHOULD) {
-         } else {
+         $self->{onerror}->(node => $item->{node},
-           $self->{onerror}->(node => $attr,
+                            type => 'deprecated:element',
-                              type => 'link with type not unique:'.$word);
+                            level => $self->{level}->{should});
-         }
+       } elsif ($eldef->{status} & FEATURE_DEPRECATED_INFO) {
-       }
+         $self->{onerror}->(node => $item->{node},
-     } else {
+                            type => 'deprecated:element',
-       $self->{onerror}->(node => $attr,
+                            level => $self->{level}->{info});
-                          type => 'link type not supported:'.$word);
+       }
-     }
-   }
+       my @new_item;
-   ## TODO: The Pingback 1.0 specification, which is referenced by HTML5,
+       push @new_item, [$eldef->{check_start}, $self, $item, $element_state];
-   ## says that using both X-Pingback: header field and HTML
+       push @new_item, [$eldef->{check_attrs}, $self, $item, $element_state];
-   ## <link rel=pingback> is deprecated and if both appears they
-   ## SHOULD contain exactly the same value.
+       my @child = @{$item->{node}->child_nodes};
-   ## ISSUE: Pingback 1.0 specification defines the exact representation
+       while (@child) {
-   ## of its link element, which cannot be tested by the current arch.
+         my $child = shift @child;
-   ## ISSUE: Pingback 1.0 specification says that the document MUST NOT
+         my $child_nt = $child->node_type;
-   ## include any string that matches to the pattern for the rel=pingback link,
+         if ($child_nt == 1) { # ELEMENT_NODE
-   ## which again inpossible to test.
+           my $child_nsuri = $child->namespace_uri;
-   ## ISSUE: rel=pingback href MUST NOT include entities other than predefined 4.
+           $child_nsuri = '' unless defined $child_nsuri;
- }; # $HTMLLinkTypesAttrChecker
+           my $child_ln = $child->manakai_local_name;
+           if ($HTMLTransparentElements->{$child_nsuri}->{$child_ln} and
- ## URI (or IRI)
+               not (($self->{flag}->{in_head} or
- my $HTMLURIAttrChecker = sub {
+                     ($el_nsuri eq $HTML_NS and $el_ln eq 'head')) and
-   my ($self, $attr) = @_;
+                    $child_nsuri eq $HTML_NS and $child_ln eq 'noscript')) {
-   ## ISSUE: Relative references are allowed? (RFC 3987 "IRI" is an absolute reference with optional fragment identifier.)
+             push @new_item, [$content_def->{check_child_element},
-   my $value = $attr->value;
+                              $self, $item, $child,
-   Whatpm::URIChecker->check_iri_reference ($value, sub {
+                              $child_nsuri, $child_ln, 1,
-     my %opt = @_;
+                              $content_state, $element_state];
-     $self->{onerror}->(node => $attr,
+             push @new_item, {type => 'element', node => $child,
-                        type => 'URI:'.$opt{level}.':'.
+                              parent_state => $content_state,
-                        (defined $opt{position} ? $opt{position} : '').':'.
+                              parent_def => $content_def,
-                        $opt{type});
+                              real_parent_state => $element_state,
-   });
+                              transparent => 1};
- }; # $HTMLURIAttrChecker
+           } else {
+             if ($item->{parent_def} and # has parent
- ## A space separated list of one or more URIs (or IRIs)
+                 $el_nsuri eq $HTML_NS) { ## $HTMLSemiTransparentElements
- my $HTMLSpaceURIsAttrChecker = sub {
+               if ($el_ln eq 'object') {
-   my ($self, $attr) = @_;
+                 if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
-   ## TODO: URI or IRI check
+                   #
-   ## ISSUE: Relative references?
+                 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'param') {
-   ## ISSUE: Leading or trailing white spaces are conformant?
+                   #
-   ## ISSUE: A sequence of white space characters are conformant?
+                 } else {
-   ## ISSUE: A zero-length string is conformant? (It does contain a relative reference, i.e. same as base URI.)
+                   $content_def = $item->{parent_def} || $content_def;
-   ## NOTE: Duplication seems not an error.
+                   $content_state = $item->{parent_state} || $content_state;
- }; # $HTMLSpaceURIsAttrChecker
+                 }
+               } elsif ($el_ln eq 'video' or $el_ln eq 'audio') {
- my $HTMLIntegerAttrChecker = sub {
+                 if ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
-   my ($self, $attr) = @_;
+                   #
-   my $value = $attr->value;
+                 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'source') {
-   unless ($value =~ /\A-?[0-9]+\z/) {
+                   $element_state->{has_source} = 1;
-     $self->{onerror}->(node => $attr, type => 'integer syntax error');
+                 } else {
-   }
+                   $content_def = $item->{parent_def} || $content_def;
- }; # $HTMLIntegerAttrChecker
+                   $content_state = $item->{parent_state} || $content_state;
+                 }
- my $GetHTMLNonNegativeIntegerAttrChecker = sub {
+               }
-   my $range_check = shift;
+             }
-   return sub {
-     my ($self, $attr) = @_;
-     my $value = $attr->value;
-     if ($value =~ /\A[0-9]+\z/) {
-       unless ($range_check->($value + 0)) {
-         $self->{onerror}->(node => $attr, type => 'out of range');
-       }
-     } else {
-       $self->{onerror}->(node => $attr,
-                          type => 'non-negative integer syntax error');
-     }
-   };
- }; # $GetHTMLNonNegativeIntegerAttrChecker
- my $GetHTMLFloatingPointNumberAttrChecker = sub {
+             push @new_item, [$content_def->{check_child_element},
-   my $range_check = shift;
+                              $self, $item, $child,
-   return sub {
+                              $child_nsuri, $child_ln,
-     my ($self, $attr) = @_;
+                              $HTMLSemiTransparentElements
-     my $value = $attr->value;
+                                  ->{$child_nsuri}->{$child_ln},
-     if ($value =~ /\A-?[0-9.]+\z/ and $value =~ /[0-9]/) {
+                              $content_state, $element_state];
-       unless ($range_check->($value + 0)) {
+             push @new_item, {type => 'element', node => $child,
-         $self->{onerror}->(node => $attr, type => 'out of range');
+                              parent_def => $content_def,
-       }
+                              real_parent_state => $element_state,
+                              parent_state => $content_state};
+           }
+           if ($HTMLEmbeddedContent->{$child_nsuri}->{$child_ln}) {
+             $element_state->{has_significant} = 1;
+           }
+         } elsif ($child_nt == 3 or # TEXT_NODE
+                  $child_nt == 4) { # CDATA_SECTION_NODE
+           my $has_significant = ($child->data =~ /[^\x09\x0A\x0C\x0D\x20]/);
+           push @new_item, [$content_def->{check_child_text},
+                            $self, $item, $child, $has_significant,
+                            $content_state, $element_state];
+           $element_state->{has_significant} ||= $has_significant;
+           if ($has_significant and
+               $HTMLSemiTransparentElements->{$el_nsuri}->{$el_ln}) {
+             $content_def = $item->{parent_def} || $content_def;
+           }
+         } elsif ($child_nt == 5) { # ENTITY_REFERENCE_NODE
+           push @child, @{$child->child_nodes};
+         }
+         ## TODO: PI_NODE
+         ## TODO: Unknown node type
+       }
+       push @new_item, [$eldef->{check_end}, $self, $item, $element_state];
+       unshift @item, @new_item;
      } else {
-       $self->{onerror}->(node => $attr,
+       die "$0: Internal error: Unsupported checking action type |$item->{type}|";
-                          type => 'floating point number syntax error');
-     }
-   };
- }; # $GetHTMLFloatingPointNumberAttrChecker
- ## "A valid MIME type, optionally with parameters. [RFC 2046]"
- ## ISSUE: RFC 2046 does not define syntax of media types.
- ## ISSUE: The definition of "a valid MIME type" is unknown.
- ## Syntactical correctness?
- my $HTMLIMTAttrChecker = sub {
-   my ($self, $attr) = @_;
-   my $value = $attr->value;
-   ## ISSUE: RFC 2045 Content-Type header field allows insertion
-   ## of LWS/comments between tokens.  Is it allowed in HTML?  Maybe no.
-   ## ISSUE: RFC 2231 extension?  Maybe no.
-   my $lws0 = qr/(?>(?>\x0D\x0A)?[\x09\x20])*/;
-   my $token = qr/[\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+/;
-   my $qs = qr/"(?>[\x00-\x0C\x0E-\x21\x23-\x5B\x5D-\x7E]|\x0D\x0A[\x09\x20]|\x5C[\x00-\x7F])*"/;
-   if ($value =~ m#\A$lws0($token)$lws0/$lws0($token)$lws0((?>;$lws0$token$lws0=$lws0(?>$token|$qs)$lws0)*)\z#) {
-     my @type = ($1, $2);
-     my $param = $3;
-     while ($param =~ s/^;$lws0($token)$lws0=$lws0(?>($token)|($qs))$lws0//) {
-       if (defined $2) {
-         push @type, $1 => $2;
-       } else {
-         my $n = $1;
-         my $v = $2;
-         $v =~ s/\\(.)/$1/gs;
-         push @type, $n => $v;
-       }
      }
-     require Whatpm::IMTChecker;
-     Whatpm::IMTChecker->check_imt (sub {
-       my %opt = @_;
-       $self->{onerror}->(node => $attr,
-                          type => 'IMT:'.$opt{level}.':'.$opt{type});
-     }, @type);
-   } else {
-     $self->{onerror}->(node => $attr, type => 'IMT syntax error');
-   }
- }; # $HTMLIMTAttrChecker
- my $HTMLLanguageTagAttrChecker = sub {
-   my ($self, $attr) = @_;
-   if ($attr->value eq '') {
-     $self->{onerror}->(node => $attr, type => 'language tag syntax error');
-   }
-   ## TODO: RFC 3066 test
-   ## ISSUE: RFC 4646 (3066bis)?
- }; # $HTMLLanguageTagAttrChecker
- ## "A valid media query [MQ]"
- my $HTMLMQAttrChecker = sub {
-   ## ISSUE: What is "a valid media query"?
- }; # $HTMLMQAttrChecker
- my $HTMLEventHandlerAttrChecker = sub {
-   ## TODO: MUST contain valid ECMAScript code matching the
-   ## ECMAScript |FunctionBody| production. [ECMA262]
-   ## ISSUE: MUST be ES3? E4X? ES4? JS1.x?
-   ## ISSUE: Automatic semicolon insertion does not apply?
-   ## ISSUE: Other script languages?
- }; # $HTMLEventHandlerAttrChecker
- my $HTMLUsemapAttrChecker = sub {
-   my ($self, $attr) = @_;
-   ## MUST be a valid hashed ID reference to a |map| element
-   my $value = $attr->value;
-   if ($value =~ s/^#//) {
-     ## ISSUE: Is |usemap="#"| conformant? (c.f. |id=""| is non-conformant.)
-     push @{$self->{usemap}}, [$value => $attr];
-   } else {
-     $self->{onerror}->(node => $attr, type => 'hashed idref syntax error');
    }
-   ## ISSUE: UA algorithm for matching is case-insensitive; IDs only different in cases should be reported
- }; # $HTMLUsemapAttrChecker
- my $HTMLTargetAttrChecker = sub {
-   my ($self, $attr) = @_;
-   my $value = $attr->value;
-   if ($value =~ /^_/) {
-     $value = lc $value; ## ISSUE: ASCII case-insentitive?
-     unless ({
-              _self => 1, _parent => 1, _top => 1,
-             }->{$value}) {
-       $self->{onerror}->(node => $attr,
-                          type => 'reserved browsing context name');
-     }
-   } else {
-     #$ ISSUE: An empty string is conforming?
-   }
- }; # $HTMLTargetAttrChecker
- my $HTMLAttrChecker = {
-   id => sub {
-     ## NOTE: |map| has its own variant of |id=""| checker
-     my ($self, $attr) = @_;
-     my $value = $attr->value;
-     if (length $value > 0) {
-       if ($self->{id}->{$value}) {
-         $self->{onerror}->(node => $attr, type => 'duplicate ID');
-       } else {
-         $self->{id}->{$value} = 1;
-       }
-       ## TODO: no space characters <http://html5.org/tools/web-apps-tracker?from=880&to=881>
-     } else {
-       ## NOTE: MUST contain at least one character
-       $self->{onerror}->(node => $attr, type => 'attribute value is empty');
-     }
-   },
-   title => sub {}, ## NOTE: No conformance creteria
-   lang => sub {
-     ## TODO: RFC 3066 or empty test
-     ## ISSUE: RFC 4646 (3066bis)?
-     ## TODO: HTML vs XHTML
-   },
-   dir => $GetHTMLEnumeratedAttrChecker->({ltr => 1, rtl => 1}),
-   class => $HTMLUnorderedSetOfSpaceSeparatedTokensAttrChecker,
-   irrelevant => $GetHTMLBooleanAttrChecker->('irrelevant'),
-   ## TODO: tabindex
- };
- for (qw/
-          onabort onbeforeunload onblur onchange onclick oncontextmenu
-          ondblclick ondrag ondragend ondragenter ondragleave ondragover
-          ondragstart ondrop onerror onfocus onkeydown onkeypress
-          onkeyup onload onmessage onmousedown onmousemove onmouseout
-          onmouseover onmouseup onmousewheel onresize onscroll onselect
-          onsubmit onunload
-      /) {
-   $HTMLAttrChecker->{$_} = $HTMLEventHandlerAttrChecker;
- }
- my $GetHTMLAttrsChecker = sub {
-   my $element_specific_checker = shift;
-   return sub {
-     my ($self, $todo) = @_;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         $checker = $element_specific_checker->{$attr_ln}
-           || $HTMLAttrChecker->{$attr_ln};
-       }
-       $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
-       if ($checker) {
-         $checker->($self, $attr);
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for unknown attributes in the spec
-       }
-     }
-   };
- }; # $GetHTMLAttrsChecker
- $Element->{$HTML_NS}->{''} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $ElementDefault->{checker},
- };
- $Element->{$HTML_NS}->{html} = {
-   is_root => 1,
-   attrs_checker => $GetHTMLAttrsChecker->({
-     xmlns => sub {
-       my ($self, $attr) = @_;
-       my $value = $attr->value;
-       unless ($value eq $HTML_NS) {
-         $self->{onerror}->(node => $attr, type => 'syntax error');
-         ## TODO: only in HTML documents
-       }
-     },
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before head';
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($phase eq 'before head') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'head') {
-             $phase = 'after head';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'body') {
-             $self->{onerror}->(node => $node, type => 'ps element missing:head');
-             $phase = 'after body';
-           } else {
-             $not_allowed = 1;
-             # before head
-           }
-         } elsif ($phase eq 'after head') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'body') {
-             $phase = 'after body';
-           } else {
-             $not_allowed = 1;
-             # after head
-           }
-         } else { #elsif ($phase eq 'after body') {
-           $not_allowed = 1;
-           # after body
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     if ($phase eq 'before head') {
+   for (@{$self->{template}}) {
-       $self->{onerror}->(node => $el, type => 'child element missing:head');
+     ## TODO: If the document is an XML document, ...
-       $self->{onerror}->(node => $el, type => 'child element missing:body');
+     ## NOTE: If the document is an HTML document:
-     } elsif ($phase eq 'after head') {
+     ## ISSUE: We need to percent-decode?
-       $self->{onerror}->(node => $el, type => 'child element missing:body');
+     F: {
-     }
+       if ($self->{id}->{$_->[0]}) {
+         my $el = $self->{id}->{$_->[0]}->[0]->owner_element;
-     return ($new_todos);
+         if ($el->node_type == 1 and # ELEMENT_NODE
-   },
+             $el->manakai_local_name eq 'datatemplate') {
- };
+           my $nsuri = $el->namespace_uri;
+           if (defined $nsuri and $nsuri eq $HTML_NS) {
- $Element->{$HTML_NS}->{head} = {
+             if ($el eq $_->[1]->owner_element) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+               $self->{onerror}->(node => $_->[1],
-   checker => sub {
+                                  type => 'fragment points itself',
-     my ($self, $todo) = @_;
+                                  level => $self->{level}->{must});
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $has_title;
-     my $phase = 'initial'; # 'after charset', 'after base'
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $HTML_NS and $node_ln eq 'title') {
-           $phase = 'after base';
-           unless ($has_title) {
-             $has_title = 1;
-           } else {
-             $not_allowed = 1;
-           }
-         } elsif ($node_ns eq $HTML_NS and $node_ln eq 'meta') {
-           if ($node->has_attribute_ns (undef, 'charset')) {
-             if ($phase eq 'initial') {
-               $phase = 'after charset';
-             } else {
-               $not_allowed = 1;
-               ## NOTE: See also |base|'s "contexts" field in the spec
              }
-           } else {
-             $phase = 'after base';
+             last F;
-           }
-         } elsif ($node_ns eq $HTML_NS and $node_ln eq 'base') {
-           if ($phase eq 'initial' or $phase eq 'after charset') {
-             $phase = 'after base';
-           } else {
-             $not_allowed = 1;
            }
-         } elsif ($HTMLMetadataElements->{$node_ns}->{$node_ln}) {
-           $phase = 'after base';
-         } else {
-           $not_allowed = 1;
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
          }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
        }
-     }
+       ## TODO: Should we raise a "fragment points nothing" error instead
-     unless ($has_title) {
+       ## if the fragment identifier identifies no element?
-       $self->{onerror}->(node => $el, type => 'child element missing:title');
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{title} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLTextChecker,
- };
- $Element->{$HTML_NS}->{base} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     href => $HTMLURIAttrChecker,
-     target => $HTMLTargetAttrChecker,
-   }),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{link} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       href => $HTMLURIAttrChecker,
-       rel => sub { $HTMLLinkTypesAttrChecker->(0, @_) },
-       media => $HTMLMQAttrChecker,
-       hreflang => $HTMLLanguageTagAttrChecker,
-       type => $HTMLIMTAttrChecker,
-       ## NOTE: Though |title| has special semantics,
-       ## syntactically same as the |title| as global attribute.
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'href')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:href');
-     }
-     unless ($todo->{node}->has_attribute_ns (undef, 'rel')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:rel');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{meta} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     my $name_attr;
-     my $http_equiv_attr;
-     my $charset_attr;
-     my $content_attr;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         if ($attr_ln eq 'content') {
-           $content_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'name') {
-           $name_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'http-equiv') {
-           $http_equiv_attr = $attr;
-           $checker = 1;
-         } elsif ($attr_ln eq 'charset') {
-           $charset_attr = $attr;
-           $checker = 1;
-         } else {
-           $checker = $HTMLAttrChecker->{$attr_ln}
-             || $AttrChecker->{$attr_ns}->{$attr_ln}
-               || $AttrChecker->{$attr_ns}->{''};
-         }
-       } else {
-         $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-           || $AttrChecker->{$attr_ns}->{''};
-       }
-       if ($checker) {
-         $checker->($self, $attr) if ref $checker;
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for unknown attributes in the spec
-       }
-     }
-     if (defined $name_attr) {
-       if (defined $http_equiv_attr) {
-         $self->{onerror}->(node => $http_equiv_attr,
-                            type => 'attribute not allowed');
-       } elsif (defined $charset_attr) {
-         $self->{onerror}->(node => $charset_attr,
-                            type => 'attribute not allowed');
-       }
-       my $metadata_name = $name_attr->value;
-       my $metadata_value;
-       if (defined $content_attr) {
-         $metadata_value = $content_attr->value;
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:content');
-         $metadata_value = '';
-       }
-     } elsif (defined $http_equiv_attr) {
-       if (defined $charset_attr) {
-         $self->{onerror}->(node => $charset_attr,
-                            type => 'attribute not allowed');
-       }
-       unless (defined $content_attr) {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:content');
-       }
-     } elsif (defined $charset_attr) {
-       if (defined $content_attr) {
-         $self->{onerror}->(node => $content_attr,
-                            type => 'attribute not allowed');
-       }
-       ## TODO: Allowed only in HTML documents
-     } else {
-       if (defined $content_attr) {
-         $self->{onerror}->(node => $content_attr,
-                            type => 'attribute not allowed');
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:name|http-equiv');
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:name|http-equiv|charset');
-       }
-     }
-     ## TODO: metadata conformance
+       $self->{onerror}->(node => $_->[1], type => 'template:not template',
+                          level => $self->{level}->{must});
-     ## TODO: pragma conformance
+     } # F
-     if (defined $http_equiv_attr) { ## An enumerated attribute
+   }
-       my $keyword = lc $http_equiv_attr->value; ## TODO: ascii case?
-       if ({
-            'refresh' => 1,
-            'default-style' => 1,
-           }->{$keyword}) {
-         #
-       } else {
-         $self->{onerror}->(node => $http_equiv_attr,
-                            type => 'invalid enumerated attribute value');
-       }
-     }
-     ## TODO: charset
-   },
-   checker => $HTMLEmptyChecker,
- };
- ## NOTE: |html:style| has no conformance creteria on content model
- $Element->{$HTML_NS}->{style} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     type => $HTMLIMTAttrChecker, ## TODO: MUST be a styling language
-     media => $HTMLMQAttrChecker,
-     scoped => $GetHTMLBooleanAttrChecker->('scoped'),
-     ## NOTE: |title| has special semantics for |style|s, but is syntactically
-     ## not different
-   }),
-   checker => $AnyChecker,
- };
- $Element->{$HTML_NS}->{body} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLBlockChecker,
- };
- $Element->{$HTML_NS}->{section} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStylableBlockChecker,
- };
- $Element->{$HTML_NS}->{nav} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLBlockOrInlineChecker,
- };
- $Element->{$HTML_NS}->{article} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStylableBlockChecker,
- };
- $Element->{$HTML_NS}->{blockquote} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLBlockChecker,
- };
- $Element->{$HTML_NS}->{aside} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),
- };
- $Element->{$HTML_NS}->{h1} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h2} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h3} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h4} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h5} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{h6} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- ## TODO: header
- $Element->{$HTML_NS}->{footer} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub { ## block -hn -header -footer -sectioning or inline
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $content = 'block-or-inline'; # or 'block' or 'inline'
+   for (@{$self->{ref}}) {
-     my @block_not_inline;
+     ## TOOD: If XML
-     while (@nodes) {
+     ## NOTE: If it is an HTML document:
-       my $node = shift @nodes;
+     if ($_->[0] eq '') {
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
+       ## NOTE: It points the top of the document.
+     } elsif ($self->{id}->{$_->[0]}) {
-       my $nt = $node->node_type;
+       if ($self->{id}->{$_->[0]}->[0]->owner_element
-       if ($nt == 1) {
+               eq $_->[1]->owner_element) {
-         my $node_ns = $node->namespace_uri;
+         $self->{onerror}->(node => $_->[1], type => 'fragment points itself',
-         $node_ns = '' unless defined $node_ns;
+                            level => $self->{level}->{must});
-         my $node_ln = $node->manakai_local_name;
-         my $not_allowed;
-         if ($self->{minuses}->{$node_ns}->{$node_ln}) {
-           $not_allowed = 1;
-         } elsif ($node_ns eq $HTML_NS and
-                  {
-                    qw/h1 1 h2 1 h3 1 h4 1 h5 1 h6 1 header 1 footer 1/
-                  }->{$node_ln}) {
-           $not_allowed = 1;
-         } elsif ($HTMLSectioningElements->{$node_ns}->{$node_ln}) {
-           $not_allowed = 1;
-         }
-         if ($content eq 'block') {
-           $not_allowed = 1
-             unless $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-         } elsif ($content eq 'inline') {
-           $not_allowed = 1
-             unless $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-         } else {
-           my $is_block = $HTMLBlockLevelElements->{$node_ns}->{$node_ln};
-           my $is_inline
-             = $HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} ||
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln};
-           push @block_not_inline, $node
-             if $is_block and not $is_inline and not $not_allowed;
-           unless ($is_block) {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-             $not_allowed = 1 unless $is_inline;
-           }
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           if ($content eq 'block') {
-             $self->{onerror}->(node => $node, type => 'character not allowed');
-           } else {
-             $content = 'inline';
-             for (@block_not_inline) {
-               $self->{onerror}->(node => $_, type => 'element not allowed');
-             }
-           }
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
        }
-     }
-     my $end = $self->_add_minuses
-       ({$HTML_NS => {qw/h1 1 h2 1 h3 1 h4 1 h5 1 h6 1/}},
-        $HTMLSectioningElements);
-     push @$new_todos, $end;
-     if ($content eq 'inline') {
-       for (@$new_todos) {
-         $_->{inline} = 1;
-       }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{address} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineChecker,
- };
- $Element->{$HTML_NS}->{p} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantInlineChecker,
- };
- $Element->{$HTML_NS}->{hr} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{br} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{dialog} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before dt';
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'before dt') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'before dd';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dt');
-             $phase = 'before dt';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } else { # before dd
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $phase = 'before dt';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dd');
-             $phase = 'before dd';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     if ($phase eq 'before dd') {
-       $self->{onerror}->(node => $el, type => 'ps element missing:dd');
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{pre} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{ol} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     start => $HTMLIntegerAttrChecker,
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         unless ($node_ns eq $HTML_NS and $node_ln eq 'li') {
-           $self->{onerror}->(node => $node, type => 'element not allowed');
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     if ($todo->{inline}) {
-       for (@$new_todos) {
-         $_->{inline} = 1;
-       }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{ul} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{ol}->{checker},
- };
- $Element->{$HTML_NS}->{li} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     start => sub {
-       my ($self, $attr) = @_;
-       my $parent = $attr->owner_element->manakai_parent_element;
-       if (defined $parent) {
-         my $parent_ns = $parent->namespace_uri;
-         $parent_ns = '' unless defined $parent_ns;
-         my $parent_ln = $parent->manakai_local_name;
-         unless ($parent_ns eq $HTML_NS and $parent_ln eq 'ol') {
-           $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         }
-       }
-       $HTMLIntegerAttrChecker->($self, $attr);
-     },
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     if ($todo->{inline}) {
-       return $HTMLInlineChecker->($self, $todo);
      } else {
-       return $HTMLBlockOrInlineChecker->($self, $todo);
+       $self->{onerror}->(node => $_->[1], type => 'fragment points nothing',
+                          level => $self->{level}->{must});
      }
-   },
+   }
- };
- $Element->{$HTML_NS}->{dl} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before dt';
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'in dds') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             #$phase = 'in dds';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'in dts';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in dts') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             #$phase = 'in dts';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $phase = 'in dds';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } else { # before dt
-           if ($node_ns eq $HTML_NS and $node_ln eq 'dt') {
-             $phase = 'in dts';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'dd') {
-             $self->{onerror}
-               ->(node => $node, type => 'ps element missing:dt');
-             $phase = 'in dds';
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     if ($phase eq 'in dts') {
-       $self->{onerror}->(node => $el, type => 'ps element missing:dd');
-     }
-     if ($todo->{inline}) {
-       for (@$new_todos) {
-         $_->{inline} = 1;
-       }
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{dt} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{dd} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{li}->{checker},
- };
- $Element->{$HTML_NS}->{a} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     my %attr;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         $checker = {
-                      target => $HTMLTargetAttrChecker,
-                      href => $HTMLURIAttrChecker,
-                      ping => $HTMLSpaceURIsAttrChecker,
-                      rel => sub { $HTMLLinkTypesAttrChecker->(1, @_) },
-                      media => $HTMLMQAttrChecker,
-                      hreflang => $HTMLLanguageTagAttrChecker,
-                      type => $HTMLIMTAttrChecker,
-                    }->{$attr_ln};
-         if ($checker) {
-           $attr{$attr_ln} = $attr;
-         } else {
-           $checker = $HTMLAttrChecker->{$attr_ln};
-         }
-       }
-       $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
-       if ($checker) {
-         $checker->($self, $attr) if ref $checker;
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for unknown attributes in the spec
-       }
-     }
-     unless (defined $attr{href}) {
-       for (qw/target ping rel media hreflang type/) {
-         if (defined $attr{$_}) {
-           $self->{onerror}->(node => $attr{$_},
-                              type => 'attribute not allowed');
-         }
-       }
-     }
-   },
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ($HTMLInteractiveElements);
-     my ($sib, $ch)
-       = $HTMLSignificantInlineOrStrictlyInlineChecker->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{q} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{cite} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{em} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{strong} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{small} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{m} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{dfn} = { ## TODO: term duplication
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {dfn => 1}});
-     my ($sib, $ch) = $HTMLStrictlyInlineChecker->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{abbr} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     ## NOTE: |title| has special semantics for |abbr|s, but is syntactically
-     ## not different.  The spec says that the |title| MAY be omitted
-     ## if there is a |dfn| whose defining term is the abbreviation,
-     ## but it does not prohibit |abbr| w/o |title| in other cases.
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{time} = { ## TODO: validate content
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO: datetime
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{meter} = { ## TODO: "The recommended way of giving the value is to include it as contents of the element"
-   attrs_checker => $GetHTMLAttrsChecker->({
-     value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     low => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     high => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-     optimum => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{progress} = { ## TODO: recommended to use content
-   attrs_checker => $GetHTMLAttrsChecker->({
-     value => $GetHTMLFloatingPointNumberAttrChecker->(sub { shift >= 0 }),
-     max => $GetHTMLFloatingPointNumberAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{code} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{var} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{samp} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{kbd} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{sub} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{sup} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{span} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLInlineOrStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{i} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   ## NOTE: Though |title| has special semantics,
-   ## syntatically same as the |title| as global attribute.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{b} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{bdo} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({})->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'dir')) {
-       $self->{onerror}->(node => $todo->{node}, type => 'attribute missing:dir');
-     }
-   },
-   ## ISSUE: The spec does not directly say that |dir| is a enumerated attr.
-   checker => $HTMLStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{ins} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-     ## TODO: datetime
-   }),
-   checker => $HTMLTransparentChecker,
- };
- $Element->{$HTML_NS}->{del} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     cite => $HTMLURIAttrChecker,
-     ## TODO: datetime
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $parent = $todo->{node}->manakai_parent_element;
-     if (defined $parent) {
-       my $nsuri = $parent->namespace_uri;
-       $nsuri = '' unless defined $nsuri;
-       my $ln = $parent->manakai_local_name;
-       my $eldef = $Element->{$nsuri}->{$ln} ||
-         $Element->{$nsuri}->{''} ||
-         $ElementDefault;
-       return $eldef->{checker}->($self, $todo);
-     } else {
-       return $HTMLBlockOrInlineChecker->($self, $todo);
-     }
-   },
- };
- ## TODO: figure
- $Element->{$HTML_NS}->{img} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       alt => sub { }, ## NOTE: No syntactical requirement
-       src => $HTMLURIAttrChecker,
-       usemap => $HTMLUsemapAttrChecker,
-       ismap => $GetHTMLBooleanAttrChecker->('ismap'), ## TODO: MUST ancestor <a>
-       ## TODO: height
-       ## TODO: width
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'alt')) {
-       $self->{onerror}->(node => $todo->{node}, type => 'attribute missing:alt');
-     }
-     unless ($todo->{node}->has_attribute_ns (undef, 'src')) {
-       $self->{onerror}->(node => $todo->{node}, type => 'attribute missing:src');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{iframe} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLTextChecker,
- };
- $Element->{$HTML_NS}->{embed} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     my $has_src;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         if ($attr_ln eq 'src') {
-           $checker = $HTMLURIAttrChecker;
-           $has_src = 1;
-         } elsif ($attr_ln eq 'type') {
-           $checker = $HTMLIMTAttrChecker;
-         } else {
-           ## TODO: height
-           ## TODO: width
-           $checker = $HTMLAttrChecker->{$attr_ln}
-             || sub { }; ## NOTE: Any local attribute is ok.
-         }
-       }
-       $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
-       if ($checker) {
-         $checker->($self, $attr);
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for global attributes in the spec
-       }
-     }
-     unless ($has_src) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:src');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{object} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       data => $HTMLURIAttrChecker,
-       type => $HTMLIMTAttrChecker,
-       usemap => $HTMLUsemapAttrChecker,
-       ## TODO: width
-       ## TODO: height
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'data')) {
-       unless ($todo->{node}->has_attribute_ns (undef, 'type')) {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:data|type');
-       }
-     }
-   },
-   checker => $ElementDefault->{checker}, ## TODO
- };
- $Element->{$HTML_NS}->{param} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       name => sub { },
-       value => sub { },
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'name')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:name');
-     }
-     unless ($todo->{node}->has_attribute_ns (undef, 'value')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:value');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{video} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-     ## TODO: start, loopstart, loopend, end
-     ## ISSUE: they MUST be "value time offset"s.  Value?
-     ## ISSUE: loopcount has no conformance creteria
-     autoplay => $GetHTMLBooleanAttrChecker->('autoplay'),
-     controls => $GetHTMLBooleanAttrChecker->('controls'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     if ($todo->{node}->has_attribute_ns (undef, 'src')) {
-       return $HTMLBlockOrInlineChecker->($self, $todo);
-     } else {
-       return $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'source')
-         ->($self, $todo);
-     }
-   },
- };
- $Element->{$HTML_NS}->{audio} = {
-   attrs_checker => $Element->{$HTML_NS}->{video}->{attrs_checker},
-   checker => $Element->{$HTML_NS}->{video}->{checker},
- };
- $Element->{$HTML_NS}->{source} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       src => $HTMLURIAttrChecker,
-       type => $HTMLIMTAttrChecker,
-       media => $HTMLMQAttrChecker,
-     })->($self, $todo);
-     unless ($todo->{node}->has_attribute_ns (undef, 'src')) {
-       $self->{onerror}->(node => $todo->{node},
-                          type => 'attribute missing:src');
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{canvas} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
-     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
-   }),
-   checker => $HTMLInlineChecker,
- };
- $Element->{$HTML_NS}->{map} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     id => sub {
-       ## NOTE: same as global |id=""|, with |$self->{map}| registeration
-       my ($self, $attr) = @_;
-       my $value = $attr->value;
-       if (length $value > 0) {
-         if ($self->{id}->{$value}) {
-           $self->{onerror}->(node => $attr, type => 'duplicate ID');
-         } else {
-           $self->{id}->{$value} = 1;
-         }
-       } else {
-         ## NOTE: MUST contain at least one character
-         $self->{onerror}->(node => $attr, type => 'attribute value is empty');
-       }
-       $self->{map}->{$value} ||= $attr;
-     },
-   }),
-   checker => $HTMLBlockChecker,
- };
- $Element->{$HTML_NS}->{area} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     my %attr;
-     my $coords;
-     for my $attr (@{$todo->{node}->attributes}) {
-       my $attr_ns = $attr->namespace_uri;
-       $attr_ns = '' unless defined $attr_ns;
-       my $attr_ln = $attr->manakai_local_name;
-       my $checker;
-       if ($attr_ns eq '') {
-         $checker = {
-                      alt => sub { },
-                          ## NOTE: |alt| value has no conformance creteria.
-                      shape => $GetHTMLEnumeratedAttrChecker->({
-                        circ => -1, circle => 1,
-                        default => 1,
-                        poly => 1, polygon => -1,
-                        rect => 1, rectangle => -1,
-                      }),
-                      coords => sub {
-                        my ($self, $attr) = @_;
-                        my $value = $attr->value;
-                        if ($value =~ /\A-?[0-9]+(?>,-?[0-9]+)*\z/) {
-                          $coords = [split /,/, $value];
-                        } else {
-                          $self->{onerror}->(node => $attr,
-                                             type => 'syntax error');
-                        }
-                      },
-                      target => $HTMLTargetAttrChecker,
-                      href => $HTMLURIAttrChecker,
-                      ping => $HTMLSpaceURIsAttrChecker,
-                      rel => sub { $HTMLLinkTypesAttrChecker->(1, @_) },
-                      media => $HTMLMQAttrChecker,
-                      hreflang => $HTMLLanguageTagAttrChecker,
-                      type => $HTMLIMTAttrChecker,
-                    }->{$attr_ln};
-         if ($checker) {
-           $attr{$attr_ln} = $attr;
-         } else {
-           $checker = $HTMLAttrChecker->{$attr_ln};
-         }
-       }
-       $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
-         || $AttrChecker->{$attr_ns}->{''};
-       if ($checker) {
-         $checker->($self, $attr) if ref $checker;
-       } else {
-         $self->{onerror}->(node => $attr, type => 'attribute not supported');
-         ## ISSUE: No comformance createria for unknown attributes in the spec
-       }
-     }
-     if (defined $attr{href}) {
-       unless (defined $attr{alt}) {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:alt');
-       }
-     } else {
-       for (qw/target ping rel media hreflang type alt/) {
-         if (defined $attr{$_}) {
-           $self->{onerror}->(node => $attr{$_},
-                              type => 'attribute not allowed');
-         }
-       }
-     }
-     my $shape = 'rectangle';
-     if (defined $attr{shape}) {
-       $shape = {
-                 circ => 'circle', circle => 'circle',
-                 default => 'default',
-                 poly => 'polygon', polygon => 'polygon',
-                 rect => 'rectangle', rectangle => 'rectangle',
-                }->{lc $attr{shape}->value} || 'rectangle';
-       ## TODO: ASCII lowercase?
-     }
-     if ($shape eq 'circle') {
-       if (defined $attr{coords}) {
-         if (defined $coords) {
-           if (@$coords == 3) {
-             if ($coords->[2] < 0) {
-               $self->{onerror}->(node => $attr{coords},
-                                  type => 'out of range:2');
-             }
-           } else {
-             $self->{onerror}->(node => $attr{coords},
-                                type => 'list item number:3:'.@$coords);
-           }
-         } else {
-           ## NOTE: A syntax error has been reported.
-         }
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:coords');
-       }
-     } elsif ($shape eq 'default') {
-       if (defined $attr{coords}) {
-         $self->{onerror}->(node => $attr{coords},
-                            type => 'attribute not allowed');
-       }
-     } elsif ($shape eq 'polygon') {
-       if (defined $attr{coords}) {
-         if (defined $coords) {
-           if (@$coords >= 6) {
-             unless (@$coords % 2 == 0) {
-               $self->{onerror}->(node => $attr{coords},
-                                  type => 'list item number:even:'.@$coords);
-             }
-           } else {
-             $self->{onerror}->(node => $attr{coords},
-                                type => 'list item number:>=6:'.@$coords);
-           }
-         } else {
-           ## NOTE: A syntax error has been reported.
-         }
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:coords');
-       }
-     } elsif ($shape eq 'rectangle') {
-       if (defined $attr{coords}) {
-         if (defined $coords) {
-           if (@$coords == 4) {
-             unless ($coords->[0] < $coords->[2]) {
-               $self->{onerror}->(node => $attr{coords},
-                                  type => 'out of range:0');
-             }
-             unless ($coords->[1] < $coords->[3]) {
-               $self->{onerror}->(node => $attr{coords},
-                                  type => 'out of range:1');
-             }
-           } else {
-             $self->{onerror}->(node => $attr{coords},
-                                type => 'list item number:4:'.@$coords);
-           }
-         } else {
-           ## NOTE: A syntax error has been reported.
-         }
-       } else {
-         $self->{onerror}->(node => $todo->{node},
-                            type => 'attribute missing:coords');
-       }
-     }
-   },
-   checker => $HTMLEmptyChecker,
- };
- ## TODO: only in map
- $Element->{$HTML_NS}->{table} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $phase = 'before caption';
-     my $has_tfoot;
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($phase eq 'in tbodys') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             #$phase = 'in tbodys';
-           } elsif (not $has_tfoot and
-                    $node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'after tfoot';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in trs') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             #$phase = 'in trs';
-           } elsif (not $has_tfoot and
-                    $node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'after tfoot';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'after thead') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'in colgroup') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'colgroup') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'thead') {
-             $phase = 'after thead';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } elsif ($phase eq 'before caption') {
-           if ($node_ns eq $HTML_NS and $node_ln eq 'caption') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'colgroup') {
-             $phase = 'in colgroup';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'thead') {
-             $phase = 'after thead';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tbody') {
-             $phase = 'in tbodys';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-             $phase = 'in trs';
-           } elsif ($node_ns eq $HTML_NS and $node_ln eq 'tfoot') {
-             $phase = 'in tbodys';
-             $has_tfoot = 1;
-           } else {
-             $self->{onerror}->(node => $node, type => 'element not allowed');
-           }
-         } else { # after tfoot
-           $self->{onerror}->(node => $node, type => 'element not allowed');
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     ## Table model errors
-     require Whatpm::HTMLTable;
-     Whatpm::HTMLTable->form_table ($todo->{node}, sub {
-       my %opt = @_;
-       $self->{onerror}->(type => 'table:'.$opt{type}, node => $opt{node});
-     });
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{caption} = {
+   ## TODO: Maybe we should have $document->manakai_get_by_fragment or something
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $HTMLSignificantStrictlyInlineChecker,
- };
- $Element->{$HTML_NS}->{colgroup} = {
+   for (@{$self->{usemap}}) {
-   attrs_checker => $GetHTMLAttrsChecker->({
+     unless ($self->{map}->{$_->[0]}) {
-     span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
+       $self->{onerror}->(node => $_->[1], type => 'no referenced map',
-       ## NOTE: Defined only if "the |colgroup| element contains no |col| elements"
+                          level => $self->{level}->{must});
-       ## TODO: "attribute not supported" if |col|.
-       ## ISSUE: MUST NOT if any |col|?
-       ## ISSUE: MUST NOT for |<colgroup span="1"><any><col/></any></colgroup>| (though non-conforming)?
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         unless ($node_ns eq $HTML_NS and $node_ln eq 'col') {
-           $self->{onerror}->(node => $node, type => 'element not allowed');
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
      }
-     return ($new_todos);
+   }
-   },
- };
- $Element->{$HTML_NS}->{col} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{tbody} = {
+   for (@{$self->{contextmenu}}) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+     unless ($self->{menu}->{$_->[0]}) {
-   checker => sub {
+       $self->{onerror}->(node => $_->[1], type => 'no referenced menu',
-     my ($self, $todo) = @_;
+                          level => $self->{level}->{must});
-     my $el = $todo->{node};
-     my $new_todos = [];
-     my @nodes = (@{$el->child_nodes});
-     my $has_tr;
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($node_ns eq $HTML_NS and $node_ln eq 'tr') {
-           $has_tr = 1;
-         } else {
-           $self->{onerror}->(node => $node, type => 'element not allowed');
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
-         }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     unless ($has_tr) {
-       $self->{onerror}->(node => $el, type => 'child element missing:tr');
      }
-     return ($new_todos);
+   }
-   },
- };
- $Element->{$HTML_NS}->{thead} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $Element->{$HTML_NS}->{tbody}->{checker},
- };
- $Element->{$HTML_NS}->{tfoot} = {
+   delete $self->{plus_elements};
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+   delete $self->{minus_elements};
-   checker => $Element->{$HTML_NS}->{tbody}->{checker},
+   delete $self->{onerror};
- };
+   delete $self->{id};
+   delete $self->{form};
+   delete $self->{usemap};
+   delete $self->{ref};
+   delete $self->{template};
+   delete $self->{map};
+   return $self->{return};
+ } # check_element
- $Element->{$HTML_NS}->{tr} = {
+ sub _add_minus_elements ($$@) {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
+   my $self = shift;
-   checker => sub {
+   my $element_state = shift;
-     my ($self, $todo) = @_;
+   for my $elements (@_) {
-     my $el = $todo->{node};
+     for my $nsuri (keys %$elements) {
-     my $new_todos = [];
+       for my $ln (keys %{$elements->{$nsuri}}) {
-     my @nodes = (@{$el->child_nodes});
+         unless ($self->{minus_elements}->{$nsuri}->{$ln}) {
+           $element_state->{minus_elements_original}->{$nsuri}->{$ln} = 0;
-     my $has_td;
+           $self->{minus_elements}->{$nsuri}->{$ln} = 1;
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         ## NOTE: |minuses| list is not checked since redundant
-         if ($node_ns eq $HTML_NS and ($node_ln eq 'td' or $node_ln eq 'th')) {
-           $has_td = 1;
-         } else {
-           $self->{onerror}->(node => $node, type => 'element not allowed');
-         }
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           $self->{onerror}->(node => $node, type => 'character not allowed');
          }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
        }
      }
-     unless ($has_td) {
+   }
-       $self->{onerror}->(node => $el, type => 'child element missing:td|th');
+ } # _add_minus_elements
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{td} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-   }),
-   checker => $HTMLBlockOrInlineChecker,
- };
- $Element->{$HTML_NS}->{th} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
-     scope => $GetHTMLEnumeratedAttrChecker
-         ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
-   }),
-   checker => $HTMLBlockOrInlineChecker,
- };
- ## TODO: table model error checking
- ## TODO: forms
- $Element->{$HTML_NS}->{script} = {
-   attrs_checker => sub {
-     my ($self, $todo) = @_;
-     $GetHTMLAttrsChecker->({
-       src => $HTMLURIAttrChecker,
-       defer => $GetHTMLBooleanAttrChecker->('defer'),
-       async => $GetHTMLBooleanAttrChecker->('async'),
-       type => $HTMLIMTAttrChecker,
-     })->($self, $todo);
-     if ($todo->{node}->has_attribute_ns (undef, 'defer')) {
-       my $async_attr = $todo->{node}->get_attribute_node_ns (undef, 'async');
-       if ($async_attr) {
-         $self->{onerror}->(node => $async_attr,
-                            type => 'attribute not allowed'); # MUST NOT
-       }
-     }
-   },
-   checker => sub {
-     my ($self, $todo) = @_;
-     if ($todo->{node}->has_attribute_ns (undef, 'src')) {
+ sub _remove_minus_elements ($$) {
-       return $HTMLEmptyChecker->($self, $todo);
+   my $self = shift;
-     } else {
+   my $element_state = shift;
-       ## NOTE: No content model conformance in HTML5 spec.
+   for my $nsuri (keys %{$element_state->{minus_elements_original}}) {
-       return $AnyChecker->($self, $todo);
+     for my $ln (keys %{$element_state->{minus_elements_original}->{$nsuri}}) {
+       delete $self->{minus_elements}->{$nsuri}->{$ln};
      }
-   },
+   }
- };
+ } # _remove_minus_elements
- ## NOTE: When script is disabled.
- $Element->{$HTML_NS}->{noscript} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {noscript => 1}});
-     my ($sib, $ch) = $HTMLBlockOrInlineChecker->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{'event-source'} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     src => $HTMLURIAttrChecker,
-   }),
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{details} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     open => $GetHTMLBooleanAttrChecker->('open'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {a => 1, datagrid => 1}});
-     my ($sib, $ch)
-       = $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'legend')
-         ->($self, $todo);
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{datagrid} = {
-   attrs_checker => $GetHTMLAttrsChecker->({
-     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
-     multiple => $GetHTMLBooleanAttrChecker->('multiple'),
-   }),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $end = $self->_add_minuses ({$HTML_NS => {a => 1, datagrid => 1}});
-     my ($sib, $ch) = $HTMLBlockChecker->($self, $todo);
-     ## TODO: (Block-table)+ | table | select | datalist
-     push @$sib, $end;
-     return ($sib, $ch);
-   },
- };
- $Element->{$HTML_NS}->{command} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLEmptyChecker,
- };
- $Element->{$HTML_NS}->{menu} = {
+ sub _add_plus_elements ($$@) {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
+   my $self = shift;
-   checker => sub {
+   my $element_state = shift;
-     my ($self, $todo) = @_;
+   for my $elements (@_) {
-     my $el = $todo->{node};
+     for my $nsuri (keys %$elements) {
-     my $new_todos = [];
+       for my $ln (keys %{$elements->{$nsuri}}) {
-     my @nodes = (@{$el->child_nodes});
+         unless ($self->{plus_elements}->{$nsuri}->{$ln}) {
+           $element_state->{plus_elements_original}->{$nsuri}->{$ln} = 0;
-     my $content = 'li or inline';
+           $self->{plus_elements}->{$nsuri}->{$ln} = 1;
-     while (@nodes) {
-       my $node = shift @nodes;
-       $self->_remove_minuses ($node) and next if ref $node eq 'HASH';
-       my $nt = $node->node_type;
-       if ($nt == 1) {
-         my $node_ns = $node->namespace_uri;
-         $node_ns = '' unless defined $node_ns;
-         my $node_ln = $node->manakai_local_name;
-         my $not_allowed = $self->{minuses}->{$node_ns}->{$node_ln};
-         if ($node_ns eq $HTML_NS and $node_ln eq 'li') {
-           if ($content eq 'inline') {
-             $not_allowed = 1;
-           } elsif ($content eq 'li or inline') {
-             $content = 'li';
-           }
-         } else {
-           if ($HTMLStrictlyInlineLevelElements->{$node_ns}->{$node_ln} or
-               $HTMLStructuredInlineLevelElements->{$node_ns}->{$node_ln}) {
-             $content = 'inline';
-           } else {
-             $not_allowed = 1;
-           }
-         }
-         $self->{onerror}->(node => $node, type => 'element not allowed')
-           if $not_allowed;
-         my ($sib, $ch) = $self->_check_get_children ($node);
-         unshift @nodes, @$sib;
-         push @$new_todos, @$ch;
-       } elsif ($nt == 3 or $nt == 4) {
-         if ($node->data =~ /[^\x09-\x0D\x20]/) {
-           if ($content eq 'li') {
-             $self->{onerror}->(node => $node, type => 'character not allowed');
-           } elsif ($content eq 'li or inline') {
-             $content = 'inline';
-           }
          }
-       } elsif ($nt == 5) {
-         unshift @nodes, @{$node->child_nodes};
-       }
-     }
-     for (@$new_todos) {
-       $_->{inline} = 1;
-     }
-     return ($new_todos);
-   },
- };
- $Element->{$HTML_NS}->{legend} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => sub {
-     my ($self, $todo) = @_;
-     my $parent = $todo->{node}->manakai_parent_element;
-     if (defined $parent) {
-       my $nsuri = $parent->namespace_uri;
-       $nsuri = '' unless defined $nsuri;
-       my $ln = $parent->manakai_local_name;
-       if ($nsuri eq $HTML_NS and $ln eq 'figure') {
-         return $HTMLInlineChecker->($self, $todo);
-       } else {
-         return $HTMLSignificantStrictlyInlineChecker->($self, $todo);
        }
-     } else {
-       return $HTMLInlineChecker->($self, $todo);
      }
-     ## ISSUE: Content model is defined only for fieldset/legend,
-     ## details/legend, and figure/legend.
-   },
- };
- $Element->{$HTML_NS}->{div} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}),
-   checker => $GetHTMLZeroOrMoreThenBlockOrInlineChecker->($HTML_NS, 'style'),
- };
- $Element->{$HTML_NS}->{font} = {
-   attrs_checker => $GetHTMLAttrsChecker->({}), ## TODO
-   checker => $HTMLTransparentChecker,
- };
- sub check_document ($$$) {
-   my ($self, $doc, $onerror) = @_;
-   $self = bless {}, $self unless ref $self;
-   $self->{onerror} = $onerror;
-   my $docel = $doc->document_element;
-   unless (defined $docel) {
-     ## ISSUE: Should we check content of Document node?
-     $onerror->(node => $doc, type => 'no document element');
-     ## ISSUE: Is this non-conforming (to what spec)?  Or just a warning?
-     return;
    }
+ } # _add_plus_elements
-   ## ISSUE: Unexpanded entity references and HTML5 conformance
+ sub _remove_plus_elements ($$) {
+   my $self = shift;
-   my $docel_nsuri = $docel->namespace_uri;
+   my $element_state = shift;
-   $docel_nsuri = '' unless defined $docel_nsuri;
+   for my $nsuri (keys %{$element_state->{plus_elements_original}}) {
-   my $docel_def = $Element->{$docel_nsuri}->{$docel->manakai_local_name} ||
+     for my $ln (keys %{$element_state->{plus_elements_original}->{$nsuri}}) {
-     $Element->{$docel_nsuri}->{''} ||
+       delete $self->{plus_elements}->{$nsuri}->{$ln};
-     $ElementDefault;
+     }
-   if ($docel_def->{is_root}) {
-     #
-   } else {
-     $onerror->(node => $docel, type => 'element not allowed');
    }
+ } # _remove_plus_elements
-   ## TODO: Check for other items other than document element
+ sub _attr_status_info ($$$) {
-   ## (second (errorous) element, text nodes, PI nodes, doctype nodes)
+   my ($self, $attr, $status_code) = @_;
-   $self->check_element ($docel, $onerror);
- } # check_document
- sub check_element ($$$) {
-   my ($self, $el, $onerror) = @_;
-   $self = bless {}, $self unless ref $self;
-   $self->{onerror} = $onerror;
-   $self->{minuses} = {};
-   $self->{id} = {};
-   $self->{usemap} = [];
-   $self->{map} = {};
-   $self->{has_link_type} = {};
-   my @todo = ({type => 'element', node => $el});
+   if (not ($status_code & FEATURE_ALLOWED)) {
-   while (@todo) {
+     $self->{onerror}->(node => $attr,
-     my $todo = shift @todo;
+                        type => 'attribute not defined',
-     if ($todo->{type} eq 'element') {
+                        level => $self->{level}->{must});
-       my $prefix = $todo->{node}->prefix;
+   } elsif ($status_code & FEATURE_DEPRECATED_SHOULD) {
-       if (defined $prefix and $prefix eq 'xmlns') {
+     $self->{onerror}->(node => $attr,
-         $self->{onerror}
+                        type => 'deprecated:attr',
-           ->(node => $todo->{node},
+                        level => $self->{level}->{should});
-              type => 'NC:Reserved Prefixes and Namespace Names:<xmlns:>');
+   } elsif ($status_code & FEATURE_DEPRECATED_INFO) {
-       }
+     $self->{onerror}->(node => $attr,
-       my $nsuri = $todo->{node}->namespace_uri;
+                        type => 'deprecated:attr',
-       $nsuri = '' unless defined $nsuri;
+                        level => $self->{level}->{info});
-       my $ln = $todo->{node}->manakai_local_name;
-       my $eldef = $Element->{$nsuri}->{$ln} ||
-         $Element->{$nsuri}->{''} ||
-           $ElementDefault;
-       $eldef->{attrs_checker}->($self, $todo);
-       my ($new_todos) = $eldef->{checker}->($self, $todo);
-       unshift @todo, @$new_todos;
-     } elsif ($todo->{type} eq 'element-attributes') {
-       my $prefix = $todo->{node}->prefix;
-       if (defined $prefix and $prefix eq 'xmlns') {
-         $self->{onerror}
-           ->(node => $todo->{node},
-              type => 'NC:Reserved Prefixes and Namespace Names:<xmlns:>');
-       }
-       my $nsuri = $todo->{node}->namespace_uri;
-       $nsuri = '' unless defined $nsuri;
-       my $ln = $todo->{node}->manakai_local_name;
-       my $eldef = $Element->{$nsuri}->{$ln} ||
-         $Element->{$nsuri}->{''} ||
-           $ElementDefault;
-       $eldef->{attrs_checker}->($self, $todo);
-     } elsif ($todo->{type} eq 'plus') {
-       $self->_remove_minuses ($todo);
-     }
    }
-   for (@{$self->{usemap}}) {
+   my $status;
-     unless ($self->{map}->{$_->[0]}) {
+   if ($status_code & FEATURE_STATUS_REC) {
-       $self->{onerror}->(node => $_->[1], type => 'no referenced map');
+     return;
-     }
+   } elsif ($status_code & FEATURE_STATUS_CR) {
+     $status = 'cr';
+   } elsif ($status_code & FEATURE_STATUS_LC) {
+     $status = 'lc';
+   } elsif ($status_code & FEATURE_STATUS_WD) {
+     $status = 'wd';
+   } else {
+     $status = 'non-standard';
    }
+   $self->{onerror}->(node => $attr,
-   delete $self->{minuses};
+                      type => 'status:'.$status.':attr',
-   delete $self->{onerror};
+                      level => $self->{level}->{info});
-   delete $self->{id};
+ } # _attr_status_info
-   delete $self->{usemap};
-   delete $self->{map};
- } # check_element
  sub _add_minuses ($@) {
    my $self = shift;
-Line 2773 
 sub _add_minuses ($@) {
+Line 896 
 sub _add_minuses ($@) {
    return {type => 'plus', list => $r};
  } # _add_minuses
+ sub _add_pluses ($@) {
+   my $self = shift;
+   my $r = {};
+   for my $list (@_) {
+     for my $ns (keys %$list) {
+       for my $ln (keys %{$list->{$ns}}) {
+         unless ($self->{pluses}->{$ns}->{$ln}) {
+           $self->{pluses}->{$ns}->{$ln} = 1;
+           $r->{$ns}->{$ln} = 1;
+         }
+       }
+     }
+   }
+   return {type => 'minus', list => $r};
+ } # _add_pluses
  sub _remove_minuses ($$) {
    my ($self, $todo) = @_;
-   for my $ns (keys %{$todo->{list}}) {
+   if ($todo->{type} eq 'minus') {
-     for my $ln (keys %{$todo->{list}->{$ns}}) {
+     for my $ns (keys %{$todo->{list}}) {
-       delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       for my $ln (keys %{$todo->{list}->{$ns}}) {
+         delete $self->{pluses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       }
      }
+   } elsif ($todo->{type} eq 'plus') {
+     for my $ns (keys %{$todo->{list}}) {
+       for my $ln (keys %{$todo->{list}->{$ns}}) {
+         delete $self->{minuses}->{$ns}->{$ln} if $todo->{list}->{$ns}->{$ln};
+       }
+     }
+   } else {
+     die "$0: Unknown +- type: $todo->{type}";
    }
 ;
  } # _remove_minuses
- sub _check_get_children ($$) {
+ ## NOTE: Priority for "minuses" and "pluses" are currently left
-   my ($self, $node) = @_;
+ ## undefined and implemented inconsistently; it is not a problem for
+ ## now, since no element belongs to both lists.
+ sub _check_get_children ($$$) {
+   my ($self, $node, $parent_todo) = @_;
    my $new_todos = [];
    my $sib = [];
    TP: {
      my $node_ns = $node->namespace_uri;
      $node_ns = '' unless defined $node_ns;
      my $node_ln = $node->manakai_local_name;
-     if ($node_ns eq $HTML_NS) {
-       if ($node_ln eq 'noscript') {
-         my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});
-         push @$sib, $end;
-       }
-     }
      if ($HTMLTransparentElements->{$node_ns}->{$node_ln}) {
-       unshift @$sib, @{$node->child_nodes};
+       if ($node_ns eq $HTML_NS and $node_ln eq 'noscript') {
-       push @$new_todos, {type => 'element-attributes', node => $node};
+         if ($parent_todo->{flag}->{in_head}) {
-       last TP;
+           #
+         } else {
+           my $end = $self->_add_minuses ({$HTML_NS, {noscript => 1}});
+           push @$sib, $end;
+           unshift @$sib, @{$node->child_nodes};
+           push @$new_todos, {type => 'element-attributes', node => $node};
+           last TP;
+         }
+       } elsif ($node_ns eq $HTML_NS and $node_ln eq 'del') {
+         my $sig_flag = $parent_todo->{flag}->{has_descendant}->{significant};
+         unshift @$sib, @{$node->child_nodes};
+         push @$new_todos, {type => 'element-attributes', node => $node};
+         push @$new_todos,
+             {type => 'code',
+              code => sub {
+                $parent_todo->{flag}->{has_descendant}->{significant} = 0
+                    if not $sig_flag;
+              }};
+         last TP;
+       } else {
+         unshift @$sib, @{$node->child_nodes};
+         push @$new_todos, {type => 'element-attributes', node => $node};
+         last TP;
+       }
      }
      if ($node_ns eq $HTML_NS and ($node_ln eq 'video' or $node_ln eq 'audio')) {
        if ($node->has_attribute_ns (undef, 'src')) {
-Line 2821 
 sub _check_get_children ($$) {
+Line 992 
 sub _check_get_children ($$) {
                last CN;
              }
            } elsif ($cnt == 3 or $cnt == 4) {
-             if ($cn->data =~ /[^\x09-\x0D\x20]/) {
+             if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
                last CN;
              }
            }
          } # CN
          unshift @$sib, @cn;
        }
+     } elsif ($node_ns eq $HTML_NS and $node_ln eq 'object') {
+       my @cn = @{$node->child_nodes};
+       CN: while (@cn) {
+         my $cn = shift @cn;
+         my $cnt = $cn->node_type;
+         if ($cnt == 1) {
+           my $cn_nsuri = $cn->namespace_uri;
+           $cn_nsuri = '' unless defined $cn_nsuri;
+           if ($cn_nsuri eq $HTML_NS and $cn->manakai_local_name eq 'param') {
+             #
+           } else {
+             last CN;
+           }
+         } elsif ($cnt == 3 or $cnt == 4) {
+           if ($cn->data =~ /[^\x09\x0A\x0C\x0D\x20]/) {
+             last CN;
+           }
+         }
+       } # CN
+       unshift @$sib, @cn;
      }
      push @$new_todos, {type => 'element', node => $node};
    } # TP
+   for my $new_todo (@$new_todos) {
+     $new_todo->{flag} = {%{$parent_todo->{flag} or {}}};
+   }
    return ($sib, $new_todos);
  } # _check_get_children
+ =head1 LICENSE
+ Copyright 2007-2008 Wakaba <[email protected]>
+ This library is free software; you can redistribute it
+ and/or modify it under the same terms as Perl itself.
+ =cut
 ;
  # $Date$

 Legend:



Removed from v.1.26
 


changed lines


 
Added in v.1.97
 Legend:



Removed from v.1.26
 


changed lines


 
Added in v.1.97
-Removed from v.1.26
+Added in v.1.97

[email protected]	ViewVC Help
Powered by ViewVC 1.1.24