Internationalization Tag Set (ITS) Version 2.0

1.1.1 Relation to ITS 1.0

ITS 2.0 has the following relation relations to ITS 1.0:

• It adopts and maintains the following principles from ITS 1.0:

  • It adopts the use of data categories to define discrete units of functionality

  • It adopts the separation of data category definition from the mapping of the data category to a given content format

  • It adopts the conformance principle of ITS1.0 that an implementation only needs to implement one data category to claim conformance to ITS 2.0

  • A data category implementation only needs to support a single content format mapping in order to support a claim of ITS 2.0 conformance

• ITS 2.0 specifies implementations of supports all ITS 1.0 data categories in HTML5 category definitions and XML adds new definitions.

• ITS 2.0 provides algorithms to generate RDFa and NIF out adds a number of HTML5 or XML with new data categories not found in ITS 2.0 metadata 1.0.

• ITS 2.0 supports all While ITS 1.0 addressed only XML, ITS 2.0 specifies implementations of data category definitions categories in both XML and adds new definitions HTML5.

• Where ITS 1.0 data categories are implemented in XML, the implementation must be conformant with the ITS 1.0 mapping approach to XML to claim conformance to ITS 2.0.

1.1.2 New Principles

ITS 2.0 also adds the following principles and features not found in ITS 1.0:

• ITS 2.0 data categories are intended to be format neutral, with support for XML, HTML5, RDFa, and NIF: a data category implementation only needs to support a single content format mapping in order to support a claim of ITS 2.0 conformance.

• ITS 2.0 provides algorithms to generate RDFa and NIF out of HTML5 or XML with ITS 2.0 metadata.

• A global implementation of ITS 2.0 requires at least the XPath version 1.0. Other versions of XPath or other query languages (e.g., CSS selectors) can be expressed via a dedicated query language queryLanguage attribute.

As of the time of this writing, the new data categories included in ITS 2.0 are: Section 6.9:   Domain , Section 6.10:   Disambiguation , Section 6.11:   LocaleFilter , Section 6.12:   Provenance , and Section 6.13:   TextAnalyisAnnotation .

• [Source file: examples/html5/EX-translate-html5-global-1.html Domain ]

• Disambiguation Example 2:   ITS rules file linked from HTML5

• The rules file linked in Example 1 . Locale Filter

• <its:rules xmlns:its="http://www.w3.org/2005/11/its" xmlns:h="http://www.w3.org/1999/xhtml" xmlns:h="http://www.w3.org/1999/xhtml"   version="1.0">    <its:translateRule   translate="no"   selector="//h:code"/> </its:rules>

• Provenance

• [Source file: examples/html5/EX-translateRule-html5-1.xml Text Analysis Annotation ]

1.3.1 1.2.1 Typical Problems

The following examples sketch one of the issues that currently hinder efficient XML-related localization: the lack of a standard, declarative mechanism which that identifies which parts of an XML document need to be translated. Tools often cannot automatically do this identification. which parts of an XML document need to be translated. Tools often cannot automatically perform this identification.

<resources>
   <section   id="Homepage">
      <arguments>
         <string>page</string>
         <string>childlist</string>
      </arguments>
      <variables>
         <string>POLICY</string>
         <string>Corporate Policy</string>
      </variables>
      <keyvalue_pairs>
         <string>Page</string>
         <string>ABC Corporation - Policy Repository</string>
         <string>Footer_Last</string>
         <string>Pages</string>
         <string>bgColor</string>
         <string>NavajoWhite</string>
         <string>title</string>
         <string>List of Available Policies</string>
      </keyvalue_pairs>
   </section>
</resources>

<dialogue   xml:lang="en-gb">
   <rsrc   id="123">
      <component   id="456"   type="image">
         <data   type="text">images/cancel.gif</data>
         <data   type="coordinates">12,20,50,14</data>
      </component>
      <component   id="789"   type="caption">
         <data   type="text">Cancel</data>
         <data   type="coordinates">12,34,50,14</data>
      </component>
      <component   id="792"   type="string">
         <data   type="text">Number
of
files:
</data>

         <data   type="text">Number of files: </data>

      </component>
   </rsrc>
</dialogue>

1.4.1 1.3.1 Potential Users of ITS

The ITS specification aims to provide different types of users with information about what markup should be supported to enable worldwide use and effective internationalization and localization of content. The following paragraphs sketch these different types of users, and their usage of ITS. In order to support all of these users, the information about what markup should be supported to enable worldwide use and effective localization of content is provided in this specification in two ways:

• Schema abstractly in the data category descriptions: Section 6:   Description of Data Categories

• concretely in the ITS schemas: Appendix D:   Schemas for ITS

1.4.2 1.3.2 Ways to Use ITS

The ITS specification proposes several mechanisms for supporting worldwide use and effective internationalization and localization of content. We will sketch them below by looking at them from the perspectives of certain user types. For the purpose of illustration, we will demonstrate how ITS can indicate that certain parts of content should or should not be translated.

• A content author uses an attribute on a particular element to say that the text in the element should not be translated. be translated.

<help
  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="1.0">

      its:version="2.0">

   <head>
      <title>Building the Zebulon Toolkit</title>
   </head>
   <body>
      <p>To re-compile all the modules of the Zebulon toolkit you need to go in the
        <path
               its:translate="no">\Zebulon\Current Source\binary</path> directory.
        Then from there, run batch file <cmd
               its:translate="no">Build.bat</cmd>.</p>
   </body>
</help>

• A content author or information architect uses markup at the top of the document to identify a particular type of element or context in which the content should not be translated. content should not be translated.

<help
  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="1.0">

      its:version="2.0">

   <head>
      <title>Building the Zebulon Toolkit</title>
      <its:rules   version="1.0">

      <its:rules   version="2.0">

         <its:translateRule   selector="//path | //cmd"   translate="no"/>
      </its:rules>
   </head>
   <body>
      <p>To re-compile all the modules of the Zebulon toolkit you need to go in the
        <path>\Zebulon\Current Source\binary</path> directory.
        Then from there, run batch file <cmd>Build.bat</cmd>.</p>
   </body>
</help>

• A processor may insert markup at the top of the document which links to ITS information outside of the document. document.

<help
  xmlns:its="http://www.w3.org/2005/11/its" 
  xmlns:xlink="http://www.w3.org/1999/xlink" 
      its:version="1.0">

      its:version="2.0">

   <head>
      <title>Building the Zebulon Toolkit</title>
      <its:rules   version="1.0"   xlink:href="EX-ways-to-use-its-4.xml"   xlink:type="simple"/>

      <its:rules   version="2.0"   xlink:href="EX-ways-to-use-its-4.xml"/>

   </head>
   <body>
      <p>To re-compile all the modules of the Zebulon toolkit you need to go in the
        <path>\Zebulon\Current Source\binary</path> directory.
        Then from there, run batch file <cmd>Build.bat</cmd>.</p>
   </body>
</help>

<its:rules
xmlns:its="http://www.w3.org/2005/11/its"
   version="1.0">
   <its:translateRule   selector="//path
|
//cmd"   translate="no"/>

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">
   <its:translateRule   selector="//path | //cmd"   translate="no"/>

</its:rules>

• A schema developer integrates ITS markup declarations in his schema to allow users to indicate that specific parts of the content should not be translated. translated.

<xs:schema
  xmlns:its="http://www.w3.org/2005/11/its" 
  xmlns:xs="http://www.w3.org/2001/XMLSchema"    elementFormDefault="qualified">
   <xs:import   namespace="http://www.w3.org/2005/11/its"   schemaLocation="its.xsd"/>
   <xs:attributeGroup   name="commonAtts">
      <xs:attributeGroup   ref="its:att.local.with-ns.attribute.translate"/>
      <xs:attribute   name="id"   type="xs:ID"   use="optional"/>
   </xs:attributeGroup>
   <xs:element   name="help">
      <xs:complexType>
         <xs:sequence>
            <xs:element   name="head">
               <xs:complexType>
                  <xs:sequence>
                     <xs:element   name="title"   type="xs:string"/>
                  </xs:sequence>
                  <xs:attributeGroup   ref="commonAtts"/>
               </xs:complexType>
            </xs:element>
            <xs:element   name="body">
               <xs:complexType>
                  <xs:choice   minOccurs="1"   maxOccurs="unbounded">
                     <xs:element   name="p">
                        <xs:complexType   mixed="true">
                           <xs:choice   minOccurs="0"   maxOccurs="unbounded">
                              <xs:element   ref="path"/>
                              <xs:element   ref="cmd"/>
                           </xs:choice>
                           <xs:attributeGroup   ref="commonAtts"/>
                        </xs:complexType>
                     </xs:element>
                  </xs:choice>
               </xs:complexType>
            </xs:element>
         </xs:sequence>
         <xs:attributeGroup   ref="its:att.version.attribute.version"/>
      </xs:complexType>
   </xs:element>
   <xs:element   name="path">
      <xs:complexType   mixed="true">
         <xs:attributeGroup   ref="commonAtts"/>
      </xs:complexType>
   </xs:element>
   <xs:element   name="cmd">
      <xs:complexType   mixed="true">
         <xs:attributeGroup   ref="commonAtts"/>
      </xs:complexType>
   </xs:element>
</xs:schema>

The first two approaches above can be likened to the use of CSS in [XHTML 1.0] . Using a style attribute, an XHTML content author may assign a color to a particular paragraph. That author could also have used the style element at the top of the page to say that all paragraphs of a particular class or in a particular context would be colored red.

1.4.1 Support for legacy HTML content

ITS 2.0 does not define how to use ITS in HTML versions prior version 5. Users are encouraged to migrate their content to HTML5 or XHTML. While it is possible to use its-* attributes introduced for HTML5 in older versions of HTML (such as 3.2 or 4.01) and pages using these attributes will work without any problems, its-* attributes will be marked as invalid in validators.

2.1.1 Local Approach

The document in Example 10 shows how a content author may use the ITS translate attribute to indicate that all content inside the author element should be protected from translation. Translation tools that are aware of the meaning of this attribute can then screen the relevant content from the translation process. the translation process.

<dbk:article
  xmlns:its="http://www.w3.org/2005/11/its" 
  xmlns:dbk="http://docbook.org/ns/docbook" 
      its:version="1.0"   version="5.0"   xml:lang="en">

      its:version="2.0"   version="5.0"   xml:lang="en">

   <dbk:info>
      <dbk:title>An example article</dbk:title>
      <dbk:author
            its:translate="no">
         <dbk:personname>
            <dbk:firstname>John</dbk:firstname>
            <dbk:surname>Doe</dbk:surname>
         </dbk:personname>
         <dbk:affiliation>
            <dbk:address>
               <dbk:email>foo@example.com</dbk:email>
            </dbk:address>
         </dbk:affiliation>
      </dbk:author>
   </dbk:info>
   <dbk:para>This is a short article.</dbk:para>
</dbk:article>

For this example to work, the schema developer will need to add the translate attribute to the schema as a common attribute or on all the relevant element definitions. Note how there is an expectation in this case that inheritance plays a part in identifying which content does have to be translated and which does not. Tools that process this content for translation will need to implement the expected inheritance.

2.1.2 Global Approach

The document in Example 11 shows a different approach to identifying non-translatable content, similar to that used with a style element in [XHTML 1.0] , but using an ITS-defined element called rules . It works as follows: A document can contain a rules element (placed where it does not impact the structure of the document, like e.g., in a "head"   "head" section). It contains one or more ITS rule elements (for example translateRule ). Each of these specific elements contains a selector attribute. As its name suggests, this attribute selects the XML node or nodes to which a corresponding ITS information pertains. The values of ITS selector attributes are XPath absolute location paths. paths (or CSS selectors if queryLanguage is set to "CSS"). Information for the handling of namespaces in these path expressions is taken from namespace declarations [XML Names] at the current rules element.

<myTopic
  xmlns:its="http://www.w3.org/2005/11/its" 
  xmlns="myNamescapeURI"   id="topic01"   xml:lang="en-us">
   <prolog>
      <title>Using ITS</title>
      <its:rules   version="1.0">

      <its:rules   version="2.0">

         <its:translateRule   selector="//n:term"   translate="no"/>
      </its:rules>
   </prolog>
   <body>
      <p>ITS defines <term>data category</term> as an abstract
      concept for a particular type of information for 
      internationalization and localization of XML schemas and 
      documents.</p>
   </body>
</myTopic>

For this approach to work, the schema developer needs to add the rules element and associated markup to the schema. In some cases this global rules may be sufficient to allow the schema developer to avoid adding other ITS markup (such as an translate attribute) to the elements and attributes in the schema. However, it is likely that authors will want to use attributes on markup from time to time to override the general rule.

For specification of the Translate data category information, the contents of the rules element would normally be designed by an information architect familiar with the document format and familiar with, or working with someone familiar with, the needs of the localization group.

The global, rule-based approach has the following benefits:

• Content authors do not have to concern themselves with creating additional markup or verifying that the markup was applied correctly. ITS data categories are associated with sets of XML nodes (for example all p elements in an XML instance)

• Changes can be done made in a single location, rather than by searching and modifying the local markup throughout a document (or documents, if the rules element is stored as an external entity)

• ITS data categories can designate attribute values as well as elements.

• It is possible to associate ITS markup with existing markup (for example the term element in DITA)

The commonality in both examples above is the markup translate='no' . This piece of ITS markup can be interpreted as follows:

• it pertains to the Translate data category

• the attribute translate holds a value of "no"

The ITS selector attribute allows:

• ITS data category attributes to appear in global rules (even outside of an XML document or schema)

• ITS data categories attributes to pertain to sets of XML nodes (for example all p elements in an XML document)

• ITS markup to pertain to attributes

• ITS markup to associate with existing markup (for example the term element in DITA)

2.1.3 queryLanguage

The queryLanguage attribute provides a way to specify that an implementation of ITS use an alternative to XPath as a selection mechanism. In particular, it allows the use of CSS selectors, which may be convenient for those already working with CSS (e.g., in an HTML5 environment). Where appropriate, this specification provides examples using this attribute and CSS selectors.

5.2.1 Global, Rule-based Selection

Global, rule-based selection is implemented using the rules element. It contains zero or more rule elements . Each rule element has a mandatory selector attribute. This attribute and all other possible attributes on rule elements are in the empty namespace and used without a prefix.

If there is more than one rules element in an XML document, the rules from each section are to be processed at the same precedence level. The rules sections are to be read in document order, and the ITS rules with them processed sequentially. The versions of these rules elements MUST NOT be different.

Depending on the data category and its usage, there are additional attributes for adding information to the selected nodes, or for pointing to existing information in the document. For example, the Localization Note data category can be used for adding notes to selected nodes, or for pointing to existing notes in the document. For the former purpose, a locNote element can be used. For the latter purpose, a locNotePointer attribute can be used.

Each data category allows you users to add information to the selected nodes except for language information . Pointing to existing information is not possible for data categories that express a closed set of values , that is: Translate , Directionality , Locale Filter , and Elements Within Text .

The functionalities of adding information and pointing to existing information are mutually exclusive . That is: markup for pointing and adding MUST NOT appear in the same rule element.

Another difference between adding and pointing is the usage of XPath:

• The value of the selector attribute MUST be an XPath expression which starts with " / ". That is, it must be an AbsoluteLocationPath as described in XPath 1.0 or its successor. This ensures that the selection is not relative to a specific location. The resulting nodes MUST be either element or attribute nodes.

• Attributes that point to existing information in the document, i.e. attributes whose name ends in ...Pointer , MUST use a RelativeLocationPath as described in XPath 1.0 or its successor. The XPath expression is evaluated relative to the nodes selected by the selector attribute. The following attributes point to existing information: locNotePointer , locNoteRefPointer , termInfoPointer , termInfoRefPointer , rubyPointer , rtPointer , rpPointer , rbcPointer , rtcPointer , rbspanPointer , langPointer .

If namespaces [XML Names] are used in XPath expressions in the selector attribute or the pointing attributes, the following rules MUST be applied while processing XPath:

1. For each prefix, there MUST be an xmlns attribute a namespace declaration in effect at the same rule element which allows to resolve the namespace URI of the prefix.

2. Element and attribute names without a prefix are interpreted as having no namespace.

3. To avoid a conflict with rule 2., default namespaces MUST NOT be used in the XPath expressions. [Ed. note: Need to define how default namespace work with HTML5.]

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its" 
  xmlns:tei="http://www.tei-c.org/ns/1.0"   version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">

   <its:termRule   selector="//tei:term"   term="yes"/>
</its:rules>

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="1.0">

xmlns:its="http://www.w3.org/2005/11/its"
   version="2.0">

   <its:termRule   selector="//qterm"   term="yes"/>
</its:rules>

Global rules can appear in the XML document they will be applied to, or in a separate XML document. The precedence of their processing depends on these variations. See also Section 5.4:   Precedence between Selections .

Markup for global, rule-based selection is defined as follows.

rules

[1]	rules	::=	element its:rules { rules.content, rules.attributes }
[2]	rules.content	::=	( translateRule | locNoteRule | termRule | dirRule | rubyRule | langRule | withinTextRule | domainRule | localeFilterRule | externalResourceRefRule )*
[3]	rules.attributes	::=	attribute version { xsd:float }, attribute xlink:href { xsd:anyURI }?, attribute xlink:type { "simple" }?

att.selector

[4]	att.selector.attributes	::=	att.selector.attribute.selector
[5]	att.selector.attribute.selector	::=	attribute selector { string }

att.version

[6]	att.version.attributes	::=	att.version.attribute.version
[7]	att.version.attribute.version	::=	attribute its:version { xsd:float }

5.2.2 Global selection within HTML5

Global rules work in HTML5 as follows.

1. Global rules will be attached externally using the link element, with the link relation its-rules .

2. In global rules XPath 1.0 will be used for selection.

3. If it turns out that some users prefer easier selection mechanism, they can switch query language to CSS selectors by using the proposed queryLanguage attribute attribute, see Section 2.1.3:   queryLanguage .

5.2.3 Local Selection in an XML Document

Local selection in XML documents is realized with local ITS attributes , the ruby element, or the span element. span serves just as a carrier for the local ITS attributes and a container for ruby .

The content model of span permits arbitrary nesting of ruby markup, since the rb and rt elements themselves can contain span . An application of ruby ruby, however, MUST not use such arbitrary nesting.

The data category determines what is being selected. The necessary data category specific defaults are described in Section 6.1:   Position, Defaults, Inheritance and Overriding of Data Categories .

<text
  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="1.0"   xml:lang="en">

      its:version="2.0"   xml:lang="en">

   <head
         its:translate="no">
      <author>Sven Corneliusson</author>
      <date>2006-09-26T17:34:04Z</date>
      <title
            its:translate="yes"   role="header">Bidirectional Text</title>
   </head>
   <body>
      <par>In Arabic, the title <quote   xml:lang="ar"
               its:dir="rtl">نشاط التدويل، W3C</quote>
         means <quote>Internationalization Activity, W3C</quote>.</par>
   </body>
</text>

Markup for local selection is defined as follows. The attribute group att.local.no-ns.attributes contains ITS attributes in no namespace and is used with the ITS elements span , locNote , ruby , rb , rt , rbc , rtc and rp . The attribute group att.local.with-ns.attributes contains namespace qualified ITS attributes and is used with elements from different namespaces. The attribute group att.local.html5 att.local.html5.attributes contains ITS attribute for HTML5.

att.local.no-ns

[8]	att.local.no-ns.attributes	::=	att.local.no-ns.attribute.translate , att.local.no-ns.attribute.locNote , att.local.no-ns.attribute.locNoteType , att.local.no-ns.attribute.locNoteRef , att.local.no-ns.attribute.termInfoRef , att.local.no-ns.attribute.term , att.local.no-ns.attribute.dir , att.local.no-ns.attribute.withinText ,att.local.no-ns.attribute.localeFilterType ,att.local.no-ns.attribute.localeFilterList
[9]	att.local.no-ns.attribute.translate	::=	attribute translate { "yes" | "no" }?
[10]	att.local.no-ns.attribute.locNote	::=	attribute locNote { string }?
[11]	att.local.no-ns.attribute.locNoteType	::=	attribute locNoteType { "alert" | "description" }?
[12]	att.local.no-ns.attribute.locNoteRef	::=	attribute locNoteRef { xsd:anyURI }?
[13]	att.local.no-ns.attribute.termInfoRef	::=	attribute termInfoRef { xsd:anyURI }?
[14]	att.local.no-ns.attribute.term	::=	attribute term { "yes" | "no" }?
[15]	att.local.no-ns.attribute.dir	::=	attribute dir { "ltr" | "rtl" | "lro" | "rlo" }?
[16]	att.local.no-ns.attribute.withinText	::=	attribute withinText { "yes" | "no" | "nested" }?
[17]	att.local.no-ns.attribute.localeFilterType	::=	attribute localeFilterType { "all" | "none" | "include" | "exclude" }?
[18]	att.local.no-ns.attribute.localeFilterList	::=	attribute localeFilterList { string }?

att.local.with-ns

[16] [19]	att.local.with-ns.attributes	::=	att.local.with-ns.attribute.translate , att.local.with-ns.attribute.locNote , att.local.with-ns.attribute.locNoteType , att.local.with-ns.attribute.locNoteRef , att.local.with-ns.attribute.termInfoRef , att.local.with-ns.attribute.term , att.local.with-ns.attribute.dir , att.local.with-ns.attribute.withinText ,att.local.with-ns.attribute.localeFilterType ,att.local.with-ns.attribute.localeFilterList
[17] [20]	att.local.with-ns.attribute.translate	::=	attribute its:translate { "yes" | "no" }?
[18] [21]	att.local.with-ns.attribute.locNote	::=	attribute its:locNote { string }?
[19] [22]	att.local.with-ns.attribute.locNoteType	::=	attribute its:locNoteType { "alert" | "description" }?
[20] [23]	att.local.with-ns.attribute.locNoteRef	::=	attribute its:locNoteRef { xsd:anyURI }?
[21] [24]	att.local.with-ns.attribute.termInfoRef	::=	attribute its:termInfoRef { xsd:anyURI }?
[22] [25]	att.local.with-ns.attribute.term	::=	attribute its:term { "yes" | "no" }?
[23] [26]	att.local.with-ns.attribute.dir	::=	attribute its:dir { "ltr" | "rtl" | "lro" | "rlo" }?
[27]	att.local.with-ns.attribute.withinText	::=	attribute its:withinText { "yes" | "no" | "nested" }?
[28]	att.local.with-ns.attribute.localeFilterType	::=	attribute its:localeFilterType { "all" | "none" | "include" | "exclude" }?
[29]	att.local.with-ns.attribute.localeFilterList	::=	attribute its:localeFilterList { string }?

att.local.html5

[24] [30]	att.local.html5.attributes	::=	att.local.html5.attribute.translate , att.local.html5.attribute.its-loc-note , att.local.html5.attribute.its-loc-note-type , att.local.html5.attribute.its-loc-note-ref , att.local.html5.attribute.its-term-info-ref , att.local.html5.attribute.its-term , att.local.html5.attribute.dir att.local.html5.attribute.its-within-text ,att.local.html5.attribute.locale-filter-type ,att.local.html5.attribute.locale-filter-list
[25] [31]	att.local.html5.attribute.translate att.local.html5.attribute.its-loc-note	::=	attribute translate its-loc-note { "yes" | "no" string }?
[26] [32]	att.local.html5.attribute.its-loc-note att.local.html5.attribute.its-loc-note-type	::=	attribute its-loc-note its-loc-note-type { string "alert" | "description" }?
[27] [33]	att.local.html5.attribute.its-loc-note-type att.local.html5.attribute.its-loc-note-ref	::=	attribute its-loc-note-type its-loc-note-ref { "alert" | "description" xsd:anyURI }?
[28] [34]	att.local.html5.attribute.its-loc-note-ref att.local.html5.attribute.its-term-info-ref	::=	attribute its-loc-note-ref its-term-info-ref { xsd:anyURI }?
[29] [35]	att.local.html5.attribute.its-term-info-ref att.local.html5.attribute.its-term	::=	attribute its-term-info-ref its-term { xsd:anyURI "yes" | "no" }?
[30] [36]	att.local.html5.attribute.its-term att.local.html5.attribute.its-within-text	::=	attribute its-term its-within-text { "yes" | "no" | "nested" }?
[31] [37]	att.local.html5.attribute.dir att.local.html5.attribute.locale-filter-type	::=	attribute dir locale-filter-type { "ltr" "all" | "rtl" "none" | "lro" "include" | "rlo" "exclude" }?
[38]	att.local.html5.attribute.locale-filter-list	::=	attribute locale-filter-list { string }?

span

[32] [39]	span	::=	element its:span { span.content, span.attributes }
[33] [40]	span.content	::=	( text | ruby | span )*
[34] [41]	span.attributes	::=	att.local.no-ns.attributes

6.2.1 Definition

The Translate data category expresses information about whether the content of an element or attribute should be translated or not. The values of this data category are "yes" (translatable) or "no" (not translatable).

6.2.2 Implementation

The Translate data category can be expressed with global rules, or locally on an individual element. The information applies to the textual content of the element, including child elements, but excluding attributes. The default is that elements are translatable and attributes are not.

GLOBAL: The translateRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required translate attribute with the value "yes" or "no".

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">

   <its:translateRule   translate="no"   selector="//code"/>
</its:rules>

LOCAL: The following local markup is available for the Translate data category:

• A translate attribute with the value "yes" or "no".

<messages
xmlns:its="http://www.w3.org/2005/11/its"
      its:version="1.0">
   <msg   num="123">Click
Resume
Button
on
Status
Display
or
   
<panelmsg
            its:translate="no">CONTINUE</panelmsg>
Button
   
on
printer
panel</msg>

  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="2.0">
   <msg   num="123">Click Resume Button on Status Display or  
      <panelmsg
            its:translate="no">CONTINUE</panelmsg> Button
      on printer panel</msg>

</messages>

<!DOCTYPE html>
<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>Translate
flag
test:
Default</title>

      <title>Translate flag test: Default</title>

   </head>
   <body>
      <p>The
<span   translate="no">World
Wide
Web
Consortium</span>
is
      
making
the
World
Web
Web
worldwide!</p>

      <p>The <span   translate="no">World Wide Web Consortium</span> is
        making the World Web Web worldwide!</p>

   </body>
</html>

6.2.3 Markup Declarations for Translate

translateRule

[35] [42]	translateRule	::=	element its:translateRule { translateRule.content, translateRule.attributes }
[36] [43]	translateRule.content	::=	empty
[37] [44]	translateRule.attributes	::=	att.selector.attributes , attribute translate { "yes" | "no" }

att.translate

[38] [45]	att.translate.attributes	::=	att.translate.attribute.translate
[39] [46]	att.translate.attribute.translate	::=	attribute its:translate { "yes" | "no" }?

att.translate.html5

[40] [47]	att.translate.html5.attributes	::=	att.translate.html5.attribute.translate
[41] [48]	att.translate.html5.attribute.translate	::=	attribute translate { "yes" | "no" }?

6.3.1 Definition

The Localization Note data category is used to communicate notes to localizers about a particular item of content.

This data category can be used for several purposes, including, but not limited to:

• Tell the translator how to translate parts of the content

• Expand on the meaning or contextual usage of a specific element, such as what a variable refers to or how a string will be used on in the user interface

• Clarify ambiguity and show relationships between items sufficiently to allow correct translation (e.g. (e.g., in many languages it is impossible to translate the word " word" enabled " in isolation without knowing the gender, number and case of the thing it refers to.)

• Indicate why a piece of text is emphasized (important, sarcastic, etc.)

Two types of informative notes are needed:

• An alert contains information that the translator must read before translating a piece of text. Example: an instruction to the translator to leave parts of the text in the source language.

• A description provides useful background information that the translator will refer to only if they wish. Example: a clarification of ambiguity in the source text.

Editing tools may offer an easy way to create this type of information. Translation tools can be made to recognize the difference between these two types of localization notes, and present the information to translators in different ways.

6.3.2 Implementation

The Localization Note data category can be expressed with global rules, or locally on an individual element. The information applies to the textual content of the element, including child elements, but but excluding attributes.

GLOBAL: The locNoteRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required locNoteType attribute with the value "description" or "alert".

• Exactly one of the following:

  • A locNote element that contains the note itself and allows for local ITS markup .

  • A locNotePointer attribute that contains a relative XPath expression pointing to a node that holds the localization note.

  • A locNoteRef attribute that contains a URI referring to the location of the localization note.

  • A locNoteRefPointer attribute that contains a relative XPath expression pointing to a node that holds the URI referring to the location of the localization note.

<myRes
  xmlns:its="http://www.w3.org/2005/11/its" >
   <head>
      <its:rules   version="1.0"

      <its:rules   version="2.0"

            its:translate="no">
         <its:locNoteRule   locNoteType="alert"   selector="//msg[@id='DisableInfo']">
            <its:locNote>The variable {0} has three possible values: 'printer', 
                'stacker' and 'stapler options'.</its:locNote>
         </its:locNoteRule>
      </its:rules>
   </head>
   <body>
      <msg   id="DisableInfo">The {0} has been disabled.</msg>
   </body>
</myRes>

<Res
xmlns:its="http://www.w3.org/2005/11/its"
>

  xmlns:its="http://www.w3.org/2005/11/its" >

   <prolog>
      <its:rules   version="1.0">

      <its:rules   version="2.0">

         <its:translateRule   selector="//msg/notes"   translate="no"/>
         <its:locNoteRule   locNoteType="description"   selector="//msg/data"   locNotePointer="../notes"/>
      </its:rules>
   </prolog>
   <body>
      <msg   id="FileNotFound">
         <notes>Indicates
that
the
resource
file
{0}
could
not
be
loaded.</notes>
         <data>Cannot
find
the
file
{0}.</data>

         <notes>Indicates that the resource file {0} could not be loaded.</notes>
         <data>Cannot find the file {0}.</data>

      </msg>
      <msg   id="DivByZero">
         <notes>A
division
by
0
was
going
to
be
computed.</notes>
         <data>Invalid
parameter.</data>

         <notes>A division by 0 was going to be computed.</notes>
         <data>Invalid parameter.</data>

      </msg>
   </body>
</Res>

<myRes
  xmlns:its="http://www.w3.org/2005/11/its" >
   <head>
      <its:rules   version="1.0">

      <its:rules   version="2.0">

         <its:locNoteRule   locNoteType="description"   selector="//msg[@id='NotFound']"   locNoteRef="ErrorsInfo.html#NotFound"/>
      </its:rules>
   </head>
   <body>
      <msg   id="NotFound">Cannot find {0} on {1}.</msg>
   </body>
</myRes>

<dataFile
xmlns:its="http://www.w3.org/2005/11/its"
>

  xmlns:its="http://www.w3.org/2005/11/its" >

   <prolog>
      <its:rules   version="1.0">

      <its:rules   version="2.0">

         <its:locNoteRule   locNoteType="description"   selector="//data"   locNoteRefPointer="../@noteFile"/>
      </its:rules>
   </prolog>
   <body>
      <string   id="FileNotFound"   noteFile="Comments.html#FileNotFound">
         <data>Cannot
find
the
file
{0}.</data>

         <data>Cannot find the file {0}.</data>

      </string>
      <string   id="DivByZero"   noteFile="Comments.html#DivByZero">
         <data>Invalid
parameter.</data>

         <data>Invalid parameter.</data>

      </string>
   </body>
</dataFile>

LOCAL: The following local markup is available for the Localization Note data category:

• One of the following:

  • A locNote attribute that contains the note itself.

  • A locNoteRef attribute that contains a URI referring to the location of the localization note.

• An optional locNoteType attribute with the value "description" or "alert". If the locNoteType attribute is not present, the type of localization note will be assumed to be "description".

<msgList
xmlns:its="http://www.w3.org/2005/11/its"
   xml:space="preserve"
      its:version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    xml:space="preserve"
      its:version="2.0">

   <data   name="LISTFILTERS_VARIANT"
         its:locNote="Keep
the
leading
space!"

         its:locNote="Keep the leading space!"

         its:locNoteType="alert">
      <value>
Variant
{0}
=
{1}
({2})</value>

      <value> Variant {0} = {1} ({2})</value>

   </data>
   <data
         its:locNote="%1\$s
is
the
original
text's
date
in
the
format
YYYY-MM-DD
HH:MM
always
in
GMT">
      <value>Translated
from
English
content
dated
<span   id="version-info">%1\$s</span>
GMT.</value>

         its:locNote="%1\$s is the original text's date in the format YYYY-MM-DD HH:MM always in GMT">
      <value>Translated from English content dated <span   id="version-info">%1\$s</span> GMT.</value>

   </data>
</msgList>

<!DOCTYPE html>

<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>LocNote
test:
Default</title>

      <title>LocNote test: Default</title>

   </head>
   <body>
      <p>This
is
a
<span   its-loc-note="Check
with
terminology
engineer"   its-loc-note-type="alert">motherboard</span>.</p>

      <p>This is a <span   its-loc-note="Check with terminology engineer"   its-loc-note-type="alert">motherboard</span>.</p>

   </body>
</html>

6.3.3 Markup Declarations for Localization Note

locNoteRule

[42] [49]	locNoteRule	::=	element its:locNoteRule { locNoteRule.content, locNoteRule.attributes }
[43] [50]	locNoteRule.content	::=	locNote ?
[44] [51]	locNoteRule.attributes	::=	att.selector.attributes , attribute locNotePointer { string }?, attribute locNoteType { "alert" | "description" }, attribute locNoteRef { xsd:anyURI }?, attribute locNoteRefPointer { string }?

locNote

[45] [52]	locNote	::=	element its:locNote { locNote.content, locNote.attributes }
[46] [53]	locNote.content	::=	( text | ruby | span )*
[47] [54]	locNote.attributes	::=	att.local.no-ns.attributes

att.locNote

[48] [55]	att.locNote.attributes	::=	att.locNote.attribute.locNote , att.locNote.attribute.locNoteType , att.locNote.attribute.locNoteRef
[49] [56]	att.locNote.attribute.locNote	::=	attribute its:locNote { string }?
[50] [57]	att.locNote.attribute.locNoteType	::=	attribute its:locNoteType { "alert" | "description" }?
[51] [58]	att.locNote.attribute.locNoteRef	::=	attribute its:locNoteRef { xsd:anyURI }?

att.locNote.html5

[52] [59]	att.locNote.html5.attributes	::=	att.locNote.html5.attribute.its-loc-note , att.locNote.html5.attribute.its-loc-note-type , att.locNote.html5.attribute.its-loc-note-ref
[53] [60]	att.locNote.html5.attribute.its-loc-note	::=	attribute its-loc-note { string }?
[54] [61]	att.locNote.html5.attribute.its-loc-note-type	::=	attribute its-loc-note-type { "alert" | "description" }?
[55] [62]	att.locNote.html5.attribute.its-loc-note-ref	::=	attribute its-loc-note-ref { xsd:anyURI }?

6.4.1 Definition

The Terminology data category is used to mark terms and optionally associate them with information, such as definitions. This helps to increase consistency across different parts of the documentation. It is also helpful for translation.

6.4.2 Implementation

The Terminology data category can be expressed with global rules, or locally on an individual element. There is no inheritance. The default is that neither elements nor attributes are terms. rules, or locally on an individual element. There is no inheritance. The default is that neither elements nor attributes are terms.

GLOBAL: The termRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required term attribute with the value "yes" or "no".

• Exactly one of the following:

  • A termInfoPointer attribute that contains a relative XPath expression pointing to a node that holds the terminology information.

  • A termInfoRef attribute that contains a URI referring to the resource providing information about the term.

  • A termInfoRefPointer attribute that contains a relative XPath expression pointing to a node that holds the URI referring to the location of the terminology information.

<text
  xmlns:its="http://www.w3.org/2005/11/its" >
   <its:rules   version="1.0">

   <its:rules   version="2.0">

      <its:termRule   selector="//term"   term="yes"   termInfoPointer="id(@def)"/>
   </its:rules>
   <p>We may define <term   def="TDPV">discoursal point of view</term>
   as <gloss   xml:id="TDPV">the relationship, expressed through discourse
      structure, between the implied author or some other addresser,
      and the fiction.</gloss>
   </p>
</text>

<text
xmlns:its="http://www.w3.org/2005/11/its"
>
   <its:rules   version="1.0">

   <its:rules   version="2.0">

      <its:termRule   selector="//term[1]"   term="yes"   termInfoRef="#TDPV"/>
   </its:rules>
   <p>We
may
define
<term>discoursal
point
of
view</term>
   as
<gloss   xml:id="TDPV">the
relationship,
expressed
through
discourse
      structure,
between
the
implied
author
or
some
other
addresser,
      and
the
fiction.</gloss>
   </p>
</text>

<text
xmlns:its="http://www.w3.org/2005/11/its"
>
   <its:rules   version="1.0">

   <its:rules   version="2.0">

      <its:termRule   selector="//term"   term="yes"   termInfoRefPointer="@target"/>
   </its:rules>
   <p>We
may
define
<term   target="#TDPV">discoursal
point
of
view</term>
   as
<gloss   xml:id="TDPV">the
relationship,
expressed
through
discourse
      structure,
between
the
implied
author
or
some
other
addresser,
      and
the
fiction.</gloss>
   </p>
</text>

LOCAL: The following local markup is available for the Terminology data category:

• A term attribute with the value "yes" or "no".

• An optional termInfoRef attribute that contains a URI referring to the resource providing information about the term.

<book
xmlns:its="http://www.w3.org/2005/11/its"
      its:version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="2.0">

   <head>...</head>
   <body>
...
<p>And
he
said:
you
need
a
      
new
<quote

   <body> ...  <p>And he said: you need a
       new <quote

               its:term="yes">motherboard</quote>
      </p>
...
   
</body>

      </p> ...
    </body>

</book>

<!DOCTYPE html>

<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>Terminology
test:
default</title>

      <title>Terminology test: default</title>

   </head>
   <body>
      <p>We
need
a
new
<span   its-term="yes">motherboard</span>

      <p>We need a new <span   its-term="yes">motherboard</span>

      </p>
   </body>
</html>

6.4.3 Markup Declarations for Terminology

termRule

[56] [63]	termRule	::=	element its:termRule { termRule.content, termRule.attributes }
[57] [64]	termRule.content	::=	empty
[58] [65]	termRule.attributes	::=	att.selector.attributes , attribute term { "yes" | "no" }, attribute termInfoRef { xsd:anyURI }?, attribute termInfoRefPointer { string }?, attribute termInfoPointer { string }?

att.term

[59] [66]	att.term.attributes	::=	att.term.attribute.termInfoRef , att.term.attribute.term
[60] [67]	att.term.attribute.termInfoRef	::=	attribute its:termInfoRef { xsd:anyURI }?
[61] [68]	att.term.attribute.term	::=	attribute its:term { "yes" | "no" }?

att.term.html5

[62] [69]	att.term.html5.attributes	::=	att.term.html5.attribute.its-term-info-ref , att.term.html5.attribute.its-term
[63] [70]	att.term.html5.attribute.its-term-info-ref	::=	attribute its-term-info-ref { xsd:anyURI }?
[64] [71]	att.term.html5.attribute.its-term	::=	attribute its-term { "yes" | "no" }?

6.5.1 Definition

The Directionality data category allows the user to specify the base writing direction of blocks, embeddings and overrides for the Unicode bidirectional algorithm. It has four values: "ltr", "rtl", "lro" and "rlo".

6.5.2 Implementation

The Directionality data category can be expressed with global rules, or locally on an individual element. The information applies to the textual content of the element, including child elements and attributes. The default is that both elements and attributes have the directionality of left-to-right.

GLOBAL: The dirRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required dir attribute with the value "ltr", "rtl", "lro" or "rlo".

<text   xml:lang="en">
   <body>
      <par>In Hebrew, the title <quote   xml:lang="he"   direction="rtlText">פעילות ×”×‘×™× ×ו×, W3C</quote>
         means <quote>Internationalization Activity, W3C</quote>.</par>
   </body>
</text>

<its:rules
xmlns:its="http://www.w3.org/2005/11/its"
   version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">

   <its:dirRule   dir="rtl"   selector="//*[@direction='rtlText']"/>
</its:rules>

LOCAL: The following local markup is available for the Directionality data category:

• A dir attribute with the value "ltr", "rtl", "lro" or "rlo".

<text
xmlns:its="http://www.w3.org/2005/11/its"
   xml:lang="en"
      its:version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    xml:lang="en"
      its:version="2.0">

   <body>
      <par>In
Arabic,
the
title
<quote   xml:lang="ar"
               its:dir="rtl">
نشاط
التدويل،
W3C
</quote>
      
means
<quote>Internationalization
Activity,
W3C</quote>.</par>

      <par>In Arabic, the title <quote   xml:lang="ar"
               its:dir="rtl">نشاط التدويل، W3C</quote>
         means <quote>Internationalization Activity, W3C</quote>.</par>

   </body>
</text>

<!DOCTYPE html>

<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>Dir
test:
Default</title>

      <title>Dir test: Default</title>

   </head>
   <body>
      <p>In
Arabic,
the
title
<quote   xml:lang="ar"   dir="rtl">نشاط
التدويل،
W3C</quote>
      
means
<quote>Internationalization
Activity,
W3C</quote>.</p>

      <p>In Arabic, the title <quote   xml:lang="ar"   dir="rtl">نشاط التدويل، W3C</quote>
         means <quote>Internationalization Activity, W3C</quote>.</p>

   </body>
</html>

6.5.3 Markup Declarations for Directionality

dirRule

[65] [72]	dirRule	::=	element its:dirRule { dirRule.content, dirRule.attributes }
[66] [73]	dirRule.content	::=	empty
[67] [74]	dirRule.attributes	::=	att.selector.attributes , attribute dir { "ltr" | "rtl" | "lro" | "rlo" }

att.dir

[68] [75]	att.dir.attributes	::=	att.dir.attribute.dir
[69] [76]	att.dir.attribute.dir	::=	attribute its:dir { "ltr" | "rtl" | "lro" | "rlo" }?

att.dir.html5

[70] [77]	att.dir.html5.attributes	::=	att.dir.html5.attribute.dir
[71] [78]	att.dir.html5.attribute.dir	::=	attribute dir { "ltr" | "rtl" | "lro" | "rlo" }?

6.6.1 Definition

The Ruby data category is used for a run of text that is associated with another run of text, referred to as the base text. Ruby text is used to provide a short annotation of the associated base text. It is most often used to provide a reading (pronunciation) guide.

6.6.2 Implementation

The Ruby data category can be expressed with global rules, or locally. There is no inheritance.

GLOBAL: The rubyRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies. This is the ruby base text.

• An optional rubyPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the ruby element.

• An optional rpPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the ruby parenthesis.

• An optional rbcPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the ruby base container.

• An optional rtcPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the ruby text container.

• An optional rbspanPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the rbspan attribute.

• An optional rubyText element that contains the ruby text. text.

• An optional rtPointer attribute that contains a relative XPath expression pointing to a node that corresponds to the ruby text.

<text
  xmlns:its="http://www.w3.org/2005/11/its" >
   <head> ... 
     <its:rules   version="1.0">

     <its:rules   version="2.0">

         <its:rubyRule   selector="/text/body/img[1]/@alt">
            <its:rubyText>World Wide Web Consortium</its:rubyText>
         </its:rubyRule>
      </its:rules>
   </head>
   <body>
      <img   src="w3c_home.png"   alt="W3C"/> ...
    </body>
</text>

LOCAL: In a document, the Ruby data category is realized with a ruby element. It contains the following:

• An rb element that contains the ruby base text and allows for local ITS markup .

• An rp element that contains the ruby parenthesis. It is used in case of simple markup to specify characters that can denote the beginning and end of ruby text when user agents do not have other ways to present ruby text distinctively from the base text.

• An rt element that contains the ruby text and allows for local ITS markup .It has an optional rbspan attribute. The rbspan attribute allows an rt element to span multiple rb elements.

• An rbc element that contains the ruby base container.

• An rtc element that contains the ruby text container.

All these elements share the attributes of the span element.

<text
  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="1.0">

      its:version="2.0">

   <head> ... </head>
   <body>
      <p>ã“ã®æœ¬ã¯ <its:ruby>
            <its:rb>慶応義塾大学</its:rb>
            <its:rp>(</its:rp>
            <its:rt>ã‘ã„ãŠã†ãŽã˜ã‚…ãã ã„ãŒã</its:rt>
            <its:rp>)</its:rp>
         </its:ruby>ã®æ­´å²ã‚’説明ã™ã‚‹ã‚‚ã®ã§ã™ã€‚</p>
   </body>
</text>

6.6.3 Markup Declarations for Ruby

rubyRule

[72] [79]	rubyRule	::=	element its:rubyRule { rubyRule.content, rubyRule.attributes }
[73] [80]	rubyRule.content	::=	rubyText ?
[74] [81]	rubyRule.attributes	::=	att.selector.attributes , attribute rubyPointer { string }?, attribute rtPointer { string }?, attribute rpPointer { string }?, attribute rbcPointer { string }?, attribute rtcPointer { string }?, attribute rbspanPointer { string }?

rubyText

[75] [82]	rubyText	::=	element its:rubyText { rubyText.content, rubyText.attributes }
[76] [83]	rubyText.content	::=	text
[77] [84]	rubyText.attributes	::=	att.local.no-ns.attributes , attribute rbspan { string }?

ruby

[78] [85]	ruby	::=	element its:ruby { ruby.content, ruby.attributes }
[79] [86]	ruby.content	::=	( rb , ( rt | ( rp , rt , rp ) ) ) | ( rbc , rtc , rtc ? )
[80] [87]	ruby.attributes	::=	att.local.no-ns.attributes

rb

[81] [88]	rb	::=	element its:rb { rb.content, rb.attributes }
[82] [89]	rb.content	::=	( text | span )*
[83] [90]	rb.attributes	::=	att.local.no-ns.attributes

rt

[84] [91]	rt	::=	element its:rt { rt.content, rt.attributes }
[85] [92]	rt.content	::=	( text | span )*
[86] [93]	rt.attributes	::=	att.local.no-ns.attributes , attribute rbspan { string }?

rbc

[87] [94]	rbc	::=	element its:rbc { rbc.content, rbc.attributes }
[88] [95]	rbc.content	::=	rb +
[89] [96]	rbc.attributes	::=	att.local.no-ns.attributes

rtc

[90] [97]	rtc	::=	element its:rtc { rtc.content, rtc.attributes }
[91] [98]	rtc.content	::=	rt +
[92] [99]	rtc.attributes	::=	att.local.no-ns.attributes

rp

[93] [100]	rp	::=	element its:rp { rp.content, rp.attributes }
[94] [101]	rp.content	::=	text
[95] [102]	rp.attributes	::=	att.local.no-ns.attributes

6.7.1 Definition

The element langRule is used to express the language of a given piece of content. The langPointer attribute points to the markup which expresses the language of the text selected by the selector attribute. This markup MUST use values that conform to [BCP47] . The recommended way to specify language identification is to use xml:lang . The langRule element is intended only as a fall-back mechanism for documents where language is identified with another construct.

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">

   <its:langRule   selector="//p"   langPointer="@mylangattribute"/>
</its:rules>

6.7.2 Implementation

The Language Information data category can be expressed only with global rules. The information applies to the textual content of the element, including child elements and attributes. There is no default.

GLOBAL: The langRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required langPointer attribute that contains a relative XPath expression pointing to a node that contains language information.

6.7.3 Markup Declarations for Language Information

langRule

[96] [103]	langRule	::=	element its:langRule { langRule.content, langRule.attributes }
[97] [104]	langRule.content	::=	empty
[98] [105]	langRule.attributes	::=	att.selector.attributes , attribute langPointer { string }

6.8.1 Definition

The Elements Within Text data category reveals if and how an element affects the way text content behaves from a linguistic viewpoint. This information is for example relevant to provide basic text segmentation hints for tools such as translation memory systems. The values associated with this data category are:

• "yes" : The element and its content are part of the flow of its parent element. For example the element strong in [XHTML 1.0] :

  <strong>Appaloosa horses</strong> have spotted coats.

• "nested" : The element is part of the flow of its parent element, its content is an independent flow. For example the element fn in [DITA 1.0] :

  Palouse horses<fn>A Palouse horse is the same as an Appaloosa.</fn> have spotted coats.

• "no" : The element splits the text flow of its parent element and its content is an independent text flow. For example the element p when inside the element li in DITA or XHTML:

  <li>Palouse horses: <p>They have spotted coats.</p> <p>They have been bred by the Nez Perce.</p> </li>

6.8.2 Implementation

The Elements Within Text data category can be expressed with global rules, or locally on an individual element. There is no inheritance. The default is that elements are not within text.

GLOBAL: The withinTextRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required withinText attribute with the value "yes", "no" or "nested".

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="1.0">

  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">

   <its:withinTextRule   withinText="yes"   selector="//b | //em | //i"/>
</its:rules>

LOCAL: The following local markup is available for the Elements Within Text data category:

• A withinText attribute with the values "yes", "no" or "nested".

<text
  xmlns:its="http://www.w3.org/2005/11/its" 
      its:version="2.0">
   <body>
      <par>Text with <bold
               its:withinText="yes">bold</bold>.</par>
   </body>
</text>

<!DOCTYPE html>
<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>Within text test: Default</title>
   </head>
   <body>
      <p>Text with <span   its-within-text="yes">bold</span>.</p>
   </body>
</html>

6.8.3 Markup Declarations for Elements Within Text

withinTextRule

[99] [106]	withinTextRule	::=	element its:withinTextRule { withinTextRule.content, withinTextRule.attributes }
[100] [107]	withinTextRule.content	::=	empty
[101] [108]	withinTextRule.attributes	::=	att.selector.attributes , attribute withinText { "yes" | "no" | "nested" }

att.withinText

[109]	att.withinText.attributes	::=	att.withinText.attribute.withinText
[110]	att.withinText.attribute.withinText	::=	attribute its:withinText { "yes" | "no" | "nested" }?

att.withinText.html5

[111]	att.withinText.html5.attributes	::=	att.withinText.html5.attribute.its-within-text
[112]	att.withinText.html5.attribute.its-within-text	::=	attribute its-within-text { "yes" | "no" | "nested" }?

6.9.1 Definition

The Domain data category will is used to identify the domain of content.

This data category addresses various challenges:

• Often domain related information in content does exist, e.g. keywords in the HTML meta element. The Domain data category addresses this by providing a mechanism to point to this information.

• There are many flat or structured lists of domain related values, keywords, key phrases, classification codes, ontologies. The Domain data category does not propose a given list; rather it provides a mapping mechanism to associate values in content with consumer tool specific values needed for processing domain information.

6.9.2 Implementation

The Domain data category can be defined expressed only with global rules. The information applies to the textual content of the element, including child elements and attributes. There is no default.

GLOBAL: The domainRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required domainPointer attribute that contains a relative XPath expression pointing to a node that contains the domain information.

• An optional domainMapping attribute that contains a comma separated list of mappings between values in the content and consumer tool specific values. The left part of the pair is part of the source content and unique within the mapping. The right part of the mapping belongs to the consumer tool. Several left parts can map to a single right part. The values in the left or the right part of the mapping may contain spaces; in that case they MUST be delimited by quotation marks, that is pairs of APOSTROPHE (Unicode code point U+0027) or QUOTATION MARK (U+0023).

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">
   <its:domainRule   selector="/html/body"   domainPointer="/html/head/meta[@name='DC.subject']/@content"/>
</its:rules>

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">
   <its:domainRule   selector="/html/body"   domainPointer="/html/head/meta[@name='DC.subject']/@content"
         domainMapping="automotive auto, medical medicine, 'criminal law' law, 'property law' law"/>
</its:rules>

6.9.3 Markup Declarations for Domain

domainRule

[113]	domainRule	::=	element its:domainRule { domainRule.content, domainRule.attributes }
[114]	domainRule.content	::=	empty
[115]	domainRule.attributes	::=	att.selector.attributes ,attribute domainPointer { string }, attribute domainMapping { string }?

6.11.1 Definition

The LocaleFilter Locale Filter data category will specifies that a node is only applicable to certain locales, or that it is not applicable to certain locales.

This data category can be used for several purposes, including, but not limited to:

• Include a legal notice only in locales for certain regions.

• Drop editorial notes from all localized output.

The Locale Filter data category associates with each selected node a filter type and a list of language ranges conforming to [BCP47] .The list of language ranges is a comma-separated list of basic language ranges. Whitespace surrounding language ranges is ignored.

The locale filter type can take the following values:

• "all": The node is included in all locales.

• "none": The node is included in no locales.

• "include": The node is only included in locales that match at least one language range in the list, using basic filtering as defined in [BCP47] .

• "exclude": The node is included in all locales except those that match at least one language range in the list, using basic filtering as defined in [BCP47] .

If the locale filter type is "all" or "none", a list of language ranges SHOULD NOT be provided. If one is, it MUST be ignored. If the locale filter type is "include" or "exclude", a list of language ranges SHOULD be provided. If one is not, it MUST default to the empty list.

6.11.2 Implementation

The Locale Filter data category can be expressed with global rules, or locally on an updated version individual element. The information applies to the textual content of the element, including child elements and attributes. The default is that the locale filter type is "all".

Implementations MUST NOT combine lists of language ranges from multiple rules or local attributes.

GLOBAL: The localeFilterRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this document. For details rule applies.

• A required localeFilterType attribute with the value "all", "none", "include", or "exclude".

• An optional localeFilterList attribute with a comma-separated list of language ranges.

<book
  xmlns:its="http://www.w3.org/2005/11/its" >
   <info>
      <its:rules   version="2.0">
         <its:localeFilterRule   selector="//legalnotice[@role='Canada']"   localeFilterType="include"   localeFilterList="en-CA, fr-CA"/>
      </its:rules>
      <legalnotice   role="Canada">
         <para>This legal notice is only for Canadian locales.</para>
      </legalnotice>
   </info>
</book>

<section
  xmlns:its="http://www.w3.org/2005/11/its" >
   <info>
      <its:rules   version="2.0">
         <its:localeFilterRule   selector="//remark"   localeFilterType="none"/>
      </its:rules>
   </info>
   <remark>Note: This section will be written later.</remark>
</section>

LOCAL: The following local markup is available for the proposed Locale Filter data category, see category:

• A localeFilterType attribute with the ITS 2.0 Requirements document . value "all", "none", "include", or "exclude".

• A localeFilterList attribute with a comma-separated list of language ranges.

<book
  xmlns:its="http://www.w3.org/2005/11/its" >
   <info>
      <legalnotice
            its:localeFilterType="include"
            its:localeFilterList="en-CA, fr-CA">
         <para>This legal notice is only for Canadian locales.</para>
      </legalnotice>
   </info>
</book>

6.11.3 Markup Declarations for Locale Filter

localeFilterRule

[116]	localeFilterRule	::=	element its:localeFilterRule { localeFilterRule.content, localeFilterRule.attributes }
[117]	localeFilterRule.content	::=	empty
[118]	localeFilterRule.attributes	::=	att.selector.attributes ,attribute localeFilterType { "all" | "none" | "include" | "exclude" }, attribute localeFilterList { string }?

att.localeFilter

[119]	att.localeFilter.attributes	::=	att.localeFilter.attribute.localeFilterType ,att.localeFilter.attribute.localeFilterList
[120]	att.localeFilter.attribute.localeFilterType	::=	attribute its:localeFilterType { "all" | "none" | "include" | "exclude" }?
[121]	att.localeFilter.attribute.localeFilterList	::=	attribute its:localeFilterList { string }?

att.localeFilter.html5

[122]	att.localeFilter.html5.attributes	::=	att.localeFilter.html5.attribute.its-locale-filter-type ,att.localeFilter.html5.attribute.its-locale-filter-list
[123]	att.localeFilter.html5.attribute.its-locale-filter-type	::=	attribute its-locale-filter-type { "all" | "none" | "include" | "exclude" }?
[124]	att.localeFilter.html5.attribute.its-locale-filter-list	::=	attribute its-locale-filter-list { string }?

6.14.1 Definition

The External Resource data category indicates that a node represents or references potentially translatable data in a resource outside the document. Examples of such resources are external images and audio or video files.

6.14.2 Implementation

The External Resource data category can be expressed only with global rules. The information applies to the textual content of the element, including child elements and attributes. There is no default.

GLOBAL: The externalResourceRefRule element contains the following:

• A required selector attribute. It contains an XPath expression which selects the nodes to which this rule applies.

• A required externalResourceRefPointer attribute that contains a relative XPath expression pointing to a node that provides the URI of the external resource.

<doc
  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">
   <its:externalResourceRefRule   selector="//db:imagedata | //db:audiodata |  db:videodata"   externalResourceRefPointer="@fileref"/>
</doc>

<its:rules
  xmlns:its="http://www.w3.org/2005/11/its"    version="2.0">
   <its:externalResourceRefRule   selector="//html:video/@src"   externalResourceRefPointer="."/>
   <its:externalResourceRefRule   selector="//html:video/@poster"   externalResourceRefPointer="."/>
</its:rules>

<!DOCTYPE
html>
<html   lang="en">
   <head>
      <meta   charset="utf-8"/>
      <title>Video
element
example</title>
   </head>
   <body>
      <video
            width="640"
            height="360"
            src="http://www.example.com/video/v2.mp"
            poster="video-image.png">
         <p>If
your
browser
doesn't
support
the
<code>video</code>
element,
you
can
<a   href="http://www.example.com/video/v2.mp">download
the
video</a>
instead.</p>
      </video>
   </body>
</html>

6.14.3 Markup Declarations for External Resource

externalResourceRefRule

[125]	externalResourceRefRule	::=	element its:externalResourceRefRule { externalResourceRefRule.content, externalResourceRefRule.attributes }
[126]	externalResourceRefRule.content	::=	empty
[127]	externalResourceRefRule.attributes	::=	att.selector.attributes ,attribute externalResourceRefPointer { string }