Commits

Toby Inkster committed 5172b5b

make regexps more 5.8-friendly

Comments (0)

Files changed (35)

 };
 
 subtest "Type atomic/NMTOKEN is restricted by facet pattern with value \\c{40}." => sub {
-	my $type = mk_type('NmToken', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){40}$)/});
+	my $type = mk_type('NmToken', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){40}$)/});
 	should_pass("participants.file-interconnecting_will.v", $type, 0);
 	should_pass("computer.systems_their:wide.the:assuring", $type, 0);
 	should_pass("provides.facilitates:known-discussions:o", $type, 0);
 };
 
 subtest "Type atomic/NMTOKEN is restricted by facet pattern with value \\c{18}." => sub {
-	my $type = mk_type('NmToken', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){18}$)/});
+	my $type = mk_type('NmToken', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){18}$)/});
 	should_pass("in.typical_tools:m", $type, 0);
 	should_pass("and:Conformance:to", $type, 0);
 	should_pass("tests.clean:succes", $type, 0);
 };
 
 subtest "Type atomic/NMTOKEN is restricted by facet pattern with value \\c{6}." => sub {
-	my $type = mk_type('NmToken', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){6}$)/});
+	my $type = mk_type('NmToken', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){6}$)/});
 	should_pass("for_AP", $type, 0);
 	should_pass("XML.to", $type, 0);
 	should_pass("to-Too", $type, 0);
 };
 
 subtest "Type atomic/NMTOKEN is restricted by facet pattern with value \\c{33}." => sub {
-	my $type = mk_type('NmToken', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){33}$)/});
+	my $type = mk_type('NmToken', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){33}$)/});
 	should_pass("small-.and.for.these-for:Provide-", $type, 0);
 	should_pass("if_discovery.to_allow-vocabulary_", $type, 0);
 	should_pass("nature.participate.to-key.contrib", $type, 0);
 };
 
 subtest "Type atomic/NMTOKEN is restricted by facet pattern with value \\c{18}." => sub {
-	my $type = mk_type('NmToken', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){18}$)/});
+	my $type = mk_type('NmToken', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){18}$)/});
 	should_pass("include_internatio", $type, 0);
 	should_pass("repositories.use:c", $type, 0);
 	should_pass("annual-data.a:lies", $type, 0);
 };
 
 subtest "Type atomic/Name is restricted by facet pattern with value \\i\\c{45}." => sub {
-	my $type = mk_type('Name', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){45}$)/});
+	my $type = mk_type('Name', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){45}$)/});
 	should_pass("finteroperability-these_files-print:a_into_or:", $type, 0);
 	should_pass("icomputing_will:includes:capabilities:need:to:", $type, 0);
 	should_pass("yrecognition.will:security_automating_library_", $type, 0);
 };
 
 subtest "Type atomic/Name is restricted by facet pattern with value \\i\\c{52}." => sub {
-	my $type = mk_type('Name', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){52}$)/});
+	my $type = mk_type('Name', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){52}$)/});
 	should_pass("ldesktop_object.needs_some:in:collaborating.of-be:app", $type, 0);
 	should_pass("rsignatures:the_are:degree_over_is:tests_technologies", $type, 0);
 	should_pass("uthe:profile-documents-of-we:and_recent_the_own-using", $type, 0);
 };
 
 subtest "Type atomic/Name is restricted by facet pattern with value \\i\\c{32}." => sub {
-	my $type = mk_type('Name', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){32}$)/});
+	my $type = mk_type('Name', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){32}$)/});
 	should_pass(":a-a.and_s-for-used_means-high_we", $type, 0);
 	should_pass("_the.the-a:raised-to-review-to-hi", $type, 0);
 	should_pass("gleadership_interacting_test.avai", $type, 0);
 };
 
 subtest "Type atomic/Name is restricted by facet pattern with value \\i\\c{14}." => sub {
-	my $type = mk_type('Name', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){14}$)/});
+	my $type = mk_type('Name', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){14}$)/});
 	should_pass("fof-for-pervasi", $type, 0);
 	should_pass(":necessary_auto", $type, 0);
 	should_pass("tdata_also_seri", $type, 0);
 };
 
 subtest "Type atomic/Name is restricted by facet pattern with value \\i\\c{31}." => sub {
-	my $type = mk_type('Name', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){31}$)/});
+	my $type = mk_type('Name', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar)(?:$XML::RegExp::NameChar){31}$)/});
 	should_pass("lscreen-contribute:2001.reposito", $type, 0);
 	should_pass("mmore-s:software:and:each_a:to-f", $type, 0);
 	should_pass("dcan_graphical-for.the.daily.all", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,7}\\.){1,2}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,2}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,2}(?:$XML::RegExp::NameChar){3}$)/});
 	should_pass("gopher://Sty.reques.org", $type, 0);
 	should_pass("telnet://wirel.oldert.org", $type, 0);
 	should_pass("telnet://beth.edu", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,3}\\.){1,4}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,3}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,3}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
 	should_pass("telnet://mo.X.th.com", $type, 0);
 	should_pass("news://thu.o.pro.wid.com", $type, 0);
 	should_pass("ftp://b.Co.and.net", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,7}\\.){1,4}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
 	should_pass("ftp://XSLthat.incons.isdispl.softwa.org", $type, 0);
 	should_pass("ftp://too.edu", $type, 0);
 	should_pass("ftp://indust.Aso.dra.gov", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,6}\\.){1,2}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,6}\.){1,2}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,6}\.){1,2}(?:$XML::RegExp::NameChar){3}$)/});
 	should_pass("ftp://techn.using.gov", $type, 0);
 	should_pass("ftp://the.com", $type, 0);
 	should_pass("telnet://these.s.org", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,10}\\.){1,5}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,10}\.){1,5}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,10}\.){1,5}(?:$XML::RegExp::NameChar){3}$)/});
 	should_pass("telnet://and.the.thattesti.andspeci.im.gov", $type, 0);
 	should_pass("ftp://beingamon.I.net", $type, 0);
 	should_pass("gopher://whoservi.theXSL.fact.ma.net", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,2}\\.){1,5}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,2}\.){1,5}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,2}\.){1,5}(?:$XML::RegExp::NameChar){3}$)/});
 	should_fail("ftp://eachbewit.otherwilleXtens.follow.lawbeaande.XMLus.repositor.com", $type, 0);
 	should_fail("http://build.theamongimag.becom.OASIScompu.thedue.XMLbusinessis.organizations.gov", $type, 0);
 	should_fail("http://regist.stimu.waysmanyth.andprofil.exchang.knownagraphi.ECprovidedCom.otherSchemape.edu", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,3}\\.){1,4}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,3}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,3}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
 	should_fail("ftp://toregist.thesecanther.NISTme.thefor.amongthosesuch.andtonetw.org", $type, 0);
 	should_fail("gopher://aInternetthela.Virtuallyso.software.communi.widelyTo.usedtheover.andeachS.com", $type, 0);
 	should_fail("ftp://andbothreposit.regis.revolutioniz.oncreatedt.resourcesI.usingandmakeNI.org", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,5}\\.){1,4}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,5}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,5}\.){1,4}(?:$XML::RegExp::NameChar){3}$)/});
 	should_fail("news://olderperfo.totempla.forlanguageth.thesethecreate.towidetotheb.abilitySchema.useofyears.edu", $type, 0);
 	should_fail("telnet://filewithinD.thecomputera.byresidesitp.nointhemsi.arecreates.withtodocuments.accomplishsec.gov", $type, 0);
 	should_fail("ftp://Businessdepe.thebenefitswo.SOCgovernment.referencech.deployedTh.aroledistrib.andXMLarepub.com", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,10}\\.){1,3}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,10}\.){1,3}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,10}\.){1,3}(?:$XML::RegExp::NameChar){3}$)/});
 	should_fail("telnet://aboutdevelopm.referenceofreg.mustthebuildLan.ofamongAtois.andtheandmust.certainOASI.theInternetaan.thethetheseus.com", $type, 0);
 	should_fail("gopher://CPUtographics.ebXMLArchitec.furthertheofa.thecomplexadd.fourcorrection.ofrelatedvo.com", $type, 0);
 	should_fail("ftp://scomputingth.certaintheof.issueselectroni.thetechnologie.partnersofthis.gov", $type, 0);
 };
 
 subtest "Type atomic/anyURI is restricted by facet pattern with value \\c{3,6}://(\\c{1,7}\\.){1,3}\\c{3}." => sub {
-	my $type = mk_type('AnyURI', {'pattern' => qr/(?^ums:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,3}(?:$XML::RegExp::NameChar){3}$)/});
+	my $type = mk_type('AnyURI', {'pattern' => qr/(?ms:^(?:$XML::RegExp::NameChar){3,6}:\/\/((?:$XML::RegExp::NameChar){1,7}\.){1,3}(?:$XML::RegExp::NameChar){3}$)/});
 	should_fail("gopher://mustNISTproc.aselectronican.systemsstan.andwireles.Informationa.definecanfo.completi.wouldofanat.gov", $type, 0);
 	should_fail("telnet://aparadigmsta.XMLstake.dataaregr.repositori.signaturesNat.andprocessdocum.gov", $type, 0);
 	should_fail("news://understandthe.including.whichamong.partnerships.andsupplytest.contribut.forofhel.net", $type, 0);

t/50base64Binary.t

 };
 
 subtest "Type atomic/base64Binary is restricted by facet pattern with value [a-zA-Z0-9+/]{20}." => sub {
-	my $type = mk_type('Base64Binary', {'pattern' => qr/(?^ums:^[a-zA-Z0-9+\/]{20}$)/});
+	my $type = mk_type('Base64Binary', {'pattern' => qr/(?ms:^[a-zA-Z0-9+\/]{20}$)/});
 	should_pass("dGRoYWx5anVnZnRydGRl", $type, 0);
 	should_pass("dnBtZWFvZHNkcWNjbHBx", $type, 0);
 	should_pass("bWhqcWdjd2ZwdGtjbXJs", $type, 0);
 };
 
 subtest "Type atomic/base64Binary is restricted by facet pattern with value [a-zA-Z0-9+/]{68}." => sub {
-	my $type = mk_type('Base64Binary', {'pattern' => qr/(?^ums:^[a-zA-Z0-9+\/]{68}$)/});
+	my $type = mk_type('Base64Binary', {'pattern' => qr/(?ms:^[a-zA-Z0-9+\/]{68}$)/});
 	should_pass("ZWxxdXJyanJuanFodGZ3Z25sc3VrZGJ0cGp5dHFoaGJxYmVyZ2RpbXl0c3NueWJpdXVq", $type, 0);
 	should_pass("eGpycXh2dXFsa3lsbWtwcWt4d2hkcHVicXFlcWp2b2FtcGRucmNmbmFwcHFpcG9tdm9j", $type, 0);
 	should_pass("Y2V5c2dic3R0Z3V0eHdwb3JlY2hmbGlkZW9yb25xZGl1aXZsaG9mcGVrdnd4bXlid3Fv", $type, 0);
 };
 
 subtest "Type atomic/base64Binary is restricted by facet pattern with value [a-zA-Z0-9+/]{64}." => sub {
-	my $type = mk_type('Base64Binary', {'pattern' => qr/(?^ums:^[a-zA-Z0-9+\/]{64}$)/});
+	my $type = mk_type('Base64Binary', {'pattern' => qr/(?ms:^[a-zA-Z0-9+\/]{64}$)/});
 	should_pass("b21pbWV3Ym9ibm1pbnBmdGdyYnl1Ymxybm9kcGhqbXNydmthamFocGtwaW55b2t1", $type, 0);
 	should_pass("dGx4aHlyaWxkY29hc25md3hqZnBnc214Ymlwb2t1dGdvZnNjaWljY3N1Z2NuZnB4", $type, 0);
 	should_pass("aXRhcmxvbW9lZW1zaGR3ZnF1ZW5jdHdjdG9hZmxvdnV4dWtseHd3YmJybWl1aGJo", $type, 0);
 };
 
 subtest "Type atomic/base64Binary is restricted by facet pattern with value [a-zA-Z0-9+/]{24}." => sub {
-	my $type = mk_type('Base64Binary', {'pattern' => qr/(?^ums:^[a-zA-Z0-9+\/]{24}$)/});
+	my $type = mk_type('Base64Binary', {'pattern' => qr/(?ms:^[a-zA-Z0-9+\/]{24}$)/});
 	should_pass("bmxscXJ5bWRpeWJraWxybW1l", $type, 0);
 	should_pass("cmRnd3drb291cWhnaGFpdGZz", $type, 0);
 	should_pass("ZGJ4cHFzdnVxZXd5a2RvZnJz", $type, 0);
 };
 
 subtest "Type atomic/base64Binary is restricted by facet pattern with value [a-zA-Z0-9+/]{60}." => sub {
-	my $type = mk_type('Base64Binary', {'pattern' => qr/(?^ums:^[a-zA-Z0-9+\/]{60}$)/});
+	my $type = mk_type('Base64Binary', {'pattern' => qr/(?ms:^[a-zA-Z0-9+\/]{60}$)/});
 	should_pass("a2dicW9mY29ybWdjb2tycGRscWNxamp0ZWxxbWlzaXFrZm9oZ2twdWR5eHh5", $type, 0);
 	should_pass("c3V1d2ZqdHJ1eG1nZm1kdHN4bWtoYXdrdWNzbGhrdmhxc2R5Y2tpb25lbXZx", $type, 0);
 	should_pass("a2VzdXZub2hscG53aHZsdml4aGZxdGZ3aXl3cmRocXdkcmNuaWpxZGVpYmlx", $type, 0);
 sub mk_type { "Types::XSD"->get_type($_[0])->parameterize(%{$_[1]}) }
 
 subtest "Type atomic/boolean is restricted by facet pattern with value [1]{1}." => sub {
-	my $type = mk_type('Boolean', {'pattern' => qr/(?^ums:^[1]{1}$)/});
+	my $type = mk_type('Boolean', {'pattern' => qr/(?ms:^[1]{1}$)/});
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 };
 
 subtest "Type atomic/boolean is restricted by facet pattern with value false." => sub {
-	my $type = mk_type('Boolean', {'pattern' => qr/(?^ums:^false$)/});
+	my $type = mk_type('Boolean', {'pattern' => qr/(?ms:^false$)/});
 	should_pass("false", $type, 0);
 	should_pass("false", $type, 0);
 	should_pass("false", $type, 0);
 };
 
 subtest "Type atomic/boolean is restricted by facet pattern with value [1]{1}." => sub {
-	my $type = mk_type('Boolean', {'pattern' => qr/(?^ums:^[1]{1}$)/});
+	my $type = mk_type('Boolean', {'pattern' => qr/(?ms:^[1]{1}$)/});
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 };
 
 subtest "Type atomic/boolean is restricted by facet pattern with value false." => sub {
-	my $type = mk_type('Boolean', {'pattern' => qr/(?^ums:^false$)/});
+	my $type = mk_type('Boolean', {'pattern' => qr/(?ms:^false$)/});
 	should_pass("false", $type, 0);
 	should_pass("false", $type, 0);
 	should_pass("false", $type, 0);
 };
 
 subtest "Type atomic/boolean is restricted by facet pattern with value [1]{1}." => sub {
-	my $type = mk_type('Boolean', {'pattern' => qr/(?^ums:^[1]{1}$)/});
+	my $type = mk_type('Boolean', {'pattern' => qr/(?ms:^[1]{1}$)/});
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 	should_pass("1", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{3}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{3}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{3}$)/});
 	should_pass("-113", $type, 0);
 	should_pass("-114", $type, 0);
 	should_pass("-113", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{2}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{2}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{2}$)/});
 	should_pass("-84", $type, 0);
 	should_pass("-58", $type, 0);
 	should_pass("-64", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-4", $type, 0);
 	should_pass("-4", $type, 0);
 	should_pass("-1", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_pass("8", $type, 0);
 	should_pass("2", $type, 0);
 	should_pass("6", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\d{3}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\d{3}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\d{3}$)/});
 	should_pass("114", $type, 0);
 	should_pass("113", $type, 0);
 	should_pass("113", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{3}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{3}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{3}$)/});
 	should_fail("32", $type, 0);
 	should_fail("3", $type, 0);
 	should_fail("9", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{2}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{2}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{2}$)/});
 	should_fail("115", $type, 0);
 	should_fail("-112", $type, 0);
 	should_fail("-113", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("63", $type, 0);
 	should_fail("-86", $type, 0);
 	should_fail("111", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_fail("-115", $type, 0);
 	should_fail("72", $type, 0);
 	should_fail("-112", $type, 0);
 };
 
 subtest "Type atomic/byte is restricted by facet pattern with value \\d{3}." => sub {
-	my $type = mk_type('Byte', {'pattern' => qr/(?^ums:^\d{3}$)/});
+	my $type = mk_type('Byte', {'pattern' => qr/(?ms:^\d{3}$)/});
 	should_fail("24", $type, 0);
 	should_fail("1", $type, 0);
 	should_fail("-25", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d58-0\\d-\\d8." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d58-0\d-\d8$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d58-0\d-\d8$)/});
 	should_pass("1858-06-28", $type, 0);
 	should_pass("1858-05-08", $type, 0);
 	should_pass("1958-02-08", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d10-\\d4-1\\d." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d10-\d4-1\d$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d10-\d4-1\d$)/});
 	should_pass("1910-04-16", $type, 0);
 	should_pass("1710-04-16", $type, 0);
 	should_pass("1910-04-16", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d90-\\d7-2\\d." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d90-\d7-2\d$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d90-\d7-2\d$)/});
 	should_pass("1890-07-24", $type, 0);
 	should_pass("2090-07-21", $type, 0);
 	should_pass("1990-07-23", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value 17\\d\\d-\\d0-1\\d." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^17\d\d-\d0-1\d$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^17\d\d-\d0-1\d$)/});
 	should_pass("1748-10-16", $type, 0);
 	should_pass("1731-10-17", $type, 0);
 	should_pass("1734-10-17", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d44-\\d2-\\d5." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d44-\d2-\d5$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d44-\d2-\d5$)/});
 	should_pass("1844-02-15", $type, 0);
 	should_pass("1744-02-05", $type, 0);
 	should_pass("1944-02-05", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d54-0\\d-\\d8." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d54-0\d-\d8$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d54-0\d-\d8$)/});
 	should_fail("1842-11-10", $type, 0);
 	should_fail("1944-12-23", $type, 0);
 	should_fail("1940-11-25", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d79-0\\d-\\d5." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d79-0\d-\d5$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d79-0\d-\d5$)/});
 	should_fail("1817-10-11", $type, 0);
 	should_fail("1994-12-07", $type, 0);
 	should_fail("1712-10-24", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d35-0\\d-\\d7." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d35-0\d-\d7$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d35-0\d-\d7$)/});
 	should_fail("1910-10-18", $type, 0);
 	should_fail("1939-11-06", $type, 0);
 	should_fail("2011-11-22", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value 19\\d\\d-\\d0-2\\d." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^19\d\d-\d0-2\d$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^19\d\d-\d0-2\d$)/});
 	should_fail("1868-04-03", $type, 0);
 	should_fail("1775-08-02", $type, 0);
 	should_fail("1816-07-12", $type, 0);
 };
 
 subtest "Type atomic/date is restricted by facet pattern with value \\d\\d32-0\\d-\\d7." => sub {
-	my $type = mk_type('Date', {'pattern' => qr/(?^ums:^\d\d32-0\d-\d7$)/});
+	my $type = mk_type('Date', {'pattern' => qr/(?ms:^\d\d32-0\d-\d7$)/});
 	should_fail("2039-11-14", $type, 0);
 	should_fail("1914-11-02", $type, 0);
 	should_fail("1992-11-13", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value 19\\d\\d-0\\d-\\d8T\\d8:\\d5:5\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^19\d\d-0\d-\d8T\d8:\d5:5\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^19\d\d-0\d-\d8T\d8:\d5:5\d$)/});
 	should_pass("1900-06-08T18:25:54", $type, 0);
 	should_pass("1957-07-18T18:25:53", $type, 0);
 	should_pass("1952-01-18T18:55:54", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d55-0\\d-\\d8T\\d6:1\\d:0\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d55-0\d-\d8T\d6:1\d:0\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d55-0\d-\d8T\d6:1\d:0\d$)/});
 	should_pass("1955-03-28T16:11:07", $type, 0);
 	should_pass("1955-05-18T16:15:05", $type, 0);
 	should_pass("2055-08-18T16:13:07", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value 19\\d\\d-0\\d-0\\dT\\d5:1\\d:3\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^19\d\d-0\d-0\dT\d5:1\d:3\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^19\d\d-0\d-0\dT\d5:1\d:3\d$)/});
 	should_pass("1958-07-04T15:13:32", $type, 0);
 	should_pass("1961-08-08T15:12:38", $type, 0);
 	should_pass("1953-08-03T05:18:33", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d89-\\d2-\\d0T1\\d:2\\d:1\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d89-\d2-\d0T1\d:2\d:1\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d89-\d2-\d0T1\d:2\d:1\d$)/});
 	should_pass("1889-02-10T12:26:15", $type, 0);
 	should_pass("1889-02-10T18:26:16", $type, 0);
 	should_pass("1989-02-10T17:24:12", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d77-0\\d-0\\dT1\\d:\\d5:\\d5." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d77-0\d-0\dT1\d:\d5:\d5$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d77-0\d-0\dT1\d:\d5:\d5$)/});
 	should_pass("2077-02-04T11:05:35", $type, 0);
 	should_pass("2077-02-04T14:15:25", $type, 0);
 	should_pass("1777-03-02T13:15:15", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d69-\\d9-\\d9T\\d8:\\d1:3\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d69-\d9-\d9T\d8:\d1:3\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d69-\d9-\d9T\d8:\d1:3\d$)/});
 	should_fail("1804-03-13T14:44:07", $type, 0);
 	should_fail("1857-04-20T12:48:24", $type, 0);
 	should_fail("1844-06-17T11:28:01", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d94-\\d9-\\d7T1\\d:0\\d:0\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d94-\d9-\d7T1\d:0\d:0\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d94-\d9-\d7T1\d:0\d:0\d$)/});
 	should_fail("1900-01-15T27:42:43", $type, 0);
 	should_fail("1860-07-20T47:29:29", $type, 0);
 	should_fail("1945-05-01T23:30:29", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value 20\\d\\d-\\d8-\\d5T\\d1:\\d1:0\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^20\d\d-\d8-\d5T\d1:\d1:0\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^20\d\d-\d8-\d5T\d1:\d1:0\d$)/});
 	should_fail("1870-07-17T16:19:31", $type, 0);
 	should_fail("1853-05-24T07:12:41", $type, 0);
 	should_fail("1886-04-20T06:27:46", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d58-\\d2-2\\dT0\\d:1\\d:3\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d58-\d2-2\dT0\d:1\d:3\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d58-\d2-2\dT0\d:1\d:3\d$)/});
 	should_fail("2088-09-01T58:01:14", $type, 0);
 	should_fail("1822-04-03T48:25:22", $type, 0);
 	should_fail("2045-05-17T25:35:03", $type, 0);
 };
 
 subtest "Type atomic/dateTime is restricted by facet pattern with value \\d\\d59-\\d3-\\d4T1\\d:\\d9:3\\d." => sub {
-	my $type = mk_type('DateTime', {'pattern' => qr/(?^ums:^\d\d59-\d3-\d4T1\d:\d9:3\d$)/});
+	my $type = mk_type('DateTime', {'pattern' => qr/(?ms:^\d\d59-\d3-\d4T1\d:\d9:3\d$)/});
 	should_fail("1915-09-15T04:17:25", $type, 0);
 	should_fail("2080-04-01T02:55:00", $type, 0);
 	should_fail("1773-02-07T22:02:16", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_pass("3", $type, 0);
 	should_pass("2", $type, 0);
 	should_pass("2", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\-\\d{2}\\.\\d{3}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\-\d{2}\.\d{3}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\-\d{2}\.\d{3}$)/});
 	should_pass("-24.547", $type, 0);
 	should_pass("-65.424", $type, 0);
 	should_pass("-31.228", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\-\\d{1}\\.\\d{8}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\-\d{1}\.\d{8}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\-\d{1}\.\d{8}$)/});
 	should_pass("-7.48951421", $type, 0);
 	should_pass("-4.34531931", $type, 0);
 	should_pass("-7.37470534", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\.\\d{13}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\.\d{13}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\.\d{13}$)/});
 	should_pass(".2684842045582", $type, 0);
 	should_pass(".1165417431543", $type, 0);
 	should_pass(".1055532252427", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\d{5}\\.\\d{13}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\d{5}\.\d{13}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\d{5}\.\d{13}$)/});
 	should_pass("55217.9736118850526", $type, 0);
 	should_pass("16876.8783301171042", $type, 0);
 	should_pass("11416.7935261225030", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_fail("33485.142484370", $type, 0);
 	should_fail("22277333688275456.1", $type, 0);
 	should_fail("533.47561744", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\d{1}\\.\\d{4}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\d{1}\.\d{4}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\d{1}\.\d{4}$)/});
 	should_fail("-8554.601982", $type, 0);
 	should_fail("944224585854343587", $type, 0);
 	should_fail("421252945.60641372", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\-\\d{5}\\.\\d{4}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\-\d{5}\.\d{4}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\-\d{5}\.\d{4}$)/});
 	should_fail("2978258.516875716", $type, 0);
 	should_fail("-3333144481863.7", $type, 0);
 	should_fail("5976326.11677485", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\d{10}\\.\\d{3}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\d{10}\.\d{3}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\d{10}\.\d{3}$)/});
 	should_fail("-84225859357429657.5", $type, 0);
 	should_fail("844382745.346644", $type, 0);
 	should_fail("-85.56736916122194", $type, 0);
 };
 
 subtest "Type atomic/decimal is restricted by facet pattern with value \\-\\d{17}\\.\\d{1}." => sub {
-	my $type = mk_type('Decimal', {'pattern' => qr/(?^ums:^\-\d{17}\.\d{1}$)/});
+	my $type = mk_type('Decimal', {'pattern' => qr/(?ms:^\-\d{17}\.\d{1}$)/});
 	should_fail("222935976.00581813", $type, 0);
 	should_fail("4763.344745968", $type, 0);
 	should_fail("-41338645.5464910", $type, 0);
 sub mk_type { "Types::XSD"->get_type($_[0])->parameterize(%{$_[1]}) }
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}E\\-\\d{3}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}E\-\d{3}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}E\-\d{3}$)/});
 	should_pass("4E-289", $type, 0);
 	should_pass("3E-238", $type, 0);
 	should_pass("2E-173", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{4}E\\-\\d{2}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{4}E\-\d{2}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{4}E\-\d{2}$)/});
 	should_pass("5.2185E-22", $type, 0);
 	should_pass("4.3272E-51", $type, 0);
 	should_pass("3.1138E-51", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{8}E\\-\\d{1}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{8}E\-\d{1}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{8}E\-\d{1}$)/});
 	should_pass("4.54918975E-8", $type, 0);
 	should_pass("9.82585255E-8", $type, 0);
 	should_pass("7.42727726E-4", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{12}E\\d{1}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{12}E\d{1}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{12}E\d{1}$)/});
 	should_pass("4.319926813832E4", $type, 0);
 	should_pass("4.462166867158E3", $type, 0);
 	should_pass("4.642845497493E5", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{16}E\\d{3}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{16}E\d{3}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{16}E\d{3}$)/});
 	should_pass("8.9765779385971216E261", $type, 0);
 	should_pass("6.8222841673422587E283", $type, 0);
 	should_pass("4.9578685246487246E116", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}E\\-\\d{3}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}E\-\d{3}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}E\-\d{3}$)/});
 	should_fail("3E6", $type, 0);
 	should_fail("1E-12", $type, 0);
 	should_fail("5E-47", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{4}E\\-\\d{2}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{4}E\-\d{2}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{4}E\-\d{2}$)/});
 	should_fail("5.532777422E-262", $type, 0);
 	should_fail("4.84496778864735E7", $type, 0);
 	should_fail("3.3664231457E-8", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{8}E\\-\\d{1}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{8}E\-\d{1}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{8}E\-\d{1}$)/});
 	should_fail("2.938778577292527E-112", $type, 0);
 	should_fail("8.687E-228", $type, 0);
 	should_fail("7.2552325433887758E57", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{12}E\\d{1}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{12}E\d{1}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{12}E\d{1}$)/});
 	should_fail("7.377E277", $type, 0);
 	should_fail("7.44122758643E172", $type, 0);
 	should_fail("5.37737654663E193", $type, 0);
 };
 
 subtest "Type atomic/double is restricted by facet pattern with value \\d{1}\\.\\d{16}E\\d{3}." => sub {
-	my $type = mk_type('Double', {'pattern' => qr/(?^ums:^\d{1}\.\d{16}E\d{3}$)/});
+	my $type = mk_type('Double', {'pattern' => qr/(?ms:^\d{1}\.\d{16}E\d{3}$)/});
 	should_fail("8.9396649815531E32", $type, 0);
 	should_fail("7.2936652792E4", $type, 0);
 	should_fail("3.5827872E2", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d76Y\\d4M2\\dDT1\\dH\\d9M\\d9S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d76Y\d4M2\dDT1\dH\d9M\d9S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d76Y\d4M2\dDT1\dH\d9M\d9S$)/});
 	should_pass("P1876Y04M23DT16H39M39S", $type, 0);
 	should_pass("P1876Y04M22DT17H19M19S", $type, 0);
 	should_pass("P1876Y04M24DT12H49M19S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d74Y0\\dM\\d6DT1\\dH\\d0M\\d7S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d74Y0\dM\d6DT1\dH\d0M\d7S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d74Y0\dM\d6DT1\dH\d0M\d7S$)/});
 	should_pass("P1974Y05M26DT18H00M27S", $type, 0);
 	should_pass("P2074Y09M06DT18H20M17S", $type, 0);
 	should_pass("P1974Y03M26DT14H10M17S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P20\\d\\dY\\d3M\\d1DT\\d4H\\d7M\\d6S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P20\d\dY\d3M\d1DT\d4H\d7M\d6S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P20\d\dY\d3M\d1DT\d4H\d7M\d6S$)/});
 	should_pass("P2043Y03M11DT04H17M16S", $type, 0);
 	should_pass("P2017Y03M21DT04H37M36S", $type, 0);
 	should_pass("P2034Y03M01DT14H57M06S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P19\\d\\dY\\d8M\\d3DT\\d0H1\\dM\\d2S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P19\d\dY\d8M\d3DT\d0H1\dM\d2S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P19\d\dY\d8M\d3DT\d0H1\dM\d2S$)/});
 	should_pass("P1941Y08M13DT00H15M02S", $type, 0);
 	should_pass("P1912Y08M23DT10H14M32S", $type, 0);
 	should_pass("P1944Y08M13DT00H14M32S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d63Y\\d4M1\\dDT0\\dH\\d4M4\\dS." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d63Y\d4M1\dDT0\dH\d4M4\dS$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d63Y\d4M1\dDT0\dH\d4M4\dS$)/});
 	should_pass("P1863Y04M14DT04H14M46S", $type, 0);
 	should_pass("P1863Y04M15DT06H44M47S", $type, 0);
 	should_pass("P2063Y04M17DT07H34M43S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d69Y\\d2M1\\dDT\\d0H\\d9M5\\dS." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d69Y\d2M1\dDT\d0H\d9M5\dS$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d69Y\d2M1\dDT\d0H\d9M5\dS$)/});
 	should_fail("P1986Y06M24DT05H04M09S", $type, 0);
 	should_fail("P1808Y03M05DT19H21M14S", $type, 0);
 	should_fail("P2038Y06M26DT05H46M26S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P19\\d\\dY0\\dM2\\dDT\\d1H\\d9M\\d9S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P19\d\dY0\dM2\dDT\d1H\d9M\d9S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P19\d\dY0\dM2\dDT\d1H\d9M\d9S$)/});
 	should_fail("P1813Y12M05DT03H21M34S", $type, 0);
 	should_fail("P2007Y12M12DT06H56M25S", $type, 0);
 	should_fail("P2092Y11M14DT19H47M40S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d24Y0\\dM1\\dDT1\\dH\\d0M5\\dS." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d24Y0\dM1\dDT1\dH\d0M5\dS$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d24Y0\dM1\dDT1\dH\d0M5\dS$)/});
 	should_fail("P2080Y11M20DT28H23M07S", $type, 0);
 	should_fail("P1963Y10M27DT05H33M27S", $type, 0);
 	should_fail("P1860Y11M01DT29H07M09S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P\\d\\d80Y\\d8M1\\dDT1\\dH3\\dM2\\dS." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P\d\d80Y\d8M1\dDT1\dH3\dM2\dS$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P\d\d80Y\d8M1\dDT1\dH3\dM2\dS$)/});
 	should_fail("P2035Y04M26DT42H16M44S", $type, 0);
 	should_fail("P1953Y03M25DT56H22M31S", $type, 0);
 	should_fail("P1882Y02M01DT43H46M14S", $type, 0);
 };
 
 subtest "Type atomic/duration is restricted by facet pattern with value P17\\d\\dY\\d7M\\d3DT0\\dH0\\dM\\d5S." => sub {
-	my $type = mk_type('Duration', {'pattern' => qr/(?^ums:^P17\d\dY\d7M\d3DT0\dH0\dM\d5S$)/});
+	my $type = mk_type('Duration', {'pattern' => qr/(?ms:^P17\d\dY\d7M\d3DT0\dH0\dM\d5S$)/});
 	should_fail("P1865Y03M10DT42H54M38S", $type, 0);
 	should_fail("P2018Y05M22DT17H44M47S", $type, 0);
 	should_fail("P1905Y01M08DT26H15M16S", $type, 0);
 sub mk_type { "Types::XSD"->get_type($_[0])->parameterize(%{$_[1]}) }
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}E\\-\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}E\-\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}E\-\d{2}$)/});
 	should_pass("5E-16", $type, 0);
 	should_pass("3E-18", $type, 0);
 	should_pass("4E-26", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{2}E\\-\\d{1}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{2}E\-\d{1}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{2}E\-\d{1}$)/});
 	should_pass("42E-2", $type, 0);
 	should_pass("48E-5", $type, 0);
 	should_pass("64E-2", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{2}E\\d{1}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{2}E\d{1}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{2}E\d{1}$)/});
 	should_pass("6.77E7", $type, 0);
 	should_pass("3.84E8", $type, 0);
 	should_pass("9.84E6", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{3}E\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{3}E\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{3}E\d{2}$)/});
 	should_pass("9.966E21", $type, 0);
 	should_pass("1.537E23", $type, 0);
 	should_pass("6.815E27", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{7}E\\-\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{7}E\-\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{7}E\-\d{2}$)/});
 	should_pass("2.7821581E-24", $type, 0);
 	should_pass("4.2646267E-21", $type, 0);
 	should_pass("7.3748222E-24", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}E\\-\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}E\-\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}E\-\d{2}$)/});
 	should_fail("5E3", $type, 0);
 	should_fail("1E-5", $type, 0);
 	should_fail("7E-9", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{2}E\\-\\d{1}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{2}E\-\d{1}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{2}E\-\d{1}$)/});
 	should_fail("9113754E-14", $type, 0);
 	should_fail("624922E-25", $type, 0);
 	should_fail("7576E19", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{2}E\\d{1}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{2}E\d{1}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{2}E\d{1}$)/});
 	should_fail("4.92245E25", $type, 0);
 	should_fail("7.3539E27", $type, 0);
 	should_fail("8.749E25", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{3}E\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{3}E\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{3}E\d{2}$)/});
 	should_fail("7.347924E4", $type, 0);
 	should_fail("3.7562E7", $type, 0);
 	should_fail("4.2438E5", $type, 0);
 };
 
 subtest "Type atomic/float is restricted by facet pattern with value \\d{1}\\.\\d{7}E\\-\\d{2}." => sub {
-	my $type = mk_type('Float', {'pattern' => qr/(?^ums:^\d{1}\.\d{7}E\-\d{2}$)/});
+	my $type = mk_type('Float', {'pattern' => qr/(?ms:^\d{1}\.\d{7}E\-\d{2}$)/});
 	should_fail("8.77683E-8", $type, 0);
 	should_fail("4.48E-3", $type, 0);
 	should_fail("2.36895E-6", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---\\d5." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---\d5$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---\d5$)/});
 	should_pass("---15", $type, 0);
 	should_pass("---15", $type, 0);
 	should_pass("---25", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---\\d5." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---\d5$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---\d5$)/});
 	should_pass("---15", $type, 0);
 	should_pass("---25", $type, 0);
 	should_pass("---15", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---0\\d." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---0\d$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---0\d$)/});
 	should_pass("---02", $type, 0);
 	should_pass("---03", $type, 0);
 	should_pass("---04", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---\\d2." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---\d2$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---\d2$)/});
 	should_pass("---02", $type, 0);
 	should_pass("---22", $type, 0);
 	should_pass("---22", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---1\\d." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---1\d$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---1\d$)/});
 	should_pass("---14", $type, 0);
 	should_pass("---13", $type, 0);
 	should_pass("---14", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---2\\d." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---2\d$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---2\d$)/});
 	should_fail("---14", $type, 0);
 	should_fail("---10", $type, 0);
 	should_fail("---18", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---\\d3." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---\d3$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---\d3$)/});
 	should_fail("---06", $type, 0);
 	should_fail("---05", $type, 0);
 	should_fail("---14", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---\\d4." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---\d4$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---\d4$)/});
 	should_fail("---28", $type, 0);
 	should_fail("---13", $type, 0);
 	should_fail("---03", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---0\\d." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---0\d$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---0\d$)/});
 	should_fail("---22", $type, 0);
 	should_fail("---10", $type, 0);
 	should_fail("---16", $type, 0);
 };
 
 subtest "Type atomic/gDay is restricted by facet pattern with value ---1\\d." => sub {
-	my $type = mk_type('GDay', {'pattern' => qr/(?^ums:^---1\d$)/});
+	my $type = mk_type('GDay', {'pattern' => qr/(?ms:^---1\d$)/});
 	should_fail("---22", $type, 0);
 	should_fail("---02", $type, 0);
 	should_fail("---24", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --1\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--1\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--1\d$)/});
 	should_pass("--11", $type, 0);
 	should_pass("--11", $type, 0);
 	should_pass("--11", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --\\d2." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--\d2$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--\d2$)/});
 	should_pass("--02", $type, 0);
 	should_pass("--02", $type, 0);
 	should_pass("--02", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --\\d9." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--\d9$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--\d9$)/});
 	should_pass("--09", $type, 0);
 	should_pass("--09", $type, 0);
 	should_pass("--09", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --\\d6." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--\d6$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--\d6$)/});
 	should_pass("--06", $type, 0);
 	should_pass("--06", $type, 0);
 	should_pass("--06", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --0\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--0\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--0\d$)/});
 	should_pass("--05", $type, 0);
 	should_pass("--01", $type, 0);
 	should_pass("--07", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --0\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--0\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--0\d$)/});
 	should_fail("--10", $type, 0);
 	should_fail("--12", $type, 0);
 	should_fail("--10", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --\\d1." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--\d1$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--\d1$)/});
 	should_fail("--06", $type, 0);
 	should_fail("--08", $type, 0);
 	should_fail("--05", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --0\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--0\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--0\d$)/});
 	should_fail("--11", $type, 0);
 	should_fail("--11", $type, 0);
 	should_fail("--11", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --0\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--0\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--0\d$)/});
 	should_fail("--10", $type, 0);
 	should_fail("--10", $type, 0);
 	should_fail("--10", $type, 0);
 };
 
 subtest "Type atomic/gMonth is restricted by facet pattern with value --1\\d." => sub {
-	my $type = mk_type('GMonth', {'pattern' => qr/(?^ums:^--1\d$)/});
+	my $type = mk_type('GMonth', {'pattern' => qr/(?ms:^--1\d$)/});
 	should_fail("--03", $type, 0);
 	should_fail("--08", $type, 0);
 	should_fail("--08", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d2-1\\d." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d2-1\d$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d2-1\d$)/});
 	should_pass("--02-13", $type, 0);
 	should_pass("--02-13", $type, 0);
 	should_pass("--02-17", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d1-2\\d." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d1-2\d$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d1-2\d$)/});
 	should_pass("--01-25", $type, 0);
 	should_pass("--01-22", $type, 0);
 	should_pass("--01-24", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --0\\d-\\d8." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--0\d-\d8$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--0\d-\d8$)/});
 	should_pass("--07-08", $type, 0);
 	should_pass("--08-18", $type, 0);
 	should_pass("--09-28", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d3-0\\d." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d3-0\d$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d3-0\d$)/});
 	should_pass("--03-01", $type, 0);
 	should_pass("--03-04", $type, 0);
 	should_pass("--03-03", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --0\\d-1\\d." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--0\d-1\d$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--0\d-1\d$)/});
 	should_pass("--05-11", $type, 0);
 	should_pass("--05-15", $type, 0);
 	should_pass("--07-17", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d1-1\\d." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d1-1\d$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d1-1\d$)/});
 	should_fail("--04-04", $type, 0);
 	should_fail("--06-07", $type, 0);
 	should_fail("--08-03", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d6-\\d8." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d6-\d8$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d6-\d8$)/});
 	should_fail("--08-21", $type, 0);
 	should_fail("--03-06", $type, 0);
 	should_fail("--07-12", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --0\\d-\\d0." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--0\d-\d0$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--0\d-\d0$)/});
 	should_fail("--10-17", $type, 0);
 	should_fail("--12-24", $type, 0);
 	should_fail("--11-14", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --0\\d-\\d6." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--0\d-\d6$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--0\d-\d6$)/});
 	should_fail("--10-14", $type, 0);
 	should_fail("--10-18", $type, 0);
 	should_fail("--11-11", $type, 0);
 };
 
 subtest "Type atomic/gMonthDay is restricted by facet pattern with value --\\d5-\\d9." => sub {
-	my $type = mk_type('GMonthDay', {'pattern' => qr/(?^ums:^--\d5-\d9$)/});
+	my $type = mk_type('GMonthDay', {'pattern' => qr/(?ms:^--\d5-\d9$)/});
 	should_fail("--03-17", $type, 0);
 	should_fail("--08-16", $type, 0);
 	should_fail("--07-17", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d47." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d47$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d47$)/});
 	should_pass("2047", $type, 0);
 	should_pass("1847", $type, 0);
 	should_pass("2047", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d61." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d61$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d61$)/});
 	should_pass("1961", $type, 0);
 	should_pass("1861", $type, 0);
 	should_pass("1761", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d86." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d86$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d86$)/});
 	should_pass("2086", $type, 0);
 	should_pass("2086", $type, 0);
 	should_pass("1886", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d14." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d14$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d14$)/});
 	should_pass("1814", $type, 0);
 	should_pass("1814", $type, 0);
 	should_pass("1914", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d21." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d21$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d21$)/});
 	should_pass("1921", $type, 0);
 	should_pass("1821", $type, 0);
 	should_pass("1921", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d06." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d06$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d06$)/});
 	should_fail("1835", $type, 0);
 	should_fail("1871", $type, 0);
 	should_fail("1999", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value 19\\d\\d." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^19\d\d$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^19\d\d$)/});
 	should_fail("1802", $type, 0);
 	should_fail("2010", $type, 0);
 	should_fail("1825", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value 17\\d\\d." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^17\d\d$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^17\d\d$)/});
 	should_fail("1959", $type, 0);
 	should_fail("1934", $type, 0);
 	should_fail("1983", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d66." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d66$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d66$)/});
 	should_fail("2026", $type, 0);
 	should_fail("1928", $type, 0);
 	should_fail("1873", $type, 0);
 };
 
 subtest "Type atomic/gYear is restricted by facet pattern with value \\d\\d77." => sub {
-	my $type = mk_type('GYear', {'pattern' => qr/(?^ums:^\d\d77$)/});
+	my $type = mk_type('GYear', {'pattern' => qr/(?ms:^\d\d77$)/});
 	should_fail("1802", $type, 0);
 	should_fail("1864", $type, 0);
 	should_fail("1851", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value 17\\d\\d-\\d1." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^17\d\d-\d1$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^17\d\d-\d1$)/});
 	should_pass("1747-01", $type, 0);
 	should_pass("1726-01", $type, 0);
 	should_pass("1790-01", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value \\d\\d31-\\d3." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^\d\d31-\d3$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^\d\d31-\d3$)/});
 	should_pass("1831-03", $type, 0);
 	should_pass("1831-03", $type, 0);
 	should_pass("2031-03", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value \\d\\d76-0\\d." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^\d\d76-0\d$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^\d\d76-0\d$)/});
 	should_pass("1876-08", $type, 0);
 	should_pass("1876-09", $type, 0);
 	should_pass("1876-05", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value 17\\d\\d-0\\d." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^17\d\d-0\d$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^17\d\d-0\d$)/});
 	should_pass("1718-04", $type, 0);
 	should_pass("1709-06", $type, 0);
 	should_pass("1710-08", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value 18\\d\\d-\\d2." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^18\d\d-\d2$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^18\d\d-\d2$)/});
 	should_pass("1866-02", $type, 0);
 	should_pass("1864-02", $type, 0);
 	should_pass("1877-02", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value \\d\\d10-0\\d." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^\d\d10-0\d$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^\d\d10-0\d$)/});
 	should_fail("1959-12", $type, 0);
 	should_fail("1856-11", $type, 0);
 	should_fail("2028-11", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value 19\\d\\d-0\\d." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^19\d\d-0\d$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^19\d\d-0\d$)/});
 	should_fail("1854-11", $type, 0);
 	should_fail("1853-10", $type, 0);
 	should_fail("1829-10", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value 19\\d\\d-\\d6." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^19\d\d-\d6$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^19\d\d-\d6$)/});
 	should_fail("1806-04", $type, 0);
 	should_fail("1831-05", $type, 0);
 	should_fail("1888-04", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value \\d\\d54-0\\d." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^\d\d54-0\d$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^\d\d54-0\d$)/});
 	should_fail("1994-10", $type, 0);
 	should_fail("1791-12", $type, 0);
 	should_fail("2056-10", $type, 0);
 };
 
 subtest "Type atomic/gYearMonth is restricted by facet pattern with value \\d\\d41-\\d2." => sub {
-	my $type = mk_type('GYearMonth', {'pattern' => qr/(?^ums:^\d\d41-\d2$)/});
+	my $type = mk_type('GYearMonth', {'pattern' => qr/(?ms:^\d\d41-\d2$)/});
 	should_fail("1862-03", $type, 0);
 	should_fail("1869-07", $type, 0);
 	should_fail("1847-04", $type, 0);
 };
 
 subtest "Type atomic/hexBinary is restricted by facet pattern with value [0-9A-F]{56}." => sub {
-	my $type = mk_type('HexBinary', {'pattern' => qr/(?^ums:^[0-9A-F]{56}$)/});
+	my $type = mk_type('HexBinary', {'pattern' => qr/(?ms:^[0-9A-F]{56}$)/});
 	should_pass("756765786D706E686D61746C736A66696F6870727272707864666579", $type, 0);
 	should_pass("6164696771616D657769787078716767647573626D65686570687579", $type, 0);
 	should_pass("6C6C716F636879677467686871776571686161616E6D78636B686563", $type, 0);
 };
 
 subtest "Type atomic/hexBinary is restricted by facet pattern with value [0-9A-F]{66}." => sub {
-	my $type = mk_type('HexBinary', {'pattern' => qr/(?^ums:^[0-9A-F]{66}$)/});
+	my $type = mk_type('HexBinary', {'pattern' => qr/(?ms:^[0-9A-F]{66}$)/});
 	should_pass("6564757662646E6B76686F77747473656B7876726F7062616A6B70677272736867", $type, 0);
 	should_pass("6E6776726D7468796B766A766B6872796C6A7063666C68616F616B6272766D6B6A", $type, 0);
 	should_pass("686463686A7665776B746F756A616673626E6C69796278747176677861756A6378", $type, 0);
 };
 
 subtest "Type atomic/hexBinary is restricted by facet pattern with value [0-9A-F]{18}." => sub {
-	my $type = mk_type('HexBinary', {'pattern' => qr/(?^ums:^[0-9A-F]{18}$)/});
+	my $type = mk_type('HexBinary', {'pattern' => qr/(?ms:^[0-9A-F]{18}$)/});
 	should_pass("686163626B6E726F61", $type, 0);
 	should_pass("66666F7062616A7269", $type, 0);
 	should_pass("6C706B737361767170", $type, 0);
 };
 
 subtest "Type atomic/hexBinary is restricted by facet pattern with value [0-9A-F]{46}." => sub {
-	my $type = mk_type('HexBinary', {'pattern' => qr/(?^ums:^[0-9A-F]{46}$)/});
+	my $type = mk_type('HexBinary', {'pattern' => qr/(?ms:^[0-9A-F]{46}$)/});
 	should_pass("616B6374737472717274636768616E66746C77726F6771", $type, 0);
 	should_pass("71686674766B73656B6E6772617378686D77746E696D66", $type, 0);
 	should_pass("626467696F686C71616B6D7872766B666E796D6D6D6779", $type, 0);
 };
 
 subtest "Type atomic/hexBinary is restricted by facet pattern with value [0-9A-F]{60}." => sub {
-	my $type = mk_type('HexBinary', {'pattern' => qr/(?^ums:^[0-9A-F]{60}$)/});
+	my $type = mk_type('HexBinary', {'pattern' => qr/(?ms:^[0-9A-F]{60}$)/});
 	should_pass("746A71716F6E6F796E7463657773706177746A746173616274706671616A", $type, 0);
 	should_pass("6A6F6F67676273756B726A696D6F6E61726E796969767061756262726279", $type, 0);
 	should_pass("69706467776169706D7871727879636E6D69626271797962776B67686D61", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{10}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{10}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{10}$)/});
 	should_pass("-2021151233", $type, 0);
 	should_pass("-2123141222", $type, 0);
 	should_pass("-2122362122", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_pass("-63629", $type, 0);
 	should_pass("-25648", $type, 0);
 	should_pass("-62278", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-5", $type, 0);
 	should_pass("-6", $type, 0);
 	should_pass("-9", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\d{3}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\d{3}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\d{3}$)/});
 	should_pass("526", $type, 0);
 	should_pass("637", $type, 0);
 	should_pass("864", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\d{10}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\d{10}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\d{10}$)/});
 	should_pass("2124321125", $type, 0);
 	should_pass("2011272332", $type, 0);
 	should_pass("2026262112", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{10}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{10}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{10}$)/});
 	should_fail("37", $type, 0);
 	should_fail("-96215428", $type, 0);
 	should_fail("-252765767", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_fail("2928288", $type, 0);
 	should_fail("-55", $type, 0);
 	should_fail("-656423387", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("4713", $type, 0);
 	should_fail("-6741", $type, 0);
 	should_fail("41", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\d{3}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\d{3}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\d{3}$)/});
 	should_fail("-38", $type, 0);
 	should_fail("7543", $type, 0);
 	should_fail("-2025222435", $type, 0);
 };
 
 subtest "Type atomic/int is restricted by facet pattern with value \\d{10}." => sub {
-	my $type = mk_type('Int', {'pattern' => qr/(?^ums:^\d{10}$)/});
+	my $type = mk_type('Int', {'pattern' => qr/(?ms:^\d{10}$)/});
 	should_fail("-5566282", $type, 0);
 	should_fail("-158417927", $type, 0);
 	should_fail("34672729", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_pass("-916336264155436366", $type, 0);
 	should_pass("-952682614477467412", $type, 0);
 	should_pass("-947637432751355373", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_pass("-823666421", $type, 0);
 	should_pass("-442642367", $type, 0);
 	should_pass("-321934657", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-2", $type, 0);
 	should_pass("-7", $type, 0);
 	should_pass("-9", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_pass("82365", $type, 0);
 	should_pass("79898", $type, 0);
 	should_pass("33364", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_pass("953387635577466672", $type, 0);
 	should_pass("956462344852823454", $type, 0);
 	should_pass("947511736164636562", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_fail("-2875718525374455", $type, 0);
 	should_fail("4428734471785813", $type, 0);
 	should_fail("55632973", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_fail("-39682798272352427", $type, 0);
 	should_fail("522688578965", $type, 0);
 	should_fail("278352863422374", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("-615", $type, 0);
 	should_fail("252", $type, 0);
 	should_fail("-845526", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_fail("3", $type, 0);
 	should_fail("4", $type, 0);
 	should_fail("-564172", $type, 0);
 };
 
 subtest "Type atomic/integer is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('Integer', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('Integer', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_fail("3765", $type, 0);
 	should_fail("-3163464278", $type, 0);
 	should_fail("-36284471451", $type, 0);
 };
 
 subtest "Type atomic/language is restricted by facet pattern with value ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*." => sub {
-	my $type = mk_type('Language', {'pattern' => qr/(?^ums:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
+	my $type = mk_type('Language', {'pattern' => qr/(?ms:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
 	should_pass("TE-USA", $type, 0);
 	should_pass("TG-USA", $type, 0);
 	should_pass("TH-USA", $type, 0);
 };
 
 subtest "Type atomic/language is restricted by facet pattern with value ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*." => sub {
-	my $type = mk_type('Language', {'pattern' => qr/(?^ums:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
+	my $type = mk_type('Language', {'pattern' => qr/(?ms:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
 	should_pass("TL-USA", $type, 0);
 	should_pass("TN-USA", $type, 0);
 	should_pass("TO-USA", $type, 0);
 };
 
 subtest "Type atomic/language is restricted by facet pattern with value ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*." => sub {
-	my $type = mk_type('Language', {'pattern' => qr/(?^ums:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
+	my $type = mk_type('Language', {'pattern' => qr/(?ms:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
 	should_pass("AS-USA", $type, 0);
 	should_pass("AY-USA", $type, 0);
 	should_pass("AZ-USA", $type, 0);
 };
 
 subtest "Type atomic/language is restricted by facet pattern with value ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*." => sub {
-	my $type = mk_type('Language', {'pattern' => qr/(?^ums:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
+	my $type = mk_type('Language', {'pattern' => qr/(?ms:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
 	should_pass("SL-USA", $type, 0);
 	should_pass("SM-USA", $type, 0);
 	should_pass("SN-USA", $type, 0);
 };
 
 subtest "Type atomic/language is restricted by facet pattern with value ([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*." => sub {
-	my $type = mk_type('Language', {'pattern' => qr/(?^ums:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
+	my $type = mk_type('Language', {'pattern' => qr/(?ms:^([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{3})*$)/});
 	should_pass("WO-USA", $type, 0);
 	should_pass("XH-USA", $type, 0);
 	should_pass("YO-USA", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_pass("-986558763664653645", $type, 0);
 	should_pass("-913428556433725453", $type, 0);
 	should_pass("-973221252533651368", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_pass("-787574922", $type, 0);
 	should_pass("-726788351", $type, 0);
 	should_pass("-256584684", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-8", $type, 0);
 	should_pass("-8", $type, 0);
 	should_pass("-7", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_pass("43733", $type, 0);
 	should_pass("29358", $type, 0);
 	should_pass("75414", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_pass("934646773752244366", $type, 0);
 	should_pass("946663632864638888", $type, 0);
 	should_pass("953654543736653615", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_fail("523528", $type, 0);
 	should_fail("-83453757559438134", $type, 0);
 	should_fail("-82864921", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_fail("6643732616", $type, 0);
 	should_fail("-872475", $type, 0);
 	should_fail("6622853", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("7481741375817", $type, 0);
 	should_fail("-24856383", $type, 0);
 	should_fail("72534", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_fail("-28847764362258", $type, 0);
 	should_fail("-7848246815716", $type, 0);
 	should_fail("66448574776", $type, 0);
 };
 
 subtest "Type atomic/long is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('Long', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('Long', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_fail("-1448838426", $type, 0);
 	should_fail("-13887678695934982", $type, 0);
 	should_fail("-4461457", $type, 0);

t/50negativeInteger.t

 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-7", $type, 0);
 	should_pass("-8", $type, 0);
 	should_pass("-8", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_pass("-76576", $type, 0);
 	should_pass("-92592", $type, 0);
 	should_pass("-28664", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_pass("-165429727", $type, 0);
 	should_pass("-583133911", $type, 0);
 	should_pass("-887829423", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{13}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{13}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{13}$)/});
 	should_pass("-6652874376778", $type, 0);
 	should_pass("-5362777997727", $type, 0);
 	should_pass("-2844768288884", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_pass("-914387262474557335", $type, 0);
 	should_pass("-923276382451256268", $type, 0);
 	should_pass("-917314136385244564", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("-6224178888684242", $type, 0);
 	should_fail("-27738747", $type, 0);
 	should_fail("-917486331664737187", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_fail("-3232", $type, 0);
 	should_fail("-17351737336733", $type, 0);
 	should_fail("-7417355772454323", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_fail("-765838262428", $type, 0);
 	should_fail("-58", $type, 0);
 	should_fail("-524428766258666", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{13}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{13}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{13}$)/});
 	should_fail("-64876363769717", $type, 0);
 	should_fail("-8", $type, 0);
 	should_fail("-948175624636772733", $type, 0);
 };
 
 subtest "Type atomic/negativeInteger is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('NegativeInteger', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_fail("-282", $type, 0);
 	should_fail("-678426537437946", $type, 0);
 	should_fail("-25276325622825", $type, 0);

t/50nonNegativeInteger.t

 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_pass("5", $type, 0);
 	should_pass("7", $type, 0);
 	should_pass("8", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_pass("61563", $type, 0);
 	should_pass("71174", $type, 0);
 	should_pass("88533", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{9}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{9}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{9}$)/});
 	should_pass("744672379", $type, 0);
 	should_pass("352843363", $type, 0);
 	should_pass("546285228", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{13}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{13}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{13}$)/});
 	should_pass("3515776629323", $type, 0);
 	should_pass("7439739327795", $type, 0);
 	should_pass("5383645611171", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_pass("915476347284546727", $type, 0);
 	should_pass("981361845647637366", $type, 0);
 	should_pass("921446647764661256", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{1}$)/});
 	should_fail("4335235", $type, 0);
 	should_fail("77", $type, 0);
 	should_fail("227847", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{5}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{5}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{5}$)/});
 	should_fail("39855645", $type, 0);
 	should_fail("73", $type, 0);
 	should_fail("34889484", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{9}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{9}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{9}$)/});
 	should_fail("35184452224", $type, 0);
 	should_fail("17", $type, 0);
 	should_fail("85977", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{13}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{13}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{13}$)/});
 	should_fail("3365452747", $type, 0);
 	should_fail("7", $type, 0);
 	should_fail("845326", $type, 0);
 };
 
 subtest "Type atomic/nonNegativeInteger is restricted by facet pattern with value \\d{18}." => sub {
-	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?^ums:^\d{18}$)/});
+	my $type = mk_type('NonNegativeInteger', {'pattern' => qr/(?ms:^\d{18}$)/});
 	should_fail("6462125255", $type, 0);
 	should_fail("364364648671", $type, 0);
 	should_fail("5268764", $type, 0);

t/50nonPositiveInteger.t

 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_pass("-8", $type, 0);
 	should_pass("-8", $type, 0);
 	should_pass("-5", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_pass("-78241", $type, 0);
 	should_pass("-52356", $type, 0);
 	should_pass("-36965", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_pass("-488322716", $type, 0);
 	should_pass("-437225795", $type, 0);
 	should_pass("-744662475", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{13}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{13}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{13}$)/});
 	should_pass("-8275124922345", $type, 0);
 	should_pass("-2469517378287", $type, 0);
 	should_pass("-4715332476686", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_pass("-936563332352235635", $type, 0);
 	should_pass("-942544636732766563", $type, 0);
 	should_pass("-913235447674617174", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{1}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{1}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{1}$)/});
 	should_fail("-2944", $type, 0);
 	should_fail("-84382889683379", $type, 0);
 	should_fail("-72847445", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{5}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{5}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{5}$)/});
 	should_fail("-922653546988", $type, 0);
 	should_fail("-7967", $type, 0);
 	should_fail("-7547535873", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{9}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{9}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{9}$)/});
 	should_fail("-87135695", $type, 0);
 	should_fail("-287435868776", $type, 0);
 	should_fail("-1533523342", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{13}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{13}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{13}$)/});
 	should_fail("-83736172817", $type, 0);
 	should_fail("-686465751752", $type, 0);
 	should_fail("-4", $type, 0);
 };
 
 subtest "Type atomic/nonPositiveInteger is restricted by facet pattern with value \\-\\d{18}." => sub {
-	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?^ums:^\-\d{18}$)/});
+	my $type = mk_type('NonPositiveInteger', {'pattern' => qr/(?ms:^\-\d{18}$)/});
 	should_fail("-64954588", $type, 0);
 	should_fail("-44652546", $type, 0);
 	should_fail("-78771773424874684", $type, 0);

t/50normalizedString.t

 };
 
 subtest "Type atomic/normalizedString is restricted by facet pattern with value \\d{1,5}\\s([A-Z][a-z]{1,20}\\s){4}Street\\s([A-Z][a-z]{1,20}\\s){1},\\s[A-Z]{2}\\s18037." => sub {
-	my $type = mk_type('NormalizedString', {'pattern' => qr/(?^ums:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){1},\s[A-Z]{2}\s18037$)/});
+	my $type = mk_type('NormalizedString', {'pattern' => qr/(?ms:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){1},\s[A-Z]{2}\s18037$)/});
 	should_pass("8259 Structured Participants And Of Street Forum , MT 18037", $type, 0);
 	should_pass("55 Improved Computing Future Such Street Individual , OR 18037", $type, 0);
 	should_pass("32 To And And Collaborate Street Organizations , DE 18037", $type, 0);
 };
 
 subtest "Type atomic/normalizedString is restricted by facet pattern with value \\d{1,5}\\s([A-Z][a-z]{1,20}\\s){4}Street\\s([A-Z][a-z]{1,20}\\s){2},\\s[A-Z]{2}\\s11352." => sub {
-	my $type = mk_type('NormalizedString', {'pattern' => qr/(?^ums:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){2},\s[A-Z]{2}\s11352$)/});
+	my $type = mk_type('NormalizedString', {'pattern' => qr/(?ms:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){2},\s[A-Z]{2}\s11352$)/});
 	should_pass("63663 That These At Certain Street Meets Of , MI 11352", $type, 0);
 	should_pass("9568 Registry Standards Those Beta Street Of Organizations , IA 11352", $type, 0);
 	should_pass("637 For Issues Associated Guidelines Street Better Of , LA 11352", $type, 0);
 };
 
 subtest "Type atomic/normalizedString is restricted by facet pattern with value \\d{1,5}\\s([A-Z][a-z]{1,20}\\s){4}Street\\s([A-Z][a-z]{1,20}\\s){3},\\s[A-Z]{2}\\s12317." => sub {
-	my $type = mk_type('NormalizedString', {'pattern' => qr/(?^ums:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){3},\s[A-Z]{2}\s12317$)/});
+	my $type = mk_type('NormalizedString', {'pattern' => qr/(?ms:^\d{1,5}\s([A-Z][a-z]{1,20}\s){4}Street\s([A-Z][a-z]{1,20}\s){3},\s[A-Z]{2}\s12317$)/});
 	should_pass("4 The Language That Reviewed Street Object Furthermore Not , AL 12317", $type, 0);
 	should_pass("382 This Academy Is Is Street For Accelerate Computing , NY 12317", $type, 0);
 	should_pass("437 Promises That Allow Xml Street The Software Review , UT 12317", $type, 0);
 };
 
 subtest "Type atomic/normalizedString is restricted by facet pattern with value \\d{1,5}\\s([A-Z][a-z]{1,20}\\s){1}Street\\s([A-Z][a-z]{1,20}\\s){1},\\s[A-Z]{2}\\s17076." => sub {
-	my $type = mk_type('NormalizedString', {'pattern' => qr/(?^ums:^\d{1,5}\s([A-Z][a-z]{1,20}\s){1}Street\s([A-Z][a-z]{1,20}\s){1},\s[A-Z]{2}\s17076$)/});
+	my $type = mk_type('NormalizedString', {'pattern' => qr/(?ms:^\d{1,5}\s([A-Z][a-z]{1,20}\s){1}Street\s([A-Z][a-z]{1,20}\s){1},\s[A-Z]{2}\s17076$)/});
 	should_pass("5 Provide Street Location , SD 17076", $type, 0);
 	should_pass("81846 Reviewed Street By , IL 17076", $type, 0);
 	should_pass("537 Dom Street In , WI 17076", $type, 0);
 };
 
 subtest "Type atomic/normalizedString is restricted by facet pattern with value \\d{1,5}\\s([A-Z][a-z]{1,20}\\s){1}Street\\s([A-Z][a-z]{1,20}\\s){3},\\s[A-Z]{2}\\s19099-1858." => sub {
-	my $type = mk_type('NormalizedString', {'pattern' => qr/(?^ums:^\d{1,5}\s([A-Z][a-z]{1,20}\s){1}Street\s([A-Z][a-z]{1,20}\s){3},\s[A-Z]{2}\s19099-1858$)/});
+	my $type = mk_type('NormalizedString', {'pattern' => qr/(?ms:^\d{1,5}\s([A-Z][a-z]{1,20}\s){1}Street\s([A-Z][a-z]{1,20}\s){3},\s[A-Z]{2}\s19099-1858$)/});
 	should_pass("3453 Of Street Do Of Security , NM 19099-1858", $type, 0);
 	should_pass("236 Industry Street Chi Standardization Tools , NE 19099-1858", $type, 0);
 	should_pass("154 Be Street Of Database Oasis , IL 19099-1858", $type, 0);

t/50positiveInteger.t

 };
 
 subtest "Type atomic/positiveInteger is restricted by facet pattern with value \\d{1}." => sub {
-	my $type = mk_type('PositiveInteger', {'pattern' => qr/(?^ums:^\d{1}$)/});
+	my $type = mk_type('PositiveInteger', {'pattern' => qr/(?ms:^\d{1}$)/});