/[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.208 - (hide annotations) (download)
Sun Aug 23 08:13:44 2009 UTC (15 years, 11 months ago) by wakaba
Branch: MAIN
Changes since 1.207: +47 -30 lines
++ whatpm/t/dom-conformance/ChangeLog	23 Aug 2009 08:13:30 -0000
	* html-datatemplate.dat, html-repetitions.dat, html-forms-1.dat,
	html-form-input-1.dat, html-form-button.dat, html-form-select.dat,
	html-form-textarea.dat, html-texts-1.dat, html-interactive-1.dat:
	Revised test results related to the removed datatemplate and
	repetition template feature (HTML5 revision 2319).

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

++ whatpm/Whatpm/ContentChecker/ChangeLog	23 Aug 2009 08:04:48 -0000
	* HTML.pm: Marked datatemplate and repetition template features as
	dropped (HTML5 revision 2319).

2009-08-23  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.1 }),
3767     };
3768    
3769     $Element->{$HTML_NS}->{progress} = { ## TODO: recommended to use content
3770 wakaba 1.40 %HTMLPhrasingContentChecker,
3771 wakaba 1.187 status => FEATURE_HTML5_WD,
3772 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
3773 wakaba 1.1 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { shift >= 0 }),
3774 wakaba 1.203 max => $PositiveFloatingPointNumberAttrChecker,
3775 wakaba 1.50 }, {
3776     %HTMLAttrStatus,
3777     max => FEATURE_HTML5_DEFAULT,
3778     value => FEATURE_HTML5_DEFAULT,
3779 wakaba 1.1 }),
3780     };
3781    
3782     $Element->{$HTML_NS}->{code} = {
3783 wakaba 1.40 %HTMLPhrasingContentChecker,
3784 wakaba 1.187 status => FEATURE_HTML5_REC,
3785 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3786     %HTMLAttrStatus,
3787 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3788 wakaba 1.187 lang => FEATURE_HTML5_REC,
3789 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3790 wakaba 1.49 }),
3791 wakaba 1.1 };
3792    
3793     $Element->{$HTML_NS}->{var} = {
3794 wakaba 1.40 %HTMLPhrasingContentChecker,
3795 wakaba 1.187 status => FEATURE_HTML5_REC,
3796 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3797     %HTMLAttrStatus,
3798 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3799 wakaba 1.187 lang => FEATURE_HTML5_REC,
3800 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3801 wakaba 1.49 }),
3802 wakaba 1.1 };
3803    
3804     $Element->{$HTML_NS}->{samp} = {
3805 wakaba 1.40 %HTMLPhrasingContentChecker,
3806 wakaba 1.187 status => FEATURE_HTML5_REC,
3807 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3808     %HTMLAttrStatus,
3809 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3810 wakaba 1.187 lang => FEATURE_HTML5_REC,
3811 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3812 wakaba 1.49 }),
3813 wakaba 1.1 };
3814    
3815     $Element->{$HTML_NS}->{kbd} = {
3816 wakaba 1.40 %HTMLPhrasingContentChecker,
3817 wakaba 1.187 status => FEATURE_HTML5_REC,
3818 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3819     %HTMLAttrStatus,
3820 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3821 wakaba 1.187 lang => FEATURE_HTML5_REC,
3822 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3823 wakaba 1.49 }),
3824 wakaba 1.1 };
3825    
3826     $Element->{$HTML_NS}->{sub} = {
3827 wakaba 1.40 %HTMLPhrasingContentChecker,
3828 wakaba 1.187 status => FEATURE_HTML5_REC,
3829 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3830     %HTMLAttrStatus,
3831 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3832 wakaba 1.187 lang => FEATURE_HTML5_REC,
3833 wakaba 1.61 sdapref => FEATURE_HTML2X_RFC,
3834 wakaba 1.49 }),
3835 wakaba 1.1 };
3836    
3837 wakaba 1.51 $Element->{$HTML_NS}->{sup} = $Element->{$HTML_NS}->{sub};
3838 wakaba 1.1
3839     $Element->{$HTML_NS}->{span} = {
3840 wakaba 1.40 %HTMLPhrasingContentChecker,
3841 wakaba 1.187 status => FEATURE_HTML5_REC,
3842 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3843     %HTMLAttrStatus,
3844 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
3845 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
3846     dataformatas => FEATURE_HTML4_REC_RESERVED,
3847     datasrc => FEATURE_HTML4_REC_RESERVED,
3848 wakaba 1.187 lang => FEATURE_HTML5_REC,
3849 wakaba 1.61 sdaform => FEATURE_HTML2X_RFC,
3850 wakaba 1.49 }),
3851 wakaba 1.1 };
3852    
3853 wakaba 1.205 # XXX Warning for "authors are encouraged to consider whether other
3854     # elements might be more applicable"
3855 wakaba 1.1 $Element->{$HTML_NS}->{i} = {
3856 wakaba 1.40 %HTMLPhrasingContentChecker,
3857 wakaba 1.187 status => FEATURE_HTML5_REC,
3858 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3859     %HTMLAttrStatus,
3860     %HTMLM12NCommonAttrStatus,
3861 wakaba 1.187 lang => FEATURE_HTML5_REC,
3862 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3863 wakaba 1.49 }),
3864 wakaba 1.1 };
3865    
3866 wakaba 1.51 $Element->{$HTML_NS}->{b} = $Element->{$HTML_NS}->{i};
3867    
3868 wakaba 1.61 $Element->{$HTML_NS}->{tt} = {
3869     %HTMLPhrasingContentChecker,
3870     status => FEATURE_M12N10_REC,
3871     check_attrs => $GetHTMLAttrsChecker->({}, {
3872     %HTMLAttrStatus,
3873     %HTMLM12NCommonAttrStatus,
3874 wakaba 1.187 lang => FEATURE_HTML5_REC,
3875 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
3876     }),
3877     };
3878 wakaba 1.51
3879     $Element->{$HTML_NS}->{s} = {
3880 wakaba 1.40 %HTMLPhrasingContentChecker,
3881 wakaba 1.51 status => FEATURE_M12N10_REC_DEPRECATED,
3882 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
3883     %HTMLAttrStatus,
3884     %HTMLM12NCommonAttrStatus,
3885 wakaba 1.187 lang => FEATURE_HTML5_REC,
3886 wakaba 1.49 }),
3887 wakaba 1.1 };
3888    
3889 wakaba 1.51 $Element->{$HTML_NS}->{strike} = $Element->{$HTML_NS}->{s};
3890    
3891     $Element->{$HTML_NS}->{u} = $Element->{$HTML_NS}->{s};
3892    
3893 wakaba 1.1 $Element->{$HTML_NS}->{bdo} = {
3894 wakaba 1.40 %HTMLPhrasingContentChecker,
3895 wakaba 1.187 status => FEATURE_HTML5_REC,
3896 wakaba 1.40 check_attrs => sub {
3897     my ($self, $item, $element_state) = @_;
3898 wakaba 1.49 $GetHTMLAttrsChecker->({}, {
3899     %HTMLAttrStatus,
3900 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
3901     dir => FEATURE_HTML5_REC,
3902     id => FEATURE_HTML5_REC,
3903     style => FEATURE_HTML5_REC,
3904     title => FEATURE_HTML5_REC,
3905     lang => FEATURE_HTML5_REC,
3906 wakaba 1.61 sdapref => FEATURE_HTML2X_RFC,
3907     sdasuff => FEATURE_HTML2X_RFC,
3908 wakaba 1.49 })->($self, $item, $element_state);
3909 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'dir')) {
3910     $self->{onerror}->(node => $item->{node},
3911 wakaba 1.104 type => 'attribute missing',
3912     text => 'dir',
3913     level => $self->{level}->{must});
3914 wakaba 1.1 }
3915     },
3916     ## ISSUE: The spec does not directly say that |dir| is a enumerated attr.
3917     };
3918    
3919 wakaba 1.99 $Element->{$HTML_NS}->{ruby} = {
3920     %HTMLPhrasingContentChecker,
3921 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
3922 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
3923     %HTMLAttrStatus,
3924     %HTMLM12NXHTML2CommonAttrStatus, # XHTML 1.1 & XHTML 2.0 & XHTML+RDFa 1.0
3925 wakaba 1.187 lang => FEATURE_HTML5_REC,
3926 wakaba 1.99 }),
3927     check_start => sub {
3928     my ($self, $item, $element_state) = @_;
3929    
3930     $element_state->{phase} = 'before-rb';
3931     #$element_state->{has_sig}
3932 wakaba 1.100
3933     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
3934     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
3935 wakaba 1.99 },
3936     ## NOTE: (phrasing, (rt | (rp, rt, rp)))+
3937     check_child_element => sub {
3938     my ($self, $item, $child_el, $child_nsuri, $child_ln,
3939     $child_is_transparent, $element_state) = @_;
3940 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
3941     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
3942 wakaba 1.99 $self->{onerror}->(node => $child_el,
3943     type => 'element not allowed:minus',
3944 wakaba 1.104 level => $self->{level}->{must});
3945 wakaba 1.99 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
3946     #
3947     } elsif ($element_state->{phase} eq 'before-rb') {
3948     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
3949     $element_state->{phase} = 'in-rb';
3950     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
3951     $self->{onerror}->(node => $child_el,
3952 wakaba 1.104 level => $self->{level}->{should},
3953     type => 'no significant content before');
3954 wakaba 1.99 $element_state->{phase} = 'after-rt';
3955     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
3956     $self->{onerror}->(node => $child_el,
3957 wakaba 1.104 level => $self->{level}->{should},
3958     type => 'no significant content before');
3959 wakaba 1.99 $element_state->{phase} = 'after-rp1';
3960     } else {
3961     $self->{onerror}->(node => $child_el,
3962 wakaba 1.104 type => 'element not allowed:ruby base',
3963     level => $self->{level}->{must});
3964 wakaba 1.99 $element_state->{phase} = 'in-rb';
3965     }
3966     } elsif ($element_state->{phase} eq 'in-rb') {
3967     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
3968     #$element_state->{phase} = 'in-rb';
3969     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
3970     unless ($element_state->{has_significant}) {
3971     $self->{onerror}->(node => $child_el,
3972 wakaba 1.104 level => $self->{level}->{should},
3973     type => 'no significant content before');
3974 wakaba 1.99 }
3975     $element_state->{phase} = 'after-rt';
3976     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
3977     unless ($element_state->{has_significant}) {
3978     $self->{onerror}->(node => $child_el,
3979 wakaba 1.104 level => $self->{level}->{should},
3980     type => 'no significant content before');
3981 wakaba 1.99 }
3982     $element_state->{phase} = 'after-rp1';
3983     } else {
3984     $self->{onerror}->(node => $child_el,
3985 wakaba 1.104 type => 'element not allowed:ruby base',
3986     level => $self->{level}->{must});
3987 wakaba 1.99 #$element_state->{phase} = 'in-rb';
3988     }
3989     } elsif ($element_state->{phase} eq 'after-rt') {
3990     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
3991     if ($element_state->{has_significant}) {
3992     $element_state->{has_sig} = 1;
3993     delete $element_state->{has_significant};
3994     }
3995     $element_state->{phase} = 'in-rb';
3996     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
3997     $self->{onerror}->(node => $child_el,
3998 wakaba 1.104 level => $self->{level}->{should},
3999     type => 'no significant content before');
4000 wakaba 1.99 $element_state->{phase} = 'after-rp1';
4001     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4002     $self->{onerror}->(node => $child_el,
4003 wakaba 1.104 level => $self->{level}->{should},
4004     type => 'no significant content before');
4005 wakaba 1.99 #$element_state->{phase} = 'after-rt';
4006     } else {
4007     $self->{onerror}->(node => $child_el,
4008 wakaba 1.104 type => 'element not allowed:ruby base',
4009     level => $self->{level}->{must});
4010 wakaba 1.99 if ($element_state->{has_significant}) {
4011     $element_state->{has_sig} = 1;
4012     delete $element_state->{has_significant};
4013     }
4014     $element_state->{phase} = 'in-rb';
4015     }
4016     } elsif ($element_state->{phase} eq 'after-rp1') {
4017     if ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4018     $element_state->{phase} = 'after-rp-rt';
4019     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4020     $self->{onerror}->(node => $child_el,
4021 wakaba 1.104 type => 'ps element missing',
4022     text => 'rt',
4023     level => $self->{level}->{must});
4024 wakaba 1.99 $element_state->{phase} = 'after-rp2';
4025     } else {
4026     $self->{onerror}->(node => $child_el,
4027 wakaba 1.104 type => 'ps element missing',
4028     text => 'rt',
4029     level => $self->{level}->{must});
4030 wakaba 1.99 $self->{onerror}->(node => $child_el,
4031 wakaba 1.104 type => 'ps element missing',
4032     text => 'rp',
4033     level => $self->{level}->{must});
4034 wakaba 1.99 unless ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4035     $self->{onerror}->(node => $child_el,
4036 wakaba 1.104 type => 'element not allowed:ruby base',
4037     level => $self->{level}->{must});
4038 wakaba 1.99 }
4039     if ($element_state->{has_significant}) {
4040     $element_state->{has_sig} = 1;
4041     delete $element_state->{has_significant};
4042     }
4043     $element_state->{phase} = 'in-rb';
4044     }
4045     } elsif ($element_state->{phase} eq 'after-rp-rt') {
4046     if ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4047     $element_state->{phase} = 'after-rp2';
4048     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4049     $self->{onerror}->(node => $child_el,
4050 wakaba 1.104 type => 'ps element missing',
4051     text => 'rp',
4052     level => $self->{level}->{must});
4053 wakaba 1.99 $self->{onerror}->(node => $child_el,
4054 wakaba 1.104 level => $self->{level}->{should},
4055     type => 'no significant content before');
4056 wakaba 1.99 $element_state->{phase} = 'after-rt';
4057     } else {
4058     $self->{onerror}->(node => $child_el,
4059 wakaba 1.104 type => 'ps element missing',
4060     text => 'rp',
4061     level => $self->{level}->{must});
4062 wakaba 1.99 unless ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4063     $self->{onerror}->(node => $child_el,
4064 wakaba 1.104 type => 'element not allowed:ruby base',
4065     level => $self->{level}->{must});
4066 wakaba 1.99 }
4067     if ($element_state->{has_significant}) {
4068     $element_state->{has_sig} = 1;
4069     delete $element_state->{has_significant};
4070     }
4071     $element_state->{phase} = 'in-rb';
4072     }
4073     } elsif ($element_state->{phase} eq 'after-rp2') {
4074     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
4075     if ($element_state->{has_significant}) {
4076     $element_state->{has_sig} = 1;
4077     delete $element_state->{has_significant};
4078     }
4079     $element_state->{phase} = 'in-rb';
4080     } elsif ($child_ln eq 'rt' and $child_nsuri eq $HTML_NS) {
4081     $self->{onerror}->(node => $child_el,
4082 wakaba 1.104 level => $self->{level}->{should},
4083     type => 'no significant content before');
4084 wakaba 1.99 $element_state->{phase} = 'after-rt';
4085     } elsif ($child_ln eq 'rp' and $child_nsuri eq $HTML_NS) {
4086     $self->{onerror}->(node => $child_el,
4087 wakaba 1.104 level => $self->{level}->{should},
4088     type => 'no significant content before');
4089 wakaba 1.99 $element_state->{phase} = 'after-rp1';
4090     } else {
4091     $self->{onerror}->(node => $child_el,
4092 wakaba 1.104 type => 'element not allowed:ruby base',
4093     level => $self->{level}->{must});
4094 wakaba 1.99 if ($element_state->{has_significant}) {
4095     $element_state->{has_sig} = 1;
4096     delete $element_state->{has_significant};
4097     }
4098     $element_state->{phase} = 'in-rb';
4099     }
4100     } else {
4101     die "check_child_element: Bad |ruby| phase: $element_state->{phase}";
4102     }
4103     },
4104     check_child_text => sub {
4105     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4106     if ($has_significant) {
4107     if ($element_state->{phase} eq 'before-rb') {
4108     $element_state->{phase} = 'in-rb';
4109     } elsif ($element_state->{phase} eq 'in-rb') {
4110     #
4111     } elsif ($element_state->{phase} eq 'after-rt' or
4112     $element_state->{phase} eq 'after-rp2') {
4113     $element_state->{phase} = 'in-rb';
4114     } elsif ($element_state->{phase} eq 'after-rp1') {
4115     $self->{onerror}->(node => $child_node,
4116 wakaba 1.104 type => 'ps element missing',
4117     text => 'rt',
4118     level => $self->{level}->{must});
4119 wakaba 1.99 $self->{onerror}->(node => $child_node,
4120 wakaba 1.104 type => 'ps element missing',
4121     text => 'rp',
4122     level => $self->{level}->{must});
4123 wakaba 1.99 $element_state->{phase} = 'in-rb';
4124     } elsif ($element_state->{phase} eq 'after-rp-rt') {
4125     $self->{onerror}->(node => $child_node,
4126 wakaba 1.104 type => 'ps element missing',
4127     text => 'rp',
4128     level => $self->{level}->{must});
4129 wakaba 1.99 $element_state->{phase} = 'in-rb';
4130     } else {
4131     die "check_child_text: Bad |ruby| phase: $element_state->{phase}";
4132     }
4133     }
4134     },
4135     check_end => sub {
4136     my ($self, $item, $element_state) = @_;
4137     $self->_remove_minus_elements ($element_state);
4138    
4139     if ($element_state->{phase} eq 'before-rb') {
4140     $self->{onerror}->(node => $item->{node},
4141 wakaba 1.104 level => $self->{level}->{should},
4142 wakaba 1.99 type => 'no significant content');
4143     $self->{onerror}->(node => $item->{node},
4144 wakaba 1.104 type => 'element missing',
4145     text => 'rt',
4146     level => $self->{level}->{must});
4147 wakaba 1.99 } elsif ($element_state->{phase} eq 'in-rb') {
4148     unless ($element_state->{has_significant}) {
4149     $self->{onerror}->(node => $item->{node},
4150 wakaba 1.104 level => $self->{level}->{should},
4151     type => 'no significant content at the end');
4152 wakaba 1.99 }
4153     $self->{onerror}->(node => $item->{node},
4154 wakaba 1.104 type => 'element missing',
4155     text => 'rt',
4156     level => $self->{level}->{must});
4157 wakaba 1.99 } elsif ($element_state->{phase} eq 'after-rt' or
4158     $element_state->{phase} eq 'after-rp2') {
4159     #
4160     } elsif ($element_state->{phase} eq 'after-rp1') {
4161     $self->{onerror}->(node => $item->{node},
4162 wakaba 1.104 type => 'element missing',
4163     text => 'rt',
4164     level => $self->{level}->{must});
4165 wakaba 1.99 $self->{onerror}->(node => $item->{node},
4166 wakaba 1.104 type => 'element missing',
4167     text => 'rp',
4168     level => $self->{level}->{must});
4169 wakaba 1.99 } elsif ($element_state->{phase} eq 'after-rp-rt') {
4170     $self->{onerror}->(node => $item->{node},
4171 wakaba 1.104 type => 'element missing',
4172     text => 'rp',
4173     level => $self->{level}->{must});
4174 wakaba 1.99 } else {
4175     die "check_child_text: Bad |ruby| phase: $element_state->{phase}";
4176     }
4177    
4178     ## NOTE: A modified version of |check_end| of %AnyChecker.
4179     if ($element_state->{has_significant} or $element_state->{has_sig}) {
4180     $item->{real_parent_state}->{has_significant} = 1;
4181     }
4182     },
4183     };
4184    
4185     $Element->{$HTML_NS}->{rt} = {
4186     %HTMLPhrasingContentChecker,
4187 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
4188 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
4189     %HTMLAttrStatus,
4190     %HTMLM12NXHTML2CommonAttrStatus,
4191 wakaba 1.187 lang => FEATURE_HTML5_REC,
4192 wakaba 1.99 }),
4193     };
4194    
4195     $Element->{$HTML_NS}->{rp} = {
4196 wakaba 1.171 %HTMLPhrasingContentChecker,
4197 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_RUBY_REC,
4198 wakaba 1.99 check_attrs => $GetHTMLAttrsChecker->({}, {
4199     %HTMLAttrStatus,
4200     %HTMLM12NXHTML2CommonAttrStatus,
4201 wakaba 1.187 lang => FEATURE_HTML5_REC,
4202 wakaba 1.99 }),
4203 wakaba 1.171 }; # rp
4204 wakaba 1.99
4205 wakaba 1.29 =pod
4206    
4207     ## TODO:
4208    
4209     +
4210     + <p>Partly because of the confusion described above, authors are
4211     + strongly recommended to always mark up all paragraphs with the
4212     + <code>p</code> element, and to not have any <code>ins</code> or
4213     + <code>del</code> elements that cross across any <span
4214     + title="paragraph">implied paragraphs</span>.</p>
4215     +
4216     (An informative note)
4217    
4218     <p><code>ins</code> elements should not cross <span
4219     + title="paragraph">implied paragraph</span> boundaries.</p>
4220     (normative)
4221    
4222     + <p><code>del</code> elements should not cross <span
4223     + title="paragraph">implied paragraph</span> boundaries.</p>
4224     (normative)
4225    
4226     =cut
4227    
4228 wakaba 1.1 $Element->{$HTML_NS}->{ins} = {
4229 wakaba 1.40 %HTMLTransparentChecker,
4230 wakaba 1.187 status => FEATURE_HTML5_REC,
4231 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4232 wakaba 1.1 cite => $HTMLURIAttrChecker,
4233 wakaba 1.168 datetime => $GetDateTimeAttrChecker->('global_date_and_time_string'),
4234 wakaba 1.49 }, {
4235     %HTMLAttrStatus,
4236     %HTMLM12NCommonAttrStatus,
4237 wakaba 1.50 cite => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4238 wakaba 1.153 datetime => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4239 wakaba 1.187 lang => FEATURE_HTML5_REC,
4240 wakaba 1.1 }),
4241 wakaba 1.66 check_start => sub {
4242     my ($self, $item, $element_state) = @_;
4243    
4244     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
4245 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4246     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4247 wakaba 1.66 },
4248 wakaba 1.1 };
4249    
4250     $Element->{$HTML_NS}->{del} = {
4251 wakaba 1.40 %HTMLTransparentChecker,
4252 wakaba 1.187 status => FEATURE_HTML5_REC,
4253 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4254 wakaba 1.1 cite => $HTMLURIAttrChecker,
4255 wakaba 1.168 datetime => $GetDateTimeAttrChecker->('global_date_and_time_string'),
4256 wakaba 1.49 }, {
4257     %HTMLAttrStatus,
4258     %HTMLM12NCommonAttrStatus,
4259 wakaba 1.50 cite => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4260 wakaba 1.153 datetime => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4261 wakaba 1.187 lang => FEATURE_HTML5_REC,
4262 wakaba 1.1 }),
4263 wakaba 1.40 check_end => sub {
4264     my ($self, $item, $element_state) = @_;
4265     if ($element_state->{has_significant}) {
4266     ## NOTE: Significantness flag does not propagate.
4267     } elsif ($item->{transparent}) {
4268     #
4269     } else {
4270     $self->{onerror}->(node => $item->{node},
4271 wakaba 1.104 level => $self->{level}->{should},
4272 wakaba 1.40 type => 'no significant content');
4273     }
4274 wakaba 1.1 },
4275 wakaba 1.66 check_start => sub {
4276     my ($self, $item, $element_state) = @_;
4277    
4278     $element_state->{uri_info}->{cite}->{type}->{cite} = 1;
4279 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4280     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4281 wakaba 1.66 },
4282 wakaba 1.1 };
4283    
4284 wakaba 1.35 $Element->{$HTML_NS}->{figure} = {
4285 wakaba 1.72 %HTMLFlowContentChecker,
4286 wakaba 1.153 status => FEATURE_HTML5_WD,
4287 wakaba 1.72 ## NOTE: legend, Flow | Flow, legend?
4288 wakaba 1.41 check_child_element => sub {
4289     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4290     $child_is_transparent, $element_state) = @_;
4291 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4292     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4293 wakaba 1.41 $self->{onerror}->(node => $child_el,
4294     type => 'element not allowed:minus',
4295 wakaba 1.104 level => $self->{level}->{must});
4296 wakaba 1.41 $element_state->{has_non_legend} = 1;
4297 wakaba 1.181 $element_state->{has_non_table} = 1;
4298 wakaba 1.41 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4299 wakaba 1.181 $element_state->{has_non_table} = 1;
4300 wakaba 1.41 } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'legend') {
4301     if ($element_state->{has_legend_at_first}) {
4302     $self->{onerror}->(node => $child_el,
4303     type => 'element not allowed:figure legend',
4304 wakaba 1.104 level => $self->{level}->{must});
4305 wakaba 1.41 } elsif ($element_state->{has_legend}) {
4306     $self->{onerror}->(node => $element_state->{has_legend},
4307     type => 'element not allowed:figure legend',
4308 wakaba 1.104 level => $self->{level}->{must});
4309 wakaba 1.41 $element_state->{has_legend} = $child_el;
4310     } elsif ($element_state->{has_non_legend}) {
4311     $element_state->{has_legend} = $child_el;
4312     } else {
4313     $element_state->{has_legend_at_first} = 1;
4314 wakaba 1.35 }
4315 wakaba 1.41 delete $element_state->{has_non_legend};
4316     } else {
4317 wakaba 1.181 if ($child_nsuri eq $HTML_NS and $child_ln eq 'table') {
4318     $element_state->{has_table}++;
4319     } else {
4320     $element_state->{has_non_table}++;
4321     }
4322 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4323 wakaba 1.43 $element_state->{has_non_legend} = 1 unless $child_is_transparent;
4324 wakaba 1.41 }
4325     },
4326     check_child_text => sub {
4327     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4328     if ($has_significant) {
4329     $element_state->{has_non_legend} = 1;
4330 wakaba 1.181 $element_state->{has_non_table}++;
4331 wakaba 1.35 }
4332 wakaba 1.170
4333     $element_state->{in_figure} = 1;
4334 wakaba 1.41 },
4335     check_end => sub {
4336     my ($self, $item, $element_state) = @_;
4337 wakaba 1.35
4338 wakaba 1.41 if ($element_state->{has_legend_at_first}) {
4339     #
4340     } elsif ($element_state->{has_legend}) {
4341     if ($element_state->{has_non_legend}) {
4342     $self->{onerror}->(node => $element_state->{has_legend},
4343 wakaba 1.35 type => 'element not allowed:figure legend',
4344 wakaba 1.104 level => $self->{level}->{must});
4345 wakaba 1.35 }
4346     }
4347 wakaba 1.41
4348 wakaba 1.181 if (($element_state->{has_table} || 0) == 1 and
4349     not $element_state->{has_non_table} and
4350     $element_state->{table_caption_element}) {
4351     $self->{onerror}->(node => $element_state->{table_caption_element},
4352     type => 'element not allowed',
4353     level => $self->{level}->{should});
4354     }
4355    
4356 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
4357 wakaba 1.41 ## ISSUE: |<figure><legend>aa</legend></figure>| should be an error?
4358 wakaba 1.35 },
4359     };
4360 wakaba 1.8 ## TODO: Test for <nest/> in <figure/>
4361 wakaba 1.1
4362 wakaba 1.92 my $AttrCheckerNotImplemented = sub {
4363     my ($self, $attr) = @_;
4364 wakaba 1.104 $self->{onerror}->(node => $attr,
4365     type => 'unknown attribute',
4366     level => $self->{level}->{uncertain});
4367 wakaba 1.92 };
4368    
4369 wakaba 1.1 $Element->{$HTML_NS}->{img} = {
4370 wakaba 1.40 %HTMLEmptyChecker,
4371 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4372 wakaba 1.40 check_attrs => sub {
4373     my ($self, $item, $element_state) = @_;
4374 wakaba 1.1 $GetHTMLAttrsChecker->({
4375 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
4376     bottom => 1, middle => 1, top => 1, left => 1, right => 1,
4377     }),
4378 wakaba 1.1 alt => sub { }, ## NOTE: No syntactical requirement
4379 wakaba 1.70 border => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4380 wakaba 1.1 src => $HTMLURIAttrChecker,
4381     usemap => $HTMLUsemapAttrChecker,
4382 wakaba 1.70 hspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4383 wakaba 1.1 ismap => sub {
4384 wakaba 1.40 my ($self, $attr, $parent_item) = @_;
4385     if (not $self->{flag}->{in_a_href}) {
4386 wakaba 1.15 $self->{onerror}->(node => $attr,
4387 wakaba 1.59 type => 'attribute not allowed:ismap',
4388 wakaba 1.104 level => $self->{level}->{must});
4389 wakaba 1.1 }
4390 wakaba 1.40 $GetHTMLBooleanAttrChecker->('ismap')->($self, $attr, $parent_item);
4391 wakaba 1.1 },
4392 wakaba 1.70 longdesc => $HTMLURIAttrChecker,
4393     ## TODO: HTML4 |name|
4394 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4395 wakaba 1.70 vspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4396 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4397 wakaba 1.49 }, {
4398     %HTMLAttrStatus,
4399 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
4400 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
4401 wakaba 1.153 alt => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4402 wakaba 1.49 border => FEATURE_M12N10_REC_DEPRECATED,
4403 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4404 wakaba 1.49 hspace => FEATURE_M12N10_REC_DEPRECATED,
4405 wakaba 1.153 ismap => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4406 wakaba 1.187 lang => FEATURE_HTML5_REC,
4407 wakaba 1.49 longdesc => FEATURE_M12N10_REC,
4408     name => FEATURE_M12N10_REC_DEPRECATED,
4409 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
4410 wakaba 1.153 src => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4411     usemap => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4412 wakaba 1.49 vspace => FEATURE_M12N10_REC_DEPRECATED,
4413 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4414 wakaba 1.66 })->($self, $item, $element_state);
4415 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'alt')) {
4416     $self->{onerror}->(node => $item->{node},
4417 wakaba 1.104 type => 'attribute missing',
4418     text => 'alt',
4419     level => $self->{level}->{should});
4420 wakaba 1.114 ## TODO: ...
4421 wakaba 1.1 }
4422 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'src')) {
4423     $self->{onerror}->(node => $item->{node},
4424 wakaba 1.104 type => 'attribute missing',
4425     text => 'src',
4426     level => $self->{level}->{must});
4427 wakaba 1.1 }
4428 wakaba 1.66
4429 wakaba 1.114 ## TODO: external resource check
4430    
4431 wakaba 1.66 $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4432     $element_state->{uri_info}->{lowsrc}->{type}->{embedded} = 1;
4433     $element_state->{uri_info}->{dynsrc}->{type}->{embedded} = 1;
4434     $element_state->{uri_info}->{longdesc}->{type}->{cite} = 1;
4435 wakaba 1.1 },
4436     };
4437    
4438     $Element->{$HTML_NS}->{iframe} = {
4439 wakaba 1.205 %HTMLTextChecker, # XXX content model restriction
4440 wakaba 1.114 status => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4441 wakaba 1.49 ## NOTE: Not part of M12N10 Strict
4442 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4443 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4444 wakaba 1.76 name => $HTMLBrowsingContextNameAttrChecker,
4445 wakaba 1.92 sandbox => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->({
4446     'allow-same-origin' => 1, 'allow-forms' => 1, 'allow-scripts' => 1,
4447     }),
4448     seemless => $GetHTMLBooleanAttrChecker->('seemless'),
4449 wakaba 1.1 src => $HTMLURIAttrChecker,
4450 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4451 wakaba 1.49 }, {
4452     %HTMLAttrStatus,
4453     %HTMLM12NCommonAttrStatus,
4454     align => FEATURE_XHTML10_REC,
4455 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4456 wakaba 1.49 frameborder => FEATURE_M12N10_REC,
4457 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4458 wakaba 1.187 id => FEATURE_HTML5_REC,
4459 wakaba 1.49 longdesc => FEATURE_M12N10_REC,
4460     marginheight => FEATURE_M12N10_REC,
4461     marginwidth => FEATURE_M12N10_REC,
4462 wakaba 1.114 #name => FEATURE_HTML5_WD | FEATURE_M12N10_REC_DEPRECATED,
4463     name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4464     sandbox => FEATURE_HTML5_WD,
4465 wakaba 1.49 scrolling => FEATURE_M12N10_REC,
4466 wakaba 1.114 seemless => FEATURE_HTML5_WD,
4467     src => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4468 wakaba 1.187 title => FEATURE_HTML5_REC,
4469 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4470 wakaba 1.1 }),
4471 wakaba 1.66 check_start => sub {
4472     my ($self, $item, $element_state) = @_;
4473    
4474     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4475 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4476     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4477 wakaba 1.66 },
4478 wakaba 1.40 };
4479    
4480 wakaba 1.1 $Element->{$HTML_NS}->{embed} = {
4481 wakaba 1.40 %HTMLEmptyChecker,
4482 wakaba 1.98 status => FEATURE_HTML5_WD,
4483 wakaba 1.40 check_attrs => sub {
4484     my ($self, $item, $element_state) = @_;
4485 wakaba 1.1 my $has_src;
4486 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
4487 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
4488     $attr_ns = '' unless defined $attr_ns;
4489     my $attr_ln = $attr->manakai_local_name;
4490     my $checker;
4491 wakaba 1.73
4492     my $status = {
4493     %HTMLAttrStatus,
4494 wakaba 1.153 height => FEATURE_HTML5_LC,
4495 wakaba 1.98 src => FEATURE_HTML5_WD,
4496     type => FEATURE_HTML5_WD,
4497 wakaba 1.153 width => FEATURE_HTML5_LC,
4498 wakaba 1.73 }->{$attr_ln};
4499    
4500 wakaba 1.1 if ($attr_ns eq '') {
4501     if ($attr_ln eq 'src') {
4502     $checker = $HTMLURIAttrChecker;
4503     $has_src = 1;
4504     } elsif ($attr_ln eq 'type') {
4505     $checker = $HTMLIMTAttrChecker;
4506 wakaba 1.92 } elsif ($attr_ln eq 'width' or $attr_ln eq 'height') {
4507 wakaba 1.178 $checker = $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 });
4508 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
4509     $attr_ln !~ /[A-Z]/) {
4510 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
4511     $status = $HTMLDatasetAttrStatus;
4512 wakaba 1.117 } elsif ($attr_ln !~ /^[Xx][Mm][Ll]/ and
4513 wakaba 1.118 $attr_ln !~ /[A-Z]/ and
4514 wakaba 1.117 $attr_ln =~ /\A\p{InXML_NCNameStartChar10}\p{InXMLNCNameChar10}*\z/) {
4515 wakaba 1.1 $checker = $HTMLAttrChecker->{$attr_ln}
4516     || sub { }; ## NOTE: Any local attribute is ok.
4517 wakaba 1.98 $status = FEATURE_HTML5_WD | FEATURE_ALLOWED;
4518 wakaba 1.117 } else {
4519     $checker = $HTMLAttrChecker->{$attr_ln};
4520 wakaba 1.1 }
4521     }
4522     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
4523 wakaba 1.82 || $AttrChecker->{$attr_ns}->{''};
4524     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
4525     || $AttrStatus->{$attr_ns}->{''};
4526     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
4527 wakaba 1.62
4528 wakaba 1.1 if ($checker) {
4529 wakaba 1.66 $checker->($self, $attr, $item, $element_state);
4530 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
4531 wakaba 1.54 #
4532 wakaba 1.1 } else {
4533 wakaba 1.104 $self->{onerror}->(node => $attr,
4534     type => 'unknown attribute',
4535     level => $self->{level}->{uncertain});
4536 wakaba 1.50 ## ISSUE: No conformance createria for global attributes in the spec
4537     }
4538    
4539 wakaba 1.82 $self->_attr_status_info ($attr, $status);
4540 wakaba 1.1 }
4541    
4542     unless ($has_src) {
4543 wakaba 1.40 $self->{onerror}->(node => $item->{node},
4544 wakaba 1.104 type => 'attribute missing',
4545     text => 'src',
4546 wakaba 1.114 level => $self->{level}->{info});
4547     ## NOTE: <embed> without src="" is allowed since revision 1929.
4548     ## We issues an informational message since <embed> w/o src=""
4549     ## is likely an authoring error.
4550 wakaba 1.1 }
4551 wakaba 1.114
4552     ## TODO: external resource check
4553 wakaba 1.66
4554     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4555 wakaba 1.1 },
4556     };
4557    
4558 wakaba 1.49 ## TODO:
4559     ## {applet} FEATURE_M12N10_REC_DEPRECATED
4560     ## class, id, title, alt, archive, code, codebase, height, object, width name style,hspace,vspace(xhtml10)
4561    
4562 wakaba 1.1 $Element->{$HTML_NS}->{object} = {
4563 wakaba 1.40 %HTMLTransparentChecker,
4564 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4565 wakaba 1.40 check_attrs => sub {
4566     my ($self, $item, $element_state) = @_;
4567 wakaba 1.1 $GetHTMLAttrsChecker->({
4568 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
4569     bottom => 1, middle => 1, top => 1, left => 1, right => 1,
4570     }),
4571     archive => $HTMLSpaceURIsAttrChecker,
4572     ## TODO: Relative to @codebase
4573     border => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4574     classid => $HTMLURIAttrChecker,
4575     codebase => $HTMLURIAttrChecker,
4576     codetype => $HTMLIMTAttrChecker,
4577     ## TODO: "RECOMMENDED when |classid| is specified" [HTML4]
4578 wakaba 1.1 data => $HTMLURIAttrChecker,
4579 wakaba 1.70 declare => $GetHTMLBooleanAttrChecker->('declare'),
4580     ## NOTE: "The object MUST be instantiated by a subsequent OBJECT ..."
4581     ## [HTML4] but we don't know how to test this.
4582 wakaba 1.167 form => $HTMLFormAttrChecker,
4583 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4584 wakaba 1.70 hspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4585 wakaba 1.76 name => $HTMLBrowsingContextNameAttrChecker,
4586 wakaba 1.167 ## NOTE: |name| attribute of the |object| element defines
4587     ## the name of the browsing context created by the element,
4588     ## if any, but is also used as the form control name of the
4589     ## form control provided by the plugin, if any.
4590 wakaba 1.70 standby => sub {}, ## NOTE: %Text; in HTML4
4591 wakaba 1.1 type => $HTMLIMTAttrChecker,
4592     usemap => $HTMLUsemapAttrChecker,
4593 wakaba 1.70 vspace => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4594 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4595 wakaba 1.49 }, {
4596     %HTMLAttrStatus,
4597 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
4598 wakaba 1.49 align => FEATURE_XHTML10_REC,
4599 wakaba 1.82 archive => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4600 wakaba 1.49 border => FEATURE_XHTML10_REC,
4601     classid => FEATURE_M12N10_REC,
4602     codebase => FEATURE_M12N10_REC,
4603     codetype => FEATURE_M12N10_REC,
4604 wakaba 1.82 'content-length' => FEATURE_XHTML2_ED,
4605 wakaba 1.153 data => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4606 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
4607     dataformatas => FEATURE_HTML4_REC_RESERVED,
4608     datasrc => FEATURE_HTML4_REC_RESERVED,
4609 wakaba 1.82 declare => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4610 wakaba 1.187 form => FEATURE_HTML5_LC,
4611 wakaba 1.153 height => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4612 wakaba 1.49 hspace => FEATURE_XHTML10_REC,
4613 wakaba 1.187 lang => FEATURE_HTML5_REC,
4614 wakaba 1.153 name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4615 wakaba 1.49 standby => FEATURE_M12N10_REC,
4616 wakaba 1.50 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4617 wakaba 1.153 type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
4618     usemap => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4619 wakaba 1.49 vspace => FEATURE_XHTML10_REC,
4620 wakaba 1.153 width => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4621 wakaba 1.66 })->($self, $item, $element_state);
4622 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'data')) {
4623     unless ($item->{node}->has_attribute_ns (undef, 'type')) {
4624     $self->{onerror}->(node => $item->{node},
4625 wakaba 1.104 type => 'attribute missing:data|type',
4626     level => $self->{level}->{must});
4627 wakaba 1.1 }
4628     }
4629 wakaba 1.66
4630     $element_state->{uri_info}->{data}->{type}->{embedded} = 1;
4631     $element_state->{uri_info}->{classid}->{type}->{embedded} = 1;
4632     $element_state->{uri_info}->{codebase}->{type}->{base} = 1;
4633     ## TODO: archive
4634     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
4635 wakaba 1.1 },
4636 wakaba 1.72 ## NOTE: param*, transparent (Flow)
4637 wakaba 1.41 check_child_element => sub {
4638     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4639     $child_is_transparent, $element_state) = @_;
4640 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4641     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4642 wakaba 1.41 $self->{onerror}->(node => $child_el,
4643     type => 'element not allowed:minus',
4644 wakaba 1.104 level => $self->{level}->{must});
4645 wakaba 1.41 $element_state->{has_non_legend} = 1;
4646     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4647     #
4648     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'param') {
4649     if ($element_state->{has_non_param}) {
4650 wakaba 1.104 $self->{onerror}->(node => $child_el,
4651 wakaba 1.72 type => 'element not allowed:flow',
4652 wakaba 1.104 level => $self->{level}->{must});
4653 wakaba 1.39 }
4654 wakaba 1.41 } else {
4655 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4656 wakaba 1.41 $element_state->{has_non_param} = 1;
4657 wakaba 1.39 }
4658 wakaba 1.25 },
4659 wakaba 1.41 check_child_text => sub {
4660     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4661     if ($has_significant) {
4662     $element_state->{has_non_param} = 1;
4663     }
4664 wakaba 1.42 },
4665     check_end => sub {
4666     my ($self, $item, $element_state) = @_;
4667     if ($element_state->{has_significant}) {
4668 wakaba 1.46 $item->{real_parent_state}->{has_significant} = 1;
4669 wakaba 1.42 } elsif ($item->{node}->manakai_parent_element) {
4670     ## NOTE: Transparent.
4671     } else {
4672     $self->{onerror}->(node => $item->{node},
4673 wakaba 1.104 level => $self->{level}->{should},
4674 wakaba 1.42 type => 'no significant content');
4675     }
4676     },
4677 wakaba 1.8 ## TODO: Tests for <nest/> in <object/>
4678 wakaba 1.1 };
4679 wakaba 1.41 ## ISSUE: Is |<menu><object data><li>aa</li></object></menu>| conforming?
4680     ## What about |<section><object data><style scoped></style>x</object></section>|?
4681     ## |<section><ins></ins><object data><style scoped></style>x</object></section>|?
4682 wakaba 1.1
4683     $Element->{$HTML_NS}->{param} = {
4684 wakaba 1.40 %HTMLEmptyChecker,
4685 wakaba 1.187 status => FEATURE_HTML5_REC,
4686 wakaba 1.40 check_attrs => sub {
4687     my ($self, $item, $element_state) = @_;
4688 wakaba 1.1 $GetHTMLAttrsChecker->({
4689     name => sub { },
4690 wakaba 1.70 type => $HTMLIMTAttrChecker,
4691 wakaba 1.1 value => sub { },
4692 wakaba 1.70 valuetype => $GetHTMLEnumeratedAttrChecker->({
4693     data => 1, ref => 1, object => 1,
4694     }),
4695 wakaba 1.49 }, {
4696     %HTMLAttrStatus,
4697 wakaba 1.154 href => FEATURE_RDFA_REC,
4698 wakaba 1.187 id => FEATURE_HTML5_REC,
4699 wakaba 1.153 name => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4700 wakaba 1.82 type => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4701 wakaba 1.153 value => FEATURE_HTML5_WD | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4702 wakaba 1.82 valuetype => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
4703 wakaba 1.66 })->(@_);
4704 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'name')) {
4705     $self->{onerror}->(node => $item->{node},
4706 wakaba 1.104 type => 'attribute missing',
4707     text => 'name',
4708     level => $self->{level}->{must});
4709 wakaba 1.1 }
4710 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'value')) {
4711     $self->{onerror}->(node => $item->{node},
4712 wakaba 1.104 type => 'attribute missing',
4713     text => 'value',
4714     level => $self->{level}->{must});
4715 wakaba 1.1 }
4716     },
4717     };
4718    
4719     $Element->{$HTML_NS}->{video} = {
4720 wakaba 1.40 %HTMLTransparentChecker,
4721 wakaba 1.48 status => FEATURE_HTML5_LC,
4722 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4723 wakaba 1.1 src => $HTMLURIAttrChecker,
4724     ## TODO: start, loopstart, loopend, end
4725     ## ISSUE: they MUST be "value time offset"s. Value?
4726 wakaba 1.11 ## ISSUE: playcount has no conformance creteria
4727 wakaba 1.183 autobuffer => $GetHTMLBooleanAttrChecker->('autobuffer'),
4728 wakaba 1.205 autoplay => sub {
4729     my ($self, $attr) = @_;
4730    
4731     ## "Authors are also encouraged to consider not using the
4732     ## automatic playback behavior at all" according to HTML5.
4733     $self->{onerror}->(node => $attr,
4734     type => 'attribute not allowed',
4735     level => $self->{level}->{warn});
4736    
4737     $GetHTMLBooleanAttrChecker->('autoplay')->(@_);
4738     },
4739 wakaba 1.1 controls => $GetHTMLBooleanAttrChecker->('controls'),
4740 wakaba 1.59 poster => $HTMLURIAttrChecker,
4741 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4742     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4743 wakaba 1.50 }, {
4744     %HTMLAttrStatus,
4745 wakaba 1.183 autobuffer => FEATURE_HTML5_LC,
4746 wakaba 1.50 autoplay => FEATURE_HTML5_LC,
4747     controls => FEATURE_HTML5_LC,
4748 wakaba 1.153 end => FEATURE_HTML5_AT_RISK,
4749 wakaba 1.50 height => FEATURE_HTML5_LC,
4750 wakaba 1.153 loopend => FEATURE_HTML5_AT_RISK,
4751     loopstart => FEATURE_HTML5_AT_RISK,
4752     playcount => FEATURE_HTML5_AT_RISK,
4753 wakaba 1.50 poster => FEATURE_HTML5_LC,
4754     src => FEATURE_HTML5_LC,
4755 wakaba 1.153 start => FEATURE_HTML5_AT_RISK,
4756 wakaba 1.50 width => FEATURE_HTML5_LC,
4757 wakaba 1.1 }),
4758 wakaba 1.42 check_start => sub {
4759     my ($self, $item, $element_state) = @_;
4760     $element_state->{allow_source}
4761     = not $item->{node}->has_attribute_ns (undef, 'src');
4762     $element_state->{has_source} ||= $element_state->{allow_source} * -1;
4763     ## NOTE: It might be set true by |check_element|.
4764 wakaba 1.66
4765     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4766     $element_state->{uri_info}->{poster}->{type}->{embedded} = 1;
4767 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4768     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4769 wakaba 1.42 },
4770     check_child_element => sub {
4771     my ($self, $item, $child_el, $child_nsuri, $child_ln,
4772     $child_is_transparent, $element_state) = @_;
4773 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
4774     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
4775 wakaba 1.42 $self->{onerror}->(node => $child_el,
4776     type => 'element not allowed:minus',
4777 wakaba 1.104 level => $self->{level}->{must});
4778 wakaba 1.42 delete $element_state->{allow_source};
4779     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
4780     #
4781     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'source') {
4782 wakaba 1.45 unless ($element_state->{allow_source}) {
4783 wakaba 1.104 $self->{onerror}->(node => $child_el,
4784 wakaba 1.72 type => 'element not allowed:flow',
4785 wakaba 1.104 level => $self->{level}->{must});
4786 wakaba 1.42 }
4787 wakaba 1.45 $element_state->{has_source} = 1;
4788 wakaba 1.1 } else {
4789 wakaba 1.42 delete $element_state->{allow_source};
4790 wakaba 1.72 $HTMLFlowContentChecker{check_child_element}->(@_);
4791 wakaba 1.42 }
4792     },
4793     check_child_text => sub {
4794     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
4795     if ($has_significant) {
4796     delete $element_state->{allow_source};
4797     }
4798 wakaba 1.72 $HTMLFlowContentChecker{check_child_text}->(@_);
4799 wakaba 1.42 },
4800     check_end => sub {
4801     my ($self, $item, $element_state) = @_;
4802     if ($element_state->{has_source} == -1) {
4803     $self->{onerror}->(node => $item->{node},
4804 wakaba 1.104 type => 'child element missing',
4805     text => 'source',
4806     level => $self->{level}->{must});
4807 wakaba 1.1 }
4808 wakaba 1.42
4809     $Element->{$HTML_NS}->{object}->{check_end}->(@_);
4810 wakaba 1.1 },
4811     };
4812    
4813     $Element->{$HTML_NS}->{audio} = {
4814 wakaba 1.40 %{$Element->{$HTML_NS}->{video}},
4815 wakaba 1.48 status => FEATURE_HTML5_LC,
4816 wakaba 1.42 check_attrs => $GetHTMLAttrsChecker->({
4817     src => $HTMLURIAttrChecker,
4818     ## TODO: start, loopstart, loopend, end
4819     ## ISSUE: they MUST be "value time offset"s. Value?
4820     ## ISSUE: playcount has no conformance creteria
4821 wakaba 1.183 autobuffer => $GetHTMLBooleanAttrChecker->('autobuffer'),
4822 wakaba 1.205 autoplay => sub {
4823     my ($self, $attr) = @_;
4824    
4825     ## "Authors are also encouraged to consider not using the
4826     ## automatic playback behavior at all" according to HTML5.
4827     $self->{onerror}->(node => $attr,
4828     type => 'attribute not allowed',
4829     level => $self->{level}->{warn});
4830    
4831     $GetHTMLBooleanAttrChecker->('autoplay')->(@_);
4832     },
4833 wakaba 1.42 controls => $GetHTMLBooleanAttrChecker->('controls'),
4834 wakaba 1.50 }, {
4835     %HTMLAttrStatus,
4836 wakaba 1.183 autobuffer => FEATURE_HTML5_LC,
4837 wakaba 1.50 autoplay => FEATURE_HTML5_LC,
4838     controls => FEATURE_HTML5_LC,
4839 wakaba 1.153 end => FEATURE_HTML5_AT_RISK,
4840     loopend => FEATURE_HTML5_AT_RISK,
4841     loopstart => FEATURE_HTML5_AT_RISK,
4842     playcount => FEATURE_HTML5_AT_RISK,
4843 wakaba 1.50 src => FEATURE_HTML5_LC,
4844 wakaba 1.153 start => FEATURE_HTML5_AT_RISK,
4845 wakaba 1.42 }),
4846 wakaba 1.1 };
4847    
4848     $Element->{$HTML_NS}->{source} = {
4849 wakaba 1.40 %HTMLEmptyChecker,
4850 wakaba 1.153 status => FEATURE_HTML5_LC,
4851 wakaba 1.40 check_attrs => sub {
4852     my ($self, $item, $element_state) = @_;
4853 wakaba 1.1 $GetHTMLAttrsChecker->({
4854 wakaba 1.90 media => $HTMLMQAttrChecker,
4855 wakaba 1.206 pixelratio => $PositiveFloatingPointNumberAttrChecker,
4856     src => $HTMLURIAttrChecker,
4857 wakaba 1.1 type => $HTMLIMTAttrChecker,
4858 wakaba 1.50 }, {
4859     %HTMLAttrStatus,
4860 wakaba 1.153 media => FEATURE_HTML5_LC,
4861 wakaba 1.206 pixelratio => FEATURE_HTML5_DROPPED,
4862 wakaba 1.153 src => FEATURE_HTML5_LC,
4863     type => FEATURE_HTML5_LC,
4864 wakaba 1.66 })->(@_);
4865 wakaba 1.40 unless ($item->{node}->has_attribute_ns (undef, 'src')) {
4866     $self->{onerror}->(node => $item->{node},
4867 wakaba 1.104 type => 'attribute missing',
4868     text => 'src',
4869     level => $self->{level}->{must});
4870 wakaba 1.1 }
4871 wakaba 1.66
4872     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
4873 wakaba 1.206
4874     ## NOTE: The |pixelratio| attribute should have been forbidden
4875     ## when the parent of the |source| element is an |audio| element,
4876     ## but the attribute itself has been dropped from the spec.
4877 wakaba 1.1 },
4878 wakaba 1.206 }; # source
4879 wakaba 1.1
4880     $Element->{$HTML_NS}->{canvas} = {
4881 wakaba 1.40 %HTMLTransparentChecker,
4882 wakaba 1.187 status => FEATURE_HTML5_REC,
4883 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
4884 wakaba 1.1 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4885     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
4886 wakaba 1.50 }, {
4887     %HTMLAttrStatus,
4888 wakaba 1.187 height => FEATURE_HTML5_REC,
4889     width => FEATURE_HTML5_REC,
4890 wakaba 1.1 }),
4891 wakaba 1.178
4892     # Authors MUST provide alternative content (HTML5 revision 2868) -
4893     # This requirement cannot be checked, since the alternative content
4894     # might be placed outside of the element.
4895     }; # canvas
4896 wakaba 1.1
4897     $Element->{$HTML_NS}->{map} = {
4898 wakaba 1.72 %HTMLFlowContentChecker,
4899 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4900 wakaba 1.40 check_attrs => sub {
4901     my ($self, $item, $element_state) = @_;
4902 wakaba 1.100 my $has_name;
4903 wakaba 1.4 $GetHTMLAttrsChecker->({
4904 wakaba 1.100 name => sub {
4905     my ($self, $attr) = @_;
4906     my $value = $attr->value;
4907     if (length $value) {
4908 wakaba 1.196 # XXX
4909 wakaba 1.100 ## NOTE: Duplication is not non-conforming.
4910     ## NOTE: Space characters are not non-conforming.
4911     #
4912     } else {
4913     $self->{onerror}->(node => $attr,
4914     type => 'empty attribute value',
4915 wakaba 1.104 level => $self->{level}->{must});
4916 wakaba 1.100 }
4917 wakaba 1.4 $self->{map}->{$value} ||= $attr;
4918 wakaba 1.100 $has_name = [$value, $attr];
4919 wakaba 1.4 },
4920 wakaba 1.49 }, {
4921     %HTMLAttrStatus,
4922 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4923     dir => FEATURE_HTML5_REC,
4924     id => FEATURE_HTML5_REC,
4925     lang => FEATURE_HTML5_REC,
4926 wakaba 1.153 #name => FEATURE_HTML5_LC | FEATURE_M12N10_REC_DEPRECATED,
4927     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
4928 wakaba 1.50 onclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4929     ondblclick => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4930     onmousedown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4931     onmouseup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4932     onmouseover => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4933     onmousemove => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4934     onmouseout => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4935     onkeypress => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4936     onkeydown => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4937     onkeyup => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
4938 wakaba 1.187 title => FEATURE_HTML5_REC,
4939 wakaba 1.66 })->(@_);
4940 wakaba 1.100
4941 wakaba 1.135 if ($has_name) {
4942 wakaba 1.145 my $id = $item->{node}->get_attribute_ns (undef, 'id');
4943 wakaba 1.135 if (defined $id and $has_name->[0] ne $id) {
4944 wakaba 1.155 $self->{onerror}
4945     ->(node => $item->{node}->get_attribute_node_ns (undef, 'id'),
4946     type => 'id ne name',
4947     level => $self->{level}->{must});
4948 wakaba 1.100 }
4949 wakaba 1.135 } else {
4950 wakaba 1.100 $self->{onerror}->(node => $item->{node},
4951 wakaba 1.104 type => 'attribute missing',
4952     text => 'name',
4953     level => $self->{level}->{must});
4954 wakaba 1.100 }
4955 wakaba 1.4 },
4956 wakaba 1.59 check_start => sub {
4957     my ($self, $item, $element_state) = @_;
4958     $element_state->{in_map_original} = $self->{flag}->{in_map};
4959 wakaba 1.137 $self->{flag}->{in_map} = [@{$self->{flag}->{in_map} or []}, {}];
4960     ## NOTE: |{in_map}| is a reference to the array which contains
4961     ## hash references. Hashes are corresponding to the opening
4962     ## |map| elements and each of them contains the key-value
4963     ## pairs corresponding to the absolute URLs for the processed
4964     ## |area| elements in the |map| element corresponding to the
4965     ## hash. The key represents the resource (## TODO: use
4966     ## absolute URL), while the value represents whether there is
4967     ## an |area| element whose |alt| attribute is specified to a
4968     ## non-empty value. If there IS such an |area| element for
4969     ## the resource specified by the key, then the value is set to
4970     ## zero (|0|). Otherwise, if there is no such an |area|
4971     ## element but there is any |area| element with the empty
4972     ## |alt=""| attribute, then the value contains an array
4973     ## reference that contains all of such |area| elements.
4974 wakaba 1.79
4975     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
4976     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
4977 wakaba 1.59 },
4978     check_end => sub {
4979     my ($self, $item, $element_state) = @_;
4980 wakaba 1.137
4981     for (keys %{$self->{flag}->{in_map}->[-1]}) {
4982     my $nodes = $self->{flag}->{in_map}->[-1]->{$_};
4983     next unless $nodes;
4984     for (@$nodes) {
4985     $self->{onerror}->(type => 'empty area alt',
4986     node => $_,
4987     level => $self->{level}->{html5_no_may});
4988     }
4989     }
4990    
4991     $self->{flag}->{in_map} = $element_state->{in_map_original};
4992    
4993 wakaba 1.72 $HTMLFlowContentChecker{check_end}->(@_);
4994 wakaba 1.59 },
4995 wakaba 1.1 };
4996    
4997     $Element->{$HTML_NS}->{area} = {
4998 wakaba 1.40 %HTMLEmptyChecker,
4999 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5000 wakaba 1.40 check_attrs => sub {
5001     my ($self, $item, $element_state) = @_;
5002 wakaba 1.1 my %attr;
5003     my $coords;
5004 wakaba 1.40 for my $attr (@{$item->{node}->attributes}) {
5005 wakaba 1.1 my $attr_ns = $attr->namespace_uri;
5006     $attr_ns = '' unless defined $attr_ns;
5007     my $attr_ln = $attr->manakai_local_name;
5008     my $checker;
5009 wakaba 1.73 my $status;
5010 wakaba 1.1 if ($attr_ns eq '') {
5011 wakaba 1.73 $status = {
5012     %HTMLAttrStatus,
5013     %HTMLM12NCommonAttrStatus,
5014 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
5015 wakaba 1.153 alt => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5016     coords => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5017 wakaba 1.154 href => FEATURE_HTML5_WD | FEATURE_RDFA_REC | FEATURE_M12N10_REC,
5018 wakaba 1.153 hreflang => FEATURE_HTML5_WD,
5019 wakaba 1.187 lang => FEATURE_HTML5_REC,
5020 wakaba 1.154 media => FEATURE_HTML5_WD,
5021 wakaba 1.73 nohref => FEATURE_M12N10_REC,
5022     onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5023     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5024 wakaba 1.153 ping => FEATURE_HTML5_WD,
5025 wakaba 1.154 rel => FEATURE_HTML5_WD | FEATURE_RDFA_REC,
5026 wakaba 1.153 shape => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5027 wakaba 1.73 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5028 wakaba 1.153 target => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5029     type => FEATURE_HTML5_WD,
5030 wakaba 1.73 }->{$attr_ln};
5031    
5032 wakaba 1.1 $checker = {
5033 wakaba 1.153 alt => sub {
5034     ## NOTE: Checked later.
5035     },
5036 wakaba 1.1 shape => $GetHTMLEnumeratedAttrChecker->({
5037     circ => -1, circle => 1,
5038     default => 1,
5039     poly => 1, polygon => -1,
5040     rect => 1, rectangle => -1,
5041     }),
5042     coords => sub {
5043     my ($self, $attr) = @_;
5044     my $value = $attr->value;
5045     if ($value =~ /\A-?[0-9]+(?>,-?[0-9]+)*\z/) {
5046     $coords = [split /,/, $value];
5047     } else {
5048     $self->{onerror}->(node => $attr,
5049 wakaba 1.104 type => 'coords:syntax error',
5050     level => $self->{level}->{must});
5051 wakaba 1.1 }
5052     },
5053 wakaba 1.70 nohref => $GetHTMLBooleanAttrChecker->('nohref'),
5054     target => $HTMLTargetAttrChecker,
5055 wakaba 1.1 href => $HTMLURIAttrChecker,
5056     ping => $HTMLSpaceURIsAttrChecker,
5057 wakaba 1.40 rel => sub { $HTMLLinkTypesAttrChecker->(1, $item, @_) },
5058 wakaba 1.1 media => $HTMLMQAttrChecker,
5059     hreflang => $HTMLLanguageTagAttrChecker,
5060     type => $HTMLIMTAttrChecker,
5061     }->{$attr_ln};
5062     if ($checker) {
5063     $attr{$attr_ln} = $attr;
5064 wakaba 1.122 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
5065     $attr_ln !~ /[A-Z]/) {
5066 wakaba 1.73 $checker = $HTMLDatasetAttrChecker;
5067     $status = $HTMLDatasetAttrStatus;
5068 wakaba 1.1 } else {
5069     $checker = $HTMLAttrChecker->{$attr_ln};
5070     }
5071     }
5072     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
5073 wakaba 1.82 || $AttrChecker->{$attr_ns}->{''};
5074     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
5075     || $AttrStatus->{$attr_ns}->{''};
5076     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
5077 wakaba 1.62
5078 wakaba 1.1 if ($checker) {
5079 wakaba 1.66 $checker->($self, $attr, $item, $element_state) if ref $checker;
5080 wakaba 1.62 } elsif ($attr_ns eq '' and not $status) {
5081 wakaba 1.54 #
5082 wakaba 1.1 } else {
5083 wakaba 1.104 $self->{onerror}->(node => $attr,
5084     type => 'unknown attribute',
5085     level => $self->{level}->{uncertain});
5086 wakaba 1.1 ## ISSUE: No comformance createria for unknown attributes in the spec
5087     }
5088 wakaba 1.49
5089 wakaba 1.82 $self->_attr_status_info ($attr, $status);
5090 wakaba 1.1 }
5091    
5092     if (defined $attr{href}) {
5093 wakaba 1.4 $self->{has_hyperlink_element} = 1;
5094 wakaba 1.137 if (defined $attr{alt}) {
5095     my $url = $attr{href}->value; ## TODO: resolve
5096     if (length $attr{alt}->value) {
5097     for (@{$self->{flag}->{in_map} or []}) {
5098     $_->{$url} = 0;
5099     }
5100     } else {
5101     ## NOTE: Empty |alt=""|. If there is another |area| element
5102     ## with the same |href=""| and that |area| elemnet's
5103     ## |alt=""| attribute is not an empty string, then this
5104     ## is conforming.
5105     for (@{$self->{flag}->{in_map} or []}) {
5106     push @{$_->{$url} ||= []}, $attr{alt}
5107     unless exists $_->{$url} and not $_->{$url};
5108     }
5109     }
5110     } else {
5111 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5112 wakaba 1.104 type => 'attribute missing',
5113     text => 'alt',
5114     level => $self->{level}->{must});
5115 wakaba 1.1 }
5116     } else {
5117     for (qw/target ping rel media hreflang type alt/) {
5118     if (defined $attr{$_}) {
5119     $self->{onerror}->(node => $attr{$_},
5120 wakaba 1.104 type => 'attribute not allowed',
5121     level => $self->{level}->{must});
5122 wakaba 1.1 }
5123     }
5124     }
5125    
5126     my $shape = 'rectangle';
5127     if (defined $attr{shape}) {
5128     $shape = {
5129     circ => 'circle', circle => 'circle',
5130     default => 'default',
5131     poly => 'polygon', polygon => 'polygon',
5132     rect => 'rectangle', rectangle => 'rectangle',
5133     }->{lc $attr{shape}->value} || 'rectangle';
5134     ## TODO: ASCII lowercase?
5135     }
5136    
5137     if ($shape eq 'circle') {
5138     if (defined $attr{coords}) {
5139     if (defined $coords) {
5140     if (@$coords == 3) {
5141     if ($coords->[2] < 0) {
5142     $self->{onerror}->(node => $attr{coords},
5143 wakaba 1.104 type => 'coords:out of range',
5144     index => 2,
5145     value => $coords->[2],
5146     level => $self->{level}->{must});
5147 wakaba 1.1 }
5148     } else {
5149     $self->{onerror}->(node => $attr{coords},
5150 wakaba 1.104 type => 'coords:number not 3',
5151     text => 0+@$coords,
5152     level => $self->{level}->{must});
5153 wakaba 1.1 }
5154     } else {
5155     ## NOTE: A syntax error has been reported.
5156     }
5157     } else {
5158 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5159 wakaba 1.104 type => 'attribute missing',
5160     text => 'coords',
5161     level => $self->{level}->{must});
5162 wakaba 1.1 }
5163     } elsif ($shape eq 'default') {
5164     if (defined $attr{coords}) {
5165     $self->{onerror}->(node => $attr{coords},
5166 wakaba 1.104 type => 'attribute not allowed',
5167     level => $self->{level}->{must});
5168 wakaba 1.1 }
5169     } elsif ($shape eq 'polygon') {
5170     if (defined $attr{coords}) {
5171     if (defined $coords) {
5172     if (@$coords >= 6) {
5173     unless (@$coords % 2 == 0) {
5174     $self->{onerror}->(node => $attr{coords},
5175 wakaba 1.104 type => 'coords:number not even',
5176     text => 0+@$coords,
5177     level => $self->{level}->{must});
5178 wakaba 1.1 }
5179     } else {
5180     $self->{onerror}->(node => $attr{coords},
5181 wakaba 1.104 type => 'coords:number lt 6',
5182     text => 0+@$coords,
5183     level => $self->{level}->{must});
5184 wakaba 1.1 }
5185     } else {
5186     ## NOTE: A syntax error has been reported.
5187     }
5188     } else {
5189 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5190 wakaba 1.104 type => 'attribute missing',
5191     text => 'coords',
5192     level => $self->{level}->{must});
5193 wakaba 1.1 }
5194     } elsif ($shape eq 'rectangle') {
5195     if (defined $attr{coords}) {
5196     if (defined $coords) {
5197     if (@$coords == 4) {
5198     unless ($coords->[0] < $coords->[2]) {
5199     $self->{onerror}->(node => $attr{coords},
5200 wakaba 1.104 type => 'coords:out of range',
5201     index => 0,
5202     value => $coords->[0],
5203     level => $self->{level}->{must});
5204 wakaba 1.1 }
5205     unless ($coords->[1] < $coords->[3]) {
5206     $self->{onerror}->(node => $attr{coords},
5207 wakaba 1.104 type => 'coords:out of range',
5208     index => 1,
5209     value => $coords->[1],
5210     level => $self->{level}->{must});
5211 wakaba 1.1 }
5212     } else {
5213     $self->{onerror}->(node => $attr{coords},
5214 wakaba 1.104 type => 'coords:number not 4',
5215     text => 0+@$coords,
5216     level => $self->{level}->{must});
5217 wakaba 1.1 }
5218     } else {
5219     ## NOTE: A syntax error has been reported.
5220     }
5221     } else {
5222 wakaba 1.40 $self->{onerror}->(node => $item->{node},
5223 wakaba 1.104 type => 'attribute missing',
5224     text => 'coords',
5225     level => $self->{level}->{must});
5226 wakaba 1.1 }
5227     }
5228 wakaba 1.66
5229     $element_state->{uri_info}->{href}->{type}->{hyperlink} = 1;
5230 wakaba 1.1 },
5231 wakaba 1.59 check_start => sub {
5232     my ($self, $item, $element_state) = @_;
5233     unless ($self->{flag}->{in_map} or
5234     not $item->{node}->manakai_parent_element) {
5235     $self->{onerror}->(node => $item->{node},
5236     type => 'element not allowed:area',
5237 wakaba 1.104 level => $self->{level}->{must});
5238 wakaba 1.59 }
5239 wakaba 1.79
5240     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5241     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5242 wakaba 1.59 },
5243 wakaba 1.1 };
5244    
5245     $Element->{$HTML_NS}->{table} = {
5246 wakaba 1.40 %HTMLChecker,
5247 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5248 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5249 wakaba 1.86 cellpadding => $HTMLLengthAttrChecker,
5250     cellspacing => $HTMLLengthAttrChecker,
5251 wakaba 1.69 frame => $GetHTMLEnumeratedAttrChecker->({
5252     void => 1, above => 1, below => 1, hsides => 1, vsides => 1,
5253     lhs => 1, rhs => 1, box => 1, border => 1,
5254     }),
5255     rules => $GetHTMLEnumeratedAttrChecker->({
5256     none => 1, groups => 1, rows => 1, cols => 1, all => 1,
5257     }),
5258     summary => sub {}, ## NOTE: %Text; in HTML4.
5259     width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }), ## %Pixels;
5260     }, {
5261 wakaba 1.49 %HTMLAttrStatus,
5262 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5263 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
5264     bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5265     border => FEATURE_M12N10_REC,
5266     cellpadding => FEATURE_M12N10_REC,
5267     cellspacing => FEATURE_M12N10_REC,
5268 wakaba 1.61 cols => FEATURE_RFC1942,
5269 wakaba 1.49 datafld => FEATURE_HTML4_REC_RESERVED,
5270     dataformatas => FEATURE_HTML4_REC_RESERVED,
5271     datapagesize => FEATURE_M12N10_REC,
5272     datasrc => FEATURE_HTML4_REC_RESERVED,
5273     frame => FEATURE_M12N10_REC,
5274 wakaba 1.187 lang => FEATURE_HTML5_REC,
5275 wakaba 1.49 rules => FEATURE_M12N10_REC,
5276     summary => FEATURE_M12N10_REC,
5277     width => FEATURE_M12N10_REC,
5278     }),
5279 wakaba 1.40 check_start => sub {
5280     my ($self, $item, $element_state) = @_;
5281     $element_state->{phase} = 'before caption';
5282 wakaba 1.66
5283     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
5284 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5285     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5286 wakaba 1.40 },
5287     check_child_element => sub {
5288     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5289     $child_is_transparent, $element_state) = @_;
5290 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5291     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5292 wakaba 1.40 $self->{onerror}->(node => $child_el,
5293     type => 'element not allowed:minus',
5294 wakaba 1.104 level => $self->{level}->{must});
5295 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5296     #
5297     } elsif ($element_state->{phase} eq 'in tbodys') {
5298     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5299     #$element_state->{phase} = 'in tbodys';
5300     } elsif (not $element_state->{has_tfoot} and
5301     $child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5302     $element_state->{phase} = 'after tfoot';
5303     $element_state->{has_tfoot} = 1;
5304     } else {
5305 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5306     level => $self->{level}->{must});
5307 wakaba 1.40 }
5308     } elsif ($element_state->{phase} eq 'in trs') {
5309     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5310     #$element_state->{phase} = 'in trs';
5311     } elsif (not $element_state->{has_tfoot} and
5312     $child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5313     $element_state->{phase} = 'after tfoot';
5314     $element_state->{has_tfoot} = 1;
5315     } else {
5316 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5317     level => $self->{level}->{must});
5318 wakaba 1.40 }
5319     } elsif ($element_state->{phase} eq 'after thead') {
5320     if ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5321     $element_state->{phase} = 'in tbodys';
5322     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5323     $element_state->{phase} = 'in trs';
5324     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5325     $element_state->{phase} = 'in tbodys';
5326     $element_state->{has_tfoot} = 1;
5327     } else {
5328 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5329     level => $self->{level}->{must});
5330 wakaba 1.40 }
5331     } elsif ($element_state->{phase} eq 'in colgroup') {
5332     if ($child_nsuri eq $HTML_NS and $child_ln eq 'colgroup') {
5333     $element_state->{phase} = 'in colgroup';
5334     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'thead') {
5335     $element_state->{phase} = 'after thead';
5336     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5337     $element_state->{phase} = 'in tbodys';
5338     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5339     $element_state->{phase} = 'in trs';
5340     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5341     $element_state->{phase} = 'in tbodys';
5342     $element_state->{has_tfoot} = 1;
5343     } else {
5344 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5345     level => $self->{level}->{must});
5346 wakaba 1.40 }
5347     } elsif ($element_state->{phase} eq 'before caption') {
5348     if ($child_nsuri eq $HTML_NS and $child_ln eq 'caption') {
5349 wakaba 1.181 $item->{parent_state}->{table_caption_element} = $child_el;
5350 wakaba 1.40 $element_state->{phase} = 'in colgroup';
5351     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'colgroup') {
5352     $element_state->{phase} = 'in colgroup';
5353     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'thead') {
5354     $element_state->{phase} = 'after thead';
5355     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tbody') {
5356     $element_state->{phase} = 'in tbodys';
5357     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5358     $element_state->{phase} = 'in trs';
5359     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tfoot') {
5360     $element_state->{phase} = 'in tbodys';
5361     $element_state->{has_tfoot} = 1;
5362     } else {
5363 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5364     level => $self->{level}->{must});
5365 wakaba 1.40 }
5366     } elsif ($element_state->{phase} eq 'after tfoot') {
5367 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5368     level => $self->{level}->{must});
5369 wakaba 1.40 } else {
5370     die "check_child_element: Bad |table| phase: $element_state->{phase}";
5371     }
5372     },
5373     check_child_text => sub {
5374     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5375     if ($has_significant) {
5376 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5377     level => $self->{level}->{must});
5378 wakaba 1.1 }
5379 wakaba 1.40 },
5380     check_end => sub {
5381     my ($self, $item, $element_state) = @_;
5382 wakaba 1.1
5383     ## Table model errors
5384     require Whatpm::HTMLTable;
5385 wakaba 1.87 my $table = Whatpm::HTMLTable->form_table ($item->{node}, sub {
5386 wakaba 1.104 $self->{onerror}->(@_);
5387     }, $self->{level});
5388 wakaba 1.87 Whatpm::HTMLTable->assign_header
5389 wakaba 1.104 ($table, $self->{onerror}, $self->{level});
5390 wakaba 1.87 push @{$self->{return}->{table}}, $table;
5391 wakaba 1.1
5392 wakaba 1.40 $HTMLChecker{check_end}->(@_);
5393 wakaba 1.1 },
5394     };
5395    
5396     $Element->{$HTML_NS}->{caption} = {
5397 wakaba 1.169 %HTMLFlowContentChecker,
5398 wakaba 1.187 status => FEATURE_HTML5_REC,
5399 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5400     align => $GetHTMLEnumeratedAttrChecker->({
5401     top => 1, bottom => 1, left => 1, right => 1,
5402     }),
5403     }, {
5404 wakaba 1.49 %HTMLAttrStatus,
5405 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5406 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
5407 wakaba 1.187 lang => FEATURE_HTML5_REC,
5408 wakaba 1.49 }),
5409 wakaba 1.169 check_start => sub {
5410     my ($self, $item, $element_state) = @_;
5411     $self->_add_minus_elements ($element_state, {$HTML_NS => {table => 1}});
5412    
5413     $HTMLFlowContentChecker{check_start}->(@_);
5414     },
5415     check_end => sub {
5416     my ($self, $item, $element_state) = @_;
5417     $self->_remove_minus_elements ($element_state);
5418    
5419     $HTMLFlowContentChecker{check_end}->(@_);
5420     },
5421     }; # caption
5422 wakaba 1.1
5423 wakaba 1.69 my %cellalign = (
5424     ## HTML4 %cellhalign;
5425 wakaba 1.70 align => $GetHTMLEnumeratedAttrChecker->({
5426     left => 1, center => 1, right => 1, justify => 1, char => 1,
5427     }),
5428     char => sub {
5429     my ($self, $attr) = @_;
5430 wakaba 1.69
5431 wakaba 1.70 ## NOTE: "character" or |%Character;| in HTML4.
5432    
5433     my $value = $attr->value;
5434     if (length $value != 1) {
5435     $self->{onerror}->(node => $attr, type => 'char:syntax error',
5436 wakaba 1.105 level => $self->{level}->{html4_fact});
5437 wakaba 1.70 }
5438     },
5439 wakaba 1.86 charoff => $HTMLLengthAttrChecker,
5440    
5441 wakaba 1.69 ## HTML4 %cellvalign;
5442 wakaba 1.70 valign => $GetHTMLEnumeratedAttrChecker->({
5443     top => 1, middle => 1, bottom => 1, baseline => 1,
5444     }),
5445 wakaba 1.69 );
5446    
5447 wakaba 1.1 $Element->{$HTML_NS}->{colgroup} = {
5448 wakaba 1.40 %HTMLEmptyChecker,
5449 wakaba 1.187 status => FEATURE_HTML5_REC,
5450 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5451 wakaba 1.69 %cellalign,
5452 wakaba 1.1 span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5453     ## NOTE: Defined only if "the |colgroup| element contains no |col| elements"
5454     ## TODO: "attribute not supported" if |col|.
5455     ## ISSUE: MUST NOT if any |col|?
5456     ## ISSUE: MUST NOT for |<colgroup span="1"><any><col/></any></colgroup>| (though non-conforming)?
5457 wakaba 1.49 }, {
5458     %HTMLAttrStatus,
5459 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5460 wakaba 1.49 align => FEATURE_M12N10_REC,
5461     char => FEATURE_M12N10_REC,
5462     charoff => FEATURE_M12N10_REC,
5463 wakaba 1.187 lang => FEATURE_HTML5_REC,
5464 wakaba 1.153 span => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5465 wakaba 1.49 valign => FEATURE_M12N10_REC,
5466     width => FEATURE_M12N10_REC,
5467 wakaba 1.1 }),
5468 wakaba 1.40 check_child_element => sub {
5469     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5470     $child_is_transparent, $element_state) = @_;
5471 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5472     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5473 wakaba 1.40 $self->{onerror}->(node => $child_el,
5474     type => 'element not allowed:minus',
5475 wakaba 1.104 level => $self->{level}->{must});
5476 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5477     #
5478     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'col') {
5479     #
5480     } else {
5481 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5482     level => $self->{level}->{must});
5483 wakaba 1.40 }
5484     },
5485     check_child_text => sub {
5486     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5487     if ($has_significant) {
5488 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5489     level => $self->{level}->{must});
5490 wakaba 1.1 }
5491     },
5492     };
5493    
5494     $Element->{$HTML_NS}->{col} = {
5495 wakaba 1.40 %HTMLEmptyChecker,
5496 wakaba 1.187 status => FEATURE_HTML5_REC,
5497 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5498 wakaba 1.69 %cellalign,
5499 wakaba 1.1 span => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5500 wakaba 1.49 }, {
5501     %HTMLAttrStatus,
5502 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5503 wakaba 1.49 align => FEATURE_M12N10_REC,
5504     char => FEATURE_M12N10_REC,
5505     charoff => FEATURE_M12N10_REC,
5506 wakaba 1.187 lang => FEATURE_HTML5_REC,
5507 wakaba 1.153 span => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5508 wakaba 1.49 valign => FEATURE_M12N10_REC,
5509     width => FEATURE_M12N10_REC,
5510 wakaba 1.1 }),
5511     };
5512    
5513     $Element->{$HTML_NS}->{tbody} = {
5514 wakaba 1.40 %HTMLChecker,
5515 wakaba 1.187 status => FEATURE_HTML5_REC,
5516 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5517     %cellalign,
5518     }, {
5519 wakaba 1.49 %HTMLAttrStatus,
5520 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5521 wakaba 1.49 align => FEATURE_M12N10_REC,
5522     char => FEATURE_M12N10_REC,
5523     charoff => FEATURE_M12N10_REC,
5524 wakaba 1.187 lang => FEATURE_HTML5_REC,
5525 wakaba 1.49 valign => FEATURE_M12N10_REC,
5526     }),
5527 wakaba 1.40 check_child_element => sub {
5528     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5529     $child_is_transparent, $element_state) = @_;
5530 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5531     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5532 wakaba 1.40 $self->{onerror}->(node => $child_el,
5533     type => 'element not allowed:minus',
5534 wakaba 1.104 level => $self->{level}->{must});
5535 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5536     #
5537     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'tr') {
5538 wakaba 1.84 #
5539 wakaba 1.40 } else {
5540 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5541     level => $self->{level}->{must});
5542 wakaba 1.40 }
5543     },
5544     check_child_text => sub {
5545     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5546     if ($has_significant) {
5547 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5548     level => $self->{level}->{must});
5549 wakaba 1.1 }
5550 wakaba 1.40 },
5551 wakaba 1.1 };
5552    
5553     $Element->{$HTML_NS}->{thead} = {
5554 wakaba 1.40 %{$Element->{$HTML_NS}->{tbody}},
5555 wakaba 1.1 };
5556    
5557     $Element->{$HTML_NS}->{tfoot} = {
5558 wakaba 1.40 %{$Element->{$HTML_NS}->{tbody}},
5559 wakaba 1.1 };
5560    
5561     $Element->{$HTML_NS}->{tr} = {
5562 wakaba 1.40 %HTMLChecker,
5563 wakaba 1.187 status => FEATURE_HTML5_REC,
5564 wakaba 1.69 check_attrs => $GetHTMLAttrsChecker->({
5565     %cellalign,
5566     bgcolor => $HTMLColorAttrChecker,
5567     }, {
5568 wakaba 1.49 %HTMLAttrStatus,
5569 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5570 wakaba 1.49 align => FEATURE_M12N10_REC,
5571     bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5572     char => FEATURE_M12N10_REC,
5573     charoff => FEATURE_M12N10_REC,
5574 wakaba 1.187 lang => FEATURE_HTML5_REC,
5575 wakaba 1.49 valign => FEATURE_M12N10_REC,
5576     }),
5577 wakaba 1.40 check_child_element => sub {
5578     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5579     $child_is_transparent, $element_state) = @_;
5580 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5581     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5582 wakaba 1.40 $self->{onerror}->(node => $child_el,
5583     type => 'element not allowed:minus',
5584 wakaba 1.104 level => $self->{level}->{must});
5585 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5586     #
5587     } elsif ($child_nsuri eq $HTML_NS and
5588     ($child_ln eq 'td' or $child_ln eq 'th')) {
5589 wakaba 1.84 #
5590 wakaba 1.40 } else {
5591 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
5592     level => $self->{level}->{must});
5593 wakaba 1.40 }
5594     },
5595     check_child_text => sub {
5596     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5597     if ($has_significant) {
5598 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
5599     level => $self->{level}->{must});
5600 wakaba 1.1 }
5601     },
5602     };
5603    
5604     $Element->{$HTML_NS}->{td} = {
5605 wakaba 1.72 %HTMLFlowContentChecker,
5606 wakaba 1.187 status => FEATURE_HTML5_REC,
5607 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5608 wakaba 1.69 %cellalign,
5609     abbr => sub {}, ## NOTE: HTML4 %Text; and SHOULD be short.
5610     axis => sub {}, ## NOTE: HTML4 "cdata", comma-separated
5611     bgcolor => $HTMLColorAttrChecker,
5612 wakaba 1.1 colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5613 wakaba 1.87 headers => sub {
5614     ## NOTE: Will be checked by Whatpm::HTMLTable->assign_header.
5615     ## Though that method does not check the |headers| attribute of a
5616     ## |td| element if the element does not form a table, in that case
5617     ## the |td| element is non-conforming anyway.
5618     },
5619 wakaba 1.69 nowrap => $GetHTMLBooleanAttrChecker->('nowrap'),
5620 wakaba 1.1 rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5621 wakaba 1.69 scope => $GetHTMLEnumeratedAttrChecker
5622     ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
5623 wakaba 1.49 }, {
5624     %HTMLAttrStatus,
5625 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5626     abbr => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5627 wakaba 1.49 align => FEATURE_M12N10_REC,
5628 wakaba 1.82 axis => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5629 wakaba 1.49 bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5630     char => FEATURE_M12N10_REC,
5631     charoff => FEATURE_M12N10_REC,
5632 wakaba 1.153 colspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5633 wakaba 1.187 headers => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5634 wakaba 1.49 height => FEATURE_M12N10_REC_DEPRECATED,
5635 wakaba 1.187 lang => FEATURE_HTML5_REC,
5636 wakaba 1.49 nowrap => FEATURE_M12N10_REC_DEPRECATED,
5637 wakaba 1.153 rowspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5638 wakaba 1.82 scope => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5639 wakaba 1.49 valign => FEATURE_M12N10_REC,
5640     width => FEATURE_M12N10_REC_DEPRECATED,
5641 wakaba 1.1 }),
5642     };
5643    
5644     $Element->{$HTML_NS}->{th} = {
5645 wakaba 1.40 %HTMLPhrasingContentChecker,
5646 wakaba 1.187 status => FEATURE_HTML5_REC,
5647 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
5648 wakaba 1.69 %cellalign,
5649     abbr => sub {}, ## NOTE: HTML4 %Text; and SHOULD be short.
5650     axis => sub {}, ## NOTE: HTML4 "cdata", comma-separated
5651     bgcolor => $HTMLColorAttrChecker,
5652 wakaba 1.1 colspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5653 wakaba 1.87 ## TODO: HTML4(?) |headers|
5654 wakaba 1.69 nowrap => $GetHTMLBooleanAttrChecker->('nowrap'),
5655 wakaba 1.1 rowspan => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
5656     scope => $GetHTMLEnumeratedAttrChecker
5657     ->({row => 1, col => 1, rowgroup => 1, colgroup => 1}),
5658 wakaba 1.49 }, {
5659     %HTMLAttrStatus,
5660 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
5661     abbr => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5662 wakaba 1.49 align => FEATURE_M12N10_REC,
5663 wakaba 1.82 axis => FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5664 wakaba 1.49 bgcolor => FEATURE_M12N10_REC_DEPRECATED,
5665     char => FEATURE_M12N10_REC,
5666     charoff => FEATURE_M12N10_REC,
5667 wakaba 1.153 colspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5668 wakaba 1.187 headers => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5669 wakaba 1.49 height => FEATURE_M12N10_REC_DEPRECATED,
5670 wakaba 1.187 lang => FEATURE_HTML5_REC,
5671 wakaba 1.49 nowrap => FEATURE_M12N10_REC_DEPRECATED,
5672 wakaba 1.153 rowspan => FEATURE_HTML5_LC | FEATURE_XHTML2_ED | FEATURE_M12N10_REC,
5673 wakaba 1.187 scope => FEATURE_HTML5_REC,
5674 wakaba 1.49 valign => FEATURE_M12N10_REC,
5675     width => FEATURE_M12N10_REC_DEPRECATED,
5676 wakaba 1.1 }),
5677     };
5678    
5679 wakaba 1.52 $Element->{$HTML_NS}->{form} = {
5680 wakaba 1.121 %HTMLFlowContentChecker,
5681 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5682 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
5683 wakaba 1.161 accept => $AcceptAttrChecker,
5684 wakaba 1.129 'accept-charset' => $HTMLCharsetsAttrChecker,
5685 wakaba 1.166 action => $HTMLURIAttrChecker, ## TODO: Warn if submission is not defined for the scheme
5686 wakaba 1.185 autocomplete => $GetHTMLEnumeratedAttrChecker->({
5687     on => 1, off => 1,
5688     }),
5689 wakaba 1.56 data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
5690 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
5691     'application/x-www-form-urlencoded' => 1,
5692     'multipart/form-data' => 1,
5693     'text/plain' => 1,
5694     }),
5695 wakaba 1.56 method => $GetHTMLEnumeratedAttrChecker->({
5696     get => 1, post => 1, put => 1, delete => 1,
5697     }),
5698 wakaba 1.133 name => sub {
5699     my ($self, $attr) = @_;
5700    
5701     my $value = $attr->value;
5702     if ($value eq '') {
5703     $self->{onerror}->(type => 'empty form name',
5704     node => $attr,
5705     level => $self->{level}->{must});
5706     } else {
5707     if ($self->{form}->{$value}) {
5708     $self->{onerror}->(type => 'duplicate form name',
5709     node => $attr,
5710     value => $value,
5711     level => $self->{level}->{must});
5712     } else {
5713     $self->{form}->{$value} = 1;
5714     }
5715     }
5716     },
5717 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
5718 wakaba 1.126 onformchange => $HTMLEventHandlerAttrChecker,
5719     onforminput => $HTMLEventHandlerAttrChecker,
5720 wakaba 1.56 onreceived => $HTMLEventHandlerAttrChecker,
5721     replace => $GetHTMLEnumeratedAttrChecker->({document => 1, values => 1}),
5722 wakaba 1.52 target => $HTMLTargetAttrChecker,
5723     }, {
5724     %HTMLAttrStatus,
5725     %HTMLM12NCommonAttrStatus,
5726 wakaba 1.161 accept => FEATURE_HTML5_DROPPED | FEATURE_WF2X | FEATURE_M12N10_REC,
5727 wakaba 1.187 'accept-charset' => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5728 wakaba 1.119 action => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5729 wakaba 1.185 autocomplete => FEATURE_HTML5_WD,
5730 wakaba 1.56 data => FEATURE_WF2,
5731 wakaba 1.119 enctype => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5732 wakaba 1.187 lang => FEATURE_HTML5_REC,
5733 wakaba 1.119 method => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5734     #name => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC_DEPRECATED,
5735 wakaba 1.187 name => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5736 wakaba 1.207 novalidate => FEATURE_HTML5_LC,
5737 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
5738     onforminput => FEATURE_WF2_INFORMATIVE,
5739 wakaba 1.56 onreceived => FEATURE_WF2,
5740 wakaba 1.52 onreset => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5741     onsubmit => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5742 wakaba 1.56 replace => FEATURE_WF2,
5743 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
5744     sdasuff => FEATURE_HTML20_RFC,
5745 wakaba 1.119 target => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5746 wakaba 1.52 }),
5747 wakaba 1.66 check_start => sub {
5748     my ($self, $item, $element_state) = @_;
5749 wakaba 1.121 $self->_add_minus_elements ($element_state, {$HTML_NS => {form => 1}});
5750 wakaba 1.66
5751     $element_state->{uri_info}->{action}->{type}->{action} = 1;
5752     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
5753 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
5754     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
5755 wakaba 1.136 $element_state->{id_type} = 'form';
5756 wakaba 1.66 },
5757 wakaba 1.121 check_end => sub {
5758     my ($self, $item, $element_state) = @_;
5759     $self->_remove_minus_elements ($element_state);
5760    
5761     $HTMLFlowContentChecker{check_end}->(@_);
5762     },
5763 wakaba 1.185 }; # form
5764 wakaba 1.52
5765     $Element->{$HTML_NS}->{fieldset} = {
5766 wakaba 1.134 %HTMLFlowContentChecker,
5767 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5768 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
5769     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
5770 wakaba 1.136 form => $HTMLFormAttrChecker,
5771 wakaba 1.165 name => $FormControlNameAttrChecker,
5772 wakaba 1.56 }, {
5773 wakaba 1.52 %HTMLAttrStatus,
5774     %HTMLM12NCommonAttrStatus,
5775 wakaba 1.187 disabled => FEATURE_HTML5_WD | FEATURE_WF2X,
5776     form => FEATURE_HTML5_LC | FEATURE_WF2X,
5777     lang => FEATURE_HTML5_REC,
5778     name => FEATURE_HTML5_LC,
5779 wakaba 1.52 }),
5780 wakaba 1.134 ## NOTE: legend, Flow
5781     check_child_element => sub {
5782     my ($self, $item, $child_el, $child_nsuri, $child_ln,
5783     $child_is_transparent, $element_state) = @_;
5784     if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
5785     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
5786     $self->{onerror}->(node => $child_el,
5787     type => 'element not allowed:minus',
5788     level => $self->{level}->{must});
5789     $element_state->{has_non_legend} = 1;
5790     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
5791     #
5792     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'legend') {
5793     if ($element_state->{has_non_legend}) {
5794     $self->{onerror}->(node => $child_el,
5795     type => 'element not allowed:details legend',
5796     level => $self->{level}->{must});
5797     }
5798     $element_state->{has_legend} = 1;
5799     $element_state->{has_non_legend} = 1;
5800     } else {
5801     $HTMLFlowContentChecker{check_child_element}->(@_);
5802     $element_state->{has_non_legend} = 1 unless $child_is_transparent;
5803     ## TODO:
5804 wakaba 1.167 ## |<fieldset><object><legend>xx</legend></object>..</fieldset>|
5805 wakaba 1.134 ## should be an error, since |object| is allowed as flow,
5806     ## therefore |details| part of the content model does not match.
5807     }
5808     },
5809     check_child_text => sub {
5810     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
5811     if ($has_significant) {
5812     $element_state->{has_non_legend} = 1;
5813     }
5814     },
5815     check_end => sub {
5816     my ($self, $item, $element_state) = @_;
5817    
5818     unless ($element_state->{has_legend}) {
5819     $self->{onerror}->(node => $item->{node},
5820     type => 'child element missing',
5821     text => 'legend',
5822     level => $self->{level}->{must});
5823     }
5824    
5825     $HTMLFlowContentChecker{check_end}->(@_);
5826 wakaba 1.167 ## ISSUE: |<fieldset><legend>aa</legend></fieldset>| error?
5827 wakaba 1.134 },
5828     ## NOTE: This definition is partially reused by |details| element's
5829     ## checker.
5830 wakaba 1.52 };
5831    
5832     $Element->{$HTML_NS}->{input} = {
5833 wakaba 1.119 %HTMLEmptyChecker,
5834 wakaba 1.187 status => FEATURE_HTML5_WD | FEATURE_WF2X | FEATURE_M12N10_REC,
5835 wakaba 1.140 check_attrs => sub {
5836     my ($self, $item, $element_state) = @_;
5837 wakaba 1.142
5838 wakaba 1.145 my $state = $item->{node}->get_attribute_ns (undef, 'type');
5839 wakaba 1.142 $state = 'text' unless defined $state;
5840     $state =~ tr/A-Z/a-z/; ## ASCII case-insensitive
5841    
5842 wakaba 1.140 for my $attr (@{$item->{node}->attributes}) {
5843     my $attr_ns = $attr->namespace_uri;
5844     $attr_ns = '' unless defined $attr_ns;
5845     my $attr_ln = $attr->manakai_local_name;
5846     my $checker;
5847     my $status;
5848     if ($attr_ns eq '') {
5849     $status =
5850     {
5851     %HTMLAttrStatus,
5852     %HTMLM12NCommonAttrStatus,
5853     accept => FEATURE_HTML5_DEFAULT | FEATURE_WF2X | FEATURE_M12N10_REC,
5854     'accept-charset' => FEATURE_HTML2X_RFC,
5855 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
5856 wakaba 1.198 action => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5857 wakaba 1.140 align => FEATURE_M12N10_REC_DEPRECATED,
5858     alt => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5859 wakaba 1.185 autocomplete => FEATURE_HTML5_LC | FEATURE_WF2X,
5860 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
5861     checked => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5862 wakaba 1.140 datafld => FEATURE_HTML4_REC_RESERVED,
5863     dataformatas => FEATURE_HTML4_REC_RESERVED,
5864     datasrc => FEATURE_HTML4_REC_RESERVED,
5865 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5866 wakaba 1.198 enctype => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5867 wakaba 1.187 form => FEATURE_HTML5_LC | FEATURE_WF2X,
5868 wakaba 1.198 formaction => FEATURE_HTML5_LC,
5869     formenctype => FEATURE_HTML5_LC,
5870     formmethod => FEATURE_HTML5_LC,
5871     formnovalidate => FEATURE_HTML5_LC,
5872     formtarget => FEATURE_HTML5_LC,
5873 wakaba 1.178 height => FEATURE_HTML5_LC,
5874 wakaba 1.150 inputmode => FEATURE_HTML5_DROPPED | FEATURE_WF2X |
5875     FEATURE_XHTMLBASIC11_CR,
5876 wakaba 1.140 ismap => FEATURE_M12N10_REC,
5877 wakaba 1.187 lang => FEATURE_HTML5_REC,
5878     list => FEATURE_HTML5_LC | FEATURE_WF2X,
5879     max => FEATURE_HTML5_LC | FEATURE_WF2X,
5880     maxlength => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5881 wakaba 1.198 method => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5882 wakaba 1.187 min => FEATURE_HTML5_LC | FEATURE_WF2X,
5883     multiple => FEATURE_HTML5_LC,
5884     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
5885 wakaba 1.198 novalidate => FEATURE_HTML5_DROPPED,
5886 wakaba 1.140 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5887     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5888     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5889     onformchange => FEATURE_WF2_INFORMATIVE,
5890     onforminput => FEATURE_WF2_INFORMATIVE,
5891     oninput => FEATURE_WF2,
5892     oninvalid => FEATURE_WF2,
5893     onselect => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5894 wakaba 1.187 pattern => FEATURE_HTML5_LC | FEATURE_WF2X,
5895     placeholder => FEATURE_HTML5_LC,
5896     readonly => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5897 wakaba 1.140 replace => FEATURE_WF2,
5898 wakaba 1.187 required => FEATURE_HTML5_LC | FEATURE_WF2X,
5899 wakaba 1.140 sdapref => FEATURE_HTML20_RFC,
5900 wakaba 1.187 size => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
5901 wakaba 1.140 src => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5902 wakaba 1.187 step => FEATURE_HTML5_LC | FEATURE_WF2X,
5903 wakaba 1.140 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
5904 wakaba 1.198 target => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
5905 wakaba 1.208 template => FEATURE_HTML5_DROPPED | FEATURE_WF2,
5906 wakaba 1.187 type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5907 wakaba 1.140 usemap => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC,
5908 wakaba 1.187 value => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
5909 wakaba 1.178 width => FEATURE_HTML5_LC,
5910 wakaba 1.140 }->{$attr_ln};
5911    
5912     $checker =
5913     {
5914 wakaba 1.141 ## NOTE: Value of an empty string means that the attribute is only
5915     ## applicable for a specific set of states.
5916 wakaba 1.142 accept => '',
5917 wakaba 1.149 'accept-charset' => $HTMLCharsetsAttrChecker,
5918     ## NOTE: To which states it applies is not defined in RFC 2070.
5919 wakaba 1.142 action => '',
5920 wakaba 1.150 align => '',
5921 wakaba 1.141 alt => '',
5922 wakaba 1.142 autocomplete => '',
5923 wakaba 1.165 autofocus => $AutofocusAttrChecker,
5924     ## NOTE: <input type=hidden disabled> is not disallowed.
5925 wakaba 1.142 checked => '',
5926     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
5927 wakaba 1.165 ## NOTE: <input type=hidden disabled> is not disallowed.
5928 wakaba 1.142 enctype => '',
5929     form => $HTMLFormAttrChecker,
5930 wakaba 1.198 formaction => '',
5931     formenctype => '',
5932     formmethod => '',
5933     formnovalidate => '',
5934     formtarget => '',
5935 wakaba 1.178 height => '',
5936 wakaba 1.150 inputmode => '',
5937     ismap => '', ## NOTE: "MUST" be type=image [HTML4]
5938 wakaba 1.142 list => '',
5939     max => '',
5940     maxlength => '',
5941     method => '',
5942     min => '',
5943 wakaba 1.156 multiple => '',
5944 wakaba 1.165 name => $FormControlNameAttrChecker,
5945 wakaba 1.166 novalidate => '',
5946 wakaba 1.149 onformchange => $HTMLEventHandlerAttrChecker, # [WF2]
5947     onforminput => $HTMLEventHandlerAttrChecker, # [WF2]
5948     oninput => $HTMLEventHandlerAttrChecker, # [WF2]
5949     oninvalid => $HTMLEventHandlerAttrChecker, # [WF2]
5950     ## TODO: tests for four attributes above
5951 wakaba 1.142 pattern => '',
5952 wakaba 1.156 placeholder => '',
5953 wakaba 1.142 readonly => '',
5954 wakaba 1.150 replace => '',
5955 wakaba 1.142 required => '',
5956     size => '',
5957     src => '',
5958     step => '',
5959     target => '',
5960 wakaba 1.140 type => $GetHTMLEnumeratedAttrChecker->({
5961 wakaba 1.156 hidden => 1, text => 1, search => 1, url => 1,
5962 wakaba 1.193 tel => 1, email => 1, password => 1,
5963 wakaba 1.141 datetime => 1, date => 1, month => 1, week => 1, time => 1,
5964 wakaba 1.157 'datetime-local' => 1, number => 1, range => 1, color => 1,
5965     checkbox => 1,
5966 wakaba 1.141 radio => 1, file => 1, submit => 1, image => 1, reset => 1,
5967     button => 1,
5968 wakaba 1.140 }),
5969 wakaba 1.151 usemap => '',
5970 wakaba 1.142 value => '',
5971 wakaba 1.178 width => '',
5972 wakaba 1.140 }->{$attr_ln};
5973 wakaba 1.141
5974     ## State-dependent checkers
5975     unless ($checker) {
5976     if ($state eq 'hidden') {
5977     $checker =
5978     {
5979 wakaba 1.142 value => sub {
5980     my ($self, $attr, $item, $element_state) = @_;
5981 wakaba 1.145 my $name = $item->{node}->get_attribute_ns (undef, 'name');
5982 wakaba 1.142 if (defined $name and $name eq '_charset_') { ## case-sensitive
5983     $self->{onerror}->(node => $attr,
5984     type => '_charset_ value',
5985     level => $self->{level}->{must});
5986     }
5987     },
5988 wakaba 1.141 }->{$attr_ln} || $checker;
5989 wakaba 1.142 ## TODO: Warn if no name attribute?
5990     ## TODO: Warn if name!=_charset_ and no value attribute?
5991 wakaba 1.168 } elsif ({
5992     datetime => 1, date => 1, month => 1, time => 1,
5993     week => 1, 'datetime-local' => 1,
5994     }->{$state}) {
5995     my $v = {
5996     datetime => ['global_date_and_time_string'],
5997     date => ['date_string'],
5998     month => ['month_string'],
5999     week => ['week_string'],
6000     time => ['time_string'],
6001     'datetime-local' => ['local_date_and_time_string'],
6002     }->{$state};
6003 wakaba 1.144 $checker =
6004     {
6005 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6006     on => 1, off => 1,
6007     }),
6008 wakaba 1.158 list => $ListAttrChecker,
6009 wakaba 1.168 min => $GetDateTimeAttrChecker->($v->[0]),
6010     max => $GetDateTimeAttrChecker->($v->[0]),
6011 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6012 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6013 wakaba 1.148 step => $StepAttrChecker,
6014 wakaba 1.168 value => $GetDateTimeAttrChecker->($v->[0]),
6015 wakaba 1.144 }->{$attr_ln} || $checker;
6016 wakaba 1.205
6017     ## XXX Maybe it is better to check min <= value <= max
6018     ## relation is hold for convinience?
6019 wakaba 1.144 } elsif ($state eq 'number') {
6020     $checker =
6021     {
6022 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6023     on => 1, off => 1,
6024     }),
6025 wakaba 1.158 list => $ListAttrChecker,
6026 wakaba 1.144 max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6027     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6028 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6029 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6030 wakaba 1.148 step => $StepAttrChecker,
6031 wakaba 1.168 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6032 wakaba 1.144 }->{$attr_ln} || $checker;
6033     } elsif ($state eq 'range') {
6034     $checker =
6035     {
6036 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6037     on => 1, off => 1,
6038     }),
6039 wakaba 1.158 list => $ListAttrChecker,
6040 wakaba 1.144 max => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6041     min => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6042 wakaba 1.148 step => $StepAttrChecker,
6043 wakaba 1.168 value => $GetHTMLFloatingPointNumberAttrChecker->(sub { 1 }),
6044 wakaba 1.144 }->{$attr_ln} || $checker;
6045 wakaba 1.157 } elsif ($state eq 'color') {
6046     $checker =
6047     {
6048     autocomplete => $GetHTMLEnumeratedAttrChecker->({
6049     on => 1, off => 1,
6050     }),
6051 wakaba 1.158 list => $ListAttrChecker,
6052 wakaba 1.157 value => sub {
6053     my ($self, $attr) = @_;
6054     unless ($attr->value =~ /\A#[0-9A-Fa-f]{6}\z/) {
6055     $self->{onerror}->(node => $attr,
6056     type => 'scolor:syntax error', ## TODOC: type
6057     level => $self->{level}->{must});
6058     }
6059     },
6060     }->{$attr_ln} || $checker;
6061 wakaba 1.144 } elsif ($state eq 'checkbox' or $state eq 'radio') {
6062     $checker =
6063     {
6064 wakaba 1.149 checked => $GetHTMLBooleanAttrChecker->('checked'),
6065     ## TODO: tests
6066 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6067 wakaba 1.144 value => sub { }, ## NOTE: No restriction.
6068     }->{$attr_ln} || $checker;
6069     ## TODO: There MUST be another input type=radio with same
6070     ## name (Radio state).
6071     ## ISSUE: There should be exactly one type=radio with checked?
6072     } elsif ($state eq 'file') {
6073     $checker =
6074     {
6075 wakaba 1.161 accept => $AcceptAttrChecker,
6076 wakaba 1.168 ## max (default 1) & min (default 0) [WF2]: Dropped by HTML5.
6077 wakaba 1.159 multiple => $GetHTMLBooleanAttrChecker->('multiple'),
6078 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6079 wakaba 1.144 }->{$attr_ln} || $checker;
6080     } elsif ($state eq 'submit') {
6081     $checker =
6082     {
6083 wakaba 1.149 action => $HTMLURIAttrChecker,
6084 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6085     'application/x-www-form-urlencoded' => 1,
6086     'multipart/form-data' => 1,
6087     'text/plain' => 1,
6088     }),
6089 wakaba 1.198 formaction => $HTMLURIAttrChecker,
6090     formenctype => $GetHTMLEnumeratedAttrChecker->({
6091     'application/x-www-form-urlencoded' => 1,
6092     'multipart/form-data' => 1,
6093     'text/plain' => 1,
6094     }),
6095     formmethod => $GetHTMLEnumeratedAttrChecker->({
6096     get => 1, post => 1, put => 1, delete => 1,
6097     }),
6098     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6099     formtarget => $HTMLTargetAttrChecker,
6100 wakaba 1.149 method => $GetHTMLEnumeratedAttrChecker->({
6101     get => 1, post => 1, put => 1, delete => 1,
6102     }),
6103 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6104 wakaba 1.149 replace => $GetHTMLEnumeratedAttrChecker->({
6105     document => 1, values => 1,
6106     }),
6107     target => $HTMLTargetAttrChecker,
6108 wakaba 1.144 value => sub { }, ## NOTE: No restriction.
6109     }->{$attr_ln} || $checker;
6110     } elsif ($state eq 'image') {
6111     $checker =
6112     {
6113 wakaba 1.149 action => $HTMLURIAttrChecker,
6114     align => $GetHTMLEnumeratedAttrChecker->({
6115     top => 1, middle => 1, bottom => 1, left => 1, right => 1,
6116     }),
6117 wakaba 1.144 alt => sub {
6118     my ($self, $attr) = @_;
6119     my $value = $attr->value;
6120     unless (length $value) {
6121     $self->{onerror}->(node => $attr,
6122     type => 'empty anchor image alt',
6123     level => $self->{level}->{must});
6124     }
6125     },
6126 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6127     'application/x-www-form-urlencoded' => 1,
6128     'multipart/form-data' => 1,
6129     'text/plain' => 1,
6130     }),
6131 wakaba 1.198 formaction => $HTMLURIAttrChecker,
6132     formenctype => $GetHTMLEnumeratedAttrChecker->({
6133     'application/x-www-form-urlencoded' => 1,
6134     'multipart/form-data' => 1,
6135     'text/plain' => 1,
6136     }),
6137     formmethod => $GetHTMLEnumeratedAttrChecker->({
6138     get => 1, post => 1, put => 1, delete => 1,
6139     }),
6140     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6141     formtarget => $HTMLTargetAttrChecker,
6142 wakaba 1.178 height => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
6143 wakaba 1.149 ismap => $GetHTMLBooleanAttrChecker->('ismap'),
6144     method => $GetHTMLEnumeratedAttrChecker->({
6145     get => 1, post => 1, put => 1, delete => 1,
6146     }),
6147 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6148 wakaba 1.149 replace => $GetHTMLEnumeratedAttrChecker->({
6149     document => 1, values => 1,
6150     }),
6151 wakaba 1.144 src => $HTMLURIAttrChecker,
6152     ## TODO: There is requirements on the referenced resource.
6153 wakaba 1.149 target => $HTMLTargetAttrChecker,
6154     usemap => $HTMLUsemapAttrChecker,
6155 wakaba 1.178 width => $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 }),
6156 wakaba 1.144 }->{$attr_ln} || $checker;
6157     ## TODO: alt & src are required.
6158     } elsif ({
6159     reset => 1, button => 1,
6160     ## NOTE: From Web Forms 2.0:
6161     remove => 1, 'move-up' => 1, 'move-down' => 1,
6162     add => 1,
6163     }->{$state}) {
6164     $checker =
6165     {
6166     ## NOTE: According to Web Forms 2.0, |input| attribute
6167     ## has |template| attribute to support the |add| button
6168     ## type (as part of the repetition template feature). It
6169     ## conflicts with the |template| global attribute
6170     ## introduced as part of the data template feature.
6171     ## NOTE: |template| attribute as defined in Web Forms 2.0
6172     ## has no author requirement.
6173     value => sub { }, ## NOTE: No restriction.
6174     }->{$attr_ln} || $checker;
6175 wakaba 1.193 } else { # Text, Search, E-mail, URL, Telephone, Password
6176 wakaba 1.141 $checker =
6177     {
6178 wakaba 1.145 autocomplete => $GetHTMLEnumeratedAttrChecker->({
6179     on => 1, off => 1,
6180     }),
6181 wakaba 1.149 ## TODO: inputmode [WF2]
6182 wakaba 1.158 list => $ListAttrChecker,
6183 wakaba 1.147 maxlength => sub {
6184     my ($self, $attr, $item, $element_state) = @_;
6185    
6186     $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 })->(@_);
6187    
6188 wakaba 1.165 if ($attr->value =~ /^[\x09\x0A\x0C\x0D\x20]*([0-9]+)/) {
6189 wakaba 1.147 ## NOTE: Applying the rules for parsing non-negative
6190     ## integers results in a number.
6191     my $max_allowed_value_length = 0+$1;
6192    
6193     my $value = $item->{node}->get_attribute_ns (undef, 'value');
6194     if (defined $value) {
6195     my $codepoint_length = length $value;
6196 wakaba 1.162
6197 wakaba 1.147 if ($codepoint_length > $max_allowed_value_length) {
6198     $self->{onerror}
6199     ->(node => $item->{node}
6200     ->get_attribute_node_ns (undef, 'value'),
6201     type => 'value too long',
6202     level => $self->{level}->{must});
6203     }
6204     }
6205     }
6206     },
6207 wakaba 1.160 pattern => $PatternAttrChecker,
6208 wakaba 1.179 placeholder => $PlaceholderAttrChecker,
6209 wakaba 1.145 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6210 wakaba 1.146 required => $GetHTMLBooleanAttrChecker->('required'),
6211 wakaba 1.147 size => $GetHTMLNonNegativeIntegerAttrChecker->(sub {shift > 0}),
6212 wakaba 1.143 value => sub {
6213 wakaba 1.156 my ($self, $attr, $item, $element_state) = @_;
6214     if ($state eq 'url') {
6215 wakaba 1.205 ## XXX MUST be absolute IRI.
6216 wakaba 1.156 $HTMLURIAttrChecker->(@_);
6217     } elsif ($state eq 'email') {
6218     if ($item->{node}->has_attribute_ns (undef, 'multiple')) {
6219 wakaba 1.200 ## A set of comma-separated tokens.
6220 wakaba 1.156 my @addr = split /,/, $attr->value, -1;
6221     @addr = ('') unless @addr;
6222     for (@addr) {
6223 wakaba 1.165 s/\A[\x09\x0A\x0C\x0D\x20]+//;
6224     s/[\x09\x0A\x0C\x0D\x20]\z//;
6225 wakaba 1.200
6226     unless (/\A$ValidEmailAddress\z/o) {
6227 wakaba 1.156 $self->{onerror}->(node => $attr,
6228     type => 'email:syntax error', ## TODO: type
6229     value => $_,
6230     level => $self->{level}->{must});
6231     }
6232     }
6233     } else {
6234     unless ($attr->value =~ /\A$ValidEmailAddress\z/) {
6235     $self->{onerror}->(node => $attr,
6236     type => 'email:syntax error', ## TODO: type
6237     level => $self->{level}->{must});
6238     }
6239     }
6240     } else {
6241     if ($attr->value =~ /[\x0D\x0A]/) {
6242     $self->{onerror}->(node => $attr,
6243     type => 'newline in value', ## TODO: type
6244     level => $self->{level}->{must});
6245     }
6246     }
6247 wakaba 1.143 },
6248 wakaba 1.141 }->{$attr_ln} || $checker;
6249 wakaba 1.147 $checker = '' if $state eq 'password' and $attr_ln eq 'list';
6250 wakaba 1.156 $checker = $GetHTMLBooleanAttrChecker->('multiple')
6251     if $state eq 'email' and $attr_ln eq 'multiple';
6252 wakaba 1.161
6253     if ($item->{node}->has_attribute_ns (undef, 'pattern') and
6254     not $item->{node}->has_attribute_ns (undef, 'title')) {
6255     $self->{onerror}->(node => $item->{node},
6256     type => 'attribute missing',
6257     text => 'title',
6258     level => $self->{level}->{should});
6259     }
6260 wakaba 1.141 }
6261     }
6262    
6263     if (defined $checker) {
6264     if ($checker eq '') {
6265     $checker = sub {
6266     my ($self, $attr) = @_;
6267     $self->{onerror}->(node => $attr,
6268     type => 'input attr not applicable',
6269     text => $state,
6270     level => $self->{level}->{must});
6271     };
6272     }
6273 wakaba 1.140 } elsif ($attr_ln =~ /^data-\p{InXMLNCNameChar10}+\z/ and
6274     $attr_ln !~ /[A-Z]/) {
6275     $checker = $HTMLDatasetAttrChecker;
6276     $status = $HTMLDatasetAttrStatus;
6277     } else {
6278     $checker = $HTMLAttrChecker->{$attr_ln};
6279     }
6280     }
6281     $checker ||= $AttrChecker->{$attr_ns}->{$attr_ln}
6282     || $AttrChecker->{$attr_ns}->{''};
6283     $status ||= $AttrStatus->{$attr_ns}->{$attr_ln}
6284     || $AttrStatus->{$attr_ns}->{''};
6285     $status = FEATURE_ALLOWED if not defined $status and length $attr_ns;
6286 wakaba 1.157
6287 wakaba 1.140 if ($checker) {
6288     $checker->($self, $attr, $item, $element_state) if ref $checker;
6289     } elsif ($attr_ns eq '' and not $status) {
6290     #
6291     } else {
6292     $self->{onerror}->(node => $attr,
6293     type => 'unknown attribute',
6294     level => $self->{level}->{uncertain});
6295     ## ISSUE: No comformance createria for unknown attributes in the spec
6296     }
6297    
6298     $self->_attr_status_info ($attr, $status);
6299     }
6300 wakaba 1.168
6301     ## ISSUE: -0/+0
6302    
6303     if ($state eq 'range') {
6304     $element_state->{number_value}->{min} ||= 0;
6305     $element_state->{number_value}->{max} = 100
6306     unless defined $element_state->{number_value}->{max};
6307     }
6308    
6309     if (defined $element_state->{date_value}->{min} or
6310     defined $element_state->{date_value}->{max}) {
6311     my $min_value = $element_state->{date_value}->{min};
6312     my $max_value = $element_state->{date_value}->{max};
6313     my $value_value = $element_state->{date_value}->{value};
6314    
6315     if (defined $min_value and $min_value eq '' and
6316     (defined $max_value or defined $value_value)) {
6317     my $min = $item->{node}->get_attribute_node_ns (undef, 'min');
6318     $self->{onerror}->(node => $min,
6319     type => 'date value not supported', ## TODOC: type
6320     value => $min->value,
6321     level => $self->{level}->{unsupported});
6322     undef $min_value;
6323     }
6324     if (defined $max_value and $max_value eq '' and
6325     (defined $max_value or defined $value_value)) {
6326     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6327     $self->{onerror}->(node => $max,
6328     type => 'date value not supported', ## TODOC: type
6329     value => $max->value,
6330     level => $self->{level}->{unsupported});
6331     undef $max_value;
6332     }
6333     if (defined $value_value and $value_value eq '' and
6334     (defined $max_value or defined $min_value)) {
6335     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6336     $self->{onerror}->(node => $value,
6337     type => 'date value not supported', ## TODOC: type
6338     value => $value->value,
6339     level => $self->{level}->{unsupported});
6340     undef $value_value;
6341     }
6342    
6343     if (defined $min_value and defined $max_value) {
6344     if ($min_value->to_html5_number > $max_value->to_html5_number) {
6345     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6346     $self->{onerror}->(node => $max,
6347     type => 'max lt min', ## TODOC: type
6348     level => $self->{level}->{must});
6349     }
6350     }
6351    
6352     if (defined $min_value and defined $value_value) {
6353     if ($min_value->to_html5_number > $value_value->to_html5_number) {
6354     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6355     $self->{onerror}->(node => $value,
6356     type => 'value lt min', ## TODOC: type
6357     level => $self->{level}->{warn});
6358     ## NOTE: Not an error.
6359     }
6360     }
6361    
6362     if (defined $max_value and defined $value_value) {
6363     if ($max_value->to_html5_number < $value_value->to_html5_number) {
6364     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6365     $self->{onerror}->(node => $value,
6366     type => 'value gt max', ## TODOC: type
6367     level => $self->{level}->{warn});
6368     ## NOTE: Not an error.
6369     }
6370     }
6371     } elsif (defined $element_state->{number_value}->{min} or
6372     defined $element_state->{number_value}->{max}) {
6373     my $min_value = $element_state->{number_value}->{min};
6374     my $max_value = $element_state->{number_value}->{max};
6375     my $value_value = $element_state->{number_value}->{value};
6376    
6377     if (defined $min_value and defined $max_value) {
6378     if ($min_value > $max_value) {
6379     my $max = $item->{node}->get_attribute_node_ns (undef, 'max');
6380     $self->{onerror}->(node => $max,
6381     type => 'max lt min', ## TODOC: type
6382     level => $self->{level}->{must});
6383     }
6384     }
6385    
6386     if (defined $min_value and defined $value_value) {
6387     if ($min_value > $value_value) {
6388     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6389     $self->{onerror}->(node => $value,
6390     type => 'value lt min', ## TODOC: type
6391     level => $self->{level}->{warn});
6392     ## NOTE: Not an error.
6393     }
6394     }
6395    
6396     if (defined $max_value and defined $value_value) {
6397     if ($max_value < $value_value) {
6398     my $value = $item->{node}->get_attribute_node_ns (undef, 'value');
6399     $self->{onerror}->(node => $value,
6400     type => 'value gt max', ## TODOC: type
6401     level => $self->{level}->{warn});
6402     ## NOTE: Not an error.
6403     }
6404     }
6405     }
6406 wakaba 1.150
6407 wakaba 1.168 ## TODO: Warn unless value = min * x where x is an integer.
6408    
6409 wakaba 1.150 $element_state->{uri_info}->{action}->{type}->{action} = 1;
6410 wakaba 1.198 $element_state->{uri_info}->{action}->{type}->{formaction} = 1;
6411 wakaba 1.150 $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6412     $element_state->{uri_info}->{src}->{type}->{embedded} = 1;
6413     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6414     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6415 wakaba 1.192 }, # check_attrs
6416 wakaba 1.66 check_start => sub {
6417     my ($self, $item, $element_state) = @_;
6418 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6419     }, # check_start
6420     check_attrs2 => sub {
6421     my ($self, $item, $element_state) = @_;
6422     $FAECheckAttrs2->($self, $item, $element_state);
6423     }, # check_attrs2
6424     }; # input
6425 wakaba 1.52
6426 wakaba 1.178 ## XXXresource: Dimension attributes have requirements on width and
6427     ## height of referenced resource.
6428 wakaba 1.80
6429 wakaba 1.52 $Element->{$HTML_NS}->{button} = {
6430 wakaba 1.202 %HTMLPhrasingContentChecker,
6431 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6432 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6433 wakaba 1.199 ## XXXISSUE: In HTML5, no "MUST NOT" for using |action|, |method|,
6434 wakaba 1.165 ## |enctype|, |target|, and |novalidate| with non-|submit|-|type|
6435     ## |button| elements.
6436 wakaba 1.56 action => $HTMLURIAttrChecker,
6437 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6438 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6439 wakaba 1.166 enctype => $GetHTMLEnumeratedAttrChecker->({
6440     'application/x-www-form-urlencoded' => 1,
6441     'multipart/form-data' => 1,
6442     'text/plain' => 1,
6443     }),
6444 wakaba 1.136 form => $HTMLFormAttrChecker,
6445 wakaba 1.199 formaction => $HTMLURIAttrChecker,
6446     formenctype => $GetHTMLEnumeratedAttrChecker->({
6447     'application/x-www-form-urlencoded' => 1,
6448     'multipart/form-data' => 1,
6449     'text/plain' => 1,
6450     }),
6451     formmethod => $GetHTMLEnumeratedAttrChecker->({
6452     get => 1, post => 1, put => 1, delete => 1,
6453     }),
6454     formnovalidate => $GetHTMLBooleanAttrChecker->('formnovalidate'),
6455     formtarget => $HTMLTargetAttrChecker,
6456 wakaba 1.56 method => $GetHTMLEnumeratedAttrChecker->({
6457     get => 1, post => 1, put => 1, delete => 1,
6458     }),
6459 wakaba 1.165 name => $FormControlNameAttrChecker,
6460 wakaba 1.166 novalidate => $GetHTMLBooleanAttrChecker->('novalidate'),
6461 wakaba 1.162 onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
6462     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6463 wakaba 1.56 replace => $GetHTMLEnumeratedAttrChecker->({document => 1, values => 1}),
6464     target => $HTMLTargetAttrChecker,
6465 wakaba 1.80 ## NOTE: According to Web Forms 2.0, |button| attribute has |template|
6466     ## attribute to support the |add| button type (as part of repetition
6467     ## template feature). It conflicts with the |template| global attribute
6468     ## introduced as part of the data template feature.
6469     ## NOTE: |template| attribute as defined in Web Forms 2.0 has no
6470     ## author requirement.
6471 wakaba 1.52 type => $GetHTMLEnumeratedAttrChecker->({
6472     button => 1, submit => 1, reset => 1,
6473     }),
6474 wakaba 1.162 value => sub {}, ## NOTE: No restriction.
6475 wakaba 1.52 }, {
6476     %HTMLAttrStatus,
6477     %HTMLM12NCommonAttrStatus,
6478 wakaba 1.176 accesskey => FEATURE_M12N10_REC | FEATURE_HTML5_FD,
6479 wakaba 1.199 action => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6480 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
6481 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
6482     dataformatas => FEATURE_HTML4_REC_RESERVED,
6483     datasrc => FEATURE_HTML4_REC_RESERVED,
6484 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6485 wakaba 1.199 enctype => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6486 wakaba 1.187 form => FEATURE_HTML5_LC | FEATURE_WF2X,
6487 wakaba 1.199 formaction => FEATURE_HTML5_LC,
6488     formenctype => FEATURE_HTML5_LC,
6489     formmethod => FEATURE_HTML5_LC,
6490     formnovalidate => FEATURE_HTML5_LC,
6491     formtarget => FEATURE_HTML5_LC,
6492 wakaba 1.187 lang => FEATURE_HTML5_REC,
6493 wakaba 1.199 method => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6494 wakaba 1.187 name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6495 wakaba 1.199 novalidate => FEATURE_HTML5_DROPPED,
6496 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6497     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6498 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
6499     onforminput => FEATURE_WF2_INFORMATIVE,
6500 wakaba 1.56 replace => FEATURE_WF2,
6501 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6502 wakaba 1.199 target => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6503 wakaba 1.208 template => FEATURE_HTML5_DROPPED | FEATURE_WF2,
6504 wakaba 1.187 type => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6505     value => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6506 wakaba 1.199 }), # check_attrs
6507 wakaba 1.66 check_start => sub {
6508     my ($self, $item, $element_state) = @_;
6509 wakaba 1.202 $self->_add_minus_elements ($element_state, $HTMLInteractiveContent);
6510 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6511 wakaba 1.162
6512 wakaba 1.202 ## XXXISSUE: "The value attribute must not be present unless the
6513     ## form [content] attribute is present.": Wrong? Maybe it should
6514     ## also be allowed when there is an ancestor |form| element.
6515 wakaba 1.139
6516 wakaba 1.66 $element_state->{uri_info}->{action}->{type}->{action} = 1;
6517 wakaba 1.202 $element_state->{uri_info}->{formaction}->{type}->{action} = 1;
6518 wakaba 1.66 $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6519 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6520     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6521 wakaba 1.192 }, # check_start
6522     check_attrs2 => sub {
6523     my ($self, $item, $element_state) = @_;
6524     $FAECheckAttrs2->($self, $item, $element_state);
6525     }, # check_attrs2
6526 wakaba 1.202 check_end => sub {
6527     my ($self, $item, $element_state) = @_;
6528     $self->_remove_minus_elements ($element_state);
6529    
6530     $HTMLPhrasingContentChecker{check_end}->(@_);
6531     }, # check_end
6532 wakaba 1.199 }; # button
6533 wakaba 1.52
6534     $Element->{$HTML_NS}->{label} = {
6535 wakaba 1.139 %HTMLPhrasingContentChecker,
6536 wakaba 1.187 status => FEATURE_HTML5_REC,
6537 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6538 wakaba 1.138 for => sub {
6539     my ($self, $attr) = @_;
6540    
6541     ## NOTE: MUST be an ID of a labelable element.
6542    
6543     push @{$self->{idref}}, ['labelable', $attr->value, $attr];
6544     },
6545 wakaba 1.136 form => $HTMLFormAttrChecker,
6546 wakaba 1.52 }, {
6547     %HTMLAttrStatus,
6548 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
6549 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_WF2 | FEATURE_M12N10_REC,
6550 wakaba 1.187 for => FEATURE_HTML5_REC,
6551     form => FEATURE_HTML5_LC,
6552     lang => FEATURE_HTML5_REC,
6553 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6554     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6555     }),
6556 wakaba 1.139 check_start => sub {
6557     my ($self, $item, $element_state) = @_;
6558     $self->_add_minus_elements ($element_state, {$HTML_NS => {label => 1}});
6559    
6560 wakaba 1.192 ## If $self->{flag}->{has_label} is true, then there is at least
6561     ## an ancestor |label| element.
6562    
6563     ## If $self->{flag}->{has_labelable} is equal to 1, then there is
6564     ## an ancestor |label| element with its |for| attribute specified.
6565     ## If the value is equal to 2, then there is an ancestor |label|
6566     ## element with its |for| attribute unspecified but there is an
6567     ## associated form control element.
6568    
6569 wakaba 1.139 $element_state->{has_label_original} = $self->{flag}->{has_label};
6570 wakaba 1.192 $element_state->{has_labelable_original} = $self->{flag}->{has_labelable};
6571     $element_state->{label_for_original} = $self->{flag}->{label_for};
6572    
6573 wakaba 1.139 $self->{flag}->{has_label} = 1;
6574 wakaba 1.155 $self->{flag}->{has_labelable}
6575     = $item->{node}->has_attribute_ns (undef, 'for') ? 1 : 0;
6576 wakaba 1.192 $self->{flag}->{label_for}
6577     = $item->{node}->get_attribute_ns (undef, 'for');
6578 wakaba 1.139
6579     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6580     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6581     },
6582     check_end => sub {
6583     my ($self, $item, $element_state) = @_;
6584     $self->_remove_minus_elements ($element_state);
6585    
6586     if ($self->{flag}->{has_labelable} == 1) { # has for="" but no labelable
6587     $self->{flag}->{has_labelable}
6588     = $element_state->{has_labelable_original};
6589     }
6590     delete $self->{flag}->{has_label}
6591     unless $element_state->{has_label_original};
6592 wakaba 1.192 $self->{flag}->{label_for} = $element_state->{label_for_original};
6593    
6594 wakaba 1.139 ## TODO: Warn if no labelable descendant? <input type=hidden>?
6595    
6596     ## NOTE: |<label for=a><input id=a></label>| is non-conforming.
6597    
6598     $HTMLPhrasingContentChecker{check_end}->(@_);
6599     },
6600 wakaba 1.192 }; # label
6601 wakaba 1.52
6602     $Element->{$HTML_NS}->{select} = {
6603 wakaba 1.121 %HTMLChecker,
6604 wakaba 1.163 ## ISSUE: HTML5 has no requirement like these:
6605 wakaba 1.52 ## TODO: author should SELECTED at least one OPTION in non-MULTIPLE case [HTML4].
6606     ## TODO: more than one OPTION with SELECTED in non-MULTIPLE case is "error" [HTML4]
6607 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6608 wakaba 1.56 is_root => 1, ## TODO: SHOULD NOT in application/xhtml+xml [WF2]
6609 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6610 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6611 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6612 wakaba 1.56 data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
6613 wakaba 1.136 form => $HTMLFormAttrChecker,
6614 wakaba 1.52 multiple => $GetHTMLBooleanAttrChecker->('multiple'),
6615 wakaba 1.165 name => $FormControlNameAttrChecker,
6616 wakaba 1.163 ## TODO: tests for on*
6617 wakaba 1.126 onformchange => $HTMLEventHandlerAttrChecker,
6618     onforminput => $HTMLEventHandlerAttrChecker,
6619     oninput => $HTMLEventHandlerAttrChecker,
6620 wakaba 1.56 oninvalid => $HTMLEventHandlerAttrChecker,
6621 wakaba 1.163 size => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6622 wakaba 1.52 }, {
6623     %HTMLAttrStatus,
6624     %HTMLM12NCommonAttrStatus,
6625 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_WF2,
6626 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
6627 wakaba 1.56 data => FEATURE_WF2,
6628 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
6629     dataformatas => FEATURE_HTML4_REC_RESERVED,
6630     datasrc => FEATURE_HTML4_REC_RESERVED,
6631 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6632     form => FEATURE_HTML5_LC | FEATURE_WF2X,
6633     lang => FEATURE_HTML5_REC,
6634     multiple => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6635     name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6636 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6637     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6638 wakaba 1.126 onformchange => FEATURE_WF2_INFORMATIVE,
6639     onforminput => FEATURE_WF2_INFORMATIVE,
6640 wakaba 1.52 onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6641 wakaba 1.126 oninput => FEATURE_WF2,
6642 wakaba 1.56 oninvalid => FEATURE_WF2,
6643 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
6644     sdapref => FEATURE_HTML20_RFC,
6645 wakaba 1.187 size => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6646 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6647     }),
6648 wakaba 1.66 check_start => sub {
6649     my ($self, $item, $element_state) = @_;
6650 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6651 wakaba 1.66
6652     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
6653     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
6654 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6655     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6656 wakaba 1.192 }, # check_start
6657     check_attrs2 => sub {
6658     my ($self, $item, $element_state) = @_;
6659     $FAECheckAttrs2->($self, $item, $element_state);
6660     }, # check_attrs2
6661 wakaba 1.121 check_child_element => sub {
6662 wakaba 1.163 ## NOTE: (option | optgroup)*
6663    
6664 wakaba 1.121 my ($self, $item, $child_el, $child_nsuri, $child_ln,
6665     $child_is_transparent, $element_state) = @_;
6666 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6667     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6668 wakaba 1.121 $self->{onerror}->(node => $child_el,
6669     type => 'element not allowed:minus',
6670     level => $self->{level}->{must});
6671     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6672     #
6673     } elsif ($child_nsuri eq $HTML_NS and
6674     {
6675     option => 1, optgroup => 1,
6676     }->{$child_ln}) {
6677     #
6678     } else {
6679     $self->{onerror}->(node => $child_el, type => 'element not allowed',
6680     level => $self->{level}->{must});
6681     }
6682     },
6683     check_child_text => sub {
6684     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6685     if ($has_significant) {
6686     $self->{onerror}->(node => $child_node, type => 'character not allowed',
6687     level => $self->{level}->{must});
6688     }
6689     },
6690 wakaba 1.52 };
6691 wakaba 1.1
6692 wakaba 1.52 $Element->{$HTML_NS}->{datalist} = {
6693 wakaba 1.121 %HTMLPhrasingContentChecker,
6694 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X,
6695 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
6696     data => $HTMLURIAttrChecker, ## TODO: MUST point ... [WF2]
6697     }, {
6698 wakaba 1.52 %HTMLAttrStatus,
6699 wakaba 1.56 data => FEATURE_WF2,
6700 wakaba 1.52 }),
6701 wakaba 1.66 check_start => sub {
6702     my ($self, $item, $element_state) = @_;
6703    
6704 wakaba 1.121 $element_state->{phase} = 'any'; # any | phrasing | option
6705    
6706 wakaba 1.66 $element_state->{uri_info}->{data}->{type}->{resource} = 1;
6707 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6708     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6709 wakaba 1.158
6710     $element_state->{id_type} = 'datalist';
6711 wakaba 1.66 },
6712 wakaba 1.121 ## NOTE: phrasing | option*
6713     check_child_element => sub {
6714     my ($self, $item, $child_el, $child_nsuri, $child_ln,
6715     $child_is_transparent, $element_state) = @_;
6716 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6717     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6718 wakaba 1.121 $self->{onerror}->(node => $child_el,
6719     type => 'element not allowed:minus',
6720     level => $self->{level}->{must});
6721     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6722     #
6723     } elsif ($element_state->{phase} eq 'phrasing') {
6724     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
6725     #
6726     } else {
6727     $self->{onerror}->(node => $child_el,
6728     type => 'element not allowed:phrasing',
6729     level => $self->{level}->{must});
6730     }
6731     } elsif ($element_state->{phase} eq 'option') {
6732     if ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6733     #
6734     } else {
6735     $self->{onerror}->(node => $child_el,
6736     type => 'element not allowed',
6737     level => $self->{level}->{must});
6738     }
6739     } elsif ($element_state->{phase} eq 'any') {
6740     if ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
6741     $element_state->{phase} = 'phrasing';
6742     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6743     $element_state->{phase} = 'option';
6744     } else {
6745     $self->{onerror}->(node => $child_el,
6746     type => 'element not allowed',
6747     level => $self->{level}->{must});
6748     }
6749     } else {
6750     die "check_child_element: Bad |datalist| phase: $element_state->{phase}";
6751     }
6752     },
6753     check_child_text => sub {
6754     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6755     if ($has_significant) {
6756     if ($element_state->{phase} eq 'phrasing') {
6757     #
6758     } elsif ($element_state->{phase} eq 'any') {
6759     $element_state->{phase} = 'phrasing';
6760     } else {
6761     $self->{onerror}->(node => $child_node,
6762     type => 'character not allowed',
6763     level => $self->{level}->{must});
6764     }
6765     }
6766     },
6767     check_end => sub {
6768     my ($self, $item, $element_state) = @_;
6769     if ($element_state->{phase} eq 'phrasing') {
6770     if ($element_state->{has_significant}) {
6771     $item->{real_parent_state}->{has_significant} = 1;
6772     } elsif ($item->{transparent}) {
6773     #
6774     } else {
6775     $self->{onerror}->(node => $item->{node},
6776     type => 'no significant content',
6777     level => $self->{level}->{should});
6778     }
6779     } else {
6780     ## NOTE: Since the content model explicitly allows a |datalist| element
6781     ## being empty, we don't raise "no significant content" error for this
6782     ## element when there is no element. (We should raise an error for
6783     ## |<datalist><br></datalist>|, however.)
6784     ## NOTE: As a side-effect, when the |datalist| element only contains
6785     ## non-conforming content, then the |phase| flag has not changed from
6786     ## |any|, no "no significant content" error is raised neither.
6787     $HTMLChecker{check_end}->(@_);
6788     }
6789     },
6790 wakaba 1.52 };
6791 wakaba 1.49
6792 wakaba 1.52 $Element->{$HTML_NS}->{optgroup} = {
6793 wakaba 1.121 %HTMLChecker,
6794 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6795 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6796     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6797 wakaba 1.164 label => sub {},
6798 wakaba 1.52 }, {
6799     %HTMLAttrStatus,
6800     %HTMLM12NCommonAttrStatus,
6801 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6802     label => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6803     lang => FEATURE_HTML5_REC,
6804 wakaba 1.52 }),
6805 wakaba 1.164 check_attrs2 => sub {
6806     my ($self, $item, $element_state) = @_;
6807    
6808     unless ($item->{node}->has_attribute_ns (undef, 'label')) {
6809     $self->{onerror}->(node => $item->{node},
6810     type => 'attribute missing',
6811     text => 'label',
6812     level => $self->{level}->{must});
6813     }
6814     },
6815 wakaba 1.121 check_child_element => sub {
6816     my ($self, $item, $child_el, $child_nsuri, $child_ln,
6817     $child_is_transparent, $element_state) = @_;
6818 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
6819     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
6820 wakaba 1.121 $self->{onerror}->(node => $child_el,
6821     type => 'element not allowed:minus',
6822     level => $self->{level}->{must});
6823     } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
6824     #
6825     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'option') {
6826     #
6827     } else {
6828     $self->{onerror}->(node => $child_el, type => 'element not allowed',
6829     level => $self->{level}->{must});
6830     }
6831     },
6832     check_child_text => sub {
6833     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
6834     if ($has_significant) {
6835     $self->{onerror}->(node => $child_node, type => 'character not allowed',
6836     level => $self->{level}->{must});
6837     }
6838     },
6839 wakaba 1.52 };
6840    
6841     $Element->{$HTML_NS}->{option} = {
6842     %HTMLTextChecker,
6843 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6844 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6845     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6846 wakaba 1.164 label => sub {}, ## NOTE: No restriction.
6847     selected => $GetHTMLBooleanAttrChecker->('selected'), ## ISSUE: Not a "boolean attribute"
6848     value => sub {}, ## NOTE: No restriction.
6849 wakaba 1.52 }, {
6850     %HTMLAttrStatus,
6851     %HTMLM12NCommonAttrStatus,
6852 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6853     label => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6854     lang => FEATURE_HTML5_REC,
6855 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
6856     sdapref => FEATURE_HTML20_RFC,
6857 wakaba 1.187 selected => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6858     value => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6859 wakaba 1.52 }),
6860     };
6861 wakaba 1.49
6862 wakaba 1.52 $Element->{$HTML_NS}->{textarea} = {
6863     %HTMLTextChecker,
6864 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6865 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
6866 wakaba 1.164 accept => $HTMLIMTAttrChecker, ## TODO: MUST be a text-based type [WF2]
6867 wakaba 1.165 autofocus => $AutofocusAttrChecker,
6868 wakaba 1.164 cols => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6869 wakaba 1.52 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6870 wakaba 1.136 form => $HTMLFormAttrChecker,
6871 wakaba 1.56 ## TODO: inputmode [WF2]
6872 wakaba 1.164 maxlength => sub {
6873     my ($self, $attr, $item, $element_state) = @_;
6874    
6875     $GetHTMLNonNegativeIntegerAttrChecker->(sub { 1 })->(@_);
6876    
6877 wakaba 1.165 if ($attr->value =~ /^[\x09\x0A\x0C\x0D\x20]*([0-9]+)/) {
6878 wakaba 1.164 ## NOTE: Applying the rules for parsing non-negative integers
6879     ## results in a number.
6880     my $max_allowed_value_length = 0+$1;
6881    
6882     ## ISSUE: "The the purposes of this requirement," (typo)
6883    
6884     ## ISSUE: This constraint is applied w/o CRLF normalization to
6885     ## |value| attribute, but w/ CRLF normalization to
6886     ## concept-value.
6887     my $value = $item->{node}->text_content;
6888     if (defined $value) {
6889     my $codepoint_length = length $value;
6890    
6891     if ($codepoint_length > $max_allowed_value_length) {
6892     $self->{onerror}->(node => $item->{node},
6893     type => 'value too long',
6894     level => $self->{level}->{must});
6895     }
6896     }
6897     }
6898     },
6899 wakaba 1.165 name => $FormControlNameAttrChecker,
6900 wakaba 1.164 onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
6901     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6902     oninput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6903 wakaba 1.161 pattern => $PatternAttrChecker,
6904 wakaba 1.179 placeholder => $PlaceholderAttrChecker,
6905 wakaba 1.52 readonly => $GetHTMLBooleanAttrChecker->('readonly'),
6906 wakaba 1.56 required => $GetHTMLBooleanAttrChecker->('required'),
6907 wakaba 1.164 rows => $GetHTMLNonNegativeIntegerAttrChecker->(sub { shift > 0 }),
6908     oninput => $HTMLEventHandlerAttrChecker, ## TODO: tests
6909     oninvalid => $HTMLEventHandlerAttrChecker, ## TODO: tests
6910 wakaba 1.161 ## NOTE: |title| had special semantics if |pattern| was specified [WF2].
6911 wakaba 1.56 wrap => $GetHTMLEnumeratedAttrChecker->({soft => 1, hard => 1}),
6912 wakaba 1.52 }, {
6913     %HTMLAttrStatus,
6914     %HTMLM12NCommonAttrStatus,
6915 wakaba 1.164 accept => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6916 wakaba 1.61 'accept-charset' => FEATURE_HTML2X_RFC,
6917 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_M12N10_REC,
6918 wakaba 1.187 autofocus => FEATURE_HTML5_LC | FEATURE_WF2X,
6919     cols => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6920 wakaba 1.52 datafld => FEATURE_HTML4_REC_RESERVED,
6921 wakaba 1.49 dataformatas => FEATURE_HTML4_REC_RESERVED,
6922     datasrc => FEATURE_HTML4_REC_RESERVED,
6923 wakaba 1.187 disabled => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6924     form => FEATURE_HTML5_LC | FEATURE_WF2X,
6925 wakaba 1.164 inputmode => FEATURE_HTML5_DROPPED | FEATURE_WF2X | FEATURE_XHTMLBASIC11_CR,
6926 wakaba 1.187 lang => FEATURE_HTML5_REC,
6927 wakaba 1.121 maxlength => FEATURE_HTML5_DEFAULT | FEATURE_WF2X,
6928 wakaba 1.187 name => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6929 wakaba 1.52 onblur => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6930     onchange => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6931     onfocus => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6932 wakaba 1.164 onformchange => FEATURE_WF2_INFORMATIVE, ## TODO: tests
6933     onforminput => FEATURE_WF2_INFORMATIVE, ## TODO: tests
6934     oninput => FEATURE_WF2, ## TODO: tests
6935     oninvalid => FEATURE_WF2, ## TODO: tests
6936 wakaba 1.52 onselect => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6937 wakaba 1.161 pattern => FEATURE_HTML5_DROPPED | FEATURE_WF2X,
6938 wakaba 1.179 placeholder => FEATURE_HTML5_LC,
6939 wakaba 1.187 readonly => FEATURE_HTML5_LC | FEATURE_WF2X | FEATURE_M12N10_REC,
6940     required => FEATURE_HTML5_LC | FEATURE_WF2X,
6941     rows => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
6942 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
6943     sdapref => FEATURE_HTML20_RFC,
6944 wakaba 1.52 tabindex => FEATURE_HTML5_DEFAULT | FEATURE_M12N10_REC,
6945 wakaba 1.187 wrap => FEATURE_HTML5_LC | FEATURE_WF2X,
6946 wakaba 1.52 }),
6947 wakaba 1.66 check_start => sub {
6948     my ($self, $item, $element_state) = @_;
6949 wakaba 1.192 $FAECheckStart->($self, $item, $element_state);
6950 wakaba 1.164
6951     $element_state->{uri_info}->{data}->{type}->{resource} = 1;
6952     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
6953     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
6954     },
6955     check_attrs2 => sub {
6956     my ($self, $item, $element_state) = @_;
6957 wakaba 1.66
6958 wakaba 1.161 if ($item->{node}->has_attribute_ns (undef, 'pattern') and
6959     not $item->{node}->has_attribute_ns (undef, 'title')) {
6960     ## NOTE: WF2 (dropped by HTML5)
6961     $self->{onerror}->(node => $item->{node},
6962     type => 'attribute missing',
6963     text => 'title',
6964     level => $self->{level}->{should});
6965     }
6966    
6967 wakaba 1.164 unless ($item->{node}->has_attribute_ns (undef, 'cols')) {
6968     my $wrap = $item->{node}->get_attribute_ns (undef, 'wrap');
6969     if (defined $wrap) {
6970     $wrap =~ tr/A-Z/a-z/; ## ASCII case-insensitive
6971     if ($wrap eq 'hard') {
6972     $self->{onerror}->(node => $item->{node},
6973     type => 'attribute missing',
6974     text => 'cols',
6975     level => $self->{level}->{must});
6976     }
6977     }
6978     }
6979 wakaba 1.192
6980     $FAECheckAttrs2->($self, $item, $element_state);
6981     }, # check_attrs2
6982 wakaba 1.194 }; # textarea
6983    
6984     $Element->{$HTML_NS}->{keygen} = {
6985     %HTMLEmptyChecker,
6986     status => FEATURE_HTML5_FD,
6987     check_attrs => $GetHTMLAttrsChecker->({
6988     autofocus => $AutofocusAttrChecker,
6989     challenge => sub { }, ## No constraints.
6990     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
6991     form => $HTMLFormAttrChecker,
6992     keytype => $GetHTMLEnumeratedAttrChecker->({rsa => 1}),
6993     name => $FormControlNameAttrChecker,
6994     }, {
6995     %HTMLAttrStatus,
6996     autofocus => FEATURE_HTML5_LC,
6997     challenge => FEATURE_HTML5_FD,
6998     disabled => FEATURE_HTML5_LC,
6999     form => FEATURE_HTML5_LC,
7000     keytype => FEATURE_HTML5_FD,
7001     name => FEATURE_HTML5_LC,
7002     }), # check_attrs
7003     check_start => sub {
7004     my ($self, $item, $element_state) = @_;
7005     $FAECheckStart->($self, $item, $element_state);
7006    
7007     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7008     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7009     }, # check_start
7010     check_attrs2 => sub {
7011     my ($self, $item, $element_state) = @_;
7012     $FAECheckAttrs2->($self, $item, $element_state);
7013     }, # check_attrs2
7014     }; # keygen
7015 wakaba 1.49
7016 wakaba 1.52 $Element->{$HTML_NS}->{output} = {
7017 wakaba 1.121 %HTMLPhrasingContentChecker,
7018 wakaba 1.187 status => FEATURE_HTML5_LC | FEATURE_WF2X,
7019 wakaba 1.56 check_attrs => $GetHTMLAttrsChecker->({
7020 wakaba 1.165 for => sub {
7021     my ($self, $attr) = @_;
7022    
7023     ## NOTE: "Unordered set of unique space-separated tokens".
7024    
7025     my %word;
7026     for my $word (grep {length $_}
7027     split /[\x09\x0A\x0C\x0D\x20]+/, $attr->value) {
7028     unless ($word{$word}) {
7029     $word{$word} = 1;
7030     push @{$self->{idref}}, ['any', $word, $attr];
7031     } else {
7032     $self->{onerror}->(node => $attr, type => 'duplicate token',
7033     value => $word,
7034     level => $self->{level}->{must});
7035     }
7036     }
7037     },
7038 wakaba 1.136 form => $HTMLFormAttrChecker,
7039 wakaba 1.165 name => $FormControlNameAttrChecker,
7040     onformchange => $HTMLEventHandlerAttrChecker, ## TODO: tests
7041     onforminput => $HTMLEventHandlerAttrChecker, ## TODO: tests
7042 wakaba 1.56 }, {
7043 wakaba 1.52 %HTMLAttrStatus,
7044 wakaba 1.187 for => FEATURE_HTML5_LC | FEATURE_WF2X,
7045     form => FEATURE_HTML5_LC | FEATURE_WF2X,
7046     name => FEATURE_HTML5_LC | FEATURE_WF2X,
7047 wakaba 1.56 onchange => FEATURE_HTML5_DEFAULT | FEATURE_WF2,
7048     onformchange => FEATURE_WF2,
7049     onforminput => FEATURE_WF2,
7050 wakaba 1.52 }),
7051     };
7052    
7053     $Element->{$HTML_NS}->{isindex} = {
7054     %HTMLEmptyChecker,
7055 wakaba 1.54 status => FEATURE_M12N10_REC_DEPRECATED |
7056     Whatpm::ContentChecker::FEATURE_DEPRECATED_SHOULD, ## [HTML4]
7057 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
7058     prompt => sub {}, ## NOTE: Text [M12N]
7059     }, {
7060     %HTMLAttrStatus,
7061 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7062     dir => FEATURE_HTML5_REC,
7063     id => FEATURE_HTML5_REC,
7064     lang => FEATURE_HTML5_REC,
7065 wakaba 1.52 prompt => FEATURE_M12N10_REC_DEPRECATED,
7066 wakaba 1.61 sdapref => FEATURE_HTML20_RFC,
7067 wakaba 1.187 style => FEATURE_HTML5_REC,
7068     title => FEATURE_HTML5_REC,
7069 wakaba 1.52 }),
7070     ## TODO: Tests
7071     ## TODO: Tests for <nest/> in <isindex>
7072 wakaba 1.66 check_start => sub {
7073     my ($self, $item, $element_state) = @_;
7074    
7075     $element_state->{uri_info}->{action}->{type}->{action} = 1;
7076 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7077     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7078 wakaba 1.66 },
7079 wakaba 1.52 };
7080 wakaba 1.49
7081 wakaba 1.1 $Element->{$HTML_NS}->{script} = {
7082 wakaba 1.40 %HTMLChecker,
7083 wakaba 1.153 status => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7084 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7085 wakaba 1.91 charset => sub {
7086     my ($self, $attr) = @_;
7087    
7088     unless ($attr->owner_element->has_attribute_ns (undef, 'src')) {
7089     $self->{onerror}->(type => 'attribute not allowed',
7090     node => $attr,
7091 wakaba 1.104 level => $self->{level}->{must});
7092 wakaba 1.91 }
7093    
7094 wakaba 1.188 ## XXXresource: MUST match the charset of the referenced
7095     ## resource (HTML5 revision 2967).
7096    
7097 wakaba 1.91 $HTMLCharsetChecker->($attr->value, @_);
7098     },
7099 wakaba 1.86 language => sub {}, ## NOTE: No syntax constraint according to HTML4.
7100 wakaba 1.91 src => $HTMLURIAttrChecker, ## TODO: pointed resource MUST be in type of type="" (resource error)
7101 wakaba 1.1 defer => $GetHTMLBooleanAttrChecker->('defer'),
7102     async => $GetHTMLBooleanAttrChecker->('async'),
7103 wakaba 1.91 type => $HTMLIMTAttrChecker, ## TODO: MUST NOT: |charset=""| parameter
7104 wakaba 1.49 }, {
7105     %HTMLAttrStatus,
7106 wakaba 1.153 async => FEATURE_HTML5_WD,
7107     charset => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7108     defer => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7109 wakaba 1.49 event => FEATURE_HTML4_REC_RESERVED,
7110     for => FEATURE_HTML4_REC_RESERVED,
7111 wakaba 1.154 href => FEATURE_RDFA_REC,
7112 wakaba 1.187 id => FEATURE_HTML5_REC,
7113 wakaba 1.49 language => FEATURE_M12N10_REC_DEPRECATED,
7114 wakaba 1.153 src => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7115     type => FEATURE_HTML5_WD | FEATURE_M12N10_REC,
7116 wakaba 1.9 }),
7117 wakaba 1.191 check_attrs2 => sub {
7118     my ($self, $item, $element_state) = @_;
7119    
7120     my $el = $item->{node};
7121     if ($el->has_attribute_ns (undef, 'defer') and
7122     not $el->has_attribute_ns (undef, 'src')) {
7123     $self->{onerror}->(node => $el,
7124     type => 'attribute missing',
7125     text => 'src',
7126     level => $self->{level}->{must});
7127     }
7128     },
7129 wakaba 1.40 check_start => sub {
7130     my ($self, $item, $element_state) = @_;
7131 wakaba 1.1
7132 wakaba 1.40 if ($item->{node}->has_attribute_ns (undef, 'src')) {
7133     $element_state->{must_be_empty} = 1;
7134 wakaba 1.1 } else {
7135     ## NOTE: No content model conformance in HTML5 spec.
7136 wakaba 1.40 my $type = $item->{node}->get_attribute_ns (undef, 'type');
7137     my $language = $item->{node}->get_attribute_ns (undef, 'language');
7138 wakaba 1.1 if ((defined $type and $type eq '') or
7139     (defined $language and $language eq '')) {
7140     $type = 'text/javascript';
7141     } elsif (defined $type) {
7142     #
7143     } elsif (defined $language) {
7144     $type = 'text/' . $language;
7145     } else {
7146     $type = 'text/javascript';
7147     }
7148 wakaba 1.93
7149     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)]) {
7150     $type = "$1/$2";
7151     $type =~ tr/A-Z/a-z/; ## NOTE: ASCII case-insensitive
7152     ## TODO: Though we strip prameter here, it should not be ignored for the purpose of conformance checking...
7153     }
7154     $element_state->{script_type} = $type;
7155 wakaba 1.40 }
7156 wakaba 1.66
7157     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7158 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7159     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7160 wakaba 1.107
7161     $element_state->{text} = '';
7162 wakaba 1.40 },
7163     check_child_element => sub {
7164     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7165     $child_is_transparent, $element_state) = @_;
7166 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7167     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7168 wakaba 1.40 $self->{onerror}->(node => $child_el,
7169     type => 'element not allowed:minus',
7170 wakaba 1.104 level => $self->{level}->{must});
7171 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7172     #
7173     } else {
7174     if ($element_state->{must_be_empty}) {
7175     $self->{onerror}->(node => $child_el,
7176 wakaba 1.104 type => 'element not allowed:empty',
7177     level => $self->{level}->{must});
7178 wakaba 1.40 }
7179     }
7180     },
7181     check_child_text => sub {
7182     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7183     if ($has_significant and
7184     $element_state->{must_be_empty}) {
7185     $self->{onerror}->(node => $child_node,
7186 wakaba 1.104 type => 'character not allowed:empty',
7187     level => $self->{level}->{must});
7188 wakaba 1.40 }
7189 wakaba 1.115 $element_state->{text} .= $child_node->data;
7190 wakaba 1.40 },
7191     check_end => sub {
7192     my ($self, $item, $element_state) = @_;
7193     unless ($element_state->{must_be_empty}) {
7194 wakaba 1.93 if ($element_state->{script_type} =~ m![+/][Xx][Mm][Ll]\z!) {
7195     ## NOTE: XML content should be checked by THIS instance of checker
7196     ## as part of normal tree validation.
7197 wakaba 1.104 $self->{onerror}->(node => $item->{node},
7198     type => 'XML script lang',
7199     text => $element_state->{script_type},
7200     level => $self->{level}->{uncertain});
7201     ## ISSUE: Should we raise some kind of error for
7202     ## <script type="text/xml">aaaaa</script>?
7203     ## NOTE: ^^^ This is why we throw an "uncertain" error.
7204 wakaba 1.93 } else {
7205     $self->{onsubdoc}->({s => $element_state->{text},
7206     container_node => $item->{node},
7207     media_type => $element_state->{script_type},
7208     is_char_string => 1});
7209     }
7210 wakaba 1.40
7211     $HTMLChecker{check_end}->(@_);
7212 wakaba 1.1 }
7213     },
7214 wakaba 1.91 ## TODO: There MUST be |type| unless the script type is JavaScript. (resource error)
7215     ## NOTE: "When used to include script data, the script data must be embedded
7216     ## inline, the format of the data must be given using the type attribute,
7217     ## and the src attribute must not be specified." - not testable.
7218     ## TODO: It would be possible to err <script type=text/plain src=...>
7219 wakaba 1.1 };
7220 wakaba 1.25 ## ISSUE: Significant check and text child node
7221 wakaba 1.1
7222     ## NOTE: When script is disabled.
7223     $Element->{$HTML_NS}->{noscript} = {
7224 wakaba 1.40 %HTMLTransparentChecker,
7225 wakaba 1.187 status => FEATURE_HTML5_REC,
7226 wakaba 1.49 check_attrs => $GetHTMLAttrsChecker->({}, {
7227     %HTMLAttrStatus,
7228     %HTMLM12NCommonAttrStatus,
7229 wakaba 1.187 lang => FEATURE_HTML5_REC,
7230 wakaba 1.49 }),
7231 wakaba 1.40 check_start => sub {
7232     my ($self, $item, $element_state) = @_;
7233 wakaba 1.3
7234 wakaba 1.40 unless ($item->{node}->owner_document->manakai_is_html) {
7235 wakaba 1.104 $self->{onerror}->(node => $item->{node}, type => 'in XML:noscript',
7236     level => $self->{level}->{must});
7237 wakaba 1.3 }
7238    
7239 wakaba 1.40 unless ($self->{flag}->{in_head}) {
7240     $self->_add_minus_elements ($element_state,
7241     {$HTML_NS => {noscript => 1}});
7242     }
7243 wakaba 1.79
7244     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7245     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7246 wakaba 1.3 },
7247 wakaba 1.40 check_child_element => sub {
7248     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7249     $child_is_transparent, $element_state) = @_;
7250     if ($self->{flag}->{in_head}) {
7251 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7252     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7253 wakaba 1.40 $self->{onerror}->(node => $child_el,
7254     type => 'element not allowed:minus',
7255 wakaba 1.104 level => $self->{level}->{must});
7256 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7257     #
7258     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'link') {
7259     #
7260     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'style') {
7261     if ($child_el->has_attribute_ns (undef, 'scoped')) {
7262     $self->{onerror}->(node => $child_el,
7263     type => 'element not allowed:head noscript',
7264 wakaba 1.104 level => $self->{level}->{must});
7265 wakaba 1.40 }
7266     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'meta') {
7267 wakaba 1.47 my $http_equiv_attr
7268     = $child_el->get_attribute_node_ns (undef, 'http-equiv');
7269     if ($http_equiv_attr) {
7270     ## TODO: case
7271     if (lc $http_equiv_attr->value eq 'content-type') {
7272 wakaba 1.40 $self->{onerror}->(node => $child_el,
7273 wakaba 1.34 type => 'element not allowed:head noscript',
7274 wakaba 1.104 level => $self->{level}->{must});
7275 wakaba 1.47 } else {
7276     #
7277 wakaba 1.3 }
7278 wakaba 1.47 } else {
7279     $self->{onerror}->(node => $child_el,
7280     type => 'element not allowed:head noscript',
7281 wakaba 1.104 level => $self->{level}->{must});
7282 wakaba 1.3 }
7283 wakaba 1.40 } else {
7284     $self->{onerror}->(node => $child_el,
7285     type => 'element not allowed:head noscript',
7286 wakaba 1.104 level => $self->{level}->{must});
7287 wakaba 1.40 }
7288     } else {
7289     $HTMLTransparentChecker{check_child_element}->(@_);
7290     }
7291     },
7292     check_child_text => sub {
7293     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7294     if ($self->{flag}->{in_head}) {
7295     if ($has_significant) {
7296     $self->{onerror}->(node => $child_node,
7297 wakaba 1.104 type => 'character not allowed',
7298     level => $self->{level}->{must});
7299 wakaba 1.3 }
7300     } else {
7301 wakaba 1.40 $HTMLTransparentChecker{check_child_text}->(@_);
7302     }
7303     },
7304     check_end => sub {
7305     my ($self, $item, $element_state) = @_;
7306     $self->_remove_minus_elements ($element_state);
7307     if ($self->{flag}->{in_head}) {
7308     $HTMLChecker{check_end}->(@_);
7309     } else {
7310     $HTMLPhrasingContentChecker{check_end}->(@_);
7311 wakaba 1.3 }
7312 wakaba 1.1 },
7313     };
7314 wakaba 1.3 ## ISSUE: Scripting is disabled: <head><noscript><html a></noscript></head>
7315 wakaba 1.1
7316     $Element->{$HTML_NS}->{'event-source'} = {
7317 wakaba 1.40 %HTMLEmptyChecker,
7318 wakaba 1.118 status => FEATURE_HTML5_LC_DROPPED,
7319     check_attrs => $GetHTMLAttrsChecker->({
7320     src => $HTMLURIAttrChecker,
7321     }, {
7322     %HTMLAttrStatus,
7323     src => FEATURE_HTML5_LC_DROPPED,
7324     }),
7325     check_start => sub {
7326     my ($self, $item, $element_state) = @_;
7327    
7328     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7329     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7330     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7331     },
7332     };
7333    
7334     $Element->{$HTML_NS}->{eventsource} = {
7335     %HTMLEmptyChecker,
7336 wakaba 1.180 status => FEATURE_HTML5_DROPPED,
7337 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7338 wakaba 1.1 src => $HTMLURIAttrChecker,
7339 wakaba 1.50 }, {
7340     %HTMLAttrStatus,
7341 wakaba 1.180 src => FEATURE_HTML5_DROPPED,
7342 wakaba 1.1 }),
7343 wakaba 1.66 check_start => sub {
7344     my ($self, $item, $element_state) = @_;
7345    
7346     $element_state->{uri_info}->{src}->{type}->{resource} = 1;
7347 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7348     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7349 wakaba 1.66 },
7350 wakaba 1.1 };
7351    
7352     $Element->{$HTML_NS}->{details} = {
7353 wakaba 1.134 %{$Element->{$HTML_NS}->{fieldset}},
7354 wakaba 1.153 status => FEATURE_HTML5_LC,
7355 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7356 wakaba 1.1 open => $GetHTMLBooleanAttrChecker->('open'),
7357 wakaba 1.50 }, {
7358     %HTMLAttrStatus,
7359 wakaba 1.153 open => FEATURE_HTML5_LC,
7360 wakaba 1.1 }),
7361     };
7362    
7363     $Element->{$HTML_NS}->{datagrid} = {
7364 wakaba 1.72 %HTMLFlowContentChecker,
7365 wakaba 1.197 status => FEATURE_HTML5_DROPPED,
7366 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7367 wakaba 1.1 disabled => $GetHTMLBooleanAttrChecker->('disabled'),
7368     multiple => $GetHTMLBooleanAttrChecker->('multiple'),
7369 wakaba 1.50 }, {
7370     %HTMLAttrStatus,
7371 wakaba 1.197 disabled => FEATURE_HTML5_DROPPED,
7372     multiple => FEATURE_HTML5_DROPPED,
7373     }), # check_attrs
7374     }; # datagrid
7375 wakaba 1.1
7376     $Element->{$HTML_NS}->{command} = {
7377 wakaba 1.40 %HTMLEmptyChecker,
7378 wakaba 1.48 status => FEATURE_HTML5_WD,
7379 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7380 wakaba 1.1 checked => $GetHTMLBooleanAttrChecker->('checked'),
7381     default => $GetHTMLBooleanAttrChecker->('default'),
7382     disabled => $GetHTMLBooleanAttrChecker->('disabled'),
7383     icon => $HTMLURIAttrChecker,
7384     label => sub { }, ## NOTE: No conformance creteria
7385     radiogroup => sub { }, ## NOTE: No conformance creteria
7386     type => sub {
7387     my ($self, $attr) = @_;
7388     my $value = $attr->value;
7389     unless ({command => 1, checkbox => 1, radio => 1}->{$value}) {
7390 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'invalid attribute value',
7391     level => $self->{level}->{must});
7392 wakaba 1.1 }
7393     },
7394 wakaba 1.50 }, {
7395     %HTMLAttrStatus,
7396     checked => FEATURE_HTML5_WD,
7397 wakaba 1.175 default => FEATURE_HTML5_DROPPED, # HTML5 revision 3067
7398 wakaba 1.50 disabled => FEATURE_HTML5_WD,
7399     icon => FEATURE_HTML5_WD,
7400     label => FEATURE_HTML5_WD,
7401     radiogroup => FEATURE_HTML5_WD,
7402     type => FEATURE_HTML5_WD,
7403 wakaba 1.1 }),
7404 wakaba 1.66 check_start => sub {
7405     my ($self, $item, $element_state) = @_;
7406    
7407     $element_state->{uri_info}->{icon}->{type}->{embedded} = 1;
7408 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7409     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7410 wakaba 1.66 },
7411 wakaba 1.115 };
7412    
7413     $Element->{$HTML_NS}->{bb} = {
7414     %HTMLPhrasingContentChecker,
7415 wakaba 1.190 status => FEATURE_HTML5_DROPPED,
7416 wakaba 1.115 check_attrs => $GetHTMLAttrsChecker->({
7417     type => $GetHTMLEnumeratedAttrChecker->({makeapp => 1}),
7418     }, {
7419     %HTMLAttrStatus,
7420 wakaba 1.190 type => FEATURE_HTML5_DROPPED,
7421 wakaba 1.115 }),
7422 wakaba 1.130 check_start => sub {
7423     my ($self, $item, $element_state) = @_;
7424     $self->_add_minus_elements ($element_state, $HTMLInteractiveContent);
7425    
7426     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7427     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7428     },
7429     check_end => sub {
7430     my ($self, $item, $element_state) = @_;
7431     $self->_remove_minus_elements ($element_state);
7432    
7433     $HTMLTransparentChecker{check_end}->(@_);
7434     },
7435 wakaba 1.1 };
7436    
7437     $Element->{$HTML_NS}->{menu} = {
7438 wakaba 1.40 %HTMLPhrasingContentChecker,
7439 wakaba 1.54 #status => FEATURE_M12N10_REC_DEPRECATED | FEATURE_HTML5_WD,
7440     status => FEATURE_M12N10_REC | FEATURE_HTML5_WD,
7441     ## NOTE: We don't want any |menu| element warned as deprecated.
7442 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7443 wakaba 1.1 autosubmit => $GetHTMLBooleanAttrChecker->('autosubmit'),
7444 wakaba 1.68 compact => $GetHTMLBooleanAttrChecker->('compact'),
7445 wakaba 1.135 ## ISSUE: <menu id=""><p contextmenu=""> match? (In the current
7446     ## implementation, it does not match.)
7447 wakaba 1.1 label => sub { }, ## NOTE: No conformance creteria
7448     type => $GetHTMLEnumeratedAttrChecker->({context => 1, toolbar => 1}),
7449 wakaba 1.49 }, {
7450     %HTMLAttrStatus,
7451     %HTMLM12NCommonAttrStatus,
7452 wakaba 1.61 align => FEATURE_HTML2X_RFC,
7453 wakaba 1.113 autosubmit => FEATURE_HTML5_DROPPED,
7454 wakaba 1.49 compat => FEATURE_M12N10_REC_DEPRECATED,
7455 wakaba 1.50 label => FEATURE_HTML5_WD,
7456 wakaba 1.187 lang => FEATURE_HTML5_REC,
7457 wakaba 1.61 sdaform => FEATURE_HTML20_RFC,
7458     sdapref => FEATURE_HTML20_RFC,
7459 wakaba 1.50 type => FEATURE_HTML5_WD,
7460 wakaba 1.207 }), # check_attrs
7461 wakaba 1.40 check_start => sub {
7462     my ($self, $item, $element_state) = @_;
7463     $element_state->{phase} = 'li or phrasing';
7464 wakaba 1.79
7465     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7466     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7467 wakaba 1.135 $element_state->{id_type} = 'menu';
7468 wakaba 1.207 }, # check_start
7469 wakaba 1.40 check_child_element => sub {
7470     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7471     $child_is_transparent, $element_state) = @_;
7472 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7473     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7474 wakaba 1.40 $self->{onerror}->(node => $child_el,
7475     type => 'element not allowed:minus',
7476 wakaba 1.104 level => $self->{level}->{must});
7477 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7478     #
7479     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'li') {
7480     if ($element_state->{phase} eq 'li') {
7481     #
7482     } elsif ($element_state->{phase} eq 'li or phrasing') {
7483     $element_state->{phase} = 'li';
7484     } else {
7485 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7486     level => $self->{level}->{must});
7487 wakaba 1.40 }
7488     } elsif ($HTMLPhrasingContent->{$child_nsuri}->{$child_ln}) {
7489     if ($element_state->{phase} eq 'phrasing') {
7490     #
7491     } elsif ($element_state->{phase} eq 'li or phrasing') {
7492     $element_state->{phase} = 'phrasing';
7493     } else {
7494 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7495     level => $self->{level}->{must});
7496 wakaba 1.40 }
7497     } else {
7498 wakaba 1.104 $self->{onerror}->(node => $child_el, type => 'element not allowed',
7499     level => $self->{level}->{must});
7500 wakaba 1.40 }
7501 wakaba 1.207 }, # check_child_element
7502 wakaba 1.40 check_child_text => sub {
7503     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7504     if ($has_significant) {
7505     if ($element_state->{phase} eq 'phrasing') {
7506     #
7507     } elsif ($element_state->{phase} eq 'li or phrasing') {
7508     $element_state->{phase} = 'phrasing';
7509     } else {
7510     $self->{onerror}->(node => $child_node,
7511 wakaba 1.104 type => 'character not allowed',
7512     level => $self->{level}->{must});
7513 wakaba 1.1 }
7514     }
7515 wakaba 1.207 }, # check_child_text
7516 wakaba 1.40 check_end => sub {
7517     my ($self, $item, $element_state) = @_;
7518     if ($element_state->{phase} eq 'li') {
7519     $HTMLChecker{check_end}->(@_);
7520     } else { # 'phrasing' or 'li or phrasing'
7521     $HTMLPhrasingContentChecker{check_end}->(@_);
7522 wakaba 1.1 }
7523 wakaba 1.207 }, # check_end
7524     }; # menu
7525 wakaba 1.8
7526     $Element->{$HTML_NS}->{datatemplate} = {
7527 wakaba 1.40 %HTMLChecker,
7528 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7529 wakaba 1.40 check_child_element => sub {
7530     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7531     $child_is_transparent, $element_state) = @_;
7532 wakaba 1.130 if ($self->{minus_elements}->{$child_nsuri}->{$child_ln} and
7533     $IsInHTMLInteractiveContent->($child_el, $child_nsuri, $child_ln)) {
7534 wakaba 1.40 $self->{onerror}->(node => $child_el,
7535     type => 'element not allowed:minus',
7536 wakaba 1.104 level => $self->{level}->{must});
7537 wakaba 1.40 } elsif ($self->{plus_elements}->{$child_nsuri}->{$child_ln}) {
7538     #
7539     } elsif ($child_nsuri eq $HTML_NS and $child_ln eq 'rule') {
7540     #
7541     } else {
7542     $self->{onerror}->(node => $child_el,
7543 wakaba 1.104 type => 'element not allowed:datatemplate',
7544     level => $self->{level}->{must});
7545 wakaba 1.40 }
7546     },
7547     check_child_text => sub {
7548     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7549     if ($has_significant) {
7550 wakaba 1.104 $self->{onerror}->(node => $child_node, type => 'character not allowed',
7551     level => $self->{level}->{must});
7552 wakaba 1.8 }
7553     },
7554     is_xml_root => 1,
7555     };
7556    
7557     $Element->{$HTML_NS}->{rule} = {
7558 wakaba 1.40 %HTMLChecker,
7559 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7560 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7561 wakaba 1.23 condition => $HTMLSelectorsAttrChecker,
7562 wakaba 1.92 mode => $GetHTMLUnorderedUniqueSetOfSpaceSeparatedTokensAttrChecker->(),
7563 wakaba 1.50 }, {
7564     %HTMLAttrStatus,
7565 wakaba 1.208 condition => FEATURE_HTML5_DROPPED,
7566     mode => FEATURE_HTML5_DROPPED,
7567 wakaba 1.8 }),
7568 wakaba 1.40 check_start => sub {
7569     my ($self, $item, $element_state) = @_;
7570 wakaba 1.79
7571 wakaba 1.40 $self->_add_plus_elements ($element_state, {$HTML_NS => {nest => 1}});
7572 wakaba 1.79 $element_state->{in_rule_original} = $self->{flag}->{in_rule};
7573     $self->{flag}->{in_rule} = 1;
7574    
7575     $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7576     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7577 wakaba 1.40 },
7578     check_child_element => sub { },
7579     check_child_text => sub { },
7580     check_end => sub {
7581     my ($self, $item, $element_state) = @_;
7582 wakaba 1.79
7583 wakaba 1.40 $self->_remove_plus_elements ($element_state);
7584 wakaba 1.79 delete $self->{flag}->{in_rule} unless $element_state->{in_rule_original};
7585    
7586 wakaba 1.40 $HTMLChecker{check_end}->(@_);
7587 wakaba 1.8 },
7588     ## NOTE: "MAY be anything that, when the parent |datatemplate|
7589     ## is applied to some conforming data, results in a conforming DOM tree.":
7590     ## We don't check against this.
7591     };
7592    
7593     $Element->{$HTML_NS}->{nest} = {
7594 wakaba 1.40 %HTMLEmptyChecker,
7595 wakaba 1.208 status => FEATURE_HTML5_DROPPED,
7596 wakaba 1.40 check_attrs => $GetHTMLAttrsChecker->({
7597 wakaba 1.23 filter => $HTMLSelectorsAttrChecker,
7598     mode => sub {
7599     my ($self, $attr) = @_;
7600     my $value = $attr->value;
7601 wakaba 1.132 if ($value !~ /\A[^\x09\x0A\x0C\x0D\x20]+\z/) {
7602 wakaba 1.104 $self->{onerror}->(node => $attr, type => 'mode:syntax error',
7603     level => $self->{level}->{must});
7604 wakaba 1.23 }
7605     },
7606 wakaba 1.50 }, {
7607     %HTMLAttrStatus,
7608 wakaba 1.208 filter => FEATURE_HTML5_DROPPED,
7609     mode => FEATURE_HTML5_DROPPED,
7610 wakaba 1.8 }),
7611 wakaba 1.1 };
7612    
7613     $Element->{$HTML_NS}->{legend} = {
7614 wakaba 1.40 %HTMLPhrasingContentChecker,
7615 wakaba 1.153 status => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7616 wakaba 1.52 check_attrs => $GetHTMLAttrsChecker->({
7617 wakaba 1.195 # XXX
7618 wakaba 1.52 # align => $GetHTMLEnumeratedAttrChecker->({
7619     # top => 1, bottom => 1, left => 1, right => 1,
7620     # }),
7621 wakaba 1.167 form => $HTMLFormAttrChecker,
7622 wakaba 1.52 }, {
7623 wakaba 1.49 %HTMLAttrStatus,
7624     %HTMLM12NCommonAttrStatus,
7625 wakaba 1.176 accesskey => FEATURE_HTML5_FD | FEATURE_M12N10_REC,
7626 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
7627 wakaba 1.167 form => FEATURE_HTML5_DROPPED,
7628 wakaba 1.187 lang => FEATURE_HTML5_REC,
7629 wakaba 1.49 }),
7630 wakaba 1.170 check_child_element => sub {
7631     my ($self, $item, $child_el, $child_nsuri, $child_ln,
7632     $child_is_transparent, $element_state) = @_;
7633 wakaba 1.195 ## XXX This does not work for |<legned><ins><blockquote>|
7634 wakaba 1.170 if ($item->{parent_state}->{in_figure}) {
7635     $HTMLFlowContentChecker{check_child_element}->(@_);
7636     } else {
7637     $HTMLPhrasingContentChecker{check_child_element}->(@_);
7638     }
7639     },
7640     check_child_text => sub {
7641     my ($self, $item, $child_node, $has_significant, $element_state) = @_;
7642     if ($item->{parent_state}->{in_figure}) {
7643     $HTMLFlowContentChecker{check_child_text}->(@_);
7644     } else {
7645     $HTMLPhrasingContentChecker{check_child_text}->(@_);
7646     }
7647     },
7648     check_start => sub {
7649     my ($self, $item, $element_state) = @_;
7650     $self->_add_minus_elements ($element_state, {$HTML_NS => {figure => 1}});
7651    
7652     $HTMLFlowContentChecker{check_start}->(@_);
7653     },
7654     check_end => sub {
7655     my ($self, $item, $element_state) = @_;
7656     $self->_remove_minus_elements ($element_state);
7657    
7658     $HTMLFlowContentChecker{check_end}->(@_);
7659     },
7660     }; # legend
7661 wakaba 1.1
7662     $Element->{$HTML_NS}->{div} = {
7663 wakaba 1.72 %HTMLFlowContentChecker,
7664 wakaba 1.187 status => FEATURE_HTML5_REC,
7665 wakaba 1.68 check_attrs => $GetHTMLAttrsChecker->({
7666     align => $GetHTMLEnumeratedAttrChecker->({
7667     left => 1, center => 1, right => 1, justify => 1,
7668     }),
7669     }, {
7670 wakaba 1.49 %HTMLAttrStatus,
7671 wakaba 1.82 %HTMLM12NXHTML2CommonAttrStatus,
7672 wakaba 1.49 align => FEATURE_M12N10_REC_DEPRECATED,
7673     datafld => FEATURE_HTML4_REC_RESERVED,
7674     dataformatas => FEATURE_HTML4_REC_RESERVED,
7675     datasrc => FEATURE_HTML4_REC_RESERVED,
7676 wakaba 1.187 lang => FEATURE_HTML5_REC,
7677 wakaba 1.49 }),
7678 wakaba 1.66 check_start => sub {
7679     my ($self, $item, $element_state) = @_;
7680    
7681     $element_state->{uri_info}->{datasrc}->{type}->{resource} = 1;
7682 wakaba 1.79 $element_state->{uri_info}->{template}->{type}->{resource} = 1;
7683     $element_state->{uri_info}->{ref}->{type}->{resource} = 1;
7684 wakaba 1.66 },
7685 wakaba 1.1 };
7686    
7687 wakaba 1.64 $Element->{$HTML_NS}->{center} = {
7688 wakaba 1.72 %HTMLFlowContentChecker,
7689 wakaba 1.64 status => FEATURE_M12N10_REC_DEPRECATED,
7690     check_attrs => $GetHTMLAttrsChecker->({}, {
7691     %HTMLAttrStatus,
7692     %HTMLM12NCommonAttrStatus,
7693 wakaba 1.187 lang => FEATURE_HTML5_REC,
7694 wakaba 1.64 }),
7695     };
7696    
7697 wakaba 1.1 $Element->{$HTML_NS}->{font} = {
7698 wakaba 1.40 %HTMLTransparentChecker,
7699 wakaba 1.78 status => FEATURE_HTML5_DROPPED | FEATURE_M12N10_REC_DEPRECATED,
7700 wakaba 1.70 check_attrs => $GetHTMLAttrsChecker->({
7701     ## TODO: HTML4 |size|, |color|, |face|
7702 wakaba 1.49 }, {
7703     %HTMLAttrStatus,
7704 wakaba 1.187 class => FEATURE_HTML5_LC | FEATURE_M12N10_REC,
7705 wakaba 1.49 color => FEATURE_M12N10_REC_DEPRECATED,
7706 wakaba 1.187 dir => FEATURE_HTML5_REC,
7707 wakaba 1.49 face => FEATURE_M12N10_REC_DEPRECATED,
7708 wakaba 1.187 id => FEATURE_HTML5_REC,
7709     lang => FEATURE_HTML5_REC,
7710 wakaba 1.49 size => FEATURE_M12N10_REC_DEPRECATED,
7711 wakaba 1.187 style => FEATURE_HTML5_REC,
7712     title => FEATURE_HTML5_REC,
7713 wakaba 1.49 }),
7714 wakaba 1.78 ## NOTE: When the |font| element was defined in the HTML5 specification,
7715     ## it is allowed only in a document with the WYSIWYG signature. The
7716     ## checker does not check whether there is the signature, since the
7717     ## signature is dropped, too, and has never been implemented. (In addition,
7718     ## for any |font| element an "element not defined" error is raised anyway,
7719     ## such that we don't have to raise an additional error.)
7720 wakaba 1.1 };
7721 wakaba 1.49
7722 wakaba 1.64 $Element->{$HTML_NS}->{basefont} = {
7723     %HTMLEmptyChecker,
7724     status => FEATURE_M12N10_REC_DEPRECATED,
7725     check_attrs => $GetHTMLAttrsChecker->({
7726     ## TODO: color, face, size
7727     }, {
7728     %HTMLAttrStatus,
7729     color => FEATURE_M12N10_REC_DEPRECATED,
7730     face => FEATURE_M12N10_REC_DEPRECATED,
7731 wakaba 1.187 id => FEATURE_HTML5_REC,
7732 wakaba 1.64 size => FEATURE_M12N10_REC_DEPRECATED,
7733     }),
7734 wakaba 1.188 }; # basefont
7735 wakaba 1.64
7736 wakaba 1.49 ## TODO: frameset FEATURE_M12N10_REC
7737 wakaba 1.188 ## class title id cols rows style(x10)
7738    
7739     $Element->{$HTML_NS}->{frameset} = {
7740     %HTMLEmptyChecker, # XXX
7741     status => FEATURE_M12N10_REC,
7742     check_attrs => $GetHTMLAttrsChecker->({
7743     ## XXX
7744     onafterprint => $HTMLEventHandlerAttrChecker,
7745     onbeforeprint => $HTMLEventHandlerAttrChecker,
7746     onbeforeunload => $HTMLEventHandlerAttrChecker,
7747     onblur => $HTMLEventHandlerAttrChecker,
7748     onerror => $HTMLEventHandlerAttrChecker,
7749     onfocus => $HTMLEventHandlerAttrChecker,
7750     onhashchange => $HTMLEventHandlerAttrChecker,
7751     onload => $HTMLEventHandlerAttrChecker,
7752     onmessage => $HTMLEventHandlerAttrChecker,
7753     onoffline => $HTMLEventHandlerAttrChecker,
7754     ononline => $HTMLEventHandlerAttrChecker,
7755     onpopstate => $HTMLEventHandlerAttrChecker,
7756     onredo => $HTMLEventHandlerAttrChecker,
7757     onresize => $HTMLEventHandlerAttrChecker,
7758     onstorage => $HTMLEventHandlerAttrChecker,
7759     onundo => $HTMLEventHandlerAttrChecker,
7760     onunload => $HTMLEventHandlerAttrChecker,
7761     }, {
7762     %HTMLAttrStatus,
7763     ## XXX
7764     onload => FEATURE_M12N10_REC,
7765     onunload => FEATURE_M12N10_REC,
7766     }),
7767     }; # frameset
7768    
7769 wakaba 1.49 ## frame frameborder longdesc marginheight marginwidth noresize scrolling src name(deprecated) class,id,title,style(x10)
7770     ## noframes Common, lang(xhtml10)
7771    
7772 wakaba 1.100 ## TODO: CR: rbc rtc @rbspan (M12NXHTML2Common)
7773 wakaba 1.56
7774 wakaba 1.61 ## TODO: xmp, listing, plaintext FEATURE_HTML32_REC_OBSOLETE
7775     ## TODO: ^^^ lang, dir, id, class [HTML 2.x] sdaform [HTML 2.0]
7776     ## xmp, listing sdapref[HTML2,0]
7777    
7778 wakaba 1.56 =pod
7779    
7780 wakaba 1.61 HTML 2.0 nextid @n
7781    
7782     RFC 2659: CERTS CRYPTOPTS
7783    
7784     ISO-HTML: pre-html, divN
7785 wakaba 1.82
7786     XHTML2: blockcode (Common), h (Common), separator (Common), l (Common),
7787     di (Common), nl (Common), handler (Common, type), standby (Common),
7788     summary (Common)
7789    
7790 wakaba 1.97 Access & XHTML2: access (LC)
7791 wakaba 1.82
7792     XML Events & XForms (for XHTML2 support; very, very low priority)
7793 wakaba 1.61
7794 wakaba 1.56 =cut
7795 wakaba 1.61
7796     ## NOTE: Where RFC 2659 allows additional attributes is unclear.
7797     ## We added them only to |a|. |link| and |form| might also allow them
7798     ## in theory.
7799 wakaba 1.1
7800     $Whatpm::ContentChecker::Namespace->{$HTML_NS}->{loaded} = 1;
7801    
7802     1;

admin@suikawiki.org
ViewVC Help
Powered by ViewVC 1.1.24