Spelling/grammar fixes and some clarifications (#396)

While reading Metaschema documentation, I came across
some typos, grammatical issues, and phrases that could
be clearer.

website/content/_index.md

@@ -21,7 +21,7 @@ Current modeling technologies (i.e. XML Schema, JSON Schema, Schematron) are:
 - Uneven in their modeling expressiveness and validation capability;
 - Unable to express a single model that applies to all supported formats;
 - Bound to specific formats (i.e., XML, JSON, YAML); and
-- Time-consuming and labor-intensive when maintain multiple format-specific models.
+- Time-consuming and labor-intensive when maintaining multiple format-specific models.
 
 In addition to these basic challenges, there is a need to:
 

website/content/specification/information-modeling.md

@@ -12,7 +12,7 @@ The following diagram illustrates the relationships between information modeling
 
 An [*information model*](/specification/glossary/#information-model) is an abstract representation of information from a given information [*domain*](/specification/glossary/#domain). An *information model* is composed of a set of semantically well-defined information structures that each represent an [*information element*](/specification/glossary/#information-element) in the information domain.
 
-The primary purpose of the Metaschema Framework is to support the structured expression of an information model, which is represented as a [*Metaschema module*](/specification/glossary/#metaschema-module). A Metaschema module is used to represent the whole or a part of a information model for a given information domain in an information-centric, format-neutral form.
+The primary purpose of the Metaschema Framework is to support the structured expression of an information model, which is represented as a [*Metaschema module*](/specification/glossary/#metaschema-module). A Metaschema module is used to represent the whole or a part of an information model for a given information domain in an information-centric, format-neutral form.
 
 ## Graph Theoretical Basis of Metaschema
 

website/content/specification/syntax/_index.md

@@ -154,7 +154,7 @@ The following is an approximate outline of the Metaschema module syntax. Each el
     </div>
     <div class="element">
       <!-- define-assembly:model -->
-      <div class="cl"><em><span class="nt">&lt;<a href="/specification/syntax/definitions/#model">model</a></span></em><span class="nt">/&gt;</span></div>
+      <div class="cl"><em><span class="nt">&lt;<a href="/specification/syntax/definitions/#model">model</a></span></em><span class="nt">&gt;</span></div>
       <!-- define-assembly:model:assembly -->
       <div class="element">
         &lt;-- Assembly Instance --&gt;<br/>

website/content/specification/syntax/definitions.md

@@ -8,15 +8,15 @@ weight: 20
 
 A *definition* in a *Metaschema module* declares a reusable [*information element*](/specification/glossary/#information-element) within an [*information model*](/specification/glossary/#information-model).
 
-In graph theoretical terms, a *definition* provides a declaration of an graph *node* and any associated *edges* that form a given subgraph shape.
+In graph theoretical terms, a *definition* provides a declaration of a graph *node* and any associated *edges* that form a given subgraph shape.
 
 In object-oriented terms, a *definition* provides a declaration of a *class*, along with any associated *class members*.
 
 The following subsections describe the [common syntax](#common-definition-data) for all *definition* types, followed by the semantic and syntax details of each type of *definition*. The 3 types of *definitions* are [`<define-flag>`](#top-level-define-flag), [`<define-field>`](#top-level-define-field), and [`<define-assembly>`](#top-level-define-assembly).
 
 ## Common Definition Data
 
-All *definition* types share a common syntax comprised of the following XML attributes and elements.
+All *definition* types share a common syntax composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -61,7 +61,7 @@ The following example illustrates deprecating the flag named `flag-name` startin
 
 The `@name` attribute provides the definition's identifier, which can be used in other parts of a module, or in an importing *Metaschema module*, to reference the definition.
 
-This attribute's value MUST be a [token](/specification/datatypes/#token) that is unique among sibling top-level flag definitions.
+In top-level definitions, this attribute's value MUST be a [token](/specification/datatypes/#token) that is unique among sibling definitions of the same type.
 
 **Note:** The names of flags, fields, and assemblies are expected to be maintained as separate identifier sets. This allows a *flag definition*, a *field definition*, and an *assembly definition* to each have the same name in a given *Metaschema module*.
 
@@ -172,7 +172,7 @@ field:
 The optional `<remarks>` element provides a place to add notes related to the use of the definition. Remarks can be used to clarify the semantics of the definition in specific conditions, or to better describe how the definition may be more fully utilized within a model. 
 
 The `<remarks>` element is optional and may occur multiple times.
-It supports an optional `@class` attribute that can be used to identify format specific specific remarks, to be handled appropriately (or ignored when not useful) in a downstream application. Valid values for `@class` are:
+It supports an optional `@class` attribute that can be used to identify format specific remarks, to be handled appropriately (or ignored when not useful) in a downstream application. Valid values for `@class` are:
 - `XML`: The remark applies to the XML format binding.
 - `JSON`: The remark applies to the JSON or YAML format bindings.
 ### `<example>`
@@ -194,7 +194,7 @@ A *flag definition* provides the means to implement a simple, named [*informatio
 
 The flag's value is strongly typed using one of the built in [simple data types](/specification/datatypes/#simple-data-types) identified by the `@as-type` attribute.
 
-The syntax of a flag is comprised of the following XML attributes and elements.
+The syntax of a flag is composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -245,12 +245,12 @@ A *field definition*, represented by the `<define-field>` element, is used to de
 A *field definition* provides the means to implement a complex named [*information element*](/specification/glossary/#information-element) with a value and an optional set of [*flag instances*](/specification/syntax/instances/#flag-instance).
 
 {{<callout>}}
-A *field definition* is an edge node in a Metaschema-based model. *Fields* are typically used to provide supporting information for a containing [*assembly definition*](/specification/syntax/definitions/#top-level-define-assembly). The optional set of *flag instances* declared on a *field definition*, typically characterize or identify the fields value. With optional use of flags, a field can be more or less complex, depending on the modeling need.
+A *field definition* is an edge node in a Metaschema-based model. *Fields* are typically used to provide supporting information for a containing [*assembly definition*](/specification/syntax/definitions/#top-level-define-assembly). The optional *flag instances*, declared on a *field definition*, typically characterize or identify the field's value. With optional use of flags, a field can be more or less complex, depending on the modeling need.
 {{</callout>}}
 
 The field's value is strongly typed using one of the built in [simple data types](/specification/datatypes/#simple-data-types) or [markup data types](/specification/datatypes/#markup-data-types) identified by the `@as-type` attribute.
 
-The syntax of an *field definition* is comprised of the following XML attributes and elements.
+The syntax of an *field definition* is composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -488,11 +488,11 @@ An assembly definition consists of an optional set of [*flags*](/specification/s
 An *assembly definition* is a compositional node in a Metaschema-based model. Assemblies are typically used to represent complex data objects, combining multiple information elements together into a composite object representing a larger semantic concept. An assembly's flag instances will typically characterize or identify this composite object, while its model instances represent the information being composed.
 {{</callout>}}
 
-An assembly is similar to a field, except it contains structured content (objects or elements), not text or unstructured "rich text". The contents permitted in a particular (type of) assembly are indicated in its `model` element.
+An assembly is similar to a field, except it contains structured content (objects or elements), not text or unstructured "rich text." The contents permitted in a particular (type of) assembly are indicated in its `model` element.
 
 An assembly definition has no value, so the `@as-type` and `@default` attributes are not permitted.
 
-The syntax of an *assembly definition* is comprised of the following XML attributes and elements.
+The syntax of an *assembly definition* is composed of the following XML attributes and elements.
 
 Attributes:
 

website/content/specification/syntax/inline-definitions.md

@@ -8,11 +8,11 @@ weight: 40
 
 *Inline definitions* are a mechanism to both define a named [*information element*](/specification/glossary/#information-element) and instantiate it. In this way, *inline definitions* can be thought of as both [*definitions*](/specification/syntax/definitions/) and [*instances*](/specification/syntax/instances/), sharing most of the data elements of both.
 
-*Inline definitions* are provided as a convenience to allow single-use *information elements* to declared inline, within other *definitions*. Single-use, inline declarations are easier to maintain than a *top-level definition* that is referenced, since the maintainer doesn't have to trace the reference.
+*Inline definitions* are provided as a convenience to allow single-use *information elements* to be declared inline, within other *definitions*. Single-use, inline declarations are easier to maintain than a *top-level definition* that is referenced, since the maintainer doesn't have to trace the reference.
 
 ## Common Inline Definition Data
 
-All *inline definition* types share a common syntax comprised of the following XML attributes and elements.
+All *inline definition* types share a common syntax composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -47,9 +47,9 @@ A *inline flag definition* provides the means to implement a simple, named [*inf
 An *inline flag definition* is a leaf node in a Metaschema-based model that is intended to represent a granular particle of identifying and qualifying information.
 {{</callout>}}
 
-The flag's value is strongly typed using one of the built in [simple data types](/specification/datatypes/#simple-data-types) identified by the `@as-type` attribute.
+The flag's value is strongly typed using one of the built-in [simple data types](/specification/datatypes/#simple-data-types) identified by the `@as-type` attribute.
 
-The syntax of an *inline flag definition* is comprised of the following XML attributes and elements.
+The syntax of an *inline flag definition* is composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -83,12 +83,12 @@ An *inline field definition*, represented by the `<define-field>` element, is us
 A *inline field definition* provides the means to implement a complex named [*information element*](/specification/glossary/#information-element) with a value and an optional set of [*flag instances*](/specification/syntax/instances/#flag-instance).
 
 {{<callout>}}
-An *inline field definitions* is an edge node in a Metaschema-based model. *Fields* are typically used to provide supporting information for a containing [*assembly definition*](/specification/syntax/definitions/#top-level-define-assembly). The optional set of *flag instances* declared on an *inline field definition*, typically characterize or identify the fields value. With optional use of flags, a field can be more or less complex, depending on the modeling need.
+An *inline field definitions* is an edge node in a Metaschema-based model. *Fields* are typically used to provide supporting information for a containing [*assembly definition*](/specification/syntax/definitions/#top-level-define-assembly). The optional *flag instances*, declared on an *inline field definition*, typically characterize or identify the field's value. With optional use of flags, a field can be more or less complex, depending on the modeling need.
 {{</callout>}}
 
-The fields's value is strongly typed using one of the built in [simple data types](/specification/datatypes/#simple-data-types) or [markup data types](/specification/datatypes/#markup-data-types) identified by the `@as-type` attribute.
+The fields's value is strongly typed using one of the built-in [simple data types](/specification/datatypes/#simple-data-types) or [markup data types](/specification/datatypes/#markup-data-types) identified by the `@as-type` attribute.
 
-The syntax of an *inline field definition* is comprised of the following XML attributes and elements.
+The syntax of an *inline field definition* is composed of the following XML attributes and elements.
 
 Attributes:
 
@@ -131,14 +131,14 @@ A *inline assembly definition* provides the means to implement a complex, compos
 An assembly definition consists of an optional set of [*flags*](/specification/syntax/instances/#flag-instance) and an optional sequence of [model instances](/specification/syntax/instances/#model-instances).
 
 {{<callout>}}
-An *inline assembly definition* is a compositional node in a Metaschema-based model. Assemblies are typically used to represent complex data objects, combining multiple information elements together into a composite object representing a larger semantic concept. An assembly's flag instances will typically characterize or identify this composite object, while its model instances represent the information being composed.
+An *inline assembly definition* is a compositional node in a Metaschema-based model. Assemblies are typically used to represent complex data objects, combining multiple information elements together into a composite object representing a larger semantic concept. An assembly's flag instances typically characterize or identify this composite object, while its model instances represent the information being composed.
 {{</callout>}}
 
-An assembly is similar to a field, except it contains structured content (objects or elements), not text or unstructured "rich text". The contents permitted in a particular (type of) assembly are indicated in its `model` element.
+An assembly is similar to a field, except it contains structured content (objects or elements), not text or unstructured "rich text." The contents permitted in a particular (type of) assembly are indicated in its `model` element.
 
 An assembly definition has no value, so the `@as-type` and `@default` attributes are not permitted.
 
-The syntax of an *inline assembly definition* is comprised of the following XML attributes and elements.
+The syntax of an *inline assembly definition* is composed of the following XML attributes and elements.
 
 Attributes: