math_ml-0.14/0000755000004100000410000000000012055512401013102 5ustar www-datawww-datamath_ml-0.14/Rakefile0000644000004100000410000000240012055512401014543 0ustar www-datawww-dataload "Rakefile.utirake" VER = "0.14" UtiRake.setup do external("https://hg.hinet.mydns.jp", %w[eim_xml]) rdoc do |t| t.title = "MathML Library" t.main = "README" t.rdoc_files.include(FileList["lib/**/*.rb", "README"]) end publish("mathml", "hiraku") do cp "index.html", "html/index.html" end gemspec do |s| s.name = "math_ml" s.rubyforge_project = "mathml" s.version = VER s.summary = "MathML Library" s.author = "KURODA Hiraku" s.email = "hiraku@hinet.mydns.jp" s.homepage = "http://mathml.rubyforge.org/" s.add_dependency("eim_xml") end rcov_spec do |s| s.ruby_opts = %w[-rubygems] s.pattern ||= %w[spec/util.rb spec/**/*_spec.rb] s.pattern = [s.pattern] unless s.pattern.is_a?(Array) # s.pattern << "symbols/**/*_spec.rb" end spec do |s| # s.spec_opts << "-b" end alias_task end namespace :spec do RSpec::Core::RakeTask.new(:symbols) do |s| s.pattern = "./symbols/**/*_spec.rb" s.rspec_opts = %w[-c -I lib -I external/lib] end end task :package do name = "math_ml-#{VER}" cp "external/eim_xml/lib/eim_xml.rb", "pkg/#{name}/lib/" Dir.chdir "pkg" do rm "#{name}.tar.gz" sh "tar zcf #{name}.tar.gz #{name}/" end end task :default => :spec task "spec:no_here" => "spec:apart" task :all => [:spec, "spec:symbols"] math_ml-0.14/spec/0000755000004100000410000000000012055512401014034 5ustar www-datawww-datamath_ml-0.14/spec/math_ml/0000755000004100000410000000000012055512401015455 5ustar www-datawww-datamath_ml-0.14/spec/math_ml/util_spec.rb0000644000004100000410000006021312055512401017773 0ustar www-datawww-datarequire "math_ml/util" require "eim_xml/parser" describe MathML::Util do include MathML::Util it "#escapeXML" do escapeXML("<>&\"'").should == "<>&"'" escapeXML("\n").should == "\n" escapeXML("\n", true).should == "
\n" end it ".escapeXML" do MathML::Util.escapeXML("<>&\"'").should == "<>&"'" MathML::Util.escapeXML("\n").should == "\n" MathML::Util.escapeXML("\n", true).should == "
\n" end it "#collect_regexp" do collect_regexp([/a/, /b/, /c/]).should == /#{/a/}|#{/b/}|#{/c/}/ collect_regexp([[/a/, /b/, /c/]]).should == /#{/a/}|#{/b/}|#{/c/}/ collect_regexp([]).should == /(?!)/ collect_regexp(/a/).should == /#{/a/}/ end it ".collect_regexp" do MathML::Util.collect_regexp([/a/, /b/, /c/]).should == /#{/a/}|#{/b/}|#{/c/}/ MathML::Util.collect_regexp([[/a/, /b/, /c/]]).should == /#{/a/}|#{/b/}|#{/c/}/ MathML::Util.collect_regexp([]).should == /(?!)/ MathML::Util.collect_regexp(/a/).should == /#{/a/}/ MathML::Util.collect_regexp([nil, /a/, "text", /b/]).should == /#{/a/}|#{/b/}/ MathML::Util.collect_regexp([nil, [/a/, [/b/, /c/]]]).should == /#{/a/}|#{/b/}|#{/c/}/ end it "::INVALID_RE" do MathML::Util::INVALID_RE.should == /(?!)/ end end describe MathML::Util::MathData do it "#<< and #update" do m = MathML::Util::MathData.new m.math_list << "ml1" m.msrc_list << "sl1" m.dmath_list << "dml1" m.dsrc_list << "dsl1" m.escape_list << "el1" m.esrc_list << "es1" m.user_list << "ul1" m.usrc_list << "usl1" m.math_list.should == ["ml1"] m.msrc_list.should == ["sl1"] m.dmath_list.should == ["dml1"] m.dsrc_list.should == ["dsl1"] m.escape_list.should == ["el1"] m.esrc_list.should == ["es1"] m.user_list.should == ["ul1"] m.usrc_list.should == ["usl1"] m2 = MathML::Util::MathData.new m2.math_list << "ml2" m2.msrc_list << "sl2" m2.dmath_list << "dml2" m2.dsrc_list << "dsl2" m2.escape_list << "el2" m2.esrc_list << "es2" m2.user_list << "ul2" m2.usrc_list << "usl2" m.update(m2) m.math_list.should == ["ml1", "ml2"] m.msrc_list.should == ["sl1", "sl2"] m.dmath_list.should == ["dml1", "dml2"] m.dsrc_list.should == ["dsl1", "dsl2"] m.escape_list.should == ["el1", "el2"] m.esrc_list.should == ["es1", "es2"] m.user_list.should == ["ul1", "ul2"] m.usrc_list.should == ["usl1", "usl2"] end end describe MathML::Util::SimpleLaTeX do def strip_math(s) s.gsub(/>\s*/, ">").gsub(/\s*(.*)<\/math>/m, 1] end def sma(a) # Stripped Mathml Array r = [] a.each do |i| r << strip_math(i.to_s) end r end def simplify_math(src) attr = [] r = src.gsub(/]+)>/) do |m| attr << $1.scan(/\s+[^\s]+/).map{|i| i[/\A\s*(.*)/, 1]}.sort "" end attr.unshift(r) end def assert_data(src, expected_math, expected_src, expected_dmath, expected_dsrc, expected_escaped, expected_esrc, expected_encoded, expected_decoded, simple_latex = MathML::Util::SimpleLaTeX) encoded, data = simple_latex.encode(src) data.math_list.each do |i| i.attributes[:display].should == "inline" end data.dmath_list.each do |i| i.attributes[:display].should == "block" end sma(data.math_list).should == expected_math data.msrc_list.should == expected_src sma(data.dmath_list).should == expected_dmath data.dsrc_list.should == expected_dsrc data.escape_list.should == expected_escaped data.esrc_list.should == expected_esrc encoded.should == expected_encoded target = simple_latex.decode(encoded, data) simplify_math(target).should == simplify_math(expected_decoded) end it "(spec for helper)" do simplify_math("..").should == ["..", %w[a='b' c='d'], %w[e='f' g='h']] end it "should parse math environment" do assert_data("a\n$\nb\n$\nc\\(\nd\n\\)e", ["b", "d"], ["$\nb\n$", "\\(\nd\n\\)"], [], [], [], [], "a\n\001m0\001\nc\001m1\001e", "a\nb\ncde") assert_data('$\\$$', ["$"], ['$\$$'], [], [], [], [], "\001m0\001", "$") end it "should parse dmath environment" do assert_data("a\n$$\nb\n$$\nc\\[\nd\n\\]e", [], [], ["b", "d"], ["$$\nb\n$$", "\\[\nd\n\\]"], [], [], "a\n\001d0\001\nc\001d1\001e", "a\nb\ncde") end it "should parse math and dmath environment" do assert_data('a$b$c$$d$$e\(f\)g\[h\]i', ["b", "f"], ["$b$", '\(f\)'], ["d", "h"], ["$$d$$", '\[h\]'], [], [], "a\001m0\001c\001d0\001e\001m1\001g\001d1\001i", "abcdefghi") end it "should parse escaping" do assert_data('a\bc\d\e', [], [], [], [], ['b', 'd', 'e'], ['\b', '\d', '\e'], "a\001e0\001c\001e1\001\001e2\001", 'abcde') assert_data('\$a$$b$$', [], [], ["b"], ["$$b$$"], [%[$]], ['\$'], "\001e0\001a\001d0\001", "$ab") assert_data("\\<\\\n", [], [], [], [], ["<", "
\n"], ["\\<", "\\\n"], "\001e0\001\001e1\001", "<
\n") end it "should accept through_list option" do s = MathML::Util::SimpleLaTeX.new(:through_list=>[/\{\{.*\}\}/, /\(.*\)/]) assert_data("{{$a$}}($b$)", [], [], [], [], [], [], "{{$a$}}($b$)", "{{$a$}}($b$)", s) s = MathML::Util::SimpleLaTeX.new(:through_list=>/\{.*\}/) assert_data("{$a$}", [], [], [], [], [], [], "{$a$}", "{$a$}", s) end it "should accept parser option" do ps = MathML::LaTeX::Parser.new ps.macro.parse('\newcommand{\test}{t}') s = MathML::Util::SimpleLaTeX.new(:parser=>ps) assert_data('$\test$', ["t"], ['$\test$'], [], [], [], [], "\001m0\001", "t", s) end it "should accept escape option" do s = MathML::Util::SimpleLaTeX.new(:escape_list=>[/\/(.)/, /(\^.)/]) assert_data('\$a$', ["a"], ['$a$'], [], [], [], [], "\\\001m0\001", "\\a", s) assert_data(%[/$a/$], [], [], [], [], [%[$], %[$]], [%[/$], %[/$]], "\001e0\001a\001e1\001", "$a$", s) assert_data('^\(a^\)', [], [], [], [], ['^\\', '^\\'], ['^\\', '^\\'], "\001e0\001(a\001e1\001)", '^\(a^\)', s) s = MathML::Util::SimpleLaTeX.new(:escape_list=>/_(.)/) assert_data("_$a$", [], [], [], [], ['$'], ["_$"], %[\001e0\001a$], '$a$', s) end it "should accept delimiter option" do s = MathML::Util::SimpleLaTeX.new(:delimiter=>"\002\003") assert_data("a$b$c", ["b"], ["$b$"], [], [], [], [], "a\002\003m0\002\003c", "abc", s) s = MathML::Util::SimpleLaTeX.new(:delimiter=>%[$]) assert_data("a$b$c", ["b"], ["$b$"], [], [], [], [], "a$m0$c", "abc", s) end it "should accept (d)math_env_list option" do s = MathML::Util::SimpleLaTeX.new(:math_env_list=>/%(.*?)%/, :dmath_env_list=>/\[(.*?)\]/) assert_data("a$b$c%d%e[f]", ["d"], ["%d%"], ["f"], ["[f]"], [], [], "a$b$c\001m0\001e\001d0\001", "a$b$cdef", s) s = MathML::Util::SimpleLaTeX.new(:math_env_list=>[/!(.*?)!/, /"(.*)"/], :dmath_env_list=>[/\#(.*)\#/, /&(.*)&/]) assert_data('a!b!c"d"e#f#g&h&i', ["b", "d"], ['!b!', '"d"'], ["f", "h"], ['#f#', '&h&'], [], [], "a\001m0\001c\001m1\001e\001d0\001g\001d1\001i", "abcdefghi", s) end it "should accept throu_list option" do s = MathML::Util::SimpleLaTeX.new(:through_list=>[/<%=.*?%>/m, /\(\(.*?\)\)/m]) assert_data("<%=$a$%>(($b$))", [], [], [], [], [], [], "<%=$a$%>(($b$))", "<%=$a$%>(($b$))", s) s = MathML::Util::SimpleLaTeX.new(:through_list=>/<%=.*?%>/) assert_data("<%=$a$%>", [], [], [], [], [], [], "<%=$a$%>", "<%=$a$%>", s) end it "should accept through_list=>[]" do s = MathML::Util::SimpleLaTeX.new(:through_list=>[]) assert_data("$a$", ["a"], [%[$a$]], [], [], [], [], "\001m0\001", "a", s) end it "should accept without_parse option" do s = MathML::Util::SimpleLaTeX.new(:without_parse=>true) encoded, data = s.encode("$a$ $$b$$") data.math_list.should == [] data.msrc_list.should == ["$a$"] data.dmath_list.should == [] data.dsrc_list.should == ["$$b$$"] encoded.should == "\001m0\001 \001d0\001" s.parse(data) data.math_list[0].attributes[:display].should == "inline" data.dmath_list[0].attributes[:display].should == "block" sma(data.math_list).should == ["a"] sma(data.dmath_list).should == ["b"] simplify_math(s.decode(encoded, data)).should == simplify_math("a b") end it "#set_encode_proc" do s = MathML::Util::SimpleLaTeX.new s.set_encode_proc(/\{\{/) do |scanner| if scanner.scan(/\{\{(.*?)\}\}/m) "<%=#{scanner[1]}%>" end end src = "{{$a$}}{{$$b$$}}{{" assert_data(src, [], [], [], [], [], [], "\001u0\001\001u1\001{{", "<%=$a$%><%=$$b$$%>{{", s) encoded, data = s.encode(src) data.user_list.should == ["<%=$a$%>", "<%=$$b$$%>"] data.usrc_list.should == ["{{$a$}}", "{{$$b$$}}"] s.set_encode_proc(/\{\{/) do |scanner| end src = "{{a" assert_data(src, [], [], [], [], [], [], "{{a", "{{a", s) encoded, data = s.encode(src) data.user_list.should == [] data.usrc_list.should == [] end it "#set_encode_proc with arrayed regexp" do s = MathML::Util::SimpleLaTeX.new src = "{{a}}((b)){{((" encoded, data = s.encode(src, /\{\{/, /\(\(/) do |scanner| case when scanner.scan(/\{\{.*?\}\}/) "brace" when scanner.scan(/\(\(.*?\)\)/) "parenthesis" end end encoded.should == "\001u0\001\001u1\001{{((" s.decode(encoded, data).should == "braceparenthesis{{((" s.set_encode_proc(/\{\{/, /\(\(/) do |scanner| case when scanner.scan(/\{\{.*?\}\}/) "brace" when scanner.scan(/\(\(.*?\)\)/) "parenthesis" end end encoded, data = s.encode(src) encoded.should == "\001u0\001\001u1\001{{((" s.decode(encoded, data).should == "braceparenthesis{{((" end it "#encode accept block" do s = MathML::Util::SimpleLaTeX.new src = "{{$a$}}{{$$b$$}}{{" encoded, data = s.encode(src, /\{\{/) do |scanner| if scanner.scan(/\{\{(.*?)\}\}/m) "<%=#{scanner[1]}%>" end end data.math_list.should == [] data.dmath_list.should == [] data.escape_list.should == [] encoded.should == "\001u0\001\001u1\001{{" s.decode(encoded, data).should == "<%=$a$%><%=$$b$$%>{{" end it "#encode should accept block with #set_encode_proc" do s = MathML::Util::SimpleLaTeX.new src = "{{$a$}}{{$$b$$}}{{" s.set_encode_proc(/\{\{/) do |scanner| if scanner.scan(/\{\{(.*?)\}\}/m) "<%=#{scanner[1]}%>" end end encoded, data = s.encode(src, /\{\{/) do |scanner| if scanner.scan(/\{\{(.*?)\}\}/m) "<$=#{scanner[1]}$>" end end data.math_list.should == [] data.dmath_list.should == [] data.escape_list.should == [] encoded.should == "\001u0\001\001u1\001{{" s.decode(encoded, data).should == "<$=$a$$><$=$$b$$$>{{" end it "#unencode" do src = "$\na\n$\n$$\nb\n$$" s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode(src) s.unencode(encoded, data).should == "$
\na
\n$\n$$
\nb
\n$$" s = MathML::Util::SimpleLaTeX.new(:delimiter=>%[$]) e, d = s.encode("$a$") s.unencode(e, d).should == "$a$" end it "#set_rescue_proc" do src = '$a\test$ $$b\dummy$$' s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode(src) data.math_list[0].should == "
\nUndefined command.
\na\\test
" data.dmath_list[0].should == "
\nUndefined command.
\nb\\dummy
" s.set_rescue_proc do |e| e end encoded, data = s.encode(src) data.math_list[0].should be_kind_of(MathML::LaTeX::ParseError) data.math_list[0].done.should == "a" data.dmath_list[0].should be_kind_of(MathML::LaTeX::ParseError) data.dmath_list[0].done.should == "b" end it "#decode with block" do s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode('$a$$b$$$c$$$$d$$\e\\\\') r = s.decode(encoded, data) do |item, opt| case opt[:type] when :dmath item.attributes[:display].should == "block" i = strip_math(item.to_s) when :math item.attributes[:display].should == "inline" i = strip_math(item.to_s) else i = item end r = "t#{opt[:type]}i#{opt[:index]}s#{opt[:src]}#{i}" end r.should == "tmathi0s$a$atmathi1s$b$btdmathi0s$$c$$ctdmathi1s$$d$$dtescapei0s\\eetescapei1s\\\\\\" r = s.decode(encoded, data) do |item, opt| nil end r.should == s.decode(encoded, data) s.set_encode_proc(/\{\{/) do |scanner| "<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m) end encoded, data = s.encode("{{a}}{{") r = s.decode(encoded, data) do |item, opt| item.should == "<%=a%>" opt[:type].should == :user opt[:index].should == 0 opt[:src].should == "{{a}}" nil end r.should == "<%=a%>{{" s.set_decode_proc do |item, opt| "dummy" end s.decode(encoded, data).should == "dummy{{" r = s.decode(encoded, data) do |item, opt| nil end r.should == "<%=a%>{{" end it "#set_decode_proc" do s = MathML::Util::SimpleLaTeX.new src = '$a$$b$$$c$$$$d$$\e\\\\' encoded, data = s.encode(src) original_decoded = s.decode(encoded, data) s.set_decode_proc do |item, opt| case opt[:type] when :dmath item.attributes[:display].should == "block" i = strip_math(item.to_s) when :math item.attributes[:display].should == "inline" i = strip_math(item.to_s) else i = item end r = "t#{opt[:type]}i#{opt[:index]}s#{opt[:src]}#{i}" end encoded, data = s.encode(src) r = s.decode(encoded, data) r.should == "tmathi0s$a$atmathi1s$b$btdmathi0s$$c$$ctdmathi1s$$d$$dtescapei0s\\eetescapei1s\\\\\\" s.reset_decode_proc s.decode(encoded, data).should == original_decoded end it "#unencode with block" do s = MathML::Util::SimpleLaTeX.new src = '$a$$b$$$c$$$$d$$\e\\\\' encoded, data = s.encode(src) r = s.unencode(encoded, data) do |item, opt| r = "t#{opt[:type]}i#{opt[:index]}#{item.to_s}" end r.should == "tmathi0$a$tmathi1$b$tdmathi0$$c$$tdmathi1$$d$$tescapei0\\etescapei1\\\\" r = s.unencode(encoded, data) do |item, opt| nil end r.should == s.unencode(encoded, data) s.set_encode_proc(/\{\{/) do |scanner| "<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m) end encoded, data = s.encode("{{a}}{{") r = s.unencode(encoded, data) do |item, opt| item.should == "{{a}}" opt[:type].should == :user opt[:index].should == 0 nil end r.should == "{{a}}{{" end it "#set_unencode_proc" do s = MathML::Util::SimpleLaTeX.new src = '$a$$b$$$c$$$$d$$\e\\\\' encoded, data = s.encode(src) original_unencoded = s.unencode(encoded, data) s.set_unencode_proc do |item, opt| r = "t#{opt[:type]}i#{opt[:index]}#{item.to_s}" end r = s.unencode(encoded, data) r.should == "tmathi0$a$tmathi1$b$tdmathi0$$c$$tdmathi1$$d$$tescapei0\\etescapei1\\\\" s.set_unencode_proc do |item, opt| nil end s.unencode(encoded, data).should == original_unencoded s.set_encode_proc(/\{\{/) do |scanner| "<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m) end encoded, data = s.encode("{{a}}{{") s.set_unencode_proc do |item, opt| item.should == "{{a}}" opt[:type].should == :user opt[:index].should == 0 nil end r = s.unencode(encoded, data) r.should == "{{a}}{{" end it "#reset_unencode_proc" do s = MathML::Util::SimpleLaTeX.new s.set_unencode_proc do |item, opt| "dummy" end encoded, data = s.encode("$a$ $$b$$") s.unencode(encoded, data).should == "dummy dummy" s.reset_unencode_proc s.unencode(encoded, data).should == "$a$ $$b$$" end it "#unencode without escaping" do s = MathML::Util::SimpleLaTeX.new src = %[$<>&'"\n$ $$<>&"'\n$$] encoded, data = s.encode(src) s.unencode(encoded, data).should == "$<>&'"
\n$ $$<>&"'
\n$$" s.unencode(encoded, data, true).should == src end it "#decode without parsed" do s = MathML::Util::SimpleLaTeX.new src = '$a$$$b$$\a' encoded, data = s.encode(src) s.decode(encoded, data, true).should == "$a$$$b$$a" s.decode(encoded, data, true) do |item, opt| case opt[:type] when :math item.should == "$a$" when :dmath item.should == "$$b$$" when :escape item.should == "a" end end encoded, data = s.encode("$<\n$ $$<\n$$") s.decode(encoded, data, true).should == "$<
\n$ $$<
\n$$" end it "#decode_partial" do s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode("$a$$b$") simplify_math(s.decode_partial(:math, encoded, data)).should == simplify_math("ab") s.set_encode_proc(/\\/) scanner[2] end end src='$a$$$b$$\c\<.$d$.>' encoded, data = s.encode(src) simplify_math(s.decode_partial(:math, encoded, data)).should == simplify_math("a\001d0\001\001e0\001\001u0\001") simplify_math(s.decode_partial(:dmath, encoded, data)).should == simplify_math("\001m0\001b\001e0\001\001u0\001") simplify_math(s.decode_partial(:escape, encoded, data)).should == simplify_math("\001m0\001\001d0\001c\001u0\001") simplify_math(s.decode_partial(:user, encoded, data)).should == simplify_math("\001m0\001\001d0\001\001e0\001$d$") r = s.decode_partial(:math, encoded, data) do |item, opt| opt[:type].should == :math opt[:src].should == "$a$" simplify_math(item.to_s).should == simplify_math("a") item end simplify_math(r).should == simplify_math("a\001d0\001\001e0\001\001u0\001") r = s.decode_partial(:dmath, encoded, data) do |item, opt| opt[:type].should == :dmath opt[:src].should == "$$b$$" simplify_math(item.to_s).should == simplify_math("b") item end simplify_math(r).should == simplify_math("\001m0\001b\001e0\001\001u0\001") r = s.decode_partial(:escape, encoded, data) do |item, opt| opt[:type].should == :escape opt[:src].should == "\\c" item.should == "c" item end r.should == "\001m0\001\001d0\001c\001u0\001" r = s.decode_partial(:user, encoded, data) do |item, opt| opt[:type].should == :user opt[:src].should == "\\<.$d$.>" item.should == "$d$" item end r.should == "\001m0\001\001d0\001\001e0\001$d$" s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode("\\a") s.decode_partial(:escape, encoded, data).should == "a" r = s.decode_partial(:escape, encoded, data) do |item, opt| end r.should == "\001e0\001" s = MathML::Util::SimpleLaTeX.new(:delimiter=>%[$]) encoded, data = s.encode("$a$") s.decode_partial(:math, encoded, data).should =~ /^/m end it "should keep regexp order" do s = MathML::Util::SimpleLaTeX.new s.set_encode_proc(/\$/) do |sc| if sc.scan(/\$(.*)\z/) sc[1]+"is rest" end end encoded, data = s.encode("$a$$b") encoded.should == "\001m0\001\001u0\001" end it "parse eqnarray" do s = MathML::Util::SimpleLaTeX.new src = <<'EOT' test \begin {eqnarray} a&=&b\\ c&=&d \end {eqnarray} end EOT encoded, data = s.encode(src, MathML::Util::EQNARRAY_RE) do |scanner| if scanner.scan(MathML::Util::EQNARRAY_RE) s.parse_eqnarray(scanner[1]) end end encoded.should == "test\n\001u0\001\nend\n" simplify_math(s.decode(encoded, data)).should == simplify_math("test\na=bc=d\nend\n") encoded, data = s.encode('\begin{eqnarray}a\end{eqnarray}', MathML::Util::EQNARRAY_RE) do |scanner| s.parse_eqnarray(scanner[1]) if scanner.scan(MathML::Util::EQNARRAY_RE) end s.decode(encoded, data).should == "
\nNeed more column.
\n\\begin{eqnarray}a\\end{eqnarray}
" end it "should parse single command" do s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode(%q[\alpha\|\<\>\&\"\'\test], MathML::Util::SINGLE_COMMAND_RE) do |scanner| if scanner.scan(MathML::Util::SINGLE_COMMAND_RE) s.parse_single_command(scanner.matched) end end encoded.should == "\001u0\001\001e0\001\001e1\001\001e2\001\001e3\001\001e4\001\001e5\001\001u1\001" simplify_math(s.decode(encoded, data)).should == simplify_math("α|<>&"'test") encoded, data = s.encode('\alpha test', MathML::Util::SINGLE_COMMAND_RE) do |scanner| if scanner.scan(MathML::Util::SINGLE_COMMAND_RE) s.parse_single_command(scanner.matched) end end encoded.should == "\001u0\001test" simplify_math(s.decode(encoded, data)).should == simplify_math("αtest") encoded, data = s.encode('\alpha test', MathML::Util::SINGLE_COMMAND_RE) do |scanner| if scanner.scan(MathML::Util::SINGLE_COMMAND_RE) s.parse_single_command(scanner.matched) end end encoded.should == "\001u0\001 test" simplify_math(s.decode(encoded, data)).should == simplify_math("α test") encoded, data = s.encode("\\alpha\ntest", MathML::Util::SINGLE_COMMAND_RE) do |scanner| if scanner.scan(MathML::Util::SINGLE_COMMAND_RE) s.parse_single_command(scanner.matched) end end encoded.should == "\001u0\001\ntest" end it "#encode can be called twice or more times" do s = MathML::Util::SimpleLaTeX.new encoded, data = s.encode('$a$') encoded, data = s.encode('$b$', data) encoded.should == "\001m1\001" data.msrc_list.should == ["$a$", '$b$'] data.math_list.size.should == 2 strip_math(data.math_list[0].to_s).should == "a" strip_math(data.math_list[1].to_s).should == "b" encoded, data = s.encode('a', data, /a/) do |sc| sc.scan(/a/) end encoded.should == "\001u0\001" data.msrc_list.should == ["$a$", '$b$'] data.usrc_list.should == ["a"] encoded, data = s.encode('a', nil, /a/) do |s| s.scan(/a/) end encoded.should == "\001u0\001" data.usrc_list.should == ["a"] end end math_ml-0.14/spec/math_ml/latex/0000755000004100000410000000000012055512401016572 5ustar www-datawww-datamath_ml-0.14/spec/math_ml/latex/scanner_spec.rb0000644000004100000410000001046112055512401021564 0ustar www-datawww-datarequire "math_ml" describe MathML::LaTeX::Scanner do def new_scanner(src) MathML::LaTeX::Scanner.new(src) end it "#done, #rest" do s = new_scanner("0123") s.pos = 2 s.done.should == "01" s.rest.should == "23" end it "#_check" do s = new_scanner(" ") s._check(/\s/).should == " " s.pos.should == 0 end it "#_scan" do s = new_scanner(" ") s._scan(/\s/).should == " " s.pos.should == 1 end it "#check" do s = new_scanner(" a") s.check(/a/).should == "a" s.pos.should == 0 end it "#scan, #reset" do s = new_scanner(" a") s.scan(/a/).should == "a" s.pos.should == 2 s.reset s.pos.should == 0 s.scan(/b/).should be_nil s.pos.should == 0 s = new_scanner(" %comment\na") s.scan(/a/).should == "a" s.pos.should == 11 s.reset s.scan(/b/).should be_nil s.pos.should == 0 end it "#eos" do new_scanner("").should be_eos new_scanner(" ").should be_eos new_scanner(" %test\n%test").should be_eos new_scanner(" a").should_not be_eos new_scanner(" \\command").should_not be_eos end it "#check_command" do '\t'.should == '\\t' new_scanner("test").check_command.should be_nil s = new_scanner(' \test') s.check_command.should == '\\test' s[1].should == "test" new_scanner(' \test next').check_command.should == '\test' new_scanner(' \test_a').check_command.should == '\test' end it "#scan_command" do new_scanner("test").scan_command.should be_nil s = new_scanner(' \test') s.scan_command.should == '\test' s[1].should == "test" s.pos.should == 6 s = new_scanner(' \test rest') s.scan_command.should == '\test' s.pos.should == 6 s = new_scanner(' \test_a') s.scan_command.should == '\test' s.pos.should == 6 s = new_scanner(' \_test') s.check_command.should == '\_' s.scan_command.should == '\_' s.rest.should == "test" end it "#scan_block" do new_scanner(" a").scan_block.should == nil new_scanner(" a").check_block.should == nil i = " {{}{}{{}{}}} " e = "{#{i}}" s = new_scanner(" #{e} test") s.check_block.should == e s.matched.should == e s[1].should == i s.scan_block.should == e s.matched.should == e s[1].should == i s.rest.should == " test" new_scanner(' \command test').scan_block.should == nil new_scanner(' \command test').check_block.should == nil new_scanner("").scan_block.should == nil new_scanner("").check_block.should == nil new_scanner(" ").scan_block.should == nil new_scanner(" ").check_block.should == nil s = new_scanner("{test") lambda{s.scan_block}.should raise_error(MathML::LaTeX::BlockNotClosed) end it "#scan_any" do s0 = " %comment\n " s1 = "{}" s = new_scanner(s0+s1) s.scan_any.should == s1 s.reset s.scan_any(true).should == s0+s1 s.matched.should == s1 s1 = '\command' s = new_scanner(s0+s1) s.scan_any.should == s1 s.reset s.scan_any(true).should == s0+s1 s1 = 'a' s = new_scanner(s0+s1) s.scan_any.should == s1 s.reset s.scan_any(true).should == s0+s1 s = new_scanner(" ") s.scan_any.should == nil s.reset s.scan_any(true).should == " " s = new_scanner('\begin{env}test\end{env}') s.scan_any.should == '\begin' end it "#peek_command" do new_scanner(' \test').peek_command.should == "test" new_scanner("").peek_command.should == nil new_scanner(" ").peek_command.should == nil new_scanner(" a").peek_command.should == nil end it "#scan_option" do s = new_scanner(" []") s.scan_option.should == "[]" s[1].should == "" s.pos.should == 3 s = new_scanner(" [ opt ]") s.scan_option.should == "[ opt ]" s[1].should == " opt " s.pos.should == 8 s = new_scanner(" [[]]") s.scan_option.should == "[[]" s[1].should == "[" s = new_scanner(" [{[]}]") s.scan_option.should == "[{[]}]" s[1].should == "{[]}" lambda{new_scanner("[").scan_option}.should raise_error(MathML::LaTeX::OptionNotClosed) end it "#check_option" do s = new_scanner(" []") s.check_option.should == "[]" s[1].should == "" s.pos.should == 0 s = new_scanner(" [ opt ]") s.check_option.should == "[ opt ]" s[1].should == " opt " s.pos.should == 0 s = new_scanner(" [[]]") s.check_option.should == "[[]" s[1].should == "[" s = new_scanner(" [{[]}]") s.check_option.should == "[{[]}]" s[1].should == "{[]}" lambda{new_scanner("[").check_option}.should raise_error(MathML::LaTeX::OptionNotClosed) end end math_ml-0.14/spec/math_ml/latex/macro_spec.rb0000644000004100000410000001467512055512401021247 0ustar www-datawww-datarequire "math_ml" require "spec/util" describe MathML::LaTeX::Macro do include MathML::Spec::Util before(:all) do @src = <<'EOT' \newcommand{\newcom}{test} \newcommand{\paramcom}[2]{param2 #2, param1 #1.} \newcommand\ALPHA\alpha \newcommand\BETA[1]\beta \newcommand{\nothing}{} \newenvironment{newenv}{begin_newenv}{end_newenv} \newenvironment{paramenv}[2]{begin 1:#1, 2:#2}{end 2:#2 1:#1} \newenvironment{nothing}{}{} \newenvironment{separated environment}{sep}{env} \newenvironment ENV EOT end before do @m = MathML::LaTeX::Macro.new @m.parse(@src) end it "#parse" do @m = MathML::LaTeX::Macro.new lambda{@m.parse(@src)}.should_not raise_error @m = MathML::LaTeX::Macro.new lambda{@m.parse('\newcommand{notcommand}{}')}.should raise_parse_error("Need newcommand.", '\\newcommand{', "notcommand}{}") lambda{@m.parse('\newcommand{\separated command}{}')}.should raise_parse_error("Syntax error.", '\newcommand{\separated', " command}{}") lambda{@m.parse('\newcommand{\nobody}')}.should raise_parse_error("Need parameter.", '\newcommand{\nobody}', "") lambda{@m.parse('\newcommand{\noparam}{#1}')}.should raise_parse_error("Parameter \# too large.", '\newcommand{\noparam}{#', "1}") lambda{@m.parse('\newcommand{\overopt}[1]{#1#2}')}.should raise_parse_error("Parameter \# too large.", '\newcommand{\overopt}[1]{#1#', "2}") lambda{@m.parse('\newcommand{\strangeopt}[-1]')}.should raise_parse_error("Need positive number.", '\newcommand{\strangeopt}[', "-1]") lambda{@m.parse('\newcommand{\strangeopt}[a]')}.should raise_parse_error("Need positive number.", '\newcommand{\strangeopt}[', "a]") lambda{@m.parse('\newenvironment{\command}{}{}')}.should raise_parse_error("Syntax error.", '\newenvironment{', '\command}{}{}') lambda{@m.parse('\newenvironment{nobegin}')}.should raise_parse_error("Need begin block.", '\newenvironment{nobegin}', "") lambda{@m.parse('\newenvironment{noend}{}')}.should raise_parse_error("Need end block.", '\newenvironment{noend}{}', "") lambda{@m.parse('\newenvironment{noparam}{#1}{}')}.should raise_parse_error("Parameter \# too large.", '\newenvironment{noparam}{#', "1}{}") lambda{@m.parse('\newenvironment{overparam}[1]{#1#2}{}')}.should raise_parse_error("Parameter \# too large.", '\newenvironment{overparam}[1]{#1#', "2}{}") lambda{@m.parse('\newenvironment{strangeparam}[-1]{}{}')}.should raise_parse_error("Need positive number.", '\newenvironment{strangeparam}[', "-1]{}{}") lambda{@m.parse('\newenvironment{strangeparam}[a]{}{}')}.should raise_parse_error("Need positive number.", '\newenvironment{strangeparam}[', "a]{}{}") lambda{@m.parse('\newcommand{\valid}{OK} \invalid{\test}{NG}')}.should raise_parse_error("Syntax error.", '\newcommand{\valid}{OK} ', '\invalid{\test}{NG}') lambda{@m.parse('\newcommand{\valid}{OK} invalid{\test}{NG}')}.should raise_parse_error("Syntax error.", '\newcommand{\valid}{OK} ', 'invalid{\test}{NG}') lambda{@m.parse('\newcommand{\newcom}[test')}.should raise_parse_error("Option not closed.", '\newcommand{\newcom}', '[test') lambda{@m.parse('\newcommand{\newcom}[1][test')}.should raise_parse_error("Option not closed.", '\newcommand{\newcom}[1]', '[test') lambda{@m.parse('\newcommand{\newcom}[1][]{#1#2}')}.should raise_parse_error("Parameter \# too large.", '\newcommand{\newcom}[1][]{#1#', '2}') lambda{@m.parse('\newenvironment{newenv}[1][test')}.should raise_parse_error("Option not closed.", '\newenvironment{newenv}[1]', '[test') lambda{@m.parse('\newenvironment{newenv}[1][test')}.should raise_parse_error("Option not closed.", '\newenvironment{newenv}[1]', '[test') lambda{@m.parse('\newcommand{\newcom')}.should raise_parse_error("Block not closed.", '\newcommand', '{\newcom') lambda{@m.parse('\newcommand{\newcom}{test1{test2}{test3')}.should raise_parse_error("Block not closed.", '\newcommand{\newcom}', '{test1{test2}{test3') lambda{@m.parse('\newenvironment{newenv}[1][]{#1 #2}')}.should raise_parse_error("Parameter \# too large.", '\newenvironment{newenv}[1][]{#1 #', '2}') end it "#commands" do @m.commands("newcom").num.should == 0 @m.commands("paramcom").num.should == 2 @m.commands("no").should == nil end it "#expand_command" do @m.expand_command("not coommand", []).should == nil @m.expand_command("newcom", []).should == "test" @m.expand_command("newcom", ["dummy_param"]).should == "test" @m.expand_command("paramcom", ["1", "2"]).should == "param2 2, param1 1." @m.expand_command("paramcom", ["12", "34"]).should == "param2 34, param1 12." lambda{@m.expand_command("paramcom", ["12"])}.should raise_parse_error("Need more parameter.", "", "") lambda{@m.expand_command("paramcom", [])}.should raise_parse_error("Need more parameter.", "", "") end it "#environments" do @m.environments("newenv").num.should == 0 @m.environments("paramenv").num.should == 2 @m.environments("not_env").should == nil @m.environments("separated environment").num.should == 0 end it "#expand_environment" do @m.expand_environment('notregistered', "dummy", []).should == nil @m.expand_environment("newenv", "body", []).should == ' begin_newenv body end_newenv ' @m.expand_environment("paramenv", "body", ["1", "2"]).should == ' begin 1:1, 2:2 body end 2:2 1:1 ' @m.expand_environment("paramenv", "body", ["12", "34"]).should == ' begin 1:12, 2:34 body end 2:34 1:12 ' lambda{@m.expand_environment("paramenv", "body", ["1"])}.should raise_parse_error("Need more parameter.", "", "") lambda{@m.expand_environment("paramenv", "body", [])}.should raise_parse_error("Need more parameter.", "", "") @m.expand_environment("nothing", "body", []).should == ' body ' @m.expand_environment("separated environment", "body", []).should == ' sep body env ' @m.expand_environment("E", "body", []).should == ' N body V ' end it "#expand_with_options" do src = <<'EOT' \newcommand{\opt}[1][x]{#1} \newcommand{\optparam}[2][]{#1#2} \newenvironment{newenv}[1][x]{s:#1}{e:#1} \newenvironment{optenv}[2][]{s:#1}{e:#2} EOT m = MathML::LaTeX::Macro.new m.parse(src) m.expand_command("opt", []).should == 'x' m.expand_command("opt", [], "1").should == '1' m.expand_command("optparam", ["1"]).should == '1' m.expand_command("optparam", ["1"], "2").should == '21' m.expand_environment("newenv", "test", []).should == " s:x test e:x " m.expand_environment("newenv", "test", [], "1").should == " s:1 test e:1 " m.expand_environment("optenv", "test", ["1"]).should == " s: test e:1 " m.expand_environment("optenv", "test", ["1"], "2").should == " s:2 test e:1 " end end math_ml-0.14/spec/math_ml/latex/parser_spec.rb0000644000004100000410000006323212055512401021433 0ustar www-datawww-data# coding: utf-8 require "eim_xml/parser" require "eim_xml/dsl" require "math_ml" require "spec/util" require "math_ml/symbol/character_reference" require "math_ml/symbol/utf8" describe MathML::LaTeX::Parser do include MathML::Spec::Util def check_chr(tag, src) src.scan(/./) do |c| tag_re = Regexp.escape(tag) smml(c).should =~ /\A<#{tag_re}(\s+[^>]+)?>#{Regexp.escape(c)}<\/#{tag_re}>\z/ end end def check_hash(tag, hash) hash.each do |k, v| tag_re = Regexp.escape(tag) smml(k).should =~ /\A<#{tag_re}(\s+[^>]+)?>#{Regexp.escape(v)}<\/#{tag_re}>\z/ end end def check_entity(tag, hash) check_hash(tag, hash.inject({}){|r, i| r[i[0]]="&#{i[1]};"; r}) end it "Spec#strip_math_ml" do src = " b d " strip_math_ml(src).should == "bd" end describe "#parse" do it "should return math element" do ns = "http://www.w3.org/1998/Math/MathML" e = new_parser.parse("") e.should match(EimXML::Element.new(:math, :display=>"inline", "xmlns"=>ns)) e.attributes.keys.size.should == 2 e.contents.should be_empty e = new_parser.parse("", true) e.should match(EimXML::Element.new(:math, :display=>"block", "xmlns"=>ns)) e.attributes.keys.size.should == 2 e.contents.should be_empty e = new_parser.parse("", false) e.should match(EimXML::Element.new(:math, :display=>"inline", "xmlns"=>ns)) e.attributes.keys.size.should == 2 e.contents.should be_empty end it "should ignore space" do smml("{ a }").should == "a" end it "should process latex block" do lambda{smml("test {test} {test")}.should raise_parse_error("Block not closed.", "test {test} ", "{test") end it "should raise error when error happened" do src = 'a\hoge c' lambda{smml(src)}.should raise_parse_error("Undefined command.", "a", '\hoge c') src = '\sqrt\sqrt1' lambda{smml(src)}.should raise_parse_error("Syntax error.", '\sqrt\sqrt', "1") src = "a{b" lambda{smml(src)}.should raise_parse_error("Block not closed.", "a", "{b") end it "should process numerics" do smml('1234567890').should == "1234567890" smml('1.2').should == "1.2" smml('1.').should == "1." smml('.2').should == ".2" smml('1.2.3').should == "1.2.3" end it "should process alphabets" do smml("abc").should == "abc" check_chr("mi", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") end it "should process non alphabet command" do smml('\|').should == "∥" end it "should process space commands" do smml('\ ').should == "" smml('\quad').should == "" smml('\qquad').should == "" smml('\,').should == "" smml('\:').should == "" smml('\;').should == "" smml('\!').should == "" smml('~').should == "" end it "should process operators" do check_chr("mo", ",.+-*=/()[]|;:!") check_entity("mo", {"<"=>"lt", ">"=>"gt", '"'=>"quot"}) check_hash("mo", {'\backslash'=>'\\', '\%'=>'%', '\{'=>'{', '\}'=>'}', '\$'=>'$', '\#'=>'#'}) end describe "should process prime" do it "entity reference" do smml("a'").should == "a′" smml("a''").should == "a′′" smml("a'''").should == "a′′′" smml("'").should == "′" lambda{smml("a^b'")}.should raise_parse_error("Double superscript.", "a^b", "'") smml("a'^b").should == "a′b" smml("a'''^b").should == "a′′′b" smml("a'b").should == "a′b" end it "utf8" do @parser = MathML::LaTeX::Parser.new(:symbol=>MathML::Symbol::UTF8) smml("a'").should == "a′" smml("a'''").should == "a′′′" end it "character reference" do @parser = MathML::LaTeX::Parser.new(:symbol=>MathML::Symbol::CharacterReference) smml("a'").should == "a′" smml("a'''").should == "a′′′" end end it "should process sqrt" do smml('\sqrt a').should == "a" smml('\sqrt[2]3').should == "32" smml('\sqrt[2a]3').should == "32a" lambda{smml('\sqrt[12')}.should raise_parse_error("Option not closed.", '\sqrt', "[12") end it "should process subsup" do smml("a_b^c").should == "abc" smml("a_b").should == "ab" smml("a^b").should == "ab" smml("_a^b").should == "ab" lambda{smml("a_b_c")}.should raise_parse_error("Double subscript.", "a_b", "_c") lambda{smml("a^b^c")}.should raise_parse_error("Double superscript.", "a^b", "^c") lambda{smml("a_")}.should raise_parse_error("Subscript not exist.", "a_", "") lambda{smml("a^")}.should raise_parse_error("Superscript not exist.", "a^", "") end it "should process underover" do smml('\sum_a^b', true).should == "∑ab" smml('\sum_a^b').should == "∑ab" smml('\sum_a', true).should == "∑a" smml('\sum^a', true).should == "∑a" smml('\sum_a').should == "∑a" smml('\sum^a').should == "∑a" lambda{smml('\sum_b_c')}.should raise_parse_error("Double subscript.", '\sum_b', "_c") lambda{smml('\sum^b^c')}.should raise_parse_error("Double superscript.", '\sum^b', "^c") lambda{smml('\sum_')}.should raise_parse_error("Subscript not exist.", '\sum_', "") lambda{smml('\sum^')}.should raise_parse_error("Superscript not exist.", '\sum^', "") end it "should process font commands" do smml('a{\bf b c}d').should == "abcd" smml('\bf a{\it b c}d').should == "abcd" smml('a{\rm b c}d').should == "abcd" smml('a \mathbf{bc}d').should == "abcd" smml('\mathbf12').should == "12" smml('\bf a \mathit{bc} d').should == "abcd" smml('a\mathrm{bc}d').should == "abcd" smml('a \mathbb{b c} d').should == "a𝕓𝕔d" smml('a \mathscr{b c} d').should == "a𝒷𝒸d" smml('a \mathfrak{b c} d').should == "a𝔟𝔠d" smml('a \bm{bc}d').should == "abcd" smml('\bm ab').should == "ab" lambda{smml('\mathit')}.should raise_parse_error("Syntax error.", '\mathit', "") lambda{smml('\mathrm')}.should raise_parse_error("Syntax error.", '\mathrm', "") lambda{smml('\mathbf')}.should raise_parse_error("Syntax error.", '\mathbf', "") lambda{smml('\mathbb')}.should raise_parse_error("Syntax error.", '\mathbb', "") lambda{smml('\mathscr')}.should raise_parse_error("Syntax error.", '\mathscr', "") lambda{smml('\mathfrak')}.should raise_parse_error("Syntax error.", '\mathfrak', "") end it "should process mbox" do smml('a\mbox{b c}d').should == "ab cd" smml('\mbox{<>\'"&}').should == '<>'"&' end it "should process frac" do smml('\frac ab').should == "ab" smml('\frac12').should == "12" lambda{smml('\frac a')}.should raise_parse_error("Syntax error.", '\frac a', "") end it "should process environment" do lambda{smml('{\begin}rest')}.should raise_parse_error("Environment name not exist.", '{\begin', '}rest') lambda{smml('{\begin{array}{c}dummy}rest')}.should raise_parse_error('Matching \end not exist.', '{\begin{array}{c}dummy', '}rest') lambda{smml('\begin{array}c dummy\end{test}')}.should raise_parse_error("Environment mismatched.", '\begin{array}c dummy\end', "{test}") lambda{smml('\left(\begin{array}\right)')}.should raise_parse_error("Syntax error.", '\left(\begin{array}', '\right)') end it "should process array" do smml('\begin{array}{lrc} a & b & c \\\\ d & e & f \\\\ \end{array}').should == "abcdef" smml('\begin{array}{lrc}a&b&c\\\\d&e&f \end{array}').should == "abcdef" smml('\begin{array}{c}\end{array}').should == "" lambda{smml('\begin{array}\end{array}')}.should raise_parse_error('Syntax error.', '\begin{array}', '\end{array}') lambda{smml('\begin{array}{a}\end{array}')}.should raise_parse_error("Syntax error.", '\begin{array}{', 'a}\end{array}') lambda{smml('\begin{array}{cc}a\\\\b&c\end{array}')}.should raise_parse_error("Need more column.", '\begin{array}{cc}a', '\\\\b&c\end{array}') lambda{smml('\begin{array}{cc}a\end{array}')}.should raise_parse_error("Need more column.", '\begin{array}{cc}a', '\end{array}') lambda{smml('\begin{array}{c}a&\end{array}')}.should raise_parse_error("Too many column.", '\begin{array}{c}a', '&\end{array}') smml('\begin{array}{cc}&\end{array}').should == "" math_ml('\left\{\begin{array}ca_b\end{array}\right\}')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"{", :close=>"}"){ element :mrow do element :mtable do element :mtr do element :mtd do element :msub do element(:mi).add("a") element(:mi).add("b") end end end end end } smml('\begin{array}{@{a_1}l@bc@cr@d}A&B&C\end{array}').should == "a1AbBcCd" math_ml('\left\{\begin{array}ca_b\end{array}\right\}')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"{", :close=>"}"){ element :mrow do element :mtable do element :mtr do element :mtd do element :msub do element(:mi).add("a") element(:mi).add("b") end end end end end } smml('\begin{array}{c|c}a&b\\\\c&d\end{array}').should == "abcd" smml('\begin{array}{|c|}a\\\\c\end{array}').should == "ac" smml('\begin{array}{c}\hline c\end{array}').should == "c" smml('\begin{array}{c@acc}c&c&c\\\\\hline\end{array}').should == "cacc" smml('\begin{array}{c}\hline a\\\\b\\\\\hline\end{array}').should == "ab" end it "should parse \\left and \\right" do math_ml('\left(\frac12\right)')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"(", :close=>")"){ element :mrow do element :mfrac do element(:mn).add("1") element(:mn).add("2") end end } math_ml('\left \lfloor a\right \rfloor')[0].should =~ EimXML::DSL.element(:mfenced, :open=>EimXML::PCString.new("⌊", true), :close=>EimXML::PCString.new("⌋", true)){ element :mrow do element(:mi).add("a") end } math_ml('\left \{ a \right \}')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"{", :close=>"}"){ element :mrow do element(:mi).add("a") end } math_ml('\left\{\begin{array}c\begin{array}ca\end{array}\end{array}\right\}')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"{", :close=>"}"){ element :mrow do element :mtable do element :mtr do element :mtd do element :mtable do element :mtr do element :mtd do element(:mi).add("a") end end end end end end end } math_ml('\left(\sum_a\right)')[0].should =~ EimXML::DSL.element(:mfenced, :open=>"(", :close=>")"){ element :mrow do element :msub do element(:mo).add(EimXML::PCString.new("∑", true)) element(:mi).add("a") end end } math_ml('\left(\sum_a\right)', true)[0].should =~ EimXML::DSL.element(:mfenced, :open=>"(", :close=>")"){ element :mrow do element :munder do element(:mo).add(EimXML::PCString.new("∑", true)) element(:mi).add("a") end end } lambda{smml('\left(test')}.should raise_parse_error("Brace not closed.", '\left', '(test') math_ml('\left\|a\right\|')[0].should =~ EimXML::DSL.element(:mfenced, :open=>EimXML::PCString.new("∥", true), :close=>EimXML::PCString.new("∥", true)){ element :mrow do element(:mi).add("a") end } lambda{smml('\left')}.should raise_parse_error("Need brace here.", '\left', "") end it "should parse overs" do smml('\hat a').should == "aˆ" smml('\hat12').should == "1ˆ2" lambda{smml('{\hat}a')}.should raise_parse_error("Syntax error.", '{\hat', '}a') end it "should parse unders" do smml('\underline a').should == "a¯" smml('\underline12').should == "1¯2" lambda{smml('{\underline}a')}.should raise_parse_error("Syntax error.", '{\underline', '}a') end it "should parse stackrel" do smml('\stackrel\to=').should == "=→" smml('\stackrel12').should == "21" end it "should parse comment" do smml('a%b').should == "a" end it "should parse entity" do p = new_parser lambda{smml('\entity{therefore}', false, p)}.should raise_parse_error("Unregistered entity.", '\entity{', "therefore}") p.unsecure_entity = true smml('\entity{therefore}', false, p).should == "∴" p.unsecure_entity = false lambda{smml('\entity{therefore}', false, p)}.should raise_parse_error("Unregistered entity.", '\entity{', "therefore}") p.add_entity(['therefore']) smml('\entity{therefore}', false, p).should == "∴" end it "should parse backslash" do smml('\\\\').should == "
" end it "can be used with macro" do macro = <<'EOS' \newcommand{\root}[2]{\sqrt[#1]{#2}} \newcommand{\ROOT}[2]{\sqrt[#1]#2} \newenvironment{braced}[2]{\left#1}{\right#2} \newenvironment{sq}[2]{\sqrt[#2]{#1}}{\sqrt#2} \newcommand{\R}{\mathbb R} \newenvironment{BB}{\mathbb A}{\mathbb B} EOS p = new_parser p.macro.parse(macro) smml('\root12', false, p).should == "21" smml('\root{12}{34}', false, p).should == "3412" smml('\ROOT{12}{34}', false, p).should == "3124" lambda{smml('\root', false, p)}.should raise_parse_error('Error in macro(Need more parameter. "").', '', '\root') math_ml('\begin{braced}{|}{)}\frac12\end{braced}', false, p)[0].should =~ EimXML::DSL.element(:mfenced, :open=>"|", :close=>")"){ element(:mrow) do element(:mfrac) do element(:mn).add("1") element(:mn).add("2") end end } smml('\begin{sq}{12}{34}a\end{sq}', false, p).should == "1234a34" lambda{smml('\begin{braced}', false, p)}.should raise_parse_error("Need more parameter.", '\begin{braced}', "") lambda{smml('\begin{braced}123', false, p)}.should raise_parse_error('Matching \end not exist.', '\begin{braced}', "123") lambda{smml('\begin{braced}123\end{brace}', false, p)}.should raise_parse_error("Environment mismatched.", '\begin{braced}123\end', '{brace}') smml('\R', false, p).should == "ℝ" smml('\begin{BB}\end{BB}', false, p).should == "𝔸𝔹" end it "should raise error when macro define circular reference" do macro = <<'EOT' \newcommand{\C}{\C} \newenvironment{E}{\begin{E}}{\end{E}} \newcommand{\D}{\begin{F}\end{F}} \newenvironment{F}{\D}{} EOT ps = new_parser ps.macro.parse(macro) lambda{smml('\C', false, ps)}.should raise_parse_error("Circular reference.", "", '\C') lambda{smml('\begin{E}\end{E}', false, ps)}.should raise_parse_error("Circular reference.", "", '\begin{E}\end{E}') lambda{smml('\D', false, ps)}.should raise_parse_error("Circular reference.", "", '\D') lambda{smml('\begin{F}\end{F}', false, ps)}.should raise_parse_error("Circular reference.", "", '\begin{F}\end{F}') end it "should raise error when macro uses undefined command" do macro = <<'EOT' \newcommand{\C}{\dummy} \newenvironment{E}{\dummy}{} EOT ps = new_parser ps.macro.parse(macro) lambda{smml('\C', false, ps)}.should raise_parse_error('Error in macro(Undefined command. "\dummy").', "", '\C') lambda{smml('\C', false, ps)}.should raise_parse_error('Error in macro(Undefined command. "\dummy").', "", '\C') lambda{smml('\begin{E}\end{E}', false, ps)}.should raise_parse_error('Error in macro(Undefined command. "\dummy").', '', '\begin{E}\end{E}') lambda{smml('\begin{E}\end{E}', false, ps)}.should raise_parse_error('Error in macro(Undefined command. "\dummy").', "", '\begin{E}\end{E}') end it "can be used with macro with option" do macro = <<'EOS' \newcommand{\opt}[1][x]{#1} \newcommand{\optparam}[2][]{#1#2} \newenvironment{newenv}[1][x]{#1}{#1} \newenvironment{optenv}[2][]{#1}{#2} EOS p = new_parser p.macro.parse(macro) smml('\opt a', false, p).should == "xa" smml('\opt[0] a', false, p).should == "0a" smml('\optparam a', false, p).should == "a" smml('\optparam[0] a', false, p).should == "0a" smml('\begin{newenv}a\end{newenv}', false, p).should == "xax" smml('\begin{newenv}[0]a\end{newenv}', false, p).should == "0a0" smml('\begin{optenv}0a\end{optenv}', false, p).should == "a0" smml('\begin{optenv}[0]1a\end{optenv}', false, p).should == "0a1" end it "should parse matrix environment" do smml('\begin{matrix}&&\\\\&\end{matrix}').should == "" lambda{smml('\begin{matrix}&&\\\\&\end{mat}')}.should raise_parse_error("Environment mismatched.", '\begin{matrix}&&\\\\&\end', "{mat}") lambda{smml('\begin{matrix}&&\\\\&')}.should raise_parse_error("Matching \\end not exist.", '\begin{matrix}&&\\\\&', '') smml('\begin{matrix}\begin{matrix}a&b\\\\c&d\end{matrix}&1\\\\0&1\\\\\end{matrix}').should == "abcd101" smml('\begin{matrix}\end{matrix}').should == "" smml('\begin{matrix}\hline a\\\\b\\\\\hline\end{matrix}').should == "ab" smml('\begin{smallmatrix}\end{smallmatrix}').should == "" math_ml('\begin{pmatrix}\end{pmatrix}')[0].should =~ EimXML::Element.new(:mfenced, :open=>"(", :close=>")") math_ml('\begin{bmatrix}\end{bmatrix}')[0].should =~ EimXML::Element.new(:mfenced, :open=>"[", :close=>"]") math_ml('\begin{Bmatrix}\end{Bmatrix}')[0].should =~ EimXML::Element.new(:mfenced, :open=>"{", :close=>"}") math_ml('\begin{vmatrix}\end{vmatrix}')[0].should =~ EimXML::Element.new(:mfenced, :open=>"|", :close=>"|") math_ml('\begin{Vmatrix}\end{Vmatrix}')[0].should =~ EimXML::Element.new(:mfenced, :open=>EimXML::PCString.new("∥", true), :close=>EimXML::PCString.new("∥", true)) end it "can be used in safe mode" do Thread.start do $SAFE=1 $SAFE.should == 1 lambda{smml('\alpha'.taint)}.should_not raise_error end.join $SAFE.should == 0 end it "should parse symbols" do smml('\precneqq').should == "⪵" end end context ".new should accept symbol table" do it "character reference" do @parser = MathML::LaTeX::Parser.new(:symbol=>MathML::Symbol::CharacterReference) smml('\alpha').should == "α" smml('\mathbb{abcABC}').should == "𝕒𝕓𝕔𝔸𝔹ℂ" smml('\mathscr{abcABC}').should == "𝒶𝒷𝒸𝒜ℬ𝒞" smml('\mathfrak{abcABC}').should == "𝔞𝔟𝔠𝔄𝔅ℭ" end it "utf8" do @parser = MathML::LaTeX::Parser.new(:symbol=>MathML::Symbol::UTF8) smml('\alpha').should == "α" smml('\mathbb{abcABC}').should == "𝕒𝕓𝕔𝔸𝔹ℂ" smml('\mathscr{abcABC}').should == "𝒶𝒷𝒸𝒜ℬ𝒞" smml('\mathfrak{abcABC}').should == "𝔞𝔟𝔠𝔄𝔅ℭ" end end context "#symbol_table" do it "should return when .new was given name of symbol-module" do ps = MathML::LaTeX::Parser symbol = MathML::Symbol ps.new(:symbol=>symbol::UTF8).symbol_table.should == symbol::UTF8 ps.new(:symbol=>symbol::EntityReference).symbol_table.should == symbol::EntityReference ps.new(:symbol=>symbol::CharacterReference).symbol_table.should == symbol::CharacterReference ps.new(:symbol=>:utf8).symbol_table.should == symbol::UTF8 ps.new(:symbol=>:entity).symbol_table.should == symbol::EntityReference ps.new(:symbol=>:character).symbol_table.should == symbol::CharacterReference ps.new.symbol_table.should == symbol::EntityReference ps.new(:symbol=>nil).symbol_table.should == symbol::EntityReference end context "should return default symbol module" do before do @loaded_features = $LOADED_FEATURES.dup $LOADED_FEATURES.delete_if{|i| i=~/math_ml/} if ::Object.const_defined?(:MathML) @MathML = ::Object.const_get(:MathML) ::Object.module_eval{remove_const(:MathML)} end end after do $LOADED_FEATURES.clear $LOADED_FEATURES.push(@loaded_features.shift) until @loaded_features.empty? if @MathML ::Object.module_eval{remove_const(:MathML)} ::Object.const_set(:MathML, @MathML) end end it "character entity reference version by default" do require("math_ml").should be_true MathML::LaTeX::Parser.new.symbol_table.should == MathML::Symbol::EntityReference end describe "character entity reference version when set by requiring" do it do require("math_ml/symbol/entity_reference").should be_true MathML::LaTeX::Parser.new.symbol_table.should == MathML::Symbol::EntityReference end end describe "utf8 version when set by requiring" do it do require("math_ml/symbol/utf8").should be_true MathML::LaTeX::Parser.new.symbol_table.should == MathML::Symbol::UTF8 end end describe "numeric character reference version when set by requiring" do it do require("math_ml/symbol/character_reference").should be_true MathML::LaTeX::Parser.new.symbol_table.should == MathML::Symbol::CharacterReference end end end end end math_ml-0.14/spec/math_ml/element_spec.rb0000644000004100000410000000113512055512401020445 0ustar www-datawww-datarequire "math_ml" describe MathML::Element do it "#display_style and #as_display_style" do MathML::Element.new("test").display_style.should == nil e = MathML::Element.new("test") r = e.as_display_style r.should equal(e) e.display_style.should be_true end it "#pop" do e = MathML::Element.new("super") s = MathML::Element.new("sub") e.pop.should be_nil e << s e.pop.should equal(s) e.pop.should be_nil e << "text" e.pop.should == "text" e.pop.should be_nil end it "#to_s" do e = MathML::Element.new("e") e << "test<" e.to_s.should == "test<" end end math_ml-0.14/spec/math_ml/string_spec.rb0000644000004100000410000000166512055512401020332 0ustar www-datawww-datarequire "math_ml/string" describe MathML::String do it ".mathml_latex_parser" do MathML::String.mathml_latex_parser.should be_kind_of(MathML::LaTeX::Parser) mlp = MathML::LaTeX::Parser.new MathML::String.mathml_latex_parser = mlp MathML::String.mathml_latex_parser.should equal(mlp) lambda{MathML::String.mathml_latex_parser=String}.should raise_error(TypeError) MathML::String.mathml_latex_parser.should equal(mlp) MathML::String.mathml_latex_parser = nil MathML::String.mathml_latex_parser.should be_kind_of(MathML::LaTeX::Parser) MathML::String.mathml_latex_parser.should_not equal(mlp) end end describe String do it "#parse" do mlp = MathML::LaTeX::Parser.new "".to_mathml.to_s.should == mlp.parse("").to_s "".to_mathml(true).to_s.should == mlp.parse("", true).to_s MathML::String.mathml_latex_parser.macro.parse(<<'EOT') \newcommand{\test}{x} EOT '\test'.to_mathml.to_s.should == mlp.parse("x").to_s end end math_ml-0.14/spec/util.rb0000644000004100000410000000176312055512401015345 0ustar www-datawww-datarequire "rspec" module MathML module Spec module Util def raise_parse_error(message, done, rest) begin matcher_class = RSpec::Matchers::DSL::Matcher rescue NameError matcher_class = RSpec::Matchers::Matcher end matcher_class.new(:raise_parse_error){ match do |given| begin given.call @error = nil rescue Exception @error = $! end @error.is_a?(MathML::LaTeX::ParseError) && [@error.message, @error.done, @error.rest] == [message, done, rest] end }.for_expected end def new_parser MathML::LaTeX::Parser.new end def math_ml(src, display_style=false, parser=nil) parser ||= @parser || new_parser parser.parse(src, display_style) end def strip_math_ml(math_ml) math_ml.to_s.gsub(/>\s*/, ">").gsub(/\s*]*>(.*)<\/math>\Z/m, 1] end def smml(src, display_style=false, parser=nil) strip_math_ml(math_ml(src, display_style, parser)) end end end end math_ml-0.14/spec/math_ml_spec.rb0000644000004100000410000000060312055512401017013 0ustar www-datawww-datarequire "math_ml" describe MathML do it "should not raise error when math_ml.rb is required twice" do if require("lib/math_ml") lambda{MathML::LaTeX::Parser.new}.should_not raise_error end end it ".pcstring" do MathML.pcstring('<>&"\'').to_s.should == "<>&"'" MathML.pcstring('&"\'', true).to_s.should == '&"\'' end end math_ml-0.14/metadata.yml0000644000004100000410000000367012055512401015413 0ustar www-datawww-data--- !ruby/object:Gem::Specification name: math_ml version: !ruby/object:Gem::Version hash: 23 prerelease: segments: - 0 - 14 version: "0.14" platform: ruby authors: - KURODA Hiraku autorequire: bindir: bin cert_chain: [] date: 2012-11-11 00:00:00 +09:00 default_executable: dependencies: - !ruby/object:Gem::Dependency name: eim_xml prerelease: false requirement: &id001 !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 3 segments: - 0 version: "0" type: :runtime version_requirements: *id001 description: email: hiraku@hinet.mydns.jp executables: [] extensions: [] extra_rdoc_files: [] files: - Rakefile - Rakefile.utirake - lib/math_ml/string.rb - lib/math_ml/element.rb - lib/math_ml/latex/builtin.rb - lib/math_ml/latex/builtin/symbol.rb - lib/math_ml/util.rb - lib/math_ml/symbol/utf8.rb - lib/math_ml/symbol/character_reference.rb - lib/math_ml/symbol/entity_reference.rb - lib/math_ml/latex.rb - lib/math_ml.rb - spec/math_ml_spec.rb - spec/util.rb - spec/math_ml/latex/parser_spec.rb - spec/math_ml/latex/scanner_spec.rb - spec/math_ml/latex/macro_spec.rb - spec/math_ml/string_spec.rb - spec/math_ml/util_spec.rb - spec/math_ml/element_spec.rb has_rdoc: true homepage: http://mathml.rubyforge.org/ licenses: [] post_install_message: rdoc_options: [] require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 3 segments: - 0 version: "0" required_rubygems_version: !ruby/object:Gem::Requirement none: false requirements: - - ">" - !ruby/object:Gem::Version hash: 25 segments: - 1 - 3 - 1 version: 1.3.1 requirements: [] rubyforge_project: mathml rubygems_version: 1.6.2 signing_key: specification_version: 3 summary: MathML Library test_files: [] math_ml-0.14/Rakefile.utirake0000644000004100000410000002061012055512401016211 0ustar www-datawww-data# Utility for Rake # # Copyright (C) 2008, KURODA Hiraku # You can redistribute it and/or modify it under GPL3. require "rake/clean" require "rake/testtask" require "rake/contrib/rubyforgepublisher" require "rubygems/package_task" if File.exist?("Gemfile") begin require "bundler" Bundler.setup rescue LoadError if $!.message =~ / bundler\z/ warn "Warning: Bundler is not found." else raise end end end class UtiRake include Rake::DSL def self.setup(opt={}, &proc) ur = new ur.setup(opt, &proc) rescue puts $!.class, $!.message, $!.backtrace end attr_reader :opt, :spec_proc, :cucumber_proc, :rdoc_proc, :gemspec_proc, :package_proc, :rcov_spec_proc def setup(opt={}, &proc) @opt = opt directory "external" CLEAN << "coverage" << "coverage.spec" << "coverage.cuke" << "doc" CLOBBER << "external" instance_eval(&proc) if proc if need_spec? begin @rspec2_flg = false require "rspec/core/rake_task" @rspec2_flg = true rescue LoadError require "spec/rake/spectask" end define_spec_task end if need_cucumber? require "cucumber/rake/task" define_cucumber_task end define_rdoc_task define_rcov_task define_package_task define_here_dependency define_alias_task if @alias_task end def rspec2?; @rspec2_flg; end def spec_task rspec2? ? RSpec::Core::RakeTask : Spec::Rake::SpecTask end def need_spec? File.directory?("spec") end def need_cucumber? File.directory?("features") end def spec(&proc) @spec_proc = proc end def cucumber(&proc) @cucumber_proc = proc end def rdoc(&proc) @rdoc_proc = proc end def gemspec(&proc) @gemspec_proc = proc end def rcov_spec(&proc) @rcov_spec_proc = proc end def package(&proc) @package_proc = proc end def no_here(task) @no_here_task = task end def no_here_task @no_here_task || "spec:lump" end def alias_task @alias_task = true end def hg(cmd) sh "hg #{cmd.to_s}" end def external(base_url, *libs) libs = libs.first if libs.first.is_a?(Array) namespace :external do directory "external/lib" libs.each do |lib| libdir = "external/#{lib}" file libdir => "external/lib" do if File.exist?("../#{lib}") Dir.chdir("external") do ln_s "../../#{lib}", "./", :force=>true end end hg "clone #{File.join(base_url, lib)} #{libdir}" unless File.exist?(libdir) Dir["#{libdir}/lib/*"].each do |f| base = File.basename(f) cd "external/lib" do ln_s "../#{lib}/lib/#{base}", "./" end end end if File.exist?(libdir) Dir["#{libdir}/lib/*"].each do |f| base = File.basename(f) file "external/lib/#{base}" => "external/lib" do cd "external/lib" do ln_s "../#{lib}/lib/#{base}", "./" end end task :setup => "external/lib/#{base}" end end desc "Setup external libraries" task :setup=>libdir end task :rake => :setup do libs.each do |lib| Dir.chdir "external/#{lib}" do sh "rake" end end end end @external = true end def external?; @external; end def define_rdoc_task begin require "rdoc/task" rescue LoadError return end Rake::RDocTask.new(:rdoc) do |rdoc| rdoc.options << "-S" rdoc.options << "-w" << "3" rdoc.options << "-c" << "UTF-8" rdoc.rdoc_files.include("lib/**/*.rb") rdoc_proc.call(rdoc) if rdoc_proc end task :doc do remove_entry_secure "doc" if File.directory?("doc") sh "rdoc -S -w 3 -c UTF-8 -d -x external" end end def define_package_task spec = Gem::Specification.new do |s| s.platform = Gem::Platform::RUBY s.files = FileList["Rakefile*", "lib/**/*", "spec/**/*"] s.version = "0.0.0.noversion" gemspec_proc.call(s) if gemspec_proc end gem = Gem::PackageTask.new(spec) do |t| t.need_tar_gz = true package_proc.call(t) if package_proc end task "utirake:copy_for_package" do mv "Rakefile.utirake", "Rakefile.utirake_#{$$}" cp "external/utirake/utirake.rb", "Rakefile.utirake" end file gem.package_dir_path => "utirake:copy_for_package" task :gem do rm "Rakefile.utirake" mv "Rakefile.utirake_#{$$}", "Rakefile.utirake" end end def publish(project_name, user_id) task :publish => "rdoc" do yield if block_given? Rake::RubyForgePublisher.new(project_name, user_id).upload end end FILE_SORT = lambda{|a, b| File.mtime(a)<=>File.mtime(b)} def spec_files @spec_files ||= FileList["./spec/**/*_spec.rb"].sort(&FILE_SORT).reverse end def set_spec_opts(spec) spec.verbose = false if rspec2? spec.rspec_opts ||= [] spec.rspec_opts << "-c" spec.rspec_opts << "-I" << "." << "-I" << "./lib" << "-I" << "./external/lib" else spec.spec_opts << "-c" spec.libs << "." << "./lib" << "./external/lib" end end def define_spec_task task :spec => "spec:apart" namespace :spec do spec_files.each do |f| desc "" spec_task.new(:apart) do |s| if rspec2? s.pattern = f else s.spec_files = FileList[f] end set_spec_opts(s) spec_proc.call(s) if spec_proc end end task(:apart).comment = "Run all specs separately" desc "Run all specs in a lump" spec_task.new(:lump) do |s| s.spec_files = spec_files unless rspec2? set_spec_opts(s) spec_proc.call(s) if spec_proc end desc "Run all specs to profile" spec_task.new(:profile) do |s| set_spec_opts(s) if rspec2? s.rspec_opts << "-p" else s.spec_opts << "-f" << "profile" end end `grep -sRn '#[[:space:]]*here\\([[:space:]]\\|$\\)' --include='*.rb' spec`.split(/\n/).map{|l| next nil unless l=~/\A(.*?):(\d+):/ [$1, $2.to_i] }.compact.sort{|a, b| FILE_SORT.call(a[0], b[0])}.reverse.each do |file, line| desc "" spec_task.new(:here) do |s| set_spec_opts(s) if rspec2? s.pattern = file s.rspec_opts << "-l#{line}" else s.spec_files = [file] s.spec_opts << "-l#{line}" end spec_proc.call(s) if spec_proc end end task :no_here => no_here_task end end def set_cucumber_opts(task) task.libs << "." cucumber_proc.call(task) if cucumber_proc end def define_cucumber_task Cucumber::Rake::Task.new do |t| set_cucumber_opts(t) end unless `grep -sRn '^[[:space:]]*@here$' features`.empty? Cucumber::Rake::Task.new("cucumber:here") do |t| t.cucumber_opts = %w[--tags @here] set_cucumber_opts(t) end end task "cucumber:no_here" => :cucumber end def define_here_dependency unless Rake::Task.task_defined?("spec:here") || Rake::Task.task_defined?("cucumber:here") task "spec:here" => "spec:no_here" if need_spec? && !Rake::Task.task_defined?("spec:here") task "cucumber:here" => "cucumber:no_here" if need_cucumber? && !Rake::Task.task_defined?("cucumber:here") end task("spec:here").comment = "Run spec only marked '# here'" task("cucumber:here").comment = "only tagged '@here'" end def rcov_opts(t, aggregation) t.rcov_opts ||= [] t.rcov_opts << "-I" << "./spec:./lib:./external/lib" t.rcov_opts << "--exclude" << "gems\/,features\/,external\/" t.rcov_opts << "--aggregate" << "coverage.data" if aggregation t.rcov = true end def define_rcov_each_task(aggregation) if need_spec? spec_task.new do |t| t.verbose = false rcov_opts(t, aggregation) if rspec2? t.rcov_opts << "-o" << "coverage.spec" unless aggregation else set_spec_opts(t) t.spec_files = spec_files t.rcov_dir = "coverage.spec" unless aggregation end rcov_spec_proc.call(t) if rcov_spec_proc end else task "spec" end if need_cucumber? Cucumber::Rake::Task.new do |t| set_cucumber_opts(t) rcov_opts(t, aggregation) t.rcov_opts << "-o" << "coverage.cuke" unless aggregation end else task "cucumber" end end def define_rcov_task namespace :rcov do define_rcov_each_task(false) end desc "Run specs and Cucumber using RCov" task "rcov:lump" do rm "coverage.data" if File.exist?("coverage.data") ns = namespace do define_rcov_each_task(true) end ns.tasks.each do |t| t.invoke end rm "coverage.data" end task "rcov:all" => %w[rcov:spec rcov:cucumber rcov:lump] end def define_alias_task if Rake::Task.task_defined?("spec:apart") task :apart => "spec:apart" task :lump => "spec:lump" task :here => "spec:here" task :profile => "spec:profile" end task :here => "cucumber:here" if Rake::Task.task_defined?("cucumber:here") end end math_ml-0.14/lib/0000755000004100000410000000000012055512401013650 5ustar www-datawww-datamath_ml-0.14/lib/math_ml.rb0000644000004100000410000000076712055512401015630 0ustar www-datawww-data# MathML Library # # Copyright (C) 2005, KURODA Hiraku # You can redistribute it and/or modify it under GPL2. require "strscan" module MathML require "eim_xml" class XMLElement < EimXML::Element def pop @contents.pop end end def self.pcstring(s, encoded=false) s.is_a?(EimXML::PCString) ? s : EimXML::PCString.new(s, encoded) end class Error < StandardError; end end require "math_ml/element" require "math_ml/symbol/entity_reference" require "math_ml/latex" math_ml-0.14/lib/math_ml/0000755000004100000410000000000012055512401015271 5ustar www-datawww-datamath_ml-0.14/lib/math_ml/element.rb0000644000004100000410000000663012055512401017254 0ustar www-datawww-datamodule MathML class Element < XMLElement attr_reader :display_style def as_display_style @display_style = true self end end module Variant NORMAL = "normal" BOLD = "bold" BOLD_ITALIC = "bold-italic" def variant=(v) self["mathvariant"] = v end end module Align CENTER = "center" LEFT = "left" RIGHT = "right" end module Line SOLID = "solid" NONE = "none" end class Math < XMLElement def initialize(display_style) super("math", "xmlns"=>"http://www.w3.org/1998/Math/MathML") self[:display] = display_style ? "block" : "inline" end end class Row < Element def initialize super("mrow") end end class None < Element def initialize super("none") end end class Space < Element def initialize(width) super("mspace", "width"=>width) end end class Fenced < Element attr_reader :open, :close def initialize super("mfenced") end def open=(o) o = "" if o.to_s=="." || !o o = "{" if o.to_s=="\\{" self[:open] = MathML.pcstring(o, true) end def close=(c) c = "" if c.to_s=="." || !c c = "}" if c.to_s=="\\}" self[:close] = MathML.pcstring(c, true) end end class Frac < Element def initialize(numerator, denominator) super("mfrac") self << numerator self << denominator end end class SubSup < Element attr_reader :sub, :sup, :body def initialize(display_style, body) super("mrow") as_display_style if display_style @body = body end def update_name if @sub || @sup name = "m" name << (@sub ? (@display_style ? "under" : "sub") : "") name << (@sup ? (@display_style ? "over" : "sup") : "") else name = "mrow" end self.name = name end private :update_name def update_contents contents.clear contents << @body contents << @sub if @sub contents << @sup if @sup end private :update_contents def update update_name update_contents end private :update def sub=(sub) @sub = sub update end def sup=(sup) @sup = sup update end end class Over < Element def initialize(base, over) super("mover") self << base << over end end class Under < Element def initialize(base, under) super("munder") self << base << under end end class Number < Element def initialize super("mn") end end class Identifier < Element def initialize super("mi") end end class Operator < Element def initialize super("mo") end end class Text < Element def initialize super("mtext") end end class Sqrt < Element def initialize super("msqrt") end end class Root < Element def initialize(index, base) super("mroot") self << base self << index end end class Table < Element def initialize super("mtable") end def set_align_attribute(name, a, default) if a.is_a?(Array) && a.size>0 value = "" a.each do |i| value << " "+i end if value =~ /^( #{default})*$/ @attributes.delete(name) else @attributes[name] = value.strip end else @attributes.delete(name) end end def aligns=(a) set_align_attribute("columnalign", a, Align::CENTER) end def vlines=(a) set_align_attribute("columnlines", a, Line::NONE) end def hlines=(a) set_align_attribute("rowlines", a, Line::NONE) end end class Tr < Element def initialize super("mtr") end end class Td < Element def initialize super("mtd") end end end math_ml-0.14/lib/math_ml/latex/0000755000004100000410000000000012055512401016406 5ustar www-datawww-datamath_ml-0.14/lib/math_ml/latex/builtin.rb0000644000004100000410000000012512055512401020377 0ustar www-datawww-datamodule MathML::LaTeX module Builtin end end require "math_ml/latex/builtin/symbol" math_ml-0.14/lib/math_ml/latex/builtin/0000755000004100000410000000000012055512401020054 5ustar www-datawww-datamath_ml-0.14/lib/math_ml/latex/builtin/symbol.rb0000644000004100000410000002741712055512401021721 0ustar www-datawww-datamodule MathML::LaTeX::Builtin module Symbol MAP = { "{"=>[[:s,:o],""], "}"=>[[:s,:o],""], "#"=>[[:s,:o],""], "$"=>[[:s,:o],""], "&"=>[[:s,:o],:amp], "_"=>[[:s,:o],""], "%"=>[[:s,:o],""], ","=>nil, "varepsilon"=>[[:s,:I],], "mathdollar"=>[[:s,:o],"$"], "lbrace"=>[[:s],], "rbrace"=>[[:s],], "P"=>[[:s,:o],:para], "mathparagraph"=>[[:s,:o],:para], "S"=>[[:s,:o],:sect], "mathsection"=>[[:s,:o],:sect], "dag"=>[[:s,:o],:dagger], "dagger"=>[[:s],], "ddag"=>[[:s,:o],:ddagger], "ddagger"=>[[:s],], "copyright"=>[[:s,:o],:copy], "pounds"=>[[:s,:o],:pound], "mathsterling"=>[[:s,:o],:pound], "dots"=>[[:s,:o],:mldr], "mathellipsis"=>[[:s,:o],:mldr], "ldots"=>[[:s,:o],:mldr], "ensuremath"=>nil, "|"=>[[:s,:o],:DoubleVerticalBar], "mho"=>[[:s],], "Join"=>[[:s,:o],:bowtie], "Box"=>[[:s,:o],:square], "Diamond"=>[[:s],], "leadsto"=>[[:s,:o],:zigrarr], "sqsubset"=>[[:s],], "sqsupset"=>[[:s],], "lhd"=>[[:s,:o],:vltri], "unlhd"=>[[:s,:o],:ltrie], "rhd"=>[[:s,:o],:vrtri], "unrhd"=>[[:s,:o],:rtrie], "log"=>[[:s,:i],""], "lg"=>[[:s,:i],""], "ln"=>[[:s,:i],""], "lim"=>[[:u,:i],""], "limsup"=>[[:u,:i],"lim sup"], "liminf"=>[[:u,:i],"lim inf"], "sin"=>[[:s,:i],""], "arcsin"=>[[:s,:i],""], "sinh"=>[[:s,:i],""], "cos"=>[[:s,:i],""], "arccos"=>[[:s,:i],""], "cosh"=>[[:s,:i],""], "tan"=>[[:s,:i],""], "arctan"=>[[:s,:i],""], "tanh"=>[[:s,:i],""], "cot"=>[[:s,:i],""], "coth"=>[[:s,:i],""], "sec"=>[[:s,:i],""], "csc"=>[[:s,:i],""], "max"=>[[:u,:i],""], "min"=>[[:u,:i],""], "sup"=>[[:u,:i],""], "inf"=>[[:u,:i],""], "arg"=>[[:s,:i],""], "ker"=>[[:s,:i],""], "dim"=>[[:s,:i],""], "hom"=>[[:s,:i],""], "det"=>[[:u,:i],""], "exp"=>[[:s,:i],""], "Pr"=>[[:u,:i],""], "gcd"=>[[:u,:i],""], "deg"=>[[:s,:i],""], "prime"=>[[:s],], "alpha"=>[[:s,:I],], "beta"=>[[:s,:I],], "gamma"=>[[:s,:I],], "delta"=>[[:s,:I],], "epsilon"=>[[:s,:I],], "zeta"=>[[:s,:I],], "eta"=>[[:s,:I],], "theta"=>[[:s,:I],], "iota"=>[[:s,:I],], "kappa"=>[[:s,:I],], "lambda"=>[[:s,:I],], "mu"=>[[:s,:I],], "nu"=>[[:s,:I],], "xi"=>[[:s,:I],], "pi"=>[[:s,:I],], "rho"=>[[:s,:I],], "sigma"=>[[:s,:I],], "tau"=>[[:s,:I],], "upsilon"=>[[:s,:I],], "phi"=>[[:s,:I],], "chi"=>[[:s,:I],], "psi"=>[[:s,:I],], "omega"=>[[:s,:I],], "vartheta"=>[[:s,:I],], "varpi"=>[[:s,:I],], "varrho"=>[[:s,:I],], "varsigma"=>[[:s,:I],], "varphi"=>[[:s,:I],], "Gamma"=>[[:s,:i],], "Delta"=>[[:s,:i],], "Theta"=>[[:s,:i],], "Lambda"=>[[:s,:i],], "Xi"=>[[:s,:i],], "Pi"=>[[:s,:i],], "Sigma"=>[[:s,:i],], "Upsilon"=>[[:s,:i],:Upsi], "Phi"=>[[:s,:i],], "Psi"=>[[:s,:i],], "Omega"=>[[:s,:i],], "aleph"=>[[:s,:i],], "hbar"=>[[:s,:i],:hslash], "imath"=>[[:s,:i],], "jmath"=>[[:s,:i],], "ell"=>[[:s],], "wp"=>[[:s],], "Re"=>[[:s,:i],], "Im"=>[[:s,:i],], "partial"=>[[:s,:o],:part], "infty"=>[[:s,:n],:infin], "emptyset"=>[[:s,:i],:empty], "nabla"=>[[:s,:i],], "surd"=>[[:s,:o],:Sqrt], "top"=>[[:s],], "bot"=>[[:s],], "angle"=>[[:s],], "not"=>[[:s],], "triangle"=>[[:s],], "forall"=>[[:s],], "exists"=>[[:s,:o],:exist], "neg"=>[[:s,:o],:not], "lnot"=>[[:s,:o],:not], "flat"=>[[:s],], "natural"=>[[:s],], "sharp"=>[[:s],], "clubsuit"=>[[:s],], "diamondsuit"=>[[:s],], "heartsuit"=>[[:s],], "spadesuit"=>[[:s],], "coprod"=>[[:u],], "bigvee"=>[[:u],], "bigwedge"=>[[:u],], "biguplus"=>[[:u],], "bigcap"=>[[:u],], "bigcup"=>[[:u],], "intop"=>[[:u,:o],:int], "int"=>[[:s,:o],], "prod"=>[[:u],], "sum"=>[[:u],], "bigotimes"=>[[:u],], "bigoplus"=>[[:u],], "bigodot"=>[[:u],], "ointop"=>[[:u,:o],:oint], "oint"=>[[:s],], "bigsqcup"=>[[:u],], "smallint"=>[[:u,:o],:int], "triangleleft"=>[[:s],], "triangleright"=>[[:s],], "bigtriangleup"=>[[:s],], "bigtriangledown"=>[[:s],], "wedge"=>[[:s],], "land"=>[[:s,:o],:wedge], "vee"=>[[:s],], "lor"=>[[:s,:o],:vee], "cap"=>[[:s],], "cup"=>[[:s],], "sqcap"=>[[:s],], "sqcup"=>[[:s],], "uplus"=>[[:s],], "amalg"=>[[:s],], "diamond"=>[[:s],], "bullet"=>[[:s],], "wr"=>[[:s],], "div"=>[[:s],], "odot"=>[[:s],], "oslash"=>[[:s],], "otimes"=>[[:s],], "ominus"=>[[:s],], "oplus"=>[[:s],], "mp"=>[[:s],], "pm"=>[[:s],], "circ"=>[[:s,:o],:cir], "bigcirc"=>[[:s],], "setminus"=>[[:s],], "cdot"=>[[:s,:o],:sdot], "ast"=>[[:s],], "times"=>[[:s],], "star"=>[[:s],], "propto"=>[[:s],], "sqsubseteq"=>[[:s],], "sqsupseteq"=>[[:s],], "parallel"=>[[:s],], "mid"=>[[:s],], "dashv"=>[[:s],], "vdash"=>[[:s],], "nearrow"=>[[:s],], "searrow"=>[[:s],], "nwarrow"=>[[:s],], "swarrow"=>[[:s],], "Leftrightarrow"=>[[:s],], "Leftarrow"=>[[:s],], "Rightarrow"=>[[:s],], "neq"=>[[:s,:o],:ne], "ne"=>[[:s],], "leq"=>[[:s],], "le"=>[[:s],], "geq"=>[[:s],], "ge"=>[[:s],], "succ"=>[[:s],], "prec"=>[[:s],], "approx"=>[[:s],], "succeq"=>[[:s,:o],:sccue], "preceq"=>[[:s,:o],:prcue], "supset"=>[[:s],], "subset"=>[[:s],], "supseteq"=>[[:s],], "subseteq"=>[[:s],], "in"=>[[:s],], "ni"=>[[:s],], "owns"=>[[:s,:o],:ni], "gg"=>[[:s],], "ll"=>[[:s],], "leftrightarrow"=>[[:s],], "leftarrow"=>[[:s],], "gets"=>[[:s,:o],:leftarrow], "rightarrow"=>[[:s],], "to"=>[[:s,:o],:rightarrow], "mapstochar"=>[[:s,:o],:vdash], "mapsto"=>[[:s],], "sim"=>[[:s],], "simeq"=>[[:s],], "perp"=>[[:s],], "equiv"=>[[:s],], "asymp"=>[[:s],], "smile"=>[[:s],], "frown"=>[[:s],], "leftharpoonup"=>[[:s],], "leftharpoondown"=>[[:s],], "rightharpoonup"=>[[:s],], "rightharpoondown"=>[[:s],], "cong"=>[[:s],], "notin"=>[[:s],], "rightleftharpoons"=>[[:s],], "doteq"=>[[:s],], "joinrel"=>nil, "relbar"=>[[:s,:o],"-"], "Relbar"=>[[:s,:o],"="], "lhook"=>[[:s,:o],:sub], "hookrightarrow"=>[[:s],], "rhook"=>[[:s,:o],:sup], "hookleftarrow"=>[[:s],], "bowtie"=>[[:s],], "models"=>[[:s],], "Longrightarrow"=>[[:s],], "longrightarrow"=>[[:s],], "longleftarrow"=>[[:s],], "Longleftarrow"=>[[:s],], "longmapsto"=>[[:s,:o],:mapsto], "longleftrightarrow"=>[[:s],], "Longleftrightarrow"=>[[:s],], "iff"=>[[:s],], "ldotp"=>[[:s,:o],"."], "cdotp"=>[[:s,:o],:cdot], "colon"=>[[:s],], "cdots"=>[[:s,:o],:ctdot], "vdots"=>[[:s,:o],:vellip], "ddots"=>[[:s,:o],:dtdot], "braceld"=>[[:s,:o],0x25dc], "bracerd"=>[[:s,:o],0x25dd], "bracelu"=>[[:s,:o],0x25df], "braceru"=>[[:s,:o],0x25de], "lmoustache"=>[[:s],], "rmoustache"=>[[:s],], "arrowvert"=>[[:s,:o],:vert], "Arrowvert"=>[[:s,:o],:DoubleVerticalBar], "Vert"=>[[:s,:o],:DoubleVerticalBar], "vert"=>[[:s],], "uparrow"=>[[:s],], "downarrow"=>[[:s],], "updownarrow"=>[[:s],], "Uparrow"=>[[:s],], "Downarrow"=>[[:s],], "Updownarrow"=>[[:s],], "backslash"=>[[:s,:o],"\\"], "rangle"=>[[:s],], "langle"=>[[:s],], "rceil"=>[[:s],], "lceil"=>[[:s],], "rfloor"=>[[:s],], "lfloor"=>[[:s],], "lgroup"=>[[:s,:o],0x2570], "rgroup"=>[[:s,:o],0x256f], "bracevert"=>[[:s,:o],:vert], "mathunderscore"=>[[:s,:o],"_"], "square"=>[[:s],], "rightsquigarrow"=>[[:s],], "lozenge"=>[[:s],], "vartriangleright"=>[[:s],], "vartriangleleft"=>[[:s],], "trianglerighteq"=>[[:s],], "trianglelefteq"=>[[:s],], "boxdot"=>[[:s,:o],:dotsquare], "boxplus"=>[[:s],], "boxtimes"=>[[:s],], "blacksquare"=>[[:s],], "centerdot"=>[[:s],], "blacklozenge"=>[[:s],], "circlearrowright"=>[[:s],], "circlearrowleft"=>[[:s],], "leftrightharpoons"=>[[:s],], "boxminus"=>[[:s],], "Vdash"=>[[:s],], "Vvdash"=>[[:s],], "vDash"=>[[:s],], "twoheadrightarrow"=>[[:s],], "twoheadleftarrow"=>[[:s],], "leftleftarrows"=>[[:s],], "rightrightarrows"=>[[:s],], "upuparrows"=>[[:s],], "downdownarrows"=>[[:s],], "upharpoonright"=>[[:s],], "restriction"=>[[:s,:o],:upharpoonright], "downharpoonright"=>[[:s],], "upharpoonleft"=>[[:s],], "downharpoonleft"=>[[:s],], "rightarrowtail"=>[[:s],], "leftarrowtail"=>[[:s],], "leftrightarrows"=>[[:s],], "rightleftarrows"=>[[:s],], "Lsh"=>[[:s],], "Rsh"=>[[:s],], "leftrightsquigarrow"=>[[:s],], "looparrowleft"=>[[:s],], "looparrowright"=>[[:s],], "circeq"=>[[:s],], "succsim"=>[[:s],], "gtrsim"=>[[:s],], "gtrapprox"=>[[:s],], "multimap"=>[[:s],], "therefore"=>[[:s],], "because"=>[[:s],], "doteqdot"=>[[:s],], "Doteq"=>[[:s,:o],:doteqdot], "triangleq"=>[[:s],], "precsim"=>[[:s],], "lesssim"=>[[:s],], "lessapprox"=>[[:s],], "eqslantless"=>[[:s],], "eqslantgtr"=>[[:s],], "curlyeqprec"=>[[:s],], "curlyeqsucc"=>[[:s],], "preccurlyeq"=>[[:s],], "leqq"=>[[:s],], "leqslant"=>[[:s,:o],:leq], "lessgtr"=>[[:s],], "backprime"=>[[:s],], "risingdotseq"=>[[:s],], "fallingdotseq"=>[[:s],], "succcurlyeq"=>[[:s],], "geqq"=>[[:s],], "geqslant"=>[[:s,:o],:geq], "gtrless"=>[[:s],], "bigstar"=>[[:s],], "between"=>[[:s],], "blacktriangledown"=>[[:s],], "blacktriangleright"=>[[:s],], "blacktriangleleft"=>[[:s],], "vartriangle"=>[[:s,:o],:triangle], "blacktriangle"=>[[:s],], "triangledown"=>[[:s],], "eqcirc"=>[[:s],], "lesseqgtr"=>[[:s],], "gtreqless"=>[[:s],], "lesseqqgtr"=>[[:s],], "gtreqqless"=>[[:s],], "Rrightarrow"=>[[:s],], "Lleftarrow"=>[[:s],], "veebar"=>[[:s],], "barwedge"=>[[:s],], "doublebarwedge"=>[[:s],], "measuredangle"=>[[:s],], "sphericalangle"=>[[:s,:o],:angsph], "varpropto"=>[[:s],], "smallsmile"=>[[:s,:o],:smile], "smallfrown"=>[[:s,:o],:frown], "Subset"=>[[:s],], "Supset"=>[[:s],], "Cup"=>[[:s],], "doublecup"=>[[:s,:o],:Cup], "Cap"=>[[:s],], "doublecap"=>[[:s,:o],:Cap], "curlywedge"=>[[:s],], "curlyvee"=>[[:s],], "leftthreetimes"=>[[:s],], "rightthreetimes"=>[[:s],], "subseteqq"=>[[:s],], "supseteqq"=>[[:s],], "bumpeq"=>[[:s],], "Bumpeq"=>[[:s],], "lll"=>[[:s,:o],:Ll], "llless"=>[[:s,:o],:Ll], "ggg"=>[[:s],], "gggtr"=>[[:s,:o],:ggg], "circledS"=>[[:s],], "pitchfork"=>[[:s],], "dotplus"=>[[:s],], "backsim"=>[[:s],], "backsimeq"=>[[:s],], "complement"=>[[:s],], "intercal"=>[[:s],], "circledcirc"=>[[:s],], "circledast"=>[[:s],], "circleddash"=>[[:s],], "lvertneqq"=>[[:s,:o],:lneqq], "gvertneqq"=>[[:s,:o],:gneqq], "nleq"=>[[:s,:o],0x2270], "ngeq"=>[[:s,:o],0x2271], "nless"=>[[:s],], "ngtr"=>[[:s],], "nprec"=>[[:s],], "nsucc"=>[[:s],], "lneqq"=>[[:s],], "gneqq"=>[[:s],], "nleqslant"=>[[:s],], "ngeqslant"=>[[:s],], "lneq"=>[[:s],], "gneq"=>[[:s],], "npreceq"=>[[:s,:o],:nprcue], "nsucceq"=>[[:s,:o],:nsccue], "precnsim"=>[[:s],], "succnsim"=>[[:s],], "lnsim"=>[[:s],], "gnsim"=>[[:s],], "nleqq"=>[[:s],], "ngeqq"=>[[:s],], "precneqq"=>[[:s,:o],0x2ab5], "succneqq"=>[[:s,:o],0x2ab6], "precnapprox"=>[[:s],], "succnapprox"=>[[:s],], "lnapprox"=>[[:s,:o],0x2a89], "gnapprox"=>[[:s,:o],0x2a8a], "nsim"=>[[:s],], "ncong"=>[[:s],], "diagup"=>[[:s,:o],0x2571], "diagdown"=>[[:s,:o],0x2572], "varsubsetneq"=>[[:s,:o],:subsetneq], "varsupsetneq"=>[[:s,:o],:supsetneq], "nsubseteqq"=>[[:s],], "nsupseteqq"=>[[:s],], "subsetneqq"=>[[:s],], "supsetneqq"=>[[:s],], "varsubsetneqq"=>[[:s,:o],:subsetneqq], "varsupsetneqq"=>[[:s,:o],:supsetneqq], "subsetneq"=>[[:s],], "supsetneq"=>[[:s],], "nsubseteq"=>[[:s],], "nsupseteq"=>[[:s],], "nparallel"=>[[:s],], "nmid"=>[[:s],], "nshortmid"=>[[:s,:o],:nmid], "nshortparallel"=>[[:s,:o],:nparallel], "nvdash"=>[[:s],], "nVdash"=>[[:s],], "nvDash"=>[[:s],], "nVDash"=>[[:s],], "ntrianglerighteq"=>[[:s],], "ntrianglelefteq"=>[[:s],], "ntriangleleft"=>[[:s],], "ntriangleright"=>[[:s],], "nleftarrow"=>[[:s],], "nrightarrow"=>[[:s],], "nLeftarrow"=>[[:s],], "nRightarrow"=>[[:s],], "nLeftrightarrow"=>[[:s],], "nleftrightarrow"=>[[:s],], "divideontimes"=>[[:s],], "varnothing"=>[[:s],], "nexists"=>[[:s],], "Finv"=>[[:s,:o],0x2132], "Game"=>[[:s,:o],"G"], "eth"=>[[:s],], "eqsim"=>[[:s],], "beth"=>[[:s],], "gimel"=>[[:s],], "daleth"=>[[:s],], "lessdot"=>[[:s],], "gtrdot"=>[[:s],], "ltimes"=>[[:s],], "rtimes"=>[[:s],], "shortmid"=>[[:s,:o],:mid], "shortparallel"=>[[:s],], "smallsetminus"=>[[:s,:o],:setminus], "thicksim"=>[[:s,:o],:sim], "thickapprox"=>[[:s,:o],:approx], "approxeq"=>[[:s],], "succapprox"=>[[:s],], "precapprox"=>[[:s],], "curvearrowleft"=>[[:s],], "curvearrowright"=>[[:s],], "digamma"=>[[:s],], "varkappa"=>[[:s],], "Bbbk"=>[[:s,:i],:kopf], "hslash"=>[[:s],], "backepsilon"=>[[:s],], "ulcorner"=>[[:s,:o],:boxdr], "urcorner"=>[[:s,:o],:boxdl], "llcorner"=>[[:s,:o],:boxur], "lrcorner"=>[[:s,:o],:boxul], } DELIMITERS=[ "lmoustache", "rmoustache", "arrowvert", "Arrowvert", "Vert", "vert", "uparrow", "downarrow", "updownarrow", "Uparrow", "Downarrow", "Updownarrow", "backslash", "rangle", "langle", "rbrace", "lbrace", "rceil", "lceil", "rfloor", "lfloor", "lgroup", "rgroup", "bracevert", "ulcorner", "urcorner", "llcorner", "lrcorner", "{", "|", "}", ] end end math_ml-0.14/lib/math_ml/latex.rb0000644000004100000410000006524712055512401016751 0ustar www-datawww-datarequire "math_ml/latex/builtin" module MathML module LaTeX MBEC = /\\.|[^\\]/m module RE SPACE = /(?:\s|%.*$)/ NUMERICS = /(?:\.\d+)|(?:\d+(\.\d+)?)/ OPERATORS = /[,\.\+\-\*=\/\(\)\[\]<>"|;:!]/ ALPHABETS = /[a-zA-Z]/ BLOCK = /\A\{(.*?)\}\z/m OPTION = /\A\[(.*)\]\z/m COMMANDS = /\\([a-zA-Z]+|[^a-zA-Z])/ WBSLASH = /\\\\/ BRACES = /\A([.|\[\]\(\)<>])\z/ end module Font NORMAL = 0 BOLD = 1 BLACKBOLD = 2 SCRIPT = 3 FRAKTUR = 4 ROMAN = 5 BOLD_ITALIC = 6 end class BlockNotClosed < StandardError; end class NotEnvironment < StandardError; end class EnvironmentNotEnd < StandardError; end class NeedParameter < StandardError; end class EndMismatchToBegin < StandardError; end class OptionNotClosed < StandardError; end class Scanner < StringScanner def done self.string[0, pos] end def scan_space _scan(/#{RE::SPACE}+/) end def skip_space_and(check_mode) opos = pos scan_space r = yield self.pos = opos if check_mode || !r r end unless instance_methods.include?("_eos?") alias :_eos? :eos? alias :_check :check alias :_scan :scan end def check(re) skip_space_and(true){_check(re)} end def scan(re) skip_space_and(false){_scan(re)} end def eos? _eos? || _check(/#{RE::SPACE}+\z/) end def check_command check(RE::COMMANDS) end def scan_command scan(RE::COMMANDS) end def peek_command check_command ? self[1] : nil end def check_block skip_space_and(true){scan_block} end def scan_block return nil unless scan(/\{/) block = "{" bpos = pos-1 nest = 1 while _scan(/(#{MBEC}*?)([\{\}])/) block << matched case self[2] when "{" nest+=1 when "}" nest-=1 break if nest==0 end end if nest>0 self.pos = bpos raise BlockNotClosed end self.pos = bpos _scan(/\A\{(#{Regexp.escape(block[RE::BLOCK, 1].to_s)})\}/) end def check_any(remain_space=false) skip_space_and(true){scan_any(remain_space)} end def scan_any(remain_space=false) p = pos scan_space r = remain_space ? matched.to_s : "" case when s = scan_block when s = scan_command else unless _scan(/./) || remain_space self.pos = p return nil end s = matched.to_s end r << s end def scan_option return nil unless scan(/\[/) opt = "[" p = pos-1 until (s=scan_any(true)) =~ /\A#{RE::SPACE}*\]\z/ opt << s if eos? self.pos = p raise OptionNotClosed end end opt << s self.pos = p _scan(/\A\[(#{Regexp.escape(opt[RE::OPTION, 1].to_s)})\]/) end def check_option skip_space_and(true){scan_option} end end class ParseError < StandardError attr_accessor :rest, :done def initialize(message, rest = "", done = "") @done = done @rest = rest super(message) end def inspect "#{message} : '#{@done}' / '#{@rest}'\n"+backtrace[0..5].join("\n") end end class Macro class Command attr_reader :num, :body, :option def initialize(n, b, o) @num = n @body = b @option = o end end class Environment attr_reader :num, :beginning, :ending, :option def initialize(n, b, e, o) @num = n @beginning = b @ending = e @option = o end end def initialize @commands = Hash.new @environments = Hash.new end def parse_error(message, rest="", whole=nil) rest = whole[/\A.*?(#{Regexp.escape(rest)}.*\z)/, 1] if whole rest << @scanner.rest done = @scanner.string[0, @scanner.string.size-rest.size] ParseError.new(message, rest, done) end def parse(src) @scanner = Scanner.new(src) until @scanner.eos? unless @scanner.scan_command @scanner.scan_space raise parse_error("Syntax error.") end case @scanner[1] when "newcommand" parse_newcommand when "newenvironment" parse_newenvironment else raise parse_error("Syntax error.", @scanner.matched) end end rescue BlockNotClosed => e raise parse_error("Block not closed.") rescue OptionNotClosed => e raise parse_error("Option not closed.") end def scan_num_of_parameter if @scanner.scan_option raise parse_error("Need positive number.", @scanner[1]+"]") unless @scanner[1]=~/\A#{RE::SPACE}*\d+#{RE::SPACE}*\z/ @scanner[1].to_i else 0 end end def check_parameter_numbers(src, opt, whole) s = Scanner.new(src) until s.eos? case when s.scan(/#{MBEC}*?\#(\d+|.)/) raise parse_error("Need positive number.") unless s[1]=~/\d+/ raise parse_error("Parameter \# too large.", s[1]+s.rest, whole) if s[1].to_i>opt else return nil end end end def parse_newcommand case when @scanner.scan_block s = Scanner.new(@scanner[1]) raise parse_error("Need newcommand.", s.rest+"}") unless s.scan_command com = s[1] raise parse_error("Syntax error." ,s.rest+"}") unless s.eos? when @scanner.scan_command s = Scanner.new(@scanner[1]) com = s.scan_command else raise parse_error("Need newcommand.") end optnum = scan_num_of_parameter opt = @scanner.scan_option ? @scanner[1] : nil case when @scanner.scan_block body = @scanner[1] when @scanner.scan_command body = @scanner.matched else body = @scanner.scan(/./) end raise parse_error("Need parameter.") unless body check_parameter_numbers(body, optnum, @scanner.matched) optnum-=1 if opt @commands[com] = Command.new(optnum, body, opt) end def parse_newenvironment case when @scanner.scan_block env = @scanner[1] when @scanner.scan_command raise ParseError.new when @scanner.scan(/./) env = @scanner.matched end raise parse_error("Syntax error.", env[/\A.*?(\\.*\z)/, 1], @scanner.matched) if env=~/\\/ optnum = scan_num_of_parameter opt = @scanner.scan_option ? @scanner[1] : nil b = @scanner.scan_block ? @scanner[1] : @scanner.scan_any raise parse_error("Need begin block.") unless b check_parameter_numbers(b, optnum, @scanner.matched) e = @scanner.scan_block ? @scanner[1] : @scanner.scan_any raise parse_error("Need end block.") unless e check_parameter_numbers(e, optnum, @scanner.matched) optnum -= 1 if opt @environments[env] = Environment.new(optnum, b, e, opt) end def commands(com) @commands[com] end def expand_command(com, params, opt=nil) return nil unless @commands.has_key?(com) c = @commands[com] opt = c.option if c.option && !opt params.unshift(opt) if c.option raise ParseError.new("Need more parameter.") if params.size < c.num c.body.gsub(/(#{MBEC}*?)\#(\d+)/) do $1.to_s << params[$2.to_i-1] end end def environments(env) @environments[env] end def expand_environment(env, body, params, opt=nil) return nil unless @environments.has_key?(env) e = @environments[env] opt = e.option if e.option && !opt params.unshift(opt) if e.option raise ParseError.new("Need more parameter.") if params.size < e.num bg = e.beginning.gsub(/(#{MBEC}*?)\#(\d+)/) do $1.to_s << params[$2.to_i-1] end en = e.ending.gsub(/(#{MBEC}*?)\#(\d+)/) do $1.to_s << params[$2.to_i-1] end " #{bg} #{body} #{en} " end end module BuiltinCommands; end module BuiltinGroups; end module BuiltinEnvironments; end class Parser class CircularReferenceCommand < StandardError; end include LaTeX include BuiltinEnvironments include BuiltinGroups include BuiltinCommands BUILTIN_MACRO = <<'EOS' \newenvironment{smallmatrix}{\begin{matrix}}{\end{matrix}} \newenvironment{pmatrix}{\left(\begin{matrix}}{\end{matrix}\right)} \newenvironment{bmatrix}{\left[\begin{matrix}}{\end{matrix}\right]} \newenvironment{Bmatrix}{\left\{\begin{matrix}}{\end{matrix}\right\}} \newenvironment{vmatrix}{\left|\begin{matrix}}{\end{matrix}\right|} \newenvironment{Vmatrix}{\left\|\begin{matrix}}{\end{matrix}\right\|} EOS attr_accessor :unsecure_entity attr_reader :macro attr_reader :symbol_table def initialize(opt={}) @unsecure_entity = false @entities = Hash.new @commands = Hash.new @symbols = Hash.new @delimiters = Array.new @group_begins = Hash.new @group_ends = Hash.new @macro = Macro.new @macro.parse(BUILTIN_MACRO) @expanded_command = Array.new @expanded_environment = Array.new @symbol_table = opt[:symbol] || MathML::Symbol::Default @symbol_table = MathML::Symbol::MAP[@symbol_table] if @symbol_table.is_a?(::Symbol) super() end def add_entity(list) list.each do |i| @entities[i] = true end end def parse(src, displaystyle=false) @ds = displaystyle begin parse_into(src, Math.new(@ds), Font::NORMAL) rescue ParseError => e e.done = src[0...(src.size - e.rest.size)] raise end end def push_container(container, scanner=@scanner, font=@font) data = [@container, @scanner, @font] @container, @scanner, @font = [container, scanner, font] begin yield container container ensure @container, @scanner, @font = data end end def add_plugin(plugin) self.extend(plugin) end def add_commands(*a) if a.size==1 && Hash===a[0] @commands.merge!(a[0]) else a.each{|i| @commands[i] = false} end end def add_multi_command(m, *a) a.each{|i| @commands[i] = m} end def add_sym_cmd(hash) @symbols.merge!(hash) end def add_delimiter(list) @delimiters.concat(list) end def add_group(begin_name, end_name, method=nil) @group_begins[begin_name] = method @group_ends[end_name] = begin_name end private def parse_into(src, parent, font=nil) orig = [@scanner, @container, @font, @ds] @scanner = Scanner.new(src) @container = parent @font = font if font begin until @scanner.eos? @container << parse_to_element(true) end @container rescue BlockNotClosed => e raise ParseError.new("Block not closed.", @scanner.rest) rescue NotEnvironment => e raise ParseError.new("Not environment.", @scanner.rest) rescue EnvironmentNotEnd => e raise ParseError.new("Environment not end.", @scanner.rest) rescue OptionNotClosed => e raise ParseError.new("Option not closed.", @scanner.rest) rescue ParseError => e e.rest << @scanner.rest.to_s raise ensure @scanner, @container, @font, @ds = orig end end def parse_any(message = "Syntax error.") raise ParseError.new(message) unless @scanner.scan_any s = @scanner @scanner = Scanner.new(@scanner.matched) begin parse_to_element ensure @scanner = s end end def parse_to_element(whole_group = false) if whole_group && @group_begins.has_key?(@scanner.peek_command) @scanner.scan_command parse_group else case when @scanner.scan(RE::NUMERICS) parse_num when @scanner.scan(RE::ALPHABETS) parse_char when @scanner.scan(RE::OPERATORS) parse_operator when @scanner.scan_block parse_block when @scanner.scan(/_/) parse_sub when @scanner.scan(/'+|\^/) parse_sup when @scanner.scan(/~/) Space.new("1em") when @scanner.scan_command parse_command else raise ParseError.new('Syntax error.') end end end def parse_num n = Number.new n.extend(Variant).variant = Variant::BOLD if @font==Font::BOLD n << @scanner.matched end def parse_char c = @scanner.matched i = Identifier.new case @font when Font::ROMAN i.extend(Variant).variant = Variant::NORMAL when Font::BOLD i.extend(Variant).variant = Variant::BOLD when Font::BOLD_ITALIC i.extend(Variant).variant = Variant::BOLD_ITALIC when Font::BLACKBOLD c = symbol_table.convert("#{c}opf") when Font::SCRIPT c = symbol_table.convert("#{c}scr") when Font::FRAKTUR c = symbol_table.convert("#{c}fr") end i << c end def parse_operator o = @scanner.matched Operator.new.tap{|op| op[:stretchy]="false"} << o end def parse_block os = @scanner @scanner = Scanner.new(@scanner[1]) begin push_container(Row.new) do |r| r << parse_to_element(true) until @scanner.eos? end rescue ParseError => e e.rest << '}' raise ensure @scanner = os end end def parse_sub e = @container.pop e = None.new unless e e = SubSup.new(@ds && e.display_style, e) unless e.is_a?(SubSup) raise ParseError.new("Double subscript.", "_") if e.sub e.sub = parse_any("Subscript not exist.") e end def parse_sup e = @container.pop e = None.new unless e e = SubSup.new(@ds && e.display_style, e) unless e.is_a?(SubSup) raise ParseError.new("Double superscript.", @scanner[0]) if e.sup if /'+/=~@scanner[0] prime = Operator.new @scanner[0].size.times do prime << symbol_table.convert("prime") end unless @scanner.scan(/\^/) e.sup = prime return e end end sup = parse_any("Superscript not exist.") if prime unless sup.is_a?(Row) r = Row.new r << sup sup = r end sup.contents.insert(0, prime) end e.sup = sup e end def entitize(str) MathML.pcstring(str.sub(/^(.*)$/){"&#{$1};"}, true) end def parse_symbol_command(com, plain=false) unless @symbols.include?(com) @scanner.pos = @scanner.pos-(com.size+1) raise ParseError.new("Undefined command.") end data = @symbols[com] return nil unless data data, s = data su = data[0] el = data[1] el = :o unless el s = com.dup.untaint.to_sym unless s s = com if s.is_a?(String) && s.length==0 case el when :I el = Identifier.new when :i el = Identifier.new el.extend(Variant).variant = Variant::NORMAL unless s.is_a?(String)&&s.length>1 when :o el = Operator.new el[:stretchy] = "false" when :n el = Number.new else raise ParseError.new("Inner data broken.") end case s when Fixnum s = MathML.pcstring("&\#x#{s.to_s(16)};", true) when ::Symbol s = symbol_table.convert(s) else MathML.pcstring(s, true) end return s if plain el << s el.as_display_style if su==:u el end def parse_command com = @scanner[1] matched = @scanner.matched pos = @scanner.pos-matched.size macro = @macro.commands(com) if macro begin flg = @expanded_command.include?(com) @expanded_command.push(com) raise CircularReferenceCommand if flg option = (macro.option && @scanner.scan_option) ? @scanner[1] : nil params = Array.new (1..macro.num).each do params << (@scanner.scan_block ? @scanner[1] : @scanner.scan_any) raise ParseError.new("Need more parameter.") unless params.last end r = parse_into(@macro.expand_command(com, params, option), Array.new) return r rescue CircularReferenceCommand if @expanded_command.size>1 raise else @scanner.pos = pos raise ParseError.new("Circular reference.") end rescue ParseError => e if @expanded_command.size>1 raise else @scanner.pos = pos raise ParseError.new(%[Error in macro(#{e.message} "#{e.rest.strip}").]) end ensure @expanded_command.pop end elsif @commands.key?(com) m = @commands[com] m = com unless m return __send__("cmd_#{m.to_s}") end parse_symbol_command(com) end def parse_mathfont(font) f = @font @font = font begin push_container(Row.new){|r| r << parse_any} ensure @font = f end end def parse_group font = @font begin g = @group_begins[@scanner[1]] g = @scanner[1] unless g __send__("grp_#{g.to_s}") ensure @font = font end end end module BuiltinCommands OVERS = {'hat'=>'circ', 'breve'=>'smile', 'grave'=>'grave', 'acute'=>'acute', 'dot'=>'sdot', 'ddot'=>'nldr', 'dddot'=>'mldr', 'tilde'=>'tilde', 'bar'=>'macr', 'vec'=>'rightarrow', 'check'=>'vee', 'widehat'=>'circ', 'overline'=>'macr', 'widetilde'=>'tilde', 'overbrace'=>'OverBrace'} UNDERS = {'underbrace'=>'UnderBrace', 'underline'=>'macr'} def initialize add_commands("\\"=>:backslash) add_commands("entity", "stackrel", "frac", "sqrt", "mbox") add_multi_command(:hat_etc, *OVERS.keys) add_multi_command(:underbrace_etc, *UNDERS.keys) add_multi_command(:quad_etc, " ", "quad", "qquad", ",", ":", ";", "!") add_multi_command(:it_etc, "it", "rm", "bf") add_multi_command(:mathit_etc, "mathit", "mathrm", "mathbf", "bm", "mathbb", "mathscr", "mathfrak") add_sym_cmd(Builtin::Symbol::MAP) add_delimiter(Builtin::Symbol::DELIMITERS) super end def cmd_backslash @ds ? nil : XMLElement.new("br", "xmlns"=>"http://www.w3.org/1999/xhtml") end def cmd_hat_etc com = @scanner[1] Over.new(parse_any, Operator.new << entitize(OVERS[com])) end def cmd_underbrace_etc com = @scanner[1] Under.new(parse_any, Operator.new << entitize(UNDERS[com])) end def cmd_entity param = @scanner.scan_block ? @scanner[1] : @scanner.scan(/./) raise ParseError.new("Need parameter.") unless param unless @unsecure_entity || @entities[param] param =@scanner.matched[/\A\{#{RE::SPACE}*(.*\})\z/, 1] if @scanner.matched=~RE::BLOCK @scanner.pos = @scanner.pos-(param.size) raise ParseError.new("Unregistered entity.") end Operator.new << entitize(param) end def cmd_stackrel o = parse_any; b = parse_any Over.new(b, o) end def cmd_quad_etc case @scanner[1] when ' ' Space.new("1em") when 'quad' Space.new("1em") when 'qquad' Space.new("2em") when ',' Space.new("0.167em") when ':' Space.new("0.222em") when ';' Space.new("0.278em") when '!' Space.new("-0.167em") end end def cmd_it_etc case @scanner[1] when 'it' @font = Font::NORMAL when 'rm' @font = Font::ROMAN when 'bf' @font = Font::BOLD end nil end def cmd_mathit_etc case @scanner[1] when 'mathit' parse_mathfont(Font::NORMAL) when 'mathrm' parse_mathfont(Font::ROMAN) when 'mathbf' parse_mathfont(Font::BOLD) when 'bm' parse_mathfont(Font::BOLD_ITALIC) when 'mathbb' parse_mathfont(Font::BLACKBOLD) when 'mathscr' parse_mathfont(Font::SCRIPT) when 'mathfrak' parse_mathfont(Font::FRAKTUR) end end def cmd_frac n = parse_any; d = parse_any Frac.new(n, d) end def cmd_sqrt if @scanner.scan_option i = parse_into(@scanner[1], Array.new) i = i.size==1 ? i[0] : (Row.new << i) b = parse_any Root.new(i, b) else Sqrt.new << parse_any end end def cmd_mbox @scanner.scan_any Text.new << (@scanner.matched =~ RE::BLOCK ? @scanner[1] : @scanner.matched) end end module BuiltinGroups class CircularReferenceEnvironment < StandardError; end def initialize add_group("begin", "end") add_group("left", "right", :left_etc) add_group("bigg", "bigg", :left_etc) @environments = Hash.new super end def add_environment(*a) @environments = Hash.new unless @environments if a.size==1 && Hash===a[0] @environments.merge!(hash) else a.each{|i| @environments[i] = false} end end def grp_begin matched = @scanner.matched begin_pos = @scanner.pos-matched.size en = @scanner.scan_block ? @scanner[1] : @scanner.scan_any raise ParseError.new('Environment name not exist.') unless en macro = @macro.environments(en) if macro begin flg = @expanded_environment.include?(en) @expanded_environment.push(en) raise CircularReferenceEnvironment if flg pos = @scanner.pos option = (macro.option && @scanner.scan_option) ? @scanner[1] : nil params = Array.new (1..macro.num).each do params << (@scanner.scan_block ? @scanner[1] : @scanner.scan_any) raise ParseError.new("Need more parameter.") unless params.last end body = "" grpnest = 0 until @scanner.peek_command=="end" && grpnest==0 if @scanner.eos? @scanner.pos = pos raise ParseError.new('Matching \end not exist.') end com = @scanner.peek_command grpnest += 1 if @group_begins.has_key?(com) grpnest -=1 if @group_ends.has_key?(com) && @group_begins[com] raise ParseError.new("Syntax error.") if grpnest<0 body << @scanner.scan_any(true) end @scanner.scan_command raise ParseError.new("Environment mismatched.", @scanner.matched) unless en==(@scanner.scan_block ? @scanner[1] : @scanner.scan_any) begin return parse_into(@macro.expand_environment(en, body, params, option), Array.new) rescue CircularReferenceEnvironment if @expanded_environment.size>1 raise else @scanner.pos = begin_pos raise ParseError.new("Circular reference.") end rescue ParseError => e if @expanded_environment.size>1 raise else @scanner.pos = begin_pos raise ParseError.new(%[Error in macro(#{e.message} "#{e.rest.strip}").]) end end ensure @expanded_environment.pop end end raise ParseError.new("Undefined environment.") unless @environments.has_key?(en) e = @environments[en] e = en unless e # default method name __send__("env_#{e.to_s}") end def grp_left_etc right = case @scanner[1] when "left" "right" when "bigg" "bigg" end f = Fenced.new p = @scanner.pos o = @scanner.scan_any raise ParseError.new('Need brace here.') unless o && (o=~RE::BRACES || @delimiters.include?(o[RE::COMMANDS, 1])) f.open = (o=~RE::BRACES ? o : parse_symbol_command(o[RE::COMMANDS, 1], true)) f << push_container(Row.new) do |r| until @scanner.peek_command==right if @scanner.eos? @scanner.pos = p raise ParseError.new('Brace not closed.') end r << parse_to_element(true) end end @scanner.scan_command # skip right c = @scanner.scan_any raise ParseError.new('Need brace here.') unless c=~RE::BRACES || @delimiters.include?(c[RE::COMMANDS, 1]) f.close = (c=~RE::BRACES ? c : parse_symbol_command(c[RE::COMMANDS, 1], true)) f end end module BuiltinEnvironments def initialize add_environment("array", "matrix") super end def env_array layout = @scanner.scan_block ? @scanner.matched : @scanner.scan(/./) l = Scanner.new(layout=~RE::BLOCK ? layout[RE::BLOCK, 1] : layout) t = Table.new aligns = Array.new vlines = Array.new vlined = l.check(/\|/) columned = false until l.eos? c = l.scan_any raise ParseError.new("Syntax error.", layout[/\A.*(#{Regexp.escape(c+l.rest)}.*\z)/m, 1]) unless c=~/[clr\|@]/ if c=='|' aligns << Align::CENTER if vlined vlines << Line::SOLID vlined = true columned = false else vlines << Line::NONE if columned vlined = false columned = true case c when 'l' aligns << Align::LEFT when 'c' aligns << Align::CENTER when 'r' aligns << Align::RIGHT when '@' aligns << Align::CENTER l.scan_any end end end t.aligns = aligns t.vlines = vlines layout = layout[RE::BLOCK, 1] if layout=~RE::BLOCK raise ParseError.new('Need parameter here.') if layout=="" hlines = Array.new row_parsed = false hlined = false until @scanner.peek_command=="end" raise ParseError.new('Matching \end not exist.') if @scanner.eos? if @scanner.peek_command=="hline" @scanner.scan_command t << Tr.new unless row_parsed hlines << Line::SOLID row_parsed = false hlined = true else hlines << Line::NONE if row_parsed t << env_array_row(l.string) @scanner.scan(RE::WBSLASH) row_parsed = true hlined = false end end t.hlines = hlines if hlined tr = Tr.new (0..vlines.size).each {|i| tr << Td.new} t << tr end @scanner.scan_command raise ParseError.new("Environment mismatched.") unless @scanner.check_block && @scanner[1]=="array" @scanner.scan_block t end def env_array_row(layout) l = Scanner.new(layout) r = Tr.new first_column = true vlined = l.check(/\|/) until l.eos? c = l.scan(/./) if c=='|' r << Td.new if vlined vlined = true next else vlined = false case c when 'r', 'l', 'c' when '@' r << parse_into(l.scan_any, Td.new) next end if first_column first_column = false else raise ParseError.new("Need more column.", @scanner.matched.to_s) unless @scanner.scan(/&/) end r << push_container(Td.new) do |td| td << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos? end end end r << Td.new if vlined raise ParseError.new("Too many column.") if @scanner.check(/&/) r end def env_matrix t = Table.new hlines = Array.new hlined = false row_parsed = false until @scanner.peek_command=="end" raise ParseError.new('Matching \end not exist.') if @scanner.eos? if @scanner.peek_command=="hline" @scanner.scan_command t << Tr.new unless row_parsed hlines << Line::SOLID row_parsed = false hlined = true else hlines << Line::NONE if row_parsed t << (r = Tr.new) r << (td=Td.new) until @scanner.check(RE::WBSLASH) || @scanner.peek_command=="end" || @scanner.eos? push_container(td) do |e| e << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos? end r << (td=Td.new) if @scanner.scan(/&/) end @scanner.scan(RE::WBSLASH) row_parsed = true hlined = false end end t.hlines = hlines t << Tr.new if hlined raise ParseError.new("Need \\end{array}.") unless @scanner.peek_command=="end" @scanner.scan_command raise ParseError.new("Environment mismatched.") unless @scanner.check_block && @scanner[1]=="matrix" @scanner.scan_block t end def env_matrix_row r = Tr.new until @scanner.check(RE::WBSLASH) || @scanner.peek_command=="end" r << push_container(Td.new) do |td| td << parse_to_element(true) until @scanner.peek_command=="end" || @scanner.check(/(&|\\\\)/) || @scanner.eos? end end end end end end math_ml-0.14/lib/math_ml/symbol/0000755000004100000410000000000012055512401016576 5ustar www-datawww-datamath_ml-0.14/lib/math_ml/symbol/utf8.rb0000644000004100000410000011420012055512401020007 0ustar www-datawww-data# coding: utf-8 module MathML module Symbol MAP = {} unless const_defined?(:MAP) module UTF8 Symbol::Default = self unless Symbol.const_defined?(:Default) Symbol::MAP[:utf8] = self def self.convert(name) MAP[name.to_s.to_sym] end MAP = { :AElig => "Æ", :Aacute => "Á", :Abreve => "Ă", :Acirc => "Â", :Acy => "А", :Afr => "𝔄", :Agrave => "À", :Amacr => "Ā", :And => "⩓", :Aogon => "Ą", :Aopf => "𝔸", :ApplyFunction => "⁡", :Aring => "Å", :Ascr => "𝒜", :Assign => "≔", :Atilde => "Ã", :Auml => "Ä", :Backslash => "∖", :Barv => "⫧", :Barwed => "⌆", :Bcy => "Б", :Because => "∵", :Bernoullis => "ℬ", :Bfr => "𝔅", :Bopf => "𝔹", :Breve => "˘", :Bscr => "ℬ", :Bumpeq => "≎", :CHcy => "Ч", :Cacute => "Ć", :Cap => "⋒", :CapitalDifferentialD => "ⅅ", :Cayleys => "ℭ", :Ccaron => "Č", :Ccedil => "Ç", :Ccirc => "Ĉ", :Cconint => "∰", :Cdot => "Ċ", :Cedilla => "¸", :CenterDot => "·", :Cfr => "ℭ", :CircleDot => "⊙", :CircleMinus => "⊖", :CirclePlus => "⊕", :CircleTimes => "⊗", :ClockwiseContourIntegral => "∲", :CloseCurlyDoubleQuote => "”", :CloseCurlyQuote => "’", :Colon => "∷", :Colone => "⩴", :Congruent => "≡", :Conint => "∯", :ContourIntegral => "∮", :Copf => "ℂ", :Coproduct => "∐", :CounterClockwiseContourIntegral => "∳", :Cross => "⨯", :Cscr => "𝒞", :Cup => "⋓", :CupCap => "≍", :DD => "ⅅ", :DDotrahd => "⤑", :DJcy => "Ђ", :DScy => "Ѕ", :DZcy => "Џ", :Dagger => "‡", :Darr => "↡", :Dashv => "⫤", :Dcaron => "Ď", :Dcy => "Д", :Del => "∇", :Delta => "Δ", :Dfr => "𝔇", :DiacriticalAcute => "´", :DiacriticalDot => "˙", :DiacriticalDoubleAcute => "˝", :DiacriticalGrave => "`", :DiacriticalTilde => "˜", :Diamond => "⋄", :DifferentialD => "ⅆ", :Dopf => "𝔻", :Dot => "¨", :DotDot => "⃜", :DotEqual => "≐", :DoubleContourIntegral => "∯", :DoubleDot => "¨", :DoubleDownArrow => "⇓", :DoubleLeftArrow => "⇐", :DoubleLeftRightArrow => "⇔", :DoubleLeftTee => "⫤", :DoubleLongLeftArrow => "⟸", :DoubleLongLeftRightArrow => "⟺", :DoubleLongRightArrow => "⟹", :DoubleRightArrow => "⇒", :DoubleRightTee => "⊨", :DoubleUpArrow => "⇑", :DoubleUpDownArrow => "⇕", :DoubleVerticalBar => "∥", :DownArrow => "↓", :DownArrowBar => "⤓", :DownArrowUpArrow => "⇵", :DownBreve => "̑", :DownLeftRightVector => "⥐", :DownLeftTeeVector => "⥞", :DownLeftVector => "↽", :DownLeftVectorBar => "⥖", :DownRightTeeVector => "⥟", :DownRightVector => "⇁", :DownRightVectorBar => "⥗", :DownTee => "⊤", :DownTeeArrow => "↧", :Downarrow => "⇓", :Dscr => "𝒟", :Dstrok => "Đ", :ENG => "Ŋ", :ETH => "Ð", :Eacute => "É", :Ecaron => "Ě", :Ecirc => "Ê", :Ecy => "Э", :Edot => "Ė", :Efr => "𝔈", :Egrave => "È", :Element => "∈", :Emacr => "Ē", :EmptySmallSquare => "◻", :EmptyVerySmallSquare => "▫", :Eogon => "Ę", :Eopf => "𝔼", :Equal => "⩵", :EqualTilde => "≂", :Equilibrium => "⇌", :Escr => "ℰ", :Esim => "⩳", :Euml => "Ë", :Exists => "∃", :ExponentialE => "ⅇ", :Fcy => "Ф", :Ffr => "𝔉", :FilledSmallSquare => "◼", :FilledVerySmallSquare => "▪", :Fopf => "𝔽", :ForAll => "∀", :Fouriertrf => "ℱ", :Fscr => "ℱ", :GJcy => "Ѓ", :Gamma => "Γ", :Gammad => "Ϝ", :Gbreve => "Ğ", :Gcedil => "Ģ", :Gcirc => "Ĝ", :Gcy => "Г", :Gdot => "Ġ", :Gfr => "𝔊", :Gg => "⋙", :Gopf => "𝔾", :GreaterEqual => "≥", :GreaterEqualLess => "⋛", :GreaterFullEqual => "≧", :GreaterGreater => "⪢", :GreaterLess => "≷", :GreaterSlantEqual => "⩾", :GreaterTilde => "≳", :Gscr => "𝒢", :Gt => "≫", :HARDcy => "Ъ", :Hacek => "ˇ", :Hat => "^", :Hcirc => "Ĥ", :Hfr => "ℌ", :HilbertSpace => "ℋ", :Hopf => "ℍ", :HorizontalLine => "─", :Hscr => "ℋ", :Hstrok => "Ħ", :HumpDownHump => "≎", :HumpEqual => "≏", :IEcy => "Е", :IJlig => "IJ", :IOcy => "Ё", :Iacute => "Í", :Icirc => "Î", :Icy => "И", :Idot => "İ", :Ifr => "ℑ", :Igrave => "Ì", :Im => "ℑ", :Imacr => "Ī", :ImaginaryI => "ⅈ", :Implies => "⇒", :Int => "∬", :Integral => "∫", :Intersection => "⋂", :InvisibleComma => "⁣", :InvisibleTimes => "⁢", :Iogon => "Į", :Iopf => "𝕀", :Iscr => "ℐ", :Itilde => "Ĩ", :Iukcy => "І", :Iuml => "Ï", :Jcirc => "Ĵ", :Jcy => "Й", :Jfr => "𝔍", :Jopf => "𝕁", :Jscr => "𝒥", :Jsercy => "Ј", :Jukcy => "Є", :KHcy => "Х", :KJcy => "Ќ", :Kcedil => "Ķ", :Kcy => "К", :Kfr => "𝔎", :Kopf => "𝕂", :Kscr => "𝒦", :LJcy => "Љ", :Lacute => "Ĺ", :Lambda => "Λ", :Lang => "《", :Laplacetrf => "ℒ", :Larr => "↞", :Lcaron => "Ľ", :Lcedil => "Ļ", :Lcy => "Л", :LeftAngleBracket => "〈", :LeftArrow => "←", :LeftArrowBar => "⇤", :LeftArrowRightArrow => "⇆", :LeftCeiling => "⌈", :LeftDoubleBracket => "〚", :LeftDownTeeVector => "⥡", :LeftDownVector => "⇃", :LeftDownVectorBar => "⥙", :LeftFloor => "⌊", :LeftRightArrow => "↔", :LeftRightVector => "⥎", :LeftTee => "⊣", :LeftTeeArrow => "↤", :LeftTeeVector => "⥚", :LeftTriangle => "⊲", :LeftTriangleBar => "⧏", :LeftTriangleEqual => "⊴", :LeftUpDownVector => "⥑", :LeftUpTeeVector => "⥠", :LeftUpVector => "↿", :LeftUpVectorBar => "⥘", :LeftVector => "↼", :LeftVectorBar => "⥒", :Leftarrow => "⇐", :Leftrightarrow => "⇔", :LessEqualGreater => "⋚", :LessFullEqual => "≦", :LessGreater => "≶", :LessLess => "⪡", :LessSlantEqual => "⩽", :LessTilde => "≲", :Lfr => "𝔏", :Ll => "⋘", :Lleftarrow => "⇚", :Lmidot => "Ŀ", :LongLeftArrow => "⟵", :LongLeftRightArrow => "⟷", :LongRightArrow => "⟶", :Longleftarrow => "⟸", :Longleftrightarrow => "⟺", :Longrightarrow => "⟹", :Lopf => "𝕃", :LowerLeftArrow => "↙", :LowerRightArrow => "↘", :Lscr => "ℒ", :Lsh => "↰", :Lstrok => "Ł", :Lt => "≪", :Map => "⤅", :Mcy => "М", :MediumSpace => " ", :Mellintrf => "ℳ", :Mfr => "𝔐", :MinusPlus => "∓", :Mopf => "𝕄", :Mscr => "ℳ", :NJcy => "Њ", :Nacute => "Ń", :Ncaron => "Ň", :Ncedil => "Ņ", :Ncy => "Н", :NegativeMediumSpace => "​", :NegativeThickSpace => "​", :NegativeThinSpace => "​", :NegativeVeryThinSpace => "​", :NestedGreaterGreater => "≫", :NestedLessLess => "≪", :NewLine => " ", :Nfr => "𝔑", :NoBreak => "⁠", :NonBreakingSpace => " ", :Nopf => "ℕ", :Not => "⫬", :NotCongruent => "≢", :NotCupCap => "≭", :NotDoubleVerticalBar => "∦", :NotElement => "∉", :NotEqual => "≠", :NotEqualTilde => "≂̸", :NotExists => "∄", :NotGreater => "≯", :NotGreaterEqual => "≱", :NotGreaterFullEqual => "≦̸", :NotGreaterGreater => "≫̸", :NotGreaterLess => "≹", :NotGreaterSlantEqual => "⩾̸", :NotGreaterTilde => "≵", :NotHumpDownHump => "≎̸", :NotHumpEqual => "≏̸", :NotLeftTriangle => "⋪", :NotLeftTriangleBar => "⧏̸", :NotLeftTriangleEqual => "⋬", :NotLess => "≮", :NotLessEqual => "≰", :NotLessGreater => "≸", :NotLessLess => "≪̸", :NotLessSlantEqual => "⩽̸", :NotLessTilde => "≴", :NotNestedGreaterGreater => "⪢̸", :NotNestedLessLess => "⪡̸", :NotPrecedes => "⊀", :NotPrecedesEqual => "⪯̸", :NotPrecedesSlantEqual => "⋠", :NotReverseElement => "∌", :NotRightTriangle => "⋫", :NotRightTriangleBar => "⧐̸", :NotRightTriangleEqual => "⋭", :NotSquareSubset => "⊏̸", :NotSquareSubsetEqual => "⋢", :NotSquareSuperset => "⊐̸", :NotSquareSupersetEqual => "⋣", :NotSubset => "⊂⃒", :NotSubsetEqual => "⊈", :NotSucceeds => "⊁", :NotSucceedsEqual => "⪰̸", :NotSucceedsSlantEqual => "⋡", :NotSucceedsTilde => "≿̸", :NotSuperset => "⊃⃒", :NotSupersetEqual => "⊉", :NotTilde => "≁", :NotTildeEqual => "≄", :NotTildeFullEqual => "≇", :NotTildeTilde => "≉", :NotVerticalBar => "∤", :Nscr => "𝒩", :Ntilde => "Ñ", :OElig => "Œ", :Oacute => "Ó", :Ocirc => "Ô", :Ocy => "О", :Odblac => "Ő", :Ofr => "𝔒", :Ograve => "Ò", :Omacr => "Ō", :Omega => "Ω", :Oopf => "𝕆", :OpenCurlyDoubleQuote => "“", :OpenCurlyQuote => "‘", :Or => "⩔", :Oscr => "𝒪", :Oslash => "Ø", :Otilde => "Õ", :Otimes => "⨷", :Ouml => "Ö", :OverBar => "¯", :OverBrace => "︷", :OverBracket => "⎴", :OverParenthesis => "︵", :PartialD => "∂", :Pcy => "П", :Pfr => "𝔓", :Phi => "Φ", :Pi => "Π", :PlusMinus => "±", :Poincareplane => "ℌ", :Popf => "ℙ", :Pr => "⪻", :Precedes => "≺", :PrecedesEqual => "⪯", :PrecedesSlantEqual => "≼", :PrecedesTilde => "≾", :Prime => "″", :Product => "∏", :Proportion => "∷", :Proportional => "∝", :Pscr => "𝒫", :Psi => "Ψ", :Qfr => "𝔔", :Qopf => "ℚ", :Qscr => "𝒬", :RBarr => "⤐", :Racute => "Ŕ", :Rang => "》", :Rarr => "↠", :Rarrtl => "⤖", :Rcaron => "Ř", :Rcedil => "Ŗ", :Rcy => "Р", :Re => "ℜ", :ReverseElement => "∋", :ReverseEquilibrium => "⇋", :ReverseUpEquilibrium => "⥯", :Rfr => "ℜ", :RightAngleBracket => "〉", :RightArrow => "→", :RightArrowBar => "⇥", :RightArrowLeftArrow => "⇄", :RightCeiling => "⌉", :RightDoubleBracket => "〛", :RightDownTeeVector => "⥝", :RightDownVector => "⇂", :RightDownVectorBar => "⥕", :RightFloor => "⌋", :RightTee => "⊢", :RightTeeArrow => "↦", :RightTeeVector => "⥛", :RightTriangle => "⊳", :RightTriangleBar => "⧐", :RightTriangleEqual => "⊵", :RightUpDownVector => "⥏", :RightUpTeeVector => "⥜", :RightUpVector => "↾", :RightUpVectorBar => "⥔", :RightVector => "⇀", :RightVectorBar => "⥓", :Rightarrow => "⇒", :Ropf => "ℝ", :RoundImplies => "⥰", :Rrightarrow => "⇛", :Rscr => "ℛ", :Rsh => "↱", :RuleDelayed => "⧴", :SHCHcy => "Щ", :SHcy => "Ш", :SOFTcy => "Ь", :Sacute => "Ś", :Sc => "⪼", :Scaron => "Š", :Scedil => "Ş", :Scirc => "Ŝ", :Scy => "С", :Sfr => "𝔖", :ShortDownArrow => "↓", :ShortLeftArrow => "←", :ShortRightArrow => "→", :ShortUpArrow => "↑", :Sigma => "Σ", :SmallCircle => "∘", :Sopf => "𝕊", :Sqrt => "√", :Square => "□", :SquareIntersection => "⊓", :SquareSubset => "⊏", :SquareSubsetEqual => "⊑", :SquareSuperset => "⊐", :SquareSupersetEqual => "⊒", :SquareUnion => "⊔", :Sscr => "𝒮", :Star => "⋆", :Sub => "⋐", :Subset => "⋐", :SubsetEqual => "⊆", :Succeeds => "≻", :SucceedsEqual => "⪰", :SucceedsSlantEqual => "≽", :SucceedsTilde => "≿", :SuchThat => "∋", :Sum => "∑", :Sup => "⋑", :Superset => "⊃", :SupersetEqual => "⊇", :Supset => "⋑", :THORN => "Þ", :TSHcy => "Ћ", :TScy => "Ц", :Tab => " ", :Tcaron => "Ť", :Tcedil => "Ţ", :Tcy => "Т", :Tfr => "𝔗", :Therefore => "∴", :Theta => "Θ", :ThickSpace => "   ", :ThinSpace => " ", :Tilde => "∼", :TildeEqual => "≃", :TildeFullEqual => "≅", :TildeTilde => "≈", :Topf => "𝕋", :TripleDot => "⃛", :Tscr => "𝒯", :Tstrok => "Ŧ", :Uacute => "Ú", :Uarr => "↟", :Uarrocir => "⥉", :Ubrcy => "Ў", :Ubreve => "Ŭ", :Ucirc => "Û", :Ucy => "У", :Udblac => "Ű", :Ufr => "𝔘", :Ugrave => "Ù", :Umacr => "Ū", :UnderBar => "̲", :UnderBrace => "︸", :UnderBracket => "⎵", :UnderParenthesis => "︶", :Union => "⋃", :UnionPlus => "⊎", :Uogon => "Ų", :Uopf => "𝕌", :UpArrow => "↑", :UpArrowBar => "⤒", :UpArrowDownArrow => "⇅", :UpDownArrow => "↕", :UpEquilibrium => "⥮", :UpTee => "⊥", :UpTeeArrow => "↥", :Uparrow => "⇑", :Updownarrow => "⇕", :UpperLeftArrow => "↖", :UpperRightArrow => "↗", :Upsi => "ϒ", :Upsilon => "Υ", :Uring => "Ů", :Uscr => "𝒰", :Utilde => "Ũ", :Uuml => "Ü", :VDash => "⊫", :Vbar => "⫫", :Vcy => "В", :Vdash => "⊩", :Vdashl => "⫦", :Vee => "⋁", :Verbar => "‖", :Vert => "‖", :VerticalBar => "∣", :VerticalLine => "|", :VerticalSeparator => "❘", :VerticalTilde => "≀", :VeryThinSpace => " ", :Vfr => "𝔙", :Vopf => "𝕍", :Vscr => "𝒱", :Vvdash => "⊪", :Wcirc => "Ŵ", :Wedge => "⋀", :Wfr => "𝔚", :Wopf => "𝕎", :Wscr => "𝒲", :Xfr => "𝔛", :Xi => "Ξ", :Xopf => "𝕏", :Xscr => "𝒳", :YAcy => "Я", :YIcy => "Ї", :YUcy => "Ю", :Yacute => "Ý", :Ycirc => "Ŷ", :Ycy => "Ы", :Yfr => "𝔜", :Yopf => "𝕐", :Yscr => "𝒴", :Yuml => "Ÿ", :ZHcy => "Ж", :Zacute => "Ź", :Zcaron => "Ž", :Zcy => "З", :Zdot => "Ż", :ZeroWidthSpace => "​", :Zfr => "ℨ", :Zopf => "ℤ", :Zscr => "𝒵", :aacute => "á", :abreve => "ă", :ac => "∾", :acE => "∾̳", :acd => "∿", :acirc => "â", :acute => "´", :acy => "а", :aelig => "æ", :af => "⁡", :afr => "𝔞", :agrave => "à", :aleph => "ℵ", :alpha => "α", :amacr => "ā", :amalg => "⨿", :amp => "&", :and => "∧", :andand => "⩕", :andd => "⩜", :andslope => "⩘", :andv => "⩚", :ang => "∠", :ange => "⦤", :angle => "∠", :angmsd => "∡", :angmsdaa => "⦨", :angmsdab => "⦩", :angmsdac => "⦪", :angmsdad => "⦫", :angmsdae => "⦬", :angmsdaf => "⦭", :angmsdag => "⦮", :angmsdah => "⦯", :angrt => "∟", :angrtvb => "⊾", :angrtvbd => "⦝", :angsph => "∢", :angst => "Å", :angzarr => "⍼", :aogon => "ą", :aopf => "𝕒", :ap => "≈", :apE => "⩰", :apacir => "⩯", :ape => "≊", :apid => "≋", :apos => "'", :approx => "≈", :approxeq => "≊", :aring => "å", :ascr => "𝒶", :ast => "*", :asymp => "≈", :asympeq => "≍", :atilde => "ã", :auml => "ä", :awconint => "∳", :awint => "⨑", :bNot => "⫭", :backcong => "≌", :backepsilon => "϶", :backprime => "‵", :backsim => "∽", :backsimeq => "⋍", :barvee => "⊽", :barwed => "⌅", :barwedge => "⌅", :bbrk => "⎵", :bbrktbrk => "⎶", :bcong => "≌", :bcy => "б", :becaus => "∵", :because => "∵", :bemptyv => "⦰", :bepsi => "϶", :bernou => "ℬ", :beta => "β", :beth => "ℶ", :between => "≬", :bfr => "𝔟", :bigcap => "⋂", :bigcirc => "◯", :bigcup => "⋃", :bigodot => "⨀", :bigoplus => "⨁", :bigotimes => "⨂", :bigsqcup => "⨆", :bigstar => "★", :bigtriangledown => "▽", :bigtriangleup => "△", :biguplus => "⨄", :bigvee => "⋁", :bigwedge => "⋀", :bkarow => "⤍", :blacklozenge => "⧫", :blacksquare => "▪", :blacktriangle => "▴", :blacktriangledown => "▾", :blacktriangleleft => "◂", :blacktriangleright => "▸", :blank => "␣", :blk12 => "▒", :blk14 => "░", :blk34 => "▓", :block => "█", :bne => "=⃥", :bnequiv => "≡⃥", :bnot => "⌐", :bopf => "𝕓", :bot => "⊥", :bottom => "⊥", :bowtie => "⋈", :boxDL => "╗", :boxDR => "╔", :boxDl => "╖", :boxDr => "╓", :boxH => "═", :boxHD => "╦", :boxHU => "╩", :boxHd => "╤", :boxHu => "╧", :boxUL => "╝", :boxUR => "╚", :boxUl => "╜", :boxUr => "╙", :boxV => "║", :boxVH => "╬", :boxVL => "╣", :boxVR => "╠", :boxVh => "╫", :boxVl => "╢", :boxVr => "╟", :boxbox => "⧉", :boxdL => "╕", :boxdR => "╒", :boxdl => "┐", :boxdr => "┌", :boxh => "─", :boxhD => "╥", :boxhU => "╨", :boxhd => "┬", :boxhu => "┴", :boxminus => "⊟", :boxplus => "⊞", :boxtimes => "⊠", :boxuL => "╛", :boxuR => "╘", :boxul => "┘", :boxur => "└", :boxv => "│", :boxvH => "╪", :boxvL => "╡", :boxvR => "╞", :boxvh => "┼", :boxvl => "┤", :boxvr => "├", :bprime => "‵", :breve => "˘", :brvbar => "¦", :bscr => "𝒷", :bsemi => "⁏", :bsim => "∽", :bsime => "⋍", :bsol => "\\", :bsolb => "⧅", :bsolhsub => "\\⊂", :bull => "•", :bullet => "•", :bump => "≎", :bumpE => "⪮", :bumpe => "≏", :bumpeq => "≏", :cacute => "ć", :cap => "∩", :capand => "⩄", :capbrcup => "⩉", :capcap => "⩋", :capcup => "⩇", :capdot => "⩀", :caps => "∩︀", :caret => "⁁", :caron => "ˇ", :ccaps => "⩍", :ccaron => "č", :ccedil => "ç", :ccirc => "ĉ", :ccups => "⩌", :ccupssm => "⩐", :cdot => "ċ", :cedil => "¸", :cemptyv => "⦲", :cent => "¢", :centerdot => "·", :cfr => "𝔠", :chcy => "ч", :check => "✓", :checkmark => "✓", :chi => "χ", :cir => "○", :cirE => "⧃", :circ => "ˆ", :circeq => "≗", :circlearrowleft => "↺", :circlearrowright => "↻", :circledR => "®", :circledS => "Ⓢ", :circledast => "⊛", :circledcirc => "⊚", :circleddash => "⊝", :cire => "≗", :cirfnint => "⨐", :cirmid => "⫯", :cirscir => "⧂", :clubs => "♣", :clubsuit => "♣", :colon => ":", :colone => "≔", :coloneq => "≔", :comma => ",", :commat => "@", :comp => "∁", :compfn => "∘", :complement => "∁", :complexes => "ℂ", :cong => "≅", :congdot => "⩭", :conint => "∮", :copf => "𝕔", :coprod => "∐", :copy => "©", :copysr => "℗", :cross => "✗", :cscr => "𝒸", :csub => "⫏", :csube => "⫑", :csup => "⫐", :csupe => "⫒", :ctdot => "⋯", :cudarrl => "⤸", :cudarrr => "⤵", :cuepr => "⋞", :cuesc => "⋟", :cularr => "↶", :cularrp => "⤽", :cup => "∪", :cupbrcap => "⩈", :cupcap => "⩆", :cupcup => "⩊", :cupdot => "⊍", :cupor => "⩅", :cups => "∪︀", :curarr => "↷", :curarrm => "⤼", :curlyeqprec => "⋞", :curlyeqsucc => "⋟", :curlyvee => "⋎", :curlywedge => "⋏", :curren => "¤", :curvearrowleft => "↶", :curvearrowright => "↷", :cuvee => "⋎", :cuwed => "⋏", :cwconint => "∲", :cwint => "∱", :cylcty => "⌭", :dArr => "⇓", :dHar => "⥥", :dagger => "†", :daleth => "ℸ", :darr => "↓", :dash => "‐", :dashv => "⊣", :dbkarow => "⤏", :dblac => "˝", :dcaron => "ď", :dcy => "д", :dd => "ⅆ", :ddagger => "‡", :ddarr => "⇊", :ddotseq => "⩷", :deg => "°", :delta => "δ", :demptyv => "⦱", :dfisht => "⥿", :dfr => "𝔡", :dharl => "⇃", :dharr => "⇂", :diam => "⋄", :diamond => "⋄", :diamondsuit => "♦", :diams => "♦", :die => "¨", :digamma => "ϝ", :disin => "⋲", :div => "÷", :divide => "÷", :divideontimes => "⋇", :divonx => "⋇", :djcy => "ђ", :dlcorn => "⌞", :dlcrop => "⌍", :dollar => "$", :dopf => "𝕕", :dot => "˙", :doteq => "≐", :doteqdot => "≑", :dotminus => "∸", :dotplus => "∔", :dotsquare => "⊡", :doublebarwedge => "⌆", :downarrow => "↓", :downdownarrows => "⇊", :downharpoonleft => "⇃", :downharpoonright => "⇂", :drbkarow => "⤐", :drcorn => "⌟", :drcrop => "⌌", :dscr => "𝒹", :dscy => "ѕ", :dsol => "⧶", :dstrok => "đ", :dtdot => "⋱", :dtri => "▿", :dtrif => "▾", :duarr => "⇵", :duhar => "⥯", :dwangle => "⦦", :dzcy => "џ", :dzigrarr => "⟿", :eDDot => "⩷", :eDot => "≑", :eacute => "é", :easter => "⩮", :ecaron => "ě", :ecir => "≖", :ecirc => "ê", :ecolon => "≕", :ecy => "э", :edot => "ė", :ee => "ⅇ", :efDot => "≒", :efr => "𝔢", :eg => "⪚", :egrave => "è", :egs => "⪖", :egsdot => "⪘", :el => "⪙", :elinters => "�", :ell => "ℓ", :els => "⪕", :elsdot => "⪗", :emacr => "ē", :empty => "∅", :emptyset => "∅", :emptyv => "∅", :emsp => " ", :emsp13 => " ", :emsp14 => " ", :eng => "ŋ", :ensp => " ", :eogon => "ę", :eopf => "𝕖", :epar => "⋕", :eparsl => "⧣", :eplus => "⩱", :epsi => "ϵ", :epsiv => "ε", :eqcirc => "≖", :eqcolon => "≕", :eqsim => "≂", :eqslantgtr => "⪖", :eqslantless => "⪕", :equals => "=", :equest => "≟", :equiv => "≡", :equivDD => "⩸", :eqvparsl => "⧥", :erDot => "≓", :erarr => "⥱", :escr => "ℯ", :esdot => "≐", :esim => "≂", :eta => "η", :eth => "ð", :euml => "ë", :excl => "!", :exist => "∃", :expectation => "ℰ", :exponentiale => "ⅇ", :fallingdotseq => "≒", :fcy => "ф", :female => "♀", :ffilig => "ffi", :fflig => "ff", :ffllig => "ffl", :ffr => "𝔣", :filig => "fi", :flat => "♭", :fllig => "fl", :fltns => "▱", :fnof => "ƒ", :fopf => "𝕗", :forall => "∀", :fork => "⋔", :forkv => "⫙", :fpartint => "⨍", :frac12 => "½", :frac13 => "⅓", :frac14 => "¼", :frac15 => "⅕", :frac16 => "⅙", :frac18 => "⅛", :frac23 => "⅔", :frac25 => "⅖", :frac34 => "¾", :frac35 => "⅗", :frac38 => "⅜", :frac45 => "⅘", :frac56 => "⅚", :frac58 => "⅝", :frac78 => "⅞", :frown => "⌢", :fscr => "𝒻", :gE => "≧", :gEl => "⪌", :gacute => "ǵ", :gamma => "γ", :gammad => "ϝ", :gap => "⪆", :gbreve => "ğ", :gcirc => "ĝ", :gcy => "г", :gdot => "ġ", :ge => "≥", :gel => "⋛", :geq => "≥", :geqq => "≧", :geqslant => "⩾", :ges => "⩾", :gescc => "⪩", :gesdot => "⪀", :gesdoto => "⪂", :gesdotol => "⪄", :gesl => "⋛︀", :gesles => "⪔", :gfr => "𝔤", :gg => "≫", :ggg => "⋙", :gimel => "ℷ", :gjcy => "ѓ", :gl => "≷", :glE => "⪒", :gla => "⪥", :glj => "⪤", :gnE => "≩", :gnap => "⪊", :gnapprox => "⪊", :gne => "⪈", :gneq => "⪈", :gneqq => "≩", :gnsim => "⋧", :gopf => "𝕘", :grave => "`", :gscr => "ℊ", :gsim => "≳", :gsime => "⪎", :gsiml => "⪐", :gt => ">", :gtcc => "⪧", :gtcir => "⩺", :gtdot => "⋗", :gtlPar => "⦕", :gtquest => "⩼", :gtrapprox => "⪆", :gtrarr => "⥸", :gtrdot => "⋗", :gtreqless => "⋛", :gtreqqless => "⪌", :gtrless => "≷", :gtrsim => "≳", :gvertneqq => "≩︀", :gvnE => "≩︀", :hArr => "⇔", :hairsp => " ", :half => "½", :hamilt => "ℋ", :hardcy => "ъ", :harr => "↔", :harrcir => "⥈", :harrw => "↭", :hbar => "ℏ", :hcirc => "ĥ", :hearts => "♥", :heartsuit => "♥", :hellip => "…", :hercon => "⊹", :hfr => "𝔥", :hksearow => "⤥", :hkswarow => "⤦", :hoarr => "⇿", :homtht => "∻", :hookleftarrow => "↩", :hookrightarrow => "↪", :hopf => "𝕙", :horbar => "―", :hscr => "𝒽", :hslash => "ℏ", :hstrok => "ħ", :hybull => "⁃", :hyphen => "‐", :iacute => "í", :ic => "⁣", :icirc => "î", :icy => "и", :iecy => "е", :iexcl => "¡", :iff => "⇔", :ifr => "𝔦", :igrave => "ì", :ii => "ⅈ", :iiiint => "⨌", :iiint => "∭", :iinfin => "⧜", :iiota => "℩", :ijlig => "ij", :imacr => "ī", :image => "ℑ", :imagline => "ℐ", :imagpart => "ℑ", :imath => "ı", :imof => "⊷", :imped => "Ƶ", :in => "∈", :incare => "℅", :infin => "∞", :infintie => "⧝", :inodot => "ı", :int => "∫", :intcal => "⊺", :integers => "ℤ", :intercal => "⊺", :intlarhk => "⨗", :intprod => "⨼", :iocy => "ё", :iogon => "į", :iopf => "𝕚", :iota => "ι", :iprod => "⨼", :iquest => "¿", :iscr => "𝒾", :isin => "∈", :isinE => "⋹", :isindot => "⋵", :isins => "⋴", :isinsv => "⋳", :isinv => "∈", :it => "⁢", :itilde => "ĩ", :iukcy => "і", :iuml => "ï", :jcirc => "ĵ", :jcy => "й", :jfr => "𝔧", :jmath => "j", :jopf => "𝕛", :jscr => "𝒿", :jsercy => "ј", :jukcy => "є", :kappa => "κ", :kappav => "ϰ", :kcedil => "ķ", :kcy => "к", :kfr => "𝔨", :kgreen => "ĸ", :khcy => "х", :kjcy => "ќ", :kopf => "𝕜", :kscr => "𝓀", :lAarr => "⇚", :lArr => "⇐", :lAtail => "⤛", :lBarr => "⤎", :lE => "≦", :lEg => "⪋", :lHar => "⥢", :lacute => "ĺ", :laemptyv => "⦴", :lagran => "ℒ", :lambda => "λ", :lang => "〈", :langd => "⦑", :langle => "〈", :lap => "⪅", :laquo => "«", :larr => "←", :larrb => "⇤", :larrbfs => "⤟", :larrfs => "⤝", :larrhk => "↩", :larrlp => "↫", :larrpl => "⤹", :larrsim => "⥳", :larrtl => "↢", :lat => "⪫", :latail => "⤙", :late => "⪭", :lates => "⪭︀", :lbarr => "⤌", :lbbrk => "〔", :lbrace => "{", :lbrack => "[", :lbrke => "⦋", :lbrksld => "⦏", :lbrkslu => "⦍", :lcaron => "ľ", :lcedil => "ļ", :lceil => "⌈", :lcub => "{", :lcy => "л", :ldca => "⤶", :ldquo => "“", :ldquor => "„", :ldrdhar => "⥧", :ldrushar => "⥋", :ldsh => "↲", :le => "≤", :leftarrow => "←", :leftarrowtail => "↢", :leftharpoondown => "↽", :leftharpoonup => "↼", :leftleftarrows => "⇇", :leftrightarrow => "↔", :leftrightarrows => "⇆", :leftrightharpoons => "⇋", :leftrightsquigarrow => "↭", :leftthreetimes => "⋋", :leg => "⋚", :leq => "≤", :leqq => "≦", :leqslant => "⩽", :les => "⩽", :lescc => "⪨", :lesdot => "⩿", :lesdoto => "⪁", :lesdotor => "⪃", :lesg => "⋚︀", :lesges => "⪓", :lessapprox => "⪅", :lessdot => "⋖", :lesseqgtr => "⋚", :lesseqqgtr => "⪋", :lessgtr => "≶", :lesssim => "≲", :lfisht => "⥼", :lfloor => "⌊", :lfr => "𝔩", :lg => "≶", :lgE => "⪑", :lhard => "↽", :lharu => "↼", :lharul => "⥪", :lhblk => "▄", :ljcy => "љ", :ll => "≪", :llarr => "⇇", :llcorner => "⌞", :llhard => "⥫", :lltri => "◺", :lmidot => "ŀ", :lmoust => "⎰", :lmoustache => "⎰", :lnE => "≨", :lnap => "⪉", :lnapprox => "⪉", :lne => "⪇", :lneq => "⪇", :lneqq => "≨", :lnsim => "⋦", :loang => "〘", :loarr => "⇽", :lobrk => "〚", :longleftarrow => "⟵", :longleftrightarrow => "⟷", :longmapsto => "⟼", :longrightarrow => "⟶", :looparrowleft => "↫", :looparrowright => "↬", :lopar => "⦅", :lopf => "𝕝", :loplus => "⨭", :lotimes => "⨴", :lowast => "∗", :lowbar => "_", :loz => "◊", :lozenge => "◊", :lozf => "⧫", :lpar => "(", :lparlt => "⦓", :lrarr => "⇆", :lrcorner => "⌟", :lrhar => "⇋", :lrhard => "⥭", :lrtri => "⊿", :lscr => "𝓁", :lsh => "↰", :lsim => "≲", :lsime => "⪍", :lsimg => "⪏", :lsqb => "[", :lsquo => "‘", :lsquor => "‚", :lstrok => "ł", :lt => "<", :ltcc => "⪦", :ltcir => "⩹", :ltdot => "⋖", :lthree => "⋋", :ltimes => "⋉", :ltlarr => "⥶", :ltquest => "⩻", :ltrPar => "⦖", :ltri => "◃", :ltrie => "⊴", :ltrif => "◂", :lurdshar => "⥊", :luruhar => "⥦", :lvertneqq => "≨︀", :lvnE => "≨︀", :mDDot => "∺", :macr => "¯", :male => "♂", :malt => "✠", :maltese => "✠", :map => "↦", :mapsto => "↦", :mapstodown => "↧", :mapstoleft => "↤", :mapstoup => "↥", :marker => "▮", :mcomma => "⨩", :mcy => "м", :mdash => "—", :measuredangle => "∡", :mfr => "𝔪", :mho => "℧", :micro => "µ", :mid => "∣", :midast => "*", :midcir => "⫰", :middot => "·", :minus => "−", :minusb => "⊟", :minusd => "∸", :minusdu => "⨪", :mlcp => "⫛", :mldr => "…", :mnplus => "∓", :models => "⊧", :mopf => "𝕞", :mp => "∓", :mscr => "𝓂", :mstpos => "∾", :mu => "μ", :multimap => "⊸", :mumap => "⊸", :nGg => "⋙̸", :nGt => "≫⃒", :nGtv => "≫̸", :nLeftarrow => "⇍", :nLeftrightarrow => "⇎", :nLl => "⋘̸", :nLt => "≪⃒", :nLtv => "≪̸", :nRightarrow => "⇏", :nVDash => "⊯", :nVdash => "⊮", :nabla => "∇", :nacute => "ń", :nang => "∠⃒", :nap => "≉", :napE => "⩰̸", :napid => "≋̸", :napos => "ʼn", :napprox => "≉", :natur => "♮", :natural => "♮", :naturals => "ℕ", :nbsp => " ", :nbump => "≎̸", :nbumpe => "≏̸", :ncap => "⩃", :ncaron => "ň", :ncedil => "ņ", :ncong => "≇", :ncongdot => "⩭̸", :ncup => "⩂", :ncy => "н", :ndash => "–", :ne => "≠", :neArr => "⇗", :nearhk => "⤤", :nearr => "↗", :nearrow => "↗", :nedot => "≐̸", :nequiv => "≢", :nesear => "⤨", :nesim => "≂̸", :nexist => "∄", :nexists => "∄", :nfr => "𝔫", :ngE => "≧̸", :nge => "≱", :ngeq => "≱", :ngeqq => "≧̸", :ngeqslant => "⩾̸", :nges => "⩾̸", :ngsim => "≵", :ngt => "≯", :ngtr => "≯", :nhArr => "⇎", :nharr => "↮", :nhpar => "⫲", :ni => "∋", :nis => "⋼", :nisd => "⋺", :niv => "∋", :njcy => "њ", :nlArr => "⇍", :nlE => "≦̸", :nlarr => "↚", :nldr => "‥", :nle => "≰", :nleftarrow => "↚", :nleftrightarrow => "↮", :nleq => "≰", :nleqq => "≦̸", :nleqslant => "⩽̸", :nles => "⩽̸", :nless => "≮", :nlsim => "≴", :nlt => "≮", :nltri => "⋪", :nltrie => "⋬", :nmid => "∤", :nopf => "𝕟", :not => "¬", :notin => "∉", :notinE => "⋹̸", :notindot => "⋵̸", :notinva => "∉", :notinvb => "⋷", :notinvc => "⋶", :notni => "∌", :notniva => "∌", :notnivb => "⋾", :notnivc => "⋽", :npar => "∦", :nparallel => "∦", :nparsl => "⫽⃥", :npart => "∂̸", :npolint => "⨔", :npr => "⊀", :nprcue => "⋠", :npre => "⪯̸", :nprec => "⊀", :npreceq => "⪯̸", :nrArr => "⇏", :nrarr => "↛", :nrarrc => "⤳̸", :nrarrw => "↝̸", :nrightarrow => "↛", :nrtri => "⋫", :nrtrie => "⋭", :nsc => "⊁", :nsccue => "⋡", :nsce => "⪰̸", :nscr => "𝓃", :nshortmid => "∤", :nshortparallel => "∦", :nsim => "≁", :nsime => "≄", :nsimeq => "≄", :nsmid => "∤", :nspar => "∦", :nsqsube => "⋢", :nsqsupe => "⋣", :nsub => "⊄", :nsubE => "⫅̸", :nsube => "⊈", :nsubset => "⊂⃒", :nsubseteq => "⊈", :nsubseteqq => "⫅̸", :nsucc => "⊁", :nsucceq => "⪰̸", :nsup => "⊅", :nsupE => "⫆̸", :nsupe => "⊉", :nsupset => "⊃⃒", :nsupseteq => "⊉", :nsupseteqq => "⫆̸", :ntgl => "≹", :ntilde => "ñ", :ntlg => "≸", :ntriangleleft => "⋪", :ntrianglelefteq => "⋬", :ntriangleright => "⋫", :ntrianglerighteq => "⋭", :nu => "ν", :num => "#", :numero => "№", :numsp => " ", :nvDash => "⊭", :nvHarr => "⤄", :nvap => "≍⃒", :nvdash => "⊬", :nvge => "≥⃒", :nvgt => ">⃒", :nvinfin => "⧞", :nvlArr => "⤂", :nvle => "≤⃒", :nvlt => "<⃒", :nvltrie => "⊴⃒", :nvrArr => "⤃", :nvrtrie => "⊵⃒", :nvsim => "∼⃒", :nwArr => "⇖", :nwarhk => "⤣", :nwarr => "↖", :nwarrow => "↖", :nwnear => "⤧", :oS => "Ⓢ", :oacute => "ó", :oast => "⊛", :ocir => "⊚", :ocirc => "ô", :ocy => "о", :odash => "⊝", :odblac => "ő", :odiv => "⨸", :odot => "⊙", :odsold => "⦼", :oelig => "œ", :ofcir => "⦿", :ofr => "𝔬", :ogon => "˛", :ograve => "ò", :ogt => "⧁", :ohbar => "⦵", :ohm => "Ω", :oint => "∮", :olarr => "↺", :olcir => "⦾", :olcross => "⦻", :olt => "⧀", :omacr => "ō", :omega => "ω", :omid => "⦶", :ominus => "⊖", :oopf => "𝕠", :opar => "⦷", :operp => "⦹", :oplus => "⊕", :or => "∨", :orarr => "↻", :ord => "⩝", :order => "ℴ", :orderof => "ℴ", :ordf => "ª", :ordm => "º", :origof => "⊶", :oror => "⩖", :orslope => "⩗", :orv => "⩛", :oscr => "ℴ", :oslash => "ø", :osol => "⊘", :otilde => "õ", :otimes => "⊗", :otimesas => "⨶", :ouml => "ö", :ovbar => "⌽", :par => "∥", :para => "¶", :parallel => "∥", :parsim => "⫳", :parsl => "⫽", :part => "∂", :pcy => "п", :percnt => "%", :period => ".", :permil => "‰", :perp => "⊥", :pertenk => "‱", :pfr => "𝔭", :phi => "ϕ", :phiv => "φ", :phmmat => "ℳ", :phone => "☎", :pi => "π", :pitchfork => "⋔", :piv => "ϖ", :planck => "ℏ", :planckh => "ℎ", :plankv => "ℏ", :plus => "+", :plusacir => "⨣", :plusb => "⊞", :pluscir => "⨢", :plusdo => "∔", :plusdu => "⨥", :pluse => "⩲", :plusmn => "±", :plussim => "⨦", :plustwo => "⨧", :pm => "±", :pointint => "⨕", :popf => "𝕡", :pound => "£", :pr => "≺", :prE => "⪳", :prap => "⪷", :prcue => "≼", :pre => "⪯", :prec => "≺", :precapprox => "⪷", :preccurlyeq => "≼", :preceq => "⪯", :precnapprox => "⪹", :precneqq => "⪵", :precnsim => "⋨", :precsim => "≾", :prime => "′", :primes => "ℙ", :prnE => "⪵", :prnap => "⪹", :prnsim => "⋨", :prod => "∏", :profalar => "⌮", :profline => "⌒", :profsurf => "⌓", :prop => "∝", :propto => "∝", :prsim => "≾", :prurel => "⊰", :pscr => "𝓅", :psi => "ψ", :puncsp => " ", :qfr => "𝔮", :qint => "⨌", :qopf => "𝕢", :qprime => "⁗", :qscr => "𝓆", :quaternions => "ℍ", :quatint => "⨖", :quest => "?", :questeq => "≟", :quot => "\"", :rAarr => "⇛", :rArr => "⇒", :rAtail => "⤜", :rBarr => "⤏", :rHar => "⥤", :race => "⧚", :racute => "ŕ", :radic => "√", :raemptyv => "⦳", :rang => "〉", :rangd => "⦒", :range => "⦥", :rangle => "〉", :raquo => "»", :rarr => "→", :rarrap => "⥵", :rarrb => "⇥", :rarrbfs => "⤠", :rarrc => "⤳", :rarrfs => "⤞", :rarrhk => "↪", :rarrlp => "↬", :rarrpl => "⥅", :rarrsim => "⥴", :rarrtl => "↣", :rarrw => "↝", :ratail => "⤚", :ratio => "∶", :rationals => "ℚ", :rbarr => "⤍", :rbbrk => "〕", :rbrace => "}", :rbrack => "]", :rbrke => "⦌", :rbrksld => "⦎", :rbrkslu => "⦐", :rcaron => "ř", :rcedil => "ŗ", :rceil => "⌉", :rcub => "}", :rcy => "р", :rdca => "⤷", :rdldhar => "⥩", :rdquo => "”", :rdquor => "”", :rdsh => "↳", :real => "ℜ", :realine => "ℛ", :realpart => "ℜ", :reals => "ℝ", :rect => "▭", :reg => "®", :rfisht => "⥽", :rfloor => "⌋", :rfr => "𝔯", :rhard => "⇁", :rharu => "⇀", :rharul => "⥬", :rho => "ρ", :rhov => "ϱ", :rightarrow => "→", :rightarrowtail => "↣", :rightharpoondown => "⇁", :rightharpoonup => "⇀", :rightleftarrows => "⇄", :rightleftharpoons => "⇌", :rightrightarrows => "⇉", :rightsquigarrow => "↝", :rightthreetimes => "⋌", :ring => "˚", :risingdotseq => "≓", :rlarr => "⇄", :rlhar => "⇌", :rmoust => "⎱", :rmoustache => "⎱", :rnmid => "⫮", :roang => "〙", :roarr => "⇾", :robrk => "〛", :ropar => "⦆", :ropf => "𝕣", :roplus => "⨮", :rotimes => "⨵", :rpar => ")", :rpargt => "⦔", :rppolint => "⨒", :rrarr => "⇉", :rscr => "𝓇", :rsh => "↱", :rsqb => "]", :rsquo => "’", :rsquor => "’", :rthree => "⋌", :rtimes => "⋊", :rtri => "▹", :rtrie => "⊵", :rtrif => "▸", :rtriltri => "⧎", :ruluhar => "⥨", :rx => "℞", :sacute => "ś", :sc => "≻", :scE => "⪴", :scap => "⪸", :scaron => "š", :sccue => "≽", :sce => "⪰", :scedil => "ş", :scirc => "ŝ", :scnE => "⪶", :scnap => "⪺", :scnsim => "⋩", :scpolint => "⨓", :scsim => "≿", :scy => "с", :sdot => "⋅", :sdotb => "⊡", :sdote => "⩦", :seArr => "⇘", :searhk => "⤥", :searr => "↘", :searrow => "↘", :sect => "§", :semi => ";", :seswar => "⤩", :setminus => "∖", :setmn => "∖", :sext => "✶", :sfr => "𝔰", :sfrown => "⌢", :sharp => "♯", :shchcy => "щ", :shcy => "ш", :shortmid => "∣", :shortparallel => "∥", :shy => "­", :sigma => "σ", :sigmav => "ς", :sim => "∼", :simdot => "⩪", :sime => "≃", :simeq => "≃", :simg => "⪞", :simgE => "⪠", :siml => "⪝", :simlE => "⪟", :simne => "≆", :simplus => "⨤", :simrarr => "⥲", :slarr => "←", :smallsetminus => "∖", :smashp => "⨳", :smeparsl => "⧤", :smid => "∣", :smile => "⌣", :smt => "⪪", :smte => "⪬", :smtes => "⪬︀", :softcy => "ь", :sol => "/", :solb => "⧄", :solbar => "⌿", :sopf => "𝕤", :spades => "♠", :spadesuit => "♠", :spar => "∥", :sqcap => "⊓", :sqcaps => "⊓︀", :sqcup => "⊔", :sqcups => "⊔︀", :sqsub => "⊏", :sqsube => "⊑", :sqsubset => "⊏", :sqsubseteq => "⊑", :sqsup => "⊐", :sqsupe => "⊒", :sqsupset => "⊐", :sqsupseteq => "⊒", :squ => "□", :square => "□", :squarf => "▪", :squf => "▪", :srarr => "→", :sscr => "𝓈", :ssetmn => "∖", :ssmile => "⌣", :sstarf => "⋆", :star => "☆", :starf => "★", :straightepsilon => "ϵ", :straightphi => "ϕ", :strns => "¯", :sub => "⊂", :subE => "⫅", :subdot => "⪽", :sube => "⊆", :subedot => "⫃", :submult => "⫁", :subnE => "⫋", :subne => "⊊", :subplus => "⪿", :subrarr => "⥹", :subset => "⊂", :subseteq => "⊆", :subseteqq => "⫅", :subsetneq => "⊊", :subsetneqq => "⫋", :subsim => "⫇", :subsub => "⫕", :subsup => "⫓", :succ => "≻", :succapprox => "⪸", :succcurlyeq => "≽", :succeq => "⪰", :succnapprox => "⪺", :succneqq => "⪶", :succnsim => "⋩", :succsim => "≿", :sum => "∑", :sung => "♪", :sup => "⊃", :sup1 => "¹", :sup2 => "²", :sup3 => "³", :supE => "⫆", :supdot => "⪾", :supdsub => "⫘", :supe => "⊇", :supedot => "⫄", :suphsol => "⊃/", :suphsub => "⫗", :suplarr => "⥻", :supmult => "⫂", :supnE => "⫌", :supne => "⊋", :supplus => "⫀", :supset => "⊃", :supseteq => "⊇", :supseteqq => "⫆", :supsetneq => "⊋", :supsetneqq => "⫌", :supsim => "⫈", :supsub => "⫔", :supsup => "⫖", :swArr => "⇙", :swarhk => "⤦", :swarr => "↙", :swarrow => "↙", :swnwar => "⤪", :szlig => "ß", :target => "⌖", :tau => "τ", :tbrk => "⎴", :tcaron => "ť", :tcedil => "ţ", :tcy => "т", :tdot => "⃛", :telrec => "⌕", :tfr => "𝔱", :there4 => "∴", :therefore => "∴", :theta => "θ", :thetav => "ϑ", :thickapprox => "≈", :thicksim => "∼", :thinsp => " ", :thkap => "≈", :thksim => "∼", :thorn => "þ", :tilde => "˜", :times => "×", :timesb => "⊠", :timesbar => "⨱", :timesd => "⨰", :tint => "∭", :toea => "⤨", :top => "⊤", :topbot => "⌶", :topcir => "⫱", :topf => "𝕥", :topfork => "⫚", :tosa => "⤩", :tprime => "‴", :trade => "™", :triangle => "▵", :triangledown => "▿", :triangleleft => "◃", :trianglelefteq => "⊴", :triangleq => "≜", :triangleright => "▹", :trianglerighteq => "⊵", :tridot => "◬", :trie => "≜", :triminus => "⨺", :triplus => "⨹", :trisb => "⧍", :tritime => "⨻", :trpezium => "�", :tscr => "𝓉", :tscy => "ц", :tshcy => "ћ", :tstrok => "ŧ", :twixt => "≬", :twoheadleftarrow => "↞", :twoheadrightarrow => "↠", :uArr => "⇑", :uHar => "⥣", :uacute => "ú", :uarr => "↑", :ubrcy => "ў", :ubreve => "ŭ", :ucirc => "û", :ucy => "у", :udarr => "⇅", :udblac => "ű", :udhar => "⥮", :ufisht => "⥾", :ufr => "𝔲", :ugrave => "ù", :uharl => "↿", :uharr => "↾", :uhblk => "▀", :ulcorn => "⌜", :ulcorner => "⌜", :ulcrop => "⌏", :ultri => "◸", :umacr => "ū", :uml => "¨", :uogon => "ų", :uopf => "𝕦", :uparrow => "↑", :updownarrow => "↕", :upharpoonleft => "↿", :upharpoonright => "↾", :uplus => "⊎", :upsi => "υ", :upsilon => "υ", :upuparrows => "⇈", :urcorn => "⌝", :urcorner => "⌝", :urcrop => "⌎", :uring => "ů", :urtri => "◹", :uscr => "𝓊", :utdot => "⋰", :utilde => "ũ", :utri => "▵", :utrif => "▴", :uuarr => "⇈", :uuml => "ü", :uwangle => "⦧", :vArr => "⇕", :vBar => "⫨", :vBarv => "⫩", :vDash => "⊨", :vangrt => "⦜", :varepsilon => "ε", :varkappa => "ϰ", :varnothing => "∅", :varphi => "φ", :varpi => "ϖ", :varpropto => "∝", :varr => "↕", :varrho => "ϱ", :varsigma => "ς", :varsubsetneq => "⊊︀", :varsubsetneqq => "⫋︀", :varsupsetneq => "⊋︀", :varsupsetneqq => "⫌︀", :vartheta => "ϑ", :vartriangleleft => "⊲", :vartriangleright => "⊳", :vcy => "в", :vdash => "⊢", :vee => "∨", :veebar => "⊻", :veeeq => "≚", :vellip => "⋮", :verbar => "|", :vert => "|", :vfr => "𝔳", :vltri => "⊲", :vnsub => "⊂⃒", :vnsup => "⊃⃒", :vopf => "𝕧", :vprop => "∝", :vrtri => "⊳", :vscr => "𝓋", :vsubnE => "⫋︀", :vsubne => "⊊︀", :vsupnE => "⫌︀", :vsupne => "⊋︀", :vzigzag => "⦚", :wcirc => "ŵ", :wedbar => "⩟", :wedge => "∧", :wedgeq => "≙", :weierp => "℘", :wfr => "𝔴", :wopf => "𝕨", :wp => "℘", :wr => "≀", :wreath => "≀", :wscr => "𝓌", :xcap => "⋂", :xcirc => "◯", :xcup => "⋃", :xdtri => "▽", :xfr => "𝔵", :xhArr => "⟺", :xharr => "⟷", :xi => "ξ", :xlArr => "⟸", :xlarr => "⟵", :xmap => "⟼", :xnis => "⋻", :xodot => "⨀", :xopf => "𝕩", :xoplus => "⨁", :xotime => "⨂", :xrArr => "⟹", :xrarr => "⟶", :xscr => "𝓍", :xsqcup => "⨆", :xuplus => "⨄", :xutri => "△", :xvee => "⋁", :xwedge => "⋀", :yacute => "ý", :yacy => "я", :ycirc => "ŷ", :ycy => "ы", :yen => "¥", :yfr => "𝔶", :yicy => "ї", :yopf => "𝕪", :yscr => "𝓎", :yucy => "ю", :yuml => "ÿ", :zacute => "ź", :zcaron => "ž", :zcy => "з", :zdot => "ż", :zeetrf => "ℨ", :zeta => "ζ", :zfr => "𝔷", :zhcy => "ж", :zigrarr => "⇝", :zopf => "𝕫", :zscr => "𝓏", } end end end require "math_ml" math_ml-0.14/lib/math_ml/symbol/character_reference.rb0000644000004100000410000014127312055512401023105 0ustar www-datawww-datamodule MathML module Symbol MAP = {} unless const_defined?(:MAP) module CharacterReference Symbol::Default = self unless Symbol.const_defined?(:Default) Symbol::MAP[:character] = self def self.convert(name) MathML.pcstring(MAP[name.to_s.to_sym], true) end MAP = { :AElig => "Æ", :Aacute => "Á", :Abreve => "Ă", :Acirc => "Â", :Acy => "А", :Afr => "𝔄", :Agrave => "À", :Amacr => "Ā", :And => "⩓", :Aogon => "Ą", :Aopf => "𝔸", :ApplyFunction => "⁡", :Aring => "Å", :Ascr => "𝒜", :Assign => "≔", :Atilde => "Ã", :Auml => "Ä", :Backslash => "∖", :Barv => "⫧", :Barwed => "⌆", :Bcy => "Б", :Because => "∵", :Bernoullis => "ℬ", :Bfr => "𝔅", :Bopf => "𝔹", :Breve => "˘", :Bscr => "ℬ", :Bumpeq => "≎", :CHcy => "Ч", :Cacute => "Ć", :Cap => "⋒", :CapitalDifferentialD => "ⅅ", :Cayleys => "ℭ", :Ccaron => "Č", :Ccedil => "Ç", :Ccirc => "Ĉ", :Cconint => "∰", :Cdot => "Ċ", :Cedilla => "¸", :CenterDot => "·", :Cfr => "ℭ", :CircleDot => "⊙", :CircleMinus => "⊖", :CirclePlus => "⊕", :CircleTimes => "⊗", :ClockwiseContourIntegral => "∲", :CloseCurlyDoubleQuote => "”", :CloseCurlyQuote => "’", :Colon => "∷", :Colone => "⩴", :Congruent => "≡", :Conint => "∯", :ContourIntegral => "∮", :Copf => "ℂ", :Coproduct => "∐", :CounterClockwiseContourIntegral => "∳", :Cross => "⨯", :Cscr => "𝒞", :Cup => "⋓", :CupCap => "≍", :DD => "ⅅ", :DDotrahd => "⤑", :DJcy => "Ђ", :DScy => "Ѕ", :DZcy => "Џ", :Dagger => "‡", :Darr => "↡", :Dashv => "⫤", :Dcaron => "Ď", :Dcy => "Д", :Del => "∇", :Delta => "Δ", :Dfr => "𝔇", :DiacriticalAcute => "´", :DiacriticalDot => "˙", :DiacriticalDoubleAcute => "˝", :DiacriticalGrave => "`", :DiacriticalTilde => "˜", :Diamond => "⋄", :DifferentialD => "ⅆ", :Dopf => "𝔻", :Dot => "¨", :DotDot => "⃜", :DotEqual => "≐", :DoubleContourIntegral => "∯", :DoubleDot => "¨", :DoubleDownArrow => "⇓", :DoubleLeftArrow => "⇐", :DoubleLeftRightArrow => "⇔", :DoubleLeftTee => "⫤", :DoubleLongLeftArrow => "⟸", :DoubleLongLeftRightArrow => "⟺", :DoubleLongRightArrow => "⟹", :DoubleRightArrow => "⇒", :DoubleRightTee => "⊨", :DoubleUpArrow => "⇑", :DoubleUpDownArrow => "⇕", :DoubleVerticalBar => "∥", :DownArrow => "↓", :DownArrowBar => "⤓", :DownArrowUpArrow => "⇵", :DownBreve => "̑", :DownLeftRightVector => "⥐", :DownLeftTeeVector => "⥞", :DownLeftVector => "↽", :DownLeftVectorBar => "⥖", :DownRightTeeVector => "⥟", :DownRightVector => "⇁", :DownRightVectorBar => "⥗", :DownTee => "⊤", :DownTeeArrow => "↧", :Downarrow => "⇓", :Dscr => "𝒟", :Dstrok => "Đ", :ENG => "Ŋ", :ETH => "Ð", :Eacute => "É", :Ecaron => "Ě", :Ecirc => "Ê", :Ecy => "Э", :Edot => "Ė", :Efr => "𝔈", :Egrave => "È", :Element => "∈", :Emacr => "Ē", :EmptySmallSquare => "◻", :EmptyVerySmallSquare => "▫", :Eogon => "Ę", :Eopf => "𝔼", :Equal => "⩵", :EqualTilde => "≂", :Equilibrium => "⇌", :Escr => "ℰ", :Esim => "⩳", :Euml => "Ë", :Exists => "∃", :ExponentialE => "ⅇ", :Fcy => "Ф", :Ffr => "𝔉", :FilledSmallSquare => "◼", :FilledVerySmallSquare => "▪", :Fopf => "𝔽", :ForAll => "∀", :Fouriertrf => "ℱ", :Fscr => "ℱ", :GJcy => "Ѓ", :Gamma => "Γ", :Gammad => "Ϝ", :Gbreve => "Ğ", :Gcedil => "Ģ", :Gcirc => "Ĝ", :Gcy => "Г", :Gdot => "Ġ", :Gfr => "𝔊", :Gg => "⋙", :Gopf => "𝔾", :GreaterEqual => "≥", :GreaterEqualLess => "⋛", :GreaterFullEqual => "≧", :GreaterGreater => "⪢", :GreaterLess => "≷", :GreaterSlantEqual => "⩾", :GreaterTilde => "≳", :Gscr => "𝒢", :Gt => "≫", :HARDcy => "Ъ", :Hacek => "ˇ", :Hat => "^", :Hcirc => "Ĥ", :Hfr => "ℌ", :HilbertSpace => "ℋ", :Hopf => "ℍ", :HorizontalLine => "─", :Hscr => "ℋ", :Hstrok => "Ħ", :HumpDownHump => "≎", :HumpEqual => "≏", :IEcy => "Е", :IJlig => "IJ", :IOcy => "Ё", :Iacute => "Í", :Icirc => "Î", :Icy => "И", :Idot => "İ", :Ifr => "ℑ", :Igrave => "Ì", :Im => "ℑ", :Imacr => "Ī", :ImaginaryI => "ⅈ", :Implies => "⇒", :Int => "∬", :Integral => "∫", :Intersection => "⋂", :InvisibleComma => "⁣", :InvisibleTimes => "⁢", :Iogon => "Į", :Iopf => "𝕀", :Iscr => "ℐ", :Itilde => "Ĩ", :Iukcy => "І", :Iuml => "Ï", :Jcirc => "Ĵ", :Jcy => "Й", :Jfr => "𝔍", :Jopf => "𝕁", :Jscr => "𝒥", :Jsercy => "Ј", :Jukcy => "Є", :KHcy => "Х", :KJcy => "Ќ", :Kcedil => "Ķ", :Kcy => "К", :Kfr => "𝔎", :Kopf => "𝕂", :Kscr => "𝒦", :LJcy => "Љ", :Lacute => "Ĺ", :Lambda => "Λ", :Lang => "《", :Laplacetrf => "ℒ", :Larr => "↞", :Lcaron => "Ľ", :Lcedil => "Ļ", :Lcy => "Л", :LeftAngleBracket => "〈", :LeftArrow => "←", :LeftArrowBar => "⇤", :LeftArrowRightArrow => "⇆", :LeftCeiling => "⌈", :LeftDoubleBracket => "〚", :LeftDownTeeVector => "⥡", :LeftDownVector => "⇃", :LeftDownVectorBar => "⥙", :LeftFloor => "⌊", :LeftRightArrow => "↔", :LeftRightVector => "⥎", :LeftTee => "⊣", :LeftTeeArrow => "↤", :LeftTeeVector => "⥚", :LeftTriangle => "⊲", :LeftTriangleBar => "⧏", :LeftTriangleEqual => "⊴", :LeftUpDownVector => "⥑", :LeftUpTeeVector => "⥠", :LeftUpVector => "↿", :LeftUpVectorBar => "⥘", :LeftVector => "↼", :LeftVectorBar => "⥒", :Leftarrow => "⇐", :Leftrightarrow => "⇔", :LessEqualGreater => "⋚", :LessFullEqual => "≦", :LessGreater => "≶", :LessLess => "⪡", :LessSlantEqual => "⩽", :LessTilde => "≲", :Lfr => "𝔏", :Ll => "⋘", :Lleftarrow => "⇚", :Lmidot => "Ŀ", :LongLeftArrow => "⟵", :LongLeftRightArrow => "⟷", :LongRightArrow => "⟶", :Longleftarrow => "⟸", :Longleftrightarrow => "⟺", :Longrightarrow => "⟹", :Lopf => "𝕃", :LowerLeftArrow => "↙", :LowerRightArrow => "↘", :Lscr => "ℒ", :Lsh => "↰", :Lstrok => "Ł", :Lt => "≪", :Map => "⤅", :Mcy => "М", :MediumSpace => " ", :Mellintrf => "ℳ", :Mfr => "𝔐", :MinusPlus => "∓", :Mopf => "𝕄", :Mscr => "ℳ", :NJcy => "Њ", :Nacute => "Ń", :Ncaron => "Ň", :Ncedil => "Ņ", :Ncy => "Н", :NegativeMediumSpace => "​", :NegativeThickSpace => "​", :NegativeThinSpace => "​", :NegativeVeryThinSpace => "​", :NestedGreaterGreater => "≫", :NestedLessLess => "≪", :NewLine => " ", :Nfr => "𝔑", :NoBreak => "⁠", :NonBreakingSpace => " ", :Nopf => "ℕ", :Not => "⫬", :NotCongruent => "≢", :NotCupCap => "≭", :NotDoubleVerticalBar => "∦", :NotElement => "∉", :NotEqual => "≠", :NotEqualTilde => "≂̸", :NotExists => "∄", :NotGreater => "≯", :NotGreaterEqual => "≱", :NotGreaterFullEqual => "≦̸", :NotGreaterGreater => "≫̸", :NotGreaterLess => "≹", :NotGreaterSlantEqual => "⩾̸", :NotGreaterTilde => "≵", :NotHumpDownHump => "≎̸", :NotHumpEqual => "≏̸", :NotLeftTriangle => "⋪", :NotLeftTriangleBar => "⧏̸", :NotLeftTriangleEqual => "⋬", :NotLess => "≮", :NotLessEqual => "≰", :NotLessGreater => "≸", :NotLessLess => "≪̸", :NotLessSlantEqual => "⩽̸", :NotLessTilde => "≴", :NotNestedGreaterGreater => "⪢̸", :NotNestedLessLess => "⪡̸", :NotPrecedes => "⊀", :NotPrecedesEqual => "⪯̸", :NotPrecedesSlantEqual => "⋠", :NotReverseElement => "∌", :NotRightTriangle => "⋫", :NotRightTriangleBar => "⧐̸", :NotRightTriangleEqual => "⋭", :NotSquareSubset => "⊏̸", :NotSquareSubsetEqual => "⋢", :NotSquareSuperset => "⊐̸", :NotSquareSupersetEqual => "⋣", :NotSubset => "⊂⃒", :NotSubsetEqual => "⊈", :NotSucceeds => "⊁", :NotSucceedsEqual => "⪰̸", :NotSucceedsSlantEqual => "⋡", :NotSucceedsTilde => "≿̸", :NotSuperset => "⊃⃒", :NotSupersetEqual => "⊉", :NotTilde => "≁", :NotTildeEqual => "≄", :NotTildeFullEqual => "≇", :NotTildeTilde => "≉", :NotVerticalBar => "∤", :Nscr => "𝒩", :Ntilde => "Ñ", :OElig => "Œ", :Oacute => "Ó", :Ocirc => "Ô", :Ocy => "О", :Odblac => "Ő", :Ofr => "𝔒", :Ograve => "Ò", :Omacr => "Ō", :Omega => "Ω", :Oopf => "𝕆", :OpenCurlyDoubleQuote => "“", :OpenCurlyQuote => "‘", :Or => "⩔", :Oscr => "𝒪", :Oslash => "Ø", :Otilde => "Õ", :Otimes => "⨷", :Ouml => "Ö", :OverBar => "¯", :OverBrace => "︷", :OverBracket => "⎴", :OverParenthesis => "︵", :PartialD => "∂", :Pcy => "П", :Pfr => "𝔓", :Phi => "Φ", :Pi => "Π", :PlusMinus => "±", :Poincareplane => "ℌ", :Popf => "ℙ", :Pr => "⪻", :Precedes => "≺", :PrecedesEqual => "⪯", :PrecedesSlantEqual => "≼", :PrecedesTilde => "≾", :Prime => "″", :Product => "∏", :Proportion => "∷", :Proportional => "∝", :Pscr => "𝒫", :Psi => "Ψ", :Qfr => "𝔔", :Qopf => "ℚ", :Qscr => "𝒬", :RBarr => "⤐", :Racute => "Ŕ", :Rang => "》", :Rarr => "↠", :Rarrtl => "⤖", :Rcaron => "Ř", :Rcedil => "Ŗ", :Rcy => "Р", :Re => "ℜ", :ReverseElement => "∋", :ReverseEquilibrium => "⇋", :ReverseUpEquilibrium => "⥯", :Rfr => "ℜ", :RightAngleBracket => "〉", :RightArrow => "→", :RightArrowBar => "⇥", :RightArrowLeftArrow => "⇄", :RightCeiling => "⌉", :RightDoubleBracket => "〛", :RightDownTeeVector => "⥝", :RightDownVector => "⇂", :RightDownVectorBar => "⥕", :RightFloor => "⌋", :RightTee => "⊢", :RightTeeArrow => "↦", :RightTeeVector => "⥛", :RightTriangle => "⊳", :RightTriangleBar => "⧐", :RightTriangleEqual => "⊵", :RightUpDownVector => "⥏", :RightUpTeeVector => "⥜", :RightUpVector => "↾", :RightUpVectorBar => "⥔", :RightVector => "⇀", :RightVectorBar => "⥓", :Rightarrow => "⇒", :Ropf => "ℝ", :RoundImplies => "⥰", :Rrightarrow => "⇛", :Rscr => "ℛ", :Rsh => "↱", :RuleDelayed => "⧴", :SHCHcy => "Щ", :SHcy => "Ш", :SOFTcy => "Ь", :Sacute => "Ś", :Sc => "⪼", :Scaron => "Š", :Scedil => "Ş", :Scirc => "Ŝ", :Scy => "С", :Sfr => "𝔖", :ShortDownArrow => "↓", :ShortLeftArrow => "←", :ShortRightArrow => "→", :ShortUpArrow => "↑", :Sigma => "Σ", :SmallCircle => "∘", :Sopf => "𝕊", :Sqrt => "√", :Square => "□", :SquareIntersection => "⊓", :SquareSubset => "⊏", :SquareSubsetEqual => "⊑", :SquareSuperset => "⊐", :SquareSupersetEqual => "⊒", :SquareUnion => "⊔", :Sscr => "𝒮", :Star => "⋆", :Sub => "⋐", :Subset => "⋐", :SubsetEqual => "⊆", :Succeeds => "≻", :SucceedsEqual => "⪰", :SucceedsSlantEqual => "≽", :SucceedsTilde => "≿", :SuchThat => "∋", :Sum => "∑", :Sup => "⋑", :Superset => "⊃", :SupersetEqual => "⊇", :Supset => "⋑", :THORN => "Þ", :TSHcy => "Ћ", :TScy => "Ц", :Tab => " ", :Tcaron => "Ť", :Tcedil => "Ţ", :Tcy => "Т", :Tfr => "𝔗", :Therefore => "∴", :Theta => "Θ", :ThickSpace => "   ", :ThinSpace => " ", :Tilde => "∼", :TildeEqual => "≃", :TildeFullEqual => "≅", :TildeTilde => "≈", :Topf => "𝕋", :TripleDot => "⃛", :Tscr => "𝒯", :Tstrok => "Ŧ", :Uacute => "Ú", :Uarr => "↟", :Uarrocir => "⥉", :Ubrcy => "Ў", :Ubreve => "Ŭ", :Ucirc => "Û", :Ucy => "У", :Udblac => "Ű", :Ufr => "𝔘", :Ugrave => "Ù", :Umacr => "Ū", :UnderBar => "̲", :UnderBrace => "︸", :UnderBracket => "⎵", :UnderParenthesis => "︶", :Union => "⋃", :UnionPlus => "⊎", :Uogon => "Ų", :Uopf => "𝕌", :UpArrow => "↑", :UpArrowBar => "⤒", :UpArrowDownArrow => "⇅", :UpDownArrow => "↕", :UpEquilibrium => "⥮", :UpTee => "⊥", :UpTeeArrow => "↥", :Uparrow => "⇑", :Updownarrow => "⇕", :UpperLeftArrow => "↖", :UpperRightArrow => "↗", :Upsi => "ϒ", :Upsilon => "Υ", :Uring => "Ů", :Uscr => "𝒰", :Utilde => "Ũ", :Uuml => "Ü", :VDash => "⊫", :Vbar => "⫫", :Vcy => "В", :Vdash => "⊩", :Vdashl => "⫦", :Vee => "⋁", :Verbar => "‖", :Vert => "‖", :VerticalBar => "∣", :VerticalLine => "|", :VerticalSeparator => "❘", :VerticalTilde => "≀", :VeryThinSpace => " ", :Vfr => "𝔙", :Vopf => "𝕍", :Vscr => "𝒱", :Vvdash => "⊪", :Wcirc => "Ŵ", :Wedge => "⋀", :Wfr => "𝔚", :Wopf => "𝕎", :Wscr => "𝒲", :Xfr => "𝔛", :Xi => "Ξ", :Xopf => "𝕏", :Xscr => "𝒳", :YAcy => "Я", :YIcy => "Ї", :YUcy => "Ю", :Yacute => "Ý", :Ycirc => "Ŷ", :Ycy => "Ы", :Yfr => "𝔜", :Yopf => "𝕐", :Yscr => "𝒴", :Yuml => "Ÿ", :ZHcy => "Ж", :Zacute => "Ź", :Zcaron => "Ž", :Zcy => "З", :Zdot => "Ż", :ZeroWidthSpace => "​", :Zfr => "ℨ", :Zopf => "ℤ", :Zscr => "𝒵", :aacute => "á", :abreve => "ă", :ac => "∾", :acE => "∾̳", :acd => "∿", :acirc => "â", :acute => "´", :acy => "а", :aelig => "æ", :af => "⁡", :afr => "𝔞", :agrave => "à", :aleph => "ℵ", :alpha => "α", :amacr => "ā", :amalg => "⨿", :amp => "&", :and => "∧", :andand => "⩕", :andd => "⩜", :andslope => "⩘", :andv => "⩚", :ang => "∠", :ange => "⦤", :angle => "∠", :angmsd => "∡", :angmsdaa => "⦨", :angmsdab => "⦩", :angmsdac => "⦪", :angmsdad => "⦫", :angmsdae => "⦬", :angmsdaf => "⦭", :angmsdag => "⦮", :angmsdah => "⦯", :angrt => "∟", :angrtvb => "⊾", :angrtvbd => "⦝", :angsph => "∢", :angst => "Å", :angzarr => "⍼", :aogon => "ą", :aopf => "𝕒", :ap => "≈", :apE => "⩰", :apacir => "⩯", :ape => "≊", :apid => "≋", :apos => "'", :approx => "≈", :approxeq => "≊", :aring => "å", :ascr => "𝒶", :ast => "*", :asymp => "≈", :asympeq => "≍", :atilde => "ã", :auml => "ä", :awconint => "∳", :awint => "⨑", :bNot => "⫭", :backcong => "≌", :backepsilon => "϶", :backprime => "‵", :backsim => "∽", :backsimeq => "⋍", :barvee => "⊽", :barwed => "⌅", :barwedge => "⌅", :bbrk => "⎵", :bbrktbrk => "⎶", :bcong => "≌", :bcy => "б", :becaus => "∵", :because => "∵", :bemptyv => "⦰", :bepsi => "϶", :bernou => "ℬ", :beta => "β", :beth => "ℶ", :between => "≬", :bfr => "𝔟", :bigcap => "⋂", :bigcirc => "◯", :bigcup => "⋃", :bigodot => "⨀", :bigoplus => "⨁", :bigotimes => "⨂", :bigsqcup => "⨆", :bigstar => "★", :bigtriangledown => "▽", :bigtriangleup => "△", :biguplus => "⨄", :bigvee => "⋁", :bigwedge => "⋀", :bkarow => "⤍", :blacklozenge => "⧫", :blacksquare => "▪", :blacktriangle => "▴", :blacktriangledown => "▾", :blacktriangleleft => "◂", :blacktriangleright => "▸", :blank => "␣", :blk12 => "▒", :blk14 => "░", :blk34 => "▓", :block => "█", :bne => "=⃥", :bnequiv => "≡⃥", :bnot => "⌐", :bopf => "𝕓", :bot => "⊥", :bottom => "⊥", :bowtie => "⋈", :boxDL => "╗", :boxDR => "╔", :boxDl => "╖", :boxDr => "╓", :boxH => "═", :boxHD => "╦", :boxHU => "╩", :boxHd => "╤", :boxHu => "╧", :boxUL => "╝", :boxUR => "╚", :boxUl => "╜", :boxUr => "╙", :boxV => "║", :boxVH => "╬", :boxVL => "╣", :boxVR => "╠", :boxVh => "╫", :boxVl => "╢", :boxVr => "╟", :boxbox => "⧉", :boxdL => "╕", :boxdR => "╒", :boxdl => "┐", :boxdr => "┌", :boxh => "─", :boxhD => "╥", :boxhU => "╨", :boxhd => "┬", :boxhu => "┴", :boxminus => "⊟", :boxplus => "⊞", :boxtimes => "⊠", :boxuL => "╛", :boxuR => "╘", :boxul => "┘", :boxur => "└", :boxv => "│", :boxvH => "╪", :boxvL => "╡", :boxvR => "╞", :boxvh => "┼", :boxvl => "┤", :boxvr => "├", :bprime => "‵", :breve => "˘", :brvbar => "¦", :bscr => "𝒷", :bsemi => "⁏", :bsim => "∽", :bsime => "⋍", :bsol => "\", :bsolb => "⧅", :bsolhsub => "\⊂", :bull => "•", :bullet => "•", :bump => "≎", :bumpE => "⪮", :bumpe => "≏", :bumpeq => "≏", :cacute => "ć", :cap => "∩", :capand => "⩄", :capbrcup => "⩉", :capcap => "⩋", :capcup => "⩇", :capdot => "⩀", :caps => "∩︀", :caret => "⁁", :caron => "ˇ", :ccaps => "⩍", :ccaron => "č", :ccedil => "ç", :ccirc => "ĉ", :ccups => "⩌", :ccupssm => "⩐", :cdot => "ċ", :cedil => "¸", :cemptyv => "⦲", :cent => "¢", :centerdot => "·", :cfr => "𝔠", :chcy => "ч", :check => "✓", :checkmark => "✓", :chi => "χ", :cir => "○", :cirE => "⧃", :circ => "ˆ", :circeq => "≗", :circlearrowleft => "↺", :circlearrowright => "↻", :circledR => "®", :circledS => "Ⓢ", :circledast => "⊛", :circledcirc => "⊚", :circleddash => "⊝", :cire => "≗", :cirfnint => "⨐", :cirmid => "⫯", :cirscir => "⧂", :clubs => "♣", :clubsuit => "♣", :colon => ":", :colone => "≔", :coloneq => "≔", :comma => ",", :commat => "@", :comp => "∁", :compfn => "∘", :complement => "∁", :complexes => "ℂ", :cong => "≅", :congdot => "⩭", :conint => "∮", :copf => "𝕔", :coprod => "∐", :copy => "©", :copysr => "℗", :cross => "✗", :cscr => "𝒸", :csub => "⫏", :csube => "⫑", :csup => "⫐", :csupe => "⫒", :ctdot => "⋯", :cudarrl => "⤸", :cudarrr => "⤵", :cuepr => "⋞", :cuesc => "⋟", :cularr => "↶", :cularrp => "⤽", :cup => "∪", :cupbrcap => "⩈", :cupcap => "⩆", :cupcup => "⩊", :cupdot => "⊍", :cupor => "⩅", :cups => "∪︀", :curarr => "↷", :curarrm => "⤼", :curlyeqprec => "⋞", :curlyeqsucc => "⋟", :curlyvee => "⋎", :curlywedge => "⋏", :curren => "¤", :curvearrowleft => "↶", :curvearrowright => "↷", :cuvee => "⋎", :cuwed => "⋏", :cwconint => "∲", :cwint => "∱", :cylcty => "⌭", :dArr => "⇓", :dHar => "⥥", :dagger => "†", :daleth => "ℸ", :darr => "↓", :dash => "‐", :dashv => "⊣", :dbkarow => "⤏", :dblac => "˝", :dcaron => "ď", :dcy => "д", :dd => "ⅆ", :ddagger => "‡", :ddarr => "⇊", :ddotseq => "⩷", :deg => "°", :delta => "δ", :demptyv => "⦱", :dfisht => "⥿", :dfr => "𝔡", :dharl => "⇃", :dharr => "⇂", :diam => "⋄", :diamond => "⋄", :diamondsuit => "♦", :diams => "♦", :die => "¨", :digamma => "ϝ", :disin => "⋲", :div => "÷", :divide => "÷", :divideontimes => "⋇", :divonx => "⋇", :djcy => "ђ", :dlcorn => "⌞", :dlcrop => "⌍", :dollar => "$", :dopf => "𝕕", :dot => "˙", :doteq => "≐", :doteqdot => "≑", :dotminus => "∸", :dotplus => "∔", :dotsquare => "⊡", :doublebarwedge => "⌆", :downarrow => "↓", :downdownarrows => "⇊", :downharpoonleft => "⇃", :downharpoonright => "⇂", :drbkarow => "⤐", :drcorn => "⌟", :drcrop => "⌌", :dscr => "𝒹", :dscy => "ѕ", :dsol => "⧶", :dstrok => "đ", :dtdot => "⋱", :dtri => "▿", :dtrif => "▾", :duarr => "⇵", :duhar => "⥯", :dwangle => "⦦", :dzcy => "џ", :dzigrarr => "⟿", :eDDot => "⩷", :eDot => "≑", :eacute => "é", :easter => "⩮", :ecaron => "ě", :ecir => "≖", :ecirc => "ê", :ecolon => "≕", :ecy => "э", :edot => "ė", :ee => "ⅇ", :efDot => "≒", :efr => "𝔢", :eg => "⪚", :egrave => "è", :egs => "⪖", :egsdot => "⪘", :el => "⪙", :elinters => "�", :ell => "ℓ", :els => "⪕", :elsdot => "⪗", :emacr => "ē", :empty => "∅", :emptyset => "∅", :emptyv => "∅", :emsp => " ", :emsp13 => " ", :emsp14 => " ", :eng => "ŋ", :ensp => " ", :eogon => "ę", :eopf => "𝕖", :epar => "⋕", :eparsl => "⧣", :eplus => "⩱", :epsi => "ϵ", :epsiv => "ε", :eqcirc => "≖", :eqcolon => "≕", :eqsim => "≂", :eqslantgtr => "⪖", :eqslantless => "⪕", :equals => "=", :equest => "≟", :equiv => "≡", :equivDD => "⩸", :eqvparsl => "⧥", :erDot => "≓", :erarr => "⥱", :escr => "ℯ", :esdot => "≐", :esim => "≂", :eta => "η", :eth => "ð", :euml => "ë", :excl => "!", :exist => "∃", :expectation => "ℰ", :exponentiale => "ⅇ", :fallingdotseq => "≒", :fcy => "ф", :female => "♀", :ffilig => "ffi", :fflig => "ff", :ffllig => "ffl", :ffr => "𝔣", :filig => "fi", :flat => "♭", :fllig => "fl", :fltns => "▱", :fnof => "ƒ", :fopf => "𝕗", :forall => "∀", :fork => "⋔", :forkv => "⫙", :fpartint => "⨍", :frac12 => "½", :frac13 => "⅓", :frac14 => "¼", :frac15 => "⅕", :frac16 => "⅙", :frac18 => "⅛", :frac23 => "⅔", :frac25 => "⅖", :frac34 => "¾", :frac35 => "⅗", :frac38 => "⅜", :frac45 => "⅘", :frac56 => "⅚", :frac58 => "⅝", :frac78 => "⅞", :frown => "⌢", :fscr => "𝒻", :gE => "≧", :gEl => "⪌", :gacute => "ǵ", :gamma => "γ", :gammad => "ϝ", :gap => "⪆", :gbreve => "ğ", :gcirc => "ĝ", :gcy => "г", :gdot => "ġ", :ge => "≥", :gel => "⋛", :geq => "≥", :geqq => "≧", :geqslant => "⩾", :ges => "⩾", :gescc => "⪩", :gesdot => "⪀", :gesdoto => "⪂", :gesdotol => "⪄", :gesl => "⋛︀", :gesles => "⪔", :gfr => "𝔤", :gg => "≫", :ggg => "⋙", :gimel => "ℷ", :gjcy => "ѓ", :gl => "≷", :glE => "⪒", :gla => "⪥", :glj => "⪤", :gnE => "≩", :gnap => "⪊", :gnapprox => "⪊", :gne => "⪈", :gneq => "⪈", :gneqq => "≩", :gnsim => "⋧", :gopf => "𝕘", :grave => "`", :gscr => "ℊ", :gsim => "≳", :gsime => "⪎", :gsiml => "⪐", :gt => ">", :gtcc => "⪧", :gtcir => "⩺", :gtdot => "⋗", :gtlPar => "⦕", :gtquest => "⩼", :gtrapprox => "⪆", :gtrarr => "⥸", :gtrdot => "⋗", :gtreqless => "⋛", :gtreqqless => "⪌", :gtrless => "≷", :gtrsim => "≳", :gvertneqq => "≩︀", :gvnE => "≩︀", :hArr => "⇔", :hairsp => " ", :half => "½", :hamilt => "ℋ", :hardcy => "ъ", :harr => "↔", :harrcir => "⥈", :harrw => "↭", :hbar => "ℏ", :hcirc => "ĥ", :hearts => "♥", :heartsuit => "♥", :hellip => "…", :hercon => "⊹", :hfr => "𝔥", :hksearow => "⤥", :hkswarow => "⤦", :hoarr => "⇿", :homtht => "∻", :hookleftarrow => "↩", :hookrightarrow => "↪", :hopf => "𝕙", :horbar => "―", :hscr => "𝒽", :hslash => "ℏ", :hstrok => "ħ", :hybull => "⁃", :hyphen => "‐", :iacute => "í", :ic => "⁣", :icirc => "î", :icy => "и", :iecy => "е", :iexcl => "¡", :iff => "⇔", :ifr => "𝔦", :igrave => "ì", :ii => "ⅈ", :iiiint => "⨌", :iiint => "∭", :iinfin => "⧜", :iiota => "℩", :ijlig => "ij", :imacr => "ī", :image => "ℑ", :imagline => "ℐ", :imagpart => "ℑ", :imath => "ı", :imof => "⊷", :imped => "Ƶ", :in => "∈", :incare => "℅", :infin => "∞", :infintie => "⧝", :inodot => "ı", :int => "∫", :intcal => "⊺", :integers => "ℤ", :intercal => "⊺", :intlarhk => "⨗", :intprod => "⨼", :iocy => "ё", :iogon => "į", :iopf => "𝕚", :iota => "ι", :iprod => "⨼", :iquest => "¿", :iscr => "𝒾", :isin => "∈", :isinE => "⋹", :isindot => "⋵", :isins => "⋴", :isinsv => "⋳", :isinv => "∈", :it => "⁢", :itilde => "ĩ", :iukcy => "і", :iuml => "ï", :jcirc => "ĵ", :jcy => "й", :jfr => "𝔧", :jmath => "j", :jopf => "𝕛", :jscr => "𝒿", :jsercy => "ј", :jukcy => "є", :kappa => "κ", :kappav => "ϰ", :kcedil => "ķ", :kcy => "к", :kfr => "𝔨", :kgreen => "ĸ", :khcy => "х", :kjcy => "ќ", :kopf => "𝕜", :kscr => "𝓀", :lAarr => "⇚", :lArr => "⇐", :lAtail => "⤛", :lBarr => "⤎", :lE => "≦", :lEg => "⪋", :lHar => "⥢", :lacute => "ĺ", :laemptyv => "⦴", :lagran => "ℒ", :lambda => "λ", :lang => "〈", :langd => "⦑", :langle => "〈", :lap => "⪅", :laquo => "«", :larr => "←", :larrb => "⇤", :larrbfs => "⤟", :larrfs => "⤝", :larrhk => "↩", :larrlp => "↫", :larrpl => "⤹", :larrsim => "⥳", :larrtl => "↢", :lat => "⪫", :latail => "⤙", :late => "⪭", :lates => "⪭︀", :lbarr => "⤌", :lbbrk => "〔", :lbrace => "{", :lbrack => "[", :lbrke => "⦋", :lbrksld => "⦏", :lbrkslu => "⦍", :lcaron => "ľ", :lcedil => "ļ", :lceil => "⌈", :lcub => "{", :lcy => "л", :ldca => "⤶", :ldquo => "“", :ldquor => "„", :ldrdhar => "⥧", :ldrushar => "⥋", :ldsh => "↲", :le => "≤", :leftarrow => "←", :leftarrowtail => "↢", :leftharpoondown => "↽", :leftharpoonup => "↼", :leftleftarrows => "⇇", :leftrightarrow => "↔", :leftrightarrows => "⇆", :leftrightharpoons => "⇋", :leftrightsquigarrow => "↭", :leftthreetimes => "⋋", :leg => "⋚", :leq => "≤", :leqq => "≦", :leqslant => "⩽", :les => "⩽", :lescc => "⪨", :lesdot => "⩿", :lesdoto => "⪁", :lesdotor => "⪃", :lesg => "⋚︀", :lesges => "⪓", :lessapprox => "⪅", :lessdot => "⋖", :lesseqgtr => "⋚", :lesseqqgtr => "⪋", :lessgtr => "≶", :lesssim => "≲", :lfisht => "⥼", :lfloor => "⌊", :lfr => "𝔩", :lg => "≶", :lgE => "⪑", :lhard => "↽", :lharu => "↼", :lharul => "⥪", :lhblk => "▄", :ljcy => "љ", :ll => "≪", :llarr => "⇇", :llcorner => "⌞", :llhard => "⥫", :lltri => "◺", :lmidot => "ŀ", :lmoust => "⎰", :lmoustache => "⎰", :lnE => "≨", :lnap => "⪉", :lnapprox => "⪉", :lne => "⪇", :lneq => "⪇", :lneqq => "≨", :lnsim => "⋦", :loang => "〘", :loarr => "⇽", :lobrk => "〚", :longleftarrow => "⟵", :longleftrightarrow => "⟷", :longmapsto => "⟼", :longrightarrow => "⟶", :looparrowleft => "↫", :looparrowright => "↬", :lopar => "⦅", :lopf => "𝕝", :loplus => "⨭", :lotimes => "⨴", :lowast => "∗", :lowbar => "_", :loz => "◊", :lozenge => "◊", :lozf => "⧫", :lpar => "(", :lparlt => "⦓", :lrarr => "⇆", :lrcorner => "⌟", :lrhar => "⇋", :lrhard => "⥭", :lrtri => "⊿", :lscr => "𝓁", :lsh => "↰", :lsim => "≲", :lsime => "⪍", :lsimg => "⪏", :lsqb => "[", :lsquo => "‘", :lsquor => "‚", :lstrok => "ł", :lt => "<", :ltcc => "⪦", :ltcir => "⩹", :ltdot => "⋖", :lthree => "⋋", :ltimes => "⋉", :ltlarr => "⥶", :ltquest => "⩻", :ltrPar => "⦖", :ltri => "◃", :ltrie => "⊴", :ltrif => "◂", :lurdshar => "⥊", :luruhar => "⥦", :lvertneqq => "≨︀", :lvnE => "≨︀", :mDDot => "∺", :macr => "¯", :male => "♂", :malt => "✠", :maltese => "✠", :map => "↦", :mapsto => "↦", :mapstodown => "↧", :mapstoleft => "↤", :mapstoup => "↥", :marker => "▮", :mcomma => "⨩", :mcy => "м", :mdash => "—", :measuredangle => "∡", :mfr => "𝔪", :mho => "℧", :micro => "µ", :mid => "∣", :midast => "*", :midcir => "⫰", :middot => "·", :minus => "−", :minusb => "⊟", :minusd => "∸", :minusdu => "⨪", :mlcp => "⫛", :mldr => "…", :mnplus => "∓", :models => "⊧", :mopf => "𝕞", :mp => "∓", :mscr => "𝓂", :mstpos => "∾", :mu => "μ", :multimap => "⊸", :mumap => "⊸", :nGg => "⋙̸", :nGt => "≫⃒", :nGtv => "≫̸", :nLeftarrow => "⇍", :nLeftrightarrow => "⇎", :nLl => "⋘̸", :nLt => "≪⃒", :nLtv => "≪̸", :nRightarrow => "⇏", :nVDash => "⊯", :nVdash => "⊮", :nabla => "∇", :nacute => "ń", :nang => "∠⃒", :nap => "≉", :napE => "⩰̸", :napid => "≋̸", :napos => "ʼn", :napprox => "≉", :natur => "♮", :natural => "♮", :naturals => "ℕ", :nbsp => " ", :nbump => "≎̸", :nbumpe => "≏̸", :ncap => "⩃", :ncaron => "ň", :ncedil => "ņ", :ncong => "≇", :ncongdot => "⩭̸", :ncup => "⩂", :ncy => "н", :ndash => "–", :ne => "≠", :neArr => "⇗", :nearhk => "⤤", :nearr => "↗", :nearrow => "↗", :nedot => "≐̸", :nequiv => "≢", :nesear => "⤨", :nesim => "≂̸", :nexist => "∄", :nexists => "∄", :nfr => "𝔫", :ngE => "≧̸", :nge => "≱", :ngeq => "≱", :ngeqq => "≧̸", :ngeqslant => "⩾̸", :nges => "⩾̸", :ngsim => "≵", :ngt => "≯", :ngtr => "≯", :nhArr => "⇎", :nharr => "↮", :nhpar => "⫲", :ni => "∋", :nis => "⋼", :nisd => "⋺", :niv => "∋", :njcy => "њ", :nlArr => "⇍", :nlE => "≦̸", :nlarr => "↚", :nldr => "‥", :nle => "≰", :nleftarrow => "↚", :nleftrightarrow => "↮", :nleq => "≰", :nleqq => "≦̸", :nleqslant => "⩽̸", :nles => "⩽̸", :nless => "≮", :nlsim => "≴", :nlt => "≮", :nltri => "⋪", :nltrie => "⋬", :nmid => "∤", :nopf => "𝕟", :not => "¬", :notin => "∉", :notinE => "⋹̸", :notindot => "⋵̸", :notinva => "∉", :notinvb => "⋷", :notinvc => "⋶", :notni => "∌", :notniva => "∌", :notnivb => "⋾", :notnivc => "⋽", :npar => "∦", :nparallel => "∦", :nparsl => "⫽⃥", :npart => "∂̸", :npolint => "⨔", :npr => "⊀", :nprcue => "⋠", :npre => "⪯̸", :nprec => "⊀", :npreceq => "⪯̸", :nrArr => "⇏", :nrarr => "↛", :nrarrc => "⤳̸", :nrarrw => "↝̸", :nrightarrow => "↛", :nrtri => "⋫", :nrtrie => "⋭", :nsc => "⊁", :nsccue => "⋡", :nsce => "⪰̸", :nscr => "𝓃", :nshortmid => "∤", :nshortparallel => "∦", :nsim => "≁", :nsime => "≄", :nsimeq => "≄", :nsmid => "∤", :nspar => "∦", :nsqsube => "⋢", :nsqsupe => "⋣", :nsub => "⊄", :nsubE => "⫅̸", :nsube => "⊈", :nsubset => "⊂⃒", :nsubseteq => "⊈", :nsubseteqq => "⫅̸", :nsucc => "⊁", :nsucceq => "⪰̸", :nsup => "⊅", :nsupE => "⫆̸", :nsupe => "⊉", :nsupset => "⊃⃒", :nsupseteq => "⊉", :nsupseteqq => "⫆̸", :ntgl => "≹", :ntilde => "ñ", :ntlg => "≸", :ntriangleleft => "⋪", :ntrianglelefteq => "⋬", :ntriangleright => "⋫", :ntrianglerighteq => "⋭", :nu => "ν", :num => "#", :numero => "№", :numsp => " ", :nvDash => "⊭", :nvHarr => "⤄", :nvap => "≍⃒", :nvdash => "⊬", :nvge => "≥⃒", :nvgt => ">⃒", :nvinfin => "⧞", :nvlArr => "⤂", :nvle => "≤⃒", :nvlt => "<⃒", :nvltrie => "⊴⃒", :nvrArr => "⤃", :nvrtrie => "⊵⃒", :nvsim => "∼⃒", :nwArr => "⇖", :nwarhk => "⤣", :nwarr => "↖", :nwarrow => "↖", :nwnear => "⤧", :oS => "Ⓢ", :oacute => "ó", :oast => "⊛", :ocir => "⊚", :ocirc => "ô", :ocy => "о", :odash => "⊝", :odblac => "ő", :odiv => "⨸", :odot => "⊙", :odsold => "⦼", :oelig => "œ", :ofcir => "⦿", :ofr => "𝔬", :ogon => "˛", :ograve => "ò", :ogt => "⧁", :ohbar => "⦵", :ohm => "Ω", :oint => "∮", :olarr => "↺", :olcir => "⦾", :olcross => "⦻", :olt => "⧀", :omacr => "ō", :omega => "ω", :omid => "⦶", :ominus => "⊖", :oopf => "𝕠", :opar => "⦷", :operp => "⦹", :oplus => "⊕", :or => "∨", :orarr => "↻", :ord => "⩝", :order => "ℴ", :orderof => "ℴ", :ordf => "ª", :ordm => "º", :origof => "⊶", :oror => "⩖", :orslope => "⩗", :orv => "⩛", :oscr => "ℴ", :oslash => "ø", :osol => "⊘", :otilde => "õ", :otimes => "⊗", :otimesas => "⨶", :ouml => "ö", :ovbar => "⌽", :par => "∥", :para => "¶", :parallel => "∥", :parsim => "⫳", :parsl => "⫽", :part => "∂", :pcy => "п", :percnt => "%", :period => ".", :permil => "‰", :perp => "⊥", :pertenk => "‱", :pfr => "𝔭", :phi => "ϕ", :phiv => "φ", :phmmat => "ℳ", :phone => "☎", :pi => "π", :pitchfork => "⋔", :piv => "ϖ", :planck => "ℏ", :planckh => "ℎ", :plankv => "ℏ", :plus => "+", :plusacir => "⨣", :plusb => "⊞", :pluscir => "⨢", :plusdo => "∔", :plusdu => "⨥", :pluse => "⩲", :plusmn => "±", :plussim => "⨦", :plustwo => "⨧", :pm => "±", :pointint => "⨕", :popf => "𝕡", :pound => "£", :pr => "≺", :prE => "⪳", :prap => "⪷", :prcue => "≼", :pre => "⪯", :prec => "≺", :precapprox => "⪷", :preccurlyeq => "≼", :preceq => "⪯", :precnapprox => "⪹", :precneqq => "⪵", :precnsim => "⋨", :precsim => "≾", :prime => "′", :primes => "ℙ", :prnE => "⪵", :prnap => "⪹", :prnsim => "⋨", :prod => "∏", :profalar => "⌮", :profline => "⌒", :profsurf => "⌓", :prop => "∝", :propto => "∝", :prsim => "≾", :prurel => "⊰", :pscr => "𝓅", :psi => "ψ", :puncsp => " ", :qfr => "𝔮", :qint => "⨌", :qopf => "𝕢", :qprime => "⁗", :qscr => "𝓆", :quaternions => "ℍ", :quatint => "⨖", :quest => "?", :questeq => "≟", :quot => """, :rAarr => "⇛", :rArr => "⇒", :rAtail => "⤜", :rBarr => "⤏", :rHar => "⥤", :race => "⧚", :racute => "ŕ", :radic => "√", :raemptyv => "⦳", :rang => "〉", :rangd => "⦒", :range => "⦥", :rangle => "〉", :raquo => "»", :rarr => "→", :rarrap => "⥵", :rarrb => "⇥", :rarrbfs => "⤠", :rarrc => "⤳", :rarrfs => "⤞", :rarrhk => "↪", :rarrlp => "↬", :rarrpl => "⥅", :rarrsim => "⥴", :rarrtl => "↣", :rarrw => "↝", :ratail => "⤚", :ratio => "∶", :rationals => "ℚ", :rbarr => "⤍", :rbbrk => "〕", :rbrace => "}", :rbrack => "]", :rbrke => "⦌", :rbrksld => "⦎", :rbrkslu => "⦐", :rcaron => "ř", :rcedil => "ŗ", :rceil => "⌉", :rcub => "}", :rcy => "р", :rdca => "⤷", :rdldhar => "⥩", :rdquo => "”", :rdquor => "”", :rdsh => "↳", :real => "ℜ", :realine => "ℛ", :realpart => "ℜ", :reals => "ℝ", :rect => "▭", :reg => "®", :rfisht => "⥽", :rfloor => "⌋", :rfr => "𝔯", :rhard => "⇁", :rharu => "⇀", :rharul => "⥬", :rho => "ρ", :rhov => "ϱ", :rightarrow => "→", :rightarrowtail => "↣", :rightharpoondown => "⇁", :rightharpoonup => "⇀", :rightleftarrows => "⇄", :rightleftharpoons => "⇌", :rightrightarrows => "⇉", :rightsquigarrow => "↝", :rightthreetimes => "⋌", :ring => "˚", :risingdotseq => "≓", :rlarr => "⇄", :rlhar => "⇌", :rmoust => "⎱", :rmoustache => "⎱", :rnmid => "⫮", :roang => "〙", :roarr => "⇾", :robrk => "〛", :ropar => "⦆", :ropf => "𝕣", :roplus => "⨮", :rotimes => "⨵", :rpar => ")", :rpargt => "⦔", :rppolint => "⨒", :rrarr => "⇉", :rscr => "𝓇", :rsh => "↱", :rsqb => "]", :rsquo => "’", :rsquor => "’", :rthree => "⋌", :rtimes => "⋊", :rtri => "▹", :rtrie => "⊵", :rtrif => "▸", :rtriltri => "⧎", :ruluhar => "⥨", :rx => "℞", :sacute => "ś", :sc => "≻", :scE => "⪴", :scap => "⪸", :scaron => "š", :sccue => "≽", :sce => "⪰", :scedil => "ş", :scirc => "ŝ", :scnE => "⪶", :scnap => "⪺", :scnsim => "⋩", :scpolint => "⨓", :scsim => "≿", :scy => "с", :sdot => "⋅", :sdotb => "⊡", :sdote => "⩦", :seArr => "⇘", :searhk => "⤥", :searr => "↘", :searrow => "↘", :sect => "§", :semi => ";", :seswar => "⤩", :setminus => "∖", :setmn => "∖", :sext => "✶", :sfr => "𝔰", :sfrown => "⌢", :sharp => "♯", :shchcy => "щ", :shcy => "ш", :shortmid => "∣", :shortparallel => "∥", :shy => "­", :sigma => "σ", :sigmav => "ς", :sim => "∼", :simdot => "⩪", :sime => "≃", :simeq => "≃", :simg => "⪞", :simgE => "⪠", :siml => "⪝", :simlE => "⪟", :simne => "≆", :simplus => "⨤", :simrarr => "⥲", :slarr => "←", :smallsetminus => "∖", :smashp => "⨳", :smeparsl => "⧤", :smid => "∣", :smile => "⌣", :smt => "⪪", :smte => "⪬", :smtes => "⪬︀", :softcy => "ь", :sol => "/", :solb => "⧄", :solbar => "⌿", :sopf => "𝕤", :spades => "♠", :spadesuit => "♠", :spar => "∥", :sqcap => "⊓", :sqcaps => "⊓︀", :sqcup => "⊔", :sqcups => "⊔︀", :sqsub => "⊏", :sqsube => "⊑", :sqsubset => "⊏", :sqsubseteq => "⊑", :sqsup => "⊐", :sqsupe => "⊒", :sqsupset => "⊐", :sqsupseteq => "⊒", :squ => "□", :square => "□", :squarf => "▪", :squf => "▪", :srarr => "→", :sscr => "𝓈", :ssetmn => "∖", :ssmile => "⌣", :sstarf => "⋆", :star => "☆", :starf => "★", :straightepsilon => "ϵ", :straightphi => "ϕ", :strns => "¯", :sub => "⊂", :subE => "⫅", :subdot => "⪽", :sube => "⊆", :subedot => "⫃", :submult => "⫁", :subnE => "⫋", :subne => "⊊", :subplus => "⪿", :subrarr => "⥹", :subset => "⊂", :subseteq => "⊆", :subseteqq => "⫅", :subsetneq => "⊊", :subsetneqq => "⫋", :subsim => "⫇", :subsub => "⫕", :subsup => "⫓", :succ => "≻", :succapprox => "⪸", :succcurlyeq => "≽", :succeq => "⪰", :succnapprox => "⪺", :succneqq => "⪶", :succnsim => "⋩", :succsim => "≿", :sum => "∑", :sung => "♪", :sup => "⊃", :sup1 => "¹", :sup2 => "²", :sup3 => "³", :supE => "⫆", :supdot => "⪾", :supdsub => "⫘", :supe => "⊇", :supedot => "⫄", :suphsol => "⊃/", :suphsub => "⫗", :suplarr => "⥻", :supmult => "⫂", :supnE => "⫌", :supne => "⊋", :supplus => "⫀", :supset => "⊃", :supseteq => "⊇", :supseteqq => "⫆", :supsetneq => "⊋", :supsetneqq => "⫌", :supsim => "⫈", :supsub => "⫔", :supsup => "⫖", :swArr => "⇙", :swarhk => "⤦", :swarr => "↙", :swarrow => "↙", :swnwar => "⤪", :szlig => "ß", :target => "⌖", :tau => "τ", :tbrk => "⎴", :tcaron => "ť", :tcedil => "ţ", :tcy => "т", :tdot => "⃛", :telrec => "⌕", :tfr => "𝔱", :there4 => "∴", :therefore => "∴", :theta => "θ", :thetav => "ϑ", :thickapprox => "≈", :thicksim => "∼", :thinsp => " ", :thkap => "≈", :thksim => "∼", :thorn => "þ", :tilde => "˜", :times => "×", :timesb => "⊠", :timesbar => "⨱", :timesd => "⨰", :tint => "∭", :toea => "⤨", :top => "⊤", :topbot => "⌶", :topcir => "⫱", :topf => "𝕥", :topfork => "⫚", :tosa => "⤩", :tprime => "‴", :trade => "™", :triangle => "▵", :triangledown => "▿", :triangleleft => "◃", :trianglelefteq => "⊴", :triangleq => "≜", :triangleright => "▹", :trianglerighteq => "⊵", :tridot => "◬", :trie => "≜", :triminus => "⨺", :triplus => "⨹", :trisb => "⧍", :tritime => "⨻", :trpezium => "�", :tscr => "𝓉", :tscy => "ц", :tshcy => "ћ", :tstrok => "ŧ", :twixt => "≬", :twoheadleftarrow => "↞", :twoheadrightarrow => "↠", :uArr => "⇑", :uHar => "⥣", :uacute => "ú", :uarr => "↑", :ubrcy => "ў", :ubreve => "ŭ", :ucirc => "û", :ucy => "у", :udarr => "⇅", :udblac => "ű", :udhar => "⥮", :ufisht => "⥾", :ufr => "𝔲", :ugrave => "ù", :uharl => "↿", :uharr => "↾", :uhblk => "▀", :ulcorn => "⌜", :ulcorner => "⌜", :ulcrop => "⌏", :ultri => "◸", :umacr => "ū", :uml => "¨", :uogon => "ų", :uopf => "𝕦", :uparrow => "↑", :updownarrow => "↕", :upharpoonleft => "↿", :upharpoonright => "↾", :uplus => "⊎", :upsi => "υ", :upsilon => "υ", :upuparrows => "⇈", :urcorn => "⌝", :urcorner => "⌝", :urcrop => "⌎", :uring => "ů", :urtri => "◹", :uscr => "𝓊", :utdot => "⋰", :utilde => "ũ", :utri => "▵", :utrif => "▴", :uuarr => "⇈", :uuml => "ü", :uwangle => "⦧", :vArr => "⇕", :vBar => "⫨", :vBarv => "⫩", :vDash => "⊨", :vangrt => "⦜", :varepsilon => "ε", :varkappa => "ϰ", :varnothing => "∅", :varphi => "φ", :varpi => "ϖ", :varpropto => "∝", :varr => "↕", :varrho => "ϱ", :varsigma => "ς", :varsubsetneq => "⊊︀", :varsubsetneqq => "⫋︀", :varsupsetneq => "⊋︀", :varsupsetneqq => "⫌︀", :vartheta => "ϑ", :vartriangleleft => "⊲", :vartriangleright => "⊳", :vcy => "в", :vdash => "⊢", :vee => "∨", :veebar => "⊻", :veeeq => "≚", :vellip => "⋮", :verbar => "|", :vert => "|", :vfr => "𝔳", :vltri => "⊲", :vnsub => "⊂⃒", :vnsup => "⊃⃒", :vopf => "𝕧", :vprop => "∝", :vrtri => "⊳", :vscr => "𝓋", :vsubnE => "⫋︀", :vsubne => "⊊︀", :vsupnE => "⫌︀", :vsupne => "⊋︀", :vzigzag => "⦚", :wcirc => "ŵ", :wedbar => "⩟", :wedge => "∧", :wedgeq => "≙", :weierp => "℘", :wfr => "𝔴", :wopf => "𝕨", :wp => "℘", :wr => "≀", :wreath => "≀", :wscr => "𝓌", :xcap => "⋂", :xcirc => "◯", :xcup => "⋃", :xdtri => "▽", :xfr => "𝔵", :xhArr => "⟺", :xharr => "⟷", :xi => "ξ", :xlArr => "⟸", :xlarr => "⟵", :xmap => "⟼", :xnis => "⋻", :xodot => "⨀", :xopf => "𝕩", :xoplus => "⨁", :xotime => "⨂", :xrArr => "⟹", :xrarr => "⟶", :xscr => "𝓍", :xsqcup => "⨆", :xuplus => "⨄", :xutri => "△", :xvee => "⋁", :xwedge => "⋀", :yacute => "ý", :yacy => "я", :ycirc => "ŷ", :ycy => "ы", :yen => "¥", :yfr => "𝔶", :yicy => "ї", :yopf => "𝕪", :yscr => "𝓎", :yucy => "ю", :yuml => "ÿ", :zacute => "ź", :zcaron => "ž", :zcy => "з", :zdot => "ż", :zeetrf => "ℨ", :zeta => "ζ", :zfr => "𝔷", :zhcy => "ж", :zigrarr => "⇝", :zopf => "𝕫", :zscr => "𝓏", } end end end require "math_ml" math_ml-0.14/lib/math_ml/symbol/entity_reference.rb0000644000004100000410000004766212055512401022474 0ustar www-datawww-datamodule MathML module Symbol MAP = {} unless const_defined?(:MAP) module EntityReference Symbol::Default = self unless Symbol.const_defined?(:Default) Symbol::MAP[:entity] = self def self.convert(name) MathML.pcstring("&#{name};", true) end NAMES = [ :AElig, :Aacute, :Abreve, :Acirc, :Acy, :Afr, :Agrave, :Amacr, :And, :Aogon, :Aopf, :ApplyFunction, :Aring, :Ascr, :Assign, :Atilde, :Auml, :Backslash, :Barv, :Barwed, :Bcy, :Because, :Bernoullis, :Bfr, :Bopf, :Breve, :Bscr, :Bumpeq, :CHcy, :Cacute, :Cap, :CapitalDifferentialD, :Cayleys, :Ccaron, :Ccedil, :Ccirc, :Cconint, :Cdot, :Cedilla, :CenterDot, :Cfr, :CircleDot, :CircleMinus, :CirclePlus, :CircleTimes, :ClockwiseContourIntegral, :CloseCurlyDoubleQuote, :CloseCurlyQuote, :Colon, :Colone, :Congruent, :Conint, :ContourIntegral, :Copf, :Coproduct, :CounterClockwiseContourIntegral, :Cross, :Cscr, :Cup, :CupCap, :DD, :DDotrahd, :DJcy, :DScy, :DZcy, :Dagger, :Darr, :Dashv, :Dcaron, :Dcy, :Del, :Delta, :Dfr, :DiacriticalAcute, :DiacriticalDot, :DiacriticalDoubleAcute, :DiacriticalGrave, :DiacriticalTilde, :Diamond, :DifferentialD, :Dopf, :Dot, :DotDot, :DotEqual, :DoubleContourIntegral, :DoubleDot, :DoubleDownArrow, :DoubleLeftArrow, :DoubleLeftRightArrow, :DoubleLeftTee, :DoubleLongLeftArrow, :DoubleLongLeftRightArrow, :DoubleLongRightArrow, :DoubleRightArrow, :DoubleRightTee, :DoubleUpArrow, :DoubleUpDownArrow, :DoubleVerticalBar, :DownArrow, :DownArrowBar, :DownArrowUpArrow, :DownBreve, :DownLeftRightVector, :DownLeftTeeVector, :DownLeftVector, :DownLeftVectorBar, :DownRightTeeVector, :DownRightVector, :DownRightVectorBar, :DownTee, :DownTeeArrow, :Downarrow, :Dscr, :Dstrok, :ENG, :ETH, :Eacute, :Ecaron, :Ecirc, :Ecy, :Edot, :Efr, :Egrave, :Element, :Emacr, :EmptySmallSquare, :EmptyVerySmallSquare, :Eogon, :Eopf, :Equal, :EqualTilde, :Equilibrium, :Escr, :Esim, :Euml, :Exists, :ExponentialE, :Fcy, :Ffr, :FilledSmallSquare, :FilledVerySmallSquare, :Fopf, :ForAll, :Fouriertrf, :Fscr, :GJcy, :Gamma, :Gammad, :Gbreve, :Gcedil, :Gcirc, :Gcy, :Gdot, :Gfr, :Gg, :Gopf, :GreaterEqual, :GreaterEqualLess, :GreaterFullEqual, :GreaterGreater, :GreaterLess, :GreaterSlantEqual, :GreaterTilde, :Gscr, :Gt, :HARDcy, :Hacek, :Hat, :Hcirc, :Hfr, :HilbertSpace, :Hopf, :HorizontalLine, :Hscr, :Hstrok, :HumpDownHump, :HumpEqual, :IEcy, :IJlig, :IOcy, :Iacute, :Icirc, :Icy, :Idot, :Ifr, :Igrave, :Im, :Imacr, :ImaginaryI, :Implies, :Int, :Integral, :Intersection, :InvisibleComma, :InvisibleTimes, :Iogon, :Iopf, :Iscr, :Itilde, :Iukcy, :Iuml, :Jcirc, :Jcy, :Jfr, :Jopf, :Jscr, :Jsercy, :Jukcy, :KHcy, :KJcy, :Kcedil, :Kcy, :Kfr, :Kopf, :Kscr, :LJcy, :Lacute, :Lambda, :Lang, :Laplacetrf, :Larr, :Lcaron, :Lcedil, :Lcy, :LeftAngleBracket, :LeftArrow, :LeftArrowBar, :LeftArrowRightArrow, :LeftCeiling, :LeftDoubleBracket, :LeftDownTeeVector, :LeftDownVector, :LeftDownVectorBar, :LeftFloor, :LeftRightArrow, :LeftRightVector, :LeftTee, :LeftTeeArrow, :LeftTeeVector, :LeftTriangle, :LeftTriangleBar, :LeftTriangleEqual, :LeftUpDownVector, :LeftUpTeeVector, :LeftUpVector, :LeftUpVectorBar, :LeftVector, :LeftVectorBar, :Leftarrow, :Leftrightarrow, :LessEqualGreater, :LessFullEqual, :LessGreater, :LessLess, :LessSlantEqual, :LessTilde, :Lfr, :Ll, :Lleftarrow, :Lmidot, :LongLeftArrow, :LongLeftRightArrow, :LongRightArrow, :Longleftarrow, :Longleftrightarrow, :Longrightarrow, :Lopf, :LowerLeftArrow, :LowerRightArrow, :Lscr, :Lsh, :Lstrok, :Lt, :Map, :Mcy, :MediumSpace, :Mellintrf, :Mfr, :MinusPlus, :Mopf, :Mscr, :NJcy, :Nacute, :Ncaron, :Ncedil, :Ncy, :NegativeMediumSpace, :NegativeThickSpace, :NegativeThinSpace, :NegativeVeryThinSpace, :NestedGreaterGreater, :NestedLessLess, :NewLine, :Nfr, :NoBreak, :NonBreakingSpace, :Nopf, :Not, :NotCongruent, :NotCupCap, :NotDoubleVerticalBar, :NotElement, :NotEqual, :NotEqualTilde, :NotExists, :NotGreater, :NotGreaterEqual, :NotGreaterFullEqual, :NotGreaterGreater, :NotGreaterLess, :NotGreaterSlantEqual, :NotGreaterTilde, :NotHumpDownHump, :NotHumpEqual, :NotLeftTriangle, :NotLeftTriangleBar, :NotLeftTriangleEqual, :NotLess, :NotLessEqual, :NotLessGreater, :NotLessLess, :NotLessSlantEqual, :NotLessTilde, :NotNestedGreaterGreater, :NotNestedLessLess, :NotPrecedes, :NotPrecedesEqual, :NotPrecedesSlantEqual, :NotReverseElement, :NotRightTriangle, :NotRightTriangleBar, :NotRightTriangleEqual, :NotSquareSubset, :NotSquareSubsetEqual, :NotSquareSuperset, :NotSquareSupersetEqual, :NotSubset, :NotSubsetEqual, :NotSucceeds, :NotSucceedsEqual, :NotSucceedsSlantEqual, :NotSucceedsTilde, :NotSuperset, :NotSupersetEqual, :NotTilde, :NotTildeEqual, :NotTildeFullEqual, :NotTildeTilde, :NotVerticalBar, :Nscr, :Ntilde, :OElig, :Oacute, :Ocirc, :Ocy, :Odblac, :Ofr, :Ograve, :Omacr, :Omega, :Oopf, :OpenCurlyDoubleQuote, :OpenCurlyQuote, :Or, :Oscr, :Oslash, :Otilde, :Otimes, :Ouml, :OverBar, :OverBrace, :OverBracket, :OverParenthesis, :PartialD, :Pcy, :Pfr, :Phi, :Pi, :PlusMinus, :Poincareplane, :Popf, :Pr, :Precedes, :PrecedesEqual, :PrecedesSlantEqual, :PrecedesTilde, :Prime, :Product, :Proportion, :Proportional, :Pscr, :Psi, :Qfr, :Qopf, :Qscr, :RBarr, :Racute, :Rang, :Rarr, :Rarrtl, :Rcaron, :Rcedil, :Rcy, :Re, :ReverseElement, :ReverseEquilibrium, :ReverseUpEquilibrium, :Rfr, :RightAngleBracket, :RightArrow, :RightArrowBar, :RightArrowLeftArrow, :RightCeiling, :RightDoubleBracket, :RightDownTeeVector, :RightDownVector, :RightDownVectorBar, :RightFloor, :RightTee, :RightTeeArrow, :RightTeeVector, :RightTriangle, :RightTriangleBar, :RightTriangleEqual, :RightUpDownVector, :RightUpTeeVector, :RightUpVector, :RightUpVectorBar, :RightVector, :RightVectorBar, :Rightarrow, :Ropf, :RoundImplies, :Rrightarrow, :Rscr, :Rsh, :RuleDelayed, :SHCHcy, :SHcy, :SOFTcy, :Sacute, :Sc, :Scaron, :Scedil, :Scirc, :Scy, :Sfr, :ShortDownArrow, :ShortLeftArrow, :ShortRightArrow, :ShortUpArrow, :Sigma, :SmallCircle, :Sopf, :Sqrt, :Square, :SquareIntersection, :SquareSubset, :SquareSubsetEqual, :SquareSuperset, :SquareSupersetEqual, :SquareUnion, :Sscr, :Star, :Sub, :Subset, :SubsetEqual, :Succeeds, :SucceedsEqual, :SucceedsSlantEqual, :SucceedsTilde, :SuchThat, :Sum, :Sup, :Superset, :SupersetEqual, :Supset, :THORN, :TSHcy, :TScy, :Tab, :Tcaron, :Tcedil, :Tcy, :Tfr, :Therefore, :Theta, :ThickSpace, :ThinSpace, :Tilde, :TildeEqual, :TildeFullEqual, :TildeTilde, :Topf, :TripleDot, :Tscr, :Tstrok, :Uacute, :Uarr, :Uarrocir, :Ubrcy, :Ubreve, :Ucirc, :Ucy, :Udblac, :Ufr, :Ugrave, :Umacr, :UnderBar, :UnderBrace, :UnderBracket, :UnderParenthesis, :Union, :UnionPlus, :Uogon, :Uopf, :UpArrow, :UpArrowBar, :UpArrowDownArrow, :UpDownArrow, :UpEquilibrium, :UpTee, :UpTeeArrow, :Uparrow, :Updownarrow, :UpperLeftArrow, :UpperRightArrow, :Upsi, :Upsilon, :Uring, :Uscr, :Utilde, :Uuml, :VDash, :Vbar, :Vcy, :Vdash, :Vdashl, :Vee, :Verbar, :Vert, :VerticalBar, :VerticalLine, :VerticalSeparator, :VerticalTilde, :VeryThinSpace, :Vfr, :Vopf, :Vscr, :Vvdash, :Wcirc, :Wedge, :Wfr, :Wopf, :Wscr, :Xfr, :Xi, :Xopf, :Xscr, :YAcy, :YIcy, :YUcy, :Yacute, :Ycirc, :Ycy, :Yfr, :Yopf, :Yscr, :Yuml, :ZHcy, :Zacute, :Zcaron, :Zcy, :Zdot, :ZeroWidthSpace, :Zfr, :Zopf, :Zscr, :aacute, :abreve, :ac, :acE, :acd, :acirc, :acute, :acy, :aelig, :af, :afr, :agrave, :aleph, :alpha, :amacr, :amalg, :amp, :and, :andand, :andd, :andslope, :andv, :ang, :ange, :angle, :angmsd, :angmsdaa, :angmsdab, :angmsdac, :angmsdad, :angmsdae, :angmsdaf, :angmsdag, :angmsdah, :angrt, :angrtvb, :angrtvbd, :angsph, :angst, :angzarr, :aogon, :aopf, :ap, :apE, :apacir, :ape, :apid, :apos, :approx, :approxeq, :aring, :ascr, :ast, :asymp, :asympeq, :atilde, :auml, :awconint, :awint, :bNot, :backcong, :backepsilon, :backprime, :backsim, :backsimeq, :barvee, :barwed, :barwedge, :bbrk, :bbrktbrk, :bcong, :bcy, :becaus, :because, :bemptyv, :bepsi, :bernou, :beta, :beth, :between, :bfr, :bigcap, :bigcirc, :bigcup, :bigodot, :bigoplus, :bigotimes, :bigsqcup, :bigstar, :bigtriangledown, :bigtriangleup, :biguplus, :bigvee, :bigwedge, :bkarow, :blacklozenge, :blacksquare, :blacktriangle, :blacktriangledown, :blacktriangleleft, :blacktriangleright, :blank, :blk12, :blk14, :blk34, :block, :bne, :bnequiv, :bnot, :bopf, :bot, :bottom, :bowtie, :boxDL, :boxDR, :boxDl, :boxDr, :boxH, :boxHD, :boxHU, :boxHd, :boxHu, :boxUL, :boxUR, :boxUl, :boxUr, :boxV, :boxVH, :boxVL, :boxVR, :boxVh, :boxVl, :boxVr, :boxbox, :boxdL, :boxdR, :boxdl, :boxdr, :boxh, :boxhD, :boxhU, :boxhd, :boxhu, :boxminus, :boxplus, :boxtimes, :boxuL, :boxuR, :boxul, :boxur, :boxv, :boxvH, :boxvL, :boxvR, :boxvh, :boxvl, :boxvr, :bprime, :breve, :brvbar, :bscr, :bsemi, :bsim, :bsime, :bsol, :bsolb, :bsolhsub, :bull, :bullet, :bump, :bumpE, :bumpe, :bumpeq, :cacute, :cap, :capand, :capbrcup, :capcap, :capcup, :capdot, :caps, :caret, :caron, :ccaps, :ccaron, :ccedil, :ccirc, :ccups, :ccupssm, :cdot, :cedil, :cemptyv, :cent, :centerdot, :cfr, :chcy, :check, :checkmark, :chi, :cir, :cirE, :circ, :circeq, :circlearrowleft, :circlearrowright, :circledR, :circledS, :circledast, :circledcirc, :circleddash, :cire, :cirfnint, :cirmid, :cirscir, :clubs, :clubsuit, :colon, :colone, :coloneq, :comma, :commat, :comp, :compfn, :complement, :complexes, :cong, :congdot, :conint, :copf, :coprod, :copy, :copysr, :cross, :cscr, :csub, :csube, :csup, :csupe, :ctdot, :cudarrl, :cudarrr, :cuepr, :cuesc, :cularr, :cularrp, :cup, :cupbrcap, :cupcap, :cupcup, :cupdot, :cupor, :cups, :curarr, :curarrm, :curlyeqprec, :curlyeqsucc, :curlyvee, :curlywedge, :curren, :curvearrowleft, :curvearrowright, :cuvee, :cuwed, :cwconint, :cwint, :cylcty, :dArr, :dHar, :dagger, :daleth, :darr, :dash, :dashv, :dbkarow, :dblac, :dcaron, :dcy, :dd, :ddagger, :ddarr, :ddotseq, :deg, :delta, :demptyv, :dfisht, :dfr, :dharl, :dharr, :diam, :diamond, :diamondsuit, :diams, :die, :digamma, :disin, :div, :divide, :divideontimes, :divonx, :djcy, :dlcorn, :dlcrop, :dollar, :dopf, :dot, :doteq, :doteqdot, :dotminus, :dotplus, :dotsquare, :doublebarwedge, :downarrow, :downdownarrows, :downharpoonleft, :downharpoonright, :drbkarow, :drcorn, :drcrop, :dscr, :dscy, :dsol, :dstrok, :dtdot, :dtri, :dtrif, :duarr, :duhar, :dwangle, :dzcy, :dzigrarr, :eDDot, :eDot, :eacute, :easter, :ecaron, :ecir, :ecirc, :ecolon, :ecy, :edot, :ee, :efDot, :efr, :eg, :egrave, :egs, :egsdot, :el, :elinters, :ell, :els, :elsdot, :emacr, :empty, :emptyset, :emptyv, :emsp, :emsp13, :emsp14, :eng, :ensp, :eogon, :eopf, :epar, :eparsl, :eplus, :epsi, :epsiv, :eqcirc, :eqcolon, :eqsim, :eqslantgtr, :eqslantless, :equals, :equest, :equiv, :equivDD, :eqvparsl, :erDot, :erarr, :escr, :esdot, :esim, :eta, :eth, :euml, :excl, :exist, :expectation, :exponentiale, :fallingdotseq, :fcy, :female, :ffilig, :fflig, :ffllig, :ffr, :filig, :flat, :fllig, :fltns, :fnof, :fopf, :forall, :fork, :forkv, :fpartint, :frac12, :frac13, :frac14, :frac15, :frac16, :frac18, :frac23, :frac25, :frac34, :frac35, :frac38, :frac45, :frac56, :frac58, :frac78, :frown, :fscr, :gE, :gEl, :gacute, :gamma, :gammad, :gap, :gbreve, :gcirc, :gcy, :gdot, :ge, :gel, :geq, :geqq, :geqslant, :ges, :gescc, :gesdot, :gesdoto, :gesdotol, :gesl, :gesles, :gfr, :gg, :ggg, :gimel, :gjcy, :gl, :glE, :gla, :glj, :gnE, :gnap, :gnapprox, :gne, :gneq, :gneqq, :gnsim, :gopf, :grave, :gscr, :gsim, :gsime, :gsiml, :gt, :gtcc, :gtcir, :gtdot, :gtlPar, :gtquest, :gtrapprox, :gtrarr, :gtrdot, :gtreqless, :gtreqqless, :gtrless, :gtrsim, :gvertneqq, :gvnE, :hArr, :hairsp, :half, :hamilt, :hardcy, :harr, :harrcir, :harrw, :hbar, :hcirc, :hearts, :heartsuit, :hellip, :hercon, :hfr, :hksearow, :hkswarow, :hoarr, :homtht, :hookleftarrow, :hookrightarrow, :hopf, :horbar, :hscr, :hslash, :hstrok, :hybull, :hyphen, :iacute, :ic, :icirc, :icy, :iecy, :iexcl, :iff, :ifr, :igrave, :ii, :iiiint, :iiint, :iinfin, :iiota, :ijlig, :imacr, :image, :imagline, :imagpart, :imath, :imof, :imped, :in, :incare, :infin, :infintie, :inodot, :int, :intcal, :integers, :intercal, :intlarhk, :intprod, :iocy, :iogon, :iopf, :iota, :iprod, :iquest, :iscr, :isin, :isinE, :isindot, :isins, :isinsv, :isinv, :it, :itilde, :iukcy, :iuml, :jcirc, :jcy, :jfr, :jmath, :jopf, :jscr, :jsercy, :jukcy, :kappa, :kappav, :kcedil, :kcy, :kfr, :kgreen, :khcy, :kjcy, :kopf, :kscr, :lAarr, :lArr, :lAtail, :lBarr, :lE, :lEg, :lHar, :lacute, :laemptyv, :lagran, :lambda, :lang, :langd, :langle, :lap, :laquo, :larr, :larrb, :larrbfs, :larrfs, :larrhk, :larrlp, :larrpl, :larrsim, :larrtl, :lat, :latail, :late, :lates, :lbarr, :lbbrk, :lbrace, :lbrack, :lbrke, :lbrksld, :lbrkslu, :lcaron, :lcedil, :lceil, :lcub, :lcy, :ldca, :ldquo, :ldquor, :ldrdhar, :ldrushar, :ldsh, :le, :leftarrow, :leftarrowtail, :leftharpoondown, :leftharpoonup, :leftleftarrows, :leftrightarrow, :leftrightarrows, :leftrightharpoons, :leftrightsquigarrow, :leftthreetimes, :leg, :leq, :leqq, :leqslant, :les, :lescc, :lesdot, :lesdoto, :lesdotor, :lesg, :lesges, :lessapprox, :lessdot, :lesseqgtr, :lesseqqgtr, :lessgtr, :lesssim, :lfisht, :lfloor, :lfr, :lg, :lgE, :lhard, :lharu, :lharul, :lhblk, :ljcy, :ll, :llarr, :llcorner, :llhard, :lltri, :lmidot, :lmoust, :lmoustache, :lnE, :lnap, :lnapprox, :lne, :lneq, :lneqq, :lnsim, :loang, :loarr, :lobrk, :longleftarrow, :longleftrightarrow, :longmapsto, :longrightarrow, :looparrowleft, :looparrowright, :lopar, :lopf, :loplus, :lotimes, :lowast, :lowbar, :loz, :lozenge, :lozf, :lpar, :lparlt, :lrarr, :lrcorner, :lrhar, :lrhard, :lrtri, :lscr, :lsh, :lsim, :lsime, :lsimg, :lsqb, :lsquo, :lsquor, :lstrok, :lt, :ltcc, :ltcir, :ltdot, :lthree, :ltimes, :ltlarr, :ltquest, :ltrPar, :ltri, :ltrie, :ltrif, :lurdshar, :luruhar, :lvertneqq, :lvnE, :mDDot, :macr, :male, :malt, :maltese, :map, :mapsto, :mapstodown, :mapstoleft, :mapstoup, :marker, :mcomma, :mcy, :mdash, :measuredangle, :mfr, :mho, :micro, :mid, :midast, :midcir, :middot, :minus, :minusb, :minusd, :minusdu, :mlcp, :mldr, :mnplus, :models, :mopf, :mp, :mscr, :mstpos, :mu, :multimap, :mumap, :nGg, :nGt, :nGtv, :nLeftarrow, :nLeftrightarrow, :nLl, :nLt, :nLtv, :nRightarrow, :nVDash, :nVdash, :nabla, :nacute, :nang, :nap, :napE, :napid, :napos, :napprox, :natur, :natural, :naturals, :nbsp, :nbump, :nbumpe, :ncap, :ncaron, :ncedil, :ncong, :ncongdot, :ncup, :ncy, :ndash, :ne, :neArr, :nearhk, :nearr, :nearrow, :nedot, :nequiv, :nesear, :nesim, :nexist, :nexists, :nfr, :ngE, :nge, :ngeq, :ngeqq, :ngeqslant, :nges, :ngsim, :ngt, :ngtr, :nhArr, :nharr, :nhpar, :ni, :nis, :nisd, :niv, :njcy, :nlArr, :nlE, :nlarr, :nldr, :nle, :nleftarrow, :nleftrightarrow, :nleq, :nleqq, :nleqslant, :nles, :nless, :nlsim, :nlt, :nltri, :nltrie, :nmid, :nopf, :not, :notin, :notinE, :notindot, :notinva, :notinvb, :notinvc, :notni, :notniva, :notnivb, :notnivc, :npar, :nparallel, :nparsl, :npart, :npolint, :npr, :nprcue, :npre, :nprec, :npreceq, :nrArr, :nrarr, :nrarrc, :nrarrw, :nrightarrow, :nrtri, :nrtrie, :nsc, :nsccue, :nsce, :nscr, :nshortmid, :nshortparallel, :nsim, :nsime, :nsimeq, :nsmid, :nspar, :nsqsube, :nsqsupe, :nsub, :nsubE, :nsube, :nsubset, :nsubseteq, :nsubseteqq, :nsucc, :nsucceq, :nsup, :nsupE, :nsupe, :nsupset, :nsupseteq, :nsupseteqq, :ntgl, :ntilde, :ntlg, :ntriangleleft, :ntrianglelefteq, :ntriangleright, :ntrianglerighteq, :nu, :num, :numero, :numsp, :nvDash, :nvHarr, :nvap, :nvdash, :nvge, :nvgt, :nvinfin, :nvlArr, :nvle, :nvlt, :nvltrie, :nvrArr, :nvrtrie, :nvsim, :nwArr, :nwarhk, :nwarr, :nwarrow, :nwnear, :oS, :oacute, :oast, :ocir, :ocirc, :ocy, :odash, :odblac, :odiv, :odot, :odsold, :oelig, :ofcir, :ofr, :ogon, :ograve, :ogt, :ohbar, :ohm, :oint, :olarr, :olcir, :olcross, :olt, :omacr, :omega, :omid, :ominus, :oopf, :opar, :operp, :oplus, :or, :orarr, :ord, :order, :orderof, :ordf, :ordm, :origof, :oror, :orslope, :orv, :oscr, :oslash, :osol, :otilde, :otimes, :otimesas, :ouml, :ovbar, :par, :para, :parallel, :parsim, :parsl, :part, :pcy, :percnt, :period, :permil, :perp, :pertenk, :pfr, :phi, :phiv, :phmmat, :phone, :pi, :pitchfork, :piv, :planck, :planckh, :plankv, :plus, :plusacir, :plusb, :pluscir, :plusdo, :plusdu, :pluse, :plusmn, :plussim, :plustwo, :pm, :pointint, :popf, :pound, :pr, :prE, :prap, :prcue, :pre, :prec, :precapprox, :preccurlyeq, :preceq, :precnapprox, :precneqq, :precnsim, :precsim, :prime, :primes, :prnE, :prnap, :prnsim, :prod, :profalar, :profline, :profsurf, :prop, :propto, :prsim, :prurel, :pscr, :psi, :puncsp, :qfr, :qint, :qopf, :qprime, :qscr, :quaternions, :quatint, :quest, :questeq, :quot, :rAarr, :rArr, :rAtail, :rBarr, :rHar, :race, :racute, :radic, :raemptyv, :rang, :rangd, :range, :rangle, :raquo, :rarr, :rarrap, :rarrb, :rarrbfs, :rarrc, :rarrfs, :rarrhk, :rarrlp, :rarrpl, :rarrsim, :rarrtl, :rarrw, :ratail, :ratio, :rationals, :rbarr, :rbbrk, :rbrace, :rbrack, :rbrke, :rbrksld, :rbrkslu, :rcaron, :rcedil, :rceil, :rcub, :rcy, :rdca, :rdldhar, :rdquo, :rdquor, :rdsh, :real, :realine, :realpart, :reals, :rect, :reg, :rfisht, :rfloor, :rfr, :rhard, :rharu, :rharul, :rho, :rhov, :rightarrow, :rightarrowtail, :rightharpoondown, :rightharpoonup, :rightleftarrows, :rightleftharpoons, :rightrightarrows, :rightsquigarrow, :rightthreetimes, :ring, :risingdotseq, :rlarr, :rlhar, :rmoust, :rmoustache, :rnmid, :roang, :roarr, :robrk, :ropar, :ropf, :roplus, :rotimes, :rpar, :rpargt, :rppolint, :rrarr, :rscr, :rsh, :rsqb, :rsquo, :rsquor, :rthree, :rtimes, :rtri, :rtrie, :rtrif, :rtriltri, :ruluhar, :rx, :sacute, :sc, :scE, :scap, :scaron, :sccue, :sce, :scedil, :scirc, :scnE, :scnap, :scnsim, :scpolint, :scsim, :scy, :sdot, :sdotb, :sdote, :seArr, :searhk, :searr, :searrow, :sect, :semi, :seswar, :setminus, :setmn, :sext, :sfr, :sfrown, :sharp, :shchcy, :shcy, :shortmid, :shortparallel, :shy, :sigma, :sigmav, :sim, :simdot, :sime, :simeq, :simg, :simgE, :siml, :simlE, :simne, :simplus, :simrarr, :slarr, :smallsetminus, :smashp, :smeparsl, :smid, :smile, :smt, :smte, :smtes, :softcy, :sol, :solb, :solbar, :sopf, :spades, :spadesuit, :spar, :sqcap, :sqcaps, :sqcup, :sqcups, :sqsub, :sqsube, :sqsubset, :sqsubseteq, :sqsup, :sqsupe, :sqsupset, :sqsupseteq, :squ, :square, :squarf, :squf, :srarr, :sscr, :ssetmn, :ssmile, :sstarf, :star, :starf, :straightepsilon, :straightphi, :strns, :sub, :subE, :subdot, :sube, :subedot, :submult, :subnE, :subne, :subplus, :subrarr, :subset, :subseteq, :subseteqq, :subsetneq, :subsetneqq, :subsim, :subsub, :subsup, :succ, :succapprox, :succcurlyeq, :succeq, :succnapprox, :succneqq, :succnsim, :succsim, :sum, :sung, :sup, :sup1, :sup2, :sup3, :supE, :supdot, :supdsub, :supe, :supedot, :suphsol, :suphsub, :suplarr, :supmult, :supnE, :supne, :supplus, :supset, :supseteq, :supseteqq, :supsetneq, :supsetneqq, :supsim, :supsub, :supsup, :swArr, :swarhk, :swarr, :swarrow, :swnwar, :szlig, :target, :tau, :tbrk, :tcaron, :tcedil, :tcy, :tdot, :telrec, :tfr, :there4, :therefore, :theta, :thetav, :thickapprox, :thicksim, :thinsp, :thkap, :thksim, :thorn, :tilde, :times, :timesb, :timesbar, :timesd, :tint, :toea, :top, :topbot, :topcir, :topf, :topfork, :tosa, :tprime, :trade, :triangle, :triangledown, :triangleleft, :trianglelefteq, :triangleq, :triangleright, :trianglerighteq, :tridot, :trie, :triminus, :triplus, :trisb, :tritime, :trpezium, :tscr, :tscy, :tshcy, :tstrok, :twixt, :twoheadleftarrow, :twoheadrightarrow, :uArr, :uHar, :uacute, :uarr, :ubrcy, :ubreve, :ucirc, :ucy, :udarr, :udblac, :udhar, :ufisht, :ufr, :ugrave, :uharl, :uharr, :uhblk, :ulcorn, :ulcorner, :ulcrop, :ultri, :umacr, :uml, :uogon, :uopf, :uparrow, :updownarrow, :upharpoonleft, :upharpoonright, :uplus, :upsi, :upsilon, :upuparrows, :urcorn, :urcorner, :urcrop, :uring, :urtri, :uscr, :utdot, :utilde, :utri, :utrif, :uuarr, :uuml, :uwangle, :vArr, :vBar, :vBarv, :vDash, :vangrt, :varepsilon, :varkappa, :varnothing, :varphi, :varpi, :varpropto, :varr, :varrho, :varsigma, :varsubsetneq, :varsubsetneqq, :varsupsetneq, :varsupsetneqq, :vartheta, :vartriangleleft, :vartriangleright, :vcy, :vdash, :vee, :veebar, :veeeq, :vellip, :verbar, :vert, :vfr, :vltri, :vnsub, :vnsup, :vopf, :vprop, :vrtri, :vscr, :vsubnE, :vsubne, :vsupnE, :vsupne, :vzigzag, :wcirc, :wedbar, :wedge, :wedgeq, :weierp, :wfr, :wopf, :wp, :wr, :wreath, :wscr, :xcap, :xcirc, :xcup, :xdtri, :xfr, :xhArr, :xharr, :xi, :xlArr, :xlarr, :xmap, :xnis, :xodot, :xopf, :xoplus, :xotime, :xrArr, :xrarr, :xscr, :xsqcup, :xuplus, :xutri, :xvee, :xwedge, :yacute, :yacy, :ycirc, :ycy, :yen, :yfr, :yicy, :yopf, :yscr, :yucy, :yuml, :zacute, :zcaron, :zcy, :zdot, :zeetrf, :zeta, :zfr, :zhcy, :zigrarr, :zopf, :zscr, ] end end end require "math_ml" math_ml-0.14/lib/math_ml/util.rb0000644000004100000410000002111512055512401016573 0ustar www-datawww-data#!/usr/bin/ruby # # Utility for MathML Library # # Copyright (C) 2006, KURODA Hiraku # You can redistribute it and/or modify it under GPL2. # require "math_ml" module MathML::Util ESCAPES = {"<"=>"lt", ">"=>"gt", "&"=>"amp", "\""=>"quot", "'"=>"apos" } INVALID_RE = /(?!)/ EQNARRAY_RE = /\\begin\s*\{eqnarray\}(#{MathML::LaTeX::MBEC}*?)\\end\s*\{eqnarray\}/ SINGLE_COMMAND_RE = /(\\([a-zA-Z]+))[ \t]?/ def self.escapeXML(s, br=false) r = s.gsub(/[<>&"']/){|m| "&#{ESCAPES[m]};"} br ? r.gsub(/\n/, "
\n") : r end def escapeXML(s, br=false) MathML::Util.escapeXML(s, br) end def self.collect_regexp(a) if a a = [a].flatten a.size>0 ? Regexp.new(a.inject(""){|r, i| i.is_a?(Regexp) ? "#{r}#{i.to_s}|" : r}.chop) : INVALID_RE else INVALID_RE end end def collect_regexp(a) MathML::Util.collect_regexp(a) end class MathData attr_reader :math_list, :msrc_list, :dmath_list, :dsrc_list, :escape_list, :esrc_list, :user_list, :usrc_list def initialize @math_list = [] @msrc_list = [] @dmath_list = [] @dsrc_list = [] @escape_list = [] @esrc_list = [] @user_list = [] @usrc_list = [] end def update(s) @math_list.concat(s.math_list) @msrc_list.concat(s.msrc_list) @dmath_list.concat(s.dmath_list) @dsrc_list.concat(s.dsrc_list) @escape_list.concat(s.escape_list) @esrc_list.concat(s.esrc_list) @user_list.concat(s.user_list) @usrc_list.concat(s.usrc_list) end end class SimpleLaTeX include MathML::Util @@default_latex = nil DEFAULT = { :delimiter=>"\001", :math_env_list=>[ /\$((?:\\.|[^\\\$])#{MathML::LaTeX::MBEC}*?)\$/m, /\\\((#{MathML::LaTeX::MBEC}*?)\\\)/m ], :dmath_env_list=>[ /\$\$(#{MathML::LaTeX::MBEC}*?)\$\$/m, /\\\[(#{MathML::LaTeX::MBEC}*?)\\\]/m ], :escape_list=>[ /\\(.)/m ], :through_list=>[ ], :escape_any=> false, :without_parse=>false } def initialize(options = {}) @params = DEFAULT.merge(options) @params[:parser] = MathML::LaTeX::Parser.new unless @params[:parser] || @params[:without_parse] @params[:math_envs] = collect_regexp(@params[:math_env_list]) @params[:dmath_envs] = collect_regexp(@params[:dmath_env_list]) @params[:escapes] = collect_regexp(@params[:escape_list]) @params[:throughs] = collect_regexp(@params[:through_list]) reset_encode_proc reset_rescue_proc reset_decode_proc reset_unencode_proc end def reset_encode_proc @encode_proc_re = INVALID_RE @encode_proc = nil end def set_encode_proc(*re, &proc) @encode_proc_re = collect_regexp(re) @encode_proc = proc end def reset_rescue_proc @rescue_proc = nil end def set_rescue_proc(&proc) @rescue_proc = proc end def reset_decode_proc @decode_proc = nil end def set_decode_proc(&proc) @decode_proc = proc end def set_unencode_proc(&proc) @unencode_proc = proc end def reset_unencode_proc @unencode_proc = nil end def encode(src, *proc_re, &proc) if proc_re.size>0 && proc_re[0].is_a?(MathData) data = proc_re.shift else data = MathData.new end proc_re = proc_re.size==0 ? @encode_proc_re : collect_regexp(proc_re) proc = @encode_proc unless proc s = StringScanner.new(src) encoded = "" until s.eos? if s.scan(/(.*?)(((((#{@params[:throughs]})|#{@params[:dmath_envs]})|#{@params[:math_envs]})|#{proc_re})|#{@params[:escapes]})/m) encoded << s[1] case when s[6] encoded << s[6] when s[5], s[4] env_src = s[5] || s[4] if @params[:dmath_envs]=~env_src encoded << "#{@params[:delimiter]}d#{data.dsrc_list.size}#{@params[:delimiter]}" data.dsrc_list << env_src else encoded << "#{@params[:delimiter]}m#{data.msrc_list.size}#{@params[:delimiter]}" data.msrc_list << env_src end when s[3] size = s[3].size s.pos = left = s.pos-size if r=proc.call(s) right = s.pos encoded << "#{@params[:delimiter]}u#{data.user_list.size}#{@params[:delimiter]}" data.user_list << r data.usrc_list << s.string[left...right] else encoded << s.peek(size) s.pos = s.pos+size end when s[2] encoded << "#{@params[:delimiter]}e#{data.escape_list.size}#{@params[:delimiter]}" @params[:escapes]=~s[2] data.esrc_list << s[2] data.escape_list << escapeXML($+, true) end else encoded << s.rest s.terminate end end parse(data, @params[:parser]) unless @params[:without_parse] return encoded, data end def error_to_html(e) "
\n#{escapeXML(e.message)}
\n#{escapeXML(e.done).gsub(/\n/, "
\n")}#{escapeXML(e.rest).gsub(/\n/, "
\n")}
" end def latex_parser @params[:parser] = MathML::LaTeX::Parser.new unless @params[:parser] @params[:parser] end def parse(data, parser=nil) parser = latex_parser unless parser (data.math_list.size...data.msrc_list.size).each do |i| begin @params[:math_envs]=~data.msrc_list[i] data.math_list[i] = parser.parse($+) rescue MathML::LaTeX::ParseError => e if @rescue_proc data.math_list[i] = @rescue_proc.call(e) else data.math_list[i] = error_to_html(e) end end end (data.dmath_list.size...data.dsrc_list.size).each do |i| begin @params[:dmath_envs]=~data.dsrc_list[i] data.dmath_list[i] = parser.parse($+, true) rescue MathML::LaTeX::ParseError => e if @rescue_proc data.dmath_list[i] = @rescue_proc.call(e) else data.dmath_list[i] = error_to_html(e) end end end end def decode(encoded, data, without_parsed = false, &proc) return nil if encoded==nil proc = @decode_proc unless proc encoded.gsub(/#{Regexp.escape(@params[:delimiter])}([demu])(\d+)#{Regexp.escape(@params[:delimiter])}/) do i = $2.to_i t, d, s = case $1 when "d" [:dmath, without_parsed ? escapeXML(data.dsrc_list[i], true) : data.dmath_list[i], data.dsrc_list[i]] when "e" [:escape, data.escape_list[i], data.esrc_list[i]] when "m" [:math, without_parsed ? escapeXML(data.msrc_list[i], true) : data.math_list[i], data.msrc_list[i]] when "u" [:user, data.user_list[i], data.usrc_list[i]] end if proc proc.call(d, :type=>t, :index=>i, :src=>s) || d else d end end end def decode_partial(type, encoded, data, &proc) return nil if encoded==nil head = case type when :math "m" when :dmath "d" when :escape "e" when :user "u" else return end encoded.gsub(/#{Regexp.escape(@params[:delimiter])}#{head}(\d+)#{Regexp.escape(@params[:delimiter])}/) do i = $1.to_i t, d, s = case head when "d" [:dmath, data.dmath_list[i], data.dsrc_list[i]] when "e" [:escape, data.escape_list[i], data.esrc_list[i]] when "m" [:math, data.math_list[i], data.msrc_list[i]] when "u" [:user, data.user_list[i], data.usrc_list[i]] end if proc proc.call(d, :type=>t, :index=>i, :src=>s) || "#{@params[:delimiter]}#{head}#{i}#{@params[:delimiter]}" else d end end end def unencode(encoded, data, without_escape=false, &proc) return nil if encoded==nil proc = @unencode_proc unless proc encoded.gsub(/#{Regexp.escape(@params[:delimiter])}([demu])(\d+)#{Regexp.escape(@params[:delimiter])}/) do i = $2.to_i t, s = case $1 when "d" [:dmath, data.dsrc_list[i]] when "e" [:escape, data.esrc_list[i]] when "m" [:math, data.msrc_list[i]] when "u" [:user, data.usrc_list[i]] end s = escapeXML(s, true) unless without_escape if proc proc.call(s, :type=>t, :index=>i) || s else s end end end def self.encode(src) @@default_latex = self.new unless @@default_latex @@default_latex.encode(src) end def self.decode(src, data) @@default_latex.decode(src, data) end def parse_eqnarray(src, parser=nil) src = "\\begin{array}{ccc}#{src}\\end{array}" parser = latex_parser unless parser begin parser.parse(src, true) rescue MathML::LaTeX::ParseError => e e = MathML::LaTeX::ParseError.new(e.message, e.rest.sub(/\\end\{array\}\z/, '\end{eqnarray}'), e.done.sub(/\A\\begin\{array\}\{ccc\}/, '\begin{eqnarray}')) @rescue_proc ? @rescue_proc.call(e) : error_to_html(e) end end def parse_single_command(src, parser=nil) s = src[SINGLE_COMMAND_RE, 1] parser = latex_parser unless parser begin parser.parse(s) rescue MathML::LaTeX::ParseError => e src[SINGLE_COMMAND_RE, 2] end end end end math_ml-0.14/lib/math_ml/string.rb0000644000004100000410000000130612055512401017124 0ustar www-datawww-data#!/usr/bin/ruby # # Extension of String class by MathML Library # # Copyright (C) 2007, KURODA Hiraku # You can redistribute it and/or modify it under GPL2. # require "math_ml" module MathML module String @@mathml_latex_parser = nil def self.mathml_latex_parser @@mathml_latex_parser = MathML::LaTeX::Parser.new unless @@mathml_latex_parser @@mathml_latex_parser end def self.mathml_latex_parser=(mlp) raise TypeError unless mlp.is_a?(MathML::LaTeX::Parser) || mlp==nil @@mathml_latex_parser = mlp end def to_mathml(displaystyle=false) MathML::String.mathml_latex_parser.parse(self, displaystyle) end end end class String include MathML::String end