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

Contents of /markup/html/whatpm/Whatpm/ContentChecker/HTML.pm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.211 - (hide annotations) (download)
Sun Aug 30 07:20:42 2009 UTC (15 years, 10 months ago) by wakaba
Branch: MAIN
Changes since 1.210: +70 -7 lines
++ whatpm/t/dom-conformance/ChangeLog	30 Aug 2009 07:13:46 -0000
	* html-texts-1.dat: Added test cases for |progress|'s |value| and
	|max| attributes (cf. HTML5 revision 2484).

2009-08-30  Wakaba  <wakaba@suika.fam.cx>

++ whatpm/Whatpm/ContentChecker/ChangeLog	30 Aug 2009 07:13:58 -0000
	* HTML.pm: Implemented |progress|'s author requirements (cf. HTML5
	revision 2484).

2009-08-30  Wakaba  <wakaba@suika.fam.cx>

1 wakaba 1.1 package Whatpm::ContentChecker;
2     use strict;
3     require Whatpm::ContentChecker;
4    
5 wakaba 1.117 use Char::Class::XML qw/InXML_NCNameStartChar10 InXMLNCNameChar10/;
6    
7 wakaba 1.1 my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
8    
9 wakaba 1.174 ## --- Feature Status ---
10    
11 wakaba 1.187 sub FEATURE_HTML5_REC () {
12 wakaba 1.154 ## NOTE: Part of HTML5, the implemented status.
13 wakaba 1.89 Whatpm::ContentChecker::FEATURE_STATUS_REC |
14     Whatpm::ContentChecker::FEATURE_ALLOWED
15 wakaba 1.187
16     ## Strictly speaking, HTML5's "implemented and widely deployed"
17     ## status does not necessarily satisfy the condition for
18     ## FEATURE_STATUS_REC, since there is no test cases for most of
19     ## features marked as "implemented" in HTML5. Nevertheless, we
20     ## special-case HTML5's this status as if that had passed the CR
21     ## phase, considering HTML's history.
22 wakaba 1.89 }
23 wakaba 1.187
24 wakaba 1.154 sub FEATURE_HTML5_CR () {
25     ## NOTE: Part of HTML5, the awaiting implementation feedback status.
26     Whatpm::ContentChecker::FEATURE_STATUS_CR |
27     Whatpm::ContentChecker::FEATURE_ALLOWED
28     }
29 wakaba 1.54 sub FEATURE_HTML5_LC () {
30 wakaba 1.154 ## NOTE: Part of HTML5, the last call of comments status.
31 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_LC |
32     Whatpm::ContentChecker::FEATURE_ALLOWED
33     }
34     sub FEATURE_HTML5_AT_RISK () {
35 wakaba 1.154 ## NOTE: Part of HTML5, but in the being considered for removal
36     ## status.
37 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_WD |
38     Whatpm::ContentChecker::FEATURE_ALLOWED
39     }
40     sub FEATURE_HTML5_WD () {
41 wakaba 1.154 ## NOTE: Part of HTML5, the working draft status.
42 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_WD |
43     Whatpm::ContentChecker::FEATURE_ALLOWED
44     }
45     sub FEATURE_HTML5_FD () {
46 wakaba 1.154 ## NOTE: Part of HTML5, the first draft status.
47 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_WD |
48     Whatpm::ContentChecker::FEATURE_ALLOWED
49     }
50     sub FEATURE_HTML5_DEFAULT () {
51 wakaba 1.154 ## NOTE: Part of HTML5, but not annotated.
52 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_WD |
53     Whatpm::ContentChecker::FEATURE_ALLOWED
54 wakaba 1.49 }
55 wakaba 1.54 sub FEATURE_HTML5_DROPPED () {
56 wakaba 1.154 ## NOTE: Was part of HTML5, in a status before the last call of
57     ## comments, but then dropped.
58 wakaba 1.49 Whatpm::ContentChecker::FEATURE_STATUS_WD
59     }
60 wakaba 1.118 sub FEATURE_HTML5_LC_DROPPED () {
61 wakaba 1.154 ## NOTE: Was part of HTML5, in the last call of comments status, but
62     ## then dropped.
63 wakaba 1.118 Whatpm::ContentChecker::FEATURE_STATUS_LC
64     }
65 wakaba 1.154
66 wakaba 1.119 sub FEATURE_WF2X () {
67 wakaba 1.154 ## NOTE: Defined in WF2 (whether deprecated or not) and then
68     ## incorporated into the HTML5 spec.
69 wakaba 1.119 Whatpm::ContentChecker::FEATURE_STATUS_LC
70     }
71 wakaba 1.54 sub FEATURE_WF2 () {
72 wakaba 1.154 ## NOTE: Features introduced or modified in WF2, which were not
73     ## merged into HTML5.
74 wakaba 1.119 Whatpm::ContentChecker::FEATURE_STATUS_LC
75 wakaba 1.54 }
76 wakaba 1.126 sub FEATURE_WF2_INFORMATIVE () {
77 wakaba 1.154 ## NOTE: Features mentioned in WF2's informative appendix A, which
78     ## were not merged into HTML5.
79 wakaba 1.56 Whatpm::ContentChecker::FEATURE_STATUS_LC
80     }
81 wakaba 1.49
82 wakaba 1.154 sub FEATURE_RDFA_REC () {
83     Whatpm::ContentChecker::FEATURE_STATUS_REC
84 wakaba 1.121 }
85 wakaba 1.154 sub FEATURE_RDFA_LC_DROPPED () {
86     ## NOTE: The feature that was defined in a RDFa last call working
87     ## draft, but then dropped.
88 wakaba 1.61 Whatpm::ContentChecker::FEATURE_STATUS_LC
89     }
90 wakaba 1.58
91     ## NOTE: XHTML Role LCWD has almost no information on how the |role|
92     ## attribute can be used- the only requirements for that matter is:
93     ## "the attribute MUST be referenced using its namespace-qualified form" (and
94     ## this is a host language conformance!).
95 wakaba 1.82 sub FEATURE_ROLE_LC () {
96     Whatpm::ContentChecker::FEATURE_STATUS_LC
97     }
98    
99     sub FEATURE_XHTML2_ED () {
100 wakaba 1.154 ## NOTE: XHTML 2.0 Editor's Draft, in which the namespace URI is
101     ## "http://www.w3.org/1999/xhtml".
102 wakaba 1.82 Whatpm::ContentChecker::FEATURE_STATUS_WD
103     }
104 wakaba 1.58
105 wakaba 1.55 sub FEATURE_XHTMLBASIC11_CR () {
106 wakaba 1.154 ## NOTE: XHTML Basic 1.1 Recommendation, new features (not in XHTML
107     ## M12N).
108     Whatpm::ContentChecker::FEATURE_STATUS_REC
109 wakaba 1.55 }
110     sub FEATURE_XHTMLBASIC11_CR_DEPRECATED () {
111 wakaba 1.154 ## NOTE: XHTML Basic 1.1 Recommendation, new but deprecated
112     ## features.
113     Whatpm::ContentChecker::FEATURE_STATUS_REC |
114 wakaba 1.55 Whatpm::ContentChecker::FEATURE_DEPRECATED_INFO
115     }
116    
117 wakaba 1.154 sub FEATURE_RUBY_REC () {
118     Whatpm::ContentChecker::FEATURE_STATUS_CR
119 wakaba 1.82 }
120    
121 wakaba 1.154 sub FEATURE_M12N11_LC () {
122     ## NOTE: XHTML M12N 1.1 Recommendation, new features (not in 1.0).
123     Whatpm::ContentChecker::FEATURE_STATUS_REC;
124 wakaba 1.99 }
125    
126 wakaba 1.49 ## NOTE: M12N10 status is based on its abstract module definition.
127     ## It contains a number of problems. (However, again, it's a REC!)
128 wakaba 1.54 sub FEATURE_M12N10_REC () {
129 wakaba 1.154 ## NOTE: Oh, XHTML m12n 1.0 passed the CR phase! W3C Process sucks!
130 wakaba 1.54 Whatpm::ContentChecker::FEATURE_STATUS_REC
131     }
132     sub FEATURE_M12N10_REC_DEPRECATED () {
133     Whatpm::ContentChecker::FEATURE_STATUS_REC |
134     Whatpm::ContentChecker::FEATURE_DEPRECATED_INFO
135     }
136 wakaba 1.49
137     ## NOTE: XHTML10 status is based on its transitional and frameset DTDs
138     ## (second edition). Only missing attributes from M12N10 abstract
139     ## definition are added.
140 wakaba 1.54 sub FEATURE_XHTML10_REC () {
141     Whatpm::ContentChecker::FEATURE_STATUS_CR
142     }
143    
144 wakaba 1.61 ## NOTE: Diff from HTML4.
145     sub FEATURE_ISOHTML_PREPARATION () { ## Informative documentation
146     Whatpm::ContentChecker::FEATURE_STATUS_CR
147     }
148 wakaba 1.58
149 wakaba 1.49 ## NOTE: HTML4 status is based on its transitional and frameset DTDs (HTML
150     ## 4.01). Only missing attributes from XHTML10 are added.
151 wakaba 1.54 sub FEATURE_HTML4_REC_RESERVED () {
152     Whatpm::ContentChecker::FEATURE_STATUS_WD
153     }
154    
155     ## TODO: According to HTML4 definition, authors SHOULD use style sheets
156     ## rather than presentational attributes (deprecated or not deprecated).
157 wakaba 1.48
158 wakaba 1.61 ## NOTE: Diff from HTML4.
159     sub FEATURE_HTML32_REC_OBSOLETE () {
160     Whatpm::ContentChecker::FEATURE_STATUS_CR |
161     Whatpm::ContentChecker::FEATURE_DEPRECATED_SHOULD
162     ## NOTE: Lowercase normative "should".
163     }
164    
165     sub FEATURE_RFC2659 () { ## Experimental RFC
166     Whatpm::ContentChecker::FEATURE_STATUS_CR
167     }
168    
169     ## NOTE: HTML 2.x - diff from HTML 2.0 and not in newer versions.
170     sub FEATURE_HTML2X_RFC () { ## Proposed Standard, obsolete
171     Whatpm::ContentChecker::FEATURE_STATUS_CR
172     }
173    
174     ## NOTE: Diff from HTML 2.0.
175     sub FEATURE_RFC1942 () { ## Experimental RFC, obsolete
176     Whatpm::ContentChecker::FEATURE_STATUS_CR
177     }
178    
179     ## NOTE: Diff from HTML 3.2.
180     sub FEATURE_HTML20_RFC () { ## Proposed Standard, obsolete
181     Whatpm::ContentChecker::FEATURE_STATUS_CR
182     }
183 wakaba 1.58
184 wakaba 1.174 ## --- Content Model ---
185    
186 wakaba 1.29 ## December 2007 HTML5 Classification
187    
188     my $HTMLMetadataContent = {
189     $HTML_NS => {
190     title => 1, base => 1, link => 1, style => 1, script => 1, noscript => 1,
191 wakaba 1.118 'event-source' => 1, eventsource => 1,
192     command => 1, datatemplate => 1,
193 wakaba 1.29 ## NOTE: A |meta| with no |name| element is not allowed as
194     ## a metadata content other than |head| element.
195     meta => 1,
196     },
197     ## NOTE: RDF is mentioned in the HTML5 spec.
198     ## TODO: Other RDF elements?
199     q<http://www.w3.org/1999/02/22-rdf-syntax-ns#> => {RDF => 1},
200     };
201    
202 wakaba 1.72 my $HTMLFlowContent = {
203 wakaba 1.29 $HTML_NS => {
204     section => 1, nav => 1, article => 1, blockquote => 1, aside => 1,
205 wakaba 1.195 h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1, hgroup => 1,
206     header => 1,
207 wakaba 1.29 footer => 1, address => 1, p => 1, hr => 1, dialog => 1, pre => 1,
208 wakaba 1.207 ol => 1, ul => 1, dl => 1, menu => 1, figure => 1, table => 1,
209 wakaba 1.119 form => 1, fieldset => 1,
210 wakaba 1.72 details => 1, ## ISSUE: "Flow element" in spec.
211     datagrid => 1, ## ISSUE: "Flow element" in spec.
212 wakaba 1.29 datatemplate => 1,
213     div => 1, ## ISSUE: No category in spec.
214     ## NOTE: |style| is only allowed if |scoped| attribute is specified.
215     ## Additionally, it must be before any other element or
216     ## non-inter-element-whitespace text node.
217     style => 1,
218    
219 wakaba 1.193 ## These phrasing content are also categorized as flow content.
220 wakaba 1.38 br => 1, q => 1, cite => 1, em => 1, strong => 1, small => 1, mark => 1,
221 wakaba 1.29 dfn => 1, abbr => 1, time => 1, progress => 1, meter => 1, code => 1,
222     var => 1, samp => 1, kbd => 1, sub => 1, sup => 1, span => 1, i => 1,
223 wakaba 1.99 b => 1, bdo => 1, ruby => 1,
224 wakaba 1.118 script => 1, noscript => 1, 'event-source' => 1, eventsource => 1,
225     command => 1, bb => 1,
226 wakaba 1.119 input => 1, button => 1, label => 1, select => 1, datalist => 1,
227 wakaba 1.194 textarea => 1, keygen => 1, output => 1,
228     datagrid => 1,
229 wakaba 1.29 ## NOTE: |area| is allowed only as a descendant of |map|.
230     area => 1,
231 wakaba 1.193
232     ## Flow/phrasing content whose content model is transparent.
233 wakaba 1.196 a => 1, ins => 1, del => 1, font => 1, map => 1,
234 wakaba 1.29
235 wakaba 1.193 ## These embeded content are also categorized as flow content.
236 wakaba 1.29 img => 1, iframe => 1, embed => 1, object => 1, video => 1, audio => 1,
237     canvas => 1,
238     },
239    
240 wakaba 1.193 ## These embedded content are also categorized as flow content.
241 wakaba 1.29 q<http://www.w3.org/1998/Math/MathML> => {math => 1},
242     q<http://www.w3.org/2000/svg> => {svg => 1},
243 wakaba 1.193
244     ## And, non-inter-element-whitespace text nodes.
245     }; # $HTMLFlowContent
246 wakaba 1.29
247 wakaba 1.58 my $HTMLSectioningContent = {
248 wakaba 1.57 $HTML_NS => {
249     section => 1, nav => 1, article => 1, aside => 1,
250     },
251 wakaba 1.205 }; # $HTMLSectioningContent
252 wakaba 1.57
253 wakaba 1.58 my $HTMLSectioningRoot = {
254 wakaba 1.29 $HTML_NS => {
255 wakaba 1.58 blockquote => 1, datagrid => 1, figure => 1, td => 1,
256 wakaba 1.29 },
257     };
258    
259     my $HTMLHeadingContent = {
260     $HTML_NS => {
261 wakaba 1.195 h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1, hgroup => 1,
262 wakaba 1.29 },
263     };
264    
265     my $HTMLPhrasingContent = {
266 wakaba 1.72 ## NOTE: All phrasing content is also flow content.
267 wakaba 1.29 $HTML_NS => {
268 wakaba 1.38 br => 1, q => 1, cite => 1, em => 1, strong => 1, small => 1, mark => 1,
269 wakaba 1.29 dfn => 1, abbr => 1, time => 1, progress => 1, meter => 1, code => 1,
270     var => 1, samp => 1, kbd => 1, sub => 1, sup => 1, span => 1, i => 1,
271 wakaba 1.99 b => 1, bdo => 1, ruby => 1,
272 wakaba 1.118 script => 1, noscript => 1, 'event-source' => 1, eventsource => 1,
273     command => 1, bb => 1,
274 wakaba 1.119 input => 1, button => 1, label => 1, select => 1, datalist => 1,
275 wakaba 1.194 textarea => 1, keygen => 1, output => 1,
276     datagrid => 1,
277 wakaba 1.29 ## NOTE: |area| is allowed only as a descendant of |map|.
278     area => 1,
279    
280     ## NOTE: Transparent.
281 wakaba 1.196 a => 1, ins => 1, del => 1, font => 1, map => 1,
282 wakaba 1.29
283 wakaba 1.193 ## These embedded content is also categorized as phrasing content.
284 wakaba 1.29 img => 1, iframe => 1, embed => 1, object => 1, video => 1, audio => 1,
285     canvas => 1,
286     },
287    
288 wakaba 1.193 ## These embedded content is also categorized as phrasing content.
289 wakaba 1.29 q<http://www.w3.org/1998/Math/MathML> => {math => 1},
290     q<http://www.w3.org/2000/svg> => {svg => 1},
291    
292 wakaba 1.193 ## And, non-inter-element-whitespace text nodes.
293     }; # $HTMLPhrasingContent
294 wakaba 1.29
295 wakaba 1.40 ## $HTMLEmbeddedContent: See Whatpm::ContentChecker.
296 wakaba 1.29
297     my $HTMLInteractiveContent = {
298     $HTML_NS => {
299     a => 1,
300 wakaba 1.202 label => 1, button => 1, select => 1, textarea => 1,
301     keygen => 1, details => 1,
302     datagrid => 1, bb => 1, ## dropped
303     iframe => 1, embed => 1,
304    
305     ## NOTE: When the |usemap| attribute is specified.
306     img => 1, object => 1,
307    
308     ## NOTE: When "type=hidden" attribute is not specified.
309     input => 1,
310 wakaba 1.130
311     ## NOTE: When "controls" attribute is specified.
312     video => 1, audio => 1,
313    
314     ## NOTE: When "type=toolbar" attribute is specified.
315     menu => 1,
316 wakaba 1.29 },
317 wakaba 1.202 }; # $HTMLInteractiveContent
318 wakaba 1.29
319 wakaba 1.139 ## NOTE: Labelable form-associated element.
320     my $LabelableFAE = {
321     $HTML_NS => {
322 wakaba 1.194 input => 1, button => 1, select => 1, textarea => 1, keygen => 1,
323 wakaba 1.139 },
324     };
325    
326 wakaba 1.192 ## Check whether the labelable form-associated element is allowed to
327     ## place there or not and mark the element ID, if any, might be used
328     ## in the |for| attribute of a |label| element.
329     my $FAECheckStart = sub {
330     my ($self, $item, $element_state) = @_;
331    
332     $element_state->{id_type} = 'labelable';
333     }; # $FAECheckStart
334     my $FAECheckAttrs2 = sub {
335     my ($self, $item, $element_state) = @_;
336    
337     ## This must be done in "check_attrs2" phase since it requires the
338     ## |id| attribute of the element, if any, reflected to the
339     ## |$self->{id}| hash.
340    
341     CHK: {
342     if ($self->{flag}->{has_label} and $self->{flag}->{has_labelable}) {
343     my $for = $self->{flag}->{label_for};
344     if (defined $for) {
345     my $id_attrs = $self->{id}->{$for};
346     if ($id_attrs and $id_attrs->[0]) {
347     my $el = $id_attrs->[0]->owner_element;
348     if ($el and $el eq $item->{node}) {
349     ## Even if there is an ancestor |label| element with its
350     ## |for| attribute specified, the attribute value
351     ## identifies THIS element, then there is no problem.
352     last CHK;
353     }
354     }
355     }
356    
357     $self->{onerror}->(node => $item->{node},
358     type => 'multiple labelable fae',
359     level => $self->{level}->{must});
360     } else {
361     $self->{flag}->{has_labelable} = 2;
362     }
363     } # CHK
364     }; # $FAECheckAttrs2
365    
366 wakaba 1.130 our $IsInHTMLInteractiveContent; # See Whatpm::ContentChecker.
367    
368 wakaba 1.36 ## NOTE: $HTMLTransparentElements: See Whatpm::ContentChecker.
369     ## NOTE: Semi-transparent elements: See Whatpm::ContentChecker.
370    
371     ## -- Common attribute syntacx checkers
372    
373 wakaba 1.1 our $AttrChecker;
374 wakaba 1.82 our $AttrStatus;
375 wakaba 1.1
376     my $GetHTMLEnumeratedAttrChecker = sub {
377     my $states = shift; # {value => conforming ? 1 : -1}
378     return sub {
379     my ($self, $attr) = @_;
380     my $value = lc $attr->value; ## TODO: ASCII case insensitibility?
381     if ($states->{$value} > 0) {
382     #
383     } elsif ($states->{$value}) {
384 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'enumerated:non-conforming',
385     level => $self->{level}->{must});
386 wakaba 1.1 } else {
387 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'enumerated:invalid',
388     level => $self->{level}->{must});
389 wakaba 1.1 }
390     };
391     }; # $GetHTMLEnumeratedAttrChecker
392    
393     my $GetHTMLBooleanAttrChecker = sub {
394     my $local_name = shift;
395     return sub {
396     my ($self, $attr) = @_;
397 wakaba 1.88 my $value = lc $attr->value; ## TODO: case
398 wakaba 1.1 unless ($value eq $local_name or $value eq '') {
399 wakaba 1.88 $self->{onerror}->(node => $attr, type => 'boolean:invalid',
400 wakaba 1.104 level => $self->{level}->{must});
401 wakaba 1.1 }
402     };
403     }; # $GetHTMLBooleanAttrChecker
404    
405 wakaba 1.8 ## Unordered set of space-separated tokens
406 wakaba 1.92 my $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker = sub {
407     my $allowed_words = shift;
408     return sub {
409     my ($self, $attr) = @_;
410     my %word;
411 wakaba 1.132 for my $word (grep {length $_}
412     split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
413 wakaba 1.92 unless ($word{$word}) {
414     $word{$word} = 1;
415     if (not defined $allowed_words or
416     $allowed_words->{$word}) {
417     #
418     } else {
419 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'word not allowed',
420 wakaba 1.92 value => $word,
421 wakaba 1.104 level => $self->{level}->{must});
422 wakaba 1.92 }
423     } else {
424 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'duplicate token',
425     value => $word,
426     level => $self->{level}->{must});
427 wakaba 1.92 }
428 wakaba 1.8 }
429 wakaba 1.92 };
430     }; # $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker
431 wakaba 1.8
432 wakaba 1.132 ## |rel| attribute (set of space separated tokens,
433 wakaba 1.1 ## whose allowed values are defined by the section on link types)
434     my $HTMLLinkTypesAttrChecker = sub {
435 wakaba 1.66 my ($a_or_area, $todo, $self, $attr, $item, $element_state) = @_;
436 wakaba 1.1 my %word;
437 wakaba 1.132 for my $word (grep {length $_}
438     split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
439 wakaba 1.1 unless ($word{$word}) {
440     $word{$word} = 1;
441 wakaba 1.18 } elsif ($word eq 'up') {
442     #
443 wakaba 1.1 } else {
444 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'duplicate token',
445     value => $word,
446     level => $self->{level}->{must});
447 wakaba 1.1 }
448     }
449     ## NOTE: Case sensitive match (since HTML5 spec does not say link
450     ## types are case-insensitive and it says "The value should not
451     ## be confusingly similar to any other defined value (e.g.
452     ## differing only in case).").
453     ## NOTE: Though there is no explicit "MUST NOT" for undefined values,
454     ## "MAY"s and "only ... MAY" restrict non-standard non-registered
455     ## values to be used conformingly.
456 wakaba 1.66
457     my $is_hyperlink;
458     my $is_resource;
459 wakaba 1.1 require Whatpm::_LinkTypeList;
460     our $LinkType;
461     for my $word (keys %word) {
462     my $def = $LinkType->{$word};
463     if (defined $def) {
464     if ($def->{status} eq 'accepted') {
465     if (defined $def->{effect}->[$a_or_area]) {
466     #
467     } else {
468     $self->{onerror}->(node => $attr,
469 wakaba 1.104 type => 'link type:bad context',
470     value => $word,
471 wakaba 1.110 level => $self->{level}->{must});
472 wakaba 1.1 }
473     } elsif ($def->{status} eq 'proposal') {
474 wakaba 1.104 $self->{onerror}->(node => $attr,
475     type => 'link type:proposed',
476     value => $word,
477     level => $self->{level}->{should});
478 wakaba 1.20 if (defined $def->{effect}->[$a_or_area]) {
479     #
480     } else {
481     $self->{onerror}->(node => $attr,
482 wakaba 1.104 type => 'link type:bad context',
483     value => $word,
484     level => $self->{level}->{must});
485 wakaba 1.20 }
486 wakaba 1.1 } else { # rejected or synonym
487     $self->{onerror}->(node => $attr,
488 wakaba 1.104 type => 'link type:non-conforming',
489     value => $word,
490     level => $self->{level}->{must});
491 wakaba 1.1 }
492 wakaba 1.4 if (defined $def->{effect}->[$a_or_area]) {
493     if ($word eq 'alternate') {
494     #
495     } elsif ($def->{effect}->[$a_or_area] eq 'hyperlink') {
496 wakaba 1.66 $is_hyperlink = 1;
497 wakaba 1.4 }
498     }
499 wakaba 1.1 if ($def->{unique}) {
500     unless ($self->{has_link_type}->{$word}) {
501     $self->{has_link_type}->{$word} = 1;
502     } else {
503     $self->{onerror}->(node => $attr,
504 wakaba 1.104 type => 'link type:duplicate',
505     value => $word,
506     level => $self->{level}->{must});
507 wakaba 1.1 }
508     }
509 wakaba 1.66
510     if (defined $def->{effect}->[$a_or_area] and $word ne 'alternate') {
511     $is_hyperlink = 1 if $def->{effect}->[$a_or_area] eq 'hyperlink';
512     $is_resource = 1 if $def->{effect}->[$a_or_area] eq 'external resource';
513     }
514 wakaba 1.1 } else {
515 wakaba 1.104 $self->{onerror}->(node => $attr,
516     type => 'unknown link type',
517     value => $word,
518     level => $self->{level}->{uncertain});
519 wakaba 1.1 }
520     }
521 wakaba 1.66 $is_hyperlink = 1 if $word{alternate} and not $word{stylesheet};
522 wakaba 1.1 ## TODO: The Pingback 1.0 specification, which is referenced by HTML5,
523     ## says that using both X-Pingback: header field and HTML
524     ## <link rel=pingback> is deprecated and if both appears they
525     ## SHOULD contain exactly the same value.
526     ## ISSUE: Pingback 1.0 specification defines the exact representation
527     ## of its link element, which cannot be tested by the current arch.
528     ## ISSUE: Pingback 1.0 specification says that the document MUST NOT
529     ## include any string that matches to the pattern for the rel=pingback link,
530     ## which again inpossible to test.
531     ## ISSUE: rel=pingback href MUST NOT include entities other than predefined 4.
532 wakaba 1.12
533     ## NOTE: <link rel="up index"><link rel="up up index"> is not an error.
534 wakaba 1.17 ## NOTE: We can't check "If the page is part of multiple hierarchies,
535     ## then they SHOULD be described in different paragraphs.".
536 wakaba 1.66
537     $todo->{has_hyperlink_link_type} = 1 if $is_hyperlink;
538     if ($is_hyperlink or $a_or_area) {
539     $element_state->{uri_info}->{href}->{type}->{hyperlink} = 1;
540     }
541     if ($is_resource and not $a_or_area) {
542     $element_state->{uri_info}->{href}->{type}->{resource} = 1;
543     }
544 wakaba 1.96
545     $element_state->{link_rel} = \%word;
546 wakaba 1.1 }; # $HTMLLinkTypesAttrChecker
547 wakaba 1.20
548     ## TODO: "When an author uses a new type not defined by either this specification or the Wiki page, conformance checkers should offer to add the value to the Wiki, with the details described above, with the "proposal" status."
549 wakaba 1.1
550     ## URI (or IRI)
551     my $HTMLURIAttrChecker = sub {
552 wakaba 1.66 my ($self, $attr, $item, $element_state) = @_;
553 wakaba 1.1 ## ISSUE: Relative references are allowed? (RFC 3987 "IRI" is an absolute reference with optional fragment identifier.)
554     my $value = $attr->value;
555     Whatpm::URIChecker->check_iri_reference ($value, sub {
556 wakaba 1.104 $self->{onerror}->(@_, node => $attr);
557 wakaba 1.106 }), $self->{level};
558 wakaba 1.17 $self->{has_uri_attr} = 1; ## TODO: <html manifest>
559 wakaba 1.66
560     my $attr_name = $attr->name;
561     $element_state->{uri_info}->{$attr_name}->{node} = $attr;
562     ## TODO: absolute
563     push @{$self->{return}->{uri}->{$value} ||= []},
564     $element_state->{uri_info}->{$attr_name};
565 wakaba 1.1 }; # $HTMLURIAttrChecker
566    
567     ## A space separated list of one or more URIs (or IRIs)
568     my $HTMLSpaceURIsAttrChecker = sub {
569     my ($self, $attr) = @_;
570 wakaba 1.66
571     my $type = {ping => 'action',
572     profile => 'namespace',
573     archive => 'resource'}->{$attr->name};
574    
575 wakaba 1.1 my $i = 0;
576 wakaba 1.132 for my $value (split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
577 wakaba 1.1 Whatpm::URIChecker->check_iri_reference ($value, sub {
578 wakaba 1.104 $self->{onerror}->(value => $value, @_, node => $attr, index => $i);
579 wakaba 1.106 }, $self->{level});
580 wakaba 1.66
581     ## TODO: absolute
582     push @{$self->{return}->{uri}->{$value} ||= []},
583 wakaba 1.67 {node => $attr, type => {$type => 1}};
584 wakaba 1.66
585 wakaba 1.1 $i++;
586     }
587 wakaba 1.67 ## ISSUE: Relative references? (especially, in profile="")
588 wakaba 1.1 ## ISSUE: Leading or trailing white spaces are conformant?
589     ## ISSUE: A sequence of white space characters are conformant?
590     ## ISSUE: A zero-length string is conformant? (It does contain a relative reference, i.e. same as base URI.)
591 wakaba 1.132 ## ISSUE: What is "space"?
592 wakaba 1.1 ## NOTE: Duplication seems not an error.
593 wakaba 1.4 $self->{has_uri_attr} = 1;
594 wakaba 1.1 }; # $HTMLSpaceURIsAttrChecker
595    
596 wakaba 1.156 my $ValidEmailAddress;
597     {
598     my $atext = qr[[A-Za-z0-9!#\$%&'*+/=?^_`{|}~-]];
599 wakaba 1.200 my $dot_atom = qr/$atext+(?>\.$atext+)*/o;
600     $ValidEmailAddress = qr/$dot_atom\@$dot_atom/o;
601 wakaba 1.156 }
602    
603 wakaba 1.168 ## Valid global date and time.
604     my $GetDateTimeAttrChecker = sub ($) {
605     my $type = shift;
606     return sub {
607     my ($self, $attr, $item, $element_state) = @_;
608    
609     my $range_error;
610    
611     require Message::Date;
612     my $dp = Message::Date->new;
613     $dp->{level} = $self->{level};
614     $dp->{onerror} = sub {
615     my %opt = @_;
616     unless ($opt{type} eq 'date value not supported') {
617     $self->{onerror}->(%opt, node => $attr);
618     $range_error = '';
619     }
620     };
621    
622     my $method = 'parse_' . $type;
623     my $d = $dp->$method ($attr->value);
624     $element_state->{date_value}->{$attr->name} = $d || $range_error;
625     };
626     }; # $GetDateTimeAttrChecker
627 wakaba 1.1
628     my $HTMLIntegerAttrChecker = sub {
629     my ($self, $attr) = @_;
630     my $value = $attr->value;
631     unless ($value =~ /\A-?[0-9]+\z/) {
632 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'integer:syntax error',
633     level => $self->{level}->{must});
634 wakaba 1.1 }
635     }; # $HTMLIntegerAttrChecker
636    
637     my $GetHTMLNonNegativeIntegerAttrChecker = sub {
638     my $range_check = shift;
639     return sub {
640     my ($self, $attr) = @_;
641     my $value = $attr->value;
642     if ($value =~ /\A[0-9]+\z/) {
643     unless ($range_check->($value + 0)) {
644 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'nninteger:out of range',
645     level => $self->{level}->{must});
646 wakaba 1.1 }
647     } else {
648     $self->{onerror}->(node => $attr,
649 wakaba 1.104 type => 'nninteger:syntax error',
650     level => $self->{level}->{must});
651 wakaba 1.1 }
652     };
653     }; # $GetHTMLNonNegativeIntegerAttrChecker
654    
655 wakaba 1.203 ## "Valid floating point number".
656 wakaba 1.1 my $GetHTMLFloatingPointNumberAttrChecker = sub {
657     my $range_check = shift;
658     return sub {
659 wakaba 1.168 my ($self, $attr, $item, $element_state) = @_;
660 wakaba 1.1 my $value = $attr->value;
661 wakaba 1.203 if ($value =~ /
662     \A
663     (-?) # $1
664     ([0-9]+) # $2
665     (?>(\.[0-9]+))? # $3
666     (?>[Ee] ([+-]?[0-9]+) )? # $4
667     \z
668     /x) {
669     my $num = (defined $3 ? $2 . $3 : $2) + 0;
670     $num = -$num if $1;
671     $num *= 10 ** ($4 + 0) if $4; # $4 can be "-0", but no problem.
672     if ($range_check->($num)) {
673     $element_state->{number_value}->{$attr->name} = $num;
674 wakaba 1.168 } else {
675 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'float:out of range',
676     level => $self->{level}->{must});
677 wakaba 1.1 }
678     } else {
679     $self->{onerror}->(node => $attr,
680 wakaba 1.104 type => 'float:syntax error',
681     level => $self->{level}->{must});
682 wakaba 1.1 }
683     };
684 wakaba 1.203 }; # $GetHTMLFloatingPointNumberAttrChecker
685 wakaba 1.144
686 wakaba 1.203 my $PositiveFloatingPointNumberAttrChecker
687     = $GetHTMLFloatingPointNumberAttrChecker->(sub { $_[0] > 0 });
688 wakaba 1.1
689 wakaba 1.148 my $StepAttrChecker = sub {
690     ## NOTE: A valid floating point number (> 0), or ASCII
691     ## case-insensitive "any".
692    
693     my ($self, $attr) = @_;
694     my $value = $attr->value;
695 wakaba 1.203 if ($value =~ /\A[Aa][Nn][Yy]\z/) {
696 wakaba 1.148 #
697     } else {
698 wakaba 1.203 $PositiveFloatingPointNumberAttrChecker->(@_);
699 wakaba 1.148 }
700     }; # $StepAttrChecker
701    
702 wakaba 1.86 ## HTML4 %Length;
703     my $HTMLLengthAttrChecker = sub {
704     my ($self, $attr) = @_;
705     my $value = $attr->value;
706     unless ($value =~ /\A[0-9]+%?\z/) {
707     $self->{onerror}->(node => $attr, type => 'length:syntax error',
708 wakaba 1.104 level => $self->{level}->{must});
709 wakaba 1.86 }
710    
711     ## NOTE: HTML4 definition is too vague - it does not define the syntax
712     ## of percentage value at all (!).
713     }; # $HTMLLengthAttrChecker
714    
715 wakaba 1.161 my $MIMEToken = qr/[\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+/;
716     my $TypeOrSubtype = qr/[A-Za-z0-9!#\$&.+^_-]{1,127}/; # RFC 4288
717     my $IMTNoParameter = qr[($TypeOrSubtype)/($TypeOrSubtype)];
718    
719 wakaba 1.1 ## "A valid MIME type, optionally with parameters. [RFC 2046]"
720     ## ISSUE: RFC 2046 does not define syntax of media types.
721     ## ISSUE: The definition of "a valid MIME type" is unknown.
722     ## Syntactical correctness?
723     my $HTMLIMTAttrChecker = sub {
724     my ($self, $attr) = @_;
725     my $value = $attr->value;
726     ## ISSUE: RFC 2045 Content-Type header field allows insertion
727     ## of LWS/comments between tokens. Is it allowed in HTML? Maybe no.
728     ## ISSUE: RFC 2231 extension? Maybe no.
729     my $lws0 = qr/(?>(?>\x0D\x0A)?[\x09\x20])*/;
730     my $qs = qr/"(?>[\x00-\x0C\x0E-\x21\x23-\x5B\x5D-\x7E]|\x0D\x0A[\x09\x20]|\x5C[\x00-\x7F])*"/;
731 wakaba 1.161 if ($value =~ m#\A$lws0($MIMEToken)$lws0/$lws0($MIMEToken)$lws0((?>;$lws0$MIMEToken$lws0=$lws0(?>$MIMEToken|$qs)$lws0)*)\z#) {
732 wakaba 1.1 my @type = ($1, $2);
733     my $param = $3;
734 wakaba 1.161 while ($param =~ s/^;$lws0($MIMEToken)$lws0=$lws0(?>($MIMEToken)|($qs))$lws0//) {
735 wakaba 1.1 if (defined $2) {
736     push @type, $1 => $2;
737     } else {
738     my $n = $1;
739 wakaba 1.152 my $v = $3;
740 wakaba 1.1 $v =~ s/\\(.)/$1/gs;
741 wakaba 1.152 push @type, $n => substr ($v, 1, length ($v) - 2);
742 wakaba 1.1 }
743     }
744     require Whatpm::IMTChecker;
745 wakaba 1.109 my $ic = Whatpm::IMTChecker->new;
746     $ic->{level} = $self->{level};
747     $ic->check_imt (sub {
748 wakaba 1.104 $self->{onerror}->(@_, node => $attr);
749 wakaba 1.1 }, @type);
750     } else {
751 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'IMT:syntax error',
752     level => $self->{level}->{must});
753 wakaba 1.1 }
754     }; # $HTMLIMTAttrChecker
755    
756     my $HTMLLanguageTagAttrChecker = sub {
757 wakaba 1.7 ## NOTE: See also $AtomLanguageTagAttrChecker in Atom.pm.
758    
759 wakaba 1.1 my ($self, $attr) = @_;
760 wakaba 1.6 my $value = $attr->value;
761     require Whatpm::LangTag;
762     Whatpm::LangTag->check_rfc3066_language_tag ($value, sub {
763 wakaba 1.104 $self->{onerror}->(@_, node => $attr);
764 wakaba 1.106 }, $self->{level});
765 wakaba 1.1 ## ISSUE: RFC 4646 (3066bis)?
766 wakaba 1.6
767     ## TODO: testdata
768 wakaba 1.1 }; # $HTMLLanguageTagAttrChecker
769    
770     ## "A valid media query [MQ]"
771     my $HTMLMQAttrChecker = sub {
772     my ($self, $attr) = @_;
773 wakaba 1.104 $self->{onerror}->(node => $attr,
774     type => 'media query',
775     level => $self->{level}->{uncertain});
776 wakaba 1.1 ## ISSUE: What is "a valid media query"?
777     }; # $HTMLMQAttrChecker
778    
779     my $HTMLEventHandlerAttrChecker = sub {
780     my ($self, $attr) = @_;
781 wakaba 1.104 $self->{onerror}->(node => $attr,
782     type => 'event handler',
783     level => $self->{level}->{uncertain});
784 wakaba 1.1 ## TODO: MUST contain valid ECMAScript code matching the
785     ## ECMAScript |FunctionBody| production. [ECMA262]
786     ## ISSUE: MUST be ES3? E4X? ES4? JS1.x?
787     ## ISSUE: Automatic semicolon insertion does not apply?
788     ## ISSUE: Other script languages?
789     }; # $HTMLEventHandlerAttrChecker
790    
791 wakaba 1.136 my $HTMLFormAttrChecker = sub {
792     my ($self, $attr) = @_;
793    
794     ## NOTE: MUST be the ID of a |form| element.
795    
796     my $value = $attr->value;
797 wakaba 1.138 push @{$self->{idref}}, ['form', $value => $attr];
798 wakaba 1.136
799     ## ISSUE: <form id=""><input form=""> (empty ID)?
800     }; # $HTMLFormAttrChecker
801    
802 wakaba 1.158 my $ListAttrChecker = sub {
803     my ($self, $attr) = @_;
804    
805     ## NOTE: MUST be the ID of a |datalist| element.
806    
807     push @{$self->{idref}}, ['datalist', $attr->value, $attr];
808    
809     ## TODO: Warn violation to control-dependent restrictions. For
810     ## example, |<input type=url maxlength=10 list=a> <datalist
811     ## id=a><option value=nonurlandtoolong></datalist>| should be
812     ## warned.
813     }; # $ListAttrChecker
814    
815 wakaba 1.160 my $PatternAttrChecker = sub {
816     my ($self, $attr) = @_;
817     $self->{onsubdoc}->({s => $attr->value,
818     container_node => $attr,
819     media_type => 'text/x-regexp-js',
820     is_char_string => 1});
821 wakaba 1.161
822     ## ISSUE: "value must match the Pattern production of ECMA 262's
823     ## grammar" - no additional constraints (e.g. {n,m} then n>=m).
824    
825     ## TODO: Warn if @value does not match @pattern.
826 wakaba 1.160 }; # $PatternAttrChecker
827    
828 wakaba 1.161 my $AcceptAttrChecker = sub {
829     my ($self, $attr) = @_;
830    
831     my $value = $attr->value;
832     $value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
833 wakaba 1.200
834     ## A set of comma-separated tokens.
835 wakaba 1.161 my @value = length $value ? split /,/, $value, -1 : ('');
836 wakaba 1.200
837 wakaba 1.161 my %has_value;
838     for my $v (@value) {
839 wakaba 1.200 $v =~ s/^[\x09\x0A\x0C\x0D\x20]+//;
840     $v =~ s/[\x09\x0A\x0C\x0D\x20]+\z//;
841    
842 wakaba 1.161 if ($has_value{$v}) {
843     $self->{onerror}->(node => $attr,
844     type => 'duplicate token',
845     value => $v,
846     level => $self->{level}->{must});
847     next;
848     }
849     $has_value{$v} = 1;
850    
851     if ($v eq 'audio/*' or $v eq 'video/*' or $v eq 'image/*') {
852     #
853     } elsif ($v =~ m[\A$IMTNoParameter\z]) {
854     ## ISSUE: HTML5 references RFC 2046, but maybe HTML5 should
855     ## define its own syntax citing RFC 4288.
856    
857     ## NOTE: Parameters not allowed.
858     require Whatpm::IMTChecker;
859     my $ic = Whatpm::IMTChecker->new;
860     $ic->{level} = $self->{level};
861     $ic->check_imt (sub {
862     $self->{onerror}->(@_, node => $attr);
863     }, $1, $2);
864     } else {
865     $self->{onerror}->(node => $attr,
866     type => 'IMTnp:syntax error', ## TODOC: type
867     value => $v,
868     level => $self->{level}->{must});
869     }
870     }
871     }; # $AcceptAttrChecker
872    
873 wakaba 1.165 my $FormControlNameAttrChecker = sub {
874     my ($self, $attr) = @_;
875    
876     unless (length $attr->value) {
877     $self->{onerror}->(node => $attr,
878     type => 'empty control name', ## TODOC: type
879     level => $self->{level}->{must});
880     }
881    
882     ## NOTE: No uniqueness constraint.
883     }; # $FormControlNameAttrChecker
884    
885     my $AutofocusAttrChecker = sub {
886     my ($self, $attr) = @_;
887    
888     $GetHTMLBooleanAttrChecker->('autofocus')->(@_);
889    
890     if ($self->{has_autofocus}) {
891     $self->{onerror}->(node => $attr,
892     type => 'duplicate autofocus', ## TODOC: type
893     level => $self->{level}->{must});
894     }
895     $self->{has_autofocus} = 1;
896     }; # $AutofocusAttrChekcer
897    
898 wakaba 1.1 my $HTMLUsemapAttrChecker = sub {
899     my ($self, $attr) = @_;
900 wakaba 1.100 ## MUST be a valid hash-name reference to a |map| element.
901 wakaba 1.1 my $value = $attr->value;
902     if ($value =~ s/^#//) {
903 wakaba 1.100 ## NOTE: |usemap="#"| is conforming, though it identifies no |map| element
904     ## according to the "rules for parsing a hash-name reference" algorithm.
905     ## The document is non-conforming anyway, since |<map name="">| (empty
906     ## name) is non-conforming.
907 wakaba 1.1 push @{$self->{usemap}}, [$value => $attr];
908     } else {
909 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'hashref:syntax error',
910     level => $self->{level}->{must});
911 wakaba 1.1 }
912 wakaba 1.100 ## NOTE: Space characters in hash-name references are conforming.
913 wakaba 1.1 ## ISSUE: UA algorithm for matching is case-insensitive; IDs only different in cases should be reported
914     }; # $HTMLUsemapAttrChecker
915    
916 wakaba 1.76 ## Valid browsing context name
917     my $HTMLBrowsingContextNameAttrChecker = sub {
918     my ($self, $attr) = @_;
919     my $value = $attr->value;
920     if ($value =~ /^_/) {
921     $self->{onerror}->(node => $attr, type => 'window name:reserved',
922 wakaba 1.104 level => $self->{level}->{must},
923 wakaba 1.76 value => $value);
924     } elsif (length $value) {
925     #
926     } else {
927     $self->{onerror}->(node => $attr, type => 'window name:empty',
928 wakaba 1.104 level => $self->{level}->{must});
929 wakaba 1.76 }
930     }; # $HTMLBrowsingContextNameAttrChecker
931    
932     ## Valid browsing context name or keyword
933 wakaba 1.1 my $HTMLTargetAttrChecker = sub {
934     my ($self, $attr) = @_;
935     my $value = $attr->value;
936     if ($value =~ /^_/) {
937     $value = lc $value; ## ISSUE: ASCII case-insentitive?
938     unless ({
939 wakaba 1.76 _blank => 1,_self => 1, _parent => 1, _top => 1,
940 wakaba 1.1 }->{$value}) {
941     $self->{onerror}->(node => $attr,
942 wakaba 1.76 type => 'window name:reserved',
943 wakaba 1.104 level => $self->{level}->{must},
944 wakaba 1.76 value => $value);
945 wakaba 1.1 }
946 wakaba 1.76 } elsif (length $value) {
947     #
948 wakaba 1.1 } else {
949 wakaba 1.76 $self->{onerror}->(node => $attr, type => 'window name:empty',
950 wakaba 1.104 level => $self->{level}->{must});
951 wakaba 1.1 }
952     }; # $HTMLTargetAttrChecker
953    
954 wakaba 1.23 my $HTMLSelectorsAttrChecker = sub {
955     my ($self, $attr) = @_;
956    
957     ## ISSUE: Namespace resolution?
958    
959     my $value = $attr->value;
960    
961     require Whatpm::CSS::SelectorsParser;
962     my $p = Whatpm::CSS::SelectorsParser->new;
963     $p->{pseudo_class}->{$_} = 1 for qw/
964     active checked disabled empty enabled first-child first-of-type
965     focus hover indeterminate last-child last-of-type link only-child
966     only-of-type root target visited
967     lang nth-child nth-last-child nth-of-type nth-last-of-type not
968     -manakai-contains -manakai-current
969     /;
970    
971     $p->{pseudo_element}->{$_} = 1 for qw/
972     after before first-letter first-line
973     /;
974    
975 wakaba 1.104 $p->{level} = $self->{level};
976 wakaba 1.23 $p->{onerror} = sub {
977 wakaba 1.104 $self->{onerror}->(@_, node => $attr);
978 wakaba 1.23 };
979     $p->parse_string ($value);
980     }; # $HTMLSelectorsAttrChecker
981    
982 wakaba 1.129 my $HTMLCharsetChecker = sub ($$$;$) {
983     my ($charset_value, $self, $attr, $ascii_compat) = @_;
984    
985     ## NOTE: This code is used for |charset=""| attributes, |charset=|
986     ## portion of the |content=""| attributes, and |accept-charset=""|
987     ## attributes.
988 wakaba 1.91
989     ## NOTE: Though the case-sensitivility of |charset| attribute value
990     ## is not explicitly spelled in the HTML5 spec, the Character Set
991     ## registry of IANA, which is referenced from HTML5 spec, says that
992     ## charset name is case-insensitive.
993     $charset_value =~ tr/A-Z/a-z/; ## NOTE: ASCII Case-insensitive.
994    
995     require Message::Charset::Info;
996     my $charset = $Message::Charset::Info::IANACharset->{$charset_value};
997    
998     ## ISSUE: What is "valid character encoding name"? Syntactically valid?
999     ## Syntactically valid and registered? What about x-charset names?
1000     unless (Message::Charset::Info::is_syntactically_valid_iana_charset_name
1001     ($charset_value)) {
1002     $self->{onerror}->(node => $attr,
1003 wakaba 1.104 type => 'charset:syntax error',
1004     value => $charset_value,
1005     level => $self->{level}->{must});
1006 wakaba 1.91 }
1007    
1008     if ($charset) {
1009     ## ISSUE: What is "the preferred name for that encoding" (for a charset
1010     ## with no "preferred MIME name" label)?
1011     my $charset_status = $charset->{iana_names}->{$charset_value} || 0;
1012     if (($charset_status &
1013     Message::Charset::Info::PREFERRED_CHARSET_NAME ())
1014     != Message::Charset::Info::PREFERRED_CHARSET_NAME ()) {
1015     $self->{onerror}->(node => $attr,
1016 wakaba 1.104 type => 'charset:not preferred',
1017     value => $charset_value,
1018     level => $self->{level}->{must});
1019 wakaba 1.91 }
1020 wakaba 1.129
1021 wakaba 1.91 if (($charset_status &
1022     Message::Charset::Info::REGISTERED_CHARSET_NAME ())
1023     != Message::Charset::Info::REGISTERED_CHARSET_NAME ()) {
1024     if ($charset_value =~ /^x-/) {
1025     $self->{onerror}->(node => $attr,
1026 wakaba 1.104 type => 'charset:private',
1027     value => $charset_value,
1028     level => $self->{level}->{good});
1029 wakaba 1.91 } else {
1030     $self->{onerror}->(node => $attr,
1031 wakaba 1.104 type => 'charset:not registered',
1032     value => $charset_value,
1033     level => $self->{level}->{good});
1034 wakaba 1.91 }
1035     }
1036 wakaba 1.129
1037     if ($ascii_compat) {
1038     if ($charset->{category} &
1039     Message::Charset::Info::CHARSET_CATEGORY_ASCII_COMPAT ()) {
1040     #
1041     } else {
1042     $self->{onerror}->(node => $attr,
1043     type => 'charset:not ascii compat',
1044     value => $charset_value,
1045     level => $self->{level}->{must});
1046     }
1047     }
1048    
1049 wakaba 1.91 ## TODO: non-preferred-name error for following cases:
1050     } elsif ($charset_value =~ /^x-/) {
1051     $self->{onerror}->(node => $attr,
1052 wakaba 1.104 type => 'charset:private',
1053     value => $charset_value,
1054     level => $self->{level}->{good});
1055 wakaba 1.129
1056     ## NOTE: Whether this is an ASCII-compatible character encoding or
1057     ## not is unknown.
1058 wakaba 1.91 } else {
1059     $self->{onerror}->(node => $attr,
1060 wakaba 1.104 type => 'charset:not registered',
1061     value => $charset_value,
1062     level => $self->{level}->{good});
1063 wakaba 1.129
1064     ## NOTE: Whether this is an ASCII-compatible character encoding or
1065     ## not is unknown.
1066 wakaba 1.91 }
1067    
1068     return ($charset, $charset_value);
1069     }; # $HTMLCharsetChecker
1070    
1071 wakaba 1.129 ## NOTE: "An ordered set of space-separated tokens" where "each token
1072     ## MUST be the preferred name of an ASCII-compatible character
1073     ## encoding".
1074     my $HTMLCharsetsAttrChecker = sub {
1075     my ($self, $attr) = @_;
1076    
1077     ## ISSUE: "ordered set of space-separated tokens" is not defined.
1078    
1079 wakaba 1.132 my @value = grep {length $_} split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value;
1080 wakaba 1.129
1081 wakaba 1.176 ## XXX
1082 wakaba 1.129 ## ISSUE: Uniqueness is not enforced.
1083    
1084     for my $charset (@value) {
1085     $HTMLCharsetChecker->($charset, $self, $attr, 1);
1086     }
1087    
1088     ## ISSUE: Shift_JIS is ASCII-compatible? What about ISO-2022-JP?
1089     }; # $HTMLCharsetsAttrChecker
1090    
1091 wakaba 1.68 my $HTMLColorAttrChecker = sub {
1092     my ($self, $attr) = @_;
1093    
1094     ## NOTE: HTML4 "color" or |%Color;|
1095    
1096     my $value = $attr->value;
1097    
1098     if ($value !~ /\A(?>#[0-9A-F]+|black|silver|gray|white|maroon|red|purple|fuchsia|green|lime|olive|yellow|navy|blue|teal|aqua)\z/i) {
1099 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'color:syntax error',
1100 wakaba 1.105 level => $self->{level}->{html4_fact});
1101 wakaba 1.68 }
1102    
1103     ## TODO: HTML4 has some guideline on usage of color.
1104     }; # $HTMLColorAttrChecker
1105    
1106 wakaba 1.79 my $HTMLRefOrTemplateAttrChecker = sub {
1107     my ($self, $attr) = @_;
1108     $HTMLURIAttrChecker->(@_);
1109    
1110     my $attr_name = $attr->name;
1111    
1112     if ($attr_name eq 'ref') {
1113     unless ($attr->owner_element->has_attribute_ns (undef, 'template')) {
1114     $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1115 wakaba 1.104 level => $self->{level}->{must});
1116 wakaba 1.79 }
1117     }
1118 wakaba 1.155
1119     require Message::URL;
1120 wakaba 1.79 my $doc = $attr->owner_document;
1121     my $doc_uri = $doc->document_uri;
1122 wakaba 1.155 my $uri = Message::URL->new_abs ($attr->value, $doc_uri);
1123 wakaba 1.79 my $no_frag_uri = $uri->clone;
1124     $no_frag_uri->uri_fragment (undef);
1125     if ((defined $doc_uri and $doc_uri eq $no_frag_uri) or
1126     (not defined $doc_uri and $no_frag_uri eq '')) {
1127     my $fragid = $uri->uri_fragment;
1128     if (defined $fragid) {
1129     push @{$self->{$attr_name}}, [$fragid => $attr];
1130     } else {
1131     DOCEL: {
1132     last DOCEL unless $attr_name eq 'template';
1133    
1134     my $docel = $doc->document_element;
1135     if ($docel) {
1136     my $nsuri = $docel->namespace_uri;
1137     if (defined $nsuri and $nsuri eq $HTML_NS) {
1138     if ($docel->manakai_local_name eq 'datatemplate') {
1139     last DOCEL;
1140     }
1141     }
1142     }
1143    
1144     $self->{onerror}->(node => $attr, type => 'template:not template',
1145 wakaba 1.104 level => $self->{level}->{must});
1146 wakaba 1.79 } # DOCEL
1147     }
1148     } else {
1149 wakaba 1.208 ## An external document is referenced.
1150    
1151     ## NOTE: Maybe the same-policy restriction should be posed to the
1152     ## referenced document, but the spec did not define such
1153     ## requirements and the entire feature has already been dropped
1154     ## from the spec anyway.
1155    
1156     ## XXXresource:
1157     ## - The document MUST be an HTML or XML document.
1158     ## - If there is a fragment identifier, it MUST point a part of the doc.
1159     ## - If the attribute is |template|, the pointed part MUST be a
1160     ## |datatemplat| element.
1161     ## - If no fragment identifier is specified, the root element MUST be
1162     ## a |datatemplate| element when the attribute is |template|.
1163 wakaba 1.79 }
1164     }; # $HTMLRefOrTemplateAttrChecker
1165    
1166 wakaba 1.83 my $HTMLRepeatIndexAttrChecker = sub {
1167     my ($self, $attr) = @_;
1168    
1169     if (defined $attr->namespace_uri) {
1170     my $oe = $attr->owner_element;
1171     my $oe_nsuri = $oe->namespace_uri;
1172 wakaba 1.128 if (defined $oe_nsuri or $oe_nsuri eq $HTML_NS) { ## TODO: wrong?
1173 wakaba 1.83 $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1174 wakaba 1.104 level => $self->{level}->{must});
1175 wakaba 1.83 }
1176     }
1177    
1178     $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 })->(@_);
1179     }; # $HTMLRepeatIndexAttrChecker
1180    
1181 wakaba 1.179 my $PlaceholderAttrChecker = sub {
1182     my ($self, $attr) = @_;
1183     if ($attr->value =~ /[\x0D\x0A]/) {
1184     $self->{onerror}->(node => $attr,
1185     type => 'newline in value', ## TODOC: type
1186     level => $self->{level}->{must});
1187     }
1188     }; # $PlaceholderAttrChecker
1189    
1190 wakaba 1.1 my $HTMLAttrChecker = {
1191 wakaba 1.176 accesskey => sub {
1192     my ($self, $attr) = @_;
1193    
1194     ## "Ordered set of unique space-separated tokens"
1195    
1196     my %keys;
1197     my @keys = grep {length} split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value;
1198    
1199     for my $key (@keys) {
1200     unless ($keys{$key}) {
1201     $keys{$key} = 1;
1202     if (length $key != 1) {
1203     $self->{onerror}->(node => $attr, type => 'char:syntax error',
1204     value => $key,
1205     level => $self->{level}->{must});
1206     }
1207     } else {
1208     $self->{onerror}->(node => $attr, type => 'duplicate token',
1209     value => $key,
1210     level => $self->{level}->{must});
1211     }
1212     }
1213     }, # accesskey
1214    
1215 wakaba 1.58 ## TODO: aria-* ## TODO: svg:*/@aria-* [HTML5ROLE] -> [STATES]
1216 wakaba 1.1 id => sub {
1217 wakaba 1.135 my ($self, $attr, $item, $element_state) = @_;
1218 wakaba 1.1 my $value = $attr->value;
1219     if (length $value > 0) {
1220     if ($self->{id}->{$value}) {
1221 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'duplicate ID',
1222     level => $self->{level}->{must});
1223 wakaba 1.1 push @{$self->{id}->{$value}}, $attr;
1224     } else {
1225     $self->{id}->{$value} = [$attr];
1226 wakaba 1.135 $self->{id_type}->{$value} = $element_state->{id_type} || '';
1227 wakaba 1.1 }
1228 wakaba 1.132 if ($value =~ /[\x09\x0A\x0C\x0D\x20]/) {
1229 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'space in ID',
1230     level => $self->{level}->{must});
1231 wakaba 1.1 }
1232     } else {
1233     ## NOTE: MUST contain at least one character
1234 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'empty attribute value',
1235     level => $self->{level}->{must});
1236 wakaba 1.1 }
1237     },
1238     title => sub {}, ## NOTE: No conformance creteria
1239     lang => sub {
1240     my ($self, $attr) = @_;
1241 wakaba 1.6 my $value = $attr->value;
1242     if ($value eq '') {
1243     #
1244     } else {
1245     require Whatpm::LangTag;
1246     Whatpm::LangTag->check_rfc3066_language_tag ($value, sub {
1247 wakaba 1.104 $self->{onerror}->(@_, node => $attr);
1248 wakaba 1.106 }, $self->{level});
1249 wakaba 1.6 }
1250 wakaba 1.1 ## ISSUE: RFC 4646 (3066bis)?
1251 wakaba 1.6
1252     ## TODO: test data
1253 wakaba 1.111
1254     ## NOTE: Inconsistency between |lang| and |xml:lang| attributes are
1255     ## non-conforming. Such errors are detected by the checkers of
1256     ## |{}xml:lang| and |{xml}:lang| attributes.
1257 wakaba 1.1 },
1258     dir => $GetHTMLEnumeratedAttrChecker->({ltr => 1, rtl => 1}),
1259     class => sub {
1260     my ($self, $attr) = @_;
1261 wakaba 1.132
1262     ## NOTE: "Unordered set of unique space-separated tokens".
1263    
1264 wakaba 1.1 my %word;
1265 wakaba 1.132 for my $word (grep {length $_}
1266     split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
1267 wakaba 1.1 unless ($word{$word}) {
1268     $word{$word} = 1;
1269     push @{$self->{return}->{class}->{$word}||=[]}, $attr;
1270     } else {
1271 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'duplicate token',
1272     value => $word,
1273     level => $self->{level}->{must});
1274 wakaba 1.1 }
1275     }
1276     },
1277 wakaba 1.63 contenteditable => $GetHTMLEnumeratedAttrChecker->({
1278     true => 1, false => 1, '' => 1,
1279     }),
1280 wakaba 1.1 contextmenu => sub {
1281     my ($self, $attr) = @_;
1282     my $value = $attr->value;
1283 wakaba 1.138 push @{$self->{idref}}, ['menu', $value => $attr];
1284 wakaba 1.1 ## ISSUE: "The value must be the ID of a menu element in the DOM."
1285     ## What is "in the DOM"? A menu Element node that is not part
1286     ## of the Document tree is in the DOM? A menu Element node that
1287     ## belong to another Document tree is in the DOM?
1288     },
1289 wakaba 1.115 hidden => $GetHTMLBooleanAttrChecker->('hidden'),
1290 wakaba 1.60 irrelevant => $GetHTMLBooleanAttrChecker->('irrelevant'),
1291 wakaba 1.79 ref => $HTMLRefOrTemplateAttrChecker,
1292     registrationmark => sub {
1293     my ($self, $attr, $item, $element_state) = @_;
1294    
1295     ## NOTE: Any value is conforming.
1296    
1297     if ($self->{flag}->{in_rule}) {
1298     my $el = $attr->owner_element;
1299     my $ln = $el->manakai_local_name;
1300     if ($ln eq 'nest' or
1301     ($ln eq 'rule' and not $element_state->{in_rule_original})) {
1302     my $nsuri = $el->namespace_uri;
1303     if (defined $nsuri and $nsuri eq $HTML_NS) {
1304     $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1305 wakaba 1.104 level => $self->{level}->{must});
1306 wakaba 1.79 }
1307     }
1308     } else {
1309     $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1310 wakaba 1.104 level => $self->{level}->{must});
1311 wakaba 1.79 }
1312     },
1313 wakaba 1.80 repeat => sub {
1314     my ($self, $attr) = @_;
1315 wakaba 1.83
1316     if (defined $attr->namespace_uri) {
1317     my $oe = $attr->owner_element;
1318     my $oe_nsuri = $oe->namespace_uri;
1319     if (defined $oe_nsuri or $oe_nsuri eq $HTML_NS) {
1320     $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1321 wakaba 1.104 level => $self->{level}->{must});
1322 wakaba 1.83 }
1323     }
1324    
1325 wakaba 1.80 my $value = $attr->value;
1326     if ($value eq 'template') {
1327     #
1328     } elsif ($value =~ /\A-?[0-9]+\z/) {
1329     #
1330     } else {
1331     $self->{onerror}->(node => $attr, type => 'repeat:syntax error',
1332 wakaba 1.104 level => $self->{level}->{must});
1333 wakaba 1.80 }
1334    
1335 wakaba 1.208 ## NOTE: Where this attribute is allowed to set was not clearly
1336     ## defined in Web Forms 2.0. The spec said that "Repetition
1337     ## templates may occur anywhere", which might imply the attribute
1338     ## can be specified to any element, but its primary implication
1339     ## would be that the template can be appear in any hierarchy in
1340     ## the document structure. Anyway, the feature has been removed
1341     ## from the HTML5 spec.
1342 wakaba 1.80 },
1343 wakaba 1.83 'repeat-min' => $HTMLRepeatIndexAttrChecker,
1344     'repeat-max' => $HTMLRepeatIndexAttrChecker,
1345     'repeat-start' => $HTMLRepeatIndexAttrChecker,
1346 wakaba 1.80 'repeat-template' => sub {
1347 wakaba 1.83 my ($self, $attr) = @_;
1348    
1349     if (defined $attr->namespace_uri) {
1350     my $oe = $attr->owner_element;
1351     my $oe_nsuri = $oe->namespace_uri;
1352 wakaba 1.208 if (defined $oe_nsuri and $oe_nsuri eq $HTML_NS) {
1353 wakaba 1.83 $self->{onerror}->(node => $attr, type => 'attribute not allowed',
1354 wakaba 1.104 level => $self->{level}->{must});
1355 wakaba 1.83 }
1356     }
1357 wakaba 1.208
1358     ## NOTE: In the Web Forms 2.0 specification, this attribute had no
1359     ## author requirement. In addition, though the spec said that
1360     ## repetition blocks MAY have this attribute specified, it did not
1361     ## explicitly prohibit the attribute specified on an element that
1362     ## is not a repetition block. In anyway, the repetition template
1363     ## feature has been removed from the HTML5 specification.
1364 wakaba 1.80 },
1365 wakaba 1.58 ## TODO: role [HTML5ROLE] ## TODO: global @role [XHTML1ROLE]
1366 wakaba 1.184 spellcheck => $GetHTMLEnumeratedAttrChecker->({
1367     true => 1, false => 1, '' => 1,
1368     }),
1369 wakaba 1.128 style => sub {
1370     my ($self, $attr) = @_;
1371    
1372     $self->{onsubdoc}->({s => $attr->value,
1373     container_node => $attr,
1374     media_type => 'text/x-css-inline',
1375     is_char_string => 1});
1376    
1377     ## NOTE: "... MUST still be comprehensible and usable if those
1378     ## attributes were removed" is a semantic requirement, it cannot
1379     ## be tested.
1380     },
1381 wakaba 1.74 tabindex => $HTMLIntegerAttrChecker,
1382 wakaba 1.79 template => $HTMLRefOrTemplateAttrChecker,
1383 wakaba 1.208
1384     ## The |xml:lang| attribute in the null namespace, which is
1385     ## different from the |lang| attribute in the XML's namespace.
1386 wakaba 1.111 'xml:lang' => sub {
1387     my ($self, $attr) = @_;
1388    
1389     if ($attr->owner_document->manakai_is_html) {
1390     $self->{onerror}->(type => 'in HTML:xml:lang',
1391     level => $self->{level}->{info},
1392     node => $attr);
1393     ## NOTE: This is not an error, but the attribute will be ignored.
1394     } else {
1395     $self->{onerror}->(type => 'in XML:xml:lang',
1396     level => $self->{level}->{html5_no_may},
1397     node => $attr);
1398     ## TODO: We need to add test for this error.
1399     }
1400    
1401     my $lang_attr = $attr->owner_element->get_attribute_node_ns
1402     (undef, 'lang');
1403     if ($lang_attr) {
1404     my $lang_attr_value = $lang_attr->value;
1405     $lang_attr_value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
1406     my $value = $attr->value;
1407     $value =~ tr/A-Z/a-z/; ## ASCII case-insensitive
1408     if ($lang_attr_value ne $value) {
1409     $self->{onerror}->(type => 'xml:lang ne lang',
1410     level => $self->{level}->{must},
1411     node => $attr);
1412     }
1413     } else {
1414     $self->{onerror}->(type => 'xml:lang not allowed',
1415     level => $self->{level}->{must},
1416     node => $attr);
1417     ## TODO: We need to add test for <x {xml}:lang {}xml:lang>.
1418     }
1419     },
1420 wakaba 1.208
1421     ## The |xmlns| attribute in the null namespace, which is different
1422     ## from the |xmlns| attribute in the XMLNS namespace.
1423 wakaba 1.74 xmlns => sub {
1424     my ($self, $attr) = @_;
1425     my $value = $attr->value;
1426     unless ($value eq $HTML_NS) {
1427 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'invalid attribute value',
1428     level => $self->{level}->{must});
1429 wakaba 1.74 ## TODO: Should be new "bad namespace" error?
1430     }
1431     unless ($attr->owner_document->manakai_is_html) {
1432 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'in XML:xmlns',
1433     level => $self->{level}->{must});
1434 wakaba 1.74 ## TODO: Test
1435     }
1436    
1437     ## TODO: Should be resolved?
1438     push @{$self->{return}->{uri}->{$value} ||= []},
1439     {node => $attr, type => {namespace => 1}};
1440     },
1441 wakaba 1.1 };
1442    
1443 wakaba 1.49 my %HTMLAttrStatus = (
1444 wakaba 1.176 accesskey => FEATURE_HTML5_FD,
1445 wakaba 1.187 class => FEATURE_HTML5_LC,
1446     contenteditable => FEATURE_HTML5_REC,
1447 wakaba 1.50 contextmenu => FEATURE_HTML5_WD,
1448 wakaba 1.187 dir => FEATURE_HTML5_REC,
1449 wakaba 1.50 draggable => FEATURE_HTML5_LC,
1450 wakaba 1.187 hidden => FEATURE_HTML5_LC,
1451     id => FEATURE_HTML5_REC,
1452 wakaba 1.115 irrelevant => FEATURE_HTML5_DROPPED,
1453 wakaba 1.187 lang => FEATURE_HTML5_REC,
1454 wakaba 1.208 ref => FEATURE_HTML5_DROPPED,
1455     registrationmark => FEATURE_HTML5_DROPPED,
1456 wakaba 1.60 repeat => FEATURE_WF2,
1457     'repeat-max' => FEATURE_WF2,
1458     'repeat-min' => FEATURE_WF2,
1459     'repeat-start' => FEATURE_WF2,
1460     'repeat-template' => FEATURE_WF2,
1461 wakaba 1.154 role => 0,
1462 wakaba 1.184 spellcheck => FEATURE_HTML5_WD,
1463 wakaba 1.187 style => FEATURE_HTML5_REC,
1464 wakaba 1.50 tabindex => FEATURE_HTML5_DEFAULT,
1465 wakaba 1.208 template => FEATURE_HTML5_DROPPED,
1466 wakaba 1.187 title => FEATURE_HTML5_REC,
1467 wakaba 1.154 xmlns => FEATURE_HTML5_WD,
1468 wakaba 1.49 );
1469    
1470     my %HTMLM12NCommonAttrStatus = (
1471 wakaba 1.154 about => FEATURE_RDFA_REC,
1472 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
1473 wakaba 1.154 content => FEATURE_RDFA_REC,
1474     datatype => FEATURE_RDFA_REC,
1475 wakaba 1.187 dir => FEATURE_HTML5_REC,
1476 wakaba 1.154 href => FEATURE_RDFA_REC,
1477 wakaba 1.187 id => FEATURE_HTML5_REC,
1478 wakaba 1.154 instanceof => FEATURE_RDFA_LC_DROPPED,
1479 wakaba 1.50 onclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1480     ondblclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1481     onmousedown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1482     onmouseup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1483     onmouseover => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1484     onmousemove => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1485     onmouseout => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1486     onkeypress => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1487     onkeydown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1488     onkeyup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
1489 wakaba 1.154 property => FEATURE_RDFA_REC,
1490     rel => FEATURE_RDFA_REC,
1491     resource => FEATURE_RDFA_REC,
1492     rev => FEATURE_RDFA_REC,
1493 wakaba 1.153 #style => FEATURE_HTML5_WD | FEATURE_XHTMLBASIC11_CR_DEPRECATED |
1494 wakaba 1.78 # FEATURE_M12N10_REC,
1495 wakaba 1.187 style => FEATURE_HTML5_REC,
1496     title => FEATURE_HTML5_REC,
1497 wakaba 1.154 typeof => FEATURE_RDFA_REC,
1498 wakaba 1.49 );
1499    
1500 wakaba 1.82 my %XHTML2CommonAttrStatus = (
1501     ## Core
1502 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_XHTML2_ED,
1503     id => FEATURE_HTML5_REC,
1504 wakaba 1.82 #xml:id
1505     layout => FEATURE_XHTML2_ED,
1506 wakaba 1.187 title => FEATURE_HTML5_REC,
1507 wakaba 1.82
1508     ## Hypertext
1509     cite => FEATURE_XHTML2_ED,
1510     href => FEATURE_XHTML2_ED,
1511     hreflang => FEATURE_XHTML2_ED,
1512     hrefmedia => FEATURE_XHTML2_ED,
1513     hreftype => FEATURE_XHTML2_ED,
1514     nextfocus => FEATURE_XHTML2_ED,
1515     prevfocus => FEATURE_XHTML2_ED,
1516     target => FEATURE_XHTML2_ED,
1517     #xml:base
1518    
1519     ## I18N
1520     #xml:lang
1521    
1522     ## Bi-directional
1523 wakaba 1.187 dir => FEATURE_HTML5_REC,
1524 wakaba 1.82
1525     ## Edit
1526     edit => FEATURE_XHTML2_ED,
1527     datetime => FEATURE_XHTML2_ED,
1528    
1529     ## Embedding
1530     encoding => FEATURE_XHTML2_ED,
1531     src => FEATURE_XHTML2_ED,
1532     srctype => FEATURE_XHTML2_ED,
1533    
1534     ## Image Map
1535     usemap => FEATURE_XHTML2_ED,
1536     ismap => FEATURE_XHTML2_ED,
1537     shape => FEATURE_XHTML2_ED,
1538     coords => FEATURE_XHTML2_ED,
1539    
1540     ## Media
1541     media => FEATURE_XHTML2_ED,
1542    
1543     ## Metadata
1544     about => FEATURE_XHTML2_ED,
1545     content => FEATURE_XHTML2_ED,
1546     datatype => FEATURE_XHTML2_ED,
1547     instanceof => FEATURE_XHTML2_ED,
1548     property => FEATURE_XHTML2_ED,
1549     rel => FEATURE_XHTML2_ED,
1550     resource => FEATURE_XHTML2_ED,
1551     rev => FEATURE_XHTML2_ED,
1552    
1553     ## Role
1554 wakaba 1.154 role => FEATURE_XHTML2_ED,
1555 wakaba 1.82
1556     ## Style
1557 wakaba 1.187 style => FEATURE_HTML5_REC,
1558 wakaba 1.82 );
1559    
1560     my %HTMLM12NXHTML2CommonAttrStatus = (
1561     %HTMLM12NCommonAttrStatus,
1562     %XHTML2CommonAttrStatus,
1563    
1564 wakaba 1.154 about => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1565 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
1566 wakaba 1.154 content => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1567     datatype => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1568 wakaba 1.187 dir => FEATURE_HTML5_REC,
1569 wakaba 1.154 href => FEATURE_RDFA_REC,
1570 wakaba 1.187 id => FEATURE_HTML5_REC,
1571 wakaba 1.154 instanceof => FEATURE_RDFA_LC_DROPPED | FEATURE_XHTML2_ED,
1572     property => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1573     rel => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1574     resource => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1575     rev => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
1576 wakaba 1.153 #style => FEATURE_HTML5_WD | FEATURE_XHTMLBASIC11_CR_DEPRECATED |
1577 wakaba 1.82 # FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
1578 wakaba 1.187 style => FEATURE_HTML5_REC,
1579     title => FEATURE_HTML5_REC,
1580 wakaba 1.154 typeof => FEATURE_RDFA_REC,
1581 wakaba 1.82 );
1582    
1583 wakaba 1.1 for (qw/
1584 wakaba 1.188 onabort onblur onchange onclick oncontextmenu
1585 wakaba 1.1 ondblclick ondrag ondragend ondragenter ondragleave ondragover
1586     ondragstart ondrop onerror onfocus onkeydown onkeypress
1587 wakaba 1.180 onkeyup onload onmousedown onmousemove onmouseout
1588 wakaba 1.188 onmouseover onmouseup onmousewheel onscroll onselect
1589     onsubmit
1590 wakaba 1.1 /) {
1591     $HTMLAttrChecker->{$_} = $HTMLEventHandlerAttrChecker;
1592 wakaba 1.50 $HTMLAttrStatus{$_} = FEATURE_HTML5_DEFAULT;
1593 wakaba 1.1 }
1594    
1595 wakaba 1.170 for (qw/
1596 wakaba 1.188 onbeforeunload onhashchange onresize onstorage onunload
1597 wakaba 1.170 ondataunavailable
1598 wakaba 1.180 onmessage
1599 wakaba 1.170 /) {
1600     $HTMLAttrChecker->{$_} = $HTMLEventHandlerAttrChecker;
1601     $HTMLAttrStatus{$_} = FEATURE_HTML5_DROPPED;
1602     }
1603    
1604 wakaba 1.82 ## NOTE: Non-standard global attributes in the HTML namespace.
1605     $AttrChecker->{$HTML_NS}->{''} = sub {}; # no syntactical checks
1606     $AttrStatus->{$HTML_NS}->{''} = 0; # disallowed and not part of any standard
1607    
1608     $AttrStatus->{$HTML_NS}->{active} = FEATURE_HTML5_DROPPED;
1609     for (qw/repeat repeat-max repeat-min repeat-start repeat-template/) {
1610     $AttrChecker->{$HTML_NS}->{$_} = $HTMLAttrChecker->{$_};
1611     $AttrStatus->{$HTML_NS}->{$_} = FEATURE_WF2;
1612     }
1613    
1614 wakaba 1.120 for (qw/about content datatype property rel resource rev/) {
1615 wakaba 1.154 $AttrStatus->{$HTML_NS}->{$_} = FEATURE_RDFA_REC | FEATURE_XHTML2_ED;
1616 wakaba 1.82 }
1617 wakaba 1.154 $AttrStatus->{$HTML_NS}->{instanceof} = FEATURE_RDFA_LC_DROPPED | FEATURE_XHTML2_ED;
1618     $AttrStatus->{$HTML_NS}->{typeof} = FEATURE_RDFA_REC;
1619 wakaba 1.82 $AttrStatus->{$HTML_NS}->{role} = FEATURE_ROLE_LC;
1620     for (qw/cite coords datetime edit encoding href hreflang hrefmedia hreftype
1621     ismap layout media nextfocus prevfocus shape src srctype style
1622     target usemap/) {
1623     $AttrStatus->{$HTML_NS}->{$_} = FEATURE_XHTML2_ED;
1624     }
1625     for (qw/class dir id title/) {
1626     $AttrStatus->{$HTML_NS}->{$_} = FEATURE_M12N11_LC | FEATURE_XHTML2_ED;
1627     }
1628     for (qw/onclick ondblclick onmousedown onmouseup onmouseover onmousemove
1629     onmouseout onkeypress onkeydown onkeyup/) {
1630     $AttrStatus->{$HTML_NS}->{$_} = FEATURE_M12N11_LC;
1631     }
1632    
1633 wakaba 1.73 my $HTMLDatasetAttrChecker = sub {
1634     ## NOTE: "Authors should ... when the attributes are ignored and
1635     ## any associated CSS dropped, the page is still usable." (semantic
1636     ## constraint.)
1637     }; # $HTMLDatasetAttrChecker
1638    
1639 wakaba 1.187 my $HTMLDatasetAttrStatus = FEATURE_HTML5_LC;
1640 wakaba 1.73
1641 wakaba 1.1 my $GetHTMLAttrsChecker = sub {
1642     my $element_specific_checker = shift;
1643 wakaba 1.49 my $element_specific_status = shift;
1644 wakaba 1.1 return sub {
1645 wakaba 1.40 my ($self, $item, $element_state) = @_;
1646     for my $attr (@{$item->{node}->attributes}) {
1647 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
1648     $attr_ns = '' unless defined $attr_ns;
1649     my $attr_ln = $attr->manakai_local_name;
1650     my $checker;
1651 wakaba 1.73 my $status;
1652 wakaba 1.1 if ($attr_ns eq '') {
1653 wakaba 1.122 if ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
1654     $attr_ln !~ /[A-Z]/) {
1655 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
1656     $status = $HTMLDatasetAttrStatus;
1657     } else {
1658     $checker = $element_specific_checker->{$attr_ln}
1659     || $HTMLAttrChecker->{$attr_ln};
1660     $status = $element_specific_status->{$attr_ln};
1661     }
1662 wakaba 1.1 }
1663     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
1664 wakaba 1.40 || $AttrChecker->{$attr_ns}->{''};
1665 wakaba 1.82 $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
1666     || $AttrStatus->{$attr_ns}->{''};
1667     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
1668 wakaba 1.1 if ($checker) {
1669 wakaba 1.66 $checker->($self, $attr, $item, $element_state);
1670 wakaba 1.62 } elsif ($attr_ns eq '' and not $element_specific_status->{$attr_ln}) {
1671 wakaba 1.54 #
1672 wakaba 1.1 } else {
1673 wakaba 1.104 $self->{onerror}->(node => $attr,
1674     type => 'unknown attribute',
1675     level => $self->{level}->{uncertain});
1676 wakaba 1.49 ## ISSUE: No conformance createria for unknown attributes in the spec
1677     }
1678 wakaba 1.82 $self->_attr_status_info ($attr, $status);
1679 wakaba 1.1 }
1680     };
1681     }; # $GetHTMLAttrsChecker
1682    
1683 wakaba 1.40 my %HTMLChecker = (
1684     %Whatpm::ContentChecker::AnyChecker,
1685 wakaba 1.79 check_start => sub {
1686     my ($self, $item, $element_state) = @_;
1687    
1688     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
1689     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
1690     },
1691 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, \%HTMLAttrStatus),
1692 wakaba 1.40 );
1693    
1694     my %HTMLEmptyChecker = (
1695     %HTMLChecker,
1696     check_child_element => sub {
1697     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1698     $child_is_transparent, $element_state) = @_;
1699 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1700     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1701 wakaba 1.40 $self->{onerror}->(node => $child_el,
1702     type => 'element not allowed:minus',
1703 wakaba 1.104 level => $self->{level}->{must});
1704 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1705     #
1706     } else {
1707     $self->{onerror}->(node => $child_el,
1708     type => 'element not allowed:empty',
1709 wakaba 1.104 level => $self->{level}->{must});
1710 wakaba 1.40 }
1711     },
1712     check_child_text => sub {
1713     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
1714     if ($has_significant) {
1715     $self->{onerror}->(node => $child_node,
1716     type => 'character not allowed:empty',
1717 wakaba 1.104 level => $self->{level}->{must});
1718 wakaba 1.40 }
1719     },
1720     );
1721    
1722     my %HTMLTextChecker = (
1723     %HTMLChecker,
1724     check_child_element => sub {
1725     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1726     $child_is_transparent, $element_state) = @_;
1727 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1728     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1729 wakaba 1.40 $self->{onerror}->(node => $child_el,
1730     type => 'element not allowed:minus',
1731 wakaba 1.104 level => $self->{level}->{must});
1732 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1733     #
1734     } else {
1735 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed:text',
1736     level => $self->{level}->{must});
1737 wakaba 1.40 }
1738     },
1739     );
1740    
1741 wakaba 1.72 my %HTMLFlowContentChecker = (
1742 wakaba 1.40 %HTMLChecker,
1743     check_child_element => sub {
1744     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1745     $child_is_transparent, $element_state) = @_;
1746 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1747     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1748 wakaba 1.40 $self->{onerror}->(node => $child_el,
1749     type => 'element not allowed:minus',
1750 wakaba 1.104 level => $self->{level}->{must});
1751 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1752     #
1753     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'style') {
1754     if ($element_state->{has_non_style} or
1755     not $child_el->has_attribute_ns (undef, 'scoped')) {
1756 wakaba 1.104 $self->{onerror}->(node => $child_el,
1757 wakaba 1.72 type => 'element not allowed:flow style',
1758 wakaba 1.104 level => $self->{level}->{must});
1759 wakaba 1.40 }
1760 wakaba 1.72 } elsif ($HTMLFlowContent->{$child_nsuri}->{$child_ln}) {
1761 wakaba 1.43 $element_state->{has_non_style} = 1 unless $child_is_transparent;
1762 wakaba 1.40 } else {
1763     $element_state->{has_non_style} = 1;
1764 wakaba 1.104 $self->{onerror}->(node => $child_el,
1765 wakaba 1.72 type => 'element not allowed:flow',
1766 wakaba 1.104 level => $self->{level}->{must})
1767 wakaba 1.40 }
1768     },
1769     check_child_text => sub {
1770     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
1771     if ($has_significant) {
1772     $element_state->{has_non_style} = 1;
1773     }
1774     },
1775     check_end => sub {
1776     my ($self, $item, $element_state) = @_;
1777 wakaba 1.95 ## NOTE: A modified copy of the code below is in |datagrid| checker.
1778 wakaba 1.40 if ($element_state->{has_significant}) {
1779 wakaba 1.46 $item->{real_parent_state}->{has_significant} = 1;
1780 wakaba 1.40 } elsif ($item->{transparent}) {
1781     #
1782     } else {
1783     $self->{onerror}->(node => $item->{node},
1784 wakaba 1.104 level => $self->{level}->{should},
1785 wakaba 1.40 type => 'no significant content');
1786     }
1787     },
1788     );
1789    
1790     my %HTMLPhrasingContentChecker = (
1791     %HTMLChecker,
1792     check_child_element => sub {
1793     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1794     $child_is_transparent, $element_state) = @_;
1795 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1796     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1797 wakaba 1.40 $self->{onerror}->(node => $child_el,
1798     type => 'element not allowed:minus',
1799 wakaba 1.104 level => $self->{level}->{must});
1800 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1801     #
1802     } elsif ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
1803     #
1804     } else {
1805     $self->{onerror}->(node => $child_el,
1806     type => 'element not allowed:phrasing',
1807 wakaba 1.104 level => $self->{level}->{must});
1808 wakaba 1.40 }
1809     },
1810 wakaba 1.72 check_end => $HTMLFlowContentChecker{check_end},
1811 wakaba 1.40 ## NOTE: The definition for |li| assumes that the only differences
1812 wakaba 1.72 ## between flow and phrasing content checkers are |check_child_element|
1813 wakaba 1.40 ## and |check_child_text|.
1814     );
1815    
1816 wakaba 1.72 my %HTMLTransparentChecker = %HTMLFlowContentChecker;
1817 wakaba 1.40 ## ISSUE: Significant content rule should be applied to transparent element
1818 wakaba 1.46 ## with parent?
1819 wakaba 1.40
1820 wakaba 1.1 our $Element;
1821     our $ElementDefault;
1822    
1823     $Element->{$HTML_NS}->{''} = {
1824 wakaba 1.40 %HTMLChecker,
1825 wakaba 1.1 };
1826    
1827     $Element->{$HTML_NS}->{html} = {
1828 wakaba 1.187 status => FEATURE_HTML5_REC,
1829 wakaba 1.1 is_root => 1,
1830 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
1831 wakaba 1.16 manifest => $HTMLURIAttrChecker,
1832 wakaba 1.67 version => sub {
1833     ## NOTE: According to HTML4 prose, this is a "cdata" attribute.
1834     ## Though DTDs of various versions of HTML define the attribute
1835     ## as |#FIXED|, this conformance checker does no check for
1836     ## the attribute value, since what kind of check should be done
1837     ## is unknown.
1838     },
1839 wakaba 1.49 }, {
1840     %HTMLAttrStatus,
1841 wakaba 1.82 %XHTML2CommonAttrStatus,
1842 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_HTML2X_RFC,
1843     dir => FEATURE_HTML5_REC,
1844     id => FEATURE_HTML5_REC,
1845     lang => FEATURE_HTML5_REC,
1846 wakaba 1.153 manifest => FEATURE_HTML5_WD,
1847 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
1848 wakaba 1.82 version => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
1849 wakaba 1.1 }),
1850 wakaba 1.40 check_start => sub {
1851     my ($self, $item, $element_state) = @_;
1852     $element_state->{phase} = 'before head';
1853 wakaba 1.79
1854 wakaba 1.66 $element_state->{uri_info}->{manifest}->{type}->{resource} = 1;
1855 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
1856     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
1857 wakaba 1.40 },
1858     check_child_element => sub {
1859     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1860     $child_is_transparent, $element_state) = @_;
1861 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1862     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1863 wakaba 1.40 $self->{onerror}->(node => $child_el,
1864     type => 'element not allowed:minus',
1865 wakaba 1.104 level => $self->{level}->{must});
1866 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1867     #
1868     } elsif ($element_state->{phase} eq 'before head') {
1869     if ($child_nsuri eq $HTML_NS and $child_ln eq 'head') {
1870     $element_state->{phase} = 'after head';
1871     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'body') {
1872     $self->{onerror}->(node => $child_el,
1873 wakaba 1.104 type => 'ps element missing',
1874     text => 'head',
1875     level => $self->{level}->{must});
1876 wakaba 1.40 $element_state->{phase} = 'after body';
1877     } else {
1878     $self->{onerror}->(node => $child_el,
1879 wakaba 1.104 type => 'element not allowed',
1880     level => $self->{level}->{must});
1881 wakaba 1.40 }
1882     } elsif ($element_state->{phase} eq 'after head') {
1883     if ($child_nsuri eq $HTML_NS and $child_ln eq 'body') {
1884     $element_state->{phase} = 'after body';
1885     } else {
1886     $self->{onerror}->(node => $child_el,
1887 wakaba 1.104 type => 'element not allowed',
1888     level => $self->{level}->{must});
1889 wakaba 1.40 }
1890     } elsif ($element_state->{phase} eq 'after body') {
1891     $self->{onerror}->(node => $child_el,
1892 wakaba 1.104 type => 'element not allowed',
1893     level => $self->{level}->{must});
1894 wakaba 1.40 } else {
1895     die "check_child_element: Bad |html| phase: $element_state->{phase}";
1896     }
1897     },
1898     check_child_text => sub {
1899     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
1900     if ($has_significant) {
1901     $self->{onerror}->(node => $child_node,
1902 wakaba 1.104 type => 'character not allowed',
1903     level => $self->{level}->{must});
1904 wakaba 1.40 }
1905     },
1906     check_end => sub {
1907     my ($self, $item, $element_state) = @_;
1908     if ($element_state->{phase} eq 'after body') {
1909     #
1910     } elsif ($element_state->{phase} eq 'before head') {
1911     $self->{onerror}->(node => $item->{node},
1912 wakaba 1.104 type => 'child element missing',
1913     text => 'head',
1914     level => $self->{level}->{must});
1915 wakaba 1.40 $self->{onerror}->(node => $item->{node},
1916 wakaba 1.104 type => 'child element missing',
1917     text => 'body',
1918     level => $self->{level}->{must});
1919 wakaba 1.40 } elsif ($element_state->{phase} eq 'after head') {
1920     $self->{onerror}->(node => $item->{node},
1921 wakaba 1.104 type => 'child element missing',
1922     text => 'body',
1923     level => $self->{level}->{must});
1924 wakaba 1.40 } else {
1925     die "check_end: Bad |html| phase: $element_state->{phase}";
1926     }
1927 wakaba 1.1
1928 wakaba 1.40 $HTMLChecker{check_end}->(@_);
1929     },
1930     };
1931 wakaba 1.25
1932 wakaba 1.40 $Element->{$HTML_NS}->{head} = {
1933 wakaba 1.187 status => FEATURE_HTML5_REC,
1934 wakaba 1.67 check_attrs => $GetHTMLAttrsChecker->({
1935     profile => $HTMLSpaceURIsAttrChecker, ## NOTE: MUST be profile URIs.
1936     }, {
1937 wakaba 1.49 %HTMLAttrStatus,
1938 wakaba 1.82 %XHTML2CommonAttrStatus,
1939 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_HTML2X_RFC,
1940     dir => FEATURE_HTML5_REC,
1941     id => FEATURE_HTML5_REC,
1942     lang => FEATURE_HTML5_REC,
1943 wakaba 1.49 profile => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC,
1944     }),
1945 wakaba 1.40 check_child_element => sub {
1946     my ($self, $item, $child_el, $child_nsuri, $child_ln,
1947     $child_is_transparent, $element_state) = @_;
1948 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
1949     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
1950 wakaba 1.40 $self->{onerror}->(node => $child_el,
1951     type => 'element not allowed:minus',
1952 wakaba 1.104 level => $self->{level}->{must});
1953 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
1954     #
1955     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'title') {
1956     unless ($element_state->{has_title}) {
1957     $element_state->{has_title} = 1;
1958     } else {
1959     $self->{onerror}->(node => $child_el,
1960     type => 'element not allowed:head title',
1961 wakaba 1.104 level => $self->{level}->{must});
1962 wakaba 1.40 }
1963     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'style') {
1964     if ($child_el->has_attribute_ns (undef, 'scoped')) {
1965     $self->{onerror}->(node => $child_el,
1966     type => 'element not allowed:head style',
1967 wakaba 1.104 level => $self->{level}->{must});
1968 wakaba 1.1 }
1969 wakaba 1.40 } elsif ($HTMLMetadataContent->{$child_nsuri}->{$child_ln}) {
1970     #
1971    
1972     ## NOTE: |meta| is a metadata content. However, strictly speaking,
1973     ## a |meta| element with none of |charset|, |name|,
1974     ## or |http-equiv| attribute is not allowed. It is non-conforming
1975     ## anyway.
1976 wakaba 1.56
1977     ## TODO: |form| MUST be empty and in XML [WF2].
1978 wakaba 1.40 } else {
1979     $self->{onerror}->(node => $child_el,
1980     type => 'element not allowed:metadata',
1981 wakaba 1.104 level => $self->{level}->{must});
1982 wakaba 1.40 }
1983     $element_state->{in_head_original} = $self->{flag}->{in_head};
1984     $self->{flag}->{in_head} = 1;
1985     },
1986     check_child_text => sub {
1987     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
1988     if ($has_significant) {
1989 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
1990     level => $self->{level}->{must});
1991 wakaba 1.1 }
1992 wakaba 1.40 },
1993     check_end => sub {
1994     my ($self, $item, $element_state) = @_;
1995     unless ($element_state->{has_title}) {
1996     $self->{onerror}->(node => $item->{node},
1997 wakaba 1.104 type => 'child element missing',
1998     text => 'title',
1999 wakaba 1.105 level => $self->{level}->{must});
2000 wakaba 1.1 }
2001 wakaba 1.40 $self->{flag}->{in_head} = $element_state->{in_head_original};
2002 wakaba 1.1
2003 wakaba 1.40 $HTMLChecker{check_end}->(@_);
2004 wakaba 1.1 },
2005     };
2006    
2007 wakaba 1.40 $Element->{$HTML_NS}->{title} = {
2008     %HTMLTextChecker,
2009 wakaba 1.187 status => FEATURE_HTML5_REC,
2010 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
2011     %HTMLAttrStatus,
2012 wakaba 1.82 %XHTML2CommonAttrStatus,
2013 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_HTML2X_RFC,
2014     dir => FEATURE_HTML5_REC,
2015     id => FEATURE_HTML5_REC,
2016     lang => FEATURE_HTML5_REC,
2017 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
2018 wakaba 1.49 }),
2019 wakaba 1.40 };
2020 wakaba 1.1
2021 wakaba 1.40 $Element->{$HTML_NS}->{base} = {
2022 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
2023 wakaba 1.40 %HTMLEmptyChecker,
2024     check_attrs => sub {
2025     my ($self, $item, $element_state) = @_;
2026 wakaba 1.1
2027 wakaba 1.40 if ($self->{has_base}) {
2028     $self->{onerror}->(node => $item->{node},
2029 wakaba 1.104 type => 'element not allowed:base',
2030     level => $self->{level}->{must});
2031 wakaba 1.40 } else {
2032     $self->{has_base} = 1;
2033 wakaba 1.29 }
2034    
2035 wakaba 1.40 my $has_href = $item->{node}->has_attribute_ns (undef, 'href');
2036     my $has_target = $item->{node}->has_attribute_ns (undef, 'target');
2037 wakaba 1.14
2038     if ($self->{has_uri_attr} and $has_href) {
2039 wakaba 1.4 ## ISSUE: Are these examples conforming?
2040     ## <head profile="a b c"><base href> (except for |profile|'s
2041     ## non-conformance)
2042     ## <title xml:base="relative"/><base href/> (maybe it should be)
2043     ## <unknown xmlns="relative"/><base href/> (assuming that
2044     ## |{relative}:unknown| is allowed before XHTML |base| (unlikely, though))
2045     ## <style>@import 'relative';</style><base href>
2046     ## <script>location.href = 'relative';</script><base href>
2047 wakaba 1.14 ## NOTE: <html manifest=".."><head><base href=""/> is conforming as
2048     ## an exception.
2049 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2050 wakaba 1.104 type => 'basehref after URL attribute',
2051     level => $self->{level}->{must});
2052 wakaba 1.4 }
2053 wakaba 1.14 if ($self->{has_hyperlink_element} and $has_target) {
2054 wakaba 1.4 ## ISSUE: Are these examples conforming?
2055     ## <head><title xlink:href=""/><base target="name"/></head>
2056     ## <xbl:xbl>...<svg:a href=""/>...</xbl:xbl><base target="name"/>
2057     ## (assuming that |xbl:xbl| is allowed before |base|)
2058     ## NOTE: These are non-conformant anyway because of |head|'s content model:
2059     ## <link href=""/><base target="name"/>
2060     ## <link rel=unknown href=""><base target=name>
2061 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2062 wakaba 1.104 type => 'basetarget after hyperlink',
2063     level => $self->{level}->{must});
2064 wakaba 1.4 }
2065    
2066 wakaba 1.14 if (not $has_href and not $has_target) {
2067 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2068 wakaba 1.104 type => 'attribute missing:href|target',
2069     level => $self->{level}->{must});
2070 wakaba 1.14 }
2071    
2072 wakaba 1.66 $element_state->{uri_info}->{href}->{type}->{base} = 1;
2073    
2074 wakaba 1.4 return $GetHTMLAttrsChecker->({
2075     href => $HTMLURIAttrChecker,
2076     target => $HTMLTargetAttrChecker,
2077 wakaba 1.49 }, {
2078     %HTMLAttrStatus,
2079 wakaba 1.153 href => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
2080 wakaba 1.187 id => FEATURE_HTML5_REC,
2081 wakaba 1.153 target => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
2082 wakaba 1.40 })->($self, $item, $element_state);
2083 wakaba 1.4 },
2084 wakaba 1.1 };
2085    
2086     $Element->{$HTML_NS}->{link} = {
2087 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2088 wakaba 1.40 %HTMLEmptyChecker,
2089     check_attrs => sub {
2090     my ($self, $item, $element_state) = @_;
2091 wakaba 1.96 my $sizes_attr;
2092 wakaba 1.1 $GetHTMLAttrsChecker->({
2093 wakaba 1.91 charset => sub {
2094     my ($self, $attr) = @_;
2095     $HTMLCharsetChecker->($attr->value, @_);
2096     },
2097 wakaba 1.1 href => $HTMLURIAttrChecker,
2098 wakaba 1.40 rel => sub { $HTMLLinkTypesAttrChecker->(0, $item, @_) },
2099 wakaba 1.92 rev => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->(),
2100 wakaba 1.1 media => $HTMLMQAttrChecker,
2101     hreflang => $HTMLLanguageTagAttrChecker,
2102 wakaba 1.96 sizes => sub {
2103     my ($self, $attr) = @_;
2104     $sizes_attr = $attr;
2105     my %word;
2106     for my $word (grep {length $_}
2107 wakaba 1.132 split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
2108 wakaba 1.96 unless ($word{$word}) {
2109     $word{$word} = 1;
2110     if ($word eq 'any' or $word =~ /\A[1-9][0-9]*x[1-9][0-9]*\z/) {
2111     #
2112     } else {
2113     $self->{onerror}->(node => $attr,
2114 wakaba 1.104 type => 'sizes:syntax error',
2115 wakaba 1.96 value => $word,
2116 wakaba 1.104 level => $self->{level}->{must});
2117 wakaba 1.96 }
2118     } else {
2119     $self->{onerror}->(node => $attr, type => 'duplicate token',
2120     value => $word,
2121 wakaba 1.104 level => $self->{level}->{must});
2122 wakaba 1.96 }
2123     }
2124     },
2125 wakaba 1.70 target => $HTMLTargetAttrChecker,
2126 wakaba 1.1 type => $HTMLIMTAttrChecker,
2127     ## NOTE: Though |title| has special semantics,
2128     ## syntactically same as the |title| as global attribute.
2129 wakaba 1.49 }, {
2130     %HTMLAttrStatus,
2131 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2132 wakaba 1.91 charset => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC,
2133     ## NOTE: |charset| attribute had been part of HTML5 spec though
2134     ## it had been commented out.
2135 wakaba 1.154 href => FEATURE_HTML5_LC | FEATURE_RDFA_REC | FEATURE_XHTML2_ED |
2136 wakaba 1.82 FEATURE_M12N10_REC,
2137 wakaba 1.153 hreflang => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2138 wakaba 1.187 lang => FEATURE_HTML5_REC,
2139 wakaba 1.153 media => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2140 wakaba 1.61 methods => FEATURE_HTML20_RFC,
2141 wakaba 1.154 rel => FEATURE_HTML5_LC | FEATURE_RDFA_REC | FEATURE_XHTML2_ED |
2142 wakaba 1.153 FEATURE_M12N10_REC,
2143 wakaba 1.154 rev => FEATURE_RDFA_REC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2144 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
2145 wakaba 1.153 sizes => FEATURE_HTML5_LC,
2146 wakaba 1.82 target => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2147 wakaba 1.153 # title: HTML5_WD | HTML5_LC | ...
2148     type => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
2149 wakaba 1.61 urn => FEATURE_HTML20_RFC,
2150 wakaba 1.40 })->($self, $item, $element_state);
2151 wakaba 1.96
2152 wakaba 1.40 if ($item->{node}->has_attribute_ns (undef, 'href')) {
2153     $self->{has_hyperlink_element} = 1 if $item->{has_hyperlink_link_type};
2154 wakaba 1.4 } else {
2155 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2156 wakaba 1.104 type => 'attribute missing',
2157     text => 'href',
2158     level => $self->{level}->{must});
2159 wakaba 1.1 }
2160 wakaba 1.96
2161 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'rel')) {
2162     $self->{onerror}->(node => $item->{node},
2163 wakaba 1.104 type => 'attribute missing',
2164     text => 'rel',
2165     level => $self->{level}->{must});
2166 wakaba 1.96 }
2167    
2168     if ($sizes_attr and not $element_state->{link_rel}->{icon}) {
2169     $self->{onerror}->(node => $sizes_attr,
2170     type => 'attribute not allowed',
2171 wakaba 1.104 level => $self->{level}->{must});
2172 wakaba 1.1 }
2173 wakaba 1.116
2174     if ($element_state->{link_rel}->{alternate} and
2175     $element_state->{link_rel}->{stylesheet}) {
2176     my $title_attr = $item->{node}->get_attribute_node_ns (undef, 'title');
2177     unless ($title_attr) {
2178     $self->{onerror}->(node => $item->{node},
2179     type => 'attribute missing',
2180     text => 'title',
2181     level => $self->{level}->{must});
2182     } elsif ($title_attr->value eq '') {
2183     $self->{onerror}->(node => $title_attr,
2184     type => 'empty style sheet title',
2185     level => $self->{level}->{must});
2186     }
2187     }
2188 wakaba 1.1 },
2189     };
2190    
2191     $Element->{$HTML_NS}->{meta} = {
2192 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2193 wakaba 1.40 %HTMLEmptyChecker,
2194     check_attrs => sub {
2195     my ($self, $item, $element_state) = @_;
2196 wakaba 1.1 my $name_attr;
2197     my $http_equiv_attr;
2198     my $charset_attr;
2199     my $content_attr;
2200 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
2201 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
2202     $attr_ns = '' unless defined $attr_ns;
2203     my $attr_ln = $attr->manakai_local_name;
2204     my $checker;
2205 wakaba 1.73 my $status;
2206 wakaba 1.1 if ($attr_ns eq '') {
2207 wakaba 1.73 $status = {
2208     %HTMLAttrStatus,
2209 wakaba 1.82 %XHTML2CommonAttrStatus,
2210 wakaba 1.153 charset => FEATURE_HTML5_WD,
2211     content => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2212 wakaba 1.187 dir => FEATURE_HTML5_REC,
2213 wakaba 1.153 'http-equiv' => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
2214 wakaba 1.187 id => FEATURE_HTML5_REC,
2215     lang => FEATURE_HTML5_REC,
2216 wakaba 1.153 name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
2217 wakaba 1.73 scheme => FEATURE_M12N10_REC,
2218     }->{$attr_ln};
2219    
2220 wakaba 1.1 if ($attr_ln eq 'content') {
2221     $content_attr = $attr;
2222     $checker = 1;
2223     } elsif ($attr_ln eq 'name') {
2224     $name_attr = $attr;
2225     $checker = 1;
2226     } elsif ($attr_ln eq 'http-equiv') {
2227     $http_equiv_attr = $attr;
2228     $checker = 1;
2229     } elsif ($attr_ln eq 'charset') {
2230     $charset_attr = $attr;
2231     $checker = 1;
2232 wakaba 1.67 } elsif ($attr_ln eq 'scheme') {
2233 wakaba 1.71 ## NOTE: <http://suika.fam.cx/2007/html/standards#html-meta-scheme>
2234 wakaba 1.67 $checker = sub {};
2235 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
2236     $attr_ln !~ /[A-Z]/) {
2237 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
2238     $status = $HTMLDatasetAttrStatus;
2239 wakaba 1.1 } else {
2240     $checker = $HTMLAttrChecker->{$attr_ln}
2241 wakaba 1.67 || $AttrChecker->{$attr_ns}->{$attr_ln}
2242 wakaba 1.1 || $AttrChecker->{$attr_ns}->{''};
2243     }
2244     } else {
2245     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
2246 wakaba 1.82 || $AttrChecker->{$attr_ns}->{''};
2247     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
2248     || $AttrStatus->{$attr_ns}->{''};
2249     $status = FEATURE_ALLOWED if not defined $status;
2250 wakaba 1.1 }
2251 wakaba 1.62
2252 wakaba 1.1 if ($checker) {
2253 wakaba 1.66 $checker->($self, $attr, $item, $element_state) if ref $checker;
2254 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
2255 wakaba 1.54 #
2256 wakaba 1.1 } else {
2257 wakaba 1.104 $self->{onerror}->(node => $attr,
2258     type => 'unknown attribute',
2259     level => $self->{level}->{uncertain});
2260 wakaba 1.49 ## ISSUE: No conformance createria for unknown attributes in the spec
2261     }
2262    
2263 wakaba 1.82 $self->_attr_status_info ($attr, $status);
2264 wakaba 1.1 }
2265    
2266     if (defined $name_attr) {
2267     if (defined $http_equiv_attr) {
2268     $self->{onerror}->(node => $http_equiv_attr,
2269 wakaba 1.104 type => 'attribute not allowed',
2270     level => $self->{level}->{must});
2271 wakaba 1.1 } elsif (defined $charset_attr) {
2272     $self->{onerror}->(node => $charset_attr,
2273 wakaba 1.104 type => 'attribute not allowed',
2274     level => $self->{level}->{must});
2275 wakaba 1.1 }
2276     my $metadata_name = $name_attr->value;
2277     my $metadata_value;
2278     if (defined $content_attr) {
2279     $metadata_value = $content_attr->value;
2280     } else {
2281 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2282 wakaba 1.104 type => 'attribute missing',
2283     text => 'content',
2284     level => $self->{level}->{must});
2285 wakaba 1.1 $metadata_value = '';
2286     }
2287     } elsif (defined $http_equiv_attr) {
2288     if (defined $charset_attr) {
2289     $self->{onerror}->(node => $charset_attr,
2290 wakaba 1.104 type => 'attribute not allowed',
2291     level => $self->{level}->{must});
2292 wakaba 1.1 }
2293     unless (defined $content_attr) {
2294 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2295 wakaba 1.104 type => 'attribute missing',
2296     text => 'content',
2297     level => $self->{level}->{must});
2298 wakaba 1.1 }
2299     } elsif (defined $charset_attr) {
2300     if (defined $content_attr) {
2301     $self->{onerror}->(node => $content_attr,
2302 wakaba 1.104 type => 'attribute not allowed',
2303     level => $self->{level}->{must});
2304 wakaba 1.1 }
2305     } else {
2306     if (defined $content_attr) {
2307     $self->{onerror}->(node => $content_attr,
2308 wakaba 1.104 type => 'attribute not allowed',
2309     level => $self->{level}->{must});
2310 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2311 wakaba 1.104 type => 'attribute missing:name|http-equiv',
2312     level => $self->{level}->{must});
2313 wakaba 1.1 } else {
2314 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2315 wakaba 1.104 type => 'attribute missing:name|http-equiv|charset',
2316     level => $self->{level}->{must});
2317 wakaba 1.1 }
2318     }
2319    
2320 wakaba 1.32 my $check_charset_decl = sub () {
2321 wakaba 1.40 my $parent = $item->{node}->manakai_parent_element;
2322 wakaba 1.29 if ($parent and $parent eq $parent->owner_document->manakai_head) {
2323     for my $el (@{$parent->child_nodes}) {
2324     next unless $el->node_type == 1; # ELEMENT_NODE
2325 wakaba 1.40 unless ($el eq $item->{node}) {
2326 wakaba 1.29 ## NOTE: Not the first child element.
2327 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2328 wakaba 1.32 type => 'element not allowed:meta charset',
2329 wakaba 1.104 level => $self->{level}->{must});
2330 wakaba 1.29 }
2331     last;
2332     ## NOTE: Entity references are not supported.
2333     }
2334     } else {
2335 wakaba 1.40 $self->{onerror}->(node => $item->{node},
2336 wakaba 1.32 type => 'element not allowed:meta charset',
2337 wakaba 1.104 level => $self->{level}->{must});
2338 wakaba 1.29 }
2339 wakaba 1.32 }; # $check_charset_decl
2340 wakaba 1.21
2341 wakaba 1.32 my $check_charset = sub ($$) {
2342     my ($attr, $charset_value) = @_;
2343 wakaba 1.21
2344 wakaba 1.91 my $charset;
2345     ($charset, $charset_value)
2346     = $HTMLCharsetChecker->($charset_value, $self, $attr);
2347    
2348 wakaba 1.40 my $ic = $item->{node}->owner_document->input_encoding;
2349 wakaba 1.21 if (defined $ic) {
2350     ## TODO: Test for this case
2351     my $ic_charset = $Message::Charset::Info::IANACharset->{$ic};
2352     if ($charset ne $ic_charset) {
2353 wakaba 1.32 $self->{onerror}->(node => $attr,
2354 wakaba 1.104 type => 'mismatched charset name',
2355 wakaba 1.106 text => $ic,
2356 wakaba 1.104 value => $charset_value,
2357     level => $self->{level}->{must});
2358 wakaba 1.21 }
2359     } else {
2360     ## NOTE: MUST, but not checkable, since the document is not originally
2361     ## in serialized form (or the parser does not preserve the input
2362     ## encoding information).
2363 wakaba 1.32 $self->{onerror}->(node => $attr,
2364 wakaba 1.104 type => 'mismatched charset name not checked',
2365     value => $charset_value,
2366     level => $self->{level}->{uncertain});
2367 wakaba 1.21 }
2368    
2369 wakaba 1.32 if ($attr->get_user_data ('manakai_has_reference')) {
2370     $self->{onerror}->(node => $attr,
2371 wakaba 1.104 type => 'charref in charset',
2372     level => $self->{level}->{must},
2373     layer => 'syntax');
2374 wakaba 1.22 }
2375 wakaba 1.32 }; # $check_charset
2376    
2377     ## TODO: metadata conformance
2378    
2379 wakaba 1.204 ## -- The |http-equiv| attribute (pragmas)
2380 wakaba 1.32 if (defined $http_equiv_attr) { ## An enumerated attribute
2381 wakaba 1.204 my $keyword = $http_equiv_attr->value;
2382     $keyword =~ tr/A-Z/a-z/; ## ASCII case-insensitive.
2383 wakaba 1.33
2384 wakaba 1.85 if ($self->{has_http_equiv}->{$keyword}) {
2385     $self->{onerror}->(type => 'duplicate http-equiv', value => $keyword,
2386     node => $http_equiv_attr,
2387 wakaba 1.104 level => $self->{level}->{must});
2388 wakaba 1.85 } else {
2389     $self->{has_http_equiv}->{$keyword} = 1;
2390     }
2391    
2392     if ($keyword eq 'content-type') {
2393 wakaba 1.58 ## TODO: refs in "text/html; charset=" are not disallowed since rev.1275.
2394 wakaba 1.33
2395 wakaba 1.32 $check_charset_decl->();
2396 wakaba 1.182
2397     unless ($item->{node}->owner_document->manakai_is_html) {
2398     $self->{onerror}->(node => $item->{node},
2399     type => 'in XML:charset',
2400     level => $self->{level}->{must});
2401     }
2402    
2403 wakaba 1.32 if ($content_attr) {
2404     my $content = $content_attr->value;
2405 wakaba 1.58 if ($content =~ m!^[Tt][Ee][Xx][Tt]/[Hh][Tt][Mm][Ll];
2406 wakaba 1.132 [\x09\x0A\x0C\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
2407 wakaba 1.58 =(.+)\z!sx) {
2408 wakaba 1.32 $check_charset->($content_attr, $1);
2409     } else {
2410     $self->{onerror}->(node => $content_attr,
2411     type => 'meta content-type syntax error',
2412 wakaba 1.104 level => $self->{level}->{must});
2413 wakaba 1.85 }
2414     }
2415     } elsif ($keyword eq 'default-style') {
2416 wakaba 1.204 ## XXX no author requirement in the spec
2417    
2418 wakaba 1.85 } elsif ($keyword eq 'refresh') {
2419     if ($content_attr) {
2420     my $content = $content_attr->value;
2421     if ($content =~ /\A[0-9]+\z/) {
2422     ## NOTE: Valid non-negative integer.
2423     #
2424 wakaba 1.132 } elsif ($content =~ s/\A[0-9]+;[\x09\x0A\x0C\x0D\x20]+[Uu][Rr][Ll]=//) {
2425 wakaba 1.204 ## XXXURL
2426 wakaba 1.85 Whatpm::URIChecker->check_iri_reference ($content, sub {
2427 wakaba 1.104 $self->{onerror}->(value => $content, @_, node => $content_attr);
2428 wakaba 1.106 }, $self->{level});
2429 wakaba 1.204 $self->{has_uri_attr} = 1; ## NOTE: One of "attributes with URLs".
2430 wakaba 1.85
2431     $element_state->{uri_info}->{content}->{node} = $content_attr;
2432     $element_state->{uri_info}->{content}->{type}->{hyperlink} = 1;
2433 wakaba 1.204 ## XXXTODO: absolute
2434 wakaba 1.85 push @{$self->{return}->{uri}->{$content} ||= []},
2435     $element_state->{uri_info}->{content};
2436     } else {
2437     $self->{onerror}->(node => $content_attr,
2438     type => 'refresh:syntax error',
2439 wakaba 1.104 level => $self->{level}->{must});
2440 wakaba 1.32 }
2441     }
2442 wakaba 1.204 } elsif ($keyword eq 'content-language') {
2443     if ($content_attr) {
2444     my $content = $content_attr->value;
2445     require Whatpm::LangTag;
2446     ## XXX In fact what the spec requires is "BCP 47 langauge code".
2447     Whatpm::LangTag->check_rfc3066_language_tag ($content, sub {
2448     $self->{onerror}->(@_, node => $content_attr);
2449     }, $self->{level});
2450     }
2451    
2452     ## XXX This is conforming but obsolete.
2453 wakaba 1.32 } else {
2454 wakaba 1.204 ## NOTE: |Content-Style-Type| and |Content-Script-Type|
2455     ## pragmas are listed in the table of the spec in the
2456     ## commented-out form, but there is no author requirement
2457     ## (even commented-out one isn't there).
2458    
2459     ## NOTE: Pragma extensions are listed in
2460     ## <http://wiki.whatwg.org/wiki/PragmaExtensions>. At the
2461     ## time of writing, no extension has been registered yet.
2462    
2463 wakaba 1.32 $self->{onerror}->(node => $http_equiv_attr,
2464 wakaba 1.104 type => 'enumerated:invalid',
2465     level => $self->{level}->{must});
2466 wakaba 1.32 }
2467     }
2468    
2469     if (defined $charset_attr) {
2470 wakaba 1.182 my $value = $charset_attr->value;
2471    
2472 wakaba 1.32 $check_charset_decl->();
2473 wakaba 1.182 $check_charset->($charset_attr, $value);
2474    
2475     if (not $item->{node}->owner_document->manakai_is_html and
2476     not $value =~ /\A[Uu][Tt][Ff]-8\z/) {
2477     $self->{onerror}->(node => $item->{node},
2478     type => 'in XML:charset',
2479     level => $self->{level}->{must});
2480     }
2481 wakaba 1.1 }
2482     },
2483     };
2484    
2485     $Element->{$HTML_NS}->{style} = {
2486 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2487 wakaba 1.40 %HTMLChecker,
2488     check_attrs => $GetHTMLAttrsChecker->({
2489 wakaba 1.1 type => $HTMLIMTAttrChecker, ## TODO: MUST be a styling language
2490     media => $HTMLMQAttrChecker,
2491     scoped => $GetHTMLBooleanAttrChecker->('scoped'),
2492     ## NOTE: |title| has special semantics for |style|s, but is syntactically
2493     ## not different
2494 wakaba 1.49 }, {
2495     %HTMLAttrStatus,
2496 wakaba 1.82 %XHTML2CommonAttrStatus,
2497 wakaba 1.187 dir => FEATURE_HTML5_REC,
2498 wakaba 1.82 disabled => FEATURE_XHTML2_ED,
2499 wakaba 1.154 href => FEATURE_RDFA_REC | FEATURE_XHTML2_ED,
2500 wakaba 1.187 id => FEATURE_HTML5_REC,
2501     lang => FEATURE_HTML5_REC,
2502 wakaba 1.153 media => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2503     scoped => FEATURE_HTML5_FD,
2504 wakaba 1.187 title => FEATURE_HTML5_REC,
2505 wakaba 1.153 type => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2506 wakaba 1.1 }),
2507 wakaba 1.40 check_start => sub {
2508     my ($self, $item, $element_state) = @_;
2509    
2510 wakaba 1.27 ## NOTE: |html:style| itself has no conformance creteria on content model.
2511 wakaba 1.40 my $type = $item->{node}->get_attribute_ns (undef, 'type');
2512 wakaba 1.93 $type = 'text/css' unless defined $type;
2513     if ($type =~ m[\A(?>(?>\x0D\x0A)?[\x09\x20])*([\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+)(?>(?>\x0D\x0A)?[\x09\x20])*/(?>(?>\x0D\x0A)?[\x09\x20])*([\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+)(?>(?>\x0D\x0A)?[\x09\x20])*\z]) {
2514     $type = "$1/$2";
2515     $type =~ tr/A-Z/a-z/; ## NOTE: ASCII case-insensitive
2516     } else {
2517     ## NOTE: We don't know how parameters are handled by UAs. According to
2518     ## HTML5 specification, <style> with unknown parameters in |type=""|
2519     ## must be ignored.
2520     undef $type;
2521     }
2522     if (not defined $type) {
2523     $element_state->{allow_element} = 1; # invalid type=""
2524     } elsif ($type eq 'text/css') {
2525 wakaba 1.40 $element_state->{allow_element} = 0;
2526 wakaba 1.93 #} elsif ($type =~ m![/+][Xx][Mm][Ll]\z!) {
2527     # ## NOTE: There is no definition for "XML-based styling language" in HTML5
2528     # $element_state->{allow_element} = 1;
2529 wakaba 1.40 } else {
2530     $element_state->{allow_element} = 1; # unknown
2531     }
2532 wakaba 1.93 $element_state->{style_type} = $type;
2533 wakaba 1.79
2534     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2535     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2536 wakaba 1.107
2537     $element_state->{text} = '';
2538 wakaba 1.40 },
2539     check_child_element => sub {
2540     my ($self, $item, $child_el, $child_nsuri, $child_ln,
2541     $child_is_transparent, $element_state) = @_;
2542 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
2543     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
2544 wakaba 1.40 $self->{onerror}->(node => $child_el,
2545     type => 'element not allowed:minus',
2546 wakaba 1.104 level => $self->{level}->{must});
2547 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
2548     #
2549     } elsif ($element_state->{allow_element}) {
2550     #
2551     } else {
2552 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
2553     level => $self->{level}->{must});
2554 wakaba 1.40 }
2555     },
2556     check_child_text => sub {
2557     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
2558 wakaba 1.115 $element_state->{text} .= $child_node->data;
2559 wakaba 1.40 },
2560     check_end => sub {
2561     my ($self, $item, $element_state) = @_;
2562 wakaba 1.93 if (not defined $element_state->{style_type}) {
2563     ## NOTE: Invalid type=""
2564     #
2565     } elsif ($element_state->{style_type} eq 'text/css') {
2566 wakaba 1.40 $self->{onsubdoc}->({s => $element_state->{text},
2567     container_node => $item->{node},
2568 wakaba 1.28 media_type => 'text/css', is_char_string => 1});
2569 wakaba 1.93 } elsif ($element_state->{style_type} =~ m![+/][Xx][Mm][Ll]\z!) {
2570     ## NOTE: XML content should be checked by THIS instance of checker
2571     ## as part of normal tree validation. However, we don't know of any
2572     ## XML-based styling language that can be used in HTML <style> element,
2573     ## such that we throw a "style language not supported" error.
2574 wakaba 1.104 $self->{onerror}->(node => $item->{node},
2575     type => 'XML style lang',
2576     text => $element_state->{style_type},
2577     level => $self->{level}->{uncertain});
2578 wakaba 1.93 } else {
2579     ## NOTE: Should we raise some kind of error for,
2580     ## say, <style type="text/plaion">?
2581     $self->{onsubdoc}->({s => $element_state->{text},
2582     container_node => $item->{node},
2583     media_type => $element_state->{style_type},
2584     is_char_string => 1});
2585 wakaba 1.27 }
2586 wakaba 1.40
2587     $HTMLChecker{check_end}->(@_);
2588 wakaba 1.1 },
2589     };
2590 wakaba 1.25 ## ISSUE: Relationship to significant content check?
2591 wakaba 1.1
2592     $Element->{$HTML_NS}->{body} = {
2593 wakaba 1.72 %HTMLFlowContentChecker,
2594 wakaba 1.187 status => FEATURE_HTML5_REC,
2595 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
2596     alink => $HTMLColorAttrChecker,
2597     background => $HTMLURIAttrChecker,
2598     bgcolor => $HTMLColorAttrChecker,
2599     link => $HTMLColorAttrChecker,
2600 wakaba 1.188 onafterprint => $HTMLEventHandlerAttrChecker,
2601     onbeforeprint => $HTMLEventHandlerAttrChecker,
2602     onbeforeunload => $HTMLEventHandlerAttrChecker,
2603     onblur => $HTMLEventHandlerAttrChecker,
2604     onerror => $HTMLEventHandlerAttrChecker,
2605     onfocus => $HTMLEventHandlerAttrChecker,
2606     onhashchange => $HTMLEventHandlerAttrChecker,
2607     onload => $HTMLEventHandlerAttrChecker,
2608     onmessage => $HTMLEventHandlerAttrChecker,
2609     onoffline => $HTMLEventHandlerAttrChecker,
2610     ononline => $HTMLEventHandlerAttrChecker,
2611 wakaba 1.186 onpopstate => $HTMLEventHandlerAttrChecker,
2612 wakaba 1.188 onredo => $HTMLEventHandlerAttrChecker,
2613     onresize => $HTMLEventHandlerAttrChecker,
2614     onstorage => $HTMLEventHandlerAttrChecker,
2615     onundo => $HTMLEventHandlerAttrChecker,
2616     onunload => $HTMLEventHandlerAttrChecker,
2617 wakaba 1.68 text => $HTMLColorAttrChecker,
2618     vlink => $HTMLColorAttrChecker,
2619     }, {
2620 wakaba 1.49 %HTMLAttrStatus,
2621 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2622 wakaba 1.49 alink => FEATURE_M12N10_REC_DEPRECATED,
2623     background => FEATURE_M12N10_REC_DEPRECATED,
2624     bgcolor => FEATURE_M12N10_REC_DEPRECATED,
2625 wakaba 1.187 lang => FEATURE_HTML5_REC,
2626 wakaba 1.49 link => FEATURE_M12N10_REC_DEPRECATED,
2627 wakaba 1.188 onafterprint => FEATURE_HTML5_LC,
2628     onbeforeprint => FEATURE_HTML5_LC,
2629     onbeforeunload => FEATURE_HTML5_LC,
2630     onblur => FEATURE_HTML5_LC,
2631     onerror => FEATURE_HTML5_LC,
2632     onfocus => FEATURE_HTML5_LC,
2633     onhashchange => FEATURE_HTML5_LC,
2634     onload => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
2635     onmessage => FEATURE_HTML5_LC,
2636     onoffline => FEATURE_HTML5_LC,
2637     ononline => FEATURE_HTML5_LC,
2638 wakaba 1.186 onpopstate => FEATURE_HTML5_LC,
2639 wakaba 1.188 onredo => FEATURE_HTML5_LC,
2640     onresize => FEATURE_HTML5_LC,
2641     onstorage => FEATURE_HTML5_LC,
2642     onundo => FEATURE_HTML5_LC,
2643     onunload => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
2644 wakaba 1.49 text => FEATURE_M12N10_REC_DEPRECATED,
2645     vlink => FEATURE_M12N10_REC_DEPRECATED,
2646     }),
2647 wakaba 1.68 check_start => sub {
2648     my ($self, $item, $element_state) = @_;
2649    
2650     $element_state->{uri_info}->{background}->{type}->{embedded} = 1;
2651 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2652     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2653 wakaba 1.68 },
2654 wakaba 1.1 };
2655    
2656     $Element->{$HTML_NS}->{section} = {
2657 wakaba 1.72 %HTMLFlowContentChecker,
2658 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED,
2659 wakaba 1.82 check_attrs => $GetHTMLAttrsChecker->({
2660 wakaba 1.189 cite => $HTMLURIAttrChecker,
2661 wakaba 1.82 }, {
2662     %HTMLAttrStatus,
2663     %XHTML2CommonAttrStatus,
2664 wakaba 1.189 cite => FEATURE_HTML5_DROPPED | FEATURE_XHTML2_ED,
2665 wakaba 1.82 }),
2666 wakaba 1.1 };
2667    
2668     $Element->{$HTML_NS}->{nav} = {
2669 wakaba 1.153 status => FEATURE_HTML5_LC,
2670 wakaba 1.72 %HTMLFlowContentChecker,
2671 wakaba 1.1 };
2672    
2673     $Element->{$HTML_NS}->{article} = {
2674 wakaba 1.174 %HTMLFlowContentChecker,
2675 wakaba 1.153 status => FEATURE_HTML5_LC,
2676 wakaba 1.174 check_attrs => $GetHTMLAttrsChecker->({
2677 wakaba 1.189 cite => $HTMLURIAttrChecker,
2678 wakaba 1.174 pubdate => $GetDateTimeAttrChecker->('global_date_and_time_string'),
2679     }, {
2680     %HTMLAttrStatus,
2681 wakaba 1.189 cite => FEATURE_HTML5_DROPPED,
2682 wakaba 1.174 pubdate => FEATURE_HTML5_LC,
2683     }),
2684     }; # article
2685 wakaba 1.1
2686     $Element->{$HTML_NS}->{blockquote} = {
2687 wakaba 1.154 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2688 wakaba 1.72 %HTMLFlowContentChecker,
2689 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
2690 wakaba 1.1 cite => $HTMLURIAttrChecker,
2691 wakaba 1.49 }, {
2692     %HTMLAttrStatus,
2693 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2694 wakaba 1.61 align => FEATURE_HTML2X_RFC,
2695 wakaba 1.154 cite => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
2696 wakaba 1.187 lang => FEATURE_HTML5_REC,
2697 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
2698 wakaba 1.1 }),
2699 wakaba 1.66 check_start => sub {
2700     my ($self, $item, $element_state) = @_;
2701    
2702     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
2703 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2704     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2705 wakaba 1.66 },
2706 wakaba 1.1 };
2707    
2708     $Element->{$HTML_NS}->{aside} = {
2709 wakaba 1.153 status => FEATURE_HTML5_LC,
2710 wakaba 1.72 %HTMLFlowContentChecker,
2711 wakaba 1.1 };
2712    
2713     $Element->{$HTML_NS}->{h1} = {
2714 wakaba 1.40 %HTMLPhrasingContentChecker,
2715 wakaba 1.187 status => FEATURE_HTML5_REC,
2716 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
2717     align => $GetHTMLEnumeratedAttrChecker->({
2718     left => 1, center => 1, right => 1, justify => 1,
2719     }),
2720     }, {
2721 wakaba 1.49 %HTMLAttrStatus,
2722 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2723 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
2724 wakaba 1.187 lang => FEATURE_HTML5_REC,
2725 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
2726 wakaba 1.49 }),
2727 wakaba 1.40 check_start => sub {
2728     my ($self, $item, $element_state) = @_;
2729     $self->{flag}->{has_hn} = 1;
2730 wakaba 1.79
2731     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2732     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2733 wakaba 1.1 },
2734     };
2735    
2736 wakaba 1.40 $Element->{$HTML_NS}->{h2} = {%{$Element->{$HTML_NS}->{h1}}};
2737 wakaba 1.1
2738 wakaba 1.40 $Element->{$HTML_NS}->{h3} = {%{$Element->{$HTML_NS}->{h1}}};
2739 wakaba 1.1
2740 wakaba 1.40 $Element->{$HTML_NS}->{h4} = {%{$Element->{$HTML_NS}->{h1}}};
2741 wakaba 1.1
2742 wakaba 1.40 $Element->{$HTML_NS}->{h5} = {%{$Element->{$HTML_NS}->{h1}}};
2743 wakaba 1.1
2744 wakaba 1.40 $Element->{$HTML_NS}->{h6} = {%{$Element->{$HTML_NS}->{h1}}};
2745 wakaba 1.1
2746 wakaba 1.29 ## TODO: Explicit sectioning is "encouraged".
2747 wakaba 1.174
2748 wakaba 1.195 $Element->{$HTML_NS}->{hgroup} = {
2749     %HTMLChecker,
2750     status => FEATURE_HTML5_LC,
2751     check_child_element => sub {
2752     my ($self, $item, $child_el, $child_nsuri, $child_ln,
2753     $child_is_transparent, $element_state, $element_state2) = @_;
2754     if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
2755     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
2756     $self->{onerror}->(node => $child_el,
2757     type => 'element not allowed:minus',
2758     level => $self->{level}->{must});
2759     if ($child_nsuri eq $HTML_NS and $child_ln =~ /\Ah[1-6]\z/) {
2760     $element_state2->{has_hn} = 1;
2761     }
2762     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
2763     #
2764     } elsif ($child_nsuri eq $HTML_NS and $child_ln =~ /\Ah[1-6]\z/) {
2765     ## NOTE: Use $element_state2 instead of $element_state here so
2766     ## that the |h2| element in |<hgroup><ins><h2>| is not counted
2767     ## as an |h2| of the |hgroup| element.
2768     $element_state2->{has_hn} = 1;
2769     } else {
2770     $self->{onerror}->(node => $child_el, type => 'element not allowed',
2771     level => $self->{level}->{must});
2772     }
2773     }, # check_child_element
2774     check_child_text => sub {
2775     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
2776     if ($has_significant) {
2777     $self->{onerror}->(node => $child_node, type => 'character not allowed',
2778     level => $self->{level}->{must});
2779     }
2780     }, # check_child_text
2781     check_end => sub {
2782     my ($self, $item, $element_state) = @_;
2783     unless ($element_state->{has_hn}) {
2784     $self->{onerror}->(node => $item->{node},
2785     type => 'element missing:hn',
2786     level => $self->{level}->{must});
2787     }
2788    
2789     $HTMLChecker{check_end}->(@_);
2790     }, # check_end
2791     }; # hgroup
2792 wakaba 1.29
2793 wakaba 1.1 $Element->{$HTML_NS}->{header} = {
2794 wakaba 1.195 %HTMLFlowContentChecker,
2795 wakaba 1.153 status => FEATURE_HTML5_LC,
2796 wakaba 1.40 check_start => sub {
2797     my ($self, $item, $element_state) = @_;
2798     $self->_add_minus_elements ($element_state,
2799 wakaba 1.195 {$HTML_NS => {qw/header 1 footer 1/}});
2800 wakaba 1.40 $element_state->{has_hn_original} = $self->{flag}->{has_hn};
2801     $self->{flag}->{has_hn} = 0;
2802 wakaba 1.79
2803     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2804     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2805 wakaba 1.195 }, # check_start
2806 wakaba 1.40 check_end => sub {
2807     my ($self, $item, $element_state) = @_;
2808     $self->_remove_minus_elements ($element_state);
2809     unless ($self->{flag}->{has_hn}) {
2810     $self->{onerror}->(node => $item->{node},
2811 wakaba 1.104 type => 'element missing:hn',
2812 wakaba 1.195 level => $self->{level}->{warn});
2813 wakaba 1.40 }
2814     $self->{flag}->{has_hn} ||= $element_state->{has_hn_original};
2815 wakaba 1.1
2816 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
2817 wakaba 1.195 }, # check_end
2818     }; # header
2819 wakaba 1.1
2820     $Element->{$HTML_NS}->{footer} = {
2821 wakaba 1.153 status => FEATURE_HTML5_LC,
2822 wakaba 1.72 %HTMLFlowContentChecker,
2823 wakaba 1.40 check_start => sub {
2824     my ($self, $item, $element_state) = @_;
2825     $self->_add_minus_elements ($element_state,
2826 wakaba 1.177 {$HTML_NS => {header => 1, footer => 1}},
2827 wakaba 1.58 $HTMLSectioningContent,
2828 wakaba 1.57 $HTMLHeadingContent);
2829 wakaba 1.79
2830     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2831     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2832 wakaba 1.40 },
2833     check_end => sub {
2834     my ($self, $item, $element_state) = @_;
2835     $self->_remove_minus_elements ($element_state);
2836 wakaba 1.1
2837 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
2838 wakaba 1.1 },
2839     };
2840    
2841     $Element->{$HTML_NS}->{address} = {
2842 wakaba 1.72 %HTMLFlowContentChecker,
2843 wakaba 1.187 status => FEATURE_HTML5_REC,
2844 wakaba 1.110 check_attrs => $GetHTMLAttrsChecker->({
2845     ## TODO: add test
2846     #align => $GetHTMLEnumeratedAttrChecker->({
2847     # left => 1, center => 1, right => 1, justify => 1,
2848     #}),
2849     }, {
2850 wakaba 1.49 %HTMLAttrStatus,
2851 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2852 wakaba 1.61 align => FEATURE_HTML2X_RFC,
2853 wakaba 1.187 lang => FEATURE_HTML5_REC,
2854 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
2855     sdapref => FEATURE_HTML20_RFC,
2856 wakaba 1.49 }),
2857 wakaba 1.40 check_start => sub {
2858     my ($self, $item, $element_state) = @_;
2859 wakaba 1.177 $self->_add_minus_elements
2860     ($element_state,
2861     {$HTML_NS => {header => 1, footer => 1, address => 1}},
2862     $HTMLSectioningContent, $HTMLHeadingContent);
2863 wakaba 1.79
2864     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2865     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2866 wakaba 1.40 },
2867     check_end => sub {
2868     my ($self, $item, $element_state) = @_;
2869     $self->_remove_minus_elements ($element_state);
2870 wakaba 1.29
2871 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
2872 wakaba 1.29 },
2873 wakaba 1.1 };
2874    
2875     $Element->{$HTML_NS}->{p} = {
2876 wakaba 1.40 %HTMLPhrasingContentChecker,
2877 wakaba 1.187 status => FEATURE_HTML5_REC,
2878 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
2879     align => $GetHTMLEnumeratedAttrChecker->({
2880     left => 1, center => 1, right => 1, justify => 1,
2881     }),
2882     }, {
2883 wakaba 1.49 %HTMLAttrStatus,
2884 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
2885 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
2886 wakaba 1.187 lang => FEATURE_HTML5_REC,
2887 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
2888 wakaba 1.49 }),
2889 wakaba 1.1 };
2890    
2891     $Element->{$HTML_NS}->{hr} = {
2892 wakaba 1.40 %HTMLEmptyChecker,
2893 wakaba 1.187 status => FEATURE_HTML5_REC,
2894 wakaba 1.70 check_attrs => $GetHTMLAttrsChecker->({
2895     ## TODO: HTML4 |align|, |noshade|, |size|, |width|
2896     }, {
2897 wakaba 1.49 %HTMLAttrStatus,
2898     %HTMLM12NCommonAttrStatus,
2899     align => FEATURE_M12N10_REC_DEPRECATED,
2900 wakaba 1.187 lang => FEATURE_HTML5_REC,
2901 wakaba 1.49 noshade => FEATURE_M12N10_REC_DEPRECATED,
2902 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
2903 wakaba 1.49 size => FEATURE_M12N10_REC_DEPRECATED,
2904     width => FEATURE_M12N10_REC_DEPRECATED,
2905     }),
2906 wakaba 1.1 };
2907    
2908     $Element->{$HTML_NS}->{br} = {
2909 wakaba 1.40 %HTMLEmptyChecker,
2910 wakaba 1.187 status => FEATURE_HTML5_REC,
2911 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
2912     clear => $GetHTMLEnumeratedAttrChecker->({
2913     left => 1, all => 1, right => 1, none => 1,
2914     }),
2915     }, {
2916 wakaba 1.49 %HTMLAttrStatus,
2917 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
2918 wakaba 1.49 clear => FEATURE_M12N10_REC_DEPRECATED,
2919 wakaba 1.187 id => FEATURE_HTML5_REC,
2920 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
2921 wakaba 1.187 style => FEATURE_HTML5_REC,
2922     title => FEATURE_HTML5_REC,
2923 wakaba 1.49 }),
2924 wakaba 1.29 ## NOTE: Blank line MUST NOT be used for presentation purpose.
2925     ## (This requirement is semantic so that we cannot check.)
2926 wakaba 1.1 };
2927    
2928     $Element->{$HTML_NS}->{dialog} = {
2929 wakaba 1.153 status => FEATURE_HTML5_WD,
2930 wakaba 1.40 %HTMLChecker,
2931     check_start => sub {
2932     my ($self, $item, $element_state) = @_;
2933     $element_state->{phase} = 'before dt';
2934 wakaba 1.79
2935     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
2936     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
2937 wakaba 1.40 },
2938     check_child_element => sub {
2939     my ($self, $item, $child_el, $child_nsuri, $child_ln,
2940     $child_is_transparent, $element_state) = @_;
2941 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
2942     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
2943 wakaba 1.40 $self->{onerror}->(node => $child_el,
2944     type => 'element not allowed:minus',
2945 wakaba 1.104 level => $self->{level}->{must});
2946 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
2947     #
2948     } elsif ($element_state->{phase} eq 'before dt') {
2949     if ($child_nsuri eq $HTML_NS and $child_ln eq 'dt') {
2950     $element_state->{phase} = 'before dd';
2951     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'dd') {
2952     $self->{onerror}
2953 wakaba 1.104 ->(node => $child_el, type => 'ps element missing',
2954     text => 'dt',
2955     level => $self->{level}->{must});
2956 wakaba 1.40 $element_state->{phase} = 'before dt';
2957     } else {
2958 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
2959     level => $self->{level}->{must});
2960 wakaba 1.40 }
2961     } elsif ($element_state->{phase} eq 'before dd') {
2962     if ($child_nsuri eq $HTML_NS and $child_ln eq 'dd') {
2963     $element_state->{phase} = 'before dt';
2964     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'dt') {
2965     $self->{onerror}
2966 wakaba 1.104 ->(node => $child_el, type => 'ps element missing',
2967     text => 'dd',
2968     level => $self->{level}->{must});
2969 wakaba 1.40 $element_state->{phase} = 'before dd';
2970     } else {
2971 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
2972     level => $self->{level}->{must});
2973 wakaba 1.1 }
2974 wakaba 1.40 } else {
2975     die "check_child_element: Bad |dialog| phase: $element_state->{phase}";
2976     }
2977     },
2978     check_child_text => sub {
2979     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
2980     if ($has_significant) {
2981 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
2982     level => $self->{level}->{must});
2983 wakaba 1.1 }
2984 wakaba 1.40 },
2985     check_end => sub {
2986     my ($self, $item, $element_state) = @_;
2987     if ($element_state->{phase} eq 'before dd') {
2988     $self->{onerror}->(node => $item->{node},
2989 wakaba 1.104 type => 'child element missing',
2990     text => 'dd',
2991     level => $self->{level}->{must});
2992 wakaba 1.1 }
2993 wakaba 1.40
2994     $HTMLChecker{check_end}->(@_);
2995 wakaba 1.1 },
2996     };
2997    
2998     $Element->{$HTML_NS}->{pre} = {
2999 wakaba 1.40 %HTMLPhrasingContentChecker,
3000 wakaba 1.187 status => FEATURE_HTML5_REC,
3001 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
3002     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
3003     }, {
3004 wakaba 1.49 %HTMLAttrStatus,
3005 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3006 wakaba 1.187 lang => FEATURE_HTML5_REC,
3007 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3008 wakaba 1.49 width => FEATURE_M12N10_REC_DEPRECATED,
3009     }),
3010 wakaba 1.101 check_end => sub {
3011     my ($self, $item, $element_state) = @_;
3012    
3013     ## TODO: Flag to enable/disable IDL checking?
3014 wakaba 1.145 my $class = $item->{node}->get_attribute_ns (undef, 'class');
3015 wakaba 1.102 if ($class =~ /\bidl(?>-code)?\b/) { ## TODO: use classList.has
3016     ## NOTE: pre.idl: WHATWG, XHR, Selectors API, CSSOM specs
3017     ## NOTE: pre.code > code.idl-code: WebIDL spec
3018     ## NOTE: pre.idl-code: DOM1 spec
3019     ## NOTE: div.idl-code > pre: DOM, ProgressEvent specs
3020     ## NOTE: pre.schema: ReSpec-generated specs
3021 wakaba 1.101 $self->{onsubdoc}->({s => $item->{node}->text_content,
3022     container_node => $item->{node},
3023     media_type => 'text/x-webidl',
3024     is_char_string => 1});
3025     }
3026    
3027 wakaba 1.110 $HTMLPhrasingContentChecker{check_end}->(@_);
3028 wakaba 1.101 },
3029 wakaba 1.1 };
3030    
3031     $Element->{$HTML_NS}->{ol} = {
3032 wakaba 1.40 %HTMLChecker,
3033 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3034 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
3035 wakaba 1.68 compact => $GetHTMLBooleanAttrChecker->('compact'),
3036 wakaba 1.69 reversed => $GetHTMLBooleanAttrChecker->('reversed'),
3037 wakaba 1.1 start => $HTMLIntegerAttrChecker,
3038 wakaba 1.69 ## TODO: HTML4 |type|
3039 wakaba 1.49 }, {
3040     %HTMLAttrStatus,
3041 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3042 wakaba 1.61 align => FEATURE_HTML2X_RFC,
3043 wakaba 1.49 compact => FEATURE_M12N10_REC_DEPRECATED,
3044 wakaba 1.187 lang => FEATURE_HTML5_REC,
3045 wakaba 1.153 reversed => FEATURE_HTML5_WD,
3046 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3047 wakaba 1.153 #start => FEATURE_HTML5_WD | FEATURE_M12N10_REC_DEPRECATED,
3048     start => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
3049 wakaba 1.49 type => FEATURE_M12N10_REC_DEPRECATED,
3050 wakaba 1.1 }),
3051 wakaba 1.40 check_child_element => sub {
3052     my ($self, $item, $child_el, $child_nsuri, $child_ln,
3053     $child_is_transparent, $element_state) = @_;
3054 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
3055     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
3056 wakaba 1.40 $self->{onerror}->(node => $child_el,
3057     type => 'element not allowed:minus',
3058 wakaba 1.104 level => $self->{level}->{must});
3059 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
3060     #
3061     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'li') {
3062     #
3063     } else {
3064 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
3065     level => $self->{level}->{must});
3066 wakaba 1.1 }
3067 wakaba 1.40 },
3068     check_child_text => sub {
3069     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
3070     if ($has_significant) {
3071 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
3072     level => $self->{level}->{must});
3073 wakaba 1.1 }
3074     },
3075     };
3076    
3077     $Element->{$HTML_NS}->{ul} = {
3078 wakaba 1.40 %{$Element->{$HTML_NS}->{ol}},
3079 wakaba 1.187 status => FEATURE_HTML5_REC,
3080 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
3081     compact => $GetHTMLBooleanAttrChecker->('compact'),
3082 wakaba 1.69 ## TODO: HTML4 |type|
3083     ## TODO: sdaform, align
3084 wakaba 1.68 }, {
3085 wakaba 1.49 %HTMLAttrStatus,
3086 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3087 wakaba 1.61 align => FEATURE_HTML2X_RFC,
3088 wakaba 1.49 compact => FEATURE_M12N10_REC_DEPRECATED,
3089 wakaba 1.187 lang => FEATURE_HTML5_REC,
3090 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3091 wakaba 1.49 type => FEATURE_M12N10_REC_DEPRECATED,
3092     }),
3093 wakaba 1.1 };
3094    
3095 wakaba 1.64 $Element->{$HTML_NS}->{dir} = {
3096     ## TODO: %block; is not allowed [HTML4] ## TODO: Empty list allowed?
3097     %{$Element->{$HTML_NS}->{ul}},
3098     status => FEATURE_M12N10_REC_DEPRECATED,
3099 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
3100     compact => $GetHTMLBooleanAttrChecker->('compact'),
3101     }, {
3102 wakaba 1.64 %HTMLAttrStatus,
3103     %HTMLM12NCommonAttrStatus,
3104     align => FEATURE_HTML2X_RFC,
3105     compact => FEATURE_M12N10_REC_DEPRECATED,
3106 wakaba 1.187 lang => FEATURE_HTML5_REC,
3107 wakaba 1.64 sdaform => FEATURE_HTML20_RFC,
3108     sdapref => FEATURE_HTML20_RFC,
3109     }),
3110     };
3111    
3112 wakaba 1.1 $Element->{$HTML_NS}->{li} = {
3113 wakaba 1.72 %HTMLFlowContentChecker,
3114 wakaba 1.187 status => FEATURE_HTML5_REC,
3115 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
3116 wakaba 1.69 ## TODO: HTML4 |type|
3117 wakaba 1.49 value => sub {
3118 wakaba 1.1 my ($self, $attr) = @_;
3119 wakaba 1.152
3120     my $parent_is_ol;
3121 wakaba 1.1 my $parent = $attr->owner_element->manakai_parent_element;
3122     if (defined $parent) {
3123     my $parent_ns = $parent->namespace_uri;
3124     $parent_ns = '' unless defined $parent_ns;
3125     my $parent_ln = $parent->manakai_local_name;
3126 wakaba 1.152 $parent_is_ol = ($parent_ns eq $HTML_NS and $parent_ln eq 'ol');
3127     }
3128    
3129     unless ($parent_is_ol) {
3130     ## ISSUE: No "MUST" in the spec.
3131     $self->{onerror}->(node => $attr,
3132     type => 'non-ol li value',
3133     level => $self->{level}->{html5_fact});
3134 wakaba 1.1 }
3135 wakaba 1.152
3136 wakaba 1.1 $HTMLIntegerAttrChecker->($self, $attr);
3137 wakaba 1.131 },
3138 wakaba 1.49 }, {
3139     %HTMLAttrStatus,
3140 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3141 wakaba 1.61 align => FEATURE_HTML2X_RFC,
3142 wakaba 1.187 lang => FEATURE_HTML5_REC,
3143 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3144 wakaba 1.49 type => FEATURE_M12N10_REC_DEPRECATED,
3145 wakaba 1.154 #value => FEATURE_HTML5_LC | FEATURE_XHTMLBASIC11_CR |
3146 wakaba 1.55 # FEATURE_M12N10_REC_DEPRECATED,
3147 wakaba 1.154 value => FEATURE_HTML5_LC | FEATURE_XHTML2_ED |
3148 wakaba 1.82 FEATURE_XHTMLBASIC11_CR | FEATURE_M12N10_REC,
3149 wakaba 1.207 }), # check_attrs
3150 wakaba 1.40 check_child_element => sub {
3151     my ($self, $item, $child_el, $child_nsuri, $child_ln,
3152     $child_is_transparent, $element_state) = @_;
3153 wakaba 1.207 if (0) {
3154     ## XXXTODO: In <dir> element, then ...
3155 wakaba 1.40 $HTMLPhrasingContentChecker{check_child_element}->(@_);
3156     } else {
3157 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
3158 wakaba 1.40 }
3159 wakaba 1.207 }, # check_child_element
3160 wakaba 1.40 check_child_text => sub {
3161     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
3162 wakaba 1.207 if (0) {
3163     ## XXXTODO: In <dir> element, then ...
3164 wakaba 1.40 $HTMLPhrasingContentChecker{check_child_text}->(@_);
3165 wakaba 1.1 } else {
3166 wakaba 1.72 $HTMLFlowContentChecker{check_child_text}->(@_);
3167 wakaba 1.1 }
3168 wakaba 1.207 }, # check_child_text
3169     }; # li
3170 wakaba 1.1
3171     $Element->{$HTML_NS}->{dl} = {
3172 wakaba 1.40 %HTMLChecker,
3173 wakaba 1.187 status => FEATURE_HTML5_REC,
3174 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
3175     compact => $GetHTMLBooleanAttrChecker->('compact'),
3176     }, {
3177 wakaba 1.49 %HTMLAttrStatus,
3178 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3179 wakaba 1.49 compact => FEATURE_M12N10_REC_DEPRECATED,
3180 wakaba 1.187 lang => FEATURE_HTML5_REC,
3181 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3182     sdapref => FEATURE_HTML20_RFC,
3183 wakaba 1.49 type => FEATURE_M12N10_REC_DEPRECATED,
3184     }),
3185 wakaba 1.40 check_start => sub {
3186     my ($self, $item, $element_state) = @_;
3187     $element_state->{phase} = 'before dt';
3188 wakaba 1.79
3189     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3190     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3191 wakaba 1.40 },
3192     check_child_element => sub {
3193     my ($self, $item, $child_el, $child_nsuri, $child_ln,
3194     $child_is_transparent, $element_state) = @_;
3195 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
3196     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
3197 wakaba 1.40 $self->{onerror}->(node => $child_el,
3198     type => 'element not allowed:minus',
3199 wakaba 1.104 level => $self->{level}->{must});
3200 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
3201     #
3202     } elsif ($element_state->{phase} eq 'in dds') {
3203     if ($child_nsuri eq $HTML_NS and $child_ln eq 'dd') {
3204     #$element_state->{phase} = 'in dds';
3205     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'dt') {
3206     $element_state->{phase} = 'in dts';
3207     } else {
3208 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
3209     level => $self->{level}->{must});
3210 wakaba 1.40 }
3211     } elsif ($element_state->{phase} eq 'in dts') {
3212     if ($child_nsuri eq $HTML_NS and $child_ln eq 'dt') {
3213     #$element_state->{phase} = 'in dts';
3214     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'dd') {
3215     $element_state->{phase} = 'in dds';
3216     } else {
3217 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
3218     level => $self->{level}->{must});
3219 wakaba 1.40 }
3220     } elsif ($element_state->{phase} eq 'before dt') {
3221     if ($child_nsuri eq $HTML_NS and $child_ln eq 'dt') {
3222     $element_state->{phase} = 'in dts';
3223     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'dd') {
3224     $self->{onerror}
3225 wakaba 1.104 ->(node => $child_el, type => 'ps element missing',
3226     text => 'dt',
3227     level => $self->{level}->{must});
3228 wakaba 1.40 $element_state->{phase} = 'in dds';
3229     } else {
3230 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
3231     level => $self->{level}->{must});
3232 wakaba 1.1 }
3233 wakaba 1.40 } else {
3234     die "check_child_element: Bad |dl| phase: $element_state->{phase}";
3235 wakaba 1.1 }
3236 wakaba 1.40 },
3237     check_child_text => sub {
3238     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
3239     if ($has_significant) {
3240 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
3241     level => $self->{level}->{must});
3242 wakaba 1.40 }
3243     },
3244     check_end => sub {
3245     my ($self, $item, $element_state) = @_;
3246     if ($element_state->{phase} eq 'in dts') {
3247     $self->{onerror}->(node => $item->{node},
3248 wakaba 1.104 type => 'child element missing',
3249     text => 'dd',
3250     level => $self->{level}->{must});
3251 wakaba 1.1 }
3252    
3253 wakaba 1.40 $HTMLChecker{check_end}->(@_);
3254 wakaba 1.1 },
3255     };
3256    
3257     $Element->{$HTML_NS}->{dt} = {
3258 wakaba 1.40 %HTMLPhrasingContentChecker,
3259 wakaba 1.187 status => FEATURE_HTML5_REC,
3260 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3261     %HTMLAttrStatus,
3262 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3263 wakaba 1.187 lang => FEATURE_HTML5_REC,
3264 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3265 wakaba 1.49 }),
3266 wakaba 1.1 };
3267    
3268     $Element->{$HTML_NS}->{dd} = {
3269 wakaba 1.72 %HTMLFlowContentChecker,
3270 wakaba 1.187 status => FEATURE_HTML5_REC,
3271 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3272     %HTMLAttrStatus,
3273 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3274 wakaba 1.187 lang => FEATURE_HTML5_REC,
3275 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3276 wakaba 1.49 }),
3277 wakaba 1.1 };
3278    
3279     $Element->{$HTML_NS}->{a} = {
3280 wakaba 1.123 %HTMLTransparentChecker,
3281 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3282 wakaba 1.40 check_attrs => sub {
3283     my ($self, $item, $element_state) = @_;
3284 wakaba 1.1 my %attr;
3285 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
3286 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
3287     $attr_ns = '' unless defined $attr_ns;
3288     my $attr_ln = $attr->manakai_local_name;
3289     my $checker;
3290 wakaba 1.73 my $status;
3291 wakaba 1.1 if ($attr_ns eq '') {
3292 wakaba 1.73 $status = {
3293     %HTMLAttrStatus,
3294 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3295 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
3296 wakaba 1.73 charset => FEATURE_M12N10_REC,
3297 wakaba 1.82 coords => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3298 wakaba 1.73 cryptopts => FEATURE_RFC2659,
3299     dn => FEATURE_RFC2659,
3300 wakaba 1.154 href => FEATURE_HTML5_WD | FEATURE_RDFA_REC | FEATURE_XHTML2_ED |
3301 wakaba 1.153 FEATURE_M12N10_REC,
3302     hreflang => FEATURE_HTML5_WD | FEATURE_XHTML2_ED |
3303     FEATURE_M12N10_REC,
3304 wakaba 1.187 lang => FEATURE_HTML5_REC,
3305 wakaba 1.153 media => FEATURE_HTML5_WD | FEATURE_XHTML2_ED,
3306 wakaba 1.73 methods => FEATURE_HTML20_RFC,
3307     name => FEATURE_M12N10_REC_DEPRECATED,
3308     nonce => FEATURE_RFC2659,
3309     onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
3310     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
3311 wakaba 1.153 ping => FEATURE_HTML5_WD,
3312 wakaba 1.154 rel => FEATURE_HTML5_WD | FEATURE_RDFA_REC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3313     rev => FEATURE_RDFA_REC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3314 wakaba 1.73 sdapref => FEATURE_HTML20_RFC,
3315 wakaba 1.82 shape => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3316 wakaba 1.73 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
3317 wakaba 1.153 target => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3318     type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
3319 wakaba 1.73 urn => FEATURE_HTML20_RFC,
3320     }->{$attr_ln};
3321    
3322 wakaba 1.1 $checker = {
3323 wakaba 1.91 charset => sub {
3324     my ($self, $attr) = @_;
3325     $HTMLCharsetChecker->($attr->value, @_);
3326     },
3327 wakaba 1.70 ## TODO: HTML4 |coords|
3328 wakaba 1.1 target => $HTMLTargetAttrChecker,
3329     href => $HTMLURIAttrChecker,
3330     ping => $HTMLSpaceURIsAttrChecker,
3331 wakaba 1.40 rel => sub { $HTMLLinkTypesAttrChecker->(1, $item, @_) },
3332 wakaba 1.92 rev => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->(),
3333 wakaba 1.70 ## TODO: HTML4 |shape|
3334 wakaba 1.1 media => $HTMLMQAttrChecker,
3335 wakaba 1.70 ## TODO: HTML4/XHTML1 |name|
3336 wakaba 1.1 hreflang => $HTMLLanguageTagAttrChecker,
3337     type => $HTMLIMTAttrChecker,
3338     }->{$attr_ln};
3339     if ($checker) {
3340     $attr{$attr_ln} = $attr;
3341 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
3342     $attr_ln !~ /[A-Z]/) {
3343 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
3344     $status = $HTMLDatasetAttrStatus;
3345 wakaba 1.1 } else {
3346     $checker = $HTMLAttrChecker->{$attr_ln};
3347     }
3348     }
3349     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
3350     || $AttrChecker->{$attr_ns}->{''};
3351 wakaba 1.82 $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
3352     || $AttrStatus->{$attr_ns}->{''};
3353     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
3354 wakaba 1.62
3355 wakaba 1.1 if ($checker) {
3356 wakaba 1.66 $checker->($self, $attr, $item, $element_state) if ref $checker;
3357 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
3358 wakaba 1.54 #
3359 wakaba 1.1 } else {
3360 wakaba 1.104 $self->{onerror}->(node => $attr,
3361     type => 'unknown attribute',
3362     level => $self->{level}->{uncertain});
3363 wakaba 1.50 ## ISSUE: No conformance createria for unknown attributes in the spec
3364 wakaba 1.1 }
3365 wakaba 1.49
3366 wakaba 1.82 $self->_attr_status_info ($attr, $status);
3367 wakaba 1.1 }
3368    
3369 wakaba 1.40 $element_state->{in_a_href_original} = $self->{flag}->{in_a_href};
3370 wakaba 1.4 if (defined $attr{href}) {
3371     $self->{has_hyperlink_element} = 1;
3372 wakaba 1.40 $self->{flag}->{in_a_href} = 1;
3373 wakaba 1.4 } else {
3374 wakaba 1.1 for (qw/target ping rel media hreflang type/) {
3375     if (defined $attr{$_}) {
3376     $self->{onerror}->(node => $attr{$_},
3377 wakaba 1.104 type => 'attribute not allowed',
3378     level => $self->{level}->{must});
3379 wakaba 1.1 }
3380     }
3381     }
3382 wakaba 1.66
3383     $element_state->{uri_info}->{href}->{type}->{hyperlink} = 1;
3384 wakaba 1.1 },
3385 wakaba 1.40 check_start => sub {
3386     my ($self, $item, $element_state) = @_;
3387     $self->_add_minus_elements ($element_state, $HTMLInteractiveContent);
3388 wakaba 1.79
3389     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3390     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3391 wakaba 1.40 },
3392     check_end => sub {
3393     my ($self, $item, $element_state) = @_;
3394     $self->_remove_minus_elements ($element_state);
3395 wakaba 1.59 delete $self->{flag}->{in_a_href}
3396     unless $element_state->{in_a_href_original};
3397 wakaba 1.1
3398 wakaba 1.123 $HTMLTransparentChecker{check_end}->(@_);
3399 wakaba 1.1 },
3400     };
3401    
3402     $Element->{$HTML_NS}->{q} = {
3403 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3404 wakaba 1.40 %HTMLPhrasingContentChecker,
3405     check_attrs => $GetHTMLAttrsChecker->({
3406 wakaba 1.50 cite => $HTMLURIAttrChecker,
3407     }, {
3408 wakaba 1.49 %HTMLAttrStatus,
3409 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3410 wakaba 1.153 cite => FEATURE_HTML5_AT_RISK | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3411 wakaba 1.187 lang => FEATURE_HTML5_REC,
3412 wakaba 1.61 sdapref => FEATURE_HTML2X_RFC,
3413     sdasuff => FEATURE_HTML2X_RFC,
3414 wakaba 1.1 }),
3415 wakaba 1.66 check_start => sub {
3416     my ($self, $item, $element_state) = @_;
3417    
3418     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
3419 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3420     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3421 wakaba 1.66 },
3422 wakaba 1.1 };
3423 wakaba 1.75 ## TODO: "Quotation punctuation (such as quotation marks), if any, must be
3424     ## placed inside the <code>q</code> element." Though we cannot test the
3425     ## element against this requirement since it incluides a semantic bit,
3426     ## it might be possible to inform of the existence of quotation marks OUTSIDE
3427     ## the |q| element.
3428 wakaba 1.1
3429     $Element->{$HTML_NS}->{cite} = {
3430 wakaba 1.40 %HTMLPhrasingContentChecker,
3431 wakaba 1.187 status => FEATURE_HTML5_REC,
3432 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3433     %HTMLAttrStatus,
3434 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3435 wakaba 1.187 lang => FEATURE_HTML5_REC,
3436 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3437 wakaba 1.49 }),
3438 wakaba 1.1 };
3439    
3440     $Element->{$HTML_NS}->{em} = {
3441 wakaba 1.40 %HTMLPhrasingContentChecker,
3442 wakaba 1.187 status => FEATURE_HTML5_REC,
3443 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3444     %HTMLAttrStatus,
3445 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3446 wakaba 1.187 lang => FEATURE_HTML5_REC,
3447 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3448 wakaba 1.49 }),
3449 wakaba 1.1 };
3450    
3451     $Element->{$HTML_NS}->{strong} = {
3452 wakaba 1.40 %HTMLPhrasingContentChecker,
3453 wakaba 1.187 status => FEATURE_HTML5_REC,
3454 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3455     %HTMLAttrStatus,
3456 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3457 wakaba 1.187 lang => FEATURE_HTML5_REC,
3458 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3459 wakaba 1.49 }),
3460 wakaba 1.1 };
3461    
3462     $Element->{$HTML_NS}->{small} = {
3463 wakaba 1.40 %HTMLPhrasingContentChecker,
3464 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
3465 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3466     %HTMLAttrStatus,
3467     %HTMLM12NCommonAttrStatus,
3468 wakaba 1.187 lang => FEATURE_HTML5_REC,
3469 wakaba 1.49 }),
3470 wakaba 1.1 };
3471    
3472 wakaba 1.51 $Element->{$HTML_NS}->{big} = {
3473     %HTMLPhrasingContentChecker,
3474     status => FEATURE_M12N10_REC,
3475     check_attrs => $GetHTMLAttrsChecker->({}, {
3476     %HTMLAttrStatus,
3477     %HTMLM12NCommonAttrStatus,
3478 wakaba 1.187 lang => FEATURE_HTML5_REC,
3479 wakaba 1.51 }),
3480     };
3481    
3482 wakaba 1.38 $Element->{$HTML_NS}->{mark} = {
3483 wakaba 1.187 status => FEATURE_HTML5_WD,
3484 wakaba 1.40 %HTMLPhrasingContentChecker,
3485 wakaba 1.1 };
3486    
3487     $Element->{$HTML_NS}->{dfn} = {
3488 wakaba 1.40 %HTMLPhrasingContentChecker,
3489 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
3490 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3491     %HTMLAttrStatus,
3492 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3493 wakaba 1.187 lang => FEATURE_HTML5_REC,
3494 wakaba 1.49 }),
3495 wakaba 1.40 check_start => sub {
3496     my ($self, $item, $element_state) = @_;
3497     $self->_add_minus_elements ($element_state, {$HTML_NS => {dfn => 1}});
3498 wakaba 1.1
3499 wakaba 1.40 my $node = $item->{node};
3500 wakaba 1.1 my $term = $node->get_attribute_ns (undef, 'title');
3501     unless (defined $term) {
3502     for my $child (@{$node->child_nodes}) {
3503     if ($child->node_type == 1) { # ELEMENT_NODE
3504     if (defined $term) {
3505     undef $term;
3506     last;
3507     } elsif ($child->manakai_local_name eq 'abbr') {
3508     my $nsuri = $child->namespace_uri;
3509     if (defined $nsuri and $nsuri eq $HTML_NS) {
3510     my $attr = $child->get_attribute_node_ns (undef, 'title');
3511     if ($attr) {
3512     $term = $attr->value;
3513     }
3514     }
3515     }
3516     } elsif ($child->node_type == 3 or $child->node_type == 4) {
3517     ## TEXT_NODE or CDATA_SECTION_NODE
3518 wakaba 1.132 if ($child->data =~ /\A[\x09\x0A\x0C\x0D\x20]+\z/) { # Inter-element whitespace
3519 wakaba 1.1 next;
3520     }
3521     undef $term;
3522     last;
3523     }
3524     }
3525     unless (defined $term) {
3526     $term = $node->text_content;
3527     }
3528     }
3529     if ($self->{term}->{$term}) {
3530     push @{$self->{term}->{$term}}, $node;
3531     } else {
3532     $self->{term}->{$term} = [$node];
3533     }
3534 wakaba 1.77 ## ISSUE: The HTML5 definition for the defined term does not work with
3535     ## |ruby| unless |dfn| has |title|.
3536 wakaba 1.79
3537     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3538     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3539 wakaba 1.40 },
3540     check_end => sub {
3541     my ($self, $item, $element_state) = @_;
3542     $self->_remove_minus_elements ($element_state);
3543 wakaba 1.1
3544 wakaba 1.40 $HTMLPhrasingContentChecker{check_end}->(@_);
3545 wakaba 1.1 },
3546     };
3547    
3548     $Element->{$HTML_NS}->{abbr} = {
3549 wakaba 1.40 %HTMLPhrasingContentChecker,
3550 wakaba 1.187 status => FEATURE_HTML5_REC,
3551 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3552     %HTMLAttrStatus,
3553 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3554     full => FEATURE_XHTML2_ED,
3555 wakaba 1.187 lang => FEATURE_HTML5_REC,
3556 wakaba 1.49 }),
3557 wakaba 1.77 ## NOTE: "If an abbreviation is pluralised, the expansion's grammatical
3558     ## number (plural vs singular) must match the grammatical number of the
3559     ## contents of the element." Though this can be checked by machine,
3560     ## it requires language-specific knowledge and dictionary, such that
3561     ## we don't support the check of the requirement.
3562     ## ISSUE: Is <abbr title="Cascading Style Sheets">CSS</abbr> conforming?
3563 wakaba 1.49 };
3564    
3565     $Element->{$HTML_NS}->{acronym} = {
3566     %HTMLPhrasingContentChecker,
3567     status => FEATURE_M12N10_REC,
3568     check_attrs => $GetHTMLAttrsChecker->({}, {
3569     %HTMLAttrStatus,
3570     %HTMLM12NCommonAttrStatus,
3571 wakaba 1.187 lang => FEATURE_HTML5_REC,
3572 wakaba 1.49 }),
3573 wakaba 1.1 };
3574    
3575     $Element->{$HTML_NS}->{time} = {
3576 wakaba 1.187 status => FEATURE_HTML5_WD,
3577 wakaba 1.40 %HTMLPhrasingContentChecker,
3578     check_attrs => $GetHTMLAttrsChecker->({
3579 wakaba 1.1 datetime => sub { 1 }, # checked in |checker|
3580 wakaba 1.49 }, {
3581     %HTMLAttrStatus,
3582     %HTMLM12NCommonAttrStatus,
3583 wakaba 1.72 datetime => FEATURE_HTML5_FD,
3584 wakaba 1.201 }), # check_attrs
3585 wakaba 1.40 check_end => sub {
3586     my ($self, $item, $element_state) = @_;
3587 wakaba 1.1
3588 wakaba 1.201 ## XXX Maybe we should move this code out somewhere (maybe
3589     ## Message::Date) such that we can reuse this code in other places
3590     ## (e.g. HTMLTimeElement implementation).
3591    
3592     ## "Vaguer moments in time" or "valid date or time string".
3593 wakaba 1.40 my $attr = $item->{node}->get_attribute_node_ns (undef, 'datetime');
3594 wakaba 1.1 my $input;
3595     my $reg_sp;
3596     my $input_node;
3597     if ($attr) {
3598     $input = $attr->value;
3599 wakaba 1.201 $reg_sp = qr/[\x09\x0A\x0C\x0D\x20]/;
3600 wakaba 1.1 $input_node = $attr;
3601     } else {
3602 wakaba 1.40 $input = $item->{node}->text_content;
3603 wakaba 1.201 $reg_sp = qr/\p{WhiteSpace}/;
3604 wakaba 1.40 $input_node = $item->{node};
3605 wakaba 1.1 }
3606    
3607     my $hour;
3608     my $minute;
3609     my $second;
3610     if ($input =~ /
3611     \A
3612 wakaba 1.201 $reg_sp*
3613 wakaba 1.1 ([0-9]+) # 1
3614     (?>
3615     -([0-9]+) # 2
3616 wakaba 1.112 -((?>[0-9]+)) # 3 # Use (?>) such that yyyy-mm-ddhh:mm does not match
3617 wakaba 1.201 $reg_sp*
3618 wakaba 1.1 (?>
3619 wakaba 1.201 (?>
3620     T
3621     $reg_sp*
3622     )?
3623     ([0-9]+) # 4
3624     :([0-9]+) # 5
3625     (?>
3626     :([0-9]+(?>\.[0-9]+)?) # 6
3627     )?
3628     $reg_sp*
3629     (?>
3630     Z
3631     $reg_sp*
3632     |
3633     [+-]([0-9]+):([0-9]+) # 7, 8
3634     $reg_sp*
3635     )?
3636 wakaba 1.1 )?
3637     \z
3638     |
3639     :([0-9]+) # 9
3640 wakaba 1.201 (?:
3641     :([0-9]+(?>\.[0-9]+)?) # 10
3642 wakaba 1.1 )?
3643 wakaba 1.201 $reg_sp*
3644 wakaba 1.112 \z
3645 wakaba 1.1 )
3646     /x) {
3647 wakaba 1.201 my $has_syntax_error;
3648 wakaba 1.1 if (defined $2) { ## YYYY-MM-DD T? hh:mm
3649     if (length $1 != 4 or length $2 != 2 or length $3 != 2 or
3650 wakaba 1.201 (defined $4 and length $4 != 2) or
3651     (defined $5 and length $5 != 2)) {
3652 wakaba 1.1 $self->{onerror}->(node => $input_node,
3653 wakaba 1.104 type => 'dateortime:syntax error',
3654     level => $self->{level}->{must});
3655 wakaba 1.201 $has_syntax_error = 1;
3656 wakaba 1.1 }
3657    
3658     if (1 <= $2 and $2 <= 12) {
3659 wakaba 1.104 $self->{onerror}->(node => $input_node, type => 'datetime:bad day',
3660     level => $self->{level}->{must})
3661 wakaba 1.1 if $3 < 1 or
3662     $3 > [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]->[$2];
3663 wakaba 1.104 $self->{onerror}->(node => $input_node, type => 'datetime:bad day',
3664     level => $self->{level}->{must})
3665 wakaba 1.1 if $2 == 2 and $3 == 29 and
3666     not ($1 % 400 == 0 or ($1 % 4 == 0 and $1 % 100 != 0));
3667     } else {
3668     $self->{onerror}->(node => $input_node,
3669 wakaba 1.104 type => 'datetime:bad month',
3670     level => $self->{level}->{must});
3671 wakaba 1.1 }
3672 wakaba 1.201 $self->{onerror}->(node => $input_node,
3673     type => 'datetime:bad year',
3674     level => $self->{level}->{must})
3675     if $1 == 0;
3676 wakaba 1.1
3677     ($hour, $minute, $second) = ($4, $5, $6);
3678    
3679     if (defined $7) { ## [+-]hh:mm
3680     if (length $7 != 2 or length $8 != 2) {
3681     $self->{onerror}->(node => $input_node,
3682 wakaba 1.104 type => 'dateortime:syntax error',
3683     level => $self->{level}->{must});
3684 wakaba 1.201 $has_syntax_error = 1;
3685 wakaba 1.1 }
3686    
3687     $self->{onerror}->(node => $input_node,
3688 wakaba 1.104 type => 'datetime:bad timezone hour',
3689     level => $self->{level}->{must})
3690 wakaba 1.1 if $7 > 23;
3691     $self->{onerror}->(node => $input_node,
3692 wakaba 1.104 type => 'datetime:bad timezone minute',
3693     level => $self->{level}->{must})
3694 wakaba 1.1 if $8 > 59;
3695     }
3696     } else { ## hh:mm
3697     if (length $1 != 2 or length $9 != 2) {
3698     $self->{onerror}->(node => $input_node,
3699 wakaba 1.104 type => qq'dateortime:syntax error',
3700     level => $self->{level}->{must});
3701 wakaba 1.201 $has_syntax_error = 1;
3702 wakaba 1.1 }
3703    
3704     ($hour, $minute, $second) = ($1, $9, $10);
3705     }
3706    
3707 wakaba 1.104 $self->{onerror}->(node => $input_node, type => 'datetime:bad hour',
3708     level => $self->{level}->{must}) if $hour > 23;
3709     $self->{onerror}->(node => $input_node, type => 'datetime:bad minute',
3710     level => $self->{level}->{must}) if $minute > 59;
3711 wakaba 1.1
3712     if (defined $second) { ## s
3713     ## NOTE: Integer part of second don't have to have length of two.
3714    
3715     if (substr ($second, 0, 1) eq '.') {
3716     $self->{onerror}->(node => $input_node,
3717 wakaba 1.104 type => 'dateortime:syntax error',
3718     level => $self->{level}->{must});
3719 wakaba 1.201 $has_syntax_error = 1;
3720 wakaba 1.1 }
3721    
3722 wakaba 1.104 $self->{onerror}->(node => $input_node, type => 'datetime:bad second',
3723     level => $self->{level}->{must}) if $second >= 60;
3724 wakaba 1.201 }
3725    
3726     unless ($has_syntax_error) {
3727     $input =~ s/\A$reg_sp+//;
3728     $input =~ s/$reg_sp+\z//;
3729     if ($input =~ /$reg_sp+/) {
3730     $self->{onerror}->(node => $input_node,
3731     type => 'dateortime:syntax error',
3732     level => $self->{level}->{must});
3733     }
3734     }
3735 wakaba 1.1 } else {
3736     $self->{onerror}->(node => $input_node,
3737 wakaba 1.104 type => 'dateortime:syntax error',
3738     level => $self->{level}->{must});
3739 wakaba 1.1 }
3740    
3741 wakaba 1.40 $HTMLPhrasingContentChecker{check_end}->(@_);
3742 wakaba 1.201 }, # check_end
3743     }; # time
3744 wakaba 1.1
3745     $Element->{$HTML_NS}->{meter} = { ## TODO: "The recommended way of giving the value is to include it as contents of the element"
3746 wakaba 1.77 ## TODO: value inequalities (HTML5 revision 1463)
3747 wakaba 1.113 ## TODO: content checking
3748     ## TODO: content or value must contain number (rev 2053)
3749 wakaba 1.40 %HTMLPhrasingContentChecker,
3750 wakaba 1.187 status => FEATURE_HTML5_WD,
3751 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
3752 wakaba 1.1 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3753     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3754     low => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3755     high => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3756     max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3757     optimum => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
3758 wakaba 1.50 }, {
3759     %HTMLAttrStatus,
3760     high => FEATURE_HTML5_DEFAULT,
3761     low => FEATURE_HTML5_DEFAULT,
3762     max => FEATURE_HTML5_DEFAULT,
3763     min => FEATURE_HTML5_DEFAULT,
3764     optimum => FEATURE_HTML5_DEFAULT,
3765     value => FEATURE_HTML5_DEFAULT,
3766 wakaba 1.211 }), # check_attrs
3767     check_end => sub {
3768     my ($self, $item, $element_state) = @_;
3769 wakaba 1.1
3770 wakaba 1.211 ## XXX Work in progress
3771    
3772     my $tc = $item->{node}->text_content;
3773     my $n1;
3774     my $denominator;
3775     my $n2;
3776     if ($tc =~ s/^([0-9.]+)//) {
3777     $n1 = $1;
3778    
3779     if ($tc =~ s/^[^0-9.]+([0-9.]+)//) {
3780     $n2 = $1;
3781     } elsif ($tc =~ s/^([\x{0025}\x{066A}\x{FE6A}\x{FF05}\x{2030}\x{2031}])//) {
3782     $denominator = $1;
3783     }
3784     }
3785    
3786     if ($tc =~ /[0-9.]/) {
3787     undef $n1;
3788     undef $n2;
3789     }
3790    
3791     $HTMLPhrasingContentChecker{check_end}->(@_);
3792     }, # check_end
3793     }; # meter
3794    
3795     $Element->{$HTML_NS}->{progress} = {
3796 wakaba 1.40 %HTMLPhrasingContentChecker,
3797 wakaba 1.187 status => FEATURE_HTML5_WD,
3798 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
3799 wakaba 1.211 value => sub { }, ## checked in |check_attrs2|
3800     max => sub { }, ## checked in |check_attrs2|
3801 wakaba 1.50 }, {
3802     %HTMLAttrStatus,
3803     max => FEATURE_HTML5_DEFAULT,
3804     value => FEATURE_HTML5_DEFAULT,
3805 wakaba 1.211 }), # check_attrs
3806     check_attrs2 => sub {
3807     my ($self, $item, $element_state) = @_;
3808    
3809     my $max = 1;
3810     my $max_attr = $item->{node}->get_attribute_node_ns (undef, 'max');
3811     if ($max_attr) {
3812     $GetHTMLFloatingPointNumberAttrChecker->(sub {
3813     my $num = $_[0];
3814     $max = $num;
3815     return $num > 0; ## >, not >=
3816     })->($self, $max_attr);
3817     }
3818    
3819     my $value_attr = $item->{node}->get_attribute_node_ns (undef, 'value');
3820     if ($value_attr) {
3821     $self->{onerror}->(node => $value_attr,
3822     type => 'attribute not allowed',
3823     text => 'value',
3824     level => $self->{level}->{should}); # RECOMMENDED
3825    
3826     $GetHTMLFloatingPointNumberAttrChecker->(sub {
3827     my $num = $_[0];
3828    
3829     unless ($num <= $max) {
3830     $self->{onerror}->(node => $value_attr,
3831     type => 'progress value out of range',
3832     value => $max, # XXX document error type
3833     level => $self->{level}->{must});
3834     }
3835    
3836     return $num >= 0; ## >=, not >
3837     })->($self, $value_attr);
3838     }
3839     }, # check_attrs2
3840     # XXX warn if the value from the content is greater than |max|
3841     # attribute value.
3842     # XXX warn if the element content does not contain one or two numbers.
3843     }; # progress
3844 wakaba 1.1
3845     $Element->{$HTML_NS}->{code} = {
3846 wakaba 1.40 %HTMLPhrasingContentChecker,
3847 wakaba 1.187 status => FEATURE_HTML5_REC,
3848 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3849     %HTMLAttrStatus,
3850 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3851 wakaba 1.187 lang => FEATURE_HTML5_REC,
3852 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3853 wakaba 1.49 }),
3854 wakaba 1.1 };
3855    
3856     $Element->{$HTML_NS}->{var} = {
3857 wakaba 1.40 %HTMLPhrasingContentChecker,
3858 wakaba 1.187 status => FEATURE_HTML5_REC,
3859 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3860     %HTMLAttrStatus,
3861 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3862 wakaba 1.187 lang => FEATURE_HTML5_REC,
3863 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3864 wakaba 1.49 }),
3865 wakaba 1.1 };
3866    
3867     $Element->{$HTML_NS}->{samp} = {
3868 wakaba 1.40 %HTMLPhrasingContentChecker,
3869 wakaba 1.187 status => FEATURE_HTML5_REC,
3870 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3871     %HTMLAttrStatus,
3872 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3873 wakaba 1.187 lang => FEATURE_HTML5_REC,
3874 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3875 wakaba 1.49 }),
3876 wakaba 1.1 };
3877    
3878     $Element->{$HTML_NS}->{kbd} = {
3879 wakaba 1.40 %HTMLPhrasingContentChecker,
3880 wakaba 1.187 status => FEATURE_HTML5_REC,
3881 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3882     %HTMLAttrStatus,
3883 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3884 wakaba 1.187 lang => FEATURE_HTML5_REC,
3885 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3886 wakaba 1.49 }),
3887 wakaba 1.1 };
3888    
3889     $Element->{$HTML_NS}->{sub} = {
3890 wakaba 1.40 %HTMLPhrasingContentChecker,
3891 wakaba 1.187 status => FEATURE_HTML5_REC,
3892 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3893     %HTMLAttrStatus,
3894 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3895 wakaba 1.187 lang => FEATURE_HTML5_REC,
3896 wakaba 1.61 sdapref => FEATURE_HTML2X_RFC,
3897 wakaba 1.49 }),
3898 wakaba 1.1 };
3899    
3900 wakaba 1.51 $Element->{$HTML_NS}->{sup} = $Element->{$HTML_NS}->{sub};
3901 wakaba 1.1
3902     $Element->{$HTML_NS}->{span} = {
3903 wakaba 1.40 %HTMLPhrasingContentChecker,
3904 wakaba 1.187 status => FEATURE_HTML5_REC,
3905 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3906     %HTMLAttrStatus,
3907 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3908 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
3909     dataformatas => FEATURE_HTML4_REC_RESERVED,
3910     datasrc => FEATURE_HTML4_REC_RESERVED,
3911 wakaba 1.187 lang => FEATURE_HTML5_REC,
3912 wakaba 1.61 sdaform => FEATURE_HTML2X_RFC,
3913 wakaba 1.49 }),
3914 wakaba 1.1 };
3915    
3916 wakaba 1.205 # XXX Warning for "authors are encouraged to consider whether other
3917     # elements might be more applicable"
3918 wakaba 1.1 $Element->{$HTML_NS}->{i} = {
3919 wakaba 1.40 %HTMLPhrasingContentChecker,
3920 wakaba 1.187 status => FEATURE_HTML5_REC,
3921 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3922     %HTMLAttrStatus,
3923     %HTMLM12NCommonAttrStatus,
3924 wakaba 1.187 lang => FEATURE_HTML5_REC,
3925 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3926 wakaba 1.49 }),
3927 wakaba 1.1 };
3928    
3929 wakaba 1.51 $Element->{$HTML_NS}->{b} = $Element->{$HTML_NS}->{i};
3930    
3931 wakaba 1.61 $Element->{$HTML_NS}->{tt} = {
3932     %HTMLPhrasingContentChecker,
3933     status => FEATURE_M12N10_REC,
3934     check_attrs => $GetHTMLAttrsChecker->({}, {
3935     %HTMLAttrStatus,
3936     %HTMLM12NCommonAttrStatus,
3937 wakaba 1.187 lang => FEATURE_HTML5_REC,
3938 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3939     }),
3940     };
3941 wakaba 1.51
3942     $Element->{$HTML_NS}->{s} = {
3943 wakaba 1.40 %HTMLPhrasingContentChecker,
3944 wakaba 1.51 status => FEATURE_M12N10_REC_DEPRECATED,
3945 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3946     %HTMLAttrStatus,
3947     %HTMLM12NCommonAttrStatus,
3948 wakaba 1.187 lang => FEATURE_HTML5_REC,
3949 wakaba 1.49 }),
3950 wakaba 1.1 };
3951    
3952 wakaba 1.51 $Element->{$HTML_NS}->{strike} = $Element->{$HTML_NS}->{s};
3953    
3954     $Element->{$HTML_NS}->{u} = $Element->{$HTML_NS}->{s};
3955    
3956 wakaba 1.1 $Element->{$HTML_NS}->{bdo} = {
3957 wakaba 1.40 %HTMLPhrasingContentChecker,
3958 wakaba 1.187 status => FEATURE_HTML5_REC,
3959 wakaba 1.40 check_attrs => sub {
3960     my ($self, $item, $element_state) = @_;
3961 wakaba 1.49 $GetHTMLAttrsChecker->({}, {
3962     %HTMLAttrStatus,
3963 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
3964     dir => FEATURE_HTML5_REC,
3965     id => FEATURE_HTML5_REC,
3966     style => FEATURE_HTML5_REC,
3967     title => FEATURE_HTML5_REC,
3968     lang => FEATURE_HTML5_REC,
3969 wakaba 1.61 sdapref => FEATURE_HTML2X_RFC,
3970     sdasuff => FEATURE_HTML2X_RFC,
3971 wakaba 1.49 })->($self, $item, $element_state);
3972 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'dir')) {
3973     $self->{onerror}->(node => $item->{node},
3974 wakaba 1.104 type => 'attribute missing',
3975     text => 'dir',
3976     level => $self->{level}->{must});
3977 wakaba 1.1 }
3978     },
3979     ## ISSUE: The spec does not directly say that |dir| is a enumerated attr.
3980     };
3981    
3982 wakaba 1.99 $Element->{$HTML_NS}->{ruby} = {
3983     %HTMLPhrasingContentChecker,
3984 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
3985 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
3986     %HTMLAttrStatus,
3987     %HTMLM12NXHTML2CommonAttrStatus, # XHTML 1.1 & XHTML 2.0 & XHTML+RDFa 1.0
3988 wakaba 1.187 lang => FEATURE_HTML5_REC,
3989 wakaba 1.99 }),
3990     check_start => sub {
3991     my ($self, $item, $element_state) = @_;
3992    
3993     $element_state->{phase} = 'before-rb';
3994     #$element_state->{has_sig}
3995 wakaba 1.100
3996     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3997     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3998 wakaba 1.99 },
3999     ## NOTE: (phrasing, (rt | (rp, rt, rp)))+
4000     check_child_element => sub {
4001     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4002     $child_is_transparent, $element_state) = @_;
4003 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4004     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4005 wakaba 1.99 $self->{onerror}->(node => $child_el,
4006     type => 'element not allowed:minus',
4007 wakaba 1.104 level => $self->{level}->{must});
4008 wakaba 1.99 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4009     #
4010     } elsif ($element_state->{phase} eq 'before-rb') {
4011     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4012     $element_state->{phase} = 'in-rb';
4013     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4014     $self->{onerror}->(node => $child_el,
4015 wakaba 1.104 level => $self->{level}->{should},
4016     type => 'no significant content before');
4017 wakaba 1.99 $element_state->{phase} = 'after-rt';
4018     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4019     $self->{onerror}->(node => $child_el,
4020 wakaba 1.104 level => $self->{level}->{should},
4021     type => 'no significant content before');
4022 wakaba 1.99 $element_state->{phase} = 'after-rp1';
4023     } else {
4024     $self->{onerror}->(node => $child_el,
4025 wakaba 1.104 type => 'element not allowed:ruby base',
4026     level => $self->{level}->{must});
4027 wakaba 1.99 $element_state->{phase} = 'in-rb';
4028     }
4029     } elsif ($element_state->{phase} eq 'in-rb') {
4030     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4031     #$element_state->{phase} = 'in-rb';
4032     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4033     unless ($element_state->{has_significant}) {
4034     $self->{onerror}->(node => $child_el,
4035 wakaba 1.104 level => $self->{level}->{should},
4036     type => 'no significant content before');
4037 wakaba 1.99 }
4038     $element_state->{phase} = 'after-rt';
4039     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4040     unless ($element_state->{has_significant}) {
4041     $self->{onerror}->(node => $child_el,
4042 wakaba 1.104 level => $self->{level}->{should},
4043     type => 'no significant content before');
4044 wakaba 1.99 }
4045     $element_state->{phase} = 'after-rp1';
4046     } else {
4047     $self->{onerror}->(node => $child_el,
4048 wakaba 1.104 type => 'element not allowed:ruby base',
4049     level => $self->{level}->{must});
4050 wakaba 1.99 #$element_state->{phase} = 'in-rb';
4051     }
4052     } elsif ($element_state->{phase} eq 'after-rt') {
4053     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4054     if ($element_state->{has_significant}) {
4055     $element_state->{has_sig} = 1;
4056     delete $element_state->{has_significant};
4057     }
4058     $element_state->{phase} = 'in-rb';
4059     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4060     $self->{onerror}->(node => $child_el,
4061 wakaba 1.104 level => $self->{level}->{should},
4062     type => 'no significant content before');
4063 wakaba 1.99 $element_state->{phase} = 'after-rp1';
4064     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4065     $self->{onerror}->(node => $child_el,
4066 wakaba 1.104 level => $self->{level}->{should},
4067     type => 'no significant content before');
4068 wakaba 1.99 #$element_state->{phase} = 'after-rt';
4069     } else {
4070     $self->{onerror}->(node => $child_el,
4071 wakaba 1.104 type => 'element not allowed:ruby base',
4072     level => $self->{level}->{must});
4073 wakaba 1.99 if ($element_state->{has_significant}) {
4074     $element_state->{has_sig} = 1;
4075     delete $element_state->{has_significant};
4076     }
4077     $element_state->{phase} = 'in-rb';
4078     }
4079     } elsif ($element_state->{phase} eq 'after-rp1') {
4080     if ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4081     $element_state->{phase} = 'after-rp-rt';
4082     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4083     $self->{onerror}->(node => $child_el,
4084 wakaba 1.104 type => 'ps element missing',
4085     text => 'rt',
4086     level => $self->{level}->{must});
4087 wakaba 1.99 $element_state->{phase} = 'after-rp2';
4088     } else {
4089     $self->{onerror}->(node => $child_el,
4090 wakaba 1.104 type => 'ps element missing',
4091     text => 'rt',
4092     level => $self->{level}->{must});
4093 wakaba 1.99 $self->{onerror}->(node => $child_el,
4094 wakaba 1.104 type => 'ps element missing',
4095     text => 'rp',
4096     level => $self->{level}->{must});
4097 wakaba 1.99 unless ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4098     $self->{onerror}->(node => $child_el,
4099 wakaba 1.104 type => 'element not allowed:ruby base',
4100     level => $self->{level}->{must});
4101 wakaba 1.99 }
4102     if ($element_state->{has_significant}) {
4103     $element_state->{has_sig} = 1;
4104     delete $element_state->{has_significant};
4105     }
4106     $element_state->{phase} = 'in-rb';
4107     }
4108     } elsif ($element_state->{phase} eq 'after-rp-rt') {
4109     if ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4110     $element_state->{phase} = 'after-rp2';
4111     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4112     $self->{onerror}->(node => $child_el,
4113 wakaba 1.104 type => 'ps element missing',
4114     text => 'rp',
4115     level => $self->{level}->{must});
4116 wakaba 1.99 $self->{onerror}->(node => $child_el,
4117 wakaba 1.104 level => $self->{level}->{should},
4118     type => 'no significant content before');
4119 wakaba 1.99 $element_state->{phase} = 'after-rt';
4120     } else {
4121     $self->{onerror}->(node => $child_el,
4122 wakaba 1.104 type => 'ps element missing',
4123     text => 'rp',
4124     level => $self->{level}->{must});
4125 wakaba 1.99 unless ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4126     $self->{onerror}->(node => $child_el,
4127 wakaba 1.104 type => 'element not allowed:ruby base',
4128     level => $self->{level}->{must});
4129 wakaba 1.99 }
4130     if ($element_state->{has_significant}) {
4131     $element_state->{has_sig} = 1;
4132     delete $element_state->{has_significant};
4133     }
4134     $element_state->{phase} = 'in-rb';
4135     }
4136     } elsif ($element_state->{phase} eq 'after-rp2') {
4137     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4138     if ($element_state->{has_significant}) {
4139     $element_state->{has_sig} = 1;
4140     delete $element_state->{has_significant};
4141     }
4142     $element_state->{phase} = 'in-rb';
4143     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4144     $self->{onerror}->(node => $child_el,
4145 wakaba 1.104 level => $self->{level}->{should},
4146     type => 'no significant content before');
4147 wakaba 1.99 $element_state->{phase} = 'after-rt';
4148     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4149     $self->{onerror}->(node => $child_el,
4150 wakaba 1.104 level => $self->{level}->{should},
4151     type => 'no significant content before');
4152 wakaba 1.99 $element_state->{phase} = 'after-rp1';
4153     } else {
4154     $self->{onerror}->(node => $child_el,
4155 wakaba 1.104 type => 'element not allowed:ruby base',
4156     level => $self->{level}->{must});
4157 wakaba 1.99 if ($element_state->{has_significant}) {
4158     $element_state->{has_sig} = 1;
4159     delete $element_state->{has_significant};
4160     }
4161     $element_state->{phase} = 'in-rb';
4162     }
4163     } else {
4164     die "check_child_element: Bad |ruby| phase: $element_state->{phase}";
4165     }
4166     },
4167     check_child_text => sub {
4168     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4169     if ($has_significant) {
4170     if ($element_state->{phase} eq 'before-rb') {
4171     $element_state->{phase} = 'in-rb';
4172     } elsif ($element_state->{phase} eq 'in-rb') {
4173     #
4174     } elsif ($element_state->{phase} eq 'after-rt' or
4175     $element_state->{phase} eq 'after-rp2') {
4176     $element_state->{phase} = 'in-rb';
4177     } elsif ($element_state->{phase} eq 'after-rp1') {
4178     $self->{onerror}->(node => $child_node,
4179 wakaba 1.104 type => 'ps element missing',
4180     text => 'rt',
4181     level => $self->{level}->{must});
4182 wakaba 1.99 $self->{onerror}->(node => $child_node,
4183 wakaba 1.104 type => 'ps element missing',
4184     text => 'rp',
4185     level => $self->{level}->{must});
4186 wakaba 1.99 $element_state->{phase} = 'in-rb';
4187     } elsif ($element_state->{phase} eq 'after-rp-rt') {
4188     $self->{onerror}->(node => $child_node,
4189 wakaba 1.104 type => 'ps element missing',
4190     text => 'rp',
4191     level => $self->{level}->{must});
4192 wakaba 1.99 $element_state->{phase} = 'in-rb';
4193     } else {
4194     die "check_child_text: Bad |ruby| phase: $element_state->{phase}";
4195     }
4196     }
4197     },
4198     check_end => sub {
4199     my ($self, $item, $element_state) = @_;
4200     $self->_remove_minus_elements ($element_state);
4201    
4202     if ($element_state->{phase} eq 'before-rb') {
4203     $self->{onerror}->(node => $item->{node},
4204 wakaba 1.104 level => $self->{level}->{should},
4205 wakaba 1.99 type => 'no significant content');
4206     $self->{onerror}->(node => $item->{node},
4207 wakaba 1.104 type => 'element missing',
4208     text => 'rt',
4209     level => $self->{level}->{must});
4210 wakaba 1.99 } elsif ($element_state->{phase} eq 'in-rb') {
4211     unless ($element_state->{has_significant}) {
4212     $self->{onerror}->(node => $item->{node},
4213 wakaba 1.104 level => $self->{level}->{should},
4214     type => 'no significant content at the end');
4215 wakaba 1.99 }
4216     $self->{onerror}->(node => $item->{node},
4217 wakaba 1.104 type => 'element missing',
4218     text => 'rt',
4219     level => $self->{level}->{must});
4220 wakaba 1.99 } elsif ($element_state->{phase} eq 'after-rt' or
4221     $element_state->{phase} eq 'after-rp2') {
4222     #
4223     } elsif ($element_state->{phase} eq 'after-rp1') {
4224     $self->{onerror}->(node => $item->{node},
4225 wakaba 1.104 type => 'element missing',
4226     text => 'rt',
4227     level => $self->{level}->{must});
4228 wakaba 1.99 $self->{onerror}->(node => $item->{node},
4229 wakaba 1.104 type => 'element missing',
4230     text => 'rp',
4231     level => $self->{level}->{must});
4232 wakaba 1.99 } elsif ($element_state->{phase} eq 'after-rp-rt') {
4233     $self->{onerror}->(node => $item->{node},
4234 wakaba 1.104 type => 'element missing',
4235     text => 'rp',
4236     level => $self->{level}->{must});
4237 wakaba 1.99 } else {
4238     die "check_child_text: Bad |ruby| phase: $element_state->{phase}";
4239     }
4240    
4241     ## NOTE: A modified version of |check_end| of %AnyChecker.
4242     if ($element_state->{has_significant} or $element_state->{has_sig}) {
4243     $item->{real_parent_state}->{has_significant} = 1;
4244     }
4245     },
4246     };
4247    
4248     $Element->{$HTML_NS}->{rt} = {
4249     %HTMLPhrasingContentChecker,
4250 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
4251 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
4252     %HTMLAttrStatus,
4253     %HTMLM12NXHTML2CommonAttrStatus,
4254 wakaba 1.187 lang => FEATURE_HTML5_REC,
4255 wakaba 1.99 }),
4256     };
4257    
4258     $Element->{$HTML_NS}->{rp} = {
4259 wakaba 1.171 %HTMLPhrasingContentChecker,
4260 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
4261 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
4262     %HTMLAttrStatus,
4263     %HTMLM12NXHTML2CommonAttrStatus,
4264 wakaba 1.187 lang => FEATURE_HTML5_REC,
4265 wakaba 1.99 }),
4266 wakaba 1.171 }; # rp
4267 wakaba 1.99
4268 wakaba 1.29 =pod
4269    
4270     ## TODO:
4271    
4272     +
4273     + <p>Partly because of the confusion described above, authors are
4274     + strongly recommended to always mark up all paragraphs with the
4275     + <code>p</code> element, and to not have any <code>ins</code> or
4276     + <code>del</code> elements that cross across any <span
4277     + title="paragraph">implied paragraphs</span>.</p>
4278     +
4279     (An informative note)
4280    
4281     <p><code>ins</code> elements should not cross <span
4282     + title="paragraph">implied paragraph</span> boundaries.</p>
4283     (normative)
4284    
4285     + <p><code>del</code> elements should not cross <span
4286     + title="paragraph">implied paragraph</span> boundaries.</p>
4287     (normative)
4288    
4289     =cut
4290    
4291 wakaba 1.1 $Element->{$HTML_NS}->{ins} = {
4292 wakaba 1.40 %HTMLTransparentChecker,
4293 wakaba 1.187 status => FEATURE_HTML5_REC,
4294 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4295 wakaba 1.1 cite => $HTMLURIAttrChecker,
4296 wakaba 1.168 datetime => $GetDateTimeAttrChecker->('global_date_and_time_string'),
4297 wakaba 1.49 }, {
4298     %HTMLAttrStatus,
4299     %HTMLM12NCommonAttrStatus,
4300 wakaba 1.50 cite => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4301 wakaba 1.153 datetime => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4302 wakaba 1.187 lang => FEATURE_HTML5_REC,
4303 wakaba 1.1 }),
4304 wakaba 1.66 check_start => sub {
4305     my ($self, $item, $element_state) = @_;
4306    
4307     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
4308 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4309     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4310 wakaba 1.66 },
4311 wakaba 1.1 };
4312    
4313     $Element->{$HTML_NS}->{del} = {
4314 wakaba 1.40 %HTMLTransparentChecker,
4315 wakaba 1.187 status => FEATURE_HTML5_REC,
4316 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4317 wakaba 1.1 cite => $HTMLURIAttrChecker,
4318 wakaba 1.168 datetime => $GetDateTimeAttrChecker->('global_date_and_time_string'),
4319 wakaba 1.49 }, {
4320     %HTMLAttrStatus,
4321     %HTMLM12NCommonAttrStatus,
4322 wakaba 1.50 cite => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4323 wakaba 1.153 datetime => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4324 wakaba 1.187 lang => FEATURE_HTML5_REC,
4325 wakaba 1.1 }),
4326 wakaba 1.40 check_end => sub {
4327     my ($self, $item, $element_state) = @_;
4328     if ($element_state->{has_significant}) {
4329     ## NOTE: Significantness flag does not propagate.
4330     } elsif ($item->{transparent}) {
4331     #
4332     } else {
4333     $self->{onerror}->(node => $item->{node},
4334 wakaba 1.104 level => $self->{level}->{should},
4335 wakaba 1.40 type => 'no significant content');
4336     }
4337 wakaba 1.1 },
4338 wakaba 1.66 check_start => sub {
4339     my ($self, $item, $element_state) = @_;
4340    
4341     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
4342 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4343     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4344 wakaba 1.66 },
4345 wakaba 1.1 };
4346    
4347 wakaba 1.35 $Element->{$HTML_NS}->{figure} = {
4348 wakaba 1.72 %HTMLFlowContentChecker,
4349 wakaba 1.153 status => FEATURE_HTML5_WD,
4350 wakaba 1.72 ## NOTE: legend, Flow | Flow, legend?
4351 wakaba 1.41 check_child_element => sub {
4352     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4353     $child_is_transparent, $element_state) = @_;
4354 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4355     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4356 wakaba 1.41 $self->{onerror}->(node => $child_el,
4357     type => 'element not allowed:minus',
4358 wakaba 1.104 level => $self->{level}->{must});
4359 wakaba 1.41 $element_state->{has_non_legend} = 1;
4360 wakaba 1.181 $element_state->{has_non_table} = 1;
4361 wakaba 1.41 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4362 wakaba 1.181 $element_state->{has_non_table} = 1;
4363 wakaba 1.41 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'legend') {
4364     if ($element_state->{has_legend_at_first}) {
4365     $self->{onerror}->(node => $child_el,
4366     type => 'element not allowed:figure legend',
4367 wakaba 1.104 level => $self->{level}->{must});
4368 wakaba 1.41 } elsif ($element_state->{has_legend}) {
4369     $self->{onerror}->(node => $element_state->{has_legend},
4370     type => 'element not allowed:figure legend',
4371 wakaba 1.104 level => $self->{level}->{must});
4372 wakaba 1.41 $element_state->{has_legend} = $child_el;
4373     } elsif ($element_state->{has_non_legend}) {
4374     $element_state->{has_legend} = $child_el;
4375     } else {
4376     $element_state->{has_legend_at_first} = 1;
4377 wakaba 1.35 }
4378 wakaba 1.41 delete $element_state->{has_non_legend};
4379     } else {
4380 wakaba 1.181 if ($child_nsuri eq $HTML_NS and $child_ln eq 'table') {
4381     $element_state->{has_table}++;
4382     } else {
4383     $element_state->{has_non_table}++;
4384     }
4385 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4386 wakaba 1.43 $element_state->{has_non_legend} = 1 unless $child_is_transparent;
4387 wakaba 1.41 }
4388     },
4389     check_child_text => sub {
4390     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4391     if ($has_significant) {
4392     $element_state->{has_non_legend} = 1;
4393 wakaba 1.181 $element_state->{has_non_table}++;
4394 wakaba 1.35 }
4395 wakaba 1.170
4396     $element_state->{in_figure} = 1;
4397 wakaba 1.41 },
4398     check_end => sub {
4399     my ($self, $item, $element_state) = @_;
4400 wakaba 1.35
4401 wakaba 1.41 if ($element_state->{has_legend_at_first}) {
4402     #
4403     } elsif ($element_state->{has_legend}) {
4404     if ($element_state->{has_non_legend}) {
4405     $self->{onerror}->(node => $element_state->{has_legend},
4406 wakaba 1.35 type => 'element not allowed:figure legend',
4407 wakaba 1.104 level => $self->{level}->{must});
4408 wakaba 1.35 }
4409     }
4410 wakaba 1.41
4411 wakaba 1.181 if (($element_state->{has_table} || 0) == 1 and
4412     not $element_state->{has_non_table} and
4413     $element_state->{table_caption_element}) {
4414     $self->{onerror}->(node => $element_state->{table_caption_element},
4415     type => 'element not allowed',
4416     level => $self->{level}->{should});
4417     }
4418    
4419 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
4420 wakaba 1.41 ## ISSUE: |<figure><legend>aa</legend></figure>| should be an error?
4421 wakaba 1.35 },
4422     };
4423 wakaba 1.8 ## TODO: Test for <nest/> in <figure/>
4424 wakaba 1.1
4425 wakaba 1.92 my $AttrCheckerNotImplemented = sub {
4426     my ($self, $attr) = @_;
4427 wakaba 1.104 $self->{onerror}->(node => $attr,
4428     type => 'unknown attribute',
4429     level => $self->{level}->{uncertain});
4430 wakaba 1.92 };
4431    
4432 wakaba 1.1 $Element->{$HTML_NS}->{img} = {
4433 wakaba 1.40 %HTMLEmptyChecker,
4434 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4435 wakaba 1.40 check_attrs => sub {
4436     my ($self, $item, $element_state) = @_;
4437 wakaba 1.1 $GetHTMLAttrsChecker->({
4438 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
4439     bottom => 1, middle => 1, top => 1, left => 1, right => 1,
4440     }),
4441 wakaba 1.1 alt => sub { }, ## NOTE: No syntactical requirement
4442 wakaba 1.70 border => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4443 wakaba 1.1 src => $HTMLURIAttrChecker,
4444     usemap => $HTMLUsemapAttrChecker,
4445 wakaba 1.70 hspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4446 wakaba 1.1 ismap => sub {
4447 wakaba 1.40 my ($self, $attr, $parent_item) = @_;
4448     if (not $self->{flag}->{in_a_href}) {
4449 wakaba 1.15 $self->{onerror}->(node => $attr,
4450 wakaba 1.59 type => 'attribute not allowed:ismap',
4451 wakaba 1.104 level => $self->{level}->{must});
4452 wakaba 1.1 }
4453 wakaba 1.40 $GetHTMLBooleanAttrChecker->('ismap')->($self, $attr, $parent_item);
4454 wakaba 1.1 },
4455 wakaba 1.70 longdesc => $HTMLURIAttrChecker,
4456     ## TODO: HTML4 |name|
4457 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4458 wakaba 1.70 vspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4459 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4460 wakaba 1.49 }, {
4461     %HTMLAttrStatus,
4462 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
4463 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
4464 wakaba 1.153 alt => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4465 wakaba 1.49 border => FEATURE_M12N10_REC_DEPRECATED,
4466 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4467 wakaba 1.49 hspace => FEATURE_M12N10_REC_DEPRECATED,
4468 wakaba 1.153 ismap => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4469 wakaba 1.187 lang => FEATURE_HTML5_REC,
4470 wakaba 1.49 longdesc => FEATURE_M12N10_REC,
4471     name => FEATURE_M12N10_REC_DEPRECATED,
4472 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
4473 wakaba 1.153 src => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4474     usemap => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4475 wakaba 1.49 vspace => FEATURE_M12N10_REC_DEPRECATED,
4476 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4477 wakaba 1.66 })->($self, $item, $element_state);
4478 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'alt')) {
4479     $self->{onerror}->(node => $item->{node},
4480 wakaba 1.104 type => 'attribute missing',
4481     text => 'alt',
4482     level => $self->{level}->{should});
4483 wakaba 1.114 ## TODO: ...
4484 wakaba 1.1 }
4485 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'src')) {
4486     $self->{onerror}->(node => $item->{node},
4487 wakaba 1.104 type => 'attribute missing',
4488     text => 'src',
4489     level => $self->{level}->{must});
4490 wakaba 1.1 }
4491 wakaba 1.66
4492 wakaba 1.114 ## TODO: external resource check
4493    
4494 wakaba 1.66 $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4495     $element_state->{uri_info}->{lowsrc}->{type}->{embedded} = 1;
4496     $element_state->{uri_info}->{dynsrc}->{type}->{embedded} = 1;
4497     $element_state->{uri_info}->{longdesc}->{type}->{cite} = 1;
4498 wakaba 1.1 },
4499     };
4500    
4501     $Element->{$HTML_NS}->{iframe} = {
4502 wakaba 1.205 %HTMLTextChecker, # XXX content model restriction
4503 wakaba 1.114 status => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4504 wakaba 1.49 ## NOTE: Not part of M12N10 Strict
4505 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4506 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4507 wakaba 1.76 name => $HTMLBrowsingContextNameAttrChecker,
4508 wakaba 1.92 sandbox => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->({
4509     'allow-same-origin' => 1, 'allow-forms' => 1, 'allow-scripts' => 1,
4510     }),
4511     seemless => $GetHTMLBooleanAttrChecker->('seemless'),
4512 wakaba 1.1 src => $HTMLURIAttrChecker,
4513 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4514 wakaba 1.49 }, {
4515     %HTMLAttrStatus,
4516     %HTMLM12NCommonAttrStatus,
4517     align => FEATURE_XHTML10_REC,
4518 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4519 wakaba 1.49 frameborder => FEATURE_M12N10_REC,
4520 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4521 wakaba 1.187 id => FEATURE_HTML5_REC,
4522 wakaba 1.49 longdesc => FEATURE_M12N10_REC,
4523     marginheight => FEATURE_M12N10_REC,
4524     marginwidth => FEATURE_M12N10_REC,
4525 wakaba 1.114 #name => FEATURE_HTML5_WD | FEATURE_M12N10_REC_DEPRECATED,
4526     name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4527     sandbox => FEATURE_HTML5_WD,
4528 wakaba 1.49 scrolling => FEATURE_M12N10_REC,
4529 wakaba 1.114 seemless => FEATURE_HTML5_WD,
4530     src => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4531 wakaba 1.187 title => FEATURE_HTML5_REC,
4532 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4533 wakaba 1.1 }),
4534 wakaba 1.66 check_start => sub {
4535     my ($self, $item, $element_state) = @_;
4536    
4537     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4538 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4539     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4540 wakaba 1.66 },
4541 wakaba 1.40 };
4542    
4543 wakaba 1.1 $Element->{$HTML_NS}->{embed} = {
4544 wakaba 1.40 %HTMLEmptyChecker,
4545 wakaba 1.98 status => FEATURE_HTML5_WD,
4546 wakaba 1.40 check_attrs => sub {
4547     my ($self, $item, $element_state) = @_;
4548 wakaba 1.1 my $has_src;
4549 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
4550 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
4551     $attr_ns = '' unless defined $attr_ns;
4552     my $attr_ln = $attr->manakai_local_name;
4553     my $checker;
4554 wakaba 1.73
4555     my $status = {
4556     %HTMLAttrStatus,
4557 wakaba 1.153 height => FEATURE_HTML5_LC,
4558 wakaba 1.98 src => FEATURE_HTML5_WD,
4559     type => FEATURE_HTML5_WD,
4560 wakaba 1.153 width => FEATURE_HTML5_LC,
4561 wakaba 1.73 }->{$attr_ln};
4562    
4563 wakaba 1.1 if ($attr_ns eq '') {
4564     if ($attr_ln eq 'src') {
4565     $checker = $HTMLURIAttrChecker;
4566     $has_src = 1;
4567     } elsif ($attr_ln eq 'type') {
4568     $checker = $HTMLIMTAttrChecker;
4569 wakaba 1.92 } elsif ($attr_ln eq 'width' or $attr_ln eq 'height') {
4570 wakaba 1.178 $checker = $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 });
4571 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
4572     $attr_ln !~ /[A-Z]/) {
4573 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
4574     $status = $HTMLDatasetAttrStatus;
4575 wakaba 1.117 } elsif ($attr_ln !~ /^[Xx][Mm][Ll]/ and
4576 wakaba 1.118 $attr_ln !~ /[A-Z]/ and
4577 wakaba 1.117 $attr_ln =~ /\A\p{InXML_NCNameStartChar10}\p{InXMLNCNameChar10}*\z/) {
4578 wakaba 1.1 $checker = $HTMLAttrChecker->{$attr_ln}
4579     || sub { }; ## NOTE: Any local attribute is ok.
4580 wakaba 1.98 $status = FEATURE_HTML5_WD | FEATURE_ALLOWED;
4581 wakaba 1.117 } else {
4582     $checker = $HTMLAttrChecker->{$attr_ln};
4583 wakaba 1.1 }
4584     }
4585     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
4586 wakaba 1.82 || $AttrChecker->{$attr_ns}->{''};
4587     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
4588     || $AttrStatus->{$attr_ns}->{''};
4589     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
4590 wakaba 1.62
4591 wakaba 1.1 if ($checker) {
4592 wakaba 1.66 $checker->($self, $attr, $item, $element_state);
4593 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
4594 wakaba 1.54 #
4595 wakaba 1.1 } else {
4596 wakaba 1.104 $self->{onerror}->(node => $attr,
4597     type => 'unknown attribute',
4598     level => $self->{level}->{uncertain});
4599 wakaba 1.50 ## ISSUE: No conformance createria for global attributes in the spec
4600     }
4601    
4602 wakaba 1.82 $self->_attr_status_info ($attr, $status);
4603 wakaba 1.1 }
4604    
4605     unless ($has_src) {
4606 wakaba 1.40 $self->{onerror}->(node => $item->{node},
4607 wakaba 1.104 type => 'attribute missing',
4608     text => 'src',
4609 wakaba 1.114 level => $self->{level}->{info});
4610     ## NOTE: <embed> without src="" is allowed since revision 1929.
4611     ## We issues an informational message since <embed> w/o src=""
4612     ## is likely an authoring error.
4613 wakaba 1.1 }
4614 wakaba 1.114
4615     ## TODO: external resource check
4616 wakaba 1.66
4617     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4618 wakaba 1.1 },
4619     };
4620    
4621 wakaba 1.49 ## TODO:
4622     ## {applet} FEATURE_M12N10_REC_DEPRECATED
4623     ## class, id, title, alt, archive, code, codebase, height, object, width name style,hspace,vspace(xhtml10)
4624    
4625 wakaba 1.1 $Element->{$HTML_NS}->{object} = {
4626 wakaba 1.40 %HTMLTransparentChecker,
4627 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4628 wakaba 1.40 check_attrs => sub {
4629     my ($self, $item, $element_state) = @_;
4630 wakaba 1.1 $GetHTMLAttrsChecker->({
4631 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
4632     bottom => 1, middle => 1, top => 1, left => 1, right => 1,
4633     }),
4634     archive => $HTMLSpaceURIsAttrChecker,
4635     ## TODO: Relative to @codebase
4636     border => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4637     classid => $HTMLURIAttrChecker,
4638     codebase => $HTMLURIAttrChecker,
4639     codetype => $HTMLIMTAttrChecker,
4640     ## TODO: "RECOMMENDED when |classid| is specified" [HTML4]
4641 wakaba 1.1 data => $HTMLURIAttrChecker,
4642 wakaba 1.70 declare => $GetHTMLBooleanAttrChecker->('declare'),
4643     ## NOTE: "The object MUST be instantiated by a subsequent OBJECT ..."
4644     ## [HTML4] but we don't know how to test this.
4645 wakaba 1.167 form => $HTMLFormAttrChecker,
4646 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4647 wakaba 1.70 hspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4648 wakaba 1.76 name => $HTMLBrowsingContextNameAttrChecker,
4649 wakaba 1.167 ## NOTE: |name| attribute of the |object| element defines
4650     ## the name of the browsing context created by the element,
4651     ## if any, but is also used as the form control name of the
4652     ## form control provided by the plugin, if any.
4653 wakaba 1.70 standby => sub {}, ## NOTE: %Text; in HTML4
4654 wakaba 1.1 type => $HTMLIMTAttrChecker,
4655     usemap => $HTMLUsemapAttrChecker,
4656 wakaba 1.70 vspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4657 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4658 wakaba 1.49 }, {
4659     %HTMLAttrStatus,
4660 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
4661 wakaba 1.49 align => FEATURE_XHTML10_REC,
4662 wakaba 1.82 archive => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4663 wakaba 1.49 border => FEATURE_XHTML10_REC,
4664     classid => FEATURE_M12N10_REC,
4665     codebase => FEATURE_M12N10_REC,
4666     codetype => FEATURE_M12N10_REC,
4667 wakaba 1.82 'content-length' => FEATURE_XHTML2_ED,
4668 wakaba 1.153 data => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4669 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
4670     dataformatas => FEATURE_HTML4_REC_RESERVED,
4671     datasrc => FEATURE_HTML4_REC_RESERVED,
4672 wakaba 1.82 declare => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4673 wakaba 1.187 form => FEATURE_HTML5_LC,
4674 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4675 wakaba 1.49 hspace => FEATURE_XHTML10_REC,
4676 wakaba 1.187 lang => FEATURE_HTML5_REC,
4677 wakaba 1.153 name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4678 wakaba 1.49 standby => FEATURE_M12N10_REC,
4679 wakaba 1.50 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4680 wakaba 1.153 type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4681     usemap => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4682 wakaba 1.49 vspace => FEATURE_XHTML10_REC,
4683 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4684 wakaba 1.66 })->($self, $item, $element_state);
4685 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'data')) {
4686     unless ($item->{node}->has_attribute_ns (undef, 'type')) {
4687     $self->{onerror}->(node => $item->{node},
4688 wakaba 1.104 type => 'attribute missing:data|type',
4689     level => $self->{level}->{must});
4690 wakaba 1.1 }
4691     }
4692 wakaba 1.66
4693     $element_state->{uri_info}->{data}->{type}->{embedded} = 1;
4694     $element_state->{uri_info}->{classid}->{type}->{embedded} = 1;
4695     $element_state->{uri_info}->{codebase}->{type}->{base} = 1;
4696     ## TODO: archive
4697     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
4698 wakaba 1.1 },
4699 wakaba 1.72 ## NOTE: param*, transparent (Flow)
4700 wakaba 1.41 check_child_element => sub {
4701     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4702     $child_is_transparent, $element_state) = @_;
4703 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4704     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4705 wakaba 1.41 $self->{onerror}->(node => $child_el,
4706     type => 'element not allowed:minus',
4707 wakaba 1.104 level => $self->{level}->{must});
4708 wakaba 1.41 $element_state->{has_non_legend} = 1;
4709     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4710     #
4711     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'param') {
4712     if ($element_state->{has_non_param}) {
4713 wakaba 1.104 $self->{onerror}->(node => $child_el,
4714 wakaba 1.72 type => 'element not allowed:flow',
4715 wakaba 1.104 level => $self->{level}->{must});
4716 wakaba 1.39 }
4717 wakaba 1.41 } else {
4718 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4719 wakaba 1.41 $element_state->{has_non_param} = 1;
4720 wakaba 1.39 }
4721 wakaba 1.25 },
4722 wakaba 1.41 check_child_text => sub {
4723     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4724     if ($has_significant) {
4725     $element_state->{has_non_param} = 1;
4726     }
4727 wakaba 1.42 },
4728     check_end => sub {
4729     my ($self, $item, $element_state) = @_;
4730     if ($element_state->{has_significant}) {
4731 wakaba 1.46 $item->{real_parent_state}->{has_significant} = 1;
4732 wakaba 1.42 } elsif ($item->{node}->manakai_parent_element) {
4733     ## NOTE: Transparent.
4734     } else {
4735     $self->{onerror}->(node => $item->{node},
4736 wakaba 1.104 level => $self->{level}->{should},
4737 wakaba 1.42 type => 'no significant content');
4738     }
4739     },
4740 wakaba 1.8 ## TODO: Tests for <nest/> in <object/>
4741 wakaba 1.1 };
4742 wakaba 1.41 ## ISSUE: Is |<menu><object data><li>aa</li></object></menu>| conforming?
4743     ## What about |<section><object data><style scoped></style>x</object></section>|?
4744     ## |<section><ins></ins><object data><style scoped></style>x</object></section>|?
4745 wakaba 1.1
4746     $Element->{$HTML_NS}->{param} = {
4747 wakaba 1.40 %HTMLEmptyChecker,
4748 wakaba 1.187 status => FEATURE_HTML5_REC,
4749 wakaba 1.40 check_attrs => sub {
4750     my ($self, $item, $element_state) = @_;
4751 wakaba 1.1 $GetHTMLAttrsChecker->({
4752     name => sub { },
4753 wakaba 1.70 type => $HTMLIMTAttrChecker,
4754 wakaba 1.1 value => sub { },
4755 wakaba 1.70 valuetype => $GetHTMLEnumeratedAttrChecker->({
4756     data => 1, ref => 1, object => 1,
4757     }),
4758 wakaba 1.49 }, {
4759     %HTMLAttrStatus,
4760 wakaba 1.154 href => FEATURE_RDFA_REC,
4761 wakaba 1.187 id => FEATURE_HTML5_REC,
4762 wakaba 1.153 name => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4763 wakaba 1.82 type => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4764 wakaba 1.153 value => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4765 wakaba 1.82 valuetype => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4766 wakaba 1.66 })->(@_);
4767 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'name')) {
4768     $self->{onerror}->(node => $item->{node},
4769 wakaba 1.104 type => 'attribute missing',
4770     text => 'name',
4771     level => $self->{level}->{must});
4772 wakaba 1.1 }
4773 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'value')) {
4774     $self->{onerror}->(node => $item->{node},
4775 wakaba 1.104 type => 'attribute missing',
4776     text => 'value',
4777     level => $self->{level}->{must});
4778 wakaba 1.1 }
4779     },
4780     };
4781    
4782     $Element->{$HTML_NS}->{video} = {
4783 wakaba 1.40 %HTMLTransparentChecker,
4784 wakaba 1.48 status => FEATURE_HTML5_LC,
4785 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4786 wakaba 1.183 autobuffer => $GetHTMLBooleanAttrChecker->('autobuffer'),
4787 wakaba 1.205 autoplay => sub {
4788     my ($self, $attr) = @_;
4789    
4790     ## "Authors are also encouraged to consider not using the
4791     ## automatic playback behavior at all" according to HTML5.
4792     $self->{onerror}->(node => $attr,
4793     type => 'attribute not allowed',
4794     level => $self->{level}->{warn});
4795    
4796     $GetHTMLBooleanAttrChecker->('autoplay')->(@_);
4797     },
4798 wakaba 1.1 controls => $GetHTMLBooleanAttrChecker->('controls'),
4799 wakaba 1.209 end => sub { },
4800     height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4801     loop => $GetHTMLBooleanAttrChecker->('loop'),
4802     loopend => sub { },
4803     loopstart => sub { },
4804     playcount => sub { },
4805 wakaba 1.59 poster => $HTMLURIAttrChecker,
4806 wakaba 1.209 src => $HTMLURIAttrChecker,
4807     start => sub { },
4808 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4809 wakaba 1.209
4810     ## NOTE: |start|, |end|, |loopstart|, |loopend|, and |playcount|
4811     ## attributes has been deleted from the spec before the exact
4812     ## author requirement is defined.
4813 wakaba 1.50 }, {
4814     %HTMLAttrStatus,
4815 wakaba 1.183 autobuffer => FEATURE_HTML5_LC,
4816 wakaba 1.50 autoplay => FEATURE_HTML5_LC,
4817     controls => FEATURE_HTML5_LC,
4818 wakaba 1.209 end => FEATURE_HTML5_DROPPED,
4819 wakaba 1.50 height => FEATURE_HTML5_LC,
4820 wakaba 1.209 loop => FEATURE_HTML5_LC,
4821     loopend => FEATURE_HTML5_DROPPED,
4822     loopstart => FEATURE_HTML5_DROPPED,
4823     playcount => FEATURE_HTML5_DROPPED,
4824 wakaba 1.50 poster => FEATURE_HTML5_LC,
4825     src => FEATURE_HTML5_LC,
4826 wakaba 1.209 start => FEATURE_HTML5_DROPPED,
4827 wakaba 1.50 width => FEATURE_HTML5_LC,
4828 wakaba 1.209 }), # check_attrs
4829 wakaba 1.42 check_start => sub {
4830     my ($self, $item, $element_state) = @_;
4831     $element_state->{allow_source}
4832     = not $item->{node}->has_attribute_ns (undef, 'src');
4833     $element_state->{has_source} ||= $element_state->{allow_source} * -1;
4834     ## NOTE: It might be set true by |check_element|.
4835 wakaba 1.66
4836     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4837     $element_state->{uri_info}->{poster}->{type}->{embedded} = 1;
4838 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4839     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4840 wakaba 1.42 },
4841     check_child_element => sub {
4842     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4843     $child_is_transparent, $element_state) = @_;
4844 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4845     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4846 wakaba 1.42 $self->{onerror}->(node => $child_el,
4847     type => 'element not allowed:minus',
4848 wakaba 1.104 level => $self->{level}->{must});
4849 wakaba 1.42 delete $element_state->{allow_source};
4850     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4851     #
4852     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'source') {
4853 wakaba 1.45 unless ($element_state->{allow_source}) {
4854 wakaba 1.104 $self->{onerror}->(node => $child_el,
4855 wakaba 1.72 type => 'element not allowed:flow',
4856 wakaba 1.104 level => $self->{level}->{must});
4857 wakaba 1.42 }
4858 wakaba 1.45 $element_state->{has_source} = 1;
4859 wakaba 1.1 } else {
4860 wakaba 1.42 delete $element_state->{allow_source};
4861 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4862 wakaba 1.42 }
4863     },
4864     check_child_text => sub {
4865     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4866     if ($has_significant) {
4867     delete $element_state->{allow_source};
4868     }
4869 wakaba 1.72 $HTMLFlowContentChecker{check_child_text}->(@_);
4870 wakaba 1.42 },
4871     check_end => sub {
4872     my ($self, $item, $element_state) = @_;
4873     if ($element_state->{has_source} == -1) {
4874     $self->{onerror}->(node => $item->{node},
4875 wakaba 1.104 type => 'child element missing',
4876     text => 'source',
4877     level => $self->{level}->{must});
4878 wakaba 1.1 }
4879 wakaba 1.42
4880     $Element->{$HTML_NS}->{object}->{check_end}->(@_);
4881 wakaba 1.1 },
4882 wakaba 1.209 }; # video
4883 wakaba 1.1
4884     $Element->{$HTML_NS}->{audio} = {
4885 wakaba 1.40 %{$Element->{$HTML_NS}->{video}},
4886 wakaba 1.48 status => FEATURE_HTML5_LC,
4887 wakaba 1.42 check_attrs => $GetHTMLAttrsChecker->({
4888 wakaba 1.183 autobuffer => $GetHTMLBooleanAttrChecker->('autobuffer'),
4889 wakaba 1.205 autoplay => sub {
4890     my ($self, $attr) = @_;
4891    
4892     ## "Authors are also encouraged to consider not using the
4893     ## automatic playback behavior at all" according to HTML5.
4894     $self->{onerror}->(node => $attr,
4895     type => 'attribute not allowed',
4896     level => $self->{level}->{warn});
4897    
4898     $GetHTMLBooleanAttrChecker->('autoplay')->(@_);
4899     },
4900 wakaba 1.42 controls => $GetHTMLBooleanAttrChecker->('controls'),
4901 wakaba 1.209 end => sub { },
4902     loop => $GetHTMLBooleanAttrChecker->('loop'),
4903     loopend => sub { },
4904     loopstart => sub { },
4905     playcount => sub { },
4906     src => $HTMLURIAttrChecker,
4907     start => sub { },
4908    
4909     ## NOTE: |start|, |end|, |loopstart|, |loopend|, and |playcount|
4910     ## attributes has been deleted from the spec before the exact
4911     ## author requirement is defined.
4912 wakaba 1.50 }, {
4913     %HTMLAttrStatus,
4914 wakaba 1.183 autobuffer => FEATURE_HTML5_LC,
4915 wakaba 1.50 autoplay => FEATURE_HTML5_LC,
4916     controls => FEATURE_HTML5_LC,
4917 wakaba 1.209 end => FEATURE_HTML5_DROPPED,
4918     loop => FEATURE_HTML5_LC,
4919     loopend => FEATURE_HTML5_DROPPED,
4920     loopstart => FEATURE_HTML5_DROPPED,
4921     playcount => FEATURE_HTML5_DROPPED,
4922 wakaba 1.50 src => FEATURE_HTML5_LC,
4923 wakaba 1.209 start => FEATURE_HTML5_DROPPED,
4924     }), # check_attrs
4925     }; # audio
4926 wakaba 1.1
4927     $Element->{$HTML_NS}->{source} = {
4928 wakaba 1.40 %HTMLEmptyChecker,
4929 wakaba 1.153 status => FEATURE_HTML5_LC,
4930 wakaba 1.40 check_attrs => sub {
4931     my ($self, $item, $element_state) = @_;
4932 wakaba 1.1 $GetHTMLAttrsChecker->({
4933 wakaba 1.90 media => $HTMLMQAttrChecker,
4934 wakaba 1.206 pixelratio => $PositiveFloatingPointNumberAttrChecker,
4935     src => $HTMLURIAttrChecker,
4936 wakaba 1.1 type => $HTMLIMTAttrChecker,
4937 wakaba 1.50 }, {
4938     %HTMLAttrStatus,
4939 wakaba 1.153 media => FEATURE_HTML5_LC,
4940 wakaba 1.206 pixelratio => FEATURE_HTML5_DROPPED,
4941 wakaba 1.153 src => FEATURE_HTML5_LC,
4942     type => FEATURE_HTML5_LC,
4943 wakaba 1.66 })->(@_);
4944 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'src')) {
4945     $self->{onerror}->(node => $item->{node},
4946 wakaba 1.104 type => 'attribute missing',
4947     text => 'src',
4948     level => $self->{level}->{must});
4949 wakaba 1.1 }
4950 wakaba 1.66
4951     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4952 wakaba 1.206
4953     ## NOTE: The |pixelratio| attribute should have been forbidden
4954     ## when the parent of the |source| element is an |audio| element,
4955     ## but the attribute itself has been dropped from the spec.
4956 wakaba 1.1 },
4957 wakaba 1.206 }; # source
4958 wakaba 1.1
4959     $Element->{$HTML_NS}->{canvas} = {
4960 wakaba 1.40 %HTMLTransparentChecker,
4961 wakaba 1.187 status => FEATURE_HTML5_REC,
4962 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4963 wakaba 1.1 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4964     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4965 wakaba 1.50 }, {
4966     %HTMLAttrStatus,
4967 wakaba 1.187 height => FEATURE_HTML5_REC,
4968     width => FEATURE_HTML5_REC,
4969 wakaba 1.1 }),
4970 wakaba 1.178
4971     # Authors MUST provide alternative content (HTML5 revision 2868) -
4972     # This requirement cannot be checked, since the alternative content
4973     # might be placed outside of the element.
4974     }; # canvas
4975 wakaba 1.1
4976     $Element->{$HTML_NS}->{map} = {
4977 wakaba 1.72 %HTMLFlowContentChecker,
4978 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4979 wakaba 1.40 check_attrs => sub {
4980     my ($self, $item, $element_state) = @_;
4981 wakaba 1.100 my $has_name;
4982 wakaba 1.4 $GetHTMLAttrsChecker->({
4983 wakaba 1.100 name => sub {
4984     my ($self, $attr) = @_;
4985     my $value = $attr->value;
4986     if (length $value) {
4987 wakaba 1.210 if ($value =~ /[\x09\x0A\x0C\x0D\x20]/) {
4988     $self->{onerror}->(node => $attr, type => 'space in map name',
4989     level => $self->{level}->{must}); ## XXX documentation
4990     }
4991    
4992     ## XXXNOTE: Duplication is not non-conforming.
4993 wakaba 1.100 } else {
4994     $self->{onerror}->(node => $attr,
4995     type => 'empty attribute value',
4996 wakaba 1.104 level => $self->{level}->{must});
4997 wakaba 1.100 }
4998 wakaba 1.4 $self->{map}->{$value} ||= $attr;
4999 wakaba 1.100 $has_name = [$value, $attr];
5000 wakaba 1.4 },
5001 wakaba 1.49 }, {
5002     %HTMLAttrStatus,
5003 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5004     dir => FEATURE_HTML5_REC,
5005     id => FEATURE_HTML5_REC,
5006     lang => FEATURE_HTML5_REC,
5007 wakaba 1.153 #name => FEATURE_HTML5_LC | FEATURE_M12N10_REC_DEPRECATED,
5008     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5009 wakaba 1.50 onclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5010     ondblclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5011     onmousedown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5012     onmouseup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5013     onmouseover => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5014     onmousemove => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5015     onmouseout => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5016     onkeypress => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5017     onkeydown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5018     onkeyup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5019 wakaba 1.187 title => FEATURE_HTML5_REC,
5020 wakaba 1.66 })->(@_);
5021 wakaba 1.100
5022 wakaba 1.135 if ($has_name) {
5023 wakaba 1.145 my $id = $item->{node}->get_attribute_ns (undef, 'id');
5024 wakaba 1.135 if (defined $id and $has_name->[0] ne $id) {
5025 wakaba 1.155 $self->{onerror}
5026     ->(node => $item->{node}->get_attribute_node_ns (undef, 'id'),
5027     type => 'id ne name',
5028     level => $self->{level}->{must});
5029 wakaba 1.100 }
5030 wakaba 1.135 } else {
5031 wakaba 1.100 $self->{onerror}->(node => $item->{node},
5032 wakaba 1.104 type => 'attribute missing',
5033     text => 'name',
5034     level => $self->{level}->{must});
5035 wakaba 1.100 }
5036 wakaba 1.4 },
5037 wakaba 1.59 check_start => sub {
5038     my ($self, $item, $element_state) = @_;
5039     $element_state->{in_map_original} = $self->{flag}->{in_map};
5040 wakaba 1.137 $self->{flag}->{in_map} = [@{$self->{flag}->{in_map} or []}, {}];
5041     ## NOTE: |{in_map}| is a reference to the array which contains
5042     ## hash references. Hashes are corresponding to the opening
5043     ## |map| elements and each of them contains the key-value
5044     ## pairs corresponding to the absolute URLs for the processed
5045     ## |area| elements in the |map| element corresponding to the
5046     ## hash. The key represents the resource (## TODO: use
5047     ## absolute URL), while the value represents whether there is
5048     ## an |area| element whose |alt| attribute is specified to a
5049     ## non-empty value. If there IS such an |area| element for
5050     ## the resource specified by the key, then the value is set to
5051     ## zero (|0|). Otherwise, if there is no such an |area|
5052     ## element but there is any |area| element with the empty
5053     ## |alt=""| attribute, then the value contains an array
5054     ## reference that contains all of such |area| elements.
5055 wakaba 1.79
5056     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5057     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5058 wakaba 1.59 },
5059     check_end => sub {
5060     my ($self, $item, $element_state) = @_;
5061 wakaba 1.137
5062     for (keys %{$self->{flag}->{in_map}->[-1]}) {
5063     my $nodes = $self->{flag}->{in_map}->[-1]->{$_};
5064     next unless $nodes;
5065     for (@$nodes) {
5066     $self->{onerror}->(type => 'empty area alt',
5067     node => $_,
5068     level => $self->{level}->{html5_no_may});
5069     }
5070     }
5071    
5072     $self->{flag}->{in_map} = $element_state->{in_map_original};
5073    
5074 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
5075 wakaba 1.59 },
5076 wakaba 1.1 };
5077    
5078     $Element->{$HTML_NS}->{area} = {
5079 wakaba 1.40 %HTMLEmptyChecker,
5080 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5081 wakaba 1.40 check_attrs => sub {
5082     my ($self, $item, $element_state) = @_;
5083 wakaba 1.1 my %attr;
5084     my $coords;
5085 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
5086 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
5087     $attr_ns = '' unless defined $attr_ns;
5088     my $attr_ln = $attr->manakai_local_name;
5089     my $checker;
5090 wakaba 1.73 my $status;
5091 wakaba 1.1 if ($attr_ns eq '') {
5092 wakaba 1.73 $status = {
5093     %HTMLAttrStatus,
5094     %HTMLM12NCommonAttrStatus,
5095 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
5096 wakaba 1.153 alt => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5097     coords => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5098 wakaba 1.154 href => FEATURE_HTML5_WD | FEATURE_RDFA_REC | FEATURE_M12N10_REC,
5099 wakaba 1.153 hreflang => FEATURE_HTML5_WD,
5100 wakaba 1.187 lang => FEATURE_HTML5_REC,
5101 wakaba 1.154 media => FEATURE_HTML5_WD,
5102 wakaba 1.73 nohref => FEATURE_M12N10_REC,
5103     onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5104     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5105 wakaba 1.153 ping => FEATURE_HTML5_WD,
5106 wakaba 1.154 rel => FEATURE_HTML5_WD | FEATURE_RDFA_REC,
5107 wakaba 1.153 shape => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5108 wakaba 1.73 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5109 wakaba 1.153 target => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5110     type => FEATURE_HTML5_WD,
5111 wakaba 1.73 }->{$attr_ln};
5112    
5113 wakaba 1.1 $checker = {
5114 wakaba 1.153 alt => sub {
5115     ## NOTE: Checked later.
5116     },
5117 wakaba 1.1 shape => $GetHTMLEnumeratedAttrChecker->({
5118     circ => -1, circle => 1,
5119     default => 1,
5120     poly => 1, polygon => -1,
5121     rect => 1, rectangle => -1,
5122     }),
5123     coords => sub {
5124     my ($self, $attr) = @_;
5125     my $value = $attr->value;
5126     if ($value =~ /\A-?[0-9]+(?>,-?[0-9]+)*\z/) {
5127     $coords = [split /,/, $value];
5128     } else {
5129     $self->{onerror}->(node => $attr,
5130 wakaba 1.104 type => 'coords:syntax error',
5131     level => $self->{level}->{must});
5132 wakaba 1.1 }
5133     },
5134 wakaba 1.70 nohref => $GetHTMLBooleanAttrChecker->('nohref'),
5135     target => $HTMLTargetAttrChecker,
5136 wakaba 1.1 href => $HTMLURIAttrChecker,
5137     ping => $HTMLSpaceURIsAttrChecker,
5138 wakaba 1.40 rel => sub { $HTMLLinkTypesAttrChecker->(1, $item, @_) },
5139 wakaba 1.1 media => $HTMLMQAttrChecker,
5140     hreflang => $HTMLLanguageTagAttrChecker,
5141     type => $HTMLIMTAttrChecker,
5142     }->{$attr_ln};
5143     if ($checker) {
5144     $attr{$attr_ln} = $attr;
5145 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
5146     $attr_ln !~ /[A-Z]/) {
5147 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
5148     $status = $HTMLDatasetAttrStatus;
5149 wakaba 1.1 } else {
5150     $checker = $HTMLAttrChecker->{$attr_ln};
5151     }
5152     }
5153     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
5154 wakaba 1.82 || $AttrChecker->{$attr_ns}->{''};
5155     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
5156     || $AttrStatus->{$attr_ns}->{''};
5157     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
5158 wakaba 1.62
5159 wakaba 1.1 if ($checker) {
5160 wakaba 1.66 $checker->($self, $attr, $item, $element_state) if ref $checker;
5161 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
5162 wakaba 1.54 #
5163 wakaba 1.1 } else {
5164 wakaba 1.104 $self->{onerror}->(node => $attr,
5165     type => 'unknown attribute',
5166     level => $self->{level}->{uncertain});
5167 wakaba 1.1 ## ISSUE: No comformance createria for unknown attributes in the spec
5168     }
5169 wakaba 1.49
5170 wakaba 1.82 $self->_attr_status_info ($attr, $status);
5171 wakaba 1.1 }
5172    
5173     if (defined $attr{href}) {
5174 wakaba 1.4 $self->{has_hyperlink_element} = 1;
5175 wakaba 1.137 if (defined $attr{alt}) {
5176     my $url = $attr{href}->value; ## TODO: resolve
5177     if (length $attr{alt}->value) {
5178     for (@{$self->{flag}->{in_map} or []}) {
5179     $_->{$url} = 0;
5180     }
5181     } else {
5182     ## NOTE: Empty |alt=""|. If there is another |area| element
5183     ## with the same |href=""| and that |area| elemnet's
5184     ## |alt=""| attribute is not an empty string, then this
5185     ## is conforming.
5186     for (@{$self->{flag}->{in_map} or []}) {
5187     push @{$_->{$url} ||= []}, $attr{alt}
5188     unless exists $_->{$url} and not $_->{$url};
5189     }
5190     }
5191     } else {
5192 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5193 wakaba 1.104 type => 'attribute missing',
5194     text => 'alt',
5195     level => $self->{level}->{must});
5196 wakaba 1.1 }
5197     } else {
5198     for (qw/target ping rel media hreflang type alt/) {
5199     if (defined $attr{$_}) {
5200     $self->{onerror}->(node => $attr{$_},
5201 wakaba 1.104 type => 'attribute not allowed',
5202     level => $self->{level}->{must});
5203 wakaba 1.1 }
5204     }
5205     }
5206    
5207     my $shape = 'rectangle';
5208     if (defined $attr{shape}) {
5209     $shape = {
5210     circ => 'circle', circle => 'circle',
5211     default => 'default',
5212     poly => 'polygon', polygon => 'polygon',
5213     rect => 'rectangle', rectangle => 'rectangle',
5214     }->{lc $attr{shape}->value} || 'rectangle';
5215     ## TODO: ASCII lowercase?
5216     }
5217    
5218     if ($shape eq 'circle') {
5219     if (defined $attr{coords}) {
5220     if (defined $coords) {
5221     if (@$coords == 3) {
5222     if ($coords->[2] < 0) {
5223     $self->{onerror}->(node => $attr{coords},
5224 wakaba 1.104 type => 'coords:out of range',
5225     index => 2,
5226     value => $coords->[2],
5227     level => $self->{level}->{must});
5228 wakaba 1.1 }
5229     } else {
5230     $self->{onerror}->(node => $attr{coords},
5231 wakaba 1.104 type => 'coords:number not 3',
5232     text => 0+@$coords,
5233     level => $self->{level}->{must});
5234 wakaba 1.1 }
5235     } else {
5236     ## NOTE: A syntax error has been reported.
5237     }
5238     } else {
5239 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5240 wakaba 1.104 type => 'attribute missing',
5241     text => 'coords',
5242     level => $self->{level}->{must});
5243 wakaba 1.1 }
5244     } elsif ($shape eq 'default') {
5245     if (defined $attr{coords}) {
5246     $self->{onerror}->(node => $attr{coords},
5247 wakaba 1.104 type => 'attribute not allowed',
5248     level => $self->{level}->{must});
5249 wakaba 1.1 }
5250     } elsif ($shape eq 'polygon') {
5251     if (defined $attr{coords}) {
5252     if (defined $coords) {
5253     if (@$coords >= 6) {
5254     unless (@$coords % 2 == 0) {
5255     $self->{onerror}->(node => $attr{coords},
5256 wakaba 1.104 type => 'coords:number not even',
5257     text => 0+@$coords,
5258     level => $self->{level}->{must});
5259 wakaba 1.1 }
5260     } else {
5261     $self->{onerror}->(node => $attr{coords},
5262 wakaba 1.104 type => 'coords:number lt 6',
5263     text => 0+@$coords,
5264     level => $self->{level}->{must});
5265 wakaba 1.1 }
5266     } else {
5267     ## NOTE: A syntax error has been reported.
5268     }
5269     } else {
5270 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5271 wakaba 1.104 type => 'attribute missing',
5272     text => 'coords',
5273     level => $self->{level}->{must});
5274 wakaba 1.1 }
5275     } elsif ($shape eq 'rectangle') {
5276     if (defined $attr{coords}) {
5277     if (defined $coords) {
5278     if (@$coords == 4) {
5279     unless ($coords->[0] < $coords->[2]) {
5280     $self->{onerror}->(node => $attr{coords},
5281 wakaba 1.104 type => 'coords:out of range',
5282     index => 0,
5283     value => $coords->[0],
5284     level => $self->{level}->{must});
5285 wakaba 1.1 }
5286     unless ($coords->[1] < $coords->[3]) {
5287     $self->{onerror}->(node => $attr{coords},
5288 wakaba 1.104 type => 'coords:out of range',
5289     index => 1,
5290     value => $coords->[1],
5291     level => $self->{level}->{must});
5292 wakaba 1.1 }
5293     } else {
5294     $self->{onerror}->(node => $attr{coords},
5295 wakaba 1.104 type => 'coords:number not 4',
5296     text => 0+@$coords,
5297     level => $self->{level}->{must});
5298 wakaba 1.1 }
5299     } else {
5300     ## NOTE: A syntax error has been reported.
5301     }
5302     } else {
5303 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5304 wakaba 1.104 type => 'attribute missing',
5305     text => 'coords',
5306     level => $self->{level}->{must});
5307 wakaba 1.1 }
5308     }
5309 wakaba 1.66
5310     $element_state->{uri_info}->{href}->{type}->{hyperlink} = 1;
5311 wakaba 1.1 },
5312 wakaba 1.59 check_start => sub {
5313     my ($self, $item, $element_state) = @_;
5314     unless ($self->{flag}->{in_map} or
5315     not $item->{node}->manakai_parent_element) {
5316     $self->{onerror}->(node => $item->{node},
5317     type => 'element not allowed:area',
5318 wakaba 1.104 level => $self->{level}->{must});
5319 wakaba 1.59 }
5320 wakaba 1.79
5321     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5322     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5323 wakaba 1.59 },
5324 wakaba 1.1 };
5325    
5326     $Element->{$HTML_NS}->{table} = {
5327 wakaba 1.40 %HTMLChecker,
5328 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5329 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5330 wakaba 1.86 cellpadding => $HTMLLengthAttrChecker,
5331     cellspacing => $HTMLLengthAttrChecker,
5332 wakaba 1.69 frame => $GetHTMLEnumeratedAttrChecker->({
5333     void => 1, above => 1, below => 1, hsides => 1, vsides => 1,
5334     lhs => 1, rhs => 1, box => 1, border => 1,
5335     }),
5336     rules => $GetHTMLEnumeratedAttrChecker->({
5337     none => 1, groups => 1, rows => 1, cols => 1, all => 1,
5338     }),
5339     summary => sub {}, ## NOTE: %Text; in HTML4.
5340     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }), ## %Pixels;
5341     }, {
5342 wakaba 1.49 %HTMLAttrStatus,
5343 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5344 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
5345     bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5346     border => FEATURE_M12N10_REC,
5347     cellpadding => FEATURE_M12N10_REC,
5348     cellspacing => FEATURE_M12N10_REC,
5349 wakaba 1.61 cols => FEATURE_RFC1942,
5350 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
5351     dataformatas => FEATURE_HTML4_REC_RESERVED,
5352     datapagesize => FEATURE_M12N10_REC,
5353     datasrc => FEATURE_HTML4_REC_RESERVED,
5354     frame => FEATURE_M12N10_REC,
5355 wakaba 1.187 lang => FEATURE_HTML5_REC,
5356 wakaba 1.49 rules => FEATURE_M12N10_REC,
5357     summary => FEATURE_M12N10_REC,
5358     width => FEATURE_M12N10_REC,
5359     }),
5360 wakaba 1.40 check_start => sub {
5361     my ($self, $item, $element_state) = @_;
5362     $element_state->{phase} = 'before caption';
5363 wakaba 1.66
5364     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
5365 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5366     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5367 wakaba 1.40 },
5368     check_child_element => sub {
5369     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5370     $child_is_transparent, $element_state) = @_;
5371 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5372     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5373 wakaba 1.40 $self->{onerror}->(node => $child_el,
5374     type => 'element not allowed:minus',
5375 wakaba 1.104 level => $self->{level}->{must});
5376 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5377     #
5378     } elsif ($element_state->{phase} eq 'in tbodys') {
5379     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5380     #$element_state->{phase} = 'in tbodys';
5381     } elsif (not $element_state->{has_tfoot} and
5382     $child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5383     $element_state->{phase} = 'after tfoot';
5384     $element_state->{has_tfoot} = 1;
5385     } else {
5386 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5387     level => $self->{level}->{must});
5388 wakaba 1.40 }
5389     } elsif ($element_state->{phase} eq 'in trs') {
5390     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5391     #$element_state->{phase} = 'in trs';
5392     } elsif (not $element_state->{has_tfoot} and
5393     $child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5394     $element_state->{phase} = 'after tfoot';
5395     $element_state->{has_tfoot} = 1;
5396     } else {
5397 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5398     level => $self->{level}->{must});
5399 wakaba 1.40 }
5400     } elsif ($element_state->{phase} eq 'after thead') {
5401     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5402     $element_state->{phase} = 'in tbodys';
5403     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5404     $element_state->{phase} = 'in trs';
5405     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5406     $element_state->{phase} = 'in tbodys';
5407     $element_state->{has_tfoot} = 1;
5408     } else {
5409 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5410     level => $self->{level}->{must});
5411 wakaba 1.40 }
5412     } elsif ($element_state->{phase} eq 'in colgroup') {
5413     if ($child_nsuri eq $HTML_NS and $child_ln eq 'colgroup') {
5414     $element_state->{phase} = 'in colgroup';
5415     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'thead') {
5416     $element_state->{phase} = 'after thead';
5417     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5418     $element_state->{phase} = 'in tbodys';
5419     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5420     $element_state->{phase} = 'in trs';
5421     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5422     $element_state->{phase} = 'in tbodys';
5423     $element_state->{has_tfoot} = 1;
5424     } else {
5425 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5426     level => $self->{level}->{must});
5427 wakaba 1.40 }
5428     } elsif ($element_state->{phase} eq 'before caption') {
5429     if ($child_nsuri eq $HTML_NS and $child_ln eq 'caption') {
5430 wakaba 1.181 $item->{parent_state}->{table_caption_element} = $child_el;
5431 wakaba 1.40 $element_state->{phase} = 'in colgroup';
5432     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'colgroup') {
5433     $element_state->{phase} = 'in colgroup';
5434     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'thead') {
5435     $element_state->{phase} = 'after thead';
5436     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5437     $element_state->{phase} = 'in tbodys';
5438     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5439     $element_state->{phase} = 'in trs';
5440     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5441     $element_state->{phase} = 'in tbodys';
5442     $element_state->{has_tfoot} = 1;
5443     } else {
5444 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5445     level => $self->{level}->{must});
5446 wakaba 1.40 }
5447     } elsif ($element_state->{phase} eq 'after tfoot') {
5448 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5449     level => $self->{level}->{must});
5450 wakaba 1.40 } else {
5451     die "check_child_element: Bad |table| phase: $element_state->{phase}";
5452     }
5453     },
5454     check_child_text => sub {
5455     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5456     if ($has_significant) {
5457 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5458     level => $self->{level}->{must});
5459 wakaba 1.1 }
5460 wakaba 1.40 },
5461     check_end => sub {
5462     my ($self, $item, $element_state) = @_;
5463 wakaba 1.1
5464     ## Table model errors
5465     require Whatpm::HTMLTable;
5466 wakaba 1.87 my $table = Whatpm::HTMLTable->form_table ($item->{node}, sub {
5467 wakaba 1.104 $self->{onerror}->(@_);
5468     }, $self->{level});
5469 wakaba 1.87 Whatpm::HTMLTable->assign_header
5470 wakaba 1.104 ($table, $self->{onerror}, $self->{level});
5471 wakaba 1.87 push @{$self->{return}->{table}}, $table;
5472 wakaba 1.1
5473 wakaba 1.40 $HTMLChecker{check_end}->(@_);
5474 wakaba 1.1 },
5475     };
5476    
5477     $Element->{$HTML_NS}->{caption} = {
5478 wakaba 1.169 %HTMLFlowContentChecker,
5479 wakaba 1.187 status => FEATURE_HTML5_REC,
5480 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5481     align => $GetHTMLEnumeratedAttrChecker->({
5482     top => 1, bottom => 1, left => 1, right => 1,
5483     }),
5484     }, {
5485 wakaba 1.49 %HTMLAttrStatus,
5486 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5487 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
5488 wakaba 1.187 lang => FEATURE_HTML5_REC,
5489 wakaba 1.49 }),
5490 wakaba 1.169 check_start => sub {
5491     my ($self, $item, $element_state) = @_;
5492     $self->_add_minus_elements ($element_state, {$HTML_NS => {table => 1}});
5493    
5494     $HTMLFlowContentChecker{check_start}->(@_);
5495     },
5496     check_end => sub {
5497     my ($self, $item, $element_state) = @_;
5498     $self->_remove_minus_elements ($element_state);
5499    
5500     $HTMLFlowContentChecker{check_end}->(@_);
5501     },
5502     }; # caption
5503 wakaba 1.1
5504 wakaba 1.69 my %cellalign = (
5505     ## HTML4 %cellhalign;
5506 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
5507     left => 1, center => 1, right => 1, justify => 1, char => 1,
5508     }),
5509     char => sub {
5510     my ($self, $attr) = @_;
5511 wakaba 1.69
5512 wakaba 1.70 ## NOTE: "character" or |%Character;| in HTML4.
5513    
5514     my $value = $attr->value;
5515     if (length $value != 1) {
5516     $self->{onerror}->(node => $attr, type => 'char:syntax error',
5517 wakaba 1.105 level => $self->{level}->{html4_fact});
5518 wakaba 1.70 }
5519     },
5520 wakaba 1.86 charoff => $HTMLLengthAttrChecker,
5521    
5522 wakaba 1.69 ## HTML4 %cellvalign;
5523 wakaba 1.70 valign => $GetHTMLEnumeratedAttrChecker->({
5524     top => 1, middle => 1, bottom => 1, baseline => 1,
5525     }),
5526 wakaba 1.69 );
5527    
5528 wakaba 1.1 $Element->{$HTML_NS}->{colgroup} = {
5529 wakaba 1.40 %HTMLEmptyChecker,
5530 wakaba 1.187 status => FEATURE_HTML5_REC,
5531 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5532 wakaba 1.69 %cellalign,
5533 wakaba 1.1 span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5534     ## NOTE: Defined only if "the |colgroup| element contains no |col| elements"
5535     ## TODO: "attribute not supported" if |col|.
5536     ## ISSUE: MUST NOT if any |col|?
5537     ## ISSUE: MUST NOT for |<colgroup span="1"><any><col/></any></colgroup>| (though non-conforming)?
5538 wakaba 1.49 }, {
5539     %HTMLAttrStatus,
5540 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5541 wakaba 1.49 align => FEATURE_M12N10_REC,
5542     char => FEATURE_M12N10_REC,
5543     charoff => FEATURE_M12N10_REC,
5544 wakaba 1.187 lang => FEATURE_HTML5_REC,
5545 wakaba 1.153 span => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5546 wakaba 1.49 valign => FEATURE_M12N10_REC,
5547     width => FEATURE_M12N10_REC,
5548 wakaba 1.1 }),
5549 wakaba 1.40 check_child_element => sub {
5550     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5551     $child_is_transparent, $element_state) = @_;
5552 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5553     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5554 wakaba 1.40 $self->{onerror}->(node => $child_el,
5555     type => 'element not allowed:minus',
5556 wakaba 1.104 level => $self->{level}->{must});
5557 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5558     #
5559     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'col') {
5560     #
5561     } else {
5562 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5563     level => $self->{level}->{must});
5564 wakaba 1.40 }
5565     },
5566     check_child_text => sub {
5567     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5568     if ($has_significant) {
5569 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5570     level => $self->{level}->{must});
5571 wakaba 1.1 }
5572     },
5573     };
5574    
5575     $Element->{$HTML_NS}->{col} = {
5576 wakaba 1.40 %HTMLEmptyChecker,
5577 wakaba 1.187 status => FEATURE_HTML5_REC,
5578 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5579 wakaba 1.69 %cellalign,
5580 wakaba 1.1 span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5581 wakaba 1.49 }, {
5582     %HTMLAttrStatus,
5583 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5584 wakaba 1.49 align => FEATURE_M12N10_REC,
5585     char => FEATURE_M12N10_REC,
5586     charoff => FEATURE_M12N10_REC,
5587 wakaba 1.187 lang => FEATURE_HTML5_REC,
5588 wakaba 1.153 span => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5589 wakaba 1.49 valign => FEATURE_M12N10_REC,
5590     width => FEATURE_M12N10_REC,
5591 wakaba 1.1 }),
5592     };
5593    
5594     $Element->{$HTML_NS}->{tbody} = {
5595 wakaba 1.40 %HTMLChecker,
5596 wakaba 1.187 status => FEATURE_HTML5_REC,
5597 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5598     %cellalign,
5599     }, {
5600 wakaba 1.49 %HTMLAttrStatus,
5601 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5602 wakaba 1.49 align => FEATURE_M12N10_REC,
5603     char => FEATURE_M12N10_REC,
5604     charoff => FEATURE_M12N10_REC,
5605 wakaba 1.187 lang => FEATURE_HTML5_REC,
5606 wakaba 1.49 valign => FEATURE_M12N10_REC,
5607     }),
5608 wakaba 1.40 check_child_element => sub {
5609     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5610     $child_is_transparent, $element_state) = @_;
5611 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5612     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5613 wakaba 1.40 $self->{onerror}->(node => $child_el,
5614     type => 'element not allowed:minus',
5615 wakaba 1.104 level => $self->{level}->{must});
5616 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5617     #
5618     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5619 wakaba 1.84 #
5620 wakaba 1.40 } else {
5621 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5622     level => $self->{level}->{must});
5623 wakaba 1.40 }
5624     },
5625     check_child_text => sub {
5626     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5627     if ($has_significant) {
5628 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5629     level => $self->{level}->{must});
5630 wakaba 1.1 }
5631 wakaba 1.40 },
5632 wakaba 1.1 };
5633    
5634     $Element->{$HTML_NS}->{thead} = {
5635 wakaba 1.40 %{$Element->{$HTML_NS}->{tbody}},
5636 wakaba 1.1 };
5637    
5638     $Element->{$HTML_NS}->{tfoot} = {
5639 wakaba 1.40 %{$Element->{$HTML_NS}->{tbody}},
5640 wakaba 1.1 };
5641    
5642     $Element->{$HTML_NS}->{tr} = {
5643 wakaba 1.40 %HTMLChecker,
5644 wakaba 1.187 status => FEATURE_HTML5_REC,
5645 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5646     %cellalign,
5647     bgcolor => $HTMLColorAttrChecker,
5648     }, {
5649 wakaba 1.49 %HTMLAttrStatus,
5650 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5651 wakaba 1.49 align => FEATURE_M12N10_REC,
5652     bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5653     char => FEATURE_M12N10_REC,
5654     charoff => FEATURE_M12N10_REC,
5655 wakaba 1.187 lang => FEATURE_HTML5_REC,
5656 wakaba 1.49 valign => FEATURE_M12N10_REC,
5657     }),
5658 wakaba 1.40 check_child_element => sub {
5659     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5660     $child_is_transparent, $element_state) = @_;
5661 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5662     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5663 wakaba 1.40 $self->{onerror}->(node => $child_el,
5664     type => 'element not allowed:minus',
5665 wakaba 1.104 level => $self->{level}->{must});
5666 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5667     #
5668     } elsif ($child_nsuri eq $HTML_NS and
5669     ($child_ln eq 'td' or $child_ln eq 'th')) {
5670 wakaba 1.84 #
5671 wakaba 1.40 } else {
5672 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5673     level => $self->{level}->{must});
5674 wakaba 1.40 }
5675     },
5676     check_child_text => sub {
5677     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5678     if ($has_significant) {
5679 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5680     level => $self->{level}->{must});
5681 wakaba 1.1 }
5682     },
5683     };
5684    
5685     $Element->{$HTML_NS}->{td} = {
5686 wakaba 1.72 %HTMLFlowContentChecker,
5687 wakaba 1.187 status => FEATURE_HTML5_REC,
5688 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5689 wakaba 1.69 %cellalign,
5690     abbr => sub {}, ## NOTE: HTML4 %Text; and SHOULD be short.
5691     axis => sub {}, ## NOTE: HTML4 "cdata", comma-separated
5692     bgcolor => $HTMLColorAttrChecker,
5693 wakaba 1.1 colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5694 wakaba 1.87 headers => sub {
5695     ## NOTE: Will be checked by Whatpm::HTMLTable->assign_header.
5696     ## Though that method does not check the |headers| attribute of a
5697     ## |td| element if the element does not form a table, in that case
5698     ## the |td| element is non-conforming anyway.
5699     },
5700 wakaba 1.69 nowrap => $GetHTMLBooleanAttrChecker->('nowrap'),
5701 wakaba 1.1 rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5702 wakaba 1.69 scope => $GetHTMLEnumeratedAttrChecker
5703     ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
5704 wakaba 1.49 }, {
5705     %HTMLAttrStatus,
5706 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5707     abbr => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5708 wakaba 1.49 align => FEATURE_M12N10_REC,
5709 wakaba 1.82 axis => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5710 wakaba 1.49 bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5711     char => FEATURE_M12N10_REC,
5712     charoff => FEATURE_M12N10_REC,
5713 wakaba 1.153 colspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5714 wakaba 1.187 headers => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5715 wakaba 1.49 height => FEATURE_M12N10_REC_DEPRECATED,
5716 wakaba 1.187 lang => FEATURE_HTML5_REC,
5717 wakaba 1.49 nowrap => FEATURE_M12N10_REC_DEPRECATED,
5718 wakaba 1.153 rowspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5719 wakaba 1.82 scope => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5720 wakaba 1.49 valign => FEATURE_M12N10_REC,
5721     width => FEATURE_M12N10_REC_DEPRECATED,
5722 wakaba 1.1 }),
5723     };
5724    
5725     $Element->{$HTML_NS}->{th} = {
5726 wakaba 1.40 %HTMLPhrasingContentChecker,
5727 wakaba 1.187 status => FEATURE_HTML5_REC,
5728 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5729 wakaba 1.69 %cellalign,
5730     abbr => sub {}, ## NOTE: HTML4 %Text; and SHOULD be short.
5731     axis => sub {}, ## NOTE: HTML4 "cdata", comma-separated
5732     bgcolor => $HTMLColorAttrChecker,
5733 wakaba 1.1 colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5734 wakaba 1.87 ## TODO: HTML4(?) |headers|
5735 wakaba 1.69 nowrap => $GetHTMLBooleanAttrChecker->('nowrap'),
5736 wakaba 1.1 rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5737     scope => $GetHTMLEnumeratedAttrChecker
5738     ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
5739 wakaba 1.49 }, {
5740     %HTMLAttrStatus,
5741 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5742     abbr => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5743 wakaba 1.49 align => FEATURE_M12N10_REC,
5744 wakaba 1.82 axis => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5745 wakaba 1.49 bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5746     char => FEATURE_M12N10_REC,
5747     charoff => FEATURE_M12N10_REC,
5748 wakaba 1.153 colspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5749 wakaba 1.187 headers => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5750 wakaba 1.49 height => FEATURE_M12N10_REC_DEPRECATED,
5751 wakaba 1.187 lang => FEATURE_HTML5_REC,
5752 wakaba 1.49 nowrap => FEATURE_M12N10_REC_DEPRECATED,
5753 wakaba 1.153 rowspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5754 wakaba 1.187 scope => FEATURE_HTML5_REC,
5755 wakaba 1.49 valign => FEATURE_M12N10_REC,
5756     width => FEATURE_M12N10_REC_DEPRECATED,
5757 wakaba 1.1 }),
5758     };
5759    
5760 wakaba 1.52 $Element->{$HTML_NS}->{form} = {
5761 wakaba 1.121 %HTMLFlowContentChecker,
5762 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5763 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
5764 wakaba 1.161 accept => $AcceptAttrChecker,
5765 wakaba 1.129 'accept-charset' => $HTMLCharsetsAttrChecker,
5766 wakaba 1.166 action => $HTMLURIAttrChecker, ## TODO: Warn if submission is not defined for the scheme
5767 wakaba 1.185 autocomplete => $GetHTMLEnumeratedAttrChecker->({
5768     on => 1, off => 1,
5769     }),
5770 wakaba 1.56 data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
5771 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
5772     'application/x-www-form-urlencoded' => 1,
5773     'multipart/form-data' => 1,
5774     'text/plain' => 1,
5775     }),
5776 wakaba 1.56 method => $GetHTMLEnumeratedAttrChecker->({
5777     get => 1, post => 1, put => 1, delete => 1,
5778     }),
5779 wakaba 1.133 name => sub {
5780     my ($self, $attr) = @_;
5781    
5782     my $value = $attr->value;
5783     if ($value eq '') {
5784     $self->{onerror}->(type => 'empty form name',
5785     node => $attr,
5786     level => $self->{level}->{must});
5787     } else {
5788     if ($self->{form}->{$value}) {
5789     $self->{onerror}->(type => 'duplicate form name',
5790     node => $attr,
5791     value => $value,
5792     level => $self->{level}->{must});
5793     } else {
5794     $self->{form}->{$value} = 1;
5795     }
5796     }
5797     },
5798 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
5799 wakaba 1.126 onformchange => $HTMLEventHandlerAttrChecker,
5800     onforminput => $HTMLEventHandlerAttrChecker,
5801 wakaba 1.56 onreceived => $HTMLEventHandlerAttrChecker,
5802     replace => $GetHTMLEnumeratedAttrChecker->({document => 1, values => 1}),
5803 wakaba 1.52 target => $HTMLTargetAttrChecker,
5804     }, {
5805     %HTMLAttrStatus,
5806     %HTMLM12NCommonAttrStatus,
5807 wakaba 1.161 accept => FEATURE_HTML5_DROPPED | FEATURE_WF2X | FEATURE_M12N10_REC,
5808 wakaba 1.187 'accept-charset' => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5809 wakaba 1.119 action => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5810 wakaba 1.185 autocomplete => FEATURE_HTML5_WD,
5811 wakaba 1.56 data => FEATURE_WF2,
5812 wakaba 1.119 enctype => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5813 wakaba 1.187 lang => FEATURE_HTML5_REC,
5814 wakaba 1.119 method => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5815     #name => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC_DEPRECATED,
5816 wakaba 1.187 name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5817 wakaba 1.207 novalidate => FEATURE_HTML5_LC,
5818 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
5819     onforminput => FEATURE_WF2_INFORMATIVE,
5820 wakaba 1.56 onreceived => FEATURE_WF2,
5821 wakaba 1.52 onreset => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5822     onsubmit => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5823 wakaba 1.56 replace => FEATURE_WF2,
5824 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
5825     sdasuff => FEATURE_HTML20_RFC,
5826 wakaba 1.119 target => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5827 wakaba 1.52 }),
5828 wakaba 1.66 check_start => sub {
5829     my ($self, $item, $element_state) = @_;
5830 wakaba 1.121 $self->_add_minus_elements ($element_state, {$HTML_NS => {form => 1}});
5831 wakaba 1.66
5832     $element_state->{uri_info}->{action}->{type}->{action} = 1;
5833     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
5834 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5835     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5836 wakaba 1.136 $element_state->{id_type} = 'form';
5837 wakaba 1.66 },
5838 wakaba 1.121 check_end => sub {
5839     my ($self, $item, $element_state) = @_;
5840     $self->_remove_minus_elements ($element_state);
5841    
5842     $HTMLFlowContentChecker{check_end}->(@_);
5843     },
5844 wakaba 1.185 }; # form
5845 wakaba 1.52
5846     $Element->{$HTML_NS}->{fieldset} = {
5847 wakaba 1.134 %HTMLFlowContentChecker,
5848 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5849 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
5850     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
5851 wakaba 1.136 form => $HTMLFormAttrChecker,
5852 wakaba 1.165 name => $FormControlNameAttrChecker,
5853 wakaba 1.56 }, {
5854 wakaba 1.52 %HTMLAttrStatus,
5855     %HTMLM12NCommonAttrStatus,
5856 wakaba 1.187 disabled => FEATURE_HTML5_WD | FEATURE_WF2X,
5857     form => FEATURE_HTML5_LC | FEATURE_WF2X,
5858     lang => FEATURE_HTML5_REC,
5859     name => FEATURE_HTML5_LC,
5860 wakaba 1.52 }),
5861 wakaba 1.134 ## NOTE: legend, Flow
5862     check_child_element => sub {
5863     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5864     $child_is_transparent, $element_state) = @_;
5865     if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5866     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5867     $self->{onerror}->(node => $child_el,
5868     type => 'element not allowed:minus',
5869     level => $self->{level}->{must});
5870     $element_state->{has_non_legend} = 1;
5871     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5872     #
5873     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'legend') {
5874     if ($element_state->{has_non_legend}) {
5875     $self->{onerror}->(node => $child_el,
5876     type => 'element not allowed:details legend',
5877     level => $self->{level}->{must});
5878     }
5879     $element_state->{has_legend} = 1;
5880     $element_state->{has_non_legend} = 1;
5881     } else {
5882     $HTMLFlowContentChecker{check_child_element}->(@_);
5883     $element_state->{has_non_legend} = 1 unless $child_is_transparent;
5884     ## TODO:
5885 wakaba 1.167 ## |<fieldset><object><legend>xx</legend></object>..</fieldset>|
5886 wakaba 1.134 ## should be an error, since |object| is allowed as flow,
5887     ## therefore |details| part of the content model does not match.
5888     }
5889     },
5890     check_child_text => sub {
5891     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5892     if ($has_significant) {
5893     $element_state->{has_non_legend} = 1;
5894     }
5895     },
5896     check_end => sub {
5897     my ($self, $item, $element_state) = @_;
5898    
5899     unless ($element_state->{has_legend}) {
5900     $self->{onerror}->(node => $item->{node},
5901     type => 'child element missing',
5902     text => 'legend',
5903     level => $self->{level}->{must});
5904     }
5905    
5906     $HTMLFlowContentChecker{check_end}->(@_);
5907 wakaba 1.167 ## ISSUE: |<fieldset><legend>aa</legend></fieldset>| error?
5908 wakaba 1.134 },
5909     ## NOTE: This definition is partially reused by |details| element's
5910     ## checker.
5911 wakaba 1.52 };
5912    
5913     $Element->{$HTML_NS}->{input} = {
5914 wakaba 1.119 %HTMLEmptyChecker,
5915 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5916 wakaba 1.140 check_attrs => sub {
5917     my ($self, $item, $element_state) = @_;
5918 wakaba 1.142
5919 wakaba 1.145 my $state = $item->{node}->get_attribute_ns (undef, 'type');
5920 wakaba 1.142 $state = 'text' unless defined $state;
5921     $state =~ tr/A-Z/a-z/; ## ASCII case-insensitive
5922    
5923 wakaba 1.140 for my $attr (@{$item->{node}->attributes}) {
5924     my $attr_ns = $attr->namespace_uri;
5925     $attr_ns = '' unless defined $attr_ns;
5926     my $attr_ln = $attr->manakai_local_name;
5927     my $checker;
5928     my $status;
5929     if ($attr_ns eq '') {
5930     $status =
5931     {
5932     %HTMLAttrStatus,
5933     %HTMLM12NCommonAttrStatus,
5934     accept => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5935     'accept-charset' => FEATURE_HTML2X_RFC,
5936 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
5937 wakaba 1.198 action => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5938 wakaba 1.140 align => FEATURE_M12N10_REC_DEPRECATED,
5939     alt => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5940 wakaba 1.185 autocomplete => FEATURE_HTML5_LC | FEATURE_WF2X,
5941 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
5942     checked => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5943 wakaba 1.140 datafld => FEATURE_HTML4_REC_RESERVED,
5944     dataformatas => FEATURE_HTML4_REC_RESERVED,
5945     datasrc => FEATURE_HTML4_REC_RESERVED,
5946 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5947 wakaba 1.198 enctype => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5948 wakaba 1.187 form => FEATURE_HTML5_LC | FEATURE_WF2X,
5949 wakaba 1.198 formaction => FEATURE_HTML5_LC,
5950     formenctype => FEATURE_HTML5_LC,
5951     formmethod => FEATURE_HTML5_LC,
5952     formnovalidate => FEATURE_HTML5_LC,
5953     formtarget => FEATURE_HTML5_LC,
5954 wakaba 1.178 height => FEATURE_HTML5_LC,
5955 wakaba 1.150 inputmode => FEATURE_HTML5_DROPPED | FEATURE_WF2X |
5956     FEATURE_XHTMLBASIC11_CR,
5957 wakaba 1.140 ismap => FEATURE_M12N10_REC,
5958 wakaba 1.187 lang => FEATURE_HTML5_REC,
5959     list => FEATURE_HTML5_LC | FEATURE_WF2X,
5960     max => FEATURE_HTML5_LC | FEATURE_WF2X,
5961     maxlength => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5962 wakaba 1.198 method => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5963 wakaba 1.187 min => FEATURE_HTML5_LC | FEATURE_WF2X,
5964     multiple => FEATURE_HTML5_LC,
5965     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5966 wakaba 1.198 novalidate => FEATURE_HTML5_DROPPED,
5967 wakaba 1.140 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5968     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5969     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5970     onformchange => FEATURE_WF2_INFORMATIVE,
5971     onforminput => FEATURE_WF2_INFORMATIVE,
5972     oninput => FEATURE_WF2,
5973     oninvalid => FEATURE_WF2,
5974     onselect => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5975 wakaba 1.187 pattern => FEATURE_HTML5_LC | FEATURE_WF2X,
5976     placeholder => FEATURE_HTML5_LC,
5977     readonly => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5978 wakaba 1.140 replace => FEATURE_WF2,
5979 wakaba 1.187 required => FEATURE_HTML5_LC | FEATURE_WF2X,
5980 wakaba 1.140 sdapref => FEATURE_HTML20_RFC,
5981 wakaba 1.187 size => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5982 wakaba 1.140 src => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5983 wakaba 1.187 step => FEATURE_HTML5_LC | FEATURE_WF2X,
5984 wakaba 1.140 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5985 wakaba 1.198 target => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5986 wakaba 1.208 template => FEATURE_HTML5_DROPPED | FEATURE_WF2,
5987 wakaba 1.187 type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5988 wakaba 1.140 usemap => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC,
5989 wakaba 1.187 value => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5990 wakaba 1.178 width => FEATURE_HTML5_LC,
5991 wakaba 1.140 }->{$attr_ln};
5992    
5993     $checker =
5994     {
5995 wakaba 1.141 ## NOTE: Value of an empty string means that the attribute is only
5996     ## applicable for a specific set of states.
5997 wakaba 1.142 accept => '',
5998 wakaba 1.149 'accept-charset' => $HTMLCharsetsAttrChecker,
5999     ## NOTE: To which states it applies is not defined in RFC 2070.
6000 wakaba 1.142 action => '',
6001 wakaba 1.150 align => '',
6002 wakaba 1.141 alt => '',
6003 wakaba 1.142 autocomplete => '',
6004 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6005     ## NOTE: <input type=hidden disabled> is not disallowed.
6006 wakaba 1.142 checked => '',
6007     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6008 wakaba 1.165 ## NOTE: <input type=hidden disabled> is not disallowed.
6009 wakaba 1.142 enctype => '',
6010     form => $HTMLFormAttrChecker,
6011 wakaba 1.198 formaction => '',
6012     formenctype => '',
6013     formmethod => '',
6014     formnovalidate => '',
6015     formtarget => '',
6016 wakaba 1.178 height => '',
6017 wakaba 1.150 inputmode => '',
6018     ismap => '', ## NOTE: "MUST" be type=image [HTML4]
6019 wakaba 1.142 list => '',
6020     max => '',
6021     maxlength => '',
6022     method => '',
6023     min => '',
6024 wakaba 1.156 multiple => '',
6025 wakaba 1.165 name => $FormControlNameAttrChecker,
6026 wakaba 1.166 novalidate => '',
6027 wakaba 1.149 onformchange => $HTMLEventHandlerAttrChecker, # [WF2]
6028     onforminput => $HTMLEventHandlerAttrChecker, # [WF2]
6029     oninput => $HTMLEventHandlerAttrChecker, # [WF2]
6030     oninvalid => $HTMLEventHandlerAttrChecker, # [WF2]
6031     ## TODO: tests for four attributes above
6032 wakaba 1.142 pattern => '',
6033 wakaba 1.156 placeholder => '',
6034 wakaba 1.142 readonly => '',
6035 wakaba 1.150 replace => '',
6036 wakaba 1.142 required => '',
6037     size => '',
6038     src => '',
6039     step => '',
6040     target => '',
6041 wakaba 1.140 type => $GetHTMLEnumeratedAttrChecker->({
6042 wakaba 1.156 hidden => 1, text => 1, search => 1, url => 1,
6043 wakaba 1.193 tel => 1, email => 1, password => 1,
6044 wakaba 1.141 datetime => 1, date => 1, month => 1, week => 1, time => 1,
6045 wakaba 1.157 'datetime-local' => 1, number => 1, range => 1, color => 1,
6046     checkbox => 1,
6047 wakaba 1.141 radio => 1, file => 1, submit => 1, image => 1, reset => 1,
6048     button => 1,
6049 wakaba 1.140 }),
6050 wakaba 1.151 usemap => '',
6051 wakaba 1.142 value => '',
6052 wakaba 1.178 width => '',
6053 wakaba 1.140 }->{$attr_ln};
6054 wakaba 1.141
6055     ## State-dependent checkers
6056     unless ($checker) {
6057     if ($state eq 'hidden') {
6058     $checker =
6059     {
6060 wakaba 1.142 value => sub {
6061     my ($self, $attr, $item, $element_state) = @_;
6062 wakaba 1.145 my $name = $item->{node}->get_attribute_ns (undef, 'name');
6063 wakaba 1.142 if (defined $name and $name eq '_charset_') { ## case-sensitive
6064     $self->{onerror}->(node => $attr,
6065     type => '_charset_ value',
6066     level => $self->{level}->{must});
6067     }
6068     },
6069 wakaba 1.141 }->{$attr_ln} || $checker;
6070 wakaba 1.142 ## TODO: Warn if no name attribute?
6071     ## TODO: Warn if name!=_charset_ and no value attribute?
6072 wakaba 1.168 } elsif ({
6073     datetime => 1, date => 1, month => 1, time => 1,
6074     week => 1, 'datetime-local' => 1,
6075     }->{$state}) {
6076     my $v = {
6077     datetime => ['global_date_and_time_string'],
6078     date => ['date_string'],
6079     month => ['month_string'],
6080     week => ['week_string'],
6081     time => ['time_string'],
6082     'datetime-local' => ['local_date_and_time_string'],
6083     }->{$state};
6084 wakaba 1.144 $checker =
6085     {
6086 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6087     on => 1, off => 1,
6088     }),
6089 wakaba 1.158 list => $ListAttrChecker,
6090 wakaba 1.168 min => $GetDateTimeAttrChecker->($v->[0]),
6091     max => $GetDateTimeAttrChecker->($v->[0]),
6092 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6093 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6094 wakaba 1.148 step => $StepAttrChecker,
6095 wakaba 1.168 value => $GetDateTimeAttrChecker->($v->[0]),
6096 wakaba 1.144 }->{$attr_ln} || $checker;
6097 wakaba 1.205
6098     ## XXX Maybe it is better to check min <= value <= max
6099     ## relation is hold for convinience?
6100 wakaba 1.144 } elsif ($state eq 'number') {
6101     $checker =
6102     {
6103 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6104     on => 1, off => 1,
6105     }),
6106 wakaba 1.158 list => $ListAttrChecker,
6107 wakaba 1.144 max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6108     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6109 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6110 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6111 wakaba 1.148 step => $StepAttrChecker,
6112 wakaba 1.168 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6113 wakaba 1.144 }->{$attr_ln} || $checker;
6114     } elsif ($state eq 'range') {
6115     $checker =
6116     {
6117 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6118     on => 1, off => 1,
6119     }),
6120 wakaba 1.158 list => $ListAttrChecker,
6121 wakaba 1.144 max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6122     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6123 wakaba 1.148 step => $StepAttrChecker,
6124 wakaba 1.168 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6125 wakaba 1.144 }->{$attr_ln} || $checker;
6126 wakaba 1.157 } elsif ($state eq 'color') {
6127     $checker =
6128     {
6129     autocomplete => $GetHTMLEnumeratedAttrChecker->({
6130     on => 1, off => 1,
6131     }),
6132 wakaba 1.158 list => $ListAttrChecker,
6133 wakaba 1.157 value => sub {
6134     my ($self, $attr) = @_;
6135     unless ($attr->value =~ /\A#[0-9A-Fa-f]{6}\z/) {
6136     $self->{onerror}->(node => $attr,
6137     type => 'scolor:syntax error', ## TODOC: type
6138     level => $self->{level}->{must});
6139     }
6140     },
6141     }->{$attr_ln} || $checker;
6142 wakaba 1.144 } elsif ($state eq 'checkbox' or $state eq 'radio') {
6143     $checker =
6144     {
6145 wakaba 1.149 checked => $GetHTMLBooleanAttrChecker->('checked'),
6146     ## TODO: tests
6147 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6148 wakaba 1.144 value => sub { }, ## NOTE: No restriction.
6149     }->{$attr_ln} || $checker;
6150     ## TODO: There MUST be another input type=radio with same
6151     ## name (Radio state).
6152     ## ISSUE: There should be exactly one type=radio with checked?
6153     } elsif ($state eq 'file') {
6154     $checker =
6155     {
6156 wakaba 1.161 accept => $AcceptAttrChecker,
6157 wakaba 1.168 ## max (default 1) & min (default 0) [WF2]: Dropped by HTML5.
6158 wakaba 1.159 multiple => $GetHTMLBooleanAttrChecker->('multiple'),
6159 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6160 wakaba 1.144 }->{$attr_ln} || $checker;
6161     } elsif ($state eq 'submit') {
6162     $checker =
6163     {
6164 wakaba 1.149 action => $HTMLURIAttrChecker,
6165 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6166     'application/x-www-form-urlencoded' => 1,
6167     'multipart/form-data' => 1,
6168     'text/plain' => 1,
6169     }),
6170 wakaba 1.198 formaction => $HTMLURIAttrChecker,
6171     formenctype => $GetHTMLEnumeratedAttrChecker->({
6172     'application/x-www-form-urlencoded' => 1,
6173     'multipart/form-data' => 1,
6174     'text/plain' => 1,
6175     }),
6176     formmethod => $GetHTMLEnumeratedAttrChecker->({
6177     get => 1, post => 1, put => 1, delete => 1,
6178     }),
6179     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6180     formtarget => $HTMLTargetAttrChecker,
6181 wakaba 1.149 method => $GetHTMLEnumeratedAttrChecker->({
6182     get => 1, post => 1, put => 1, delete => 1,
6183     }),
6184 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6185 wakaba 1.149 replace => $GetHTMLEnumeratedAttrChecker->({
6186     document => 1, values => 1,
6187     }),
6188     target => $HTMLTargetAttrChecker,
6189 wakaba 1.144 value => sub { }, ## NOTE: No restriction.
6190     }->{$attr_ln} || $checker;
6191     } elsif ($state eq 'image') {
6192     $checker =
6193     {
6194 wakaba 1.149 action => $HTMLURIAttrChecker,
6195     align => $GetHTMLEnumeratedAttrChecker->({
6196     top => 1, middle => 1, bottom => 1, left => 1, right => 1,
6197     }),
6198 wakaba 1.144 alt => sub {
6199     my ($self, $attr) = @_;
6200     my $value = $attr->value;
6201     unless (length $value) {
6202     $self->{onerror}->(node => $attr,
6203     type => 'empty anchor image alt',
6204     level => $self->{level}->{must});
6205     }
6206     },
6207 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6208     'application/x-www-form-urlencoded' => 1,
6209     'multipart/form-data' => 1,
6210     'text/plain' => 1,
6211     }),
6212 wakaba 1.198 formaction => $HTMLURIAttrChecker,
6213     formenctype => $GetHTMLEnumeratedAttrChecker->({
6214     'application/x-www-form-urlencoded' => 1,
6215     'multipart/form-data' => 1,
6216     'text/plain' => 1,
6217     }),
6218     formmethod => $GetHTMLEnumeratedAttrChecker->({
6219     get => 1, post => 1, put => 1, delete => 1,
6220     }),
6221     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6222     formtarget => $HTMLTargetAttrChecker,
6223 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
6224 wakaba 1.149 ismap => $GetHTMLBooleanAttrChecker->('ismap'),
6225     method => $GetHTMLEnumeratedAttrChecker->({
6226     get => 1, post => 1, put => 1, delete => 1,
6227     }),
6228 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6229 wakaba 1.149 replace => $GetHTMLEnumeratedAttrChecker->({
6230     document => 1, values => 1,
6231     }),
6232 wakaba 1.144 src => $HTMLURIAttrChecker,
6233     ## TODO: There is requirements on the referenced resource.
6234 wakaba 1.149 target => $HTMLTargetAttrChecker,
6235     usemap => $HTMLUsemapAttrChecker,
6236 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
6237 wakaba 1.144 }->{$attr_ln} || $checker;
6238     ## TODO: alt & src are required.
6239     } elsif ({
6240     reset => 1, button => 1,
6241     ## NOTE: From Web Forms 2.0:
6242     remove => 1, 'move-up' => 1, 'move-down' => 1,
6243     add => 1,
6244     }->{$state}) {
6245     $checker =
6246     {
6247     ## NOTE: According to Web Forms 2.0, |input| attribute
6248     ## has |template| attribute to support the |add| button
6249     ## type (as part of the repetition template feature). It
6250     ## conflicts with the |template| global attribute
6251     ## introduced as part of the data template feature.
6252     ## NOTE: |template| attribute as defined in Web Forms 2.0
6253     ## has no author requirement.
6254     value => sub { }, ## NOTE: No restriction.
6255     }->{$attr_ln} || $checker;
6256 wakaba 1.193 } else { # Text, Search, E-mail, URL, Telephone, Password
6257 wakaba 1.141 $checker =
6258     {
6259 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6260     on => 1, off => 1,
6261     }),
6262 wakaba 1.149 ## TODO: inputmode [WF2]
6263 wakaba 1.158 list => $ListAttrChecker,
6264 wakaba 1.147 maxlength => sub {
6265     my ($self, $attr, $item, $element_state) = @_;
6266    
6267     $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 })->(@_);
6268    
6269 wakaba 1.165 if ($attr->value =~ /^[\x09\x0A\x0C\x0D\x20]*([0-9]+)/) {
6270 wakaba 1.147 ## NOTE: Applying the rules for parsing non-negative
6271     ## integers results in a number.
6272     my $max_allowed_value_length = 0+$1;
6273    
6274     my $value = $item->{node}->get_attribute_ns (undef, 'value');
6275     if (defined $value) {
6276     my $codepoint_length = length $value;
6277 wakaba 1.162
6278 wakaba 1.147 if ($codepoint_length > $max_allowed_value_length) {
6279     $self->{onerror}
6280     ->(node => $item->{node}
6281     ->get_attribute_node_ns (undef, 'value'),
6282     type => 'value too long',
6283     level => $self->{level}->{must});
6284     }
6285     }
6286     }
6287     },
6288 wakaba 1.160 pattern => $PatternAttrChecker,
6289 wakaba 1.179 placeholder => $PlaceholderAttrChecker,
6290 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6291 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6292 wakaba 1.147 size => $GetHTMLNonNegativeIntegerAttrChecker->(sub {shift > 0}),
6293 wakaba 1.143 value => sub {
6294 wakaba 1.156 my ($self, $attr, $item, $element_state) = @_;
6295     if ($state eq 'url') {
6296 wakaba 1.205 ## XXX MUST be absolute IRI.
6297 wakaba 1.156 $HTMLURIAttrChecker->(@_);
6298     } elsif ($state eq 'email') {
6299     if ($item->{node}->has_attribute_ns (undef, 'multiple')) {
6300 wakaba 1.200 ## A set of comma-separated tokens.
6301 wakaba 1.156 my @addr = split /,/, $attr->value, -1;
6302     @addr = ('') unless @addr;
6303     for (@addr) {
6304 wakaba 1.165 s/\A[\x09\x0A\x0C\x0D\x20]+//;
6305     s/[\x09\x0A\x0C\x0D\x20]\z//;
6306 wakaba 1.200
6307     unless (/\A$ValidEmailAddress\z/o) {
6308 wakaba 1.156 $self->{onerror}->(node => $attr,
6309     type => 'email:syntax error', ## TODO: type
6310     value => $_,
6311     level => $self->{level}->{must});
6312     }
6313     }
6314     } else {
6315     unless ($attr->value =~ /\A$ValidEmailAddress\z/) {
6316     $self->{onerror}->(node => $attr,
6317     type => 'email:syntax error', ## TODO: type
6318     level => $self->{level}->{must});
6319     }
6320     }
6321     } else {
6322     if ($attr->value =~ /[\x0D\x0A]/) {
6323     $self->{onerror}->(node => $attr,
6324     type => 'newline in value', ## TODO: type
6325     level => $self->{level}->{must});
6326     }
6327     }
6328 wakaba 1.143 },
6329 wakaba 1.141 }->{$attr_ln} || $checker;
6330 wakaba 1.147 $checker = '' if $state eq 'password' and $attr_ln eq 'list';
6331 wakaba 1.156 $checker = $GetHTMLBooleanAttrChecker->('multiple')
6332     if $state eq 'email' and $attr_ln eq 'multiple';
6333 wakaba 1.161
6334     if ($item->{node}->has_attribute_ns (undef, 'pattern') and
6335     not $item->{node}->has_attribute_ns (undef, 'title')) {
6336     $self->{onerror}->(node => $item->{node},
6337     type => 'attribute missing',
6338     text => 'title',
6339     level => $self->{level}->{should});
6340     }
6341 wakaba 1.141 }
6342     }
6343    
6344     if (defined $checker) {
6345     if ($checker eq '') {
6346     $checker = sub {
6347     my ($self, $attr) = @_;
6348     $self->{onerror}->(node => $attr,
6349     type => 'input attr not applicable',
6350     text => $state,
6351     level => $self->{level}->{must});
6352     };
6353     }
6354 wakaba 1.140 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
6355     $attr_ln !~ /[A-Z]/) {
6356     $checker = $HTMLDatasetAttrChecker;
6357     $status = $HTMLDatasetAttrStatus;
6358     } else {
6359     $checker = $HTMLAttrChecker->{$attr_ln};
6360     }
6361     }
6362     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
6363     || $AttrChecker->{$attr_ns}->{''};
6364     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
6365     || $AttrStatus->{$attr_ns}->{''};
6366     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
6367 wakaba 1.157
6368 wakaba 1.140 if ($checker) {
6369     $checker->($self, $attr, $item, $element_state) if ref $checker;
6370     } elsif ($attr_ns eq '' and not $status) {
6371     #
6372     } else {
6373     $self->{onerror}->(node => $attr,
6374     type => 'unknown attribute',
6375     level => $self->{level}->{uncertain});
6376     ## ISSUE: No comformance createria for unknown attributes in the spec
6377     }
6378    
6379     $self->_attr_status_info ($attr, $status);
6380     }
6381 wakaba 1.168
6382     ## ISSUE: -0/+0
6383    
6384     if ($state eq 'range') {
6385     $element_state->{number_value}->{min} ||= 0;
6386     $element_state->{number_value}->{max} = 100
6387     unless defined $element_state->{number_value}->{max};
6388     }
6389    
6390     if (defined $element_state->{date_value}->{min} or
6391     defined $element_state->{date_value}->{max}) {
6392     my $min_value = $element_state->{date_value}->{min};
6393     my $max_value = $element_state->{date_value}->{max};
6394     my $value_value = $element_state->{date_value}->{value};
6395    
6396     if (defined $min_value and $min_value eq '' and
6397     (defined $max_value or defined $value_value)) {
6398     my $min = $item->{node}->get_attribute_node_ns (undef, 'min');
6399     $self->{onerror}->(node => $min,
6400     type => 'date value not supported', ## TODOC: type
6401     value => $min->value,
6402     level => $self->{level}->{unsupported});
6403     undef $min_value;
6404     }
6405     if (defined $max_value and $max_value eq '' and
6406     (defined $max_value or defined $value_value)) {
6407     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6408     $self->{onerror}->(node => $max,
6409     type => 'date value not supported', ## TODOC: type
6410     value => $max->value,
6411     level => $self->{level}->{unsupported});
6412     undef $max_value;
6413     }
6414     if (defined $value_value and $value_value eq '' and
6415     (defined $max_value or defined $min_value)) {
6416     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6417     $self->{onerror}->(node => $value,
6418     type => 'date value not supported', ## TODOC: type
6419     value => $value->value,
6420     level => $self->{level}->{unsupported});
6421     undef $value_value;
6422     }
6423    
6424     if (defined $min_value and defined $max_value) {
6425     if ($min_value->to_html5_number > $max_value->to_html5_number) {
6426     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6427     $self->{onerror}->(node => $max,
6428     type => 'max lt min', ## TODOC: type
6429     level => $self->{level}->{must});
6430     }
6431     }
6432    
6433     if (defined $min_value and defined $value_value) {
6434     if ($min_value->to_html5_number > $value_value->to_html5_number) {
6435     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6436     $self->{onerror}->(node => $value,
6437     type => 'value lt min', ## TODOC: type
6438     level => $self->{level}->{warn});
6439     ## NOTE: Not an error.
6440     }
6441     }
6442    
6443     if (defined $max_value and defined $value_value) {
6444     if ($max_value->to_html5_number < $value_value->to_html5_number) {
6445     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6446     $self->{onerror}->(node => $value,
6447     type => 'value gt max', ## TODOC: type
6448     level => $self->{level}->{warn});
6449     ## NOTE: Not an error.
6450     }
6451     }
6452     } elsif (defined $element_state->{number_value}->{min} or
6453     defined $element_state->{number_value}->{max}) {
6454     my $min_value = $element_state->{number_value}->{min};
6455     my $max_value = $element_state->{number_value}->{max};
6456     my $value_value = $element_state->{number_value}->{value};
6457    
6458     if (defined $min_value and defined $max_value) {
6459     if ($min_value > $max_value) {
6460     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6461     $self->{onerror}->(node => $max,
6462     type => 'max lt min', ## TODOC: type
6463     level => $self->{level}->{must});
6464     }
6465     }
6466    
6467     if (defined $min_value and defined $value_value) {
6468     if ($min_value > $value_value) {
6469     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6470     $self->{onerror}->(node => $value,
6471     type => 'value lt min', ## TODOC: type
6472     level => $self->{level}->{warn});
6473     ## NOTE: Not an error.
6474     }
6475     }
6476    
6477     if (defined $max_value and defined $value_value) {
6478     if ($max_value < $value_value) {
6479     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6480     $self->{onerror}->(node => $value,
6481     type => 'value gt max', ## TODOC: type
6482     level => $self->{level}->{warn});
6483     ## NOTE: Not an error.
6484     }
6485     }
6486     }
6487 wakaba 1.150
6488 wakaba 1.168 ## TODO: Warn unless value = min * x where x is an integer.
6489    
6490 wakaba 1.150 $element_state->{uri_info}->{action}->{type}->{action} = 1;
6491 wakaba 1.198 $element_state->{uri_info}->{action}->{type}->{formaction} = 1;
6492 wakaba 1.150 $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6493     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
6494     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6495     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6496 wakaba 1.192 }, # check_attrs
6497 wakaba 1.66 check_start => sub {
6498     my ($self, $item, $element_state) = @_;
6499 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6500     }, # check_start
6501     check_attrs2 => sub {
6502     my ($self, $item, $element_state) = @_;
6503     $FAECheckAttrs2->($self, $item, $element_state);
6504     }, # check_attrs2
6505     }; # input
6506 wakaba 1.52
6507 wakaba 1.178 ## XXXresource: Dimension attributes have requirements on width and
6508     ## height of referenced resource.
6509 wakaba 1.80
6510 wakaba 1.52 $Element->{$HTML_NS}->{button} = {
6511 wakaba 1.202 %HTMLPhrasingContentChecker,
6512 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6513 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6514 wakaba 1.199 ## XXXISSUE: In HTML5, no "MUST NOT" for using |action|, |method|,
6515 wakaba 1.165 ## |enctype|, |target|, and |novalidate| with non-|submit|-|type|
6516     ## |button| elements.
6517 wakaba 1.56 action => $HTMLURIAttrChecker,
6518 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6519 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6520 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6521     'application/x-www-form-urlencoded' => 1,
6522     'multipart/form-data' => 1,
6523     'text/plain' => 1,
6524     }),
6525 wakaba 1.136 form => $HTMLFormAttrChecker,
6526 wakaba 1.199 formaction => $HTMLURIAttrChecker,
6527     formenctype => $GetHTMLEnumeratedAttrChecker->({
6528     'application/x-www-form-urlencoded' => 1,
6529     'multipart/form-data' => 1,
6530     'text/plain' => 1,
6531     }),
6532     formmethod => $GetHTMLEnumeratedAttrChecker->({
6533     get => 1, post => 1, put => 1, delete => 1,
6534     }),
6535     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6536     formtarget => $HTMLTargetAttrChecker,
6537 wakaba 1.56 method => $GetHTMLEnumeratedAttrChecker->({
6538     get => 1, post => 1, put => 1, delete => 1,
6539     }),
6540 wakaba 1.165 name => $FormControlNameAttrChecker,
6541 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6542 wakaba 1.162 onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
6543     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6544 wakaba 1.56 replace => $GetHTMLEnumeratedAttrChecker->({document => 1, values => 1}),
6545     target => $HTMLTargetAttrChecker,
6546 wakaba 1.80 ## NOTE: According to Web Forms 2.0, |button| attribute has |template|
6547     ## attribute to support the |add| button type (as part of repetition
6548     ## template feature). It conflicts with the |template| global attribute
6549     ## introduced as part of the data template feature.
6550     ## NOTE: |template| attribute as defined in Web Forms 2.0 has no
6551     ## author requirement.
6552 wakaba 1.52 type => $GetHTMLEnumeratedAttrChecker->({
6553     button => 1, submit => 1, reset => 1,
6554     }),
6555 wakaba 1.162 value => sub {}, ## NOTE: No restriction.
6556 wakaba 1.52 }, {
6557     %HTMLAttrStatus,
6558     %HTMLM12NCommonAttrStatus,
6559 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
6560 wakaba 1.199 action => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6561 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
6562 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
6563     dataformatas => FEATURE_HTML4_REC_RESERVED,
6564     datasrc => FEATURE_HTML4_REC_RESERVED,
6565 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6566 wakaba 1.199 enctype => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6567 wakaba 1.187 form => FEATURE_HTML5_LC | FEATURE_WF2X,
6568 wakaba 1.199 formaction => FEATURE_HTML5_LC,
6569     formenctype => FEATURE_HTML5_LC,
6570     formmethod => FEATURE_HTML5_LC,
6571     formnovalidate => FEATURE_HTML5_LC,
6572     formtarget => FEATURE_HTML5_LC,
6573 wakaba 1.187 lang => FEATURE_HTML5_REC,
6574 wakaba 1.199 method => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6575 wakaba 1.187 name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6576 wakaba 1.199 novalidate => FEATURE_HTML5_DROPPED,
6577 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6578     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6579 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
6580     onforminput => FEATURE_WF2_INFORMATIVE,
6581 wakaba 1.56 replace => FEATURE_WF2,
6582 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6583 wakaba 1.199 target => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6584 wakaba 1.208 template => FEATURE_HTML5_DROPPED | FEATURE_WF2,
6585 wakaba 1.187 type => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6586     value => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6587 wakaba 1.199 }), # check_attrs
6588 wakaba 1.66 check_start => sub {
6589     my ($self, $item, $element_state) = @_;
6590 wakaba 1.202 $self->_add_minus_elements ($element_state, $HTMLInteractiveContent);
6591 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6592 wakaba 1.162
6593 wakaba 1.202 ## XXXISSUE: "The value attribute must not be present unless the
6594     ## form [content] attribute is present.": Wrong? Maybe it should
6595     ## also be allowed when there is an ancestor |form| element.
6596 wakaba 1.139
6597 wakaba 1.66 $element_state->{uri_info}->{action}->{type}->{action} = 1;
6598 wakaba 1.202 $element_state->{uri_info}->{formaction}->{type}->{action} = 1;
6599 wakaba 1.66 $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6600 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6601     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6602 wakaba 1.192 }, # check_start
6603     check_attrs2 => sub {
6604     my ($self, $item, $element_state) = @_;
6605     $FAECheckAttrs2->($self, $item, $element_state);
6606     }, # check_attrs2
6607 wakaba 1.202 check_end => sub {
6608     my ($self, $item, $element_state) = @_;
6609     $self->_remove_minus_elements ($element_state);
6610    
6611     $HTMLPhrasingContentChecker{check_end}->(@_);
6612     }, # check_end
6613 wakaba 1.199 }; # button
6614 wakaba 1.52
6615     $Element->{$HTML_NS}->{label} = {
6616 wakaba 1.139 %HTMLPhrasingContentChecker,
6617 wakaba 1.187 status => FEATURE_HTML5_REC,
6618 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6619 wakaba 1.138 for => sub {
6620     my ($self, $attr) = @_;
6621    
6622     ## NOTE: MUST be an ID of a labelable element.
6623    
6624     push @{$self->{idref}}, ['labelable', $attr->value, $attr];
6625     },
6626 wakaba 1.136 form => $HTMLFormAttrChecker,
6627 wakaba 1.52 }, {
6628     %HTMLAttrStatus,
6629 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
6630 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_WF2 | FEATURE_M12N10_REC,
6631 wakaba 1.187 for => FEATURE_HTML5_REC,
6632     form => FEATURE_HTML5_LC,
6633     lang => FEATURE_HTML5_REC,
6634 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6635     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6636     }),
6637 wakaba 1.139 check_start => sub {
6638     my ($self, $item, $element_state) = @_;
6639     $self->_add_minus_elements ($element_state, {$HTML_NS => {label => 1}});
6640    
6641 wakaba 1.192 ## If $self->{flag}->{has_label} is true, then there is at least
6642     ## an ancestor |label| element.
6643    
6644     ## If $self->{flag}->{has_labelable} is equal to 1, then there is
6645     ## an ancestor |label| element with its |for| attribute specified.
6646     ## If the value is equal to 2, then there is an ancestor |label|
6647     ## element with its |for| attribute unspecified but there is an
6648     ## associated form control element.
6649    
6650 wakaba 1.139 $element_state->{has_label_original} = $self->{flag}->{has_label};
6651 wakaba 1.192 $element_state->{has_labelable_original} = $self->{flag}->{has_labelable};
6652     $element_state->{label_for_original} = $self->{flag}->{label_for};
6653    
6654 wakaba 1.139 $self->{flag}->{has_label} = 1;
6655 wakaba 1.155 $self->{flag}->{has_labelable}
6656     = $item->{node}->has_attribute_ns (undef, 'for') ? 1 : 0;
6657 wakaba 1.192 $self->{flag}->{label_for}
6658     = $item->{node}->get_attribute_ns (undef, 'for');
6659 wakaba 1.139
6660     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6661     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6662     },
6663     check_end => sub {
6664     my ($self, $item, $element_state) = @_;
6665     $self->_remove_minus_elements ($element_state);
6666    
6667     if ($self->{flag}->{has_labelable} == 1) { # has for="" but no labelable
6668     $self->{flag}->{has_labelable}
6669     = $element_state->{has_labelable_original};
6670     }
6671     delete $self->{flag}->{has_label}
6672     unless $element_state->{has_label_original};
6673 wakaba 1.192 $self->{flag}->{label_for} = $element_state->{label_for_original};
6674    
6675 wakaba 1.139 ## TODO: Warn if no labelable descendant? <input type=hidden>?
6676    
6677     ## NOTE: |<label for=a><input id=a></label>| is non-conforming.
6678    
6679     $HTMLPhrasingContentChecker{check_end}->(@_);
6680     },
6681 wakaba 1.192 }; # label
6682 wakaba 1.52
6683     $Element->{$HTML_NS}->{select} = {
6684 wakaba 1.121 %HTMLChecker,
6685 wakaba 1.163 ## ISSUE: HTML5 has no requirement like these:
6686 wakaba 1.52 ## TODO: author should SELECTED at least one OPTION in non-MULTIPLE case [HTML4].
6687     ## TODO: more than one OPTION with SELECTED in non-MULTIPLE case is "error" [HTML4]
6688 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6689 wakaba 1.56 is_root => 1, ## TODO: SHOULD NOT in application/xhtml+xml [WF2]
6690 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6691 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6692 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6693 wakaba 1.56 data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
6694 wakaba 1.136 form => $HTMLFormAttrChecker,
6695 wakaba 1.52 multiple => $GetHTMLBooleanAttrChecker->('multiple'),
6696 wakaba 1.165 name => $FormControlNameAttrChecker,
6697 wakaba 1.163 ## TODO: tests for on*
6698 wakaba 1.126 onformchange => $HTMLEventHandlerAttrChecker,
6699     onforminput => $HTMLEventHandlerAttrChecker,
6700     oninput => $HTMLEventHandlerAttrChecker,
6701 wakaba 1.56 oninvalid => $HTMLEventHandlerAttrChecker,
6702 wakaba 1.163 size => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6703 wakaba 1.52 }, {
6704     %HTMLAttrStatus,
6705     %HTMLM12NCommonAttrStatus,
6706 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_WF2,
6707 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
6708 wakaba 1.56 data => FEATURE_WF2,
6709 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
6710     dataformatas => FEATURE_HTML4_REC_RESERVED,
6711     datasrc => FEATURE_HTML4_REC_RESERVED,
6712 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6713     form => FEATURE_HTML5_LC | FEATURE_WF2X,
6714     lang => FEATURE_HTML5_REC,
6715     multiple => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6716     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6717 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6718     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6719 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
6720     onforminput => FEATURE_WF2_INFORMATIVE,
6721 wakaba 1.52 onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6722 wakaba 1.126 oninput => FEATURE_WF2,
6723 wakaba 1.56 oninvalid => FEATURE_WF2,
6724 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
6725     sdapref => FEATURE_HTML20_RFC,
6726 wakaba 1.187 size => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6727 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6728     }),
6729 wakaba 1.66 check_start => sub {
6730     my ($self, $item, $element_state) = @_;
6731 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6732 wakaba 1.66
6733     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
6734     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6735 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6736     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6737 wakaba 1.192 }, # check_start
6738     check_attrs2 => sub {
6739     my ($self, $item, $element_state) = @_;
6740     $FAECheckAttrs2->($self, $item, $element_state);
6741     }, # check_attrs2
6742 wakaba 1.121 check_child_element => sub {
6743 wakaba 1.163 ## NOTE: (option | optgroup)*
6744    
6745 wakaba 1.121 my ($self, $item, $child_el, $child_nsuri, $child_ln,
6746     $child_is_transparent, $element_state) = @_;
6747 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6748     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6749 wakaba 1.121 $self->{onerror}->(node => $child_el,
6750     type => 'element not allowed:minus',
6751     level => $self->{level}->{must});
6752     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6753     #
6754     } elsif ($child_nsuri eq $HTML_NS and
6755     {
6756     option => 1, optgroup => 1,
6757     }->{$child_ln}) {
6758     #
6759     } else {
6760     $self->{onerror}->(node => $child_el, type => 'element not allowed',
6761     level => $self->{level}->{must});
6762     }
6763     },
6764     check_child_text => sub {
6765     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6766     if ($has_significant) {
6767     $self->{onerror}->(node => $child_node, type => 'character not allowed',
6768     level => $self->{level}->{must});
6769     }
6770     },
6771 wakaba 1.52 };
6772 wakaba 1.1
6773 wakaba 1.52 $Element->{$HTML_NS}->{datalist} = {
6774 wakaba 1.121 %HTMLPhrasingContentChecker,
6775 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X,
6776 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
6777     data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
6778     }, {
6779 wakaba 1.52 %HTMLAttrStatus,
6780 wakaba 1.56 data => FEATURE_WF2,
6781 wakaba 1.52 }),
6782 wakaba 1.66 check_start => sub {
6783     my ($self, $item, $element_state) = @_;
6784    
6785 wakaba 1.121 $element_state->{phase} = 'any'; # any | phrasing | option
6786    
6787 wakaba 1.66 $element_state->{uri_info}->{data}->{type}->{resource} = 1;
6788 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6789     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6790 wakaba 1.158
6791     $element_state->{id_type} = 'datalist';
6792 wakaba 1.66 },
6793 wakaba 1.121 ## NOTE: phrasing | option*
6794     check_child_element => sub {
6795     my ($self, $item, $child_el, $child_nsuri, $child_ln,
6796     $child_is_transparent, $element_state) = @_;
6797 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6798     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6799 wakaba 1.121 $self->{onerror}->(node => $child_el,
6800     type => 'element not allowed:minus',
6801     level => $self->{level}->{must});
6802     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6803     #
6804     } elsif ($element_state->{phase} eq 'phrasing') {
6805     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
6806     #
6807     } else {
6808     $self->{onerror}->(node => $child_el,
6809     type => 'element not allowed:phrasing',
6810     level => $self->{level}->{must});
6811     }
6812     } elsif ($element_state->{phase} eq 'option') {
6813     if ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6814     #
6815     } else {
6816     $self->{onerror}->(node => $child_el,
6817     type => 'element not allowed',
6818     level => $self->{level}->{must});
6819     }
6820     } elsif ($element_state->{phase} eq 'any') {
6821     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
6822     $element_state->{phase} = 'phrasing';
6823     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6824     $element_state->{phase} = 'option';
6825     } else {
6826     $self->{onerror}->(node => $child_el,
6827     type => 'element not allowed',
6828     level => $self->{level}->{must});
6829     }
6830     } else {
6831     die "check_child_element: Bad |datalist| phase: $element_state->{phase}";
6832     }
6833     },
6834     check_child_text => sub {
6835     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6836     if ($has_significant) {
6837     if ($element_state->{phase} eq 'phrasing') {
6838     #
6839     } elsif ($element_state->{phase} eq 'any') {
6840     $element_state->{phase} = 'phrasing';
6841     } else {
6842     $self->{onerror}->(node => $child_node,
6843     type => 'character not allowed',
6844     level => $self->{level}->{must});
6845     }
6846     }
6847     },
6848     check_end => sub {
6849     my ($self, $item, $element_state) = @_;
6850     if ($element_state->{phase} eq 'phrasing') {
6851     if ($element_state->{has_significant}) {
6852     $item->{real_parent_state}->{has_significant} = 1;
6853     } elsif ($item->{transparent}) {
6854     #
6855     } else {
6856     $self->{onerror}->(node => $item->{node},
6857     type => 'no significant content',
6858     level => $self->{level}->{should});
6859     }
6860     } else {
6861     ## NOTE: Since the content model explicitly allows a |datalist| element
6862     ## being empty, we don't raise "no significant content" error for this
6863     ## element when there is no element. (We should raise an error for
6864     ## |<datalist><br></datalist>|, however.)
6865     ## NOTE: As a side-effect, when the |datalist| element only contains
6866     ## non-conforming content, then the |phase| flag has not changed from
6867     ## |any|, no "no significant content" error is raised neither.
6868     $HTMLChecker{check_end}->(@_);
6869     }
6870     },
6871 wakaba 1.52 };
6872 wakaba 1.49
6873 wakaba 1.52 $Element->{$HTML_NS}->{optgroup} = {
6874 wakaba 1.121 %HTMLChecker,
6875 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6876 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6877     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6878 wakaba 1.164 label => sub {},
6879 wakaba 1.52 }, {
6880     %HTMLAttrStatus,
6881     %HTMLM12NCommonAttrStatus,
6882 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6883     label => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6884     lang => FEATURE_HTML5_REC,
6885 wakaba 1.52 }),
6886 wakaba 1.164 check_attrs2 => sub {
6887     my ($self, $item, $element_state) = @_;
6888    
6889     unless ($item->{node}->has_attribute_ns (undef, 'label')) {
6890     $self->{onerror}->(node => $item->{node},
6891     type => 'attribute missing',
6892     text => 'label',
6893     level => $self->{level}->{must});
6894     }
6895     },
6896 wakaba 1.121 check_child_element => sub {
6897     my ($self, $item, $child_el, $child_nsuri, $child_ln,
6898     $child_is_transparent, $element_state) = @_;
6899 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6900     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6901 wakaba 1.121 $self->{onerror}->(node => $child_el,
6902     type => 'element not allowed:minus',
6903     level => $self->{level}->{must});
6904     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6905     #
6906     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6907     #
6908     } else {
6909     $self->{onerror}->(node => $child_el, type => 'element not allowed',
6910     level => $self->{level}->{must});
6911     }
6912     },
6913     check_child_text => sub {
6914     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6915     if ($has_significant) {
6916     $self->{onerror}->(node => $child_node, type => 'character not allowed',
6917     level => $self->{level}->{must});
6918     }
6919     },
6920 wakaba 1.52 };
6921    
6922     $Element->{$HTML_NS}->{option} = {
6923     %HTMLTextChecker,
6924 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6925 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6926     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6927 wakaba 1.164 label => sub {}, ## NOTE: No restriction.
6928     selected => $GetHTMLBooleanAttrChecker->('selected'), ## ISSUE: Not a "boolean attribute"
6929     value => sub {}, ## NOTE: No restriction.
6930 wakaba 1.52 }, {
6931     %HTMLAttrStatus,
6932     %HTMLM12NCommonAttrStatus,
6933 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6934     label => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6935     lang => FEATURE_HTML5_REC,
6936 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
6937     sdapref => FEATURE_HTML20_RFC,
6938 wakaba 1.187 selected => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6939     value => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6940 wakaba 1.52 }),
6941     };
6942 wakaba 1.49
6943 wakaba 1.52 $Element->{$HTML_NS}->{textarea} = {
6944     %HTMLTextChecker,
6945 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6946 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6947 wakaba 1.164 accept => $HTMLIMTAttrChecker, ## TODO: MUST be a text-based type [WF2]
6948 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6949 wakaba 1.164 cols => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6950 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6951 wakaba 1.136 form => $HTMLFormAttrChecker,
6952 wakaba 1.56 ## TODO: inputmode [WF2]
6953 wakaba 1.164 maxlength => sub {
6954     my ($self, $attr, $item, $element_state) = @_;
6955    
6956     $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 })->(@_);
6957    
6958 wakaba 1.165 if ($attr->value =~ /^[\x09\x0A\x0C\x0D\x20]*([0-9]+)/) {
6959 wakaba 1.164 ## NOTE: Applying the rules for parsing non-negative integers
6960     ## results in a number.
6961     my $max_allowed_value_length = 0+$1;
6962    
6963     ## ISSUE: "The the purposes of this requirement," (typo)
6964    
6965     ## ISSUE: This constraint is applied w/o CRLF normalization to
6966     ## |value| attribute, but w/ CRLF normalization to
6967     ## concept-value.
6968     my $value = $item->{node}->text_content;
6969     if (defined $value) {
6970     my $codepoint_length = length $value;
6971    
6972     if ($codepoint_length > $max_allowed_value_length) {
6973     $self->{onerror}->(node => $item->{node},
6974     type => 'value too long',
6975     level => $self->{level}->{must});
6976     }
6977     }
6978     }
6979     },
6980 wakaba 1.165 name => $FormControlNameAttrChecker,
6981 wakaba 1.164 onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
6982     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6983     oninput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6984 wakaba 1.161 pattern => $PatternAttrChecker,
6985 wakaba 1.179 placeholder => $PlaceholderAttrChecker,
6986 wakaba 1.52 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6987 wakaba 1.56 required => $GetHTMLBooleanAttrChecker->('required'),
6988 wakaba 1.164 rows => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6989     oninput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6990     oninvalid => $HTMLEventHandlerAttrChecker, ## TODO: tests
6991 wakaba 1.161 ## NOTE: |title| had special semantics if |pattern| was specified [WF2].
6992 wakaba 1.56 wrap => $GetHTMLEnumeratedAttrChecker->({soft => 1, hard => 1}),
6993 wakaba 1.52 }, {
6994     %HTMLAttrStatus,
6995     %HTMLM12NCommonAttrStatus,
6996 wakaba 1.164 accept => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6997 wakaba 1.61 'accept-charset' => FEATURE_HTML2X_RFC,
6998 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_M12N10_REC,
6999 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
7000     cols => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7001 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
7002 wakaba 1.49 dataformatas => FEATURE_HTML4_REC_RESERVED,
7003     datasrc => FEATURE_HTML4_REC_RESERVED,
7004 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
7005     form => FEATURE_HTML5_LC | FEATURE_WF2X,
7006 wakaba 1.164 inputmode => FEATURE_HTML5_DROPPED | FEATURE_WF2X | FEATURE_XHTMLBASIC11_CR,
7007 wakaba 1.187 lang => FEATURE_HTML5_REC,
7008 wakaba 1.121 maxlength => FEATURE_HTML5_DEFAULT | FEATURE_WF2X,
7009 wakaba 1.187 name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7010 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
7011     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
7012     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
7013 wakaba 1.164 onformchange => FEATURE_WF2_INFORMATIVE, ## TODO: tests
7014     onforminput => FEATURE_WF2_INFORMATIVE, ## TODO: tests
7015     oninput => FEATURE_WF2, ## TODO: tests
7016     oninvalid => FEATURE_WF2, ## TODO: tests
7017 wakaba 1.52 onselect => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
7018 wakaba 1.161 pattern => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
7019 wakaba 1.179 placeholder => FEATURE_HTML5_LC,
7020 wakaba 1.187 readonly => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
7021     required => FEATURE_HTML5_LC | FEATURE_WF2X,
7022     rows => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7023 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
7024     sdapref => FEATURE_HTML20_RFC,
7025 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
7026 wakaba 1.187 wrap => FEATURE_HTML5_LC | FEATURE_WF2X,
7027 wakaba 1.52 }),
7028 wakaba 1.66 check_start => sub {
7029     my ($self, $item, $element_state) = @_;
7030 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
7031 wakaba 1.164
7032     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
7033     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7034     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7035     },
7036     check_attrs2 => sub {
7037     my ($self, $item, $element_state) = @_;
7038 wakaba 1.66
7039 wakaba 1.161 if ($item->{node}->has_attribute_ns (undef, 'pattern') and
7040     not $item->{node}->has_attribute_ns (undef, 'title')) {
7041     ## NOTE: WF2 (dropped by HTML5)
7042     $self->{onerror}->(node => $item->{node},
7043     type => 'attribute missing',
7044     text => 'title',
7045     level => $self->{level}->{should});
7046     }
7047    
7048 wakaba 1.164 unless ($item->{node}->has_attribute_ns (undef, 'cols')) {
7049     my $wrap = $item->{node}->get_attribute_ns (undef, 'wrap');
7050     if (defined $wrap) {
7051     $wrap =~ tr/A-Z/a-z/; ## ASCII case-insensitive
7052     if ($wrap eq 'hard') {
7053     $self->{onerror}->(node => $item->{node},
7054     type => 'attribute missing',
7055     text => 'cols',
7056     level => $self->{level}->{must});
7057     }
7058     }
7059     }
7060 wakaba 1.192
7061     $FAECheckAttrs2->($self, $item, $element_state);
7062     }, # check_attrs2
7063 wakaba 1.194 }; # textarea
7064    
7065     $Element->{$HTML_NS}->{keygen} = {
7066     %HTMLEmptyChecker,
7067     status => FEATURE_HTML5_FD,
7068     check_attrs => $GetHTMLAttrsChecker->({
7069     autofocus => $AutofocusAttrChecker,
7070     challenge => sub { }, ## No constraints.
7071     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
7072     form => $HTMLFormAttrChecker,
7073     keytype => $GetHTMLEnumeratedAttrChecker->({rsa => 1}),
7074     name => $FormControlNameAttrChecker,
7075     }, {
7076     %HTMLAttrStatus,
7077     autofocus => FEATURE_HTML5_LC,
7078     challenge => FEATURE_HTML5_FD,
7079     disabled => FEATURE_HTML5_LC,
7080     form => FEATURE_HTML5_LC,
7081     keytype => FEATURE_HTML5_FD,
7082     name => FEATURE_HTML5_LC,
7083     }), # check_attrs
7084     check_start => sub {
7085     my ($self, $item, $element_state) = @_;
7086     $FAECheckStart->($self, $item, $element_state);
7087    
7088     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7089     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7090     }, # check_start
7091     check_attrs2 => sub {
7092     my ($self, $item, $element_state) = @_;
7093     $FAECheckAttrs2->($self, $item, $element_state);
7094     }, # check_attrs2
7095     }; # keygen
7096 wakaba 1.49
7097 wakaba 1.52 $Element->{$HTML_NS}->{output} = {
7098 wakaba 1.121 %HTMLPhrasingContentChecker,
7099 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X,
7100 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
7101 wakaba 1.165 for => sub {
7102     my ($self, $attr) = @_;
7103    
7104     ## NOTE: "Unordered set of unique space-separated tokens".
7105    
7106     my %word;
7107     for my $word (grep {length $_}
7108     split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
7109     unless ($word{$word}) {
7110     $word{$word} = 1;
7111     push @{$self->{idref}}, ['any', $word, $attr];
7112     } else {
7113     $self->{onerror}->(node => $attr, type => 'duplicate token',
7114     value => $word,
7115     level => $self->{level}->{must});
7116     }
7117     }
7118     },
7119 wakaba 1.136 form => $HTMLFormAttrChecker,
7120 wakaba 1.165 name => $FormControlNameAttrChecker,
7121     onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
7122     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
7123 wakaba 1.56 }, {
7124 wakaba 1.52 %HTMLAttrStatus,
7125 wakaba 1.187 for => FEATURE_HTML5_LC | FEATURE_WF2X,
7126     form => FEATURE_HTML5_LC | FEATURE_WF2X,
7127     name => FEATURE_HTML5_LC | FEATURE_WF2X,
7128 wakaba 1.56 onchange => FEATURE_HTML5_DEFAULT | FEATURE_WF2,
7129     onformchange => FEATURE_WF2,
7130     onforminput => FEATURE_WF2,
7131 wakaba 1.52 }),
7132     };
7133    
7134     $Element->{$HTML_NS}->{isindex} = {
7135     %HTMLEmptyChecker,
7136 wakaba 1.54 status => FEATURE_M12N10_REC_DEPRECATED |
7137     Whatpm::ContentChecker::FEATURE_DEPRECATED_SHOULD, ## [HTML4]
7138 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
7139     prompt => sub {}, ## NOTE: Text [M12N]
7140     }, {
7141     %HTMLAttrStatus,
7142 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7143     dir => FEATURE_HTML5_REC,
7144     id => FEATURE_HTML5_REC,
7145     lang => FEATURE_HTML5_REC,
7146 wakaba 1.52 prompt => FEATURE_M12N10_REC_DEPRECATED,
7147 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
7148 wakaba 1.187 style => FEATURE_HTML5_REC,
7149     title => FEATURE_HTML5_REC,
7150 wakaba 1.52 }),
7151     ## TODO: Tests
7152     ## TODO: Tests for <nest/> in <isindex>
7153 wakaba 1.66 check_start => sub {
7154     my ($self, $item, $element_state) = @_;
7155    
7156     $element_state->{uri_info}->{action}->{type}->{action} = 1;
7157 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7158     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7159 wakaba 1.66 },
7160 wakaba 1.52 };
7161 wakaba 1.49
7162 wakaba 1.1 $Element->{$HTML_NS}->{script} = {
7163 wakaba 1.40 %HTMLChecker,
7164 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7165 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7166 wakaba 1.91 charset => sub {
7167     my ($self, $attr) = @_;
7168    
7169     unless ($attr->owner_element->has_attribute_ns (undef, 'src')) {
7170     $self->{onerror}->(type => 'attribute not allowed',
7171     node => $attr,
7172 wakaba 1.104 level => $self->{level}->{must});
7173 wakaba 1.91 }
7174    
7175 wakaba 1.188 ## XXXresource: MUST match the charset of the referenced
7176     ## resource (HTML5 revision 2967).
7177    
7178 wakaba 1.91 $HTMLCharsetChecker->($attr->value, @_);
7179     },
7180 wakaba 1.86 language => sub {}, ## NOTE: No syntax constraint according to HTML4.
7181 wakaba 1.91 src => $HTMLURIAttrChecker, ## TODO: pointed resource MUST be in type of type="" (resource error)
7182 wakaba 1.1 defer => $GetHTMLBooleanAttrChecker->('defer'),
7183     async => $GetHTMLBooleanAttrChecker->('async'),
7184 wakaba 1.91 type => $HTMLIMTAttrChecker, ## TODO: MUST NOT: |charset=""| parameter
7185 wakaba 1.49 }, {
7186     %HTMLAttrStatus,
7187 wakaba 1.153 async => FEATURE_HTML5_WD,
7188     charset => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7189     defer => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7190 wakaba 1.49 event => FEATURE_HTML4_REC_RESERVED,
7191     for => FEATURE_HTML4_REC_RESERVED,
7192 wakaba 1.154 href => FEATURE_RDFA_REC,
7193 wakaba 1.187 id => FEATURE_HTML5_REC,
7194 wakaba 1.49 language => FEATURE_M12N10_REC_DEPRECATED,
7195 wakaba 1.153 src => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7196     type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7197 wakaba 1.9 }),
7198 wakaba 1.191 check_attrs2 => sub {
7199     my ($self, $item, $element_state) = @_;
7200    
7201     my $el = $item->{node};
7202     if ($el->has_attribute_ns (undef, 'defer') and
7203     not $el->has_attribute_ns (undef, 'src')) {
7204     $self->{onerror}->(node => $el,
7205     type => 'attribute missing',
7206     text => 'src',
7207     level => $self->{level}->{must});
7208     }
7209     },
7210 wakaba 1.40 check_start => sub {
7211     my ($self, $item, $element_state) = @_;
7212 wakaba 1.1
7213 wakaba 1.40 if ($item->{node}->has_attribute_ns (undef, 'src')) {
7214     $element_state->{must_be_empty} = 1;
7215 wakaba 1.1 } else {
7216     ## NOTE: No content model conformance in HTML5 spec.
7217 wakaba 1.40 my $type = $item->{node}->get_attribute_ns (undef, 'type');
7218     my $language = $item->{node}->get_attribute_ns (undef, 'language');
7219 wakaba 1.1 if ((defined $type and $type eq '') or
7220     (defined $language and $language eq '')) {
7221     $type = 'text/javascript';
7222     } elsif (defined $type) {
7223     #
7224     } elsif (defined $language) {
7225     $type = 'text/' . $language;
7226     } else {
7227     $type = 'text/javascript';
7228     }
7229 wakaba 1.93
7230     if ($type =~ m[\A(?>(?>\x0D\x0A)?[\x09\x20])*([\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+)(?>(?>\x0D\x0A)?[\x09\x20])*/(?>(?>\x0D\x0A)?[\x09\x20])*([\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7E]+)(?>(?>\x0D\x0A)?[\x09\x20])*(?>;|\z)]) {
7231     $type = "$1/$2";
7232     $type =~ tr/A-Z/a-z/; ## NOTE: ASCII case-insensitive
7233     ## TODO: Though we strip prameter here, it should not be ignored for the purpose of conformance checking...
7234     }
7235     $element_state->{script_type} = $type;
7236 wakaba 1.40 }
7237 wakaba 1.66
7238     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7239 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7240     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7241 wakaba 1.107
7242     $element_state->{text} = '';
7243 wakaba 1.40 },
7244     check_child_element => sub {
7245     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7246     $child_is_transparent, $element_state) = @_;
7247 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7248     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7249 wakaba 1.40 $self->{onerror}->(node => $child_el,
7250     type => 'element not allowed:minus',
7251 wakaba 1.104 level => $self->{level}->{must});
7252 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7253     #
7254     } else {
7255     if ($element_state->{must_be_empty}) {
7256     $self->{onerror}->(node => $child_el,
7257 wakaba 1.104 type => 'element not allowed:empty',
7258     level => $self->{level}->{must});
7259 wakaba 1.40 }
7260     }
7261     },
7262     check_child_text => sub {
7263     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7264     if ($has_significant and
7265     $element_state->{must_be_empty}) {
7266     $self->{onerror}->(node => $child_node,
7267 wakaba 1.104 type => 'character not allowed:empty',
7268     level => $self->{level}->{must});
7269 wakaba 1.40 }
7270 wakaba 1.115 $element_state->{text} .= $child_node->data;
7271 wakaba 1.40 },
7272     check_end => sub {
7273     my ($self, $item, $element_state) = @_;
7274     unless ($element_state->{must_be_empty}) {
7275 wakaba 1.93 if ($element_state->{script_type} =~ m![+/][Xx][Mm][Ll]\z!) {
7276     ## NOTE: XML content should be checked by THIS instance of checker
7277     ## as part of normal tree validation.
7278 wakaba 1.104 $self->{onerror}->(node => $item->{node},
7279     type => 'XML script lang',
7280     text => $element_state->{script_type},
7281     level => $self->{level}->{uncertain});
7282     ## ISSUE: Should we raise some kind of error for
7283     ## <script type="text/xml">aaaaa</script>?
7284     ## NOTE: ^^^ This is why we throw an "uncertain" error.
7285 wakaba 1.93 } else {
7286     $self->{onsubdoc}->({s => $element_state->{text},
7287     container_node => $item->{node},
7288     media_type => $element_state->{script_type},
7289     is_char_string => 1});
7290     }
7291 wakaba 1.40
7292     $HTMLChecker{check_end}->(@_);
7293 wakaba 1.1 }
7294     },
7295 wakaba 1.91 ## TODO: There MUST be |type| unless the script type is JavaScript. (resource error)
7296     ## NOTE: "When used to include script data, the script data must be embedded
7297     ## inline, the format of the data must be given using the type attribute,
7298     ## and the src attribute must not be specified." - not testable.
7299     ## TODO: It would be possible to err <script type=text/plain src=...>
7300 wakaba 1.1 };
7301 wakaba 1.25 ## ISSUE: Significant check and text child node
7302 wakaba 1.1
7303     ## NOTE: When script is disabled.
7304     $Element->{$HTML_NS}->{noscript} = {
7305 wakaba 1.40 %HTMLTransparentChecker,
7306 wakaba 1.187 status => FEATURE_HTML5_REC,
7307 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
7308     %HTMLAttrStatus,
7309     %HTMLM12NCommonAttrStatus,
7310 wakaba 1.187 lang => FEATURE_HTML5_REC,
7311 wakaba 1.49 }),
7312 wakaba 1.40 check_start => sub {
7313     my ($self, $item, $element_state) = @_;
7314 wakaba 1.3
7315 wakaba 1.40 unless ($item->{node}->owner_document->manakai_is_html) {
7316 wakaba 1.104 $self->{onerror}->(node => $item->{node}, type => 'in XML:noscript',
7317     level => $self->{level}->{must});
7318 wakaba 1.3 }
7319    
7320 wakaba 1.40 unless ($self->{flag}->{in_head}) {
7321     $self->_add_minus_elements ($element_state,
7322     {$HTML_NS => {noscript => 1}});
7323     }
7324 wakaba 1.79
7325     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7326     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7327 wakaba 1.3 },
7328 wakaba 1.40 check_child_element => sub {
7329     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7330     $child_is_transparent, $element_state) = @_;
7331     if ($self->{flag}->{in_head}) {
7332 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7333     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7334 wakaba 1.40 $self->{onerror}->(node => $child_el,
7335     type => 'element not allowed:minus',
7336 wakaba 1.104 level => $self->{level}->{must});
7337 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7338     #
7339     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'link') {
7340     #
7341     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'style') {
7342     if ($child_el->has_attribute_ns (undef, 'scoped')) {
7343     $self->{onerror}->(node => $child_el,
7344     type => 'element not allowed:head noscript',
7345 wakaba 1.104 level => $self->{level}->{must});
7346 wakaba 1.40 }
7347     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'meta') {
7348 wakaba 1.47 my $http_equiv_attr
7349     = $child_el->get_attribute_node_ns (undef, 'http-equiv');
7350     if ($http_equiv_attr) {
7351     ## TODO: case
7352     if (lc $http_equiv_attr->value eq 'content-type') {
7353 wakaba 1.40 $self->{onerror}->(node => $child_el,
7354 wakaba 1.34 type => 'element not allowed:head noscript',
7355 wakaba 1.104 level => $self->{level}->{must});
7356 wakaba 1.47 } else {
7357     #
7358 wakaba 1.3 }
7359 wakaba 1.47 } else {
7360     $self->{onerror}->(node => $child_el,
7361     type => 'element not allowed:head noscript',
7362 wakaba 1.104 level => $self->{level}->{must});
7363 wakaba 1.3 }
7364 wakaba 1.40 } else {
7365     $self->{onerror}->(node => $child_el,
7366     type => 'element not allowed:head noscript',
7367 wakaba 1.104 level => $self->{level}->{must});
7368 wakaba 1.40 }
7369     } else {
7370     $HTMLTransparentChecker{check_child_element}->(@_);
7371     }
7372     },
7373     check_child_text => sub {
7374     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7375     if ($self->{flag}->{in_head}) {
7376     if ($has_significant) {
7377     $self->{onerror}->(node => $child_node,
7378 wakaba 1.104 type => 'character not allowed',
7379     level => $self->{level}->{must});
7380 wakaba 1.3 }
7381     } else {
7382 wakaba 1.40 $HTMLTransparentChecker{check_child_text}->(@_);
7383     }
7384     },
7385     check_end => sub {
7386     my ($self, $item, $element_state) = @_;
7387     $self->_remove_minus_elements ($element_state);
7388     if ($self->{flag}->{in_head}) {
7389     $HTMLChecker{check_end}->(@_);
7390     } else {
7391     $HTMLPhrasingContentChecker{check_end}->(@_);
7392 wakaba 1.3 }
7393 wakaba 1.1 },
7394     };
7395 wakaba 1.3 ## ISSUE: Scripting is disabled: <head><noscript><html a></noscript></head>
7396 wakaba 1.1
7397     $Element->{$HTML_NS}->{'event-source'} = {
7398 wakaba 1.40 %HTMLEmptyChecker,
7399 wakaba 1.118 status => FEATURE_HTML5_LC_DROPPED,
7400     check_attrs => $GetHTMLAttrsChecker->({
7401     src => $HTMLURIAttrChecker,
7402     }, {
7403     %HTMLAttrStatus,
7404     src => FEATURE_HTML5_LC_DROPPED,
7405     }),
7406     check_start => sub {
7407     my ($self, $item, $element_state) = @_;
7408    
7409     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7410     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7411     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7412     },
7413     };
7414    
7415     $Element->{$HTML_NS}->{eventsource} = {
7416     %HTMLEmptyChecker,
7417 wakaba 1.180 status => FEATURE_HTML5_DROPPED,
7418 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7419 wakaba 1.1 src => $HTMLURIAttrChecker,
7420 wakaba 1.50 }, {
7421     %HTMLAttrStatus,
7422 wakaba 1.180 src => FEATURE_HTML5_DROPPED,
7423 wakaba 1.1 }),
7424 wakaba 1.66 check_start => sub {
7425     my ($self, $item, $element_state) = @_;
7426    
7427     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7428 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7429     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7430 wakaba 1.66 },
7431 wakaba 1.1 };
7432    
7433     $Element->{$HTML_NS}->{details} = {
7434 wakaba 1.134 %{$Element->{$HTML_NS}->{fieldset}},
7435 wakaba 1.153 status => FEATURE_HTML5_LC,
7436 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7437 wakaba 1.1 open => $GetHTMLBooleanAttrChecker->('open'),
7438 wakaba 1.50 }, {
7439     %HTMLAttrStatus,
7440 wakaba 1.153 open => FEATURE_HTML5_LC,
7441 wakaba 1.1 }),
7442     };
7443    
7444     $Element->{$HTML_NS}->{datagrid} = {
7445 wakaba 1.72 %HTMLFlowContentChecker,
7446 wakaba 1.197 status => FEATURE_HTML5_DROPPED,
7447 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7448 wakaba 1.1 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
7449     multiple => $GetHTMLBooleanAttrChecker->('multiple'),
7450 wakaba 1.50 }, {
7451     %HTMLAttrStatus,
7452 wakaba 1.197 disabled => FEATURE_HTML5_DROPPED,
7453     multiple => FEATURE_HTML5_DROPPED,
7454     }), # check_attrs
7455     }; # datagrid
7456 wakaba 1.1
7457     $Element->{$HTML_NS}->{command} = {
7458 wakaba 1.40 %HTMLEmptyChecker,
7459 wakaba 1.48 status => FEATURE_HTML5_WD,
7460 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7461 wakaba 1.1 checked => $GetHTMLBooleanAttrChecker->('checked'),
7462     default => $GetHTMLBooleanAttrChecker->('default'),
7463     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
7464     icon => $HTMLURIAttrChecker,
7465     label => sub { }, ## NOTE: No conformance creteria
7466     radiogroup => sub { }, ## NOTE: No conformance creteria
7467     type => sub {
7468     my ($self, $attr) = @_;
7469     my $value = $attr->value;
7470     unless ({command => 1, checkbox => 1, radio => 1}->{$value}) {
7471 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'invalid attribute value',
7472     level => $self->{level}->{must});
7473 wakaba 1.1 }
7474     },
7475 wakaba 1.50 }, {
7476     %HTMLAttrStatus,
7477     checked => FEATURE_HTML5_WD,
7478 wakaba 1.175 default => FEATURE_HTML5_DROPPED, # HTML5 revision 3067
7479 wakaba 1.50 disabled => FEATURE_HTML5_WD,
7480     icon => FEATURE_HTML5_WD,
7481     label => FEATURE_HTML5_WD,
7482     radiogroup => FEATURE_HTML5_WD,
7483     type => FEATURE_HTML5_WD,
7484 wakaba 1.1 }),
7485 wakaba 1.66 check_start => sub {
7486     my ($self, $item, $element_state) = @_;
7487    
7488     $element_state->{uri_info}->{icon}->{type}->{embedded} = 1;
7489 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7490     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7491 wakaba 1.66 },
7492 wakaba 1.115 };
7493    
7494     $Element->{$HTML_NS}->{bb} = {
7495     %HTMLPhrasingContentChecker,
7496 wakaba 1.190 status => FEATURE_HTML5_DROPPED,
7497 wakaba 1.115 check_attrs => $GetHTMLAttrsChecker->({
7498     type => $GetHTMLEnumeratedAttrChecker->({makeapp => 1}),
7499     }, {
7500     %HTMLAttrStatus,
7501 wakaba 1.190 type => FEATURE_HTML5_DROPPED,
7502 wakaba 1.115 }),
7503 wakaba 1.130 check_start => sub {
7504     my ($self, $item, $element_state) = @_;
7505     $self->_add_minus_elements ($element_state, $HTMLInteractiveContent);
7506    
7507     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7508     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7509     },
7510     check_end => sub {
7511     my ($self, $item, $element_state) = @_;
7512     $self->_remove_minus_elements ($element_state);
7513    
7514     $HTMLTransparentChecker{check_end}->(@_);
7515     },
7516 wakaba 1.1 };
7517    
7518     $Element->{$HTML_NS}->{menu} = {
7519 wakaba 1.40 %HTMLPhrasingContentChecker,
7520 wakaba 1.54 #status => FEATURE_M12N10_REC_DEPRECATED | FEATURE_HTML5_WD,
7521     status => FEATURE_M12N10_REC | FEATURE_HTML5_WD,
7522     ## NOTE: We don't want any |menu| element warned as deprecated.
7523 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7524 wakaba 1.1 autosubmit => $GetHTMLBooleanAttrChecker->('autosubmit'),
7525 wakaba 1.68 compact => $GetHTMLBooleanAttrChecker->('compact'),
7526 wakaba 1.135 ## ISSUE: <menu id=""><p contextmenu=""> match? (In the current
7527     ## implementation, it does not match.)
7528 wakaba 1.1 label => sub { }, ## NOTE: No conformance creteria
7529     type => $GetHTMLEnumeratedAttrChecker->({context => 1, toolbar => 1}),
7530 wakaba 1.49 }, {
7531     %HTMLAttrStatus,
7532     %HTMLM12NCommonAttrStatus,
7533 wakaba 1.61 align => FEATURE_HTML2X_RFC,
7534 wakaba 1.113 autosubmit => FEATURE_HTML5_DROPPED,
7535 wakaba 1.49 compat => FEATURE_M12N10_REC_DEPRECATED,
7536 wakaba 1.50 label => FEATURE_HTML5_WD,
7537 wakaba 1.187 lang => FEATURE_HTML5_REC,
7538 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
7539     sdapref => FEATURE_HTML20_RFC,
7540 wakaba 1.50 type => FEATURE_HTML5_WD,
7541 wakaba 1.207 }), # check_attrs
7542 wakaba 1.40 check_start => sub {
7543     my ($self, $item, $element_state) = @_;
7544     $element_state->{phase} = 'li or phrasing';
7545 wakaba 1.79
7546     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7547     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7548 wakaba 1.135 $element_state->{id_type} = 'menu';
7549 wakaba 1.207 }, # check_start
7550 wakaba 1.40 check_child_element => sub {
7551     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7552     $child_is_transparent, $element_state) = @_;
7553 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7554     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7555 wakaba 1.40 $self->{onerror}->(node => $child_el,
7556     type => 'element not allowed:minus',
7557 wakaba 1.104 level => $self->{level}->{must});
7558 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7559     #
7560     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'li') {
7561     if ($element_state->{phase} eq 'li') {
7562     #
7563     } elsif ($element_state->{phase} eq 'li or phrasing') {
7564     $element_state->{phase} = 'li';
7565     } else {
7566 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7567     level => $self->{level}->{must});
7568 wakaba 1.40 }
7569     } elsif ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
7570     if ($element_state->{phase} eq 'phrasing') {
7571     #
7572     } elsif ($element_state->{phase} eq 'li or phrasing') {
7573     $element_state->{phase} = 'phrasing';
7574     } else {
7575 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7576     level => $self->{level}->{must});
7577 wakaba 1.40 }
7578     } else {
7579 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7580     level => $self->{level}->{must});
7581 wakaba 1.40 }
7582 wakaba 1.207 }, # check_child_element
7583 wakaba 1.40 check_child_text => sub {
7584     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7585     if ($has_significant) {
7586     if ($element_state->{phase} eq 'phrasing') {
7587     #
7588     } elsif ($element_state->{phase} eq 'li or phrasing') {
7589     $element_state->{phase} = 'phrasing';
7590     } else {
7591     $self->{onerror}->(node => $child_node,
7592 wakaba 1.104 type => 'character not allowed',
7593     level => $self->{level}->{must});
7594 wakaba 1.1 }
7595     }
7596 wakaba 1.207 }, # check_child_text
7597 wakaba 1.40 check_end => sub {
7598     my ($self, $item, $element_state) = @_;
7599     if ($element_state->{phase} eq 'li') {
7600     $HTMLChecker{check_end}->(@_);
7601     } else { # 'phrasing' or 'li or phrasing'
7602     $HTMLPhrasingContentChecker{check_end}->(@_);
7603 wakaba 1.1 }
7604 wakaba 1.207 }, # check_end
7605     }; # menu
7606 wakaba 1.8
7607     $Element->{$HTML_NS}->{datatemplate} = {
7608 wakaba 1.40 %HTMLChecker,
7609 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7610 wakaba 1.40 check_child_element => sub {
7611     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7612     $child_is_transparent, $element_state) = @_;
7613 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7614     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7615 wakaba 1.40 $self->{onerror}->(node => $child_el,
7616     type => 'element not allowed:minus',
7617 wakaba 1.104 level => $self->{level}->{must});
7618 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7619     #
7620     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'rule') {
7621     #
7622     } else {
7623     $self->{onerror}->(node => $child_el,
7624 wakaba 1.104 type => 'element not allowed:datatemplate',
7625     level => $self->{level}->{must});
7626 wakaba 1.40 }
7627     },
7628     check_child_text => sub {
7629     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7630     if ($has_significant) {
7631 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
7632     level => $self->{level}->{must});
7633 wakaba 1.8 }
7634     },
7635     is_xml_root => 1,
7636     };
7637    
7638     $Element->{$HTML_NS}->{rule} = {
7639 wakaba 1.40 %HTMLChecker,
7640 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7641 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7642 wakaba 1.23 condition => $HTMLSelectorsAttrChecker,
7643 wakaba 1.92 mode => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->(),
7644 wakaba 1.50 }, {
7645     %HTMLAttrStatus,
7646 wakaba 1.208 condition => FEATURE_HTML5_DROPPED,
7647     mode => FEATURE_HTML5_DROPPED,
7648 wakaba 1.8 }),
7649 wakaba 1.40 check_start => sub {
7650     my ($self, $item, $element_state) = @_;
7651 wakaba 1.79
7652 wakaba 1.40 $self->_add_plus_elements ($element_state, {$HTML_NS => {nest => 1}});
7653 wakaba 1.79 $element_state->{in_rule_original} = $self->{flag}->{in_rule};
7654     $self->{flag}->{in_rule} = 1;
7655    
7656     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7657     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7658 wakaba 1.40 },
7659     check_child_element => sub { },
7660     check_child_text => sub { },
7661     check_end => sub {
7662     my ($self, $item, $element_state) = @_;
7663 wakaba 1.79
7664 wakaba 1.40 $self->_remove_plus_elements ($element_state);
7665 wakaba 1.79 delete $self->{flag}->{in_rule} unless $element_state->{in_rule_original};
7666    
7667 wakaba 1.40 $HTMLChecker{check_end}->(@_);
7668 wakaba 1.8 },
7669     ## NOTE: "MAY be anything that, when the parent |datatemplate|
7670     ## is applied to some conforming data, results in a conforming DOM tree.":
7671     ## We don't check against this.
7672     };
7673    
7674     $Element->{$HTML_NS}->{nest} = {
7675 wakaba 1.40 %HTMLEmptyChecker,
7676 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7677 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7678 wakaba 1.23 filter => $HTMLSelectorsAttrChecker,
7679     mode => sub {
7680     my ($self, $attr) = @_;
7681     my $value = $attr->value;
7682 wakaba 1.132 if ($value !~ /\A[^\x09\x0A\x0C\x0D\x20]+\z/) {
7683 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'mode:syntax error',
7684     level => $self->{level}->{must});
7685 wakaba 1.23 }
7686     },
7687 wakaba 1.50 }, {
7688     %HTMLAttrStatus,
7689 wakaba 1.208 filter => FEATURE_HTML5_DROPPED,
7690     mode => FEATURE_HTML5_DROPPED,
7691 wakaba 1.8 }),
7692 wakaba 1.1 };
7693    
7694     $Element->{$HTML_NS}->{legend} = {
7695 wakaba 1.40 %HTMLPhrasingContentChecker,
7696 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7697 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
7698 wakaba 1.195 # XXX
7699 wakaba 1.52 # align => $GetHTMLEnumeratedAttrChecker->({
7700     # top => 1, bottom => 1, left => 1, right => 1,
7701     # }),
7702 wakaba 1.167 form => $HTMLFormAttrChecker,
7703 wakaba 1.52 }, {
7704 wakaba 1.49 %HTMLAttrStatus,
7705     %HTMLM12NCommonAttrStatus,
7706 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_M12N10_REC,
7707 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
7708 wakaba 1.167 form => FEATURE_HTML5_DROPPED,
7709 wakaba 1.187 lang => FEATURE_HTML5_REC,
7710 wakaba 1.49 }),
7711 wakaba 1.170 check_child_element => sub {
7712     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7713     $child_is_transparent, $element_state) = @_;
7714 wakaba 1.195 ## XXX This does not work for |<legned><ins><blockquote>|
7715 wakaba 1.170 if ($item->{parent_state}->{in_figure}) {
7716     $HTMLFlowContentChecker{check_child_element}->(@_);
7717     } else {
7718     $HTMLPhrasingContentChecker{check_child_element}->(@_);
7719     }
7720     },
7721     check_child_text => sub {
7722     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7723     if ($item->{parent_state}->{in_figure}) {
7724     $HTMLFlowContentChecker{check_child_text}->(@_);
7725     } else {
7726     $HTMLPhrasingContentChecker{check_child_text}->(@_);
7727     }
7728     },
7729     check_start => sub {
7730     my ($self, $item, $element_state) = @_;
7731     $self->_add_minus_elements ($element_state, {$HTML_NS => {figure => 1}});
7732    
7733     $HTMLFlowContentChecker{check_start}->(@_);
7734     },
7735     check_end => sub {
7736     my ($self, $item, $element_state) = @_;
7737     $self->_remove_minus_elements ($element_state);
7738    
7739     $HTMLFlowContentChecker{check_end}->(@_);
7740     },
7741     }; # legend
7742 wakaba 1.1
7743     $Element->{$HTML_NS}->{div} = {
7744 wakaba 1.72 %HTMLFlowContentChecker,
7745 wakaba 1.187 status => FEATURE_HTML5_REC,
7746 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
7747     align => $GetHTMLEnumeratedAttrChecker->({
7748     left => 1, center => 1, right => 1, justify => 1,
7749     }),
7750     }, {
7751 wakaba 1.49 %HTMLAttrStatus,
7752 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
7753 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
7754     datafld => FEATURE_HTML4_REC_RESERVED,
7755     dataformatas => FEATURE_HTML4_REC_RESERVED,
7756     datasrc => FEATURE_HTML4_REC_RESERVED,
7757 wakaba 1.187 lang => FEATURE_HTML5_REC,
7758 wakaba 1.49 }),
7759 wakaba 1.66 check_start => sub {
7760     my ($self, $item, $element_state) = @_;
7761    
7762     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
7763 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7764     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7765 wakaba 1.66 },
7766 wakaba 1.1 };
7767    
7768 wakaba 1.64 $Element->{$HTML_NS}->{center} = {
7769 wakaba 1.72 %HTMLFlowContentChecker,
7770 wakaba 1.64 status => FEATURE_M12N10_REC_DEPRECATED,
7771     check_attrs => $GetHTMLAttrsChecker->({}, {
7772     %HTMLAttrStatus,
7773     %HTMLM12NCommonAttrStatus,
7774 wakaba 1.187 lang => FEATURE_HTML5_REC,
7775 wakaba 1.64 }),
7776     };
7777    
7778 wakaba 1.1 $Element->{$HTML_NS}->{font} = {
7779 wakaba 1.40 %HTMLTransparentChecker,
7780 wakaba 1.78 status => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC_DEPRECATED,
7781 wakaba 1.70 check_attrs => $GetHTMLAttrsChecker->({
7782     ## TODO: HTML4 |size|, |color|, |face|
7783 wakaba 1.49 }, {
7784     %HTMLAttrStatus,
7785 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7786 wakaba 1.49 color => FEATURE_M12N10_REC_DEPRECATED,
7787 wakaba 1.187 dir => FEATURE_HTML5_REC,
7788 wakaba 1.49 face => FEATURE_M12N10_REC_DEPRECATED,
7789 wakaba 1.187 id => FEATURE_HTML5_REC,
7790     lang => FEATURE_HTML5_REC,
7791 wakaba 1.49 size => FEATURE_M12N10_REC_DEPRECATED,
7792 wakaba 1.187 style => FEATURE_HTML5_REC,
7793     title => FEATURE_HTML5_REC,
7794 wakaba 1.49 }),
7795 wakaba 1.78 ## NOTE: When the |font| element was defined in the HTML5 specification,
7796     ## it is allowed only in a document with the WYSIWYG signature. The
7797     ## checker does not check whether there is the signature, since the
7798     ## signature is dropped, too, and has never been implemented. (In addition,
7799     ## for any |font| element an "element not defined" error is raised anyway,
7800     ## such that we don't have to raise an additional error.)
7801 wakaba 1.1 };
7802 wakaba 1.49
7803 wakaba 1.64 $Element->{$HTML_NS}->{basefont} = {
7804     %HTMLEmptyChecker,
7805     status => FEATURE_M12N10_REC_DEPRECATED,
7806     check_attrs => $GetHTMLAttrsChecker->({
7807     ## TODO: color, face, size
7808     }, {
7809     %HTMLAttrStatus,
7810     color => FEATURE_M12N10_REC_DEPRECATED,
7811     face => FEATURE_M12N10_REC_DEPRECATED,
7812 wakaba 1.187 id => FEATURE_HTML5_REC,
7813 wakaba 1.64 size => FEATURE_M12N10_REC_DEPRECATED,
7814     }),
7815 wakaba 1.188 }; # basefont
7816 wakaba 1.64
7817 wakaba 1.49 ## TODO: frameset FEATURE_M12N10_REC
7818 wakaba 1.188 ## class title id cols rows style(x10)
7819    
7820     $Element->{$HTML_NS}->{frameset} = {
7821     %HTMLEmptyChecker, # XXX
7822     status => FEATURE_M12N10_REC,
7823     check_attrs => $GetHTMLAttrsChecker->({
7824     ## XXX
7825     onafterprint => $HTMLEventHandlerAttrChecker,
7826     onbeforeprint => $HTMLEventHandlerAttrChecker,
7827     onbeforeunload => $HTMLEventHandlerAttrChecker,
7828     onblur => $HTMLEventHandlerAttrChecker,
7829     onerror => $HTMLEventHandlerAttrChecker,
7830     onfocus => $HTMLEventHandlerAttrChecker,
7831     onhashchange => $HTMLEventHandlerAttrChecker,
7832     onload => $HTMLEventHandlerAttrChecker,
7833     onmessage => $HTMLEventHandlerAttrChecker,
7834     onoffline => $HTMLEventHandlerAttrChecker,
7835     ononline => $HTMLEventHandlerAttrChecker,
7836     onpopstate => $HTMLEventHandlerAttrChecker,
7837     onredo => $HTMLEventHandlerAttrChecker,
7838     onresize => $HTMLEventHandlerAttrChecker,
7839     onstorage => $HTMLEventHandlerAttrChecker,
7840     onundo => $HTMLEventHandlerAttrChecker,
7841     onunload => $HTMLEventHandlerAttrChecker,
7842     }, {
7843     %HTMLAttrStatus,
7844     ## XXX
7845     onload => FEATURE_M12N10_REC,
7846     onunload => FEATURE_M12N10_REC,
7847     }),
7848     }; # frameset
7849    
7850 wakaba 1.49 ## frame frameborder longdesc marginheight marginwidth noresize scrolling src name(deprecated) class,id,title,style(x10)
7851     ## noframes Common, lang(xhtml10)
7852    
7853 wakaba 1.100 ## TODO: CR: rbc rtc @rbspan (M12NXHTML2Common)
7854 wakaba 1.56
7855 wakaba 1.61 ## TODO: xmp, listing, plaintext FEATURE_HTML32_REC_OBSOLETE
7856     ## TODO: ^^^ lang, dir, id, class [HTML 2.x] sdaform [HTML 2.0]
7857     ## xmp, listing sdapref[HTML2,0]
7858    
7859 wakaba 1.56 =pod
7860    
7861 wakaba 1.61 HTML 2.0 nextid @n
7862    
7863     RFC 2659: CERTS CRYPTOPTS
7864    
7865     ISO-HTML: pre-html, divN
7866 wakaba 1.82
7867     XHTML2: blockcode (Common), h (Common), separator (Common), l (Common),
7868     di (Common), nl (Common), handler (Common, type), standby (Common),
7869     summary (Common)
7870    
7871 wakaba 1.97 Access & XHTML2: access (LC)
7872 wakaba 1.82
7873     XML Events & XForms (for XHTML2 support; very, very low priority)
7874 wakaba 1.61
7875 wakaba 1.56 =cut
7876 wakaba 1.61
7877     ## NOTE: Where RFC 2659 allows additional attributes is unclear.
7878     ## We added them only to |a|. |link| and |form| might also allow them
7879     ## in theory.
7880 wakaba 1.1
7881     $Whatpm::ContentChecker::Namespace->{$HTML_NS}->{loaded} = 1;
7882    
7883     1;

admin@suikawiki.org
ViewVC Help
Powered by ViewVC 1.1.24