W3C home > Mailing lists > Public > public-html-commits@w3.org > August 2009

html5/markup/schema LICENSE,NONE,1.1 applications.rnc,NONE,1.1 aria.rnc,NONE,1.1 assertions.sch,NONE,1.1 block.rnc,NONE,1.1 common.rnc,NONE,1.1 core-scripting.rnc,NONE,1.1 data.rnc,NONE,1.1 embed.rnc,NONE,1.1 form-datatypes.rnc,NONE,1.1 html5.rnc,NONE,1.1 html5exclusions.rnc,NONE,1.1 media.rnc,NONE,1.1 meta.rnc,NONE,1.1 microdata.rnc,NONE,1.1 phrase.rnc,NONE,1.1 revision.rnc,NONE,1.1 ruby.rnc,NONE,1.1 sectional.rnc,NONE,1.1 structural.rnc,NONE,1.1 tables.rnc,NONE,1.1 web-forms-scripting.rnc,NONE,1.1 web-forms.rnc,NONE,1.1 web-forms2-scripting.rnc,NONE,1.1 web-forms2.rnc,NONE,1.1 xhtml5.rnc,NONE,1.1

From: Michael Smith via cvs-syncmail <cvsmail@w3.org>
Date: Sat, 29 Aug 2009 01:43:10 +0000
To: public-html-commits@&#
Message-Id: <E1MhCyE-0006IO-TH@lionel-hutz.w3.org>
Update of /sources/public/html5/markup/schema
In directory hutz:/tmp/cvs-serv24077/schema

Added Files:
	LICENSE applications.rnc aria.rnc assertions.sch block.rnc 
	common.rnc core-scripting.rnc data.rnc embed.rnc 
	form-datatypes.rnc html5.rnc html5exclusions.rnc media.rnc 
	meta.rnc microdata.rnc phrase.rnc revision.rnc ruby.rnc 
	sectional.rnc structural.rnc tables.rnc 
	web-forms-scripting.rnc web-forms.rnc web-forms2-scripting.rnc 
	web-forms2.rnc xhtml5.rnc 
Log Message:
checked in static copies of some dependencies, in order to make building easier


--- NEW FILE: block.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Basic Prose Markup                    #
# #####################################################################

# #####################################################################
## Paragraph-Level

## Paragraph: <p>

	p.elem =
		element p { p.inner & p.attrs }
	p.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	p.inner =
		( common.inner.phrasing ) # REVISIT lists in span?

	common.elem.flow |= p.elem

## Hint Transition: <hr>

	hr.elem =
		element hr { hr.inner & hr.attrs }
	hr.attrs =
		( common.attrs )
	hr.inner =
		( empty )

	common.elem.flow |= hr.elem

# #####################################################################
## Preformatting Blocks

## Preformatted Text: <pre>

	pre.elem =
		element pre { pre.inner & pre.attrs }
	pre.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	pre.inner =
		( common.inner.phrasing )

	common.elem.flow |= pre.elem

# #####################################################################
## Simple Lists

## Unordered List: <ul>

	ul.elem =
		element ul { ul.inner & ul.attrs }
	ul.attrs =
		(	common.attrs
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.region
			)?
		)
	ul.inner =
		( li.elem* )

	common.elem.flow |= ul.elem

## Unordered List Item: <li>

	li.elem =
		element li { li.inner & li.attrs }
	li.attrs =
		(	common.attrs 
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.listitem
			)?
		)
	li.inner =
		( common.inner.flow )

## Ordered List: <ol>

	ol.elem =
		element ol { ol.inner & ol.attrs }
	ol.attrs =
		(	common.attrs
		&	ol.attrs.start?
		&	ol.attrs.reversed?
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.region
			)?
		)
		ol.attrs.start =
			attribute start {
				common.data.integer
			}
		ol.attrs.reversed =
			attribute reversed {
				w:string "reversed" | w:string ""
			}
	ol.inner =
		( oli.elem* )

	common.elem.flow |= ol.elem

## Ordered List Item: <li>

	oli.elem =
		element li { oli.inner & oli.attrs }
	oli.attrs =
		(	common.attrs
		&	oli.attrs.value?
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.listitem
			)?
		)
		oli.attrs.value =
			attribute value {
				common.data.integer
			}
	oli.inner =
		( common.inner.flow )

# #####################################################################
## Definition Lists

## Definition List: <dl>

	dl.elem =
		element dl { dl.inner & dl.attrs }
	dl.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	dl.inner =
		(	(	dt.elem+
			,	dd.elem+
			)*
		)

	common.elem.flow |= dl.elem

## Definition Term: <dt>

	dt.elem =
		element dt { dt.inner & dt.attrs }
	dt.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	dt.inner =
		( common.inner.phrasing )

## Definition Description: <dd>

	dd.elem =
		element dd { dd.inner & dd.attrs }
	dd.elem.phrasing =
		element dd { dd.inner.phrasing & dd.attrs }
	dd.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	dd.inner =
		( common.inner.flow )
	dd.inner.phrasing =
		( common.inner.phrasing )

# #####################################################################
## Miscellaneous Elements

## Generic Container: <div>

	div.elem =
		element div { div.inner & div.attrs }
	div.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	div.inner =
		(	style.elem.scoped*
		,	common.inner.flow 
		)

	common.elem.flow |= div.elem

## Title or Explanatory Caption: <legend>

	legend.elem =
		element legend { legend.inner & legend.attrs }
	legend.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.region?
		)	
	legend.inner =
		( common.inner.phrasing )

--- NEW FILE: web-forms2.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Web Forms 2.0 markup                  #
# #####################################################################

## Shared attributes for form controls

	common-form.attrs.form |= 
		attribute form {
			common.data.idref
		}

	shared-form.attrs.formaction =
		attribute formaction {
			common.data.uri
		}

	shared-form.attrs.formenctype =
		attribute formenctype {
			shared-form.attrs.formenctype.data
		}
		shared-form.attrs.formenctype.data = 
			(	w:string "application/x-www-form-urlencoded" 
			|	w:string "multipart/form-data"
			|	w:string "text/plain"
			)

	shared-form.attrs.formmethod =
		attribute formmethod {
			shared-form.attrs.formmethod.data
		}
		shared-form.attrs.formmethod.data = 
			( w:string "get"
			| w:string "post"
			| w:string "put"
			| w:string "delete"
			)

	shared-form.attrs.formtarget = 
		attribute formtarget {
			common.data.browsing-context-name-or-keyword
		}

	shared-form.attrs.formnovalidate = 
		attribute formnovalidate {
			w:string "formnovalidate" | w:string ""
		}

	shared-form.attrs.autofocus = 
		attribute autofocus {
			w:string "autofocus" | w:string ""
		}
	
	shared-form.attrs.pattern = 
		attribute pattern {
			form.data.pattern
		}

	shared-form.attrs.template = 
		attribute template {
			common.data.idref
		}

	shared-form.attrs.required = 
		attribute required {
			w:string "required" | w:string ""
		}

	shared-form.attrs.placeholder = 
		attribute placeholder {
			string # FIXME line breaks
		}

## Shared attributes for <input>
		
	input.attrs.autocomplete = 
		attribute autocomplete {
			w:string "on" | w:string "off"
		}
	
	input.attrs.list = 
		attribute list {
			common.data.idref
		}
	
	input.attrs.step.float = 
		attribute step {
			w:string "any" | common.data.float.positive
		}
	
	input.attrs.step.integer = 
		attribute step {
			w:string "any" | common.data.integer.positive 
		}
	
	input.attrs.multiple = 
		attribute multiple {
			w:string "multiple" | w:string ""
		}
		
## Text Field: <input type='text'>, Extensions

	input.text.attrs &=
		(	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.placeholder?
		)

## Password Field: <input type='password'>, Extensions

	input.password.attrs &=
		(	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.placeholder?
		)

## Checkbox <input type='checkbox'>, Extensions

	input.checkbox.attrs &=
		(	shared-form.attrs.autofocus? 
		&	shared-form.attrs.required? 
		)

## Radiobutton: <input type='radio'>, Extensions

	input.radio.attrs &=
		(	shared-form.attrs.autofocus? 
		&	shared-form.attrs.required? 
		)

## Scripting Hook Button: <input type='button'>, Extensions

	input.button.attrs &=
		( shared-form.attrs.autofocus? )

## Submit Button: <input type='submit'>, Extensions

	input.submit.attrs &=
		(	shared-form.attrs.formaction? 
		&	shared-form.attrs.autofocus? 
		&	shared-form.attrs.formenctype? 
		&	shared-form.attrs.formmethod? 
		&	shared-form.attrs.formtarget? 
		&	shared-form.attrs.formnovalidate? 
		)

## Reset Button: <input type='reset'>, Extensions

	input.reset.attrs &=
		( shared-form.attrs.autofocus? )

## File Upload: <input type='file'>, Extensions

	input.file.attrs &=
		(	shared-form.attrs.autofocus? 
		&	shared-form.attrs.required? 
		&	input.attrs.multiple? 
		)

## Image Submit Button: <input type='image'>, Extensions

	input.image.attrs &=
		(	shared-form.attrs.formaction? 
		&	shared-form.attrs.autofocus? 
		&	shared-form.attrs.formenctype? 
		&	shared-form.attrs.formmethod? 
		&	shared-form.attrs.formtarget? 
		&	shared-form.attrs.formnovalidate? 
		&	input.image.attrs.height?
		&	input.image.attrs.width?
		)	
		input.image.attrs.height =
			attribute height {
				common.data.integer.positive
			}
		input.image.attrs.width =
			attribute width {
				common.data.integer.positive
			}

## Global Date and Time: <input type='datetime'>

	input.datetime.elem = 
		element input { input.datetime.attrs }	
	input.datetime.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.datetime.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.datetime.attrs.min? 
		&	input.datetime.attrs.max? 
		&	input.attrs.step.float? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.datetime.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.datetime.attrs.type = 
			attribute type {
				w:string "datetime"
			}
		input.datetime.attrs.min =
			attribute min {
				common.data.datetime
			}
		input.datetime.attrs.max =
			attribute max {
				common.data.datetime
			}	
		input.datetime.attrs.value =
			attribute value {
				common.data.datetime
			}
		
	input.elem |= input.datetime.elem

## Date and Time with No Time Zone Information: <input type='datetime-local'>

	input.datetime-local.elem = 
		element input { input.datetime-local.attrs }
	input.datetime-local.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.datetime-local.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.datetime-local.attrs.min? 
		&	input.datetime-local.attrs.max? 
		&	input.attrs.step.float? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.datetime-local.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.datetime-local.attrs.type = 
			attribute type {
				w:string "datetime-local"
			}
		input.datetime-local.attrs.min =
			attribute min {
				form.data.datetime-local
			}
		input.datetime-local.attrs.max =
			attribute max {
				form.data.datetime-local			
			}	
		input.datetime-local.attrs.value =
			attribute value {
				form.data.datetime-local
			}
		
	input.elem |= input.datetime-local.elem

## Date: <input type='date'>

	input.date.elem = 
		element input { input.date.attrs }
	input.date.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.date.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.date.attrs.min? 
		&	input.date.attrs.max? 
		&	input.attrs.step.integer? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.date.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.date.attrs.type = 
			attribute type {
				w:string "date"
			}
		input.date.attrs.min =
			attribute min {
				form.data.date
			}
		input.date.attrs.max =
			attribute max {
				form.data.date			
			}	
		input.date.attrs.value =
			attribute value {
				form.data.date
			}
		
	input.elem |= input.date.elem

## Year and Month: <input type='month'>

	input.month.elem = 
		element input { input.month.attrs }
	input.month.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.month.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.month.attrs.min? 
		&	input.month.attrs.max? 
		&	input.attrs.step.integer? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.month.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.month.attrs.type = 
			attribute type {
				w:string "month"
			}
		input.month.attrs.min =
			attribute min {
				form.data.month
			}
		input.month.attrs.max =
			attribute max {
				form.data.month			
			}	
		input.month.attrs.value =
			attribute value {
				form.data.month
			}
		
	input.elem |= input.month.elem

## Time without Time Zone Information: <input type='time'>

	input.time.elem = 
		element input { input.time.attrs }
	input.time.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.time.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.time.attrs.min? 
		&	input.time.attrs.max? 
		&	input.attrs.step.float? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.time.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.time.attrs.type = 
			attribute type {
				w:string "time"
			}
		input.time.attrs.min =
			attribute min {
				form.data.time
			}
		input.time.attrs.max =
			attribute max {
				form.data.time			
			}	
		input.time.attrs.value =
			attribute value {
				form.data.time
			}
		
	input.elem |= input.time.elem

## Year and Week: <input type='week'>

	input.week.elem = 
		element input { input.week.attrs }
	input.week.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.week.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.week.attrs.min? 
		&	input.week.attrs.max? 
		&	input.attrs.step.integer? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.week.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.week.attrs.type = 
			attribute type {
				w:string "week"
			}
		input.week.attrs.min =
			attribute min {
				form.data.week
			}
		input.week.attrs.max =
			attribute max {
				form.data.week			
			}	
		input.week.attrs.value =
			attribute value {
				form.data.week
			}
		
	input.elem |= input.week.elem

## Number: <input type='number'>

	input.number.elem = 
		element input { input.number.attrs }
	input.number.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.number.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.number.attrs.min? 
		&	input.number.attrs.max? 
		&	input.attrs.step.float? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	input.number.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.number.attrs.type = 
			attribute type {
				w:string "number"
			}
		input.number.attrs.min =
			attribute min {
				common.data.float
			}
		input.number.attrs.max =
			attribute max {
				common.data.float			
			}	
		input.number.attrs.value =
			attribute value {
				common.data.float
			}
		
	input.elem |= input.number.elem

## Imprecise Number: <input type='range'>

	input.range.elem = 
		element input { input.range.attrs }
	input.range.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.range.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.range.attrs.min? 
		&	input.range.attrs.max? 
		&	input.attrs.step.float? 
		&	input.range.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.range.attrs.type = 
			attribute type {
				w:string "range"
			}
		input.range.attrs.min =
			attribute min {
				common.data.float
			}
		input.range.attrs.max =
			attribute max {
				common.data.float			
			}	
		input.range.attrs.value =
			attribute value {
				common.data.float
			}
		
	input.elem |= input.range.elem

## Email Address: <input type='email'>

	input.email.elem = 
		element input { input.email.attrs }	
	input.email.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.email.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.size?
		&	shared-form.attrs.placeholder?
		&	(	(	input.attrs.multiple
				&	input.email.attrs.value.multiple?
				)
			|	input.email.attrs.value.single?
			)?
		&	common.attrs.aria.implicit.input?
		)	
		input.email.attrs.type = 
			attribute type {
				w:string "email"
			}
		input.email.attrs.value.single =
			attribute value {
				form.data.emailaddress
			}
		input.email.attrs.value.multiple =
			attribute value {
				form.data.emailaddresslist
			}
		
	input.elem |= input.email.elem

## IRI: <input type='url'>

	input.url.elem = 
		element input { input.url.attrs }	
	input.url.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.url.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.size?
		&	shared-form.attrs.placeholder?
		&	input.url.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.url.attrs.type = 
			attribute type {
				w:string "url"
			}
		input.url.attrs.value =
			attribute value {
				w:string "" | common.data.uri.absolute
			}
		
	input.elem |= input.url.elem

## Search: <input type='search'>

	input.search.elem = 
		element input { input.search.attrs }	
	input.search.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.search.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.size?
		&	shared-form.attrs.placeholder?
		&	input.search.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.search.attrs.type = 
			attribute type {
				w:string "search"
			}
		input.search.attrs.value =
			attribute value {
				string # FIXME line breaks
			}
		
	input.elem |= input.search.elem

## Telephone Number: <input type='tel'>

	input.tel.elem = 
		element input { input.tel.attrs }	
	input.tel.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.tel.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.pattern? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.size?
		&	shared-form.attrs.placeholder?
		&	input.tel.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.tel.attrs.type = 
			attribute type {
				w:string "tel"
			}
		input.tel.attrs.value =
			attribute value {
				string # FIXME line breaks
			}
		
	input.elem |= input.tel.elem

## Color: <input type='color'>

	input.color.elem = 
		element input { input.color.attrs }	
	input.color.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.color.attrs.type
		&	input.attrs.autocomplete? 
		&	shared-form.attrs.autofocus? 
		&	input.attrs.list? 
		&	input.color.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)	
		input.color.attrs.type = 
			attribute type {
				w:string "color"
			}
		input.color.attrs.value =
			attribute value {
				form.data.color
			}
		
	input.elem |= input.color.elem

## Form Output: <output>

	output.elem =
		element output { output.inner & output.attrs }
	output.attrs =
		(	common.attrs
		&	common-form.attrs.name?
		&	common-form.attrs.form?
		&	output.attrs.for?
		&	common.attrs.aria.implicit.region?
		)
		output.attrs.for = 
			attribute for {
				common.data.idrefs #REVISIT spec says space--not whitespace
			}
	output.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= output.elem

## Text Area: <textarea>, extensions

	textarea.attrs &=
		(	shared-form.attrs.maxlength?
		&	shared-form.attrs.autofocus? 
		&	shared-form.attrs.required? 
		&	shared-form.attrs.placeholder?
		&	textarea.attrs.rows?
		&	(	(	textarea.attrs.wrap.hard 
				&	textarea.attrs.cols
				)
			|	(	textarea.attrs.wrap.soft?
				&	textarea.attrs.cols?
				)
			)
		)
		textarea.attrs.wrap.hard =
			attribute wrap {
				w:string "hard"
			}
		textarea.attrs.wrap.soft =
			attribute wrap {
				w:string "soft"
			}

## List of Prefill Data: <datalist>

	#REVISIT should the options in datalist be non-selectable?

	datalist.elem =
		element datalist { datalist.inner & datalist.attrs }
	datalist.inner =
		( option.elem* & common.inner.phrasing )
	datalist.attrs =
		( common.attrs )

	common.elem.phrasing |= datalist.elem

## Complex Submit Button: <button type='submit'>, extensions

	button.submit.attrs &=
		(	shared-form.attrs.formaction? 
		&	shared-form.attrs.autofocus? 
		&	shared-form.attrs.formenctype? 
		&	shared-form.attrs.formmethod? 
		&	shared-form.attrs.formtarget? 
		&	shared-form.attrs.formnovalidate? 
		)
	
## Complex Reset Button: <button type='reset'>, extensions

	button.reset.attrs &=
		( shared-form.attrs.autofocus? )
	
## Complex Push Button: <button type='button'>, extensions

	button.button.attrs &=
		( shared-form.attrs.autofocus? )

## Form: <form>, extensions
	form.attrs &= 
		(	form.attrs.novalidate?
		&	form.attrs.target?
		&	form.attrs.autocomplete?
		)
		form.attrs.novalidate = 
			attribute novalidate {
				w:string "novalidate" | w:string ""
			}
		form.attrs.target = 
			attribute target {
				common.data.browsing-context-name-or-keyword
			}
		form.attrs.autocomplete = 
			attribute autocomplete {
				w:string "on" | w:string "off"
			}
		# REVISIT should this be case-insensitive in conforming XHTML documents?
		form.attrs.enctype.data |= 
			( w:string "text/plain" )
		form.attrs.method.data |= 
			( w:string "put" | w:string "delete" )

## Fieldset: <fieldset>, extensions

	fieldset.attrs &=
		( common-form.attrs )

## Label: <label>, extensions

	label.attrs &=
		( common-form.attrs.form? )

## Key-pair generator/input control: <keygen>

	keygen.elem =
		element keygen { keygen.inner & keygen.attrs }
	keygen.attrs =
		(	common.attrs
		&	keygen.attrs.challenge?
		&	keygen.attrs.keytype?
		&	shared-form.attrs.autofocus? 
		&	common-form.attrs?
		#REVISIT which ARIA attributes needed here
		)
		keygen.attrs.challenge =
			attribute challenge {
				string
			}
		keygen.attrs.keytype = 
			attribute keytype {
				w:string "rsa"
			}
	keygen.inner =
		( empty )

	common.elem.phrasing |= keygen.elem


--- NEW FILE: LICENSE ---
The RELAX NG Schema for (X)HTML 5 is licensed under the MIT open source license.
The following legal notice applies to all files in this directory:

Copyright (c) 2005-2007 Elika J. Etemad (fantasai) and Henri Sivonen (hsivonen)
Copyright (c) 2007-2008 Mozilla Foundation

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

--- NEW FILE: embed.rnc ---
datatypes w = "http://whattf.org/datatype-draft"
namespace local = ""

# #####################################################################
##  RELAX NG Schema for HTML 5: Embedded Content                      #
# #####################################################################

#######################################################################
## Replaced Content

## Images: <img>

	img.elem =
		element img { img.inner & img.attrs }
	img.attrs =
		(	common.attrs
		&	img.attrs.src
		&	img.attrs.alt?
		&	img.attrs.height?
		&	img.attrs.width?
		&	img.attrs.usemap?
		&	img.attrs.ismap?
		& img.attrs.border? # obsolete
		&	common.attrs.aria?
		)
		img.attrs.src =
			attribute src {
				common.data.uri
			}
		img.attrs.alt =
			attribute alt {
				text
			}
		img.attrs.height =
			attribute height {
				common.data.integer.non-negative
			}
		img.attrs.width =
			attribute width {
				common.data.integer.non-negative
			}
		img.attrs.usemap =
			attribute usemap {
				common.data.hash-name
			}
		img.attrs.ismap =
			attribute ismap {
				w:string "ismap" | w:string ""
			}
		img.attrs.border =
			attribute border {
				common.data.zero
			}
	img.inner =
		empty

	common.elem.phrasing |= img.elem

## Plug-ins: <embed>

	embed.elem =
		element embed { embed.inner & embed.attrs }
	embed.attrs =
		(	common.attrs
		&	embed.attrs.src?
		&	embed.attrs.type?
		&	embed.attrs.height?
		&	embed.attrs.width?
		&	embed.attrs.other*
		)
		embed.attrs.src =
			attribute src {
				common.data.uri
			}
		embed.attrs.type =
			attribute type {
				common.data.mimetype
			}
		embed.attrs.height =
			attribute height {
				common.data.integer.positive
			}
		embed.attrs.width =
			attribute width {
				common.data.integer.positive
			}
		embed.attrs.other = # REVISIT common.attrs
			attribute local:* - ( src 
			                    | type 
			                    | height 
			                    | width 
			                    | id 
			                    | class
			                    | title 
			                    | dir 
			                    | lang 
			                    | style 
			                    | tabindex 
			                    | contextmenu 
			                    | contenteditable 
			                    | draggable 
			                    | hidden
			                    | onabort
			                    | onblur
			                    | oncanplay
			                    | oncanplaythrough
			                    | onchange
			                    | onclick
			                    | oncontextmenu
			                    | ondblclick
			                    | ondrag
			                    | ondragend
			                    | ondragenter
			                    | ondragleave
			                    | ondragover
			                    | ondragstart
			                    | ondrop
			                    | ondurationchange
			                    | onemptied
			                    | onended
			                    | onerror
			                    | onfocus
			                    | onformchange
			                    | onforminput
			                    | oninput
			                    | oninvalid
			                    | onkeydown
			                    | onkeypress
			                    | onkeyup
			                    | onload
			                    | onloadeddata
			                    | onloadedmetadata
			                    | onloadstart
			                    | onmousedown
			                    | onmousemove
			                    | onmouseout
			                    | onmouseover
			                    | onmouseup
			                    | onmousewheel
			                    | onpause
			                    | onplay
			                    | onplaying
			                    | onprogress
			                    | onratechange
			                    | onreadystatechange
			                    | onscroll
			                    | onseeked
			                    | onseeking
			                    | onselect
			                    | onshow
			                    | onstalled
			                    | onsubmit
			                    | onsuspend
			                    | ontimeupdate
			                    | onvolumechange
			                    | onwaiting
			                    | onafterprint
			                    | onbeforeprint
			                    | onbeforeunload
			                    | onhashchange
			                    | onmessage
			                    | onoffline
			                    | ononline
			                    | onpopstate
			                    | onredo
			                    | onresize
			                    | onstorage
			                    | onundo
			                    | onunload
			                    | role
			                    | aria-atomic
			                    | aria-busy
			                    | aria-controls
			                    | aria-describedby
			                    | aria-disabled
			                    | aria-dropeffect
			                    | aria-flowto
			                    | aria-grabbed
			                    | aria-haspopup
			                    | aria-hidden
			                    | aria-invalid
			                    | aria-label
			                    | aria-labelledby
			                    | aria-live
			                    | aria-owns
			                    | aria-relevant
			                    | aria-required	
			                    | spellcheck
			                    | accesskey
			                    | item
			                    | itemprop
			                    | subject
			                    ) 
			{
				string
			}
	embed.inner =
		empty

	common.elem.phrasing |= embed.elem

## Generic Objects: <object>

	object.elem.flow =
		element object { object.inner.flow & object.attrs }
	object.elem.phrasing =
		element object { object.inner.phrasing & object.attrs }
	object.attrs =
		(	common.attrs
		&	(	(	object.attrs.data
				&	object.attrs.type?
				)
			|	object.attrs.type
			)
#		&	object.attrs.classid?
#		&	object.attrs.codebase?
#		&	object.attrs.codetype?
		&	object.attrs.height?
		&	object.attrs.width?
		&	object.attrs.usemap?
		&	object.attrs.name?
		&	common-form.attrs.form?
		&	common.attrs.aria?
		)
		object.attrs.data =
			attribute data {
				common.data.uri
			}
		object.attrs.type =
			attribute type {
				common.data.mimetype
			}
		object.attrs.classid =
			attribute classid {
				common.data.uri
			}
		object.attrs.codebase =
			attribute codebase {
				common.data.uri
			}
		object.attrs.codetype =
			attribute codetype {
				common.data.mimetype
			}
		object.attrs.height =
			attribute height {
				common.data.integer.positive
			}
		object.attrs.width =
			attribute width {
				common.data.integer.positive
			}
		object.attrs.usemap =
			attribute usemap {
				common.data.hash-name
			}
		object.attrs.name =
			attribute name {
				common.data.browsing-context-name
			}
	object.inner.flow =
		(	param.elem*
		,	common.inner.flow
		)
	object.inner.phrasing =
		(	param.elem*
		,	common.inner.phrasing
		)

	common.elem.flow |= object.elem.flow
	common.elem.phrasing |= object.elem.phrasing

## Initialization Parameters: <param>

	param.elem =
		element param { param.inner & param.attrs }
	param.attrs =
		(	common.attrs
		&	param.attrs.name
		&	param.attrs.value
		)
		param.attrs.name =
			attribute name {
				string
			}
		param.attrs.value =
			attribute value {
				string
			}
	param.inner =
		( empty )

## Inline Frame: <iframe>

	iframe.elem =
		element iframe { iframe.inner & iframe.attrs }
	iframe.attrs =
		(	common.attrs
		&	iframe.attrs.src?
		&	iframe.attrs.name?
		&	iframe.attrs.width?
		&	iframe.attrs.height?
		&	iframe.attrs.sandbox?
		&	iframe.attrs.seamless?
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.region
			)?
		)
		iframe.attrs.src =
			attribute src {
				common.data.uri
			}
		iframe.attrs.name =
			attribute name {
				common.data.browsing-context-name
			}
		iframe.attrs.height =
			attribute height {
				common.data.integer.positive
			}
		iframe.attrs.width =
			attribute width {
				common.data.integer.positive
			}
		iframe.attrs.seamless =
			attribute seamless {
				w:string "seamless" | w:string ""
			} & v5only
		iframe.attrs.sandbox =
			attribute sandbox {
				common.data.sandbox-allow-list 
			}
				common.data.sandbox-allow-list =
				(	list
					{	( w:string "allow-same-origin" )?
					,	( w:string "allow-forms" )?
					,	( w:string "allow-scripts" )?
					}
				|	list 
					{	( w:string "allow-same-origin" )?
					,	( w:string "allow-scripts" )?
					,	( w:string "allow-forms" )?
					}
				|	list 
					{	( w:string "allow-forms" )?
					,	( w:string "allow-same-origin" )?
					,	( w:string "allow-scripts" )?
					}
				|	list 
					{	( w:string "allow-forms" )?
					,	( w:string "allow-scripts" )?
					,	( w:string "allow-same-origin" )?
					}
				|	list 
					{	( w:string "allow-scripts" )?
					,	( w:string "allow-same-origin" )?
					,	( w:string "allow-forms" )?
					}
				|	list 
					{	( w:string "allow-scripts" )?
					,	( w:string "allow-forms" )?
					,	( w:string "allow-same-origin" )?
					}
				)	& v5only
	iframe.inner =
		( text )

	common.elem.phrasing |= iframe.elem

#######################################################################
## Image Maps

## Map Definition: <map>

	map.elem.flow =
		element map { map.inner.flow & map.attrs }
	map.elem.phrasing  =
		element map { map.inner.phrasing & map.attrs }
	map.attrs =
		(	common.attrs
		&	map.attrs.name
		) # REVISIT make id required in Schematron
		map.attrs.name =
			attribute name {
				common.data.name
			}
	map.inner.flow =
		( common.inner.flow )
	map.inner.phrasing =
		( common.inner.phrasing )

	common.elem.flow |= map.elem.flow
	common.elem.phrasing |= map.elem.phrasing

## Map Area Definition: <area>

	area.elem =
		element area { area.inner & area.attrs }
	area.attrs =
		(	common.attrs
		&	(	area.attrs.alt
			&	area.attrs.href
			)?
		&	area.attrs.target?
		&	area.attrs.ping?
		&	area.attrs.rel?
		&	area.attrs.media?
		&	area.attrs.hreflang?
		&	area.attrs.type?
		&	area.attrs.shape?
		)
		area.attrs.alt =
			attribute alt {
				text
			}
		area.attrs.href =
		  attribute href {
		    common.data.uri
		  }
		area.attrs.target =
		  attribute target {
		    common.data.browsing-context-name-or-keyword
		  }
		area.attrs.rel =
		  attribute rel {
		    common.data.tokens
		  }
		area.attrs.hreflang =
		  attribute hreflang {
		    common.data.langcode
		  }
		area.attrs.media =
		  attribute media {
		    common.data.mediaquery
		  }
		area.attrs.type =
		  attribute type {
		    common.data.mimetype
		  }
		area.attrs.ping =
		  attribute ping {
		    common.data.uris
		  } & v5only

		area.attrs.shape =
			(	( area.attrs.shape.rect?  & area.attrs.coords.rect   )
			|	( area.attrs.shape.circle & area.attrs.coords.circle )
			|	( area.attrs.shape.poly   & area.attrs.coords.poly   )
			|	( area.attrs.shape.default )
			)
		area.attrs.shape.rect =
			attribute shape {
				w:string "rect"
			}
		area.attrs.coords.rect =
			attribute coords {
				w:rectangle
#				xsd:token {
#					pattern = "-?[0-9]+,-?[0-9]+,-?[0-9]+,-?[0-9]+"
#				}
			}
		area.attrs.shape.circle =
			attribute shape {
				w:string "circle"
			}
		area.attrs.coords.circle =
			attribute coords {
				w:circle
#				xsd:token {
#					pattern = "-?[0-9]+,-?[0-9]+,[0-9]+"
#				}
			}
		area.attrs.shape.poly =
			attribute shape {
				w:string "poly"
			}
		area.attrs.coords.poly =
			attribute coords {
				w:polyline
#				xsd:token {
#					pattern = "-?[0-9]+,-?[0-9]+,-?[0-9]+,-?[0-9]+,-?[0-9]+,-?[0-9]+(,-?[0-9]+,-?[0-9]+)*"
#				}
			}
		area.attrs.shape.default =
			attribute shape {
				w:string "default"
			}
	area.inner =
		( empty )

	common.elem.phrasing |= area.elem

--- NEW FILE: meta.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Global Structure & Metadata          #
# #####################################################################

## Root Element: <html>

	html.elem =
		element html { html.inner & html.attrs }
	html.attrs =
		( common.attrs )
	html.inner =
		(	head.elem
		,	body.elem
		)

## Metadata Container: <head>

	head.elem =
		element head { head.inner & head.attrs }
	head.attrs =
		(	common.attrs
#		&	head.attrs.profile?
		)
#		head.attrs.profile =
#			attribute profile {
#				common.data.uris #REVISIT should these be absolute (zero or more)
#			}
	head.inner =
		(	title.elem
		&	base.elem? # REVISIT need a non-schema checker or Schematron
		&	common.inner.metadata # Limit encoding decl position in Schematron
		)
#	head.inner =
#		(	meta.elem.encoding?
#		,	(	title.elem
#			&	base.elem? # REVISIT need a non-schema checker or Schematron
#			&	common.inner.metadata
#			)
#		)
		
## Content Container: <body>

	body.elem =
		element body { body.inner & body.attrs }
	body.attrs =
		(	common.attrs
		&	(	common.attrs.aria.landmark.application
			|	common.attrs.aria.implicit.structure
			)?
		&	body.attrs.onafterprint?
		&	body.attrs.onbeforeprint?
		&	body.attrs.onbeforeunload?
		&	body.attrs.onhashchange?
		&	body.attrs.onmessage?
		&	body.attrs.onoffline?
		&	body.attrs.ononline?
		&	body.attrs.onpopstate?
		&	body.attrs.onredo?
		&	body.attrs.onresize?
		&	body.attrs.onstorage?
		&	body.attrs.onundo?
		&	body.attrs.onunload?
		)
	body.inner =
		( common.inner.flow )

	body.attrs.onafterprint =
		attribute onafterprint { string }
	body.attrs.onbeforeprint =
		attribute onbeforeprint { string }
	body.attrs.onbeforeunload =
		attribute onbeforeunload { string }
	body.attrs.onhashchange =
		attribute onhashchange { string }
	body.attrs.onmessage =
		attribute onmessage { string }
	body.attrs.onoffline =
		attribute onoffline { string }
	body.attrs.ononline =
		attribute ononline { string }
	body.attrs.onpopstate =
		attribute onpopstate { string }
	body.attrs.onredo =
		attribute onredo { string }
	body.attrs.onresize =
		attribute onresize { string }
	body.attrs.onstorage =
		attribute onstorage { string }
	body.attrs.onundo =
		attribute onundo { string }
	body.attrs.onunload =
		attribute onunload { string }

## Document Title: <title>

	title.elem =
		element title { title.inner & title.attrs }
	title.attrs =
		( common.attrs )
	title.inner =
		( replaceable-character-data )

## Base URI: <base>

	base.elem =
		element base { base.inner & base.attrs }
	base.attrs =
		(	common.attrs
		&	base.attrs.href?
		&	base.attrs.target?
		)
	base.attrs.href =
		attribute href {
			common.data.uri
		}
	base.attrs.target =
		attribute target {
			common.data.browsing-context-name-or-keyword
		}
	base.inner =
		( empty )

## Global Relationships: <link>

	link.elem =
		element link { link.inner & link.attrs }
	link.attrs =
		(	common.attrs
		&	link.attrs.href
		&	link.attrs.rel
		&	link.attrs.hreflang?
		&	link.attrs.media?
		&	link.attrs.type?
		&	link.attrs.sizes?
		#	link.attrs.title included in common.attrs
		)
		link.attrs.sizes =
			attribute sizes {
				w:string "any" | common.data.sizes
			}
		link.attrs.href =
		  attribute href {
		    common.data.uri
		  }
		link.attrs.rel =
		  attribute rel {
		    common.data.tokens
		  }
		link.attrs.hreflang =
		  attribute hreflang {
		    common.data.langcode
		  }
		link.attrs.media =
		  attribute media {
		    common.data.mediaquery
		  }
		link.attrs.type =
		  attribute type {
		    common.data.mimetype
		  }

	link.inner =
		( empty )
		
	common.elem.metadata |= link.elem

## Global Style: <style>

	style.elem =
		element style { style.inner & style.attrs }
	style.attrs =
		(	common.attrs
		&	style.attrs.type?
		&	style.attrs.media?
		#	style.attrs.title included in common.attrs
		)
		style.attrs.type =
			attribute type {
				common.data.mimetype
			}
		style.attrs.media =
			attribute media {
				common.data.mediaquery
			}
	style.inner =
		( non-replaceable-character-data )
		
	common.elem.metadata |= style.elem

## Scoped Style: <style scoped>

	style.elem.scoped =
		element style { style.inner & style.scoped.attrs }
	style.scoped.attrs =
		(	common.attrs
		&	style.attrs.type?
		&	style.attrs.media?
		&	style.attrs.scoped
		#	style.attrs.title included in common.attrs
		)
		style.attrs.scoped =
			attribute scoped {
				w:string "scoped" | w:string ""
			}

## Name-Value Metadata: <meta name>

	meta.name.elem =
		element meta { meta.inner & meta.name.attrs }
	meta.name.attrs =
		(	common.attrs
		&	meta.name.attrs.name
		&	meta.name.attrs.content
		)
		meta.name.attrs.name =
			attribute name {
				string
			}
		meta.name.attrs.content =
			attribute content {
				string
			}
	meta.inner =
		( empty )
		
	common.elem.metadata |= meta.name.elem

## "refresh" pragma directive: <meta http-equiv='refresh'>

	meta.http-equiv.refresh.elem =
		element meta { meta.inner & meta.http-equiv.refresh.attrs }
	meta.http-equiv.refresh.attrs =
		(	common.attrs
		&	meta.http-equiv.attrs.http-equiv.refresh
		&	meta.http-equiv.attrs.content.refresh
		)
		meta.http-equiv.attrs.http-equiv.refresh =
			attribute http-equiv {
				w:string "refresh"
			}
		meta.http-equiv.attrs.content.refresh =
			attribute content { 
				common.data.refresh
			}
	common.elem.metadata |= meta.http-equiv.refresh.elem # not quite right per spec
                                                       # if the definition is 
                                                       # reused in another language

## "default-style" pragma directive: <meta http-equiv='default-style'>

	meta.http-equiv.default-style.elem =
		element meta { meta.inner & meta.http-equiv.default-style.attrs }
	meta.http-equiv.default-style.attrs =
		(	common.attrs
		&	meta.http-equiv.attrs.http-equiv.default-style
		&	meta.http-equiv.attrs.content.default-style
		)
		meta.http-equiv.attrs.http-equiv.default-style =
			attribute http-equiv {
				w:string "default-style"
			}
		meta.http-equiv.attrs.content.default-style =
			attribute content {
				common.data.default-style
			}
		
	common.elem.metadata |= meta.http-equiv.default-style.elem # not quite right per spec
                                                               # if the definition is 
                                                               # reused in another language

## "content-language" pragma directive: <meta http-equiv='content-language'> (obsolete)

	meta.http-equiv.content-language.elem =
		element meta { meta.inner & meta.http-equiv.content-language.attrs }
	meta.http-equiv.content-language.attrs =
		(	common.attrs
		&	meta.http-equiv.attrs.http-equiv.content-language
		&	meta.http-equiv.attrs.content.content-language
		)
		meta.http-equiv.attrs.http-equiv.content-language =
			attribute http-equiv {
				w:string "content-language"
			}
		meta.http-equiv.attrs.content.content-language =
			attribute content {
				common.data.langcode
			}
		
	common.elem.metadata |= meta.http-equiv.content-language.elem # not quite right per spec
                                                               # if the definition is 
                                                               # reused in another language

## Inline Character Encoding Statement for HTML: <meta charset>

	meta.charset.elem =
		element meta { meta.inner & meta.charset.attrs }
	meta.charset.attrs =
		(	common.attrs
		&	meta.charset.attrs.charset
		)
		meta.charset.attrs.charset =
			attribute charset {
				common.data.charset
			}

## Inline Character Encoding Statement for HTML: <meta http-equiv='content-type'>

	meta.http-equiv.content-type.elem =
		element meta { meta.inner & meta.http-equiv.content-type.attrs }
		& HTMLonly
	meta.http-equiv.content-type.attrs =
		(	common.attrs
		&	meta.http-equiv.attrs.http-equiv.content-type
		&	meta.http-equiv.attrs.content.content-type
		)
		meta.http-equiv.attrs.http-equiv.content-type =
			attribute http-equiv {
				w:string "content-type"
			}
		meta.http-equiv.attrs.content.content-type =
			attribute content {
				common.data.meta-charset
			}

	common.elem.metadata |= meta.charset.elem
	common.elem.metadata |= meta.http-equiv.content-type.elem

--- NEW FILE: core-scripting.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Core Scripting                        #
# #####################################################################

# #####################################################################
## Scripting Elements

## Inline Scripts: <script>

	script.elem.embedded =
		element script { script.inner.embedded & script.attrs.embedded }
	script.attrs.embedded =
		(	common.attrs
		&	script.attrs.type?
		&	script.attrs.language? # restricted in Schematron
		)
	script.elem.imported =
		element script { script.inner.imported & script.attrs.imported }
	script.attrs.imported =
		(	common.attrs
		&	script.attrs.src
		&	script.attrs.defer?
		&	script.attrs.async?
		&	script.attrs.type?
		&	script.attrs.charset?
		&	script.attrs.language? # restricted in Schematron
		)
		script.attrs.src =
			attribute src {
				common.data.uri
			}
		script.attrs.defer =
			attribute defer {
				w:string "defer" | w:string ""
			}
		script.attrs.async =
			attribute async {
				w:string "async" | w:string ""
			} & v5only
		script.attrs.type =
			attribute type {
				common.data.mimetype # XXX without charset parameter!
			}
		script.attrs.charset =
			attribute charset {
				common.data.charset
			}
		script.attrs.language =
			attribute language {
				common.data.javascript
			}
			common.data.javascript =
				w:string "javascript"
		
	script.inner.embedded =
		( non-replaceable-character-data )
	script.inner.imported =
		( empty )
		
	script.elem = 
		(	script.elem.embedded
		|	script.elem.imported
		)
		
	common.elem.metadata |= script.elem
	common.elem.phrasing |= script.elem

## Fallback Unscripted Content: <noscript>

	noscript.elem.head =
		element noscript { noscript.inner.head & noscript.attrs }
		& HTMLonly
		noscript.inner.head = 
			(	link.elem
			|	meta.http-equiv.default-style.elem
			|	meta.http-equiv.refresh.elem
			|	style.elem
			)*
	noscript.elem.phrasing =
		element noscript { noscript.inner.phrasing & noscript.attrs }
		& HTMLonly
	noscript.inner.phrasing =
		( common.inner.phrasing )
	noscript.elem.flow =
		element noscript { noscript.inner.flow & noscript.attrs }
		& HTMLonly
	noscript.inner.flow =
		( common.inner.flow )
	noscript.attrs =
		( common.attrs )

	common.elem.metadata |= noscript.elem.head
	common.elem.phrasing |= noscript.elem.phrasing
	common.elem.flow |= noscript.elem.flow

# #####################################################################
## Event Handler Attribute Definitions

	common.attrs.event-handler =
			scripting.attr.onabort?
		&	scripting.attr.onblur?
		&	scripting.attr.oncanplay?
		&	scripting.attr.oncanplaythrough?
		&	scripting.attr.onchange?
		&	scripting.attr.onclick?
		&	scripting.attr.oncontextmenu?
		&	scripting.attr.ondblclick?
		&	scripting.attr.ondrag?
		&	scripting.attr.ondragend?
		&	scripting.attr.ondragenter?
		&	scripting.attr.ondragleave?
		&	scripting.attr.ondragover?
		&	scripting.attr.ondragstart?
		&	scripting.attr.ondrop?
		&	scripting.attr.ondurationchange?
		&	scripting.attr.onemptied?
		&	scripting.attr.onended?
		&	scripting.attr.onerror?
		&	scripting.attr.onfocus?
		&	scripting.attr.onformchange?
		&	scripting.attr.onforminput?
		&	scripting.attr.oninput?
		&	scripting.attr.oninvalid?
		&	scripting.attr.onkeydown?
		&	scripting.attr.onkeypress?
		&	scripting.attr.onkeyup?
		&	scripting.attr.onload?
		&	scripting.attr.onloadeddata?
		&	scripting.attr.onloadedmetadata?
		&	scripting.attr.onloadstart?
		&	scripting.attr.onmousedown?
		&	scripting.attr.onmousemove?
		&	scripting.attr.onmouseout?
		&	scripting.attr.onmouseover?
		&	scripting.attr.onmouseup?
		&	scripting.attr.onmousewheel?
		&	scripting.attr.onpause?
		&	scripting.attr.onplay?
		&	scripting.attr.onplaying?
		&	scripting.attr.onprogress?
		&	scripting.attr.onratechange?
		&	scripting.attr.onreadystatechange?
		&	scripting.attr.onscroll?
		&	scripting.attr.onseeked?
		&	scripting.attr.onseeking?
		&	scripting.attr.onselect?
		&	scripting.attr.onshow?
		&	scripting.attr.onstalled?
		&	scripting.attr.onsubmit?
		&	scripting.attr.onsuspend?
		&	scripting.attr.ontimeupdate?
		&	scripting.attr.onvolumechange?
		&	scripting.attr.onwaiting?
		
		

	scripting.attr.onabort =
		attribute onabort { string }
	scripting.attr.onblur =
		attribute onblur { string }
	scripting.attr.oncanplay =
		attribute oncanplay { string }
	scripting.attr.oncanplaythrough =
		attribute oncanplaythrough { string }
	scripting.attr.onchange =
		attribute onchange { string }
	scripting.attr.onclick =
		attribute onclick { string }
	scripting.attr.oncontextmenu =
		attribute oncontextmenu { string }
	scripting.attr.ondblclick =
		attribute ondblclick { string }
	scripting.attr.ondrag =
		attribute ondrag { string }
	scripting.attr.ondragend =
		attribute ondragend { string }
	scripting.attr.ondragenter =
		attribute ondragenter { string }
	scripting.attr.ondragleave =
		attribute ondragleave { string }
	scripting.attr.ondragover =
		attribute ondragover { string }
	scripting.attr.ondragstart =
		attribute ondragstart { string }
	scripting.attr.ondrop =
		attribute ondrop { string }
	scripting.attr.ondurationchange =
		attribute ondurationchange { string }
	scripting.attr.onemptied =
		attribute onemptied { string }
	scripting.attr.onended =
		attribute onended { string }
	scripting.attr.onerror =
		attribute onerror { string }
	scripting.attr.onfocus =
		attribute onfocus { string }
	scripting.attr.onformchange =
		attribute onformchange { string }
	scripting.attr.onforminput =
		attribute onforminput { string }
	scripting.attr.oninput =
		attribute oninput { string }
	scripting.attr.oninvalid =
		attribute oninvalid { string }
	scripting.attr.onkeydown =
		attribute onkeydown { string }
	scripting.attr.onkeypress =
		attribute onkeypress { string }
	scripting.attr.onkeyup =
		attribute onkeyup { string }
	scripting.attr.onload =
		attribute onload { string }
	scripting.attr.onloadeddata =
		attribute onloadeddata { string }
	scripting.attr.onloadedmetadata =
		attribute onloadedmetadata { string }
	scripting.attr.onloadstart =
		attribute onloadstart { string }
	scripting.attr.onmousedown =
		attribute onmousedown { string }
	scripting.attr.onmousemove =
		attribute onmousemove { string }
	scripting.attr.onmouseout =
		attribute onmouseout { string }
	scripting.attr.onmouseover =
		attribute onmouseover { string }
	scripting.attr.onmouseup =
		attribute onmouseup { string }
	scripting.attr.onmousewheel =
		attribute onmousewheel { string }
	scripting.attr.onpause =
		attribute onpause { string }
	scripting.attr.onplay =
		attribute onplay { string }
	scripting.attr.onplaying =
		attribute onplaying { string }
	scripting.attr.onprogress =
		attribute onprogress { string }
	scripting.attr.onratechange =
		attribute onratechange { string }
	scripting.attr.onreadystatechange =
		attribute onreadystatechange { string }
	scripting.attr.onscroll =
		attribute onscroll { string }
	scripting.attr.onseeked =
		attribute onseeked { string }
	scripting.attr.onseeking =
		attribute onseeking { string }
	scripting.attr.onselect =
		attribute onselect { string }
	scripting.attr.onshow =
		attribute onshow { string }
	scripting.attr.onstalled =
		attribute onstalled { string }
	scripting.attr.onsubmit =
		attribute onsubmit { string }
	scripting.attr.onsuspend =
		attribute onsuspend { string }
	scripting.attr.ontimeupdate =
		attribute ontimeupdate { string }
	scripting.attr.onvolumechange =
		attribute onvolumechange { string }
	scripting.attr.onwaiting =
		attribute onwaiting { string }

#	scripting.attr.common =
#		(	scripting.attr.mouse
#		&	scripting.attr.keyboard
#		&	scripting.attr.focus
#		)
#	
#	scripting.attr.mouse =
#		(	scripting.attr.mouse.click?
#		&	scripting.attr.mouse.dblclick?
#		&	scripting.attr.mouse.down?
#		&	scripting.attr.mouse.up?
#		&	scripting.attr.mouse.over?
#		&	scripting.attr.mouse.move?
#		&	scripting.attr.mouse.out?
#		)
#		scripting.attr.mouse.click =
#			attribute onclick { string }
#		scripting.attr.mouse.dblclick =
#			attribute ondblclick { string }
#		scripting.attr.mouse.down =
#			attribute onmousedown { string }
#		scripting.attr.mouse.up =
#			attribute onmouseup { string }
#		scripting.attr.mouse.over =
#			attribute onmouseover { string }
#		scripting.attr.mouse.move =
#			attribute onmousemove { string }
#		scripting.attr.mouse.out =
#			attribute onmouseout { string }
#	
#	scripting.attr.keyboard =
#		(	scripting.attr.keyboard.press?
#		&	scripting.attr.keyboard.down?
#		&	scripting.attr.keyboard.up?
#		)
#		scripting.attr.keyboard.press =
#			attribute onkeypress { string }
#		scripting.attr.keyboard.down =
#			attribute onkeydown { string }
#		scripting.attr.keyboard.up =
#			attribute onkeyup { string }
#	
#	
#	scripting.attr.focus =
#		(	scripting.attr.focus.gain?
#		&	scripting.attr.focus.lose?
#		)
#		scripting.attr.focus.gain =
#			attribute onfocus { string }
#		scripting.attr.focus.lose =
#			attribute onblur { string }
#	
#	scripting.attr.loading =
#		(	scripting.attr.loading.load?
#		&	scripting.attr.loading.unload?
#		)
#		scripting.attr.loading.load =
#			attribute onload { string }
#		scripting.attr.loading.unload =
#			attribute onunload { string }


# #####################################################################
# Event Handler Attribute Assignments

#	body.attrs   &= scripting.attr.loading

--- NEW FILE: ruby.rnc ---
datatypes w = "http://whattf.org/datatype-draft"
namespace local = ""

# #####################################################################
##  RELAX NG Schema for HTML 5: Ruby                                  #
# #####################################################################

#######################################################################

## Ruby Annotation: <ruby>

	ruby.elem =
		element ruby { ruby.inner & ruby.attrs }
	ruby.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	ruby.inner =
		(  (  common.inner.phrasing
		   ,  (  rt.elem
		      |  (  rp.elem
		         ,  rt.elem
		         ,  rp.elem
		         )
		      )
		   )+
		)

	common.elem.phrasing |= ruby.elem

## Ruby Text: <rt>

	rt.elem =
		element rt { rt.inner & rt.attrs }
	rt.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	rt.inner =
		( common.inner.phrasing )
	
## Ruby Parenthesis: <rp>

	rp.elem =
		element rp { rp.inner & rp.attrs }
	rp.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	rp.inner =
		( common.inner.phrasing )

--- NEW FILE: phrase.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Phrase Markup                         #
# #####################################################################

## Contextual Hyperlink: <a>

	a.elem.phrasing =
		element a { a.inner.phrasing & a.attrs }
	a.elem.flow =
		element a { a.inner.flow & a.attrs }
	a.attrs =
		(	common.attrs
		& a.attrs.name?
		& a.attrs.href?
		& a.attrs.target?
		& a.attrs.rel?
		& a.attrs.hreflang?
		& a.attrs.media?
		& a.attrs.type?
		& a.attrs.ping?
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.link
			)?
		)
		a.attrs.name =
		  attribute name {
		    common.data.id # XXX not what the spec says
		  }
		a.attrs.href =
		  attribute href {
		    common.data.uri
		  }
		a.attrs.target =
		  attribute target {
		    common.data.browsing-context-name-or-keyword
		  }
		a.attrs.rel =
		  attribute rel {
		    common.data.tokens
		  }
		a.attrs.hreflang =
		  attribute hreflang {
		    common.data.langcode
		  }
		a.attrs.media =
		  attribute media {
		    common.data.mediaquery
		  }
		a.attrs.type =
		  attribute type {
		    common.data.mimetype
		  }
		a.attrs.ping =
		  attribute ping {
		    common.data.uris
		  } & v5only

	a.inner.phrasing =
		( common.inner.phrasing )
	a.inner.flow =
		( common.inner.flow )

	common.elem.phrasing |= a.elem.phrasing
	common.elem.flow |= a.elem.flow

## Emphatic Stress: <em>

	em.elem =
		element em { em.inner & em.attrs }
	em.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	em.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= em.elem

## Strong Importance: <strong>

	strong.elem =
		element strong { strong.inner & strong.attrs }
	strong.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	strong.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= strong.elem

## Small Print and Side Comments: <small>

	small.elem =
		element small { small.inner & small.attrs }
	small.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	small.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= small.elem

## Marked (Highlighted) Text: <mark>

	mark.elem =
		element mark { mark.inner & mark.attrs }
		& v5only
	mark.attrs =
		( common.attrs )
	mark.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= mark.elem

## Abbreviation: <abbr>

	abbr.elem =
		element abbr { abbr.inner & abbr.attrs }
	abbr.attrs =
		(	common.attrs
		#	abbr.attrs.title included in common.attrs
		&	common.attrs.aria?
		)
	abbr.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= abbr.elem

## Defining Instance: <dfn>

	dfn.elem =
		element dfn { dfn.inner & dfn.attrs }
	dfn.attrs =
		(	common.attrs
		#	dfn.attrs.title included in common.attrs
		&	common.attrs.aria?
		)
	dfn.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= dfn.elem

## Italic: <i>

	i.elem =
		element i { i.inner & i.attrs }
	i.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	i.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= i.elem

## Bold: <b>

	b.elem =
		element b { b.inner & b.attrs }
	b.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	b.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= b.elem

## Code Fragment: <code>

	code.elem =
		element code { code.inner & code.attrs }
	code.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	code.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= code.elem

## Variable or Placeholder: <var>

	var.elem =
		element var { var.inner & var.attrs }
	var.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	var.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= var.elem

## (Sample) Output: <samp>

	samp.elem =
		element samp { samp.inner & samp.attrs }
	samp.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	samp.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= samp.elem

## User Input: <kbd>

	kbd.elem =
		element kbd { kbd.inner & kbd.attrs }
	kbd.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	kbd.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= kbd.elem

## Superscript: <sup>

	sup.elem =
		element sup { sup.inner & sup.attrs }
	sup.attrs =
		( common.attrs )
	sup.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= sup.elem

## Subscript: <sub>

	sub.elem =
		element sub { sub.inner & sub.attrs }
	sub.attrs =
		( common.attrs )
	sub.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= sub.elem

## Quotation: <q>

	q.elem =
		element q { q.inner & q.attrs }
	q.attrs =
		(	common.attrs
		&	q.attrs.cite?
		&	common.attrs.aria?
		)
		q.attrs.cite =
			attribute cite {
				common.data.uri
			}
	q.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= q.elem

## Title of Work: <cite>

	cite.elem =
		element cite { cite.inner & cite.attrs }
	cite.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	cite.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= cite.elem

## Generic Span: <span>

	span.elem =
		element span { span.inner & span.attrs }
	span.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	span.inner =
		( common.inner.phrasing ) # REVISIT allow ol and ul?

	common.elem.phrasing |= span.elem

## Bidirectional Override: <bdo>

	bdo.elem =
		element bdo { bdo.inner & bdo.attrs }
	bdo.attrs =
		( common.attrs ) # dir required in Schematron
	bdo.inner =
		( common.inner.phrasing )

	common.elem.phrasing |= bdo.elem

## Line Break: <br>

	br.elem =
		element br { br.inner & br.attrs }
	br.attrs =
		( common.attrs )
	br.inner =
		( empty )

	common.elem.phrasing |= br.elem

--- NEW FILE: web-forms2-scripting.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Web Forms 2.0 Scripting               #
# #####################################################################

	scripting.attr.form.formchange =
		attribute onformchange { string }

	scripting.attr.form.forminput =
		attribute onforminput { string }

#	output.attrs &=
#		(	scripting.attr.form.formchange?
#		&	scripting.attr.form.forminput?
#		&	scripting.attr.form.change?
#		)

--- NEW FILE: structural.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Block Markup Added in HTML5           #
# #####################################################################

## Section: <section>

	section.elem =
		element section { section.inner & section.attrs }
	section.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.region?
		)
	section.inner =
		(	style.elem.scoped*
		,	common.inner.flow 
		)

	common.elem.flow |= section.elem

## Navigational Links: <nav>

	nav.elem =
		element nav { nav.inner & nav.attrs }
	nav.attrs =
		(	common.attrs
		&	( common.attrs.aria.implicit.region
		  | common.attrs.aria.landmark.navigation
		  )?
		)
	nav.inner =
		( common.inner.flow )

	common.elem.flow |= nav.elem

## Article: <article>

	article.elem =
		element article { article.inner & article.attrs }
	article.attrs =
		(	common.attrs
		&	article.attrs.pubdate?
		&	( common.attrs.aria.implicit.region
		  | common.attrs.aria.landmark.article
		  | common.attrs.aria.landmark.main
		  | common.attrs.aria.landmark.document
		  )?
		)
		article.attrs.pubdate =
			attribute pubdate {
				common.data.datetime
			}
	article.inner =
		(	style.elem*
		,	common.inner.flow 
		)
		
	common.elem.flow |= article.elem

## Tangential Aside: <aside>

	aside.elem =
		element aside { aside.inner & aside.attrs }
	aside.attrs =
		(	common.attrs
		&	( common.attrs.aria.implicit.region
		  | common.attrs.aria.landmark.complementary
		  )?
		)
	aside.inner =
		(	style.elem*
		,	common.inner.flow 
		)

	common.elem.flow |= aside.elem

## Header: <header>

	header.elem =
		element header { header.inner & header.attrs }
	header.attrs =
		(	common.attrs
		&	( common.attrs.aria.implicit.region
		  | common.attrs.aria.landmark.banner
		  )?
		)
	header.inner =
		( common.inner.flow )

	common.elem.flow |= header.elem

## Footer: <footer>

	footer.elem =
		element footer { footer.inner & footer.attrs }
	footer.attrs =
		(	common.attrs
		&	( common.attrs.aria.implicit.region
		  | common.attrs.aria.landmark.contentinfo
		  )?
		)
	footer.inner =
		( common.inner.flow )

	common.elem.flow |= footer.elem

## Dialog: <dialog>

	dialog.elem =
		element dialog { dialog.inner & dialog.attrs }
	dialog.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.region?
		)
	dialog.inner =
		(	(	dt.elem
			,	dd.elem
			)*
		)

	common.elem.flow |= dialog.elem

--- NEW FILE: media.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Advanced Embedded Content             #
# #####################################################################

## Source: <source>

	source.elem =
		element source { source.inner & source.attrs }
	source.attrs =
		(	common.attrs
		&	source.attrs.src
		&	source.attrs.type?
		&	source.attrs.media?
		)
		source.attrs.src =
			attribute src {
				common.data.uri
			}
		source.attrs.type =
			attribute type {
				common.data.mimetype
			}
		source.attrs.media =
			attribute media {
				common.data.mediaquery
			}
	source.inner =
		( empty )

## Video: <video>

	video.elem.flow =
		element video { video.inner.flow & video.attrs }
	video.elem.phrasing =
		element video { video.inner.phrasing & video.attrs }
	video.attrs =
		(	common.attrs
		&	video.attrs.autoplay?
		&	video.attrs.autobuffer?
		&	video.attrs.controls?
		&	video.attrs.loop?
		&	video.attrs.poster?
		&	video.attrs.height?
		&	video.attrs.width?
		)
		video.attrs.poster =
			attribute poster {
				common.data.uri
			}
		video.attrs.height =
			attribute height {
				common.data.integer.positive
			}
		video.attrs.width =
			attribute width {
				common.data.integer.positive
			}
		video.attrs.src =
			attribute src {
				common.data.uri
			}
	video.inner.flow =
		(	(	video.attrs.src
			|	source.elem*
			)
		,	common.inner.flow
		)
	video.inner.phrasing =
		(	(	video.attrs.src
			|	source.elem*
			)
		,	common.inner.phrasing
		)

	common.elem.flow |= video.elem.flow
	common.elem.phrasing |= video.elem.phrasing

## Audio: <audio>

	audio.elem.flow =
		element audio { audio.inner.flow & audio.attrs }
	audio.elem.phrasing =
		element audio { audio.inner.phrasing & audio.attrs }
	audio.attrs =
		(	common.attrs
		&	audio.attrs.autoplay?
		&	audio.attrs.autobuffer?
		&	audio.attrs.controls?
		&	audio.attrs.loop?
		)
		audio.attrs.src =
			attribute src {
				common.data.uri
			}
	audio.inner.flow =
		(	(	audio.attrs.src
			|	source.elem*
			)
		,	common.inner.flow
		)
	audio.inner.phrasing =
		(	(	audio.attrs.src
			|	source.elem*
			)
		,	common.inner.phrasing
		)

	common.elem.flow |= audio.elem.flow
	common.elem.phrasing |= audio.elem.phrasing

## Captioned Content: <figure>

	figure.elem =
		element figure { figure.inner & figure.attrs }
	figure.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.img?
		)
	figure.inner =
		(	( legend.elem, common.inner.flow )
		|	( common.inner.flow, legend.elem? )
		)

	common.elem.flow |= figure.elem

--- NEW FILE: tables.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Tables                                #
# #####################################################################

# #####################################################################
## Table Envelope

## Table Datatypes

#	tables.data.multilen =
#		(	common.data.integer.positive
#		|	common.data.percent
#		|	xsd:token { pattern = "[0-9]+\*" } #REVISIT should this one be string? 
#		)

## Table Alignment Attributes

	tables.attrs.alignment =
		(	tables.attrs.align?
		&	tables.attrs.char?
		&	tables.attrs.valign?
		)
		tables.attrs.align =
			attribute align {
				(	w:string "left" 
				|	w:string "center"
				|	w:string "right"
				|	w:string "justify"
				|	w:string "char"
				)
			}
		tables.attrs.char =
			attribute char {
				xsd:string { pattern = "." }
			}
		tables.attrs.valign =
			attribute valign {
				(	w:string "top"
				|	w:string "middle"
				|	w:string "bottom"
				|	w:string "baseline"
				)
			}

## Data Table: <table>

	table.elem =
		element table { table.inner & table.attrs }
	table.attrs =
		(	common.attrs
		&	table.attrs.summary? # obsolete
		&	common.attrs.aria?
		)
		table.attrs.summary =
			attribute summary {
				string
			}
	table.inner =
		(	caption.elem?
		,	colgroup.elem*
		,	thead.elem?
		,	(	(	tfoot.elem
				,	( tbody.elem* | tr.elem+ )
				)
			|	(	( tbody.elem* | tr.elem+ )
				,	tfoot.elem?
				)
			)
		) 

	common.elem.flow |= table.elem

## Table Caption: <caption>

	caption.elem =
		element caption { caption.inner & caption.attrs }
	caption.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.region?
		)
	caption.inner =
		( common.inner.phrasing )

# #####################################################################
## Table Super Structure

## Table Column Group: <colgroup>

	colgroup.elem =
		element colgroup { colgroup.inner & colgroup.attrs }
	colgroup.attrs =
		( common.attrs )
		colgroup.attrs.span =
			attribute span {
				common.data.integer.positive
			}
	colgroup.inner =
		(	col.elem*
		|	colgroup.attrs.span?
		)

## Table Column: <col>

	col.elem =
		element col { col.inner & col.attrs }
	col.attrs =
		(	common.attrs
		&	col.attrs.span?
		)
		col.attrs.span =
			attribute span {
				common.data.integer.positive
			}
	col.inner =
		( empty )

## Table Header Row Group

	thead.elem =
		element thead { thead.inner & thead.attrs }
	thead.attrs =
		( common.attrs )
	thead.inner =
		( tr.elem* )

## Table Footer Row Group

	tfoot.elem =
		element tfoot { tfoot.inner & tfoot.attrs }
	tfoot.attrs =
		( common.attrs )
	tfoot.inner =
		( tr.elem* )

## Table Row Group

	tbody.elem =
		element tbody { tbody.inner & tbody.attrs }
	tbody.attrs =
		( common.attrs )
	tbody.inner =
		( tr.elem* )

# #####################################################################
## Cell Structure

## Table Row

	tr.elem =
		element tr { tr.inner & tr.attrs }
	tr.attrs =
		(	common.attrs
		&	common.attrs.aria?
		)
	tr.inner =
		( ( td.elem | th.elem )* )

		tables.attrs.abbr =
			attribute abbr {
				text
			}

## Table Data Cell: <td>

	td.elem =
		element td { td.inner & td.attrs }
	td.attrs =
		(	common.attrs
		&	td.attrs.colspan?
		&	td.attrs.rowspan?
		&	td.attrs.headers?
#		&	tables.attrs.alignment
		&	common.attrs.aria?
		)
		td.attrs.colspan =
			attribute colspan {
				common.data.integer.positive
			}
		td.attrs.rowspan =
			attribute rowspan {
				common.data.integer.non-negative
			}
		td.attrs.headers =
			attribute headers {
				common.data.idrefs
			}
	td.inner =
		( common.inner.flow )

## Table Header Cells: <th>

	th.elem =
		element th { th.inner & th.attrs }
	th.attrs =
		(	common.attrs
		&	th.attrs.scope?
		&	th.attrs.colspan?
		&	th.attrs.rowspan?
		&	th.attrs.headers?
#		&	tables.attrs.alignment
		&	common.attrs.aria.implicit.th?
		)
		th.attrs.scope =
			attribute scope {
				(	w:string "row"
				|	w:string "col"
				|	w:string "rowgroup"
				|	w:string "colgroup"
				)
			}
		th.attrs.colspan =
			attribute colspan {
				common.data.integer.positive
			}
		th.attrs.rowspan =
			attribute rowspan {
				common.data.integer.non-negative
			}
		th.attrs.headers =
			attribute headers {
				common.data.idrefs
			}
	th.inner =
		( common.inner.flow )

--- NEW FILE: sectional.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Sectioning Markup                     #
# #####################################################################

# #####################################################################
## Headings

## Heading (Rank 1): <h1>

	h1.elem =
		element h1 { h1.inner & h1.attrs }
	h1.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h1.inner =
		( common.inner.phrasing )

	common.elem.flow |= h1.elem

## Heading (Rank 2): <h2>

	h2.elem =
		element h2 { h2.inner & h2.attrs }
	h2.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h2.inner =
		( common.inner.phrasing )

	common.elem.flow |= h2.elem

## Heading (Rank 3): <h3>

	h3.elem =
		element h3 { h3.inner & h3.attrs }
	h3.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h3.inner =
		( common.inner.phrasing )

	common.elem.flow |= h3.elem

## Heading (Rank 4): <h4>

	h4.elem =
		element h4 { h4.inner & h4.attrs }
	h4.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h4.inner =
		( common.inner.phrasing )

	common.elem.flow |= h4.elem

## Heading (Rank 5): <h5>

	h5.elem =
		element h5 { h5.inner & h5.attrs }
	h5.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h5.inner =
		( common.inner.phrasing )

	common.elem.flow |= h5.elem

## Heading (Rank 6): <h6>

	h6.elem =
		element h6 { h6.inner & h6.attrs }
	h6.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	h6.inner =
		( common.inner.phrasing )

	common.elem.flow |= h6.elem

## Heading Group: <hgroup>

	hgroup.elem =
		element hgroup { hgroup.inner & hgroup.attrs }
	hgroup.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.structure?
		)
	hgroup.inner =
		(	h1.elem
		|	h2.elem
		|	h3.elem
		|	h4.elem
		|	h5.elem
		|	h6.elem
		)+

	common.elem.flow |= hgroup.elem

# #####################################################################
## Section Meta

## Contact Info: <address>

	address.elem =
		element address { address.inner & address.attrs }
	address.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.region?
		)
	address.inner = 
		( common.inner.flow )

	common.elem.flow |= address.elem

# #####################################################################
## Quotations	

## Block Quotes: <blockquote>

	blockquote.elem =
		element blockquote { blockquote.inner & blockquote.attrs }
	blockquote.attrs =
		(	common.attrs
		&	blockquote.attrs.cite?
		&	common.attrs.aria?
		)
		blockquote.attrs.cite =
			attribute cite {
				common.data.uri
			}
	blockquote.inner =
		( common.inner.flow )

	common.elem.flow |= blockquote.elem

--- NEW FILE: html5exclusions.rnc ---
default namespace = "http://www.w3.org/1999/xhtml"
# #####################################################################
##  RELAX NG Schema for (X)HTML 5: Exclusions                         #
# #####################################################################

  ## This file is unmaintained. Please use assertions.sch instead.
  
# #####################################################################
## Schema Framework & Parameters

	start = normal.elem.all-inclusive

# #####################################################################
##  Normal Element Patterns

## Any attribute from any namespace

	normal.attr.anything =
		attribute * { text }*

## Any element from any namespace except exceptional elements,
## but allowing those elements as descendants

	normal.elem.all =
		element * - (dfn) {
			normal.elem.all-inclusive
		}

## Any element from any namespace including exceptional elements

	normal.elem.all-inclusive =
		wildcard.elem.exclude-all | dfn.elem.exclude-self


# #####################################################################
##  Exclusion Element Patterns

  # exclude all exceptional elements from the name classes;
  # list them explicitly in content models instead

normal.elem.exclude-dfn =
	element * - (dfn) {
		normal.elem.exclude-dfn
	}

dfn.elem.exclude-self =
	element dfn {
		(	normal.attr.anything
		&	normal.elem.exclude-dfn
		)
	}

# FIXME this part was cut off -- hsivonen
wildcard.elem.exclude-all = 
	notAllowed

#FIXME no nested forms in HTML-serializable docs

#FIXME no nested labels

#FIXME no blockquote inside header or footer

#FIXME exactly one hn in header

--- NEW FILE: data.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Static Data Markup                    #
# #####################################################################

## Time: <time>

	time.elem =
		element time { time.inner & time.attrs }
	time.attrs =
		(	common.attrs
		&	time.attrs.datetime?
		)
		time.attrs.datetime =
			attribute datetime {
				common.data.date-or-time #REVISIT check format
			}
	time.inner =
		( common.inner.phrasing ) #Cannot enforce textContent format here

	common.elem.phrasing |= time.elem

## Scalar Gauge: <meter>

	meter.elem =
		element meter { meter.inner & meter.attrs }
	meter.attrs =
		(	common.attrs
		&	meter.attrs.value?
		&	meter.attrs.min?
		&	meter.attrs.low?
		&	meter.attrs.high?
		&	meter.attrs.max?
		&	meter.attrs.optimum?
		)
		meter.attrs.value =
			attribute value {
				common.data.float
			}
		meter.attrs.min =
			attribute min {
				common.data.float
			}
		meter.attrs.low =
			attribute low {
				common.data.float
			}
		meter.attrs.high =
			attribute high {
				common.data.float
			}
		meter.attrs.max =
			attribute max {
				common.data.float
			}
		meter.attrs.optimum =
			attribute optimum {
				common.data.float
			}
	meter.inner =
		( common.inner.phrasing ) #Cannot enforce textContent format here

	common.elem.phrasing |= meter.elem

--- NEW FILE: web-forms-scripting.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Web Forms 1.0 Scripting               #
# #####################################################################

	scripting.attr.form.select =
		attribute onselect { string }
	scripting.attr.form.change =
		attribute onchange { string }

#	input.text.attrs &=
#		(	scripting.attr.form.select?
#		)

#	shared-form.attrs &=
#		(	scripting.attr.form.change?
#		)

#	form.attrs &=
#		(	scripting.attr.form.reset?
#		&	scripting.attr.form.submit?
#		)
		scripting.attr.form.submit =
			attribute onsubmit { string }
		scripting.attr.form.reset =
			attribute onreset { string } 
		
		

--- NEW FILE: aria.rnc ---
# #####################################################################
##	RELAX NG Schema for HTML 5: Accessible Rich Internet Applications #
# #####################################################################

# #####################################################################
## ARIA

## Global states and properties

aria.global = 
	(	aria.prop.atomic?
	&	aria.state.busy?
	&	aria.prop.controls?
	&	aria.prop.describedby?
	&	aria.state.disabled?
	&	aria.state.dropeffect?
	&	aria.prop.flowto?
	&	aria.state.grabbed?
	&	aria.prop.haspopup?
[...976 lines suppressed...]
			attribute role { string "treegrid" }
	
	common.attrs.aria |= aria.treegrid

## treeitem
	aria.treeitem =
		(	aria.role.treeitem
		&	aria.state.checked?
		&	aria.state.expanded?
		&	aria.prop.level?
		&	aria.prop.posinset?
		&	aria.state.selected?
		&	aria.prop.setsize?
		)
		aria.role.treeitem = 
			attribute role { string "treeitem" }
	
	common.attrs.aria |= aria.treeitem



--- NEW FILE: applications.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Web Application Features              #
# #####################################################################

## Context Menu: contextmenu

	common.attrs.contextmenu =
		attribute contextmenu {
			common.data.idref
		}

## Editable Content: contenteditable

	common.attrs.contenteditable =
		attribute contenteditable {
			w:string "true" | w:string "false" | w:string ""
		}

## Draggable Element: draggable

	common.attrs.draggable =
		attribute draggable {
			w:string "true" | w:string "false"
		}

## Hidden Element: hidden

	common.attrs.hidden =
		attribute hidden {
			w:string "hidden" | w:string ""
		}

## Spellchecking and grammar checking: spellcheck

	common.attrs.spellcheck =
		attribute spellcheck{
			w:string "true" | w:string "false" | w:string ""
		}

## Application Cache: manifest

	html.attrs.manifest =
		attribute manifest {
			common.data.uri
		}
		
	html.attrs &= html.attrs.manifest?

## Progess Indicator: <progress>

	progress.elem =
		element progress { progress.inner & progress.attrs }
	progress.attrs =
		(	common.attrs
		&	progress.attrs.value?
		&	progress.attrs.max?
		)
		progress.attrs.value =
			attribute value {
				common.data.float.non-negative
			}
		progress.attrs.max =
			attribute max {
				common.data.float.positive
			}
	progress.inner =
		( common.inner.phrasing ) #Cannot enforce textContent format here

	common.elem.phrasing |= progress.elem

## Command with an associated action: <command type='command'>

	command.command.elem =
		element command { command.inner & command.command.attrs }
	command.command.attrs =
		(	common.attrs
		&	command.command.attrs.type?
		&	command.command.attrs.label?
		&	command.command.attrs.icon?
		&	command.command.attrs.disabled?
		)
		command.command.attrs.type =
			attribute type {
				w:string "command"
			}
		command.command.attrs.label =
			attribute label {
				string
			}
		command.command.attrs.icon =
			attribute icon {
				common.data.uri
			}
		command.command.attrs.disabled =
			attribute disabled {
				w:string "disabled" | w:string ""
			}
	command.elem = command.command.elem

## Selection of one item from a list of items: <command type='radio'>

	command.radio.elem =
		element command { command.inner & command.radio.attrs }
	command.radio.attrs =
		(	common.attrs
			&	(	command.radio.attrs.type
				&	command.radio.attrs.radiogroup #REVISIT taking liberties here
				&	command.radio.attrs.checked?
				)
			&	command.radio.attrs.label?
			&	command.radio.attrs.icon?
			&	command.radio.attrs.disabled?
		)
		command.radio.attrs.type =
			attribute type {
				w:string "radio"
			}
		command.radio.attrs.radiogroup =
			attribute radiogroup {
				string #REVISIT need special format here?
			}
		command.radio.attrs.checked =
			attribute checked {
				w:string "checked" | w:string ""
			}
		command.radio.attrs.label =
			attribute label {
				string
			}
		command.radio.attrs.icon =
			attribute icon {
				common.data.uri
			}
		command.radio.attrs.disabled =
			attribute disabled {
				w:string "disabled" | w:string ""
			}
	command.elem |= command.radio.elem

## State or option that can be toggled: <command type='checkbox'>

	command.checkbox.elem =
		element command { command.inner & command.checkbox.attrs }
	command.checkbox.attrs =
		(	common.attrs
			&	(	command.checkbox.attrs.type
				&	command.checkbox.attrs.checked?
				)
			&	command.checkbox.attrs.label?
			&	command.checkbox.attrs.icon?
			&	command.checkbox.attrs.disabled?
			)
		command.checkbox.attrs.type =
			attribute type {
				w:string "checkbox"
			}
		command.checkbox.attrs.checked =
			attribute checked {
				w:string "checked" | w:string ""
			}
		command.checkbox.attrs.label =
			attribute label {
				string
			}
		command.checkbox.attrs.icon =
			attribute icon {
				common.data.uri
			}
		command.checkbox.attrs.disabled =
			attribute disabled {
				w:string "disabled" | w:string ""
			}
	command.elem |= command.checkbox.elem

	command.inner =
		( empty )
	
	common.elem.metadata |=
		command.elem
	common.elem.phrasing |= command.elem

## Menu: <menu>

	menu.elem =
		element menu { menu.inner & menu.attrs }
	menu.attrs =
		(	common.attrs
		&	menu.attrs.type?
		&	menu.attrs.label?
		)
		menu.attrs.type =
			attribute type {
				w:string "toolbar" | w:string "context"
			}
		menu.attrs.label =
			attribute label {
				string
			}
	menu.inner =
		(	mli.elem*
		|	common.inner.flow
		)
	
	common.elem.flow |= menu.elem
	# REVISIT allow nested menus

## Menu Item: <li>

	mli.elem =
		element li { mli.inner & mli.attrs }
	mli.attrs =
		( common.attrs )
	mli.inner =
		( common.inner.flow )
	
## Canvas for Dynamic Graphics: <canvas>

	canvas.elem.flow =
		element canvas { canvas.inner.flow & canvas.attrs }
	canvas.elem.phrasing =
		element canvas { canvas.inner.phrasing & canvas.attrs }
	canvas.attrs =
		(	common.attrs
		&	canvas.attrs.height?
		&	canvas.attrs.width?
		&	common.attrs.aria?
		)
		canvas.attrs.height =
			attribute height {
				common.data.integer.non-negative
			}
		canvas.attrs.width =
			attribute width {
				common.data.integer.non-negative
			}
	canvas.inner.flow =
		( common.inner.flow )
	canvas.inner.phrasing =
		( common.inner.phrasing )
	
	common.elem.flow |= canvas.elem.flow
	common.elem.phrasing |= canvas.elem.phrasing

## Additional On-Demand Information: <details>

	details.elem =
		element details { details.inner & details.attrs }
	details.attrs =
		(	common.attrs
		&	details.attrs.open?
		&	common.attrs.aria.implicit.region?
		)
		details.attrs.open =
			attribute open {
				w:string "open" | w:string ""
			}
	details.inner =
		(	legend.elem
		,	common.inner.flow 
		)
	
	common.elem.flow |= details.elem

--- NEW FILE: web-forms.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Web Forms 1.0 markup                  #
# #####################################################################

## Shared attributes for form controls

	common-form.attrs =
		(	common-form.attrs.name?
		&	common-form.attrs.disabled?
		&	common-form.attrs.form?
		)
		
	common-form.attrs.name = 
		attribute name {
			string #REVISIT should this be restricted somehow? No & and = perhaps?
		}

	common-form.attrs.disabled = 
		attribute disabled {
			w:string "disabled" | w:string ""
		}

	shared-form.attrs.readonly = 
		attribute readonly {
			w:string "readonly" | w:string ""
		}

	shared-form.attrs.maxlength = 
		attribute maxlength {
			common.data.integer.positive #REVISIT should this be non-negative?
		}

	shared-form.attrs.size = 
		attribute size {
			common.data.integer.positive
		}
	
	# REVISIT tabindex goes in common.attrs

## Shared attributes for <input>
	
	input.attrs.checked = 
		attribute checked {
			w:string "checked" | w:string ""
		}

## Text Field: <input type='text'>

	input.text.elem = 
		element input { input.text.attrs }
	input.text.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.text.attrs.type?
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.size?
		&	input.text.attrs.value? 
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.input
			)?
		)		
		input.text.attrs.type = 
			attribute type {
				w:string "text"
			}
		input.text.attrs.value =
			attribute value {
				string #REVISIT "nominally" free of line breaks?
			}
		
	input.elem = input.text.elem

## Password Field: <input type='password'>

	input.password.elem = 
		element input { input.password.attrs }
	input.password.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.password.attrs.type
		&	shared-form.attrs.maxlength? 
		&	shared-form.attrs.readonly? 
		&	shared-form.attrs.size?
		&	input.password.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)
		input.password.attrs.type = 
			attribute type {
				w:string "password"
			}
		input.password.attrs.value =
			attribute value {
				string #REVISIT "nominally" free of line breaks?			
			}
		
	input.elem |= input.password.elem
		
## Checkbox: <input type='checkbox'>

	input.checkbox.elem = 
		element input { input.checkbox.attrs }
	input.checkbox.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.checkbox.attrs.type
		&	input.attrs.checked? 
		&	input.checkbox.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)
		input.checkbox.attrs.type = 
			attribute type {
				w:string "checkbox"
			}
		input.checkbox.attrs.value =
			attribute value {
				string #REVISIT require non-empty value?
			}
		
	input.elem |= input.checkbox.elem
	
## Radiobutton: <input type='radio'>

	input.radio.elem = 
		element input { input.radio.attrs }
	input.radio.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.radio.attrs.type
		&	input.attrs.checked? 
		&	input.radio.attrs.value? 
		&	common.attrs.aria.implicit.input?
		)
		input.radio.attrs.type = 
			attribute type {
				w:string "radio"
			}
		input.radio.attrs.value =
			attribute value {
				string #REVISIT require non-empty value?
			}
		
	input.elem |= input.radio.elem
	
## Scripting Hook Button: <input type='button'>

	input.button.elem = 
		element input { input.button.attrs }
	input.button.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.button.attrs.type
		&	input.button.attrs.value? 
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.button
			)?
		)
		input.button.attrs.type = 
			attribute type {
				w:string "button"
			}
		input.button.attrs.value =
			attribute value {
				string #REVISIT require non-empty value?
			}
		
	input.elem |= input.button.elem
	#REVISIT should this be enabled by a scripting module only?
	
## Submit Button: <input type='submit'>

	input.submit.elem = 
		element input { input.submit.attrs }
	input.submit.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.submit.attrs.type
		&	input.submit.attrs.value? 
		&	common.attrs.aria.implicit.button?
		)
		input.submit.attrs.type = 
			attribute type {
				w:string "submit"
			}
		input.submit.attrs.value =
			attribute value {
				string #REVISIT require non-empty value?
			}
		
	input.elem |= input.submit.elem
		
## Reset Button: <input type='reset'>

	input.reset.elem = 
		element input { input.reset.attrs }
	input.reset.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.reset.attrs.type
		&	input.reset.attrs.value? 
		&	common.attrs.aria.implicit.button?
		)
		input.reset.attrs.type = 
			attribute type {
				w:string "reset"
			}
		input.reset.attrs.value =
			attribute value {
				string #REVISIT require non-empty value?
			}
		
	input.elem |= input.reset.elem
	# REVISIT does reset make sense outside a form?
		
## File Upload: <input type='file'>

	input.file.elem = 
		element input { input.file.attrs }
	input.file.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.file.attrs.type
		&	input.file.attrs.accept?
		&	common.attrs.aria.implicit.input?
		)
		input.file.attrs.type = 
			attribute type {
				w:string "file"
			}
		input.file.attrs.accept = 
			attribute accept {
				form.data.mimetypelist
			}

	input.elem |= input.file.elem
	
## Hidden String: <input type='hidden'>

	input.hidden.elem = 
		element input { input.hidden.attrs }
	input.hidden.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.hidden.attrs.type
		&	input.hidden.attrs.value? 
		)
		input.hidden.attrs.type = 
			attribute type {
				w:string "hidden"
			}
		input.hidden.attrs.value =
			attribute value {
				string
			}
		
	input.elem |= input.hidden.elem
		
## Image Submit Button: <input type='image'>

	input.image.elem = 
		element input { input.image.attrs }
	input.image.attrs = 
		(	common.attrs
		&	common-form.attrs
		&	input.image.attrs.type
		&	input.image.attrs.alt 
		&	input.image.attrs.src? 
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.button
			)?
		)	
		input.image.attrs.type = 
			attribute type {
				w:string "image"
			}
		input.image.attrs.alt = 
			attribute alt {
				string # XXX non-empty
			}
		input.image.attrs.src = 
			attribute src {
				common.data.uri
			}
	
	input.elem |= input.image.elem
	
	common.elem.phrasing |= input.elem

## Text Area: <textarea>

	textarea.elem =
		element textarea { textarea.inner & textarea.attrs }
	textarea.attrs =
		(	common.attrs
		&	common-form.attrs
		&	shared-form.attrs.readonly?
		&	common.attrs.aria.implicit.input?
		#FIXME onfocus, onblur, onselect,onchange
		)
		textarea.attrs.cols = 
			attribute cols {
				common.data.integer.positive
			}
		textarea.attrs.rows = 
			attribute rows {
				common.data.integer.positive
			}
	textarea.inner =
		( replaceable-character-data )

	common.elem.phrasing |= textarea.elem

# Due to limitations with interleave, handling single/multiple selection
# enforcement in RELAX NG seems to be possible but really awkward.
# Tried it. Leaving it to Schematron.

## Select menu option: <option selected>

	option.elem =
		element option { option.inner & option.attrs }
	option.attrs =
		(	common.attrs
		&	common-form.attrs.disabled?
		&	option.attrs.selected?
		&	option.attrs.label?
		&	option.attrs.value?
		&	common.attrs.aria.implicit.input?
		)
		option.attrs.selected =
			attribute selected {
				w:string "selected" | w:string ""
			}
		option.attrs.label =
			attribute label {
				string
			}		
		option.attrs.value =
			attribute value {
				string
			}		
	option.inner =
		( text )

## Option Group: <optgroup>

	optgroup.elem =
		element optgroup { optgroup.inner & optgroup.attrs }
	optgroup.attrs = 
		(	common.attrs
		&	optgroup.attrs.label
		&	common-form.attrs.disabled?
		)
		optgroup.attrs.label =
			attribute label {
				string
			}
	optgroup.inner =
		( option.elem* )

## Selection Menu: <select>

	select.elem =
		element select { select.inner & select.attrs }	
	select.attrs =
		(	common.attrs
		&	common-form.attrs
		&	select.attrs.size?
		&	select.attrs.multiple?
		# FIXME onfocus, onblur, onchange
		)
		select.attrs.size =
			attribute size {
				common.data.integer.positive
			}
		select.attrs.multiple =
			attribute multiple {
				w:string "multiple" | w:string ""
			}
	select.inner =
		(	optgroup.elem*
		&	option.elem*
		)

	common.elem.phrasing |= select.elem
	
## Shared Definitions for Complex Button
	
	button.inner = 
		( common.inner.flow )
	
## Complex Submit Button: <button type='submit'>

	button.submit.elem =
		element button { button.inner & button.submit.attrs }	
	button.submit.attrs =
		(	common.attrs
		&	common-form.attrs
		&	button.submit.attrs.type?
		&	button.submit.attrs.value?
		&	common.attrs.aria.implicit.button?
		)
		button.submit.attrs.type =
			attribute type {
				w:string "submit"
			}
		button.submit.attrs.value =
			attribute value {
				string
			}

	button.elem = button.submit.elem
	
## Complex Reset Button: <button type='reset'>

	button.reset.elem =
		element button { button.inner & button.reset.attrs }	
	button.reset.attrs =
		(	common.attrs
		&	common-form.attrs
		&	button.reset.attrs.type
		&	button.reset.attrs.value? #REVISIT I guess this still affects the DOM
		&	common.attrs.aria.implicit.button?
		)
		button.reset.attrs.type =
			attribute type {
				w:string "reset"
			}
		button.reset.attrs.value =
			attribute value {
				string
			}

	button.elem |= button.reset.elem
	
## Complex Push Button: <button type='button'>

	button.button.elem =
		element button { button.inner & button.button.attrs }	
	button.button.attrs =
		(	common.attrs
		&	common-form.attrs
		&	button.button.attrs.type
		&	button.button.attrs.value? #REVISIT I guess this still affects the DOM
		&	(	common.attrs.aria
			|	common.attrs.aria.implicit.button
			)?
		)
		button.button.attrs.type =
			attribute type {
				w:string "button"
			}
		button.button.attrs.value =
			attribute value {
				string
			}

	button.elem |= button.button.elem

	common.elem.phrasing |= button.elem

## Form: <form>

	form.elem =
		element form { form.inner & form.attrs }
	form.attrs =
		(	common.attrs
		&	form.attrs.action? #REVISIT Should this be required anyway?
		&	form.attrs.method?
		&	form.attrs.enctype?
		&	common-form.attrs.name?
		&	form.attrs.accept-charset?
		&	common.attrs.aria.implicit.region?
		)
		form.attrs.action =
			attribute action {
				common.data.uri
			}
		form.attrs.method =
			attribute method {
				form.attrs.method.data
			}
			form.attrs.method.data = 
				( w:string "get" | w:string "post" )
		form.attrs.enctype =
			attribute enctype {
				form.attrs.enctype.data
			}
			form.attrs.enctype.data = 
				(	w:string "application/x-www-form-urlencoded" 
				|	w:string "multipart/form-data"
				)
		form.attrs.accept-charset =
			attribute accept-charset {
				form.data.charsetlist
			}	
	form.inner =
		( common.inner.flow )

	common.elem.flow |= form.elem

## Fieldset: <fieldset>

	fieldset.elem =
		element fieldset { fieldset.inner & fieldset.attrs }
	fieldset.attrs =
		(	common.attrs
		&	common.attrs.aria.implicit.group?
		)	
	fieldset.inner =
		(	legend.elem? #REVISIT should this be required?
		,	common.inner.flow
		)

	common.elem.flow |= fieldset.elem
	
## Label: <label>

	label.elem =
		element label { label.inner & label.attrs }
	label.attrs =
		(	common.attrs
		&	label.attrs.for?
		&	common.attrs.aria.implicit.region?
		)
		label.attrs.for =
			attribute for {
				common.data.idref
			}
	label.inner =
		( common.inner.phrasing ) #REVISIT making obvious guess

	common.elem.phrasing |= label.elem


--- NEW FILE: html5.rnc ---
default namespace = "http://www.w3.org/1999/xhtml"
# #####################################################################
##  RELAX NG Schema for HTML 5                                       #
# #####################################################################

  # To validate an HTML 5 document, you must first validate against  #
  # this schema and then ALSO validate against assertions.sch        #

  ## HTML flavor RELAX NG schemas can only be used after the         #
  ## document has been transformed to well-formed XML.               #
  ##   - Insert closing slashes in all empty element tags            #
  ##   - Insert all optional start and end tags                      #
  ##   - Add xmlns "http://www.w3.org/1999/xhtml"                    #
  ##   - Properly escape <script> and <style> CDATA                  #
  ##   - Parse and transform all HTML-only entities to numeric       #
  ##     character references                                        #
  ## Obviously, syntax-checking involving these features cannot be   #
  ## done by the RELAX NG schema and must be checked, along with the #
  ## <!DOCTYPE> requirement, by some other application.              #

# #####################################################################
## Schema Framework & Parameters

include "common.rnc" {
	# XHTML flavor #
		XMLonly = notAllowed
		HTMLonly = empty
	# HTML 4 compat #
		v5only = empty
	# HTML-serializability #
		nonHTMLizable = notAllowed
	# HTML-roundtrippability #
		nonRoundtrippable = notAllowed
}

# #####################################################################
## Language Definitions

start = html.elem

include "meta.rnc"
include "phrase.rnc"
include "block.rnc"
include "sectional.rnc"
include "structural.rnc"
include "revision.rnc"
include "embed.rnc"
include "ruby.rnc"
include "media.rnc"
include "core-scripting.rnc"
include "tables.rnc"
include "form-datatypes.rnc"
include "web-forms.rnc"
include "web-forms2.rnc"
include "applications.rnc"
include "data.rnc"

--- NEW FILE: form-datatypes.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Datatypes related to forms            #
# #####################################################################

## MIME types
		
	form.data.mimetypelist = 
		w:mime-type-list
		
	form.data.charsetlist =
		string # FIXME should be a "a space- and/or comma-delimited 
		       # list of charset values"

## ECMAScript Regular Expression
		
	form.data.pattern = 
		w:pattern
		
## Temporal
		
	form.data.datetime-local =
		w:datetime-local
	
	form.data.date =
		w:date
	
	form.data.month =
		w:month
	
	form.data.week =
		w:week
	
	form.data.time =
		w:time

## Email

	form.data.emailaddress =
		w:email-address

	form.data.emailaddresslist =
		w:email-address-list

## Color

	form.data.color =
		w:color
#		xsd:string {
#			pattern = "#[a-fA-F0-9]{6}"
#		}

--- NEW FILE: microdata.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Microdata                             #
# #####################################################################

common.attrs.microdata =
	(	common.attrs.microdata.item?
	&	common.attrs.microdata.subject?
	&	common.attrs.microdata.itemprop?
	)
	common.attrs.microdata.item =
		attribute item {
			(	w:string ""
			|	common.data.microdata-identifier
			)
		}
	common.attrs.microdata.subject =
		attribute subject {
			common.data.idref
		}
	common.attrs.microdata.itemprop =
		attribute itemprop {
			common.data.microdata-identifier
		}

common.attrs &= common.attrs.microdata

--- NEW FILE: common.rnc ---
datatypes w = "http://whattf.org/datatype-draft"

# #####################################################################
##  RELAX NG Schema for HTML 5: Common Definitions                    #
# #####################################################################


# #####################################################################
##  Language Parameters - redefine in inclusion block as necessary    #
# #####################################################################

## HTML vs. XHTML restrictions

	XMLonly = empty
	HTMLonly = notAllowed

## HTML 4 Compatibility - set to notAllowed to disallow markup introduced in HTML 5
#                         (This only affects mixed-version modules; wholly HTML5
#                          modules should simply be left out of the inclusion list.)

	v5only = empty

## HTML Compatibility Switches - set to notAllowed to disallow

	## XML features that can't be roundtripped HTML <-> XHTML
	#  (xml:base on elements other than <html>)
	nonRoundtrippable = empty

	## XML features that can't be serialized as HTML
	nonHTMLizable = empty

# #####################################################################
##  Wildcards                                                         #
# #####################################################################

## Any attribute from any namespace

	common.attr.anything =
		attribute * { text }*

	replaceable-character-data =
		(	xsd:string {
				pattern = ".*"
			}
		)

	non-replaceable-character-data =
		(	xsd:string {
				pattern = ".*"
			}
		)

# #####################################################################
##  Common Element Classes                                            #
# #####################################################################

## Metadata Elements

	common.elem.metadata =
		( notAllowed )

## Phrase Elements

	common.elem.phrasing =
		( notAllowed )

## Prose Elements

	common.elem.flow =
		( common.elem.phrasing )


# #####################################################################
##  Common Content Models                                             #
# #####################################################################

## Metadata Content

	common.inner.metadata =
		( common.elem.metadata* )

## Phrase Content

	common.inner.phrasing =
		( text & common.elem.phrasing* )

## Prose Content

	common.inner.flow =
		( text & common.elem.flow* ) # REVISIT <style scoped>

# #####################################################################
##  Common Attributes                                                 #
# #####################################################################

# When updating, check <bdo> definition too

common.attrs =
	(	common.attrs.core
	&	common.attrs.event-handler
	&	common.attrs.xml
	)

common.attrs.core =
	(	common.attrs.accesskey?
	&	common.attrs.class?
	&	common.attrs.contenteditable?
	&	common.attrs.contextmenu?
	&	common.attrs.dir?
	&	common.attrs.draggable?
	&	common.attrs.hidden?
	&	common.attrs.id?
	&	common.attrs.lang?
	&	common.attrs.spellcheck?
	&	common.attrs.style?
	&	common.attrs.tabindex?
	&	common.attrs.title?
	)
	common.attrs.id =
		attribute id {
			common.data.id
		}
	common.attrs.class =
		attribute class {
			common.data.tokens
		}
	common.attrs.title =
		attribute title {
			text
		}
	common.attrs.base =
		common.attrs.xmlbase
		& nonRoundtrippable
	common.attrs.xmlbase =
		attribute xml:base {
			common.data.uri
		} & XMLonly
	common.attrs.space =
		common.attrs.xmlspace
	common.attrs.xmlspace =
		attribute xml:space {
			string "preserve" # REVISIT this is not allowed per spec
		} & XMLonly

	common.attrs.dir =
		attribute dir {
			w:string "ltr" | w:string "rtl"
		}
	# This lang definition is a hack for enviroments where
	# the HTML5 parser maps lang to xml:lang.
	# Sameness check left to Schematron
	common.attrs.language =
		(	common.attrs.xmllang?
		&	common.attrs.lang?
		)
	common.attrs.lang =
		attribute lang {
			common.data.langcode
		} & XMLonly
	common.attrs.xmllang =
		attribute xml:lang {
			common.data.langcode
		}
#	common.attrs.language =
#		(	common.attrs.lang
#		|	common.attrs.xmllang
#		)
#	common.attrs.lang =
#		attribute lang {
#			common.data.langcode
#		} & HTMLonly
#	common.attrs.xmllang =
#		attribute xml:lang {
#			common.data.langcode
#		} & XMLonly

	common.attrs.style =
		attribute style {
			string
		}
	common.attrs.tabindex =
		attribute tabindex {
			common.data.integer
		}
		# REVISIT move style to a module and bundle tabindex with ARIA
	common.attrs.accesskey =
		attribute accesskey {
			common.data.keylabellist
		}

common.attrs.other =
	empty

common.attrs.xml =
	(	common.attrs.xmllang?
	&	common.attrs.xmlspace?
	&	common.attrs.xmlbase?
	)


# #####################################################################
##  Common Datatypes                                                  #
# #####################################################################

## Names and Tokens

	common.data.tokens =
		list { token* }

	common.data.browsing-context-name =
		w:browsing-context

	common.data.browsing-context-name-or-keyword =
		w:browsing-context-or-keyword
#		xsd:string {
#			pattern = "()|([^_].*)|(_[bB][lL][aA][nN][kK])|(_[sS][eE][lL][fF])|(_[pP][aA][rR][eE][nN][tT])|(_[tT][oO][pP])"
#		}


## IDs and IDREFs

	common.data.id =
		w:ID
#		xsd:string {
#			pattern = "\S+"
#		}

	common.data.idref =
		w:IDREF
		
	common.data.idrefs =
		w:IDREFS

	common.data.name =
		w:ID #FIXME

	common.data.hash-name =
		w:hash-name	
#		xsd:string {
#			pattern = "#.+"
#		}

## Numerical

	common.data.integer =
		w:integer
#		xsd:string {
#			pattern = "-?[0-9]+"
#		}

	common.data.integer.positive =
		w:integer-positive
#		xsd:string {
#			pattern = "0*[1-9][0-9]*"
#		}

	common.data.integer.non-negative =
		w:integer-non-negative
#		xsd:string {
#			pattern = "[0-9]+"
#		}
		
#	common.data.percent =
#		xsd:string {
#			pattern = "(100)|([1-9]?[0-9](\.[0-9]+)?)%"
#		}
		
	common.data.float =
		w:float
#		xsd:string {
#			pattern = "-?[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?"
#		}

	common.data.float.positive =
		w:float-positive
#		xsd:string {
#			pattern = "(0*[1-9][0-9]*(\.[0-9]+)?)|([0-9]+(\.0*[1-9][0-9]*)?)([eE]-?[0-9]+)?"
#		}
		
	common.data.float.non-negative =
		w:float-non-negative
#		xsd:string {
#			pattern = "[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?"
#		}
		
## Temporal

	common.data.datetime =
		w:datetime-tz

	common.data.date-or-time =
		w:date-or-time

## IRIs

	common.data.uri =
		w:string "" | w:iri-ref

	common.data.uris =
		list { w:iri-ref* }

	common.data.uri.absolute =
		w:iri

## <link type='icon'> sizes

	common.data.sizes =
#		list { w:sizes }
		list {
			xsd:string {
				pattern = "[1-9][0-9]*x[1-9][0-9]*"
			}+
		}

## MIME types

	common.data.mimetype =
		w:mime-type

## Encodings

	common.data.charset =
		w:charset

	common.data.meta-charset =
		w:meta-charset

## Refresh

	common.data.refresh =
		w:refresh

## Default style

	common.data.default-style =
        string
#		w:default-style

## Media Queries

	common.data.mediaquery =
		w:media-query

## Language Codes

	common.data.langcode =
		w:string "" | w:language

## List of Key Labels
	common.data.keylabellist =
		w:keylabellist

## Microdata Identifier
  common.data.microdata-identifier =
    w:microdata-identifier

## Zero
  common.data.zero =
    w:zero

common-form.attrs.form = ( notAllowed )

common.attrs.aria = ( notAllowed )
common.attrs.aria.implicit.button = ( notAllowed )
common.attrs.aria.implicit.input = ( notAllowed )
common.attrs.aria.implicit.region = ( notAllowed )
common.attrs.aria.implicit.group = ( notAllowed )
common.attrs.aria.implicit.th = ( notAllowed )
common.attrs.aria.implicit.structure = ( notAllowed )
common.attrs.aria.implicit.link = ( notAllowed )
common.attrs.aria.implicit.listitem = ( notAllowed )
common.attrs.aria.implicit.img = ( notAllowed )
common.attrs.aria.implicit.select = ( notAllowed )
common.attrs.aria.landmark.application = ( notAllowed )
common.attrs.aria.landmark.article = ( notAllowed )
common.attrs.aria.landmark.banner = ( notAllowed )
common.attrs.aria.landmark.complementary = ( notAllowed )
common.attrs.aria.landmark.contentinfo = ( notAllowed )
common.attrs.aria.landmark.document = ( notAllowed )
common.attrs.aria.landmark.main = ( notAllowed )
common.attrs.aria.landmark.navigation = ( notAllowed )

--- NEW FILE: xhtml5.rnc ---
default namespace = "http://www.w3.org/1999/xhtml"
# #####################################################################
##  RELAX NG Schema for XHTML 5                                       #
# #####################################################################

  # To validate an XHTML 5 document, you must first validate against #
  # this schema and then ALSO validate against assertions.sch        #

# #####################################################################
## Schema Framework & Parameters

include "common.rnc" {
	# XHTML flavor #
		XMLonly = empty
		HTMLonly = notAllowed
	# HTML 4 compat #
		v5only = empty
}

# #####################################################################
## Language Definitions

start = html.elem

include "meta.rnc"
include "phrase.rnc"
include "block.rnc"
include "sectional.rnc"
include "structural.rnc"
include "revision.rnc"
include "embed.rnc"
include "ruby.rnc"
include "media.rnc"
include "core-scripting.rnc"
include "tables.rnc"
include "form-datatypes.rnc"
include "web-forms.rnc"
include "web-forms2.rnc"
include "applications.rnc"
include "data.rnc"

--- NEW FILE: revision.rnc ---
# #####################################################################
##  RELAX NG Schema for HTML 5: Revision Annotations                  #
# #####################################################################

## Inserts: <ins>

	ins.elem.flow =
		element ins { ins.inner.flow & ins.attrs }
	ins.elem.phrasing =
		element ins { ins.inner.phrasing & ins.attrs }
	ins.attrs =
		(	common.attrs
		&	ins.attrs.cite?
		&	ins.attrs.datetime?
		)
		ins.attrs.cite =
			attribute cite {
				common.data.uri
			}
		ins.attrs.datetime =
			attribute datetime {
				common.data.datetime
			}
	ins.inner.flow =
		( common.inner.flow )
	ins.inner.phrasing =
		( common.inner.phrasing )

	common.elem.flow |= ins.elem.flow
	common.elem.phrasing |= ins.elem.phrasing

## Deletions: <del>

	del.elem.flow =
		element del { del.inner.flow & del.attrs }
	del.elem.phrasing =
		element del { del.inner.phrasing & del.attrs }
	del.attrs =
		(	common.attrs
		&	del.attrs.cite?
		&	del.attrs.datetime?
		)
		del.attrs.cite =
			attribute cite {
				common.data.uri
			}
		del.attrs.datetime =
			attribute datetime {
				common.data.datetime
			}
	del.inner.flow =
		( common.inner.flow )
	del.inner.phrasing =
		( common.inner.phrasing )

	common.elem.flow |= del.elem.flow
	common.elem.phrasing |= del.elem.phrasing

--- NEW FILE: assertions.sch ---
<?xml version="1.0"?>
<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
<!-- RELAX NG Schema for HTML 5: Schematron Assertions             -->
<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

  <!-- To validate an (X)HTML5 document, you must first validate   -->
  <!-- against the appropriate RELAX NG schema for the (X)HTML5    -->
  <!-- flavor and then also validate against this schema.          -->

<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

<schema xmlns='http://www.ascc.net/xml/schematron'>
	<ns prefix='h' uri='http://www.w3.org/1999/xhtml'/>

	<pattern name='Triggered on mutually exclusive elements and prohibited-descendant cases'>

	<!-- Exclusions and prohibited-descendant contraints  - - - - - - - - - - - -->

	<rule context='h:form|h:dfn|h:noscript|h:address'>
			<report test='ancestor::*[name() = name(current())]'>
				The &#x201C;<name/>&#x201D; element must not contain any nested 
				&#x201C;<name/>&#x201D; elements.
			</report>
		</rule>

	<rule context='h:label'>
			<report test='ancestor::*[name() = name(current())]'>
				The &#x201C;<name/>&#x201D; element must not contain any nested 
				&#x201C;<name/>&#x201D; elements.
			</report>
			<report test='count(descendant::h:input
			                   | descendant::h:button
			                   | descendant::h:select
			                   | descendant::h:keygen
			                   | descendant::h:textarea) > 1'>
				The &#x201C;label&#x201D; element may contain at most one
				&#x201C;input&#x201D;,
				&#x201C;button&#x201D;,
				&#x201C;select&#x201D;,
				or &#x201C;textarea&#x201D; descendant.
			</report>
			<report test='@for and 
			              not(//h:input[not(translate(@type, "HIDEN", "hiden")="hidden")][@id = current()/@for] or 
			              //h:textarea[@id = current()/@for] or 
			              //h:select[@id = current()/@for] or 
			              //h:button[@id = current()/@for] or 
			              //h:keygen[@id = current()/@for] or 
			              //h:output[@id = current()/@for])'>
				The &#x201C;for&#x201D; attribute of the &#x201C;label&#x201D; 
				element must refer to a form control.
			</report>
		</rule>

		<rule context='h:section|h:nav|h:article|h:aside'>
			<report test='ancestor::h:footer'>
				The sectioning element &#x201C;<name/>&#x201D; must not
				appear as a descendant of the &#x201C;footer&#x201D; element.
			</report>
			<report test='ancestor::h:address'>
				The sectioning element &#x201C;<name/>&#x201D; must not
				appear as a descendant of the &#x201C;address&#x201D; element.
			</report>
		</rule>

		<rule context='h:footer'>
			<report test='ancestor::h:header'>
				The element &#x201C;footer&#x201D; must not
				appear as a descendant of the &#x201C;header&#x201D; element.
			</report>
			<report test='ancestor::h:footer'>
				The element &#x201C;footer&#x201D; must not
				appear as a descendant of the &#x201C;footer&#x201D; element.
			</report>
			<report test='ancestor::h:address'>
				The element &#x201C;footer&#x201D; must not
				appear as a descendant of the &#x201C;address&#x201D; element.
			</report>
		</rule>

		<rule context='h:h1|h:h2|h:h3|h:h4|h:h5|h:h6'>
			<report test='ancestor::h:footer'>
				The &#x201C;<name/>&#x201D; element must not appear as a 
				descendant of the &#x201C;footer&#x201D; element.
			</report>
			<report test='ancestor::h:address'>
				The &#x201C;<name/>&#x201D; element must not appear as a 
				descendant of the &#x201C;address&#x201D; element.
			</report>
		</rule>

		<rule context='h:header'>
			<report test='ancestor::h:footer'>
				The &#x201C;<name/>&#x201D; element must not appear as a 
				descendant of the &#x201C;footer&#x201D; element.
			</report>
			<report test='ancestor::h:address'>
				The &#x201C;<name/>&#x201D; element must not appear as a 
				descendant of the &#x201C;address&#x201D; element.
			</report>
			<report test='ancestor::h:header'>
				The &#x201C;header&#x201D; element must not appear as a 
				descendant of the &#x201C;header&#x201D; element.
			</report>
		</rule>

	<!-- Interactive element exclusions -->
	
		<!-- 
		   - Interactive descendants:
		   - a
		   - video[controls]
		   - audio[controls]
		   - details
		   - menu[type=toolbar]
		   - button
		   - input[type!=hidden]
		   - textarea
		   - select
		   -
		   - Interactive ancestors
		   - a
		   - button
		  -->

		<rule context='h:a|h:details'>
			<report test='ancestor::h:a'>
				The interactive element &#x201C;<name/>&#x201D; must not 
				appear as a descendant of the &#x201C;a&#x201D; element.
			</report>
			<report test='ancestor::h:button'>
				The interactive element &#x201C;<name/>&#x201D; must not 
				appear as a descendant of the &#x201C;button&#x201D; element.
			</report>
		</rule>

		<rule context='h:button|h:textarea|h:select|h:keygen|h:input[not(translate(@type, "HIDEN", "hiden")="hidden")]'>
			<report test='ancestor::h:a'>
				The interactive element &#x201C;<name/>&#x201D; must not 
				appear as a descendant of the &#x201C;a&#x201D; element.
			</report>
			<report test='ancestor::h:button'>
				The interactive element &#x201C;<name/>&#x201D; must not 
				appear as a descendant of the &#x201C;button&#x201D; element.
			</report>
			<report test='ancestor::h:label[@for] and not(ancestor::h:label[@for = current()/@id])'>
				Any &#x201C;<name/>&#x201D; descendant of a &#x201C;label&#x201D;
				element with a &#x201C;for&#x201D; attribute must have an
				ID value that matches that &#x201C;for&#x201D; attribute.
			</report>
		</rule>

		<rule context='h:video[@controls]|h:audio[@controls]'>
			<report test='ancestor::h:a'>
				The interactive element &#x201C;<name/>&#x201D;
				with the attribute &#x201C;controls&#x201D; must not
				appear as a descendant of the &#x201C;a&#x201D; element.
			</report>
			<report test='ancestor::h:button'>
				The interactive element &#x201C;<name/>&#x201D;
				with the attribute &#x201C;controls&#x201D; must not
				appear as a descendant of the &#x201C;button&#x201D; element.
			</report>
		</rule>

		<rule context='h:menu[translate(@type, "TOLBAR", "tolbar")="toolbar"]'>
			<report test='ancestor::h:a'>
				The element &#x201C;menu&#x201D;
				with the attribute &#x201C;type=toolbar&#x201D; must not
				appear as a descendant of the &#x201C;a&#x201D; element.
			</report>
			<report test='ancestor::h:button'>
				The element &#x201C;menu&#x201D;
				with the attribute &#x201C;type=toolbar&#x201D; must not
				appear as a descendant of the &#x201C;button&#x201D; element.
			</report>
		</rule>

		<rule context='h:img[@usemap]'>
			<report test='ancestor::h:a'>
				The element &#x201C;img&#x201D;
				with the attribute &#x201C;usemap&#x201D; must not
				appear as a descendant of the &#x201C;a&#x201D; element.
			</report>
			<report test='ancestor::h:button'>
				The element &#x201C;img&#x201D;
				with the attribute &#x201C;usemap&#x201D; must not
				appear as a descendant of the &#x201C;button&#x201D; element.
			</report>
		</rule>

	<!-- REVISIT fieldset http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2006-April/006181.html -->

	<!-- Misc requirements -->
		
		<rule context='h:script[translate(@language, "JAVSCRIPT", "javscript")="javascript"]'>
			<assert test='not(@type) or translate(@type, "EXJAVSCRIPT", "exjavscript")="text/javascript"'>
				A &#x201C;script&#x201D; element with the 
				&#x201C;language="JavaScript"&#x201D; attribute set must not have a 
				&#x201C;type&#x201D; attribute whose value is not 
				&#x201C;text/javascript&#x201D;.
			</assert>
		</rule>

		<rule context='h:area'>
			<assert test='ancestor::h:map'>
				The &#x201C;area&#x201D; element must have a 
				&#x201C;map&#x201D; ancestor.
			</assert>
		</rule>

		<rule context='h:img[@ismap]'>
			<assert test='ancestor::h:a[@href]'>
				The &#x201C;img&#x201D; element with the 
				&#x201C;ismap&#x201D; attribute set must have an 
				&#x201C;a&#x201D; ancestor with the &#x201C;href&#x201D; 
				attribute.
			</assert>
		</rule>

		<rule context='h:progress[@max and @value]'>
			<assert test='number(@value) &lt;= number(@max)'>
				The value of the  &#x201C;value&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</assert>
		</rule>

		<rule context='h:progress[not(@max) and @value]'>
			<assert test='number(@value) &lt;= 1'>
				The value of the  &#x201C;value&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</assert>
		</rule>

		<!-- 
			min <= value <= max
    		min <= low <= high <= max
			min <= optimum <= max 
		-->

		<rule context='h:meter'>
			<report test='@min and @value and not(number(@min) &lt;= number(@value))'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				the value of the &#x201C;value&#x201D; attribute.
			</report>
			<report test='not(@min) and @value and not(0 &lt;= number(@value))'>
				The value of the &#x201C;value&#x201D; attribute must be greater than or equal to
				zero when the &#x201C;min&#x201D; attribute is absent.
			</report>
			<report test='@value and @max and not(number(@value) &lt;= number(@max))'>
				The value of the  &#x201C;value&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</report>
			<report test='@value and not(@max) and not(number(@value) &lt;= 1)'>
				The value of the  &#x201C;value&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</report>
			<report test='@min and @max and not(number(@min) &lt;= number(@max))'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</report>
			<report test='not(@min) and @max and not(0 &lt;= number(@max))'>
				The value of the &#x201C;max&#x201D; attribute must be greater than or equal to
				zero when the &#x201C;min&#x201D; attribute is absent.
			</report>
			<report test='@min and not(@max) and not(number(@min) &lt;= 1)'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</report>
			<report test='@min and @low and not(number(@min) &lt;= number(@low))'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				the value of the &#x201C;low&#x201D; attribute.
			</report>
			<report test='not(@min) and @low and not(0 &lt;= number(@low))'>
				The value of the &#x201C;low&#x201D; attribute must be greater than or equal to
				zero when the &#x201C;min&#x201D; attribute is absent.
			</report>
			<report test='@min and @high and not(number(@min) &lt;= number(@high))'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				the value of the &#x201C;high&#x201D; attribute.
			</report>
			<report test='not(@min) and @high and not(0 &lt;= number(@high))'>
				The value of the &#x201C;high&#x201D; attribute must be greater than or equal to
				zero when the &#x201C;min&#x201D; attribute is absent.
			</report>
			<report test='@low and @high and not(number(@low) &lt;= number(@high))'>
				The value of the  &#x201C;low&#x201D; attribute must be less than or equal to
				the value of the &#x201C;high&#x201D; attribute.
			</report>
			<report test='@high and @max and not(number(@high) &lt;= number(@max))'>
				The value of the  &#x201C;high&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</report>
			<report test='@high and not(@max) and not(number(@high) &lt;= 1)'>
				The value of the  &#x201C;high&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</report>
			<report test='@low and @max and not(number(@low) &lt;= number(@max))'>
				The value of the  &#x201C;low&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</report>
			<report test='@low and not(@max) and not(number(@low) &lt;= 1)'>
				The value of the  &#x201C;low&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</report>
			<report test='@min and @optimum and not(number(@min) &lt;= number(@optimum))'>
				The value of the  &#x201C;min&#x201D; attribute must be less than or equal to
				the value of the &#x201C;optimum&#x201D; attribute.
			</report>
			<report test='not(@min) and @optimum and not(0 &lt;= number(@optimum))'>
				The value of the &#x201C;optimum&#x201D; attribute must be greater than or equal to
				zero when the &#x201C;min&#x201D; attribute is absent.
			</report>
			<report test='@optimum and @max and not(number(@optimum) &lt;= number(@max))'>
				The value of the  &#x201C;optimum&#x201D; attribute must be less than or equal to
				the value of the &#x201C;max&#x201D; attribute.
			</report>
			<report test='@optimum and not(@max) and not(number(@optimum) &lt;= 1)'>
				The value of the  &#x201C;optimum&#x201D; attribute must be less than or equal to
				one when the &#x201C;max&#x201D; attribute is absent.
			</report>
		</rule>


	<!-- Obsolete Elements - - - - - - - - - - - - - - - - - - - - - - -->

		<rule context='h:center|h:font|h:big|h:s|h:strike|h:tt|h:u|h:acronym|h:dir|h:applet
		  |h:basefont
		  |h:frameset
		  |h:noframes'>
			<report test='true()'>
				The &#x201C;<name/>&#x201D; element is obsolete.
			</report>
		</rule>

	<!-- required attributes  - - - - - - - - - - - - - - - - - - - -->

		<rule context='h:map[@id and @name]'>
			<assert test='@id = @name'>
				The &#x201C;id&#x201D; attribute on a &#x201C;map&#x201D; element must have an 
				the same value as the &#x201C;name&#x201D; attribute.
			</assert>
		</rule>

		<rule context='h:bdo[not(@dir)]'>
			<report test='true()'>
				A &#x201C;bdo&#x201D; element must have an 
				&#x201C;dir&#x201D; attribute.
			</report>
		</rule>

	</pattern>

<!-- lang and xml:lang in XHTML  - - - - - - - - - - - - - - - - - -->

	<pattern name='lang and xml:lang in XHTML'>
		<rule context='h:*[@lang and @xml:lang]'>
			<assert test='translate(@lang, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz") = translate(@xml:lang, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz")'>
				When the attribute &#x201C;lang&#x201D; is specified, the element must also have 
				the attribute &#x201C;lang&#x201D; in the XML namespace present with the same 
				value.
			</assert>
		</rule>
		<rule context='h:*[@lang and not(@xml:lang)]'>
			<report test='true()'>
				When the attribute &#x201C;lang&#x201D; is specified, the element must also have 
				the attribute &#x201C;lang&#x201D; in the XML namespace present with the same 
				value.
			</report>
		</rule>
	</pattern>

<!-- IDREFs  - - - - - - - - - - - - - - - - - - - - - - - - - - - -->

	<!-- Assuming that ID uniqueness is already enforced. -->

	<pattern name='contextmenu must refer to a menu'>
		<rule context='h:*[@contextmenu]'>
		  <assert test='//h:menu[@id = current()/@contextmenu]'>
				The &#x201C;contextmenu&#x201D; attribute must refer to a 
				&#x201C;menu&#x201D; element.
			</assert>
		</rule>
	</pattern>

	<pattern name='list on input must refer to a select or a datalist'>
		<rule context='h:input[@list]'>
			<assert test='//h:datalist[@id = current()/@list] or 
			              //h:select[@id = current()/@list]'>
				The &#x201C;list&#x201D; attribute of the &#x201C;input&#x201D; 
				element must refer to a &#x201C;datalist&#x201D; element or to 
				a &#x201C;select&#x201D; element.
			</assert>
		</rule>
	</pattern>
		
	<!-- FIXME form attribute -->
	
	<!-- FIXME output for -->
	
<!-- Form Constraints  - - - - - - - - - - - - - - - - - - - - - - -->

	<pattern name='Non-multiple select can have up to one selected option'>
		<rule context='h:select[not(@multiple)]'>
			<report test='count(descendant::h:option[@selected]) > 1'>
				The &#x201C;select&#x201D; element cannot have more than one 
				selected &#x201C;option&#x201D; descendant unless the 
				&#x201C;multiple&#x201D; attribute is specified.
			</report>
		</rule>
	</pattern>

<!-- Unique Definitions  - - - - - - - - - - - - - - - - - - - - - -->
	
	<!-- Only one definition per term per document' -->

<!-- ARIA containment    - - - - - - - - - - - - - - - - - - - - - -->

	<pattern name='Mutually Exclusive Role triggers'>

    <!-- XXX columnheader and rowheader require row parent -->

		<rule context='*[@role="option"]'>
			<assert test='../@role="listbox"'>
				An element with &#x201C;role=option&#x201D; requires 
				&#x201C;role=listbox&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="menuitem"]'>
			<assert test='../@role="menu"'>
				An element with &#x201C;role=menuitem&#x201D; requires 
				&#x201C;role=menu&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="menuitemcheckbox"]'>
			<assert test='../@role="menu"'>
				An element with &#x201C;role=menuitemcheckbox&#x201D; requires 
				&#x201C;role=menu&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="menuitemradio"]'>
			<assert test='../@role="menu"'>
				An element with &#x201C;role=menuitemradio&#x201D; requires 
				&#x201C;role=menu&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="tab"]'>
			<assert test='../@role="tablist"'>
				An element with &#x201C;role=tab&#x201D; requires 
				&#x201C;role=tablist&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="treeitem"]'>
			<assert test='../@role="tree"'>
				An element with &#x201C;role=treeitem&#x201D; requires 
				&#x201C;role=tree&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="listitem"]'>
			<assert test='../@role="list"'>
				An element with &#x201C;role=listitem&#x201D; requires 
				&#x201C;role=list&#x201D; on the parent.
			</assert>
		</rule>

		<rule context='*[@role="row"]'>
			<assert test='../@role="grid" or 
			              ../../@role="grid" or
						  ../@role="treegrid" or 
			              ../../@role="treegrid"'>
				An element with &#x201C;role=row&#x201D; requires 
				&#x201C;role=treegrid&#x201D; or &#x201C;role=grid&#x201D; on the parent or grandparent.
			</assert>
		</rule> 
		<!-- XXX hoping for a spec change so not bothering with the reciprocal case -->

		<rule context='*[@role="gridcell"]'>
			<assert test='../@role="row"'>
				An element with &#x201C;role=gridcell&#x201D; requires 
				&#x201C;role=row&#x201D; on the parent.
			</assert>
		</rule>
		<!-- XXX hoping for a spec change so not bothering with the reciprocal case -->

	</pattern>
	
	<pattern name='Not Option'>
		<rule context='*[not(@role="option")]'>
			<report test='../@role="listbox"'>
				An element must not be a child of
				&#x201C;role=listbox&#x201D; unless it has &#x201C;role=option&#x201D;.
			</report>
		</rule>
	</pattern>
	
	<pattern name='Not menuitem*'>
		<rule context='*[not(@role="menuitem" or 
		                     @role="menuitemcheckbox" or 
		                     @role="menuitemradio")]'>
			<report test='../@role="menu"'>
				An element must not be a child of
				&#x201C;role=menu&#x201D; unless it has 
				&#x201C;role=menuitem&#x201D;, 
				&#x201C;role=menuitemcheckbox&#x201D; or 
				&#x201C;role=menuitemradio&#x201D;.
			</report>
		</rule>
	</pattern>
	
	<pattern name='Not treeitem'>
		<rule context='*[not(@role="treeitem")]'>
			<report test='../@role="tree"'>
				An element must not be a child of
				&#x201C;role=tree&#x201D; unless it has 
				&#x201C;role=treeitem&#x201D;.
			</report>
		</rule>
	</pattern>
	
	<pattern name='Not listitem'>
		<rule context='*[not(@role="listitem")]'>
			<report test='../@role="list"'>
				An element must not be a child of
				&#x201C;role=list&#x201D; unless it has 
				&#x201C;role=listitem&#x201D;.
			</report>
		</rule>
		<!-- XXX role=group omitted due to lack of detail in spec -->
	</pattern>
	
	<pattern name='Not radio'>
		<rule context='*[not(@role="radio")]'>
			<report test='../@role="radiogroup"'>
				An element must not be a child of
				&#x201C;role=radiogroup&#x201D; unless it has 
				&#x201C;role=radio&#x201D;.
			</report>
		</rule>
	</pattern>
	
	<pattern name='Not gridcell'>
		<rule context='*[not(@role="gridcell")]'>
			<report test='../@role="row"'>
				An element must not be a child of
				&#x201C;role=row&#x201D; unless it has 
				&#x201C;role=gridcell&#x201D;.
			</report>
		</rule>
	</pattern>
	
	<pattern name='Not tab'>
		<rule context='*[not(@role="tab")]'>
			<report test='../@role="tablist"'>
				An element must not be a child of
				&#x201C;role=tablist&#x201D; unless it has 
				&#x201C;role=role&#x201D;.
			</report>
		</rule>
	</pattern>

  <!-- XXX combobox requires a listbox child -->
	
	<pattern name='aria-activedescendant must refer to a descendant'>
		<rule context='*[@aria-activedescendant]'>
			<assert test='descendant::*[@id = current()/@aria-activedescendant]'>
				The &#x201C;aria-activedescendant&#x201D; attribute must refer to a 
				descendant element.
			</assert>
		</rule>
	</pattern>

	<pattern name='controls must not dangle'>
		<rule context='*[@aria-controls]'>
		  <assert test='//*[@id = current()/@aria-controls]'>
				The &#x201C;aria-controls&#x201D; attribute must point to an element in the 
				same document.
			</assert>
		</rule>
	</pattern>

	<pattern name='describedby must not dangle'>
		<rule context='*[@aria-describedby]'>
		  <assert test='//*[@id = current()/@aria-describedby]'>
				The &#x201C;aria-describedby&#x201D; attribute must point to an element in the 
				same document.
			</assert>
		</rule>
	</pattern>

	<pattern name='flowto must not dangle'>
		<rule context='*[@aria-flowto]'>
		  <assert test='//*[@id = current()/@aria-flowto]'>
				The &#x201C;aria-flowto&#x201D; attribute must point to an element in the 
				same document.
			</assert>
		</rule>
	</pattern>

	<pattern name='labelledby must not dangle'>
		<rule context='*[@aria-labelledby]'>
		  <assert test='//*[@id = current()/@aria-labelledby]'>
				The &#x201C;aria-labelledby&#x201D; attribute must point to an element in the 
				same document.
			</assert>
		</rule>
	</pattern>

	<pattern name='owns must not dangle'>
		<rule context='*[@aria-owns]'>
		  <assert test='//*[@id = current()/@aria-owns]'>
				The &#x201C;aria-owns&#x201D; attribute must point to an element in the 
				same document.
			</assert>
		</rule>
	</pattern>

</schema>
Received on Saturday, 29 August 2009 01:43:29 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Saturday, 29 August 2009 01:43:30 GMT