diff --git a/build/metaschema/json/md-converter-test.xsl b/build/metaschema/json/md-converter-test.xsl
index ee0645d313..a8988fc0d9 100644
--- a/build/metaschema/json/md-converter-test.xsl
+++ b/build/metaschema/json/md-converter-test.xsl
@@ -24,7 +24,7 @@
     <xsl:template match="text()">
         <!--<xsl:value-of select="."/>-->
         <xsl:call-template name="parse">
-            <xsl:with-param name="markdown-str" select="string(.)"/>
+            <xsl:with-param name="str" select="string(.)"/>
         </xsl:call-template><!--
         <xsl:apply-templates select="." mode="parse"/>-->
     </xsl:template>
diff --git a/build/metaschema/json/md-oscal-converter.xsl b/build/metaschema/json/md-oscal-converter.xsl
index 72d6d2b8d2..0f1c97eeb8 100644
--- a/build/metaschema/json/md-oscal-converter.xsl
+++ b/build/metaschema/json/md-oscal-converter.xsl
@@ -331,7 +331,7 @@
     <xsl:variable name="tag-replacements" xmlns="http://csrc.nist.gov/ns/oscal/1.0/md-convertor">
         <rules>
             <!-- first, literal replacements -->
-            <replace match="&amp;"  >&amp;amp;</replace>
+            <!--<replace match="&amp;"  >&amp;amp;</replace>-->
             <replace match="&lt;"   >&amp;lt;</replace>
             <!-- next, explicit escape sequences -->
             <replace match="\\&#34;">&amp;quot;</replace>
@@ -462,9 +462,7 @@
      <xsl:variable name="examples" xml:space="preserve">
         <p>**Markdown** and even " quoted text" and **more markdown**</p>
         <p>
- 
-See the FedRAMP Documents page under Key Cloud Service Provider (CSP) Documents, Plan of Action &amp; Milestones (POA&amp;M) Template Completion Guide [https://www.fedramp.gov/documents/](https://www.fedramp.gov/documents/)
- 
+            
 Paragraph, \n\nand new paragraph
             
 ## My test file!   has an &amp; ampersand         
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test-json-converter.xsl b/build/metaschema/unit-testing/char-handling/charstrings-test-json-converter.xsl
deleted file mode 100644
index 90155608d5..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test-json-converter.xsl
+++ /dev/null
@@ -1,456 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-                xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                xmlns:m="http://csrc.nist.gov/ns/oscal/1.0/md-convertor"
-                version="3.0"
-                xpath-default-namespace="http://www.w3.org/2005/xpath-functions"
-                exclude-result-prefixes="#all">
-   <xsl:output indent="yes" method="xml"/>
-   <!-- OSCAL examples conversion stylesheet supports JSON->XML conversion -->
-   <xsl:param name="target-ns"
-              as="xs:string?"
-              select="'http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime'"/>
-   <!-- 00000000000000000000000000000000000000000000000000000000000000 -->
-   <xsl:output indent="yes"/>
-   <xsl:strip-space elements="*"/>
-   <xsl:preserve-space elements="string"/>
-   <xsl:param name="json-file" as="xs:string?"/>
-   <xsl:variable name="using-json-file"
-                 select="replace($json-file,'^/','') ! ('file:///' || .)"/>
-   <xsl:variable name="json-xml"
-                 select="unparsed-text($using-json-file) ! json-to-xml(.)"/>
-   <xsl:template name="xsl:initial-template" match="/">
-      <xsl:choose>
-         <xsl:when test="matches($json-file,'\S') and exists($json-xml/map)">
-            <xsl:apply-templates select="$json-xml" mode="json2xml"/>
-         </xsl:when>
-         <xsl:otherwise>
-            <xsl:apply-templates mode="json2xml"/>
-         </xsl:otherwise>
-      </xsl:choose>
-   </xsl:template>
-   <xsl:template match="/map[empty(@key)]" priority="10" mode="json2xml">
-      <xsl:apply-templates mode="#current" select="*[@key=('examples')]"/>
-   </xsl:template>
-   <xsl:template match="array" priority="10" mode="json2xml">
-      <xsl:apply-templates mode="#current"/>
-   </xsl:template>
-   <xsl:template match="string[@key='RICHTEXT']" mode="json2xml">
-      <xsl:call-template name="parse">
-         <xsl:with-param name="markdown-str" select="string(.)"/>
-      </xsl:call-template>
-   </xsl:template>
-   <xsl:template match="string[@key='STRVALUE']" mode="json2xml">
-      <xsl:apply-templates mode="#current"/>
-   </xsl:template>
-   <xsl:template mode="as-attribute" match="*"/>
-   <xsl:template mode="as-attribute" match="string[@key='id']" priority="0.4">
-      <xsl:attribute name="id">
-         <xsl:apply-templates mode="#current"/>
-      </xsl:attribute>
-   </xsl:template>
-   <!-- 00000000000000000000000000000000000000000000000000000000000000 -->
-   <!-- 000 Handling assembly "{ @name }" 000 -->
-   <!-- 000 NB - template matching 'array' overrides this one 000 -->
-   <xsl:template match="*[@key='examples'] | /map[empty(@key)]"
-                 priority="4"
-                 mode="json2xml">
-      <xsl:element name="examples"
-                   namespace="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime">
-         <xsl:apply-templates mode="as-attribute"/>
-         <xsl:apply-templates mode="#current" select="*[@key=('charstring', 'character-strings')]"/>
-         <xsl:apply-templates mode="#current" select="*[@key=('markupline', 'markup-lines')]"/>
-      </xsl:element>
-   </xsl:template>
-   <!-- 000 Handling field "charstring" 000 -->
-   <!-- 000 NB - template matching 'array' overrides this one 000 -->
-   <!--*[@key='charstring'] | *[@key='character-strings']  | array[@key='character-strings']/*-->
-   <xsl:template match="*[@key='charstring'] | *[@key='character-strings']  | array[@key='character-strings']/*"
-                 priority="5"
-                 mode="json2xml">
-      <xsl:element name="charstring"
-                   namespace="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime">
-         <xsl:apply-templates select="*" mode="as-attribute"/>
-         <xsl:apply-templates select="string[@key='STRVALUE']" mode="json2xml"/>
-         <xsl:for-each select="self::string | self::boolean | self::number">
-            <xsl:apply-templates mode="json2xml"/>
-         </xsl:for-each>
-      </xsl:element>
-   </xsl:template>
-   <xsl:template priority="3"
-                 mode="json2xml"
-                 match="map[@key = 'character-strings']/array[@key = 'STRVALUE'] | array[@key = 'character-strings']/map/array[@key = 'STRVALUE']">
-      <xsl:variable name="expanded" as="element()*">
-         <array xmlns="http://www.w3.org/2005/xpath-functions" key="character-strings">
-            <xsl:apply-templates mode="expand" select="array[@key = 'STRVALUE']/string"/>
-         </array>
-      </xsl:variable>
-      <xsl:apply-templates select="$expanded" mode="json2xml"/>
-   </xsl:template>
-   <xsl:template mode="expand"
-                 match="map[@key = 'character-strings']/array[@key = 'STRVALUE']/string | array[@key = 'character-strings']/map/array[@key = 'STRVALUE']/string">
-      <xsl:variable name="me" select="."/>
-      <xsl:for-each select="parent::array/parent::map">
-         <xsl:copy>
-            <xsl:copy-of select="* except array[@key = 'STRVALUE']"/>
-            <string xmlns="http://www.w3.org/2005/xpath-functions" key="STRVALUE">
-               <xsl:value-of select="$me"/>
-            </string>
-         </xsl:copy>
-      </xsl:for-each>
-   </xsl:template>
-   <!-- 000 Handling field "markupline" 000 -->
-   <!-- 000 NB - template matching 'array' overrides this one 000 -->
-   <!--*[@key='markupline'] | *[@key='markup-lines']  | array[@key='markup-lines']/*-->
-   <xsl:template match="*[@key='markupline'] | *[@key='markup-lines']  | array[@key='markup-lines']/*"
-                 priority="5"
-                 mode="json2xml">
-      <xsl:element name="markupline"
-                   namespace="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime">
-         <xsl:apply-templates select="*" mode="as-attribute"/>
-         <xsl:for-each select="string[@key='RICHTEXT'], self::string">
-            <xsl:variable name="markup">
-               <xsl:apply-templates mode="infer-inlines"/>
-            </xsl:variable>
-            <xsl:apply-templates mode="cast-ns" select="$markup"/>
-         </xsl:for-each>
-      </xsl:element>
-   </xsl:template>
-   <xsl:template priority="3"
-                 mode="json2xml"
-                 match="map[@key = 'markup-lines']/array[@key = 'RICHTEXT'] | array[@key = 'markup-lines']/map/array[@key = 'RICHTEXT']">
-      <xsl:variable name="expanded" as="element()*">
-         <array xmlns="http://www.w3.org/2005/xpath-functions" key="markup-lines">
-            <xsl:apply-templates mode="expand" select="array[@key = 'RICHTEXT']/string"/>
-         </array>
-      </xsl:variable>
-      <xsl:apply-templates select="$expanded" mode="json2xml"/>
-   </xsl:template>
-   <xsl:template mode="expand"
-                 match="map[@key = 'markup-lines']/array[@key = 'RICHTEXT']/string | array[@key = 'markup-lines']/map/array[@key = 'RICHTEXT']/string">
-      <xsl:variable name="me" select="."/>
-      <xsl:for-each select="parent::array/parent::map">
-         <xsl:copy>
-            <xsl:copy-of select="* except array[@key = 'RICHTEXT']"/>
-            <string xmlns="http://www.w3.org/2005/xpath-functions" key="RICHTEXT">
-               <xsl:value-of select="$me"/>
-            </string>
-         </xsl:copy>
-      </xsl:for-each>
-   </xsl:template>
-   <!-- 00000000000000000000000000000000000000000000000000000000000000 -->
-   <!-- Markdown converter-->
-   <xsl:output indent="yes"/>
-   <xsl:template name="parse"><!-- First, group according to ``` delimiters btw codeblocks and not
-        within codeblock, escape & and < (only)
-        within not-codeblock split lines at \n\s*\n
-        
-        --><!-- $str may be passed in, or we can process the current node -->
-      <xsl:param name="markdown-str" as="xs:string" required="yes"/>
-      <xsl:variable name="str" select="string($markdown-str) =&gt; replace('\\n','&#xA;')"/>
-      <xsl:variable name="starts-with-code" select="matches($str,'^```')"/>
-      <!-- Blocks is split between code blocks and everything else -->
-      <xsl:variable name="blocks">
-         <xsl:for-each-group select="tokenize($str, '\n')"
-                             group-starting-with=".[matches(., '^```')]">
-            <xsl:variable name="this-is-code"
-                          select="not((position() mod 2) + number($starts-with-code))"/>
-            <m:p><!-- Adding an attribute flag when this is a code block, code='code' -->
-               <xsl:if test="$this-is-code">
-                  <xsl:variable name="language"
-                                expand-text="true"
-                                select="(replace(.,'^```','') ! normalize-space(.))[matches(.,'\S')]"/>
-                  <xsl:attribute name="code" select="if ($language) then $language else 'code'"/>
-               </xsl:if>
-               <xsl:value-of select="string-join(current-group()[not(matches(., '^```'))],'&#xA;')"/>
-            </m:p>
-         </xsl:for-each-group>
-      </xsl:variable>
-      <xsl:variable name="rough-blocks">
-         <xsl:apply-templates select="$blocks" mode="parse-block"/>
-      </xsl:variable>
-      <xsl:variable name="flat-structures">
-         <xsl:apply-templates select="$rough-blocks" mode="mark-structures"/>
-      </xsl:variable>
-      <!-- for debugging <xsl:copy-of select="$flat-structures"/>-->
-      <xsl:variable name="nested-structures">
-         <xsl:apply-templates select="$flat-structures" mode="build-structures"/>
-      </xsl:variable>
-      <!-- for debugging <xsl:copy-of select="$nested-structures"/>-->
-      <xsl:variable name="fully-marked">
-         <xsl:apply-templates select="$nested-structures" mode="infer-inlines"/>
-      </xsl:variable>
-      <xsl:apply-templates select="$fully-marked" mode="cast-ns"/>
-   </xsl:template>
-   <xsl:template match="*" mode="copy mark-structures build-structures infer-inlines">
-      <xsl:copy>
-         <xsl:copy-of select="@*"/>
-         <xsl:apply-templates mode="#current"/>
-      </xsl:copy>
-   </xsl:template>
-   <xsl:template mode="parse-block"
-                 priority="1"
-                 match="m:p[exists(@code)]"
-                 expand-text="true">
-      <xsl:element name="m:pre" namespace="{ $target-ns }">
-         <xsl:element name="code" namespace="{ $target-ns }">
-            <xsl:for-each select="@code[not(.='code')]">
-               <xsl:attribute name="class">language-{.}</xsl:attribute>
-            </xsl:for-each>
-            <xsl:value-of select="string(.)"/>
-         </xsl:element>
-      </xsl:element>
-   </xsl:template>
-   <xsl:template mode="parse-block" match="m:p" expand-text="true">
-      <xsl:for-each select="tokenize(string(.),'\n\s*\n')[normalize-space(.)]">
-         <m:p>
-            <xsl:value-of select="replace(.,'^\s*\n','')"/>
-         </m:p>
-      </xsl:for-each>
-   </xsl:template>
-   <xsl:function name="m:is-table-row-demarcator" as="xs:boolean">
-      <xsl:param name="line" as="xs:string"/>
-      <xsl:sequence select="matches($line,'^[\|\-:\s]+$')"/>
-   </xsl:function>
-   <xsl:function name="m:is-table" as="xs:boolean">
-      <xsl:param name="line" as="element(m:p)"/>
-      <xsl:variable name="lines" select="tokenize($line,'\s*\n')[matches(.,'\S')]"/>
-      <xsl:sequence select="(every $l in $lines satisfies matches($l,'^\|')) and (some $l in $lines satisfies m:is-table-row-demarcator($l))"/>
-   </xsl:function>
-   <xsl:template mode="mark-structures" priority="5" match="m:p[m:is-table(.)]">
-      <xsl:variable name="rows">
-         <xsl:for-each select="tokenize(string(.),'\s*\n')">
-            <m:tr>
-               <xsl:value-of select="."/>
-            </m:tr>
-         </xsl:for-each>
-      </xsl:variable>
-      <m:table>
-         <xsl:apply-templates select="$rows/m:tr" mode="make-row"/>
-      </m:table>
-   </xsl:template>
-   <xsl:template match="m:tr[m:is-table-row-demarcator(string(.))]"
-                 priority="5"
-                 mode="make-row"/>
-   <xsl:template match="m:tr" mode="make-row">
-      <m:tr>
-         <xsl:for-each select="tokenize(string(.), '\s*\|\s*')[not(position() = (1,last())) ]">
-            <m:td>
-               <xsl:value-of select="."/>
-            </m:td>
-         </xsl:for-each>
-      </m:tr>
-   </xsl:template>
-   <xsl:template match="m:tr[some $f in (following-sibling::tr) satisfies m:is-table-row-demarcator(string($f))]"
-                 mode="make-row">
-      <m:tr>
-         <xsl:for-each select="tokenize(string(.), '\s*\|\s*')[not(position() = (1,last())) ]">
-            <m:th>
-               <xsl:value-of select="."/>
-            </m:th>
-         </xsl:for-each>
-      </m:tr>
-   </xsl:template>
-   <xsl:template mode="mark-structures" match="m:p[matches(.,'^#')]"><!-- 's' flag is dot-matches-all, so \n does not impede -->
-      <m:p header-level="{ replace(.,'[^#].*$','','s') ! string-length(.) }">
-         <xsl:value-of select="replace(.,'^#+\s*','') ! replace(.,'\s+$','')"/>
-      </m:p>
-   </xsl:template>
-   <xsl:variable name="li-regex" as="xs:string">^\s*(\*|\d+\.)\s</xsl:variable>
-   <xsl:template mode="mark-structures" match="m:p[matches(.,$li-regex)]">
-      <m:list>
-         <xsl:for-each-group group-starting-with=".[matches(.,$li-regex)]"
-                             select="tokenize(., '\n')">
-            <m:li level="{ replace(.,'\S.*$','') ! floor(string-length(.) div 2)}"
-                  type="{ if (matches(.,'\s*\d')) then 'ol' else 'ul' }">
-               <xsl:for-each select="current-group()[normalize-space(.)]">
-                  <xsl:if test="not(position() eq 1)">
-                     <m:br/>
-                  </xsl:if>
-                  <xsl:value-of select="replace(., $li-regex, '')"/>
-               </xsl:for-each>
-            </m:li>
-         </xsl:for-each-group>
-      </m:list>
-   </xsl:template>
-   <xsl:template mode="build-structures" match="m:p[@header-level]">
-      <xsl:variable name="level" select="(@header-level[6 &gt;= .],6)[1]"/>
-      <xsl:element name="m:h{$level}"
-                   namespace="http://csrc.nist.gov/ns/oscal/1.0/md-convertor">
-         <xsl:value-of select="."/>
-      </xsl:element>
-   </xsl:template>
-   <xsl:template mode="build-structures" match="m:list" name="nest-lists"><!-- Starting at level 0 and grouping  --><!--        -->
-      <xsl:param name="level" select="0"/>
-      <xsl:param name="group" select="m:li"/>
-      <xsl:variable name="this-type" select="$group[1]/@type"/>
-      <!--first, splitting ul from ol groups -->
-      <!--<xsl:for-each-group select="$group" group-starting-with="*[@level = $level and not(@type = preceding-sibling::*[1]/@type)]">-->
-      <!--<xsl:for-each-group select="$group" group-starting-with="*[@level = $level]">-->
-      <xsl:element name="m:{ $group[1]/@type }"
-                   namespace="http://csrc.nist.gov/ns/oscal/1.0/md-convertor">
-         <xsl:for-each-group select="$group"
-                             group-starting-with="m:li[(@level = $level) or not(@type = preceding-sibling::*[1]/@type)]">
-            <xsl:choose>
-               <xsl:when test="@level = $level (: checking first item in group :)">
-                  <m:li><!--<xsl:copy-of select="@level"/>-->
-                     <xsl:apply-templates mode="copy"/>
-                     <xsl:if test="current-group()/@level &gt; $level (: go deeper? :)">
-                        <xsl:call-template name="nest-lists">
-                           <xsl:with-param name="level" select="$level + 1"/>
-                           <xsl:with-param name="group" select="current-group()[@level &gt; $level]"/>
-                        </xsl:call-template>
-                     </xsl:if>
-                  </m:li>
-               </xsl:when>
-               <xsl:otherwise><!-- fallback for skipping levels -->
-                  <m:li><!-- level="{$level}"-->
-                     <xsl:call-template name="nest-lists">
-                        <xsl:with-param name="level" select="$level + 1"/>
-                        <xsl:with-param name="group" select="current-group()"/>
-                     </xsl:call-template>
-                  </m:li>
-               </xsl:otherwise>
-            </xsl:choose>
-         </xsl:for-each-group>
-      </xsl:element>
-      <!--</xsl:for-each-group>-->
-   </xsl:template>
-   <xsl:template match="m:pre//text()" mode="infer-inlines">
-      <xsl:copy-of select="."/>
-   </xsl:template>
-   <xsl:template match="text()" mode="infer-inlines">
-      <xsl:variable name="markup">
-         <xsl:apply-templates select="$tag-replacements/m:rules">
-            <xsl:with-param name="original" tunnel="yes" as="text()" select="."/>
-         </xsl:apply-templates>
-      </xsl:variable>
-      <xsl:try select="parse-xml-fragment($markup)">
-         <xsl:catch select="."/>
-      </xsl:try>
-   </xsl:template>
-   <xsl:template mode="cast-ns" match="*">
-      <xsl:element name="{local-name()}" namespace="{ $target-ns }">
-         <xsl:copy-of select="@*[matches(.,'\S')]"/>
-         <xsl:apply-templates mode="#current"/>
-      </xsl:element>
-   </xsl:template>
-   <xsl:template match="m:rules" as="xs:string"><!-- Original is only provided for processing text nodes -->
-      <xsl:param name="original" as="text()?" tunnel="yes"/>
-      <xsl:param name="starting" as="xs:string" select="string($original)"/>
-      <xsl:iterate select="*">
-         <xsl:param name="original" select="$original" as="text()?"/>
-         <xsl:param name="str" select="$starting" as="xs:string"/>
-         <xsl:on-completion select="$str"/>
-         <xsl:next-iteration>
-            <xsl:with-param name="str">
-               <xsl:apply-templates select=".">
-                  <xsl:with-param name="str" select="$str"/>
-               </xsl:apply-templates>
-            </xsl:with-param>
-         </xsl:next-iteration>
-      </xsl:iterate>
-   </xsl:template>
-   <xsl:template match="m:replace" expand-text="true">
-      <xsl:param name="str" as="xs:string"/>
-      <!--<xsl:value-of>replace({$str},{@match},{string(.)})</xsl:value-of>-->
-      <xsl:sequence select="replace($str, @match, string(.))"/>
-      <!--<xsl:copy-of select="."/>-->
-   </xsl:template>
-   <xsl:variable xmlns="http://csrc.nist.gov/ns/oscal/1.0/md-convertor"
-                 name="tag-replacements">
-      <rules><!-- first, literal replacements -->
-         <replace match="&amp;">&amp;amp;</replace>
-         <replace match="&lt;">&amp;lt;</replace>
-         <!-- next, explicit escape sequences -->
-         <replace match="\\&#34;">&amp;quot;</replace>
-         <replace match="\\'">&amp;apos;</replace>
-         <replace match="\\\*">&amp;#2A;</replace>
-         <replace match="\\`">&amp;#60;</replace>
-         <replace match="\\~">&amp;#7E;</replace>
-         <replace match="\\^">&amp;#5E;</replace>
-         <!-- then, replacements based on $tag-specification -->
-         <xsl:for-each select="$tag-specification/*">
-            <xsl:variable name="match-expr">
-               <xsl:apply-templates select="." mode="write-match"/>
-            </xsl:variable>
-            <xsl:variable name="repl-expr">
-               <xsl:apply-templates select="." mode="write-replace"/>
-            </xsl:variable>
-            <replace match="{$match-expr}">
-               <xsl:sequence select="$repl-expr"/>
-            </replace>
-         </xsl:for-each>
-      </rules>
-   </xsl:variable>
-   <xsl:variable xmlns="http://csrc.nist.gov/ns/oscal/1.0/md-convertor"
-                 name="tag-specification"
-                 as="element(m:tag-spec)">
-      <tag-spec><!-- The XML notation represents the substitution by showing both delimiters and tags  --><!-- Note that text contents are regex notation for matching so * must be \* -->
-         <q>"<text/>"</q>
-         <img alt="!\[{{$noclosebracket}}\]" src="\({{$nocloseparen}}\)"/>
-         <insert param-id="\{{\{{{{$nws}}\}}\}}"/>
-         <a href="\[{{$nocloseparen}}\]">\(<text not="\)"/>\)</a>
-         <code>`<text/>`</code>
-         <strong>
-            <em>\*\*\*<text/>\*\*\*</em>
-         </strong>
-         <strong>\*\*<text/>\*\*</strong>
-         <em>\*<text/>\*</em>
-         <sub>~<text/>~</sub>
-         <sup>\^<text/>\^</sup>
-      </tag-spec>
-   </xsl:variable>
-   <xsl:template match="*" mode="write-replace"><!-- we can write an open/close pair even for an empty element b/c
-             it will be parsed and serialized -->
-      <xsl:text>&lt;</xsl:text>
-      <xsl:value-of select="local-name()"/>
-      <!-- coercing the order to ensure correct formation of regegex       -->
-      <xsl:apply-templates mode="#current" select="@*"/>
-      <xsl:text>&gt;</xsl:text>
-      <xsl:apply-templates mode="#current" select="*"/>
-      <xsl:text>&lt;/</xsl:text>
-      <xsl:value-of select="local-name()"/>
-      <xsl:text>&gt;</xsl:text>
-   </xsl:template>
-   <xsl:template match="*" mode="write-match">
-      <xsl:apply-templates select="@*, node()" mode="write-match"/>
-   </xsl:template>
-   <xsl:template match="@*[matches(., '\{\$text\}')]" mode="write-match">
-      <xsl:value-of select="replace(., '\{\$text\}', '(.*)?')"/>
-   </xsl:template>
-   <xsl:template match="@*[matches(., '\{\$nocloseparen\}')]" mode="write-match">
-      <xsl:value-of select="replace(., '\{\$nocloseparen\}', '([^\\(]*)?')"/>
-   </xsl:template>
-   <xsl:template match="@*[matches(., '\{\$noclosebracket\}')]" mode="write-match">
-      <xsl:value-of select="replace(., '\{\$noclosebracket\}', '([^\\[]*)?')"/>
-   </xsl:template>
-   <xsl:template match="@*[matches(., '\{\$nws\}')]" mode="write-match"><!--<xsl:value-of select="."/>--><!--<xsl:value-of select="replace(., '\{\$nws\}', '(\S*)?')"/>-->
-      <xsl:value-of select="replace(., '\{\$nws\}', '\\s*(\\S+)?\\s*')"/>
-   </xsl:template>
-   <xsl:template match="m:text" mode="write-replace">
-      <xsl:text>$1</xsl:text>
-   </xsl:template>
-   <xsl:template match="m:insert/@param-id" mode="write-replace">
-      <xsl:text> param-id='$1'</xsl:text>
-   </xsl:template>
-   <xsl:template match="m:a/@href" mode="write-replace">
-      <xsl:text> href='$2'</xsl:text>
-      <!--<xsl:value-of select="replace(.,'\{\$insert\}','\$2')"/>-->
-   </xsl:template>
-   <xsl:template match="m:img/@alt" mode="write-replace">
-      <xsl:text> alt='$1'</xsl:text>
-      <!--<xsl:value-of select="replace(.,'\{\$insert\}','\$2')"/>-->
-   </xsl:template>
-   <xsl:template match="m:img/@src" mode="write-replace">
-      <xsl:text> src='$2'</xsl:text>
-      <!--<xsl:value-of select="replace(.,'\{\$insert\}','\$2')"/>-->
-   </xsl:template>
-   <xsl:template match="m:text" mode="write-match">
-      <xsl:text>(.*?)</xsl:text>
-   </xsl:template>
-   <xsl:template match="m:text[@not]" mode="write-match">
-      <xsl:text expand-text="true">([^{ @not }]*?)</xsl:text>
-   </xsl:template>
-   <xsl:variable name="line-example" xml:space="preserve"> { insertion } </xsl:variable>
-</xsl:stylesheet>
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test-schema.json b/build/metaschema/unit-testing/char-handling/charstrings-test-schema.json
deleted file mode 100644
index f634dbd315..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test-schema.json
+++ /dev/null
@@ -1,44 +0,0 @@
-
-  { "$schema" : "http://json-schema.org/draft-07/schema#",
-    "$id" : "http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime-schema.json",
-    "$comment" : "Metaschema Unit Test: datatypes-dateTime: JSON Schema",
-    "type" : "object",
-    "definitions" : 
-    { "examples" : 
-      { "title" : "Examples",
-        "description" : "Some character strings of different sorts",
-        "$id" : "#/definitions/examples",
-        "type" : "object",
-        "properties" : 
-        { "character-strings" : 
-          { "anyOf" : 
-            [ 
-              { "$ref" : "#/definitions/charstring" },
-              
-              { "type" : "array",
-                "items" : 
-                { "$ref" : "#/definitions/charstring" },
-                "minItems" : 2 } ] },
-          "markup-lines" : 
-          { "anyOf" : 
-            [ 
-              { "$ref" : "#/definitions/markupline" },
-              
-              { "type" : "array",
-                "items" : 
-                { "$ref" : "#/definitions/markupline" },
-                "minItems" : 2 } ] } },
-        "additionalProperties" : false },
-      "charstring" : 
-      { "title" : "Character string",
-        "description" : "String of characters",
-        "$id" : "#/definitions/charstring",
-        "type" : "string" },
-      "markupline" : 
-      { "title" : "Markup line",
-        "description" : "Characters, and more",
-        "$id" : "#/definitions/markupline",
-        "type" : "string" } },
-    "properties" : 
-    { "examples" : 
-      { "$ref" : "#/definitions/examples" } } }
\ No newline at end of file
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test-schema.xsd b/build/metaschema/unit-testing/char-handling/charstrings-test-schema.xsd
deleted file mode 100644
index 49e95bc931..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test-schema.xsd
+++ /dev/null
@@ -1,285 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-           xmlns:m="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
-           xmlns:metaschema-datatypes-dateTime="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime"
-           xmlns:oscal-prose="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime"
-           elementFormDefault="qualified"
-           targetNamespace="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime"
-           version="1.0-milestone1">
-   <xs:annotation>
-      <xs:appinfo>
-         <m:schema-name>Metaschema Unit Test: datatypes-dateTime</m:schema-name>
-         <m:schema-version>1.0-milestone1</m:schema-version>
-         <m:short-name>metaschema-datatypes-dateTime</m:short-name>
-         <m:root>examples</m:root>
-      </xs:appinfo>
-   </xs:annotation>
-   <xs:element name="examples" m:root="yes">
-      <xs:annotation>
-         <xs:appinfo>
-            <m:formal-name>Examples</m:formal-name>
-            <m:description>Some character strings of different sorts</m:description>
-         </xs:appinfo>
-         <xs:documentation>
-            <b>Examples</b>: Some character strings of different sorts</xs:documentation>
-      </xs:annotation>
-      <xs:complexType>
-         <xs:sequence>
-            <xs:element ref="metaschema-datatypes-dateTime:charstring"
-                        minOccurs="0"
-                        maxOccurs="unbounded"/>
-            <xs:element ref="metaschema-datatypes-dateTime:markupline"
-                        minOccurs="0"
-                        maxOccurs="unbounded"/>
-         </xs:sequence>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="charstring">
-      <xs:annotation>
-         <xs:appinfo>
-            <m:formal-name>Character string</m:formal-name>
-            <m:description>String of characters</m:description>
-         </xs:appinfo>
-         <xs:documentation>
-            <b>Character string</b>: String of characters</xs:documentation>
-      </xs:annotation>
-      <xs:complexType mixed="true"/>
-   </xs:element>
-   <xs:element name="markupline">
-      <xs:annotation>
-         <xs:appinfo>
-            <m:formal-name>Markup line</m:formal-name>
-            <m:description>Characters, and more</m:description>
-         </xs:appinfo>
-         <xs:documentation>
-            <b>Markup line</b>: Characters, and more</xs:documentation>
-      </xs:annotation>
-      <xs:complexType mixed="true">
-         <xs:group ref="metaschema-datatypes-dateTime:everything-inline"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h1">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h2">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h3">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h4">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h5">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="h6">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:inlines"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="p">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:everything-inline"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="pre">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="ol">
-      <xs:complexType>
-         <xs:sequence>
-            <xs:element maxOccurs="unbounded" ref="oscal-prose:li"/>
-         </xs:sequence>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="li">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:everything-inline"/>
-            <xs:element ref="oscal-prose:ol"/>
-            <xs:element ref="oscal-prose:ul"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="ul">
-      <xs:complexType>
-         <xs:sequence>
-            <xs:element maxOccurs="unbounded" ref="oscal-prose:li"/>
-         </xs:sequence>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="table">
-      <xs:complexType>
-         <xs:sequence>
-            <xs:element maxOccurs="unbounded" ref="oscal-prose:tr"/>
-         </xs:sequence>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="tr">
-      <xs:complexType>
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element maxOccurs="unbounded" ref="oscal-prose:td"/>
-            <xs:element maxOccurs="unbounded" ref="oscal-prose:th"/>
-         </xs:choice>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="th">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:everything-inline"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="td">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:everything-inline"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:group name="everything-inline">
-      <xs:sequence>
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:group ref="oscal-prose:special"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-      </xs:sequence>
-   </xs:group>
-   <xs:group name="mix">
-      <xs:sequence>
-         <xs:group minOccurs="0" maxOccurs="unbounded" ref="oscal-prose:inlines"/>
-      </xs:sequence>
-   </xs:group>
-   <xs:group name="inlines">
-      <xs:sequence>
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element ref="oscal-prose:q"/>
-            <xs:element ref="oscal-prose:code"/>
-            <xs:element ref="oscal-prose:em"/>
-            <xs:element ref="oscal-prose:i"/>
-            <xs:element ref="oscal-prose:strong"/>
-            <xs:element ref="oscal-prose:b"/>
-            <xs:element ref="oscal-prose:sub"/>
-            <xs:element ref="oscal-prose:sup"/>
-            <xs:element ref="oscal-prose:img"/>
-         </xs:choice>
-      </xs:sequence>
-   </xs:group>
-   <xs:element name="q">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element ref="oscal-prose:code"/>
-            <xs:element ref="oscal-prose:em"/>
-            <xs:element ref="oscal-prose:i"/>
-            <xs:element ref="oscal-prose:b"/>
-            <xs:element ref="oscal-prose:strong"/>
-            <xs:element ref="oscal-prose:sub"/>
-            <xs:element ref="oscal-prose:sup"/>
-         </xs:choice>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="code">
-      <xs:complexType mixed="true">
-         <xs:group ref="oscal-prose:mix"/>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="strong">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="em">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="i">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="b">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:group ref="oscal-prose:mix"/>
-            <xs:element ref="oscal-prose:a"/>
-         </xs:choice>
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="sub">
-      <xs:complexType mixed="true">
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="sup">
-      <xs:complexType mixed="true">
-         <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="img">
-      <xs:complexType>
-         <xs:attribute name="alt"/>
-         <xs:attribute name="src" use="required" type="xs:anyURI"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:element name="a">
-      <xs:complexType mixed="true">
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element ref="oscal-prose:q"/>
-            <xs:element ref="oscal-prose:code"/>
-            <xs:element name="em">
-               <xs:complexType mixed="true">
-                  <xs:attributeGroup ref="oscal-prose:optionalClass"/>
-               </xs:complexType>
-            </xs:element>
-         </xs:choice>
-         <xs:attribute name="href"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:group name="special">
-      <xs:sequence>
-         <xs:choice minOccurs="0" maxOccurs="unbounded">
-            <xs:element ref="oscal-prose:insert"/>
-         </xs:choice>
-      </xs:sequence>
-   </xs:group>
-   <xs:element name="insert">
-      <xs:complexType>
-         <xs:attribute name="param-id" use="required" type="xs:NCName"/>
-      </xs:complexType>
-   </xs:element>
-   <xs:attributeGroup name="requiredClass"/>
-   <xs:attributeGroup name="optionalClass"/>
-   <xs:attributeGroup name="hrefAttr">
-      <xs:attribute name="href"/>
-   </xs:attributeGroup>
-</xs:schema>
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test-xml-converter.xsl b/build/metaschema/unit-testing/char-handling/charstrings-test-xml-converter.xsl
deleted file mode 100644
index 950ad1dbdd..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test-xml-converter.xsl
+++ /dev/null
@@ -1,257 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-                xmlns:xs="http://www.w3.org/2001/XMLSchema"
-                xmlns:m="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
-                xmlns="http://www.w3.org/2005/xpath-functions"
-                version="3.0"
-                xpath-default-namespace="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime"
-                exclude-result-prefixes="#all">
-   <xsl:output indent="yes"
-               method="text"
-               omit-xml-declaration="yes"
-               use-character-maps="delimiters"/>
-   <!-- METASCHEMA conversion stylesheet supports XML->JSON conversion -->
-   <!-- 88888888888888888888888888888888888888888888888888888888888888 -->
-   <xsl:character-map name="delimiters"/>
-   <xsl:param name="json-indent" as="xs:string">no</xsl:param>
-   <!-- Pass $diagnostic as 'rough' for first pass, 'rectified' for second pass -->
-   <xsl:param name="diagnostic" as="xs:string">no</xsl:param>
-   <xsl:template match="text()" mode="md #default">
-      <xsl:value-of select="."/>
-   </xsl:template>
-   <xsl:variable name="write-options" as="map(*)" expand-text="true">
-      <xsl:map>
-         <xsl:map-entry key="'indent'">{ $json-indent='yes' }</xsl:map-entry>
-      </xsl:map>
-   </xsl:variable>
-   <xsl:variable name="xpath-json">
-      <map>
-         <xsl:apply-templates select="/" mode="xml2json"/>
-      </map>
-   </xsl:variable>
-   <xsl:variable name="rectified">
-      <xsl:apply-templates select="$xpath-json" mode="rectify"/>
-   </xsl:variable>
-   <xsl:template match="/">
-      <xsl:choose>
-         <xsl:when test="$diagnostic = 'rough'">
-            <xsl:copy-of select="$xpath-json"/>
-         </xsl:when>
-         <xsl:when test="$diagnostic = 'rectified'">
-            <xsl:copy-of select="$rectified"/>
-         </xsl:when>
-         <xsl:otherwise>
-            <xsl:value-of select="xml-to-json($rectified, $write-options)"/>
-         </xsl:otherwise>
-      </xsl:choose>
-   </xsl:template>
-   <xsl:template match="node() | @*" mode="rectify">
-      <xsl:copy copy-namespaces="no">
-         <xsl:apply-templates mode="#current" select="node() | @*"/>
-      </xsl:copy>
-   </xsl:template>
-   <xsl:template mode="rectify"
-                 xpath-default-namespace="http://www.w3.org/2005/xpath-functions"
-                 match="/*/@key | array/*/@key"/>
-   <xsl:template mode="rectify" match="@m:*"/>
-   <xsl:template mode="rectify"
-                 match="array[count(*) eq 1][not(@m:in-json = 'ARRAY')]"
-                 xpath-default-namespace="http://www.w3.org/2005/xpath-functions">
-      <xsl:for-each select="*">
-         <xsl:copy>
-            <xsl:copy-of select="../@key"/>
-            <xsl:apply-templates mode="#current"/>
-         </xsl:copy>
-      </xsl:for-each>
-   </xsl:template>
-   <xsl:template name="prose">
-      <xsl:param name="key" select="'PROSE'"/>
-      <xsl:variable name="blocks"
-                    select="p | ul | ol | pre | h1 | h2 | h3 | h4 | h5 | h6 | table"/>
-      <xsl:if test="exists($blocks)">
-         <xsl:variable name="string-sequence" as="element()*">
-            <xsl:apply-templates mode="md" select="$blocks"/>
-         </xsl:variable>
-         <string key="{$key}">
-            <xsl:value-of select="string-join($string-sequence, '\n')"/>
-         </string>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="as-string" match="@* | *">
-      <xsl:param name="key" select="local-name()"/>
-      <xsl:param name="mandatory" select="false()"/>
-      <xsl:if test="$mandatory or matches(., '\S')">
-         <string key="{ $key }">
-            <xsl:value-of select="."/>
-         </string>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="as-boolean" match="@* | *">
-      <xsl:param name="key" select="local-name()"/>
-      <xsl:param name="mandatory" select="false()"/>
-      <xsl:if test="$mandatory or matches(., '\S')">
-         <boolean key="{ $key }">
-            <xsl:value-of select="."/>
-         </boolean>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="as-integer" match="@* | *">
-      <xsl:param name="key" select="local-name()"/>
-      <xsl:param name="mandatory" select="false()"/>
-      <xsl:if test="$mandatory or matches(., '\S')">
-         <integer key="{ $key }">
-            <xsl:value-of select="."/>
-         </integer>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="as-number" match="@* | *">
-      <xsl:param name="key" select="local-name()"/>
-      <xsl:param name="mandatory" select="false()"/>
-      <xsl:if test="$mandatory or matches(., '\S')">
-         <number key="{ $key }">
-            <xsl:value-of select="."/>
-         </number>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template name="conditional-lf">
-      <xsl:variable name="predecessor"
-                    select="preceding-sibling::p | preceding-sibling::ul | preceding-sibling::ol | preceding-sibling::table | preceding-sibling::pre"/>
-      <xsl:if test="exists($predecessor)">
-         <string/>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="md" match="p | link | part/*">
-      <xsl:call-template name="conditional-lf"/>
-      <string>
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-   <xsl:template mode="md" match="h1 | h2 | h3 | h4 | h5 | h6">
-      <xsl:call-template name="conditional-lf"/>
-      <string>
-         <xsl:apply-templates select="." mode="mark"/>
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-   <xsl:template mode="mark" match="h1"># </xsl:template>
-   <xsl:template mode="mark" match="h2">## </xsl:template>
-   <xsl:template mode="mark" match="h3">### </xsl:template>
-   <xsl:template mode="mark" match="h4">#### </xsl:template>
-   <xsl:template mode="mark" match="h5">##### </xsl:template>
-   <xsl:template mode="mark" match="h6">###### </xsl:template>
-   <xsl:template mode="md" match="table">
-      <xsl:call-template name="conditional-lf"/>
-      <xsl:apply-templates select="*" mode="md"/>
-   </xsl:template>
-   <xsl:template mode="md" match="tr">
-      <string>
-         <xsl:apply-templates select="*" mode="md"/>
-      </string>
-      <xsl:if test="empty(preceding-sibling::tr)">
-         <string>
-            <xsl:text>|</xsl:text>
-            <xsl:for-each select="th | td"> --- |</xsl:for-each>
-         </string>
-      </xsl:if>
-   </xsl:template>
-   <xsl:template mode="md" match="th | td">
-      <xsl:if test="empty(preceding-sibling::*)">|</xsl:if>
-      <xsl:text> </xsl:text>
-      <xsl:apply-templates mode="md"/>
-      <xsl:text> |</xsl:text>
-   </xsl:template>
-   <xsl:template mode="md" priority="1" match="pre">
-      <xsl:call-template name="conditional-lf"/>
-      <string>```</string>
-      <string>
-         <xsl:apply-templates mode="md"/>
-      </string>
-      <string>```</string>
-   </xsl:template>
-   <xsl:template mode="md" priority="1" match="ul | ol">
-      <xsl:call-template name="conditional-lf"/>
-      <xsl:apply-templates mode="md"/>
-      <string/>
-   </xsl:template>
-   <xsl:template mode="md" match="ul//ul | ol//ol | ol//ul | ul//ol">
-      <xsl:apply-templates mode="md"/>
-   </xsl:template>
-   <xsl:template mode="md" match="li">
-      <string>
-         <xsl:for-each select="../ancestor::ul">
-            <xsl:text/>
-         </xsl:for-each>
-         <xsl:text>* </xsl:text>
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-   <xsl:template mode="md" match="ol/li">
-      <string/>
-      <string>
-         <xsl:for-each select="../ancestor::ul">
-            <xsl:text/>
-         </xsl:for-each>
-         <xsl:text>1. </xsl:text>
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-   <xsl:template mode="md" match="code | span[contains(@class, 'code')]">
-      <xsl:text>`</xsl:text>
-      <xsl:apply-templates mode="md"/>
-      <xsl:text>`</xsl:text>
-   </xsl:template>
-   <xsl:template mode="md" match="em | i">
-      <xsl:text>*</xsl:text>
-      <xsl:apply-templates mode="md"/>
-      <xsl:text>*</xsl:text>
-   </xsl:template>
-   <xsl:template mode="md" match="strong | b">
-      <xsl:text>**</xsl:text>
-      <xsl:apply-templates mode="md"/>
-      <xsl:text>**</xsl:text>
-   </xsl:template>
-   <xsl:template mode="md" match="q">
-      <xsl:text>"</xsl:text>
-      <xsl:apply-templates mode="md"/>
-      <xsl:text>"</xsl:text>
-   </xsl:template>
-   <xsl:template mode="md" match="insert">
-      <xsl:text>{{ </xsl:text>
-      <xsl:value-of select="@param-id"/>
-      <xsl:text> }}</xsl:text>
-   </xsl:template>
-   <xsl:key name="element-by-id" match="*[exists(@id)]" use="@id"/>
-   <xsl:template mode="md" match="a">
-      <xsl:text>[</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-      <xsl:text>(</xsl:text>
-      <xsl:value-of select="@href"/>
-      <xsl:text>)</xsl:text>
-   </xsl:template>
-   <!-- 88888888888888888888888888888888888888888888888888888888888888 -->
-   <xsl:template match="examples" mode="xml2json">
-      <map key="examples">
-         <xsl:if test="exists(charstring)">
-            <array key="character-strings">
-               <xsl:apply-templates select="charstring" mode="#current"/>
-            </array>
-         </xsl:if>
-         <xsl:if test="exists(markupline)">
-            <array key="markup-lines">
-               <xsl:apply-templates select="markupline" mode="#current"/>
-            </array>
-         </xsl:if>
-      </map>
-   </xsl:template>
-   <xsl:template match="charstring" mode="xml2json">
-      <string key="charstring">
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-   <xsl:template match="markupline" mode="xml2json">
-      <string key="markupline">
-         <xsl:apply-templates mode="md"/>
-      </string>
-   </xsl:template>
-</xsl:stylesheet>
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test_metaschema.xml b/build/metaschema/unit-testing/char-handling/charstrings-test_metaschema.xml
deleted file mode 100644
index 71c63bf407..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test_metaschema.xml
+++ /dev/null
@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- OSCAL CATALOG METASCHEMA -->
-<!-- validate with XSD and Schematron (linked) -->
-<?xml-model href="../../lib/metaschema-check.sch" type="application/xml" schematypens="http://purl.oclc.org/dsdl/schematron"?>
-<?xml-stylesheet type="text/css" href="../../lib/metaschema-author.css"?>
-<METASCHEMA xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://csrc.nist.gov/ns/oscal/metaschema/1.0 ../../lib/metaschema.xsd"
- xmlns="http://csrc.nist.gov/ns/oscal/metaschema/1.0"
- xmlns:o="http://csrc.nist.gov/ns/oscal/example"
- root="examples">
-  <schema-name>Metaschema Unit Test: datatypes-dateTime</schema-name>
-  <schema-version>1.0-milestone1</schema-version>
-  <short-name>metaschema-datatypes-dateTime</short-name>
-  <namespace>http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime</namespace>
-
-  <define-assembly name="examples">
-    <formal-name>Examples</formal-name>
-    <description>Some character strings of different sorts</description>
-    <model>
-      <field ref="charstring" max-occurs="unbounded">
-        <group-as name="character-strings"/>
-      </field>
-      <field ref="markupline" max-occurs="unbounded">
-        <group-as name="markup-lines"/>
-      </field>
-    </model>
-  </define-assembly>
-
-  <define-field name="charstring">
-    <formal-name>Character string</formal-name>
-    <description>String of characters</description>
-  </define-field>
-  
-  <define-field name="markupline" as-type="markup-line">
-    <formal-name>Markup line</formal-name>
-    <description>Characters, and more</description>
-  </define-field>
-  
-  
-</METASCHEMA>
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS-back.xml b/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS-back.xml
deleted file mode 100644
index 99c71f4b7c..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS-back.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<examples xmlns="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime">
-   <charstring>Here's a string including punctuation ' " \ . $</charstring>
-   <charstring>Here's a string with an ampersand &amp;</charstring>
-   <charstring>Less-than and greater-than, as &lt;delimiters&gt; ...</charstring>
-   <charstring>The star aka asterisk * may be magical and maybe also the tick `</charstring>
-   <markupline>Also, occasionally we have <a href="w3.org">links</a> and <em>other markup</em>.</markupline>
-</examples>
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.json b/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.json
deleted file mode 100644
index 23a0a98cb0..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.json
+++ /dev/null
@@ -1,8 +0,0 @@
-
-  { "examples" : 
-    { "character-strings" : 
-      [ "Here's a string including punctuation ' \" \\ . $",
-        "Here's a string with an ampersand &",
-        "Less-than and greater-than, as <delimiters> ...",
-        "The star aka asterisk * may be magical and maybe also the tick `" ],
-      "markup-lines" : "Also, occasionally we have [links](w3.org) and *other markup*." } }
\ No newline at end of file
diff --git a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.xml b/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.xml
deleted file mode 100644
index 9a8f9beb3e..0000000000
--- a/build/metaschema/unit-testing/char-handling/charstrings-test_okay-PASS.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<examples xmlns="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://csrc.nist.gov/ns/metaschema/unit-test/datatypes-dateTime file:/C:/Users/wap1/Documents/OSCAL/build/metaschema/unit-testing/char-encoding/charstrings-test-schema.xsd">
-  <charstring>Here's a string including punctuation ' " \ . $</charstring>
-  <charstring>Here's a string with an ampersand &amp;</charstring>
-  <charstring>Less-than and greater-than, as &lt;delimiters> ...</charstring>
-  <charstring>The star aka asterisk * may be magical and maybe also the tick `</charstring>
-  <markupline>Also, occasionally we have <a href="w3.org">links</a> and <em>other markup</em>.</markupline>    
-</examples>
\ No newline at end of file
diff --git a/build/metaschema/unit-testing/char-handling/refresh.sh b/build/metaschema/unit-testing/char-handling/refresh.sh
deleted file mode 100644
index ab6c8adba4..0000000000
--- a/build/metaschema/unit-testing/char-handling/refresh.sh
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/bin/bash
-
-# Produces Metaschema artifacts from an OSCAL Metaschema metaschema
-# Including XML and JSON schemas, conversion utilities (XSLTs) and Markdown documentation
-
-METASCHEMAXML=charstrings-test_metaschema.xml
-BASENAME=charstrings-test
-
-OSCALDIR=../../../..
-
-if [[ -z SAXON_HOME ]]; then
-    echo "SAXON_HOME is not set"
-    exit 1
-elif [[ -z "$SAXON_HOME" ]]; then
-    echo "SAXON_HOME is set to the empty string"
-    exit 1
-fi
-
-SAXON=$SAXON_HOME/Saxon-HE-9.9.1-3.jar
-
-if [ ! -f $SAXON ]; then
-    echo "The saxon library was not found at: $SAXON!"
-    exit 1
-fi
-
-# Saxon CL documented here: http://www.saxonica.com/documentation9.8/using-xsl/commandline.html
-
-LIBDIR=$OSCALDIR/build/metaschema
-XSDDIR=.
-JSONDIR=.
-CONVERSION_DIR=.
-CURRENT_DIR=$(pwd -W)
-# DOCSDIR=docs
-
-echo Working in $CURRENT_DIR
-
-MAKE_XSD="java -jar $SAXON -s:$METASCHEMAXML -o:$XSDDIR/$BASENAME-schema.xsd -xsl:$LIBDIR/xml/produce-xsd.xsl"
-MAKE_JSC="java -jar $SAXON -s:$METASCHEMAXML -o:$JSONDIR/$BASENAME-schema.json -xsl:$LIBDIR/json/produce-json-schema.xsl"
-
-CONV_XML="java -jar $SAXON -s:$METASCHEMAXML -o:$CONVERSION_DIR/$BASENAME-xml-converter.xsl -xsl:$LIBDIR/xml/produce-xml-converter.xsl"
-CONV_JSON="java -jar $SAXON -s:$METASCHEMAXML -o:$CONVERSION_DIR/$BASENAME-json-converter.xsl  -xsl:$LIBDIR/json/produce-json-converter.xsl"
-
-EXAMPLE_BASE=charstrings-test_okay-PASS
-
-EXAMPLE_JSON="java -jar $SAXON -s:$EXAMPLE_BASE.xml -o:$EXAMPLE_BASE.json  -xsl:$CONVERSION_DIR/$BASENAME-xml-converter.xsl json-indent=yes"
-EXAMPLE_BACK="java -jar $SAXON -it -o:$EXAMPLE_BASE-back.xml  -xsl:$CONVERSION_DIR/$BASENAME-json-converter.xsl json-file=$CURRENT_DIR/$EXAMPLE_BASE.json"
-
-# DOCS_XSLT="java -jar $SAXON -s:$METASCHEMAXML -o:$LIBDIR/temp/$BASENAME-xml-docs-md.xsl -xsl:$LIBDIR/xml/produce-and-run-documentor.xsl"
-
-# Now ...
-echo
-echo Producing JSON and XML schemas and tools from $METASCHEMAXML ...
-$MAKE_XSD
-echo _ Made XSD ________________________ $XSDDIR/$BASENAME-schema.xsd
-$MAKE_JSC
-echo _ Made JSON Schema ________________ $JSONDIR/$BASENAME-schema.json
-$CONV_XML
-echo _ Made XML-to-JSON converter ______ $CONVERSION_DIR/$BASENAME-xml-converter.xsl
-$CONV_JSON
-echo _ Made JSON-to-XML converter ______ $CONVERSION_DIR/$BASENAME-json-converter.xsl
-$EXAMPLE_JSON
-echo _ Produced $EXAMPLE_BASE.json from $EXAMPLE_BASE.xml
-$EXAMPLE_BACK
-echo _ Produced $EXAMPLE_BASE-back.xml from $EXAMPLE_BASE.json
-
-# $DOCS_XSLT
-# echo _ Made Metaschema documentation _ $DOCSDIR/${BASENAME}_xml.md $DOCSDIR/json_${BASENAME}_json.md
-# echo
diff --git a/build/metaschema/xml/produce-xml-converter.xsl b/build/metaschema/xml/produce-xml-converter.xsl
index 206c1f3b3d..b414af680a 100644
--- a/build/metaschema/xml/produce-xml-converter.xsl
+++ b/build/metaschema/xml/produce-xml-converter.xsl
@@ -44,38 +44,12 @@
             xpath-default-namespace="{ $target-namespace }"
             exclude-result-prefixes="#all">
             
-            <XSLT:output indent="yes" method="text" omit-xml-declaration="yes" use-character-maps="delimiters"/>
+            <XSLT:output indent="yes" method="xml" omit-xml-declaration="yes" use-character-maps="delimiters"/>
             
             <xsl:comment> METASCHEMA conversion stylesheet supports XML->JSON conversion </xsl:comment>
             <xsl:text>&#xA;</xsl:text>
             <xsl:comment> 88888888888888888888888888888888888888888888888888888888888888 </xsl:comment>
             <xsl:text>&#xA;</xsl:text>
-            
-            <XSLT:character-map name="delimiters">
-                <!--<XSLT:output-character character="&lt;" string="\u003c"/>
-                <XSLT:output-character character="&gt;" string="\u003e"/>-->
-            </XSLT:character-map>
-            
-            <XSLT:param name="json-indent" as="xs:string">no</XSLT:param>
-            <xsl:comment> Pass $diagnostic as 'rough' for first pass, 'rectified' for second pass </xsl:comment>
-            <XSLT:param name="diagnostic" as="xs:string">no</XSLT:param>
-            
-            <!-- Note that Saxon's JSON serializer already escapes characters per
-                 https://www.w3.org/XML/Group/qtspecs/specifications/xpath-functions-31/html/Overview.html#func-xml-to-json 
-            -->
-            <XSLT:template match="text()" mode="md #default">
-                <!-- Escapes go here       -->
-                <!--<XSLT:value-of select="replace(.,'\s+',' ') ! replace(.,'([`~\^\*])','\\$1')"/>-->
-                <!--<XSLT:value-of select="replace(., '([`~\^\*''&quot;])', '\\$1')"/>-->
-                <XSLT:value-of select="."/>
-            </XSLT:template>
-            
-            <XSLT:variable name="write-options" as="map(*)" expand-text="true">
-                <XSLT:map>
-                    <XSLT:map-entry key="'indent'">{ $json-indent='yes' }</XSLT:map-entry>
-                </XSLT:map>
-            </XSLT:variable>
-            
             <xsl:call-template name="furniture"/>
             <xsl:text>&#xA;</xsl:text>
             <xsl:comment> 88888888888888888888888888888888888888888888888888888888888888 </xsl:comment>
@@ -95,6 +69,63 @@
      with fields or assemblies. -->
     <xsl:template match="define-flag"/>
     
+    <!--<xsl:template match="define-field[@address=flag/@name][@as='mixed'][empty(flag)]" priority="4">
+        <XSLT:template match="{@name}" mode="xml2json">
+            <string key="{@address}">
+                <xsl:apply-templates mode="md"/>
+            </string>
+        </XSLT:template>
+    </xsl:template>-->
+    
+    <!--<xsl:template match="define-field[@address=flag/@name][empty(flag)]" priority="3">
+        <XSLT:template match="{@name}" mode="xml2json">
+            <string key="{@address}">
+                <xsl:apply-templates mode="md"/>
+            </string>
+        </XSLT:template>
+    </xsl:template>-->
+    
+    <!--<xsl:template match="define-field[@address=flag/@name][@as='mixed']" priority="2">
+        <XSLT:template match="{@name}" mode="xml2json">
+            <map key="{@address}">
+                <xsl:apply-templates select="flag"/>
+                
+                <XSLT:if test="matches(.,'\S')">
+                    <string key="TEXT">
+                        <XSLT:apply-templates mode="md"/>
+                    </string>
+                </XSLT:if>
+            </map>
+        </XSLT:template>
+    </xsl:template>-->
+    
+    
+<!-- Keys are added to everything and then removed from nodes in arrays, in mode 'rectify' -->
+
+    <!-- ignoring address in these cases -->
+   <!-- <xsl:template match="define-field[empty(flag)][@as='mixed']" priority="3">
+        <XSLT:template match="{@name}" mode="xml2json">
+            <string key="{@name}">
+                <XSLT:apply-templates mode="md"/>
+            </string>
+        </XSLT:template>
+    </xsl:template>-->
+    
+    <!--<xsl:template match="define-field[@as='mixed']">
+        <XSLT:template match="{@name}" mode="xml2json">
+            <map key="{@name}">
+                <xsl:apply-templates select="flag"/>
+                
+                <XSLT:if test="matches(.,'\S')">
+                    <string key="RICHTEXT">
+                        <XSLT:apply-templates mode="md"/>
+                    </string>
+                </XSLT:if>
+            </map>
+        </XSLT:template>
+    </xsl:template>-->
+    
+    
     <xsl:template match="define-field" mode="text-key">
         <xsl:value-of select="$string-value-label"/>
     </xsl:template>
@@ -337,6 +368,21 @@
     
     <xsl:template name="furniture">
 
+        <XSLT:character-map name="delimiters">
+            <XSLT:output-character character="&lt;" string="\u003c"/>
+            <XSLT:output-character character="&gt;" string="\u003e"/>
+        </XSLT:character-map>
+
+        <XSLT:param name="json-indent" as="xs:string">no</XSLT:param>
+        <xsl:comment> Pass $diagnostic as 'rough' for first pass, 'rectified' for second pass </xsl:comment>
+        <XSLT:param name="diagnostic" as="xs:string">no</XSLT:param>
+
+        <XSLT:variable name="write-options" as="map(*)" expand-text="true">
+            <XSLT:map>
+                <XSLT:map-entry key="'indent'">{ $json-indent='yes' }</XSLT:map-entry>
+            </XSLT:map>
+        </XSLT:variable>
+
         <XSLT:variable name="xpath-json">
             <map>
                 <XSLT:apply-templates select="/" mode="xml2json"/>
@@ -584,7 +630,13 @@
             <XSLT:text>)</XSLT:text>
         </XSLT:template>
 
-<!-- See top level template match="/" for XSLT:template match="text()" mode="md" -->
+        <XSLT:template match="text()" mode="md">
+            <!-- Escapes go here       -->
+            <!--<XSLT:value-of select="replace(.,'\s+',' ') ! replace(.,'([`~\^\*])','\\$1')"/>-->
+            <XSLT:value-of select="replace(., '([`~\^\*''&quot;])', '\\$1')"/>
+        </XSLT:template>
+
+
     </xsl:template>
     
 </xsl:stylesheet>
\ No newline at end of file