eXtensible Package (XPackage) 1.0

Working Draft 11 May 2006

Copyright © 2001-2006 GlobalMentor, Inc. This specification may be freely used and copied, but only in unmodified form.

Editor

Garret Wilson (GlobalMentor, Inc.) mailto:garret@globalmentor.com

This Version

http://www.xpackage.org/specification/xpackage-draft-20060511.html

Latest Version

http://www.xpackage.org/specification/

Note: This page is presented for historical purposes only. XPackage has now superseded by URF Content.

Abstract

This specification defines the eXtensible Package format (XPackage) for describing resources and their associations as they appear in packages or collections of resources. It specifies a framework for enumerating the properties of those resources, their methods of inclusion, and their relationships between each another. XPackage use cases include specifying the stylesheets used by an HTML document, declaring the images shared by multiple documents, indicating the author and other metadata of a document, describing how namespaces are used by XML resources, illustrating fallback sequences for varying levels of multimedia support, and providing a manifest for bundling resources into a single archive file.

The XPackage framework is based upon XML and RDF; and provides a central RDF ontology for packaging-specific metadata. XPackage also provides supplementary ontologies for expressing useful metadata indirectly related to packaging. The XPackage framework naturally allows customization through extension.

Status of This Document

This is a draft document and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use this draft as reference material or to cite it as other than "work in progress".

This document was originally produced as a submission to the OeBF Publication Structure Working Group to be the basis in part of the OeB Publication Structure 2.0. Due to the uncertain schedule of future OEBPS versions as of 6 March 2003, this specification is now being developed independently. Please send comments and questions regarding this document to garret@globalmentor.com.

Table of Contents

1. Introduction
2. Definitions
3. Conformance
4. Related Specifications
5. Package Description Document
6. XPackage Ontology
7. File Ontology
8. MIME Ontology
9. Unicode Ontology
10. XML Ontology
11. Package Archive
12. Examples
    • XHTML Document
    • Photo Album
    • QTI Assessment
    • eXtensible eBook (XEbook)
    • Java Archive (JAR) Manifest
    • RDDL Replacement
13. Namespaces Referenced
14. OWL Definitions
15. XML Schemas
16. References
17. Revision History

Introduction

This section is informative.

The World Wide Web Consortium's XML specification [XML] has seen wide acceptance as a method of encoding textual content for display, for maintaining metadata, and for storing other forms of data. As many independent XML documents are increasingly being used in various situations that require these documents to interact in some fashion, there is becoming a need to maintain information in a standard form at a level above independent documents. Such information is necessary not only for indicating to bundling applications the existence of relationships but also for defining the semantics of those relationships. This high-level group-related information includes:

• The binding of an XML document to one or more stylesheets.
• The illustration of a relationship between an XML document and various included resources such as images.
• The binding of various metadata to an XML document.
• A canonical listing of the necessary files for a file or group of files that need to be transported.

This specification describes how a group of related files, or package, can be described, using XML as a storage format for package-related information. This specification does not dictate a particular physical bundling mechanism of the files identified in the package document, although several alternatives are recommended.

This packaging specification uses the RDF specification [RDF] [RDF/XML Syntax] as a framework for identifying resources and describing relationships among those resources. XPackage provides several RDF ontologies and allows others to be integrated. The data model borrows heavily from the model currently in use by the Open eBook Publication Structure version 1.0.1 [OEBPS1], as well as some concepts in the IMS Content Packaging Specification [IMS Content Packaging] version 1.1.2.

Overview

One application of XPackage is in describing an XHTML document and its supporting resources. An XHTML document retrieved from a web site may rely on other resources such as image files that also need to be retrieved, but the supporting resources needed are not obvious without processing the entire XHTML document. Other information about the web page, such as the name of its author, are similarly inaccessible without processing the document contents. XPackage allows this information to be carried separately from the XHTML document.

Some information could be made available in the content of the document, but that would lower the flexibility and usefulness of the document. Stylesheet information, for example, can be hard-coded into a web page through use of the XML namespace processing instruction, but doing so irrevocably binds style information to the web content. XPackage allows stylesheet information to be specified in a document separate from the XHTML document being described.

XPackage allows such descriptive information, which is essentially metadata, to be stored in a standard way in a package description instance. The most common way to store this package description is in a special XML document called a package description document. The outer elements of the package description document of the XHTML document described above might look like the following example.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <xpackage:Package>

    <em>(description of individual resources go here)</em>

  </xpackage:Package>
</rdf:RDF>

Each resource (such as the XHTML document, stylesheets, and images) is described within this package description document. The XHTML document resource is described inside an XML <rdf:Description> element using various properties from various vocabularies, or ontologies. XPackage defines a core packaging ontology along with several supplementary ontologies, and allows authors to create other vocabularies with custom extension property sets. In the example below, the document's required support files are specified using a property from the core XPackage ontology XPackage ontology, xpackage:require. The document's MIME content type ("application/xhtml+xml") is defined using a supplemental XPackage property from the MIME ontology, mime:contentType. The supplemental XML ontology is used to specify a stylesheet using the x:style property. Another property, the document's author (in this case, "Garret Wilson"), is described using a property from the third-party Dublin Core ontology [DC] (defined external to this specification), resulting in a dc:creator property. The example also illustrates usage of other custom ontologies, such as the example:annotation property that has hypothetically been defined outside this specification.

<!--doc.html-->
<rdf:Description rdf:about="doc.html">
  <rdfs:comment>The XHTML document.</rdfs:comment>
  <mime:contentType>application/xhtml+xml</mime:contentType>
  <x:namespace rdf:resource="http://www.w3.org/1999/xhtml"/>
  <x:style rdf:resource="stylesheet.css"/>
  <example:annotation rdf:resource="urn:examples:xhtmldocument-annotation"/>
  <dc:creator>Garret Wilson</dc:creator>
  <xpackage:require rdf:resource="stylesheet.css"/>
  <xpackage:require rdf:resource="image.png"/>
</rdf:Description>

The xpackage:require property specifies which other resources are needed for the correct processing of the XHTML document. In this case, both a stylesheet and an image are listed. More information about those supporting resources may be found in the descriptions for those resources (see below).

A useful aspect of XPackage properties is that not only can they contain literal values (such as the dc:creator value of "Garret Wilson"), they can also contain other resources as their values. The XML property x:style, for example, indicates that another resource identified by stylesheet.css should be the stylesheet of the XHTML document. That stylesheet is itself a resource, described by another rdf:Description element:

<!--stylesheet.css-->
<rdf:Description rdf:about="stylesheet.css">
  <rdfs:comment>The document stylesheet.</rdfs:comment>
  <mime:contentType>text/css</mime:contentType>
</rdf:Description>

The stylesheet's rdf:about attribute serves to identify the resource so that it can be referenced in the properties of other resources, such as is the case with the XHTML document's x:style property. The stylesheet's resource descrption also shows through use of the mime:contentType property that it is a CSS stylesheet (text/css).

The XHTML document through use of the xpackage:require property indicates that another resource identified by "image.png" is also needed by the XHTML document. The separate description of that resource makes it clear that the resource is a PNG image, with a content type of image/png.

<!--image.png-->
<rdf:Description rdf:about="image.png">
  <rdfs:comment>A document image.</rdfs:comment>
  <mime:contentType>image/png</mime:contentType>
</rdf:Description>

The full version of this example can be found in the section entitled, "XHTML Document".

Ontologies

XPackage Ontology

File Ontology

MIME Ontology

Unicode Ontology

XML Ontology

Definitions

Resource

Any entity that can be identified and described. Examples are XML documents, XML fragments, stylsheets, images, audio files. See the [RDF] definition of a resource. Throughout this specification, many types of resources will be mentioned so as to indicate the specific category of resource being discussed. "XML document resource", for instance, is simply a resource that is an XML document, and an "annotation resource" is simply a resource that is an annotation.

Ontology

A set of resources and properties that are assigned specific semantics; a vocabulary of resources and properties, along with their meanings and rules of usage.

Package Archive

Any physical storage format that bundles the various resources described in the package description document and stores them in some cohesive group.

Package Description Instance

The formal enumeration of the package contents and properties as specified by this specification. This description consists of a series of RDF statements that may be contained within an RDF wrapper element <RDF>, although this element is optional in certain contexts. The package description instance is usually contained within a package description document but may also appear in other XML documents.

Package Description Document

The XML document using [RDF/XML Syntax] that contains the package description. Although this specification assumes there is only one XML document that describes the package, this does not preclude other documents from also describing the package.

Package Processor

One or more software modules used to read a package description and provide access to its content and structure and to the content and structure of the resources it describes.

Conformance

This section is normative. All sections in this document are normative unless indicated otherwise.

The key words must, must not, required, shall, shall not, should, should not, recommended, may, and optional in this specification are to be interpreted as described in [IETF RFC 2119].

Processing Dependencies

XPackage processing depends on [XML], [RDF], [XBase], [XML Namespaces], [IETF RFC 2046], and [IETF RFC 2396] (as updated by [IETF RFC 2732]).

Package Conformance

A package description is a conforming package description instance if:

1. it describes an RDF graph in conformance with [RDF].
2. the RDF graph it describes conforms to the OWL ontology [OWL] specified in this specification.
3. it adheres to the conformance constraints imposed upon a package description instance prescribed in this specification.

An XML document is a conforming package description document if:

1. it describes an RDF graph through [RDF/XML Syntax].
2. its RDF data contains a conforming package description instance.
3. it adheres to the conformance constraints imposed upon a package description document prescribed in this specification.

Processor Conformance

An XPackage processor is any software module that can process and interpret package description instances. Such a processor is conforming if:

1. it is a conforming XML processor according to [XML].
2. it can correctly process XML namespaces according to [XML Namespaces].
3. it is a conforming RDF processor according to [RDF].
4. it determines URI locations in links according to [XBase].
5. it observes the mandatory conditions for XPackage processors ("must") set forth in this specification.
6. for any optional conditions ("should" and "may") it chooses to observe, it observes them in the way prescribed.
7. it performs markup conformance testing according to all the conformance constraints appearing in this specification.

Related Specifications

This section is informative

XPackage and RDF

XPackage uses the [RDF] model and syntax for describing the relationships among the various resources that make up the package. Several ontologies are provided: one for providing general packaging information, and others for describing MIME information, Unicode information, and information regarding XML-based resources.

The RDF model consists of three object types:

Resources

All things described by RDF expressions. In the XPackage model, each image, each stylesheet, each XML document, and even portions of XML documents are all resources. Importantly, the package itself is an RDF resource. Resources are always named using URIs [IETF RFC 2396]. Each URI is considered a unique identifiers for resource — it is not meant to directly specify the location of the resource.

Properties

A specific aspect, characteristic, attribute, or relation used to describe a resource. In XPackage as in RDF, some resources may be properties of other resources. A document of media type text/css, for example, may be a stylesheet property of an XML document resource.

Statements

A specific resource (the subject) with a named property (the predicate) plus the value of that property (the object). A package description document could, for example, make the following statement: "The resource indicated by the URI urn:oeb:examplepackage1-stylesheet1 (the subject) is a stylesheet (the property) of the XML document resource indicated by the URI urn:oeb:examplepackage1-chapter1 (the object)."

RDF Statements

RDF statements can be represented in one of several syntaxes. The most common syntax uses an <rdf:Description> XML element to indicate the statement subject, references the subject's URI using the RDF rdf:about attribute. Properties are indicated by XML elements appearing directly beneath the <rdf:Description> element, each of which reference the object's URI using the RDF rdf:resource attribute:

<rdf:Description rdf:about="doc.html">
  <x:style rdf:resource="stylesheet.css"/>
</rdf:Description>

In this example, the item being described (the subject) is identified using the RDF rdf:about attribute in an <rdf:Description> element, while the object of the statement is referenced by the rdf:resource attribute of the child XML element. The style element in the x namespace serves as an identification of the statement predicate. It is assumed that the resource stylesheet.css is described elsewhere with its own <rdf:Description> description element or equivalent.

Note that the object being described above, stylesheet.css, could itself be the subject of another statement. Its predicate could be expressed using an XML element from another vocabulary rather than the <rdf:Description> element.

RDF Literals

Properties can also contain simple string values ("literals") by foregoing the rdf:resource attribute and including text as the child of the property XML element:

<rdf:Description rdf:about="doc.html">
  <dc:creator>Jane Doe</dc:creator>
</rdf:Description>

RDF Collections

A property may have as its object an ordered list of resources. Such a list is indicated by adding the attribute and value rdf:parseType="Collection" to the property XML element:

<rdf:Description rdf:about="chapter1-version4.html">
  <example:replaces rdf:parseType="Collection">
    <rdf:Description rdf:about="chapter1-version3.html"/>
    <rdf:Description rdf:about="chapter1-version2.html"/>
    <rdf:Description rdf:about="chapter1-version1.html"/>
  </example:replaces>
</rdf:Description>

This is a shortcut form that represents linked rdf:List resources, each referencing a resource in the collection. For a complete description, see [RDF/XML Syntax].

Node IDs

Within an RDF instance serialized in [RDF/XML Syntax], one resource may refer to another using rdf:nodeID. This unique ID is used only while processing the XML serialization and is not represented in the resulting RDF graph. This syntax is particularly useful to form relationships between anonymous resources—those that do not have unique reference URIs. A non-normative example is as follows:

<rdf:Description rdf:about="doc.html">
  <mime:contentType>application/xhtml+xml</mime:contentType>
  <example:annotation rdf:nodeID="annotation"/>
</rdf:Description>

<annotea:Annotation rdf:nodeID="annotation">
  <rdf:type rdf:resource="http://www.w3.org/2000/10/annotationType#Comment"/>
  <dc:creator>Jane Doe</dc:creator>
  <dc:date>2001-10-30T08:58Z</dc:date>
  <annotea:context>#xpointer(id("heading1")/p[3])</annotea:context>
  <annotea:body>I lost track of the subject here.</annotea:body>
</annotea:Annotation>

Literal XML

RDF allows a literal XML subtree to be specified as a resource value. This is done by using the rdf:parseType="Literal" on the property XML element. Using [RDF/XML Syntax], the following non-normative example illustrates the inclusion of an XHTML fragment. Note that the application/xhtml+xml-external-parsed-entity MIME content type has not yet been officially defined.

<rdf:Description rdf:nodeID="preface">
  <mime:contentType>application/xhtml+xml-external-parsed-entity</mime:contentType>
  <rdf:value rdf:parseType="Literal">
    <xhtml:h1>Hello, World</xhtml:h1>
  <rdf:value>
</rdf:Description>

XPackage and RDF Schema

This specification uses the RDFS ontology described in [RDF Schema] to provide certain generally useful properties. These are mostly documentation-related properties such as rdfs:comment and rdfs:label. Some of these properties are necessary to replicate the semantics of other specifications. For example, rdfs:label allows the title of a stylesheet to be defined to replicate the use of the title attribute of [XML Style Sheets].

RDFS is also an integral part of OWL [OWL].

XPackage and OWL

XPackage uses the Web Ontology Language [OWL] to concisely describe the XPackage ontologies. Whenever the XPackage ontologies appear in package description instances, the RDF statements must conform to the XPackage OWL definitions.

XPackage and MIME Media Types

XPackage uses MIME media types [IETF RFC 2046] to allow classification of the contents of a resource. This specification follows HTML 4 [HTML4] in employing the term content type to identify the MIME media type, in accordance with current usage, in order to distinguish it from the type of media for which the content is intended.

Package Description Document

XPackage provides a model describing resources in a package by means of a package description instance. While a package description instance may use any syntax allowed by RDF (including syntaxes not based upon XML), one common serialization is in RDF+XML [RDF/XML Syntax] stored in a single XML document, a package description document. The package description instance may be comprised of descriptions located in any appropriate XML document, and may even consist of descriptions in several XML documents. The package description document merely provides a common and identifiable XML document in which to place a package description instance using XML.

In a package description document, there must be an <RDF> element that encloses the RDF statements about the package resource and is defined in the namespace http://www.w3.org/1999/02/22-rdf-syntax-ns#. The enclosing <RDF> element identifies the package instance as compliant [RDF] so that it may be recognized as such by any RDF processor.

The package description document may contain any description allowed by [RDF], as illustustrated by the following non-normative example XML fragment:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">

  <rdf:Description>
    <--resource description-->
  </rdf:Description>

  <rdf:Description>
    <--resource description-->
  </rdf:Description>

</rdf:RDF>

XPackage Ontology

The XPackage ontology specifies resources and properties that allow descriptions of general resources. The XPackage ontology specifies the following resources and properties:

XPackage Ontology Classes

Generic Package (<xpackage:Package>)

A generic package resource is a package resource that describes a loosly defined grouping of resources that does not have a strong identify as an independent entity. A general package resource usually does not have special semantics as a resource other than as a grouping mechanism for the components of a package. A generic package should use the xpackage:manifest property to indicate the resources contained within the package. The most common use of a generic package resource is to describe the contents of an archive, as shown in the following non-normative example:

<xpackage:Package>
  <xpackage:manifest rdf:parseType="Collection">
    <--package manifest contents-->
  </xpackage:manifest>
</xpackage:Package>

XPackage Ontology Properties

XPackage defines several properties specific to packaging. These include properties to indicate required resources, fallback resources, alternate resources, other characteristics of a resource helpful for bundling and transportation. The following properties are defined in the XPackage vocabulary represented by the namespace http://xpackage.org/namespaces/xpackage# .

Alternate (<xpackage:alternate>)

A package description can indicate that one resource may be substituted for another. The xpackage:alternate property indicates that another resource is the equal of the first, and may be substituted if the processing application so decides. Multiple alternates may be specified, each using a separate xpackage:alternate property.

The alternate resource may in turn provide on or more alternates of its own, creating a "chain" of alternates. For example, resource A may specify an alternate of resource B, which may specify an alternate of resource C. The alternate property is transitive, indicating to the processing application that each alternate may be substituted for any other up the chain. In this example, resource B may be substituted for resource A, and resouce C may be substituted for either resource B or resource A. Resources may not be substituted down the chain, however: resource B may not be substituted for resource C, unless resource C explicitly names resource B as its alternate.

The xpackage:alternate property indicates a relationship of equality. For indicating a subordinate substitution relationship, use the xpackage:fallbacks property.

The following is a non-normative OWL fragment description of the alternate property:

<owl:ObjectProperty rdf:ID="alternate">
  <rdfs:comment>An equal substitute for the resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

The following example illustrates how to specify that a PCX image is an equal alternate for a PNG, and may be substituted for the PNG image if the processing application wishes. Note that the converse is not true: the PNG is not a substitute for the PCX image.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="dog.png">
    <mime:contentType>image/png</mime:contentType>
    <xpackage:alternate rdf:resource="urn:examples:pcx-image"/>
  </rdf:Description>

  <rdf:Description rdf:about="dog.pcx">
    <mime:contentType>image/pcx</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Fallbacks (<xpackage:fallbacks>)

The xpackage:fallbacks property indicates that one or more resources may act as less preferable substitutes for the first resource. Just as fallbacks are less preferable than the original resource, some fallback resources may be less preferable than other fallback resources. There must be at most one list of fallbacks for each resource, and the order of fallbacks within the list is significant.

The resource description for each fallback within a list may in turn provide its own list of fallbacks. For example, resource A may specify fallbacks of B1 and B2, and B1 may specify alternates of C1 and C2. The fallback property is transitive, indicating to the processing application that each fallback may be substituted for any other up the chain. In this example, resource B1 may be substituted for resource A, and resouces C1 and C2 may be substituted for either resource B1, or resource A—but not B2. Resources may not be substituted down the chain, however: resource B1 may not be substituted for resource C1, unless resource C1 explicitly names resource B1 as a fallback. The semantics of xpackage:fallbacks indicate to the processing application that resources farther down the chain are less preferable substitutes. Here, C2 is less preferable than C1, and C1 is a less preferable substitute than both B1 and B2.

The xpackage:fallbacks property indicates that substitution is less preferable than usage of the original resource. To indicate that a resource provides an equal substitute, use the xpackage:alternate property.

The <xpackage:fallbacks> element is described below using a non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="fallbacks">
  <rdfs:comment>An ordered list of less preferable substitutions for the resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</owl:ObjectProperty>

Each fallback resource is referenced by an element in the RDF list. The following example illustrates how to specify that, for an animated GIF image, there is a non-animated PNG image that could be used as a substitute, although this is less preferable than the GIF image itself. There is also a JPEG image if neither of the other image types are supported, but the JPEG image is less preferable than the other two.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="dog.gif">
    <mime:contentType>image/gif</mime:contentType>
    <xpackage:fallbacks rdf:parseType="Collection">
      <rdf:Description rdf:about="dog.png"/>
      <rdf:Description rdf:about="dog.jpg"/>
    </xpackage:fallbacks>
  </rdf:Description>

  <rdf:Description rdf:about="dog.png">
    <mime:contentType>image/png</mime:contentType>
  </rdf:Description>

  <rdf:Description rdf:about="dog.jpg">
    <mime:contentType>image/jpeg</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Manifest (<xpackage:manifest>)

A manifest provides a definitive list of all contained resources that are included in a resource (for example in a generic package resource). Note that a manifest denotes containment; in contast, the xpackage:require property denotes dependency.

A manifest is defined through use of a xpackage:manifest property containing a list of all resources in the manifest. Each resource must have at most one manifest defined.

The package xpackage:manifest property is described below using a non-normative OWL description fragment:

<owl:ObjectProperty rdf:ID="manifest">
  <rdfs:comment>Contained resource information.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</owl:ObjectProperty>

The following non-normative example illustrates the use of the xpackage:manifest property to define a package manifest in a package description:

<xpackage:Package rdf:about="urn:x-example.org/myZipFile">
  <xpackage:manifest rdf:parseType="Collection">
    <rdf:Description rdf:about="chapter1.html"/>
    <rdf:Description rdf:about="image.png"/>
    <rdf:Description rdf:about="stylesheet.css"/>
    <rdf:Description rdf:about="rights.xml"/>
  </xpackage:manifest>
</xpackage:Package>

Media Descriptor (<xpackage:media>)

A resource may provide one or more media descriptors to indicate for which media the given resource is intended. The media descriptor is semantically equivalent to that defined in HTML [HTML4]. Media descriptor values must be parsed according to the rules prescribed in [HTML4].

The media descriptor values allowed are the same as those defined in current and future versions of HTML, including the following list normatively described in [HTML4]:

screen

Intended for non-paged computer screens.

tty

Intended for media using a fixed-pitch character grid, such as teletypes, terminals, or portable devices with limited display capabilities.

tv

Intended for television-type devices (low resolution, color, limited scrollability).

projection

Intended for projectors.

handheld

Intended for handheld devices (small screen, monochrome, bitmapped graphics, limited bandwidth).

print

Intended for paged, opaque material and for documents viewed on screen in print preview mode.

braille

Intended for braille tactile feedback devices.

aural

Intended for speech synthesizers.

all

Suitable for all devices.

A media descriptor is specified using the xpackage:media property, as illustrated by the following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="media">
  <rdfs:comment>Media descriptor.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Literal"/>
</owl:ObjectProperty>

Media descriptors may only be relevant to particular types of resources, but are especially valuable for stylesheet associations. The XPackage stylesheet association mechanism described in "Style" follow the semantics of [XML Style Sheets], which requires the ability to describe media to which a style should be applied. The following non-normative example illustrates specifying a stylesheet that might be applied on the screen and in print:

<rdf:Description rdf:about="stylesheet.css">
  <mime:contentType>text/css</mime:contentType>
  <xpackage:media>screen</xpackage:media>
  <xpackage:media>printer</xpackage:media>
</rdf:Description>

Again following [HTML4], style resources that include internal descriptions of media-dependent variations (such as the CSS @media construct) may use a media descriptor value of all.

Metadata (<xpackage:metadata>)

There are two options for associating metadata with resources within a package description instance: through native RDF statements, and through use of the XPackage <metadata> element when metadata are inside some other resource.

The preferred method of including metadata in a document description instance is through a series of RDF statements. This allows the metadata to be directly included into the package description in a native, consistent way that is accessible to RDF processors. Native RDF can be included using either internal or external syntax. Non-RDF metadata can also be associated with resources, but such associations must use the second, external syntax.

Internal Metadata

The package description instance, being an application of RDF, allows other RDF-based metadata to be natively integrated into the RDF instance using an inline syntax. Any RDF-based metadata ontology may be used, as long as standard RDF syntax is used to associate the various properties with a resource using RDF statements. Put another way, a package description document allows any valid RDF material to be located within the RDF <RDF> element, interspersed among the various package elements defined in this specification.

This specification does not prescribe or provide a normative description of any metadata ontology outside the ontologies defined here. A popular ontology for describing metadata is the Dublin Core [DC], [DC RDF/XML]. The following non-normative example assumes the Dublin Core namespace has been associated with the XML prefix dc, and provides Dublin Core metadata as RDF child elements of the resource being described.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:dc="http://purl.org/dc/elements/1.1/">

  <rdf:Description rdf:about="document.html">
    <dc:creator>Garret Wilson</dc:creator>
    <dc:subject>Examples</dc:subject>
    <dc:subject>Specifications</dc:subject>
  </rdf:Description>

</rdf:RDF>

External Metadata

If metadata are defined in a resource separate from the package description document, the metadata are associated through use of the xpackage:metadata property. This property is used regardless of the format in which the associated metadata are stored.

The xpackage:metadata property is shown in the following non-normative OWL description fragment:

<owl:ObjectProperty rdf:ID="metadata">
  <rdfs:comment>Descriptive information about a resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

The following non-normative example illustrates specifying that the resource rights.xml provides metadata for the document. As with any other resource reference, such a reference defines neither the location of that resource nor any further information about its contents:

<rdf:Description rdf:about="document.html">
  <xpackage:metadata rdf:resource="rights.xml"/>
</rdf:Description>

Required Resource (<xpackage:require>)

The xpackage:require property indicates a related resource should be included in any package archive, should bundling take place. A resource indicated by the xpackage:require property is assumed to be so intrinsic to the package that its absence would cause normal processing of the package to fail. Inclusion as the object of an xpackage:require property implies that a resource will always be available for processing in the context of the package description instance.

xpackage:require can be defined for any resource, indicating any supplementary resource the first resource requires. The object of each xpackage:require property is "bound" to the package in that it must be distributed with any package archive that uses that package description instance.

The package xpackage:require property is described below using a non-normative OWL description fragment:

<owl:ObjectProperty rdf:ID="require">
  <rdfs:comment>Resource bundling dependency information.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

The following non-normative example illustrates the use of the xpackage:require property to indicate required resources:

<rdf:Description rdf:about="book.xeb">
  <xpackage:require rdf:resource="chapter1.html"/>
  <xpackage:require rdf:resource="image.png"/>
  <xpackage:require rdf:resource="stylesheet.css"/>
  <xpackage:require rdf:resource="rights.xml"/>
</rdf:Description>

File Ontology

The file ontology specifies properties relating to physical files, resources which consist of a series of bytes and are storable in a computer file system.

File Folder (<file:Folder>)

A file folder is a resource type that indicates that other resources share a parent-child relationship with this resource, usually by means of a URI hierarchy, such as file names or documents on a web site. Thus the resource represented by http://www.example.org/samples/ might be represented as a file:Folder that has two children, http://www.example.org/samples/sample1.txt and http://www.example.org/samples/sample2.txt. The file:Folder resource allows XPackage to accurately represent an entire group of resources in a file system.

The resources with a child relationship to a file:Folder use the xpackage:manifest property to represent the children, as indicated in the following non-normative example:

<xpackage:Folder rdf:about="http://www.example.org/samples/">
  <xpackage:manifest rdf:parseType="Collection">
    <rdf:Description rdf:about="http://www.example.org/samples/sample1.txt"/>
    <rdf:Description rdf:about="http://www.example.org/samples/sample2.txt"/>
  </xpackage:manifest>
</xpackage:Folder>

File Size (<file:size>)

A file resource may provide the size of the file in bytes. The file size is specified using the file:size property, as illustrated by the following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="size">
  <rdfs:comment>Physical file size, in bytes.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</owl:ObjectProperty>

The following non-normative example describes two images, large.png and small.png, both of which provide a file size using the file:size property. The former resource specifies the latter as an alternate resource. A XPackage processor might use the given sizes of the files as one criteria in determining which of the alternates to use:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:file="http://xpackage.org/namespaces/file#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="large.png">
    <mime:contentType>image/png</mime:contentType>
    <xpackage:alternate rdf:resource="spall.png"/>
    <file:size>928337</file:size>
  </rdf:Description>

  <rdf:Description rdf:about="small.png">
    <mime:contentType>image/png</mime:contentType>
    <file:size>4025</file:size>
  </rdf:Description>

</rdf:RDF>

MIME Ontology

The MIME ontology specifies a property that specifies a MIME media type:

MIME Ontology Properties

XPackage defines a single property for specifying MIME content type. The property is defined in the MIME ontology represented by the namespace http://xpackage.org/namespaces/mime# and may be be associated with any resource unless otherwise specified.

Content Type (<mime:contentType>)

A resource described in the package description instance may specify one or more media types as defined by [IETF RFC 2046]. Such a media type is specified using the mime:contentType property, as illustrated by the following non-normative OWL definition fragment:

<owl:ObjectProperty rdf:ID="contentType">
  <rdfs:comment>MIME content type.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

A PNG image [PNG], therefore, might declare its media type to be image/png using the syntax in the following non-normative example:

<rdf:Description rdf:about="image.png">
  <mime:contentType>image/png</mime:contentType>
</rdf:Description>

Unicode Ontology

The Unicode ontology specifies properties that indicate Unicode code points and scripts used by a resource.

Unicode Ontology Properties

The following properties are defined in the Unicode vocabulary represented by the namespace http://xpackage.org/namespaces/unicode# and should only be associated with resources that use Unicode [Unicode].

Script (<unicode:script>)

It may be useful for a resource to specify which Unicode code points [Unicode] it uses. In most cases, this information is provided to assist an application in determining which groups of characters might be used to display the information in the resource. The unicode:script property specifies Unicode code points based upon Unicode script name as defined by [Unicode Script Names].

A resource may indicate one or more scripts through use of the unicode:script element, as indicated by the non-normative OWL fragment below:

<owl:ObjectProperty rdf:ID="script">
  <rdfs:comment>Unicode script usage.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

A package description instance that indicates one or more scripts must use only values from the latest normative Unicode script names list, which is currently http://www.unicode.org/Public/UNIDATA/Scripts.txt for Unicode 4.1.0. An XPackage processor must interpret each script name value without regard to case. A processor may ignore unknown script name values and must continue processing the package description instance without error.

The following non-normative example declares that the given resource uses Unicode code points from both the Japanese Hiragana and Katakana scripts:

<rdf:Description rdf:about="chapter2.html">
  <unicode:script>hiragana</unicode:script>
  <unicode:script>katakana</unicode:script>
</rdf:Description>

Unicode Code Points (<unicode:codePoints>)

The preferred method of indicating Unicode code points used by a resource is through the unicode:script property, which indicates the script name of a set of code points. There might be some instances, however, in which the identification of Unicode code points by script name is too broad. The Unicode code points property may specify Unicode code point ranges as well as individual code points.

The unicode:codePoints property allows Unicode code points to be identified using a regular expression as defined by [Unicode Regular Expressions]. The regular expression appears as the literal value of the property, as illustrated in the following non-normative XML Schema fragment:

<owl:ObjectProperty rdf:ID="codePoints">
  <rdfs:comment>Unicode script usage.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

The Unicode regular expression must only include single Unicode code points and locale-independent ranges according to [Unicode Regular Expressions]. The following non-normative fragment, for example, specifies that the resource chapter2.html uses all the ASCII characters (0x0000-0x007F) except the lowercase letters 'a' through 'z', and also uses the superscript '2' (0x00B2):

<rdf:Description rdf:about="chapter2.html">
  <!--uses all ASCII characters (except the lowercase Latin letters) and a superscript '2'-->
  <unicode:codePoints>[\u0000-\u007F-[a-z], \u00B2]</unicode:codePoints>
</rdf:Description>

XML Ontology

XML resources are so prevalent (used even in the XPackage description document itself) that this specification defines an ontology specifically for use with those resources. XML resources are those resources encoded in XML, which usually have a content type of text/xml, of application/xml, or ending in +xml. The XML ontology specifies specifies the following properties:

XML Ontology Properties

The following properties are defined in the XML ontology represented by the namespace http://xpackage.org/namespaces/xml# and should only be associated with XML resources unless otherwise specified.

DTD (<x:dtd>)

Many XML documents can be validated according to a definition contained in a DTD. This property allows a DTD to be associated with an XML document using the syntax illustrated by the following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="dtd">
  <rdfs:comment>XML DTD association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

The following non-normative example illustrates assigning a DTD to an XML document:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:x="http://xpackage.org/namespaces/xml#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="source.xml">
    <mime:contentType>text/xml</mime:contentType>
    <x:dtd rdf:resource="validation.dtd"/>
  </rdf:Description>

  <rdf:Description rdf:about="validation.dtd">
    <mime:contentType>text/xml-dtd</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Namespace (<x:namespace>)

The namespace property indicates an XML namespace [XML Namespaces] used by a resource, and should therefore only be applied to resources that contain XML [XML]. The x:namespace property must identify the namespace resource by its URI, the unique identifying URI of the namespace described in [XML Namespaces], as shown by the following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="namespace">
  <rdfs:comment>Namespace assocation.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

The following non-normative example illustrates expressing that a particular item resource contains XML elements from both the XHTML [XHTML] and MathML [MathML] namespaces:

<rdf:Description rdf:about="chapter1.html">
  <mime:contentType>application/xhtml+xml</mime:contentType>
  <x:namespace rdf:resource="http://www.w3.org/1999/xhtml"/>
  <x:namespace rdf:resource="http://www.w3.org/1998/Math/MathML"/>
<rdf:Description>

Style (<x:style>)

This specification allows a resources to be associated with another resources as style. Specifying that one resource is the style of another indicates that the resource provides information that governs the presentation of the other resource. Examples of style resources include stylesheets of CSS [CSS2] and XSL [XSL].

XPackage style information follows the semantics of [XML Style Sheets], although most of these properties as used by XPackage are intrinsic to the style resource itself (the RDF object), not of the style relationship. XPackage x:style follows both [XML Style Sheets] and HTML [HTML4] in that style sheets specified in a package description instance are considered to occur before any style sheets specified internally to the style resources, such as through the xml-stylesheet XML processing instruction or through the HTML link element.

The following normative table describes how XML style sheet properties [XML Style Sheets] are expressed in XPackage:

Declaring style information for a resource is accomplished as illustrated in following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="style">
  <rdfs:comment>Stylesheet association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

In most of these cases, XPackage expresses these properties as aspects of the style resource itself, not of the style property. Such style-related properties should therefore be described in the description of that style resource. The following non-normative example illustrates assigning a CSS stylesheet to an XHTML document:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:x="http://xpackage.org/namespaces/xml#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="chapter1.html">
    <mime:contentType>application/xhtml+xml</mime:contentType>
    <x:style rdf:resource="stylesheet.css"/>
  </rdf:Description>

  <rdf:Description rdf:about="stylesheet.css">
    <rdfs:comment>A groovy stylesheet for use on the screen or on the printer.</rdfs:comment>
    <rdfs:label>Groovy Style Sheet</rdfs:label>
    <mime:contentType>text/css</mime:contentType>
    <xpackage:media>screen</xpackage:media>
    <xpackage:media>printer</xpackage:media>
  </rdf:Description>

</rdf:RDF>

Transformation (<x:transform>)

This specification allows another resources to be associated with the resources as a transformation. This property indicates that another resource provides information that should be used to transform this resource. Examples of transformation resources include XSLT documents [XSLT].

Another resource may be declared to contain transformation information as illustrated by the following non-normative OWL fragment:

<owl:ObjectProperty rdf:ID="transform">
  <rdfs:comment>Transformation stylesheet association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

The following non-normative example illustrates assigning an XSLT transformation to an XML document:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:x="http://xpackage.org/namespaces/xml#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="source.xml">
    <mime:contentType>text/xml</mime:contentType>
    <x:transform rdf:resource="manipulator.xsl"/>
  </rdf:Description>

  <rdf:Description rdf:about="manipulator.xsl">
    <mime:contentType>application/xml</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Package Archive

A package archive must contain at least one package description instance and must contain at least the resources specified in the package description's manifest. The package archive may physically store its resources in a variety of configurations, including:

• In a physical directory structure, separate from any archive file.
• In a single archive file, such as [ZIP] or Tar, that preserves the original directory structure.

There must be a default canonical package description instance defined in a package description document located in the root of the directory hierarchy under the file name "package.rdf". More than one package resource may be stored in a package archive, using one or more package description instances in one or more package description documents.

There is no requirement that there exist any package archive associated with a package description instance. A package archive is only one recommended method of encoding and transferring a serialized version of a package, enabling standardized discovery of the package description.

Examples

All examples in this section are non-normative.

XHTML Document

The following example shows how to use XPackage as a simple packaging mechanism to group a single XHTML document with its related files. The related files include a CSS stylesheet, an image, and a single annotation.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:x="http://xpackage.org/namespaces/xml#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
    xmlns:annotea="http://www.w3.org/2000/10/annotation-ns#"
    xmlns:example="http://example.org/namespaces/example#">

  <!--doc.html-->
  <rdf:Description rdf:about="doc.html">
    <rdfs:comment>The XHTML document.</rdfs:comment>
    <mime:contentType>application/xhtml+xml</mime:contentType>
    <x:namespace rdf:resource="http://www.w3.org/1999/xhtml"/>
    <x:style rdf:resource="stylesheet.css"/>
    <example:annotation rdf:nodeID="annotation"/>
    <dc:creator>Garret Wilson</dc:creator>
    <xpackage:require rdf:resource="stylesheet.css"/>
    <xpackage:require rdf:resource="image.png"/>
  </rdf:Description>

  <!--stylesheet.css-->
  <rdf:Description rdf:about="stylesheet.css">
    <rdfs:comment>The document stylesheet.</rdfs:comment>
    <mime:contentType>text/css</mime:contentType>
  </rdf:Description>

  <!--image.png-->
  <rdf:Description rdf:about="image.png">
    <rdfs:comment>A document image.</rdfs:comment>
    <mime:contentType>image/png</mime:contentType>
  </rdf:Description>

  <!--annotation-->
  <annotea:Annotation rdf:nodeID="annotation">
    <rdf:type rdf:resource="http://www.w3.org/2000/10/annotationType#Comment"/>
    <dc:creator>Jane Doe</dc:creator>
    <dc:date>2001-10-30T08:58Z</dc:date>
    <annotea:context>#xpointer(id("heading1")/p[3])</annotea:context>
    <annotea:body>I lost track of the subject here.</annotea:body>
  </annotea:Annotation>

</rdf:RDF>

Photo Album

This package description gives information about various images containing photos grouped together in a package. These files are of the same importance, rather than a single file and its supporting resources as in the XHTML document example. There really is no "photo album" per se—the package simply contains descriptions of several unordered photos, giving the location and MIME content type of each.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xlink="http://www.w3.org/1999/xlink">
  <xpackage:Package>

    <xpackage:manifest rdf:parseType="Collection">

      <rdf:Description rdf:about="image1.jpg">
        <mime:contentType>image/jpeg</mime:contentType>
      </rdf:Description>

      <rdf:Description rdf:about="image2.jpg">
        <mime:contentType>image/jpeg</mime:contentType>
      </rdf:Description>

      <rdf:Description rdf:about="image3.jpg">
        <mime:contentType>image/jpeg</mime:contentType>
      </rdf:Description>

    </xpackage:manifest>
  </xpackage:Package>
</rdf:RDF>

QTI Assessment

This example illustrates a physical file-based resource, a QTI assessment file as defined in [QTI]. XPackage is used for packaging instead of [IMS Content Packaging]. The resource media type is specified to be application/qti+xml, which would need to be defined by the QTI specification.

The resource described is a Question/Test Interoperability (QTI) assessment [QTI]. The assessment references a single GIF image, ctpoint.gif. A PNG fallback, ctpoint.png, is provided for the GIF image.

This example is informative, and illustrates the use of QTI as defined in [QTI], except that XPackage is used for packaging instead of [IMS Content Packaging].

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xlink="http://www.w3.org/1999/xlink">

  <rdf:Description rdf:about="questions.qti">
    <mime:contentType>application/qti+xml</mime:contentType>
    <xpackage:require rdf:resource="ctpoint.gif"/>
    <xpackage:require rdf:resource="ctpoint.png"/>
  </rdf:Description>

  <rdf:Description rdf:about="ctpoint.gif">
    <mime:contentType>image/gif</mime:contentType>
    <xpackage:fallbacks rdf:parseType="Collection">
      <rdf:Description rdf:about="ctpoint.png"/>
    </xpackage:fallbacks>
  </rdf:Description>

  <rdf:Description rdf:about="ctpoint.png">
    <mime:contentType>image/gif</mime:contentType>
  </rdf:Description>

</rdf:RDF>

eXtensible eBook (XEbook)

This example is informative, and illustrates an eXtensible eBook (XEbook), the specification of which has not yet been published.

The preface of this book is defined inline using the application/xhtml+xml-external-parsed-entity MIME content type, which has not yet been officially defined.

<?xml version="1.0"?>
<rdf:RDF
  xmlns:xeb="http://xebook.org/namespaces/xeb#"
  xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:xhtml="http://www.w3.org/1999/xhtml"
  xmlns:mime="http://xpackage.org/namespaces/mime#"
  xmlns:x="http://xpackage.org/namespaces/xml#"
>

  <xeb:Book>
    <dc:creator>Garret Wilson</dc:creator>
    <xeb:spine rdf:parseType="Collection">
      <rdf:Description rdf:nodeID="preface"/>
      <rdf:Description rdf:about="chapter1.html"/>
    </xeb:spine>
  </xeb:Book>

  <rdf:Description rdf:nodeID="preface">
    <mime:contentType>application/xhtml+xml-external-parsed-entity</mime:contentType>
    <rdf:value rdf:parseType="Literal">
      <xhtml:h1>Hello, World</xhtml:h1>
      <xhtml:p>Welcome to XEbook.</xhtml:p>
    <rdf:value>
  </rdf:Description>

  <rdf:Description rdf:about="chapter1.html">
    <mime:contentType>application/xhtml+xml</mime:contentType>
    <xpackage:style rdf:nodeID="stylesheet"/>
    <xpackage:require rdf:resource="image.gif"/>
  </rdf:Description>

  <rdf:Description rdf:about="stylesheet.css">
    <mime:contentType>text/css</mime:contentType>
  </rdf:Description>

  <rdf:Description rdf:about="image.gif">
    <rdfs:comment>An animaged image in GIF 89a format</rdfs:comment>
    <mime:contentType>image/gif</mime:contentType>
    <xpackage:fallbacks rdf:parseType="Collection">
      <rdf:Description rdf:about="image.png"/>
    </xpackage:fallback>
  </rdf:Description>

  <rdf:Description rdf:about="image.png">
    <rdfs:comment>A non-animated version of the GIF image, in PNG format.</rdfs:comment>
    <mime:contentType>image/png</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Java Archive (JAR) Manifest

A JAR file is a file format created by Sun Microsystems for storing Java class files, for listing properties of those classes, and for describing Java setup and deployment information. Although a JAR file typically ends in the extension ".jar", each is essentially a ZIP file [ZIP] that aggregates Java classes and other files, and usually contains a META-INF directory. Package and extension configuration data, including security, versioning, extension, and services, are included in the following two files, among other files [JAR]:

• MANIFEST.MF The manifest file that is used to define extension and package related data.
• INDEX.LIST The file containing location information for packages defined in an application or extension.

Information in the manifest file is represented using "name: value" pairs referred to as "headers" or "attributes".

JAR 1.0 Version

The following is an example of a typical MANIFEST.MF file as would be found in a JAR file. It indicates that all packages in the JAR file are sealed except those in the org.openebook.common package, and that the main class file to execute is org.openebook.test.TestApplication. It also includes a PNG file marked as such:

Manifest-Version: 1.0
Created-By: 1.5 (Sun Microsystems Inc.)
Main-Class: com.globalmentor.test.TestApplication
Sealed: true

Name: com/globalmentor/common
Sealed: false

Name: resources/images/image1.png
Content-Type: image/png

JAR XPackage Version

Pairs of names and values lend themselves naturally to representation in XPackage. The same example listed above could be reformulated using XPackage. One possible result is listed below:

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:jar="http://java.sun.com/j2se/1.5.0/docs/guide/jar/jar.html"
    xmlns:dc="http://purl.org/dc/elements/1.1/">

  <!--JAR-->
  <jar:Jar>
    <mime:contentType>application/x-jar</mime:contentType>
    <dc:version>1.0</dc:version>
    <dc:creator>1.5 (Sun Microsystems Inc.)</dc:creator>
    <jar:mainClass>org.globalmentor.test.TestApplication</jar:mainClass>
    <jar:sealed>true</jar:sealed>
    <xpackage:manifest rdf:parseType="Collection">

      <!--package: org/openebook/common-->
      <jar:Package rdf:about="java:com.globalmentor.common">
        <jar:sealed>false</jar:sealed>
      </jar:Package>

      <!--image: image1.png-->
      <rdf:Description rdf:about="image1.png">
        <mime:contentType>image/png</mime:contentType>
      </rdf:Description>

    </xpackage:manifest>
  </jar:jar>

</rdf:RDF>

RDDL Replacement

The Resource Directory Description Language [RDDL] catalogs and describes in a human-readable syntax various resources that are related to an XML namespace. RDDL was conceived in part to provide a target document for an XML namespace URI, even though the original [XML Namespaces] specification declared a namespace URI to be nothing more than an identifier, not a locator.

RDDL appears inside an XHTML document [XHTML] that resides at the destination of an XML namespace URI. It adds a single element, <rddl:resource>, that is used to identify each resources related to the XML namespace. XLink attributes [XLink] provide information about each resource. As examples, the attribute xlink:role is used to specify an RDDL nature (similar to but more specific than a MIME media type), and the attribute xlink:arcrole specifies the RDDL purpose of the resource, such "validation", "notation", or "entities".

RDDL Version

The following example RDDL document was written by Elliotte Rusty Harold in an xml.com article on RDDL entitled, RDDL Me This: What Does a Namespace URL Locate?, and is available at http://xml.oreilly.com/news/xmlnut2_code.html.

<!DOCTYPE html PUBLIC "-//XML-DEV//DTD XHTML RDDL 1.0//EN"
    "http://www.rddl.org/rddl-xhtml.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:rddl="http://www.rddl.org/">
  <head>
    <title>Resource Directory Description Language (RDDL) Document for Recipes</title>
  </head>
  <body>
    <h1>Recipe Resources</h1>
    <p>
      This document describes an XML application for
      recipes adapted from an example in Chapters 12
      and 13 of <cite>XML in a Nutshell</cite>
      by Elliotte Rusty Harold and W. Scott Means.
      The namespace for this application is
      <tt>http://www.ibiblio.org/xml/ns/recipe</tt>
    </p>
    <h2>DTD</h2>
    <p>Recipes may optionally be valid.</p>
    <rddl:resource
        xlink:type="simple" xlink:href="http://www.ibiblio.org/xml/dtds/recipe.dtd"
        xlink:role="http://www.isi.edu/in-notes/iana/assignments/media-types/text/xml-dtd"
        xlink:arcrole="http://www.rddl.org/purposes#validation"
        xlink:title="DTD for validation">
      <p>If you wish to validate a recipe you should use the following
        PUBLIC identifier:
      </p>
      <pre><tt>
        PUBLIC "-//Elliotte Rusty Harold//DTD Recipe 0.91//EN"
        "http://www.ibiblio.org/xml/dtds/recipe.dtd"
      </tt></pre>
    </rddl:resource>
    <h2>Style Sheets</h2>
    <rddl:resource
        xlink:type="simple" xlink:href="http://www.ibiblio.org/xml/styles/recipe.css"
        xlink:title="CSS Style Sheet for Recipes"
        xlink:role="http://www.isi.edu/in-notes/iana/assignments/media-types/text/css">
      <p>
        A CSS style sheet for recipes is available from
        <a href="http://www.ibiblio.org/xml/styles/recipe.css">http://www.ibiblio.org/xml/styles/recipe.css</a>
      </p>
    </rddl:resource>
    <hr />
    Copyright 2001 Elliotte Rusty Harold<br />
    Last Modified February 3, 2001
  </body>
</html>

RDDL XPackage Version

The components of RDDL are functionally equivalent to XPackage components, making RDDL a functional subset of XPackage. The fundamental differences between the two are that RDDL uses XLink rather than RDF (although [RDDL] provides an example RDF schema for RDDL), that RDDL cannot easily be extended, and that RDDL does not provide for readily apparent hierarchical relationships of resources. On a higher level, XPackage provides packaging and other relational information not available in RDDL.

Each RDDL <rddl:resource> element is roughly analogous to an XPackage/RDF resource description. The RDDL purpose of a resource is in effect the type of relationship the resource has with the XML namespace. In XPackage/RDF terms, the RDDL purpose is the predicate of an RDF statement in which the XML namespace is the subject and the resource is the object. Put another way, each RDDL resource is a property of the XML namespace being described, with the RDDL purpose representing the property name or type.

Using XPackage to describe RDDL information permits multiple namespaces to be described, allows multiple levels of association hierarchy, and facilitates adding custom properties to describe each namespace. Machine-interpretable information not present in RDDL (such as the fact that "Copyright 2001 Elliotte Rusty Harold" specifies copyright information) can be semantically represented through RDF properties such as those from the Dublin Core.

<?xml version="1.0"?>
<rdf:RDF
    xmlns:xpackage="http://xpackage.org/namespaces/xpackage#"
    xmlns:x="http://xpackage.org/namespaces/xml#"
    xmlns:mime="http://xpackage.org/namespaces/mime#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:rddl="http://www.rddl.org/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">

  <!--namespace: http://www.ibiblio.org/xml/ns/recipe-->
  <rddl:namespace rdf:about="http://www.ibiblio.org/xml/ns/recipe">
    <dc:title>Resource Document for Recipes using XPackage</dc:title>
    <rdfs:comment>
      This namespace describes an XML application for
      recipes adapted from an example in Chapters 12
      and 13 of _XML in a Nutshell_
      by Elliotte Rusty Harold and W. Scott Means.
      The XPackage version was created by Garret Wilson
      of GlobalMentor,
      Inc.
    </rdfs:comment>
    <dc:creator>Elliotte Rusty Harold</dc:creator>
    <dc:rights>Copyright 2001 Elliotte Rusty Harold</dc:rights>
    <dc:creator>Garret Wilson</dc:creator>
    <dc:rights>Copyright 2002-2006 GlobalMentor, Inc.</dc:rights>
    <dc:date>2006-05-11</dc:date>
    <x:dtd rdf:resource="http://www.ibiblio.org/xml/dtds/recipe.dtd"/>
    <xpackage:style rdf:resource="http://www.ibiblio.org/xml/styles/recipe.css"/>
  </rddl:namespace>

  <!--DTD: http://www.ibiblio.org/xml/dtds/recipe.dtd-->
  <rdf:Description rdf:about="http://www.ibiblio.org/xml/dtds/recipe.dtd">
    <dc:identifier>urn:public-id:-//Elliotte%20Rusty%20Harold//DTD%20Recipe%200.91//EN</dc:identifier>
    <rdfs:label>DTD for validation</rdfs:label>
    <mime:contentType>text/xml-dtd</mime:contentType>
  </rdf:Description>

  <!--styleshet: recipe.css-->
  <rdf:Description rdf:about="http://www.ibiblio.org/xml/styles/recipe.css">
    <rdfs:label>CSS Style Sheet for Recipes</rdfs:label>
    <mime:contentType>text/css</mime:contentType>
  </rdf:Description>

</rdf:RDF>

Namespaces Referenced

This section is informative.

Annotea [Annotea]

http://www.w3.org/2000/10/annotation-ns#

Dublin Core [DC]

http://purl.org/dc/elements/1.1/

Example [IETF RFC 2606]

http://example.org/namespaces/example#

MathML [MathML]

http://www.w3.org/1998/Math/MathML

RDF [RDF]

http://www.w3.org/1999/02/22-rdf-syntax-ns#

RDF Schema [RDF Schema]

http://www.w3.org/2000/01/rdf-schema#

XLink [XLink]

http://www.w3.org/1999/xlink

XPackage

http://xpackage.org/namespaces/xpackage#

XPackage File Ontology

http://xpackage.org/namespaces/file#

XPackage MIME Ontology

http://xpackage.org/namespaces/mime#

XPackage Unicode Ontology

http://xpackage.org/namespaces/unicode#

XPackage XML Ontology

http://xpackage.org/namespaces/xml#

XML [XML Namespaces]

http://www.w3.org/XML/1998/namespace

OWL Definitions

This section is informative.

XPackage Ontology OWL Definition

<owl:Class rdf:ID="Package">
  <rdfs:comment>A general description of a group of resources.</rdfs:comment>
</owl:Class>

<owl:ObjectProperty rdf:ID="alternate">
  <rdfs:comment>An equal substitute for the resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="fallbacks">
  <rdfs:comment>An ordered list of less preferable substitutions for the resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="location">
  <rdfs:comment>Physical resource location.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdf;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:about="&xlink;href">
  <rdfs:comment>The href property that exists in the XLink ontology</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;anyURI"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="manifest">
  <rdfs:comment>Contained resource information.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="media">
  <rdfs:comment>Media descriptor.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Literal"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="metadata">
  <rdfs:comment>Descriptive information about a resource.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="require">
  <rdfs:comment>Resource bundling dependency information.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&rdfs;Resource"/>
</owl:ObjectProperty>

File Ontology OWL Definition

<owl:Class rdf:ID="Folder">
  <rdfs:comment>A resource in a file system hierarchy has a parent relationship to other resources.</rdfs:comment>
  <rdfs:subClassOf rdf:resource="&rdf;Bag"/>
</owl:Class>

<owl:ObjectProperty rdf:ID="size">
  <rdfs:comment>Physical file size, in bytes.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</owl:ObjectProperty>

MIME Ontology OWL Definition

<owl:ObjectProperty rdf:ID="contentType">
  <rdfs:comment>MIME content type.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

Unicode Ontology OWL Definition

<owl:ObjectProperty rdf:ID="script">
  <rdfs:comment>Unicode script usage.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="codePoints">
  <rdfs:comment>Unicode script usage.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;String"/>
</owl:ObjectProperty>

XML Ontology OWL Definition

<owl:ObjectProperty rdf:ID="dtd">
  <rdfs:comment>XML DTD association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="namespace">
  <rdfs:comment>Namespace assocation.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="style">
  <rdfs:comment>Stylesheet association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

<owl:ObjectProperty rdf:ID="transform">
  <rdfs:comment>Transformation stylesheet association.</rdfs:comment>
  <rdfs:domain rdf:resource="&rdfs;Resource"/>
  <rdfs:range rdf:resource="&xsd;Resource"/>
</owl:ObjectProperty>

XML Schemas

This section is informative.

XPackage Ontology XML Schema

<xsd:element name="xpackage:alternate">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

<xsd:element name="xpackage:fallbacks">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:attribute name="rdf:parseType" fixed="Collection" use="required"/>
      <xsd:element ref="rdf:Description" maxOccurs="unbounded">
        <xsd:complexType>
          <xsd:attribute name="rdf:about" type="xsd:anyURI" minOccurs="1"/>
        </xsd:complexType>
      </xsd:element>
    <xsd:sequence>
  </xsd:complexType>
</xsd:element>

<xsd:element name="xpackage:manifest">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:attribute name="rdf:parseType" fixed="Collection" use="required"/>
      <xsd:element ref="rdf:Description" maxOccurs="unbounded">
        <xsd:complexType>
          <xsd:attribute name="rdf:about" type="xsd:anyURI" minOccurs="1"/>
        </xsd:complexType>
      </xsd:element>
    <xsd:sequence>
  </xsd:complexType>
</xsd:element>

<xsd:element name="xpackage:media" type="xsd:string"/>

<xsd:element name="xpackage:metadata">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

<xsd:element name="xpackage:require">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

File Ontology XML Schema

<xsd:element name="file:size" type="xsd:nonNegativeInteger"/>

MIME Ontology XML Schema

<xsd:element name="mime:contentType" type="xsd:string"/>

Unicode Ontology XML Schema

<xsd:element name="unicode:script" type="xsd:string"/>

<xsd:element name="unicode:codePoints" type="xsd:string"/>

XML Ontology XML Schema

<xsd:element name="x:dtd">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

<xsd:element name="x:namespace">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

<xsd:element name="x:style">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

<xsd:element name="x:transform">
  <xsd:complexType>
    <xsd:attribute name="rdf:resource" type="xsd:anyURI"/>
  </xsd:complexType>
</xsd:element>

References

Annotea

José Kahan, Marja-Riitta Koivunen, Eric Prud'Hommeaux, and Ralph R. Swick. Annotea: An Open RDF Infrastructure for Shared Web Annotations. World Wide Web Consortium, 2001. (See http://www.w3.org/2001/Annotea/, http://www.w3.org/2000/10/annotation-ns#.)

CSS2

Cascading Style Sheets, level 2. World Wide Web Consortium, 1998. (See http://www.w3.org/TR/REC-CSS2.)

DC

Dublin Core Metadata Element Set, Version 1.1: Reference Description. Dublin Core Metadata Initiative, 1999. (See http://www.dublincore.org/documents/dces/.)

DC RDF/XML

Expressing Simple Dublin Core in RDF/XML Proposed Recommendation. Dublin Core Metadata Initiative, 2001. (See http://www.dublincore.org/documents/dcmes-xml/.)

HTML4

Dave Raggett, Arnaud Le Hors, and Ian Jacobs, editors. HTML 4.01 Specification. World Wide Web Consortium, 1999. (See http://www.w3.org/TR/html4.)

IETF RFC 2046

N. Freed, N. Borenstein, editors. Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types. Internet Engineering Task Force, 1996. (See http://www.ietf.org/rfc/rfc2046.txt.)

IETF RFC 2119

S. Bradner, editor. Key words for Use in RFCs to Indicate Requirement Levels. Internet Engineering Task Force, 1997. (See http://www.ietf.org/rfc/rfc2119.txt.)

IETF RFC 2396

RFC 2396: Uniform Resource Identifiers. Internet Engineering Task Force, 1995. (See http://www.ietf.org/rfc/rfc2396.txt.)

IETF RFC 2376

RFC 2376: XML Media Types.. Internet Engineering Task Force, 1998. (See http://www.ietf.org/rfc/rfc2376.txt.)

IETF RFC 2606

RFC 2606: Reserved Top Level DNS Names. Internet Engineering Task Force, 1999. (See http://www.ietf.org/rfc/rfc2606.txt.)

IETF RFC 2732

RFC 2732: Format for Literal IPv6 Addresses in URL's. Internet Engineering Task Force, 1999. (See http://www.ietf.org/rfc/rfc2732.txt.)

IETF RFC 3023

M. Murata, S. St. Laurent, and D.Kohn, editors. XML Media Types. Internet Engineering Task Force, 2001. (See http://www.ietf.org/rfc/rfc3023.txt.)

IMS Content Packaging

IMS Content Packaging Specification Version 1.1.2. IMS Global Learning Consortium, Inc., 2001. (See http://www.imsglobal.org/content/packaging/.)

JAR

JAR File Specification. Sun Microsystems, Inc., 2003. (See http://java.sun.com/j2se/1.5.0/docs/guide/jar/jar.html.)

MathML

David Carlisle, Patrick Ion, Robert Miner, and Nico Poppelier, editors. Mathematical Markup Language (MathML) Version 2.0 Recommendation. World Wide Web Consortium, 2001. (See http://www.w3.org/TR/MathML2.)

OEBPS1

Open eBook™ (OeB) Publication Structure 1.0.1. Open eBook Forum, 2001. (See http://www.openebook.org/oebps/oebps1.0.1/download/2001-07-02_OEBPS1.0.1_recommended/hoeb101.htm.)

OWL

Michael K. Smith, Chris Welty, and Deborah McGuinness, editors. OWL Web Ontology Language Guide. World Wide Web Consortium, 2004. (See http://www.w3.org/TR/owl-guide/.)

PNG

Glenn Randers-Pehrson and Thomas Boutell, editors. PNG (Portable Network Graphics) Specification, Version 1.2. PNG Development Group. PNG 1.0 published as RFC 2083: PNG (Portable Network Graphics) Specification Version 1.0.. Internet Engineering Task Force, 1997. PNG 1.0 also published as PNG (Portable Network Graphics) Specification Recommendation. World Wide Web Consortium, 1996. (See http://www.libpng.org/pub/png/.)

QTI

IMS Question & Test Interoperability Specification Version 1.2. IMS Global Learning Consortium, 2002. (See http://www.imsglobal.org/question/index.html.)

RDDL

Jonathan Borden and Tim Bray. Resource Directory Description Language (RDDL). (See http://www.rddl.org/.)

RDF

Graham Klyne and Jeremy J. Carroll, editors. Resource Description Framework (RDF): Concepts and Abstract Syntax. World Wide Web Consortium, 2004. (See http://www.w3.org/TR/rdf-concepts/.)

RDF Schema

Dan Brickley and R.V. Guha, editors. RDF Vocabulary Description Language 1.0: RDF Schema. World Wide Web Consortium, 2004. (See http://www.w3.org/TR/rdf-schema/.)

RDF/XML Syntax

Dave Beckett and Brian McBride, editors. RDF/XML Syntax Specification (Revised). World Wide Web Consortium, 2004. (See http://www.w3.org/TR/rdf-syntax-grammar/.)

UML

Unified Modeling Language (UML), Version 1.3. Object Management Group, 2000. (See http://www.omg.org/technology/documents/formal/uml.htm.)

Unicode

The Unicode Standard, Version 3.0. Unicode Consortium, 2000. ISBN 0-201-61633-5. (See http://www.unicode.org/unicode/uni2book/u2.html.)

Unicode Regular Expressions

Mark Davis. Unicode Technical Report #18: Unicode Regular Expression Guidelines Version 5.1. Unicode Consortium, 2000. (See http://www.unicode.org/unicode/reports/tr18.)

Unicode Script Names

Mark Davis. Unicode Technical Report #24: Script Names Version 3. Unicode Consortium, 2001. (See http://www.unicode.org/unicode/reports/tr24/.)

XBase

Jonathan Marsh, editor. XML Base (XBase). World Wide Web Consortium, 1999. (See http://www.w3.org/TR/xmlbase/.)

XHTML

XHTML™ 1.0: The Extensible HyperText Markup Language. World Wide Web Consortium, 2000. (See http://www.w3.org/TR/xhtml1.)

XLink

Steve DeRose, Eve Maler, David Orchard, and David Orchard, editors. XML Linking Language (XLink) Version 1.0. World Wide Web Consortium, 2000. (See http://www.w3.org/TR/xlink/.)

XML

Tim Bray, Jean Paoli, C.M. Sperberg-McQueen, and Eve Maler, editors. Extensible Markup Language (XML) 1.0 (Second Edition). World Wide Web Consortium, 2000. (See http://www.w3.org/TR/REC-xml.)

XML Namespaces

Tim Bray, Dave Hollander, and Andrew Layman, editors. Namespaces in XML. World Wide Web Consortium, 1999. (See http://www.w3.org/TR/REC-xml-names.)

XML Style Sheets

Tim Bray, Dave Hollander, and Andrew Layman, editors. Associating Style Sheets with XML Documents. World Wide Web Consortium, 1999. (See http://www.w3.org/TR/xml-stylesheet.)

XPointer

Ron Daniel, Steve DeRose, and Eve Maler, editors. XML Pointer Language (XPointer) Version 1.0. World Wide Web Consortium, 1998. (See http://www.w3.org/TR/xptr.)

XSL

Extensible Stylesheet Language (XSL) Proposed Recommendation. World Wide Web Consortium, 2001. (See http://www.w3.org/TR/xsl/.)

XSLT

James Clark, editor. XSL Transformations (XSLT) Version 1.0. World Wide Web Consortium, 1999. (See http://www.w3.org/TR/xslt.)

ZIP

.ZIP File Format Specification Version 4.5. PKWARE, Inc., 2001. (See http://www.pkware.com/support/appnote.html.)

Revision History

This section is informative.

11 May 2006

• Added XEbook book example.
• Removed OEBPS 2.0 publication example.
• Removed xpackage:description.
• Removed xpackage:location.
• Renamed xpackage:fallback to xpackage:fallbacks.
• Updated references to RDF specifications.
• Removed "/2003" segment from all namespaces.
• Changed name from XML Package to eXtensible Package to reflect that serialization no longer relies exclusively on XML.
• Added file:Folder class.
• Added xpackage:require property.
• Changed semantics of xpackage:manifest to denote containment.
• Brought back and revised xpackage:Package class.

6 March 2003

• Removed the requirement that a package description instance must be conforming to any particular XML Schema, and added the requirement that each XPackage processor must be a conforming RDF processor.
• Added the file ontology, along with the file:size property.
• Added OWL ontology definitions and moved XML Schema definitions to a non-normative appendix.
• Added the xpackage:alternate and xpackage:fallback properties to the XPackage ontology.
• Removed the x:annotation property from the XML ontology.
• Removed rdf:Bag from xpackage:manifest and added parseType="Collection".

23 October 2002

• Modified examples to reflect changes.
• Added the x:dtd property.
• Temporarily removed fallbacks.
• Temporarily removed processing information.
• Removed the xpackage:organization property in favor of navigation work being done in OEB.
• Removed the xpackage:resource resource as unecessary, replacing it with <rdf:Description>.
• Created separate MIME and Unicode ontologies and placed all supplemental ontologies in appendices.

26 March 2002

• Removed the package description document acronym, "PDD".
• Added table of contents.
• Added ontology summary tables.
• Changed the XPackage namespaces to use xpackage.org.
• Added requested location alias capability for xmlprop:location.
• Added the xmlprop:transform property.
• Rearranged sections to clearly illustrate separate ontologies.

8 March 2002

• Fixed typographical errors and made wording changes.
• Updated XPackage and OEB namespaces.

6 March 2002

• Added RDDL Example