mathematical 1.7.0-x86_64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42a02742484230dd0dbcf25103fe707d765adb6edb2c191344b387cc79ee833e
+  data.tar.gz: 14eb9ac009aba8008226b7ae050644c1fbd1e7aff2e37d2bd4a08f04bc6a56a9
+SHA512:
+  metadata.gz: 7a540559e24938d67faa00bd7416978c3fc9909b8b5fe018756d4fa9a8c4db59f071592213dfa21433dad8b4ebb3c822baf617b0fb381572a6c286afdd32e131
+  data.tar.gz: aef19bef5f1d25d1c0eb9df7682d45a32ded44d5f03a181b6a9196204636e59f8e411feec4366f9ea013bf373f21c3ee462e91d204ff13c567a54b6f2f74eb2d

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Garen Torikian
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,284 @@
+# Mathematical
+
+Quickly convert math equations into beautiful SVGs (or PNGs/MathML).
+
+[![Build Status](https://travis-ci.org/gjtorikian/mathematical.svg?branch=master)](https://travis-ci.org/gjtorikian/mathematical) [![Gem Version](https://badge.fury.io/rb/mathematical.svg)](http://badge.fury.io/rb/mathematical)
+
+![Mathematical](https://i.imgur.com/JC7HT32.gif)
+
+## ⚠️ Maintenance Status ⚠️
+
+SVG and especially PNG generation is currently unmaintained. This library should primarily be used for MathML generation.
+
+Please reach out if you would like to mantain SVG and PNG portions of the library.
+
+## Installation
+
+Precompiled native gems are available for Linux, macOS, and Windows. Add this line to your application's Gemfile:
+
+    gem 'mathematical'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mathematical
+
+### Platform-specific notes
+
+**Linux** (x86_64 and ARM, glibc and musl): Fully self-contained — no additional dependencies needed.
+
+**macOS**: Install runtime libraries via Homebrew:
+
+    $ brew install glib gdk-pixbuf cairo pango libxml2
+
+**Windows**: Install runtime libraries via MSYS2 (UCRT64):
+
+    $ pacman -S mingw-w64-ucrt-x86_64-glib2 mingw-w64-ucrt-x86_64-cairo mingw-w64-ucrt-x86_64-pango mingw-w64-ucrt-x86_64-gdk-pixbuf2 mingw-w64-ucrt-x86_64-libxml2
+
+### Building from source
+
+If no precompiled gem is available for your platform, it will be compiled from source. You'll need cmake, pkg-config, bison, flex, and the development headers for glib, cairo, pango, gdk-pixbuf, and libxml2.
+
+## Usage
+
+The simplest way to do this is
+
+``` ruby
+require 'mathematical'
+
+Mathematical.new.render(string_with_math)
+```
+
+`string_with_math` should just be a string of TeX math. The default delimiters are `$..$` for inline and `$$..$$` for display. These can be changed by options--see below.
+
+The output will be a hash, with keys that depend on the format you want:
+
+* If you asked for an SVG, you'll get:
+  * `:width`: the width of the resulting image
+  * `:height`: the height of the resulting image
+  * `:data`: the actual string of SVG
+* If you asked for a PNG, you'll get:
+  * `:width`: the width of the resulting image
+  * `:height`: the height of the resulting image
+  * `:data`: the PNG data
+* If you asked for MathML, you'll get:
+  * `:data`: the MathML data
+* If you pass in invalid TeX, you'll get:
+  * `:data`: the original invalid TeX
+  * `:exception`: the error class (with message)
+
+**Note**: If you pass in invalid TeX, an error is not raised, but a message *is* printed to STDERR. It is the caller's responsibility to check for `:exception` and act on it.
+
+`render` just converts a single equation. There are several other methods you can use:
+
+* `filter`:  Given a string with a mix of TeX math and non-math elements, this returns a single string containing just the converted math elements.
+* `text_filter`: Given a string with a mix of TeX math and non-math elements, this converts all the math and leaves the rest of the string unmodified.
+* `strict_filter`:  Given a string with a mix of TeX math and non-math elements, this converts all the math and leaves the rest of the string unmodified. HTML tags are removed completely.
+
+### Array of equations
+
+Rather than just a string, you can also provide an array of math inputs:
+
+``` ruby
+inputs = []
+inputs << '$\pi$'
+inputs << '$not__thisisnotreal$'
+inputs << '$\alpha$'
+
+Mathematical.new.render(inputs)
+```
+
+This returns an array of hashes, rendering the indices. For example, for the above, you will receive the following output:
+
+```
+[ {:data => "...", :width => ... }, { :data => '$not__thisisnotreal$', :exception => "...", {:data => "...", :width => ... }]
+```
+
+That is, while the first and last elements are valid TeX math, the middle one is not, so the same string is returned. As with single strings, the error message is printed to STDERR, but not raised.
+
+### Options
+
+`Mathematical.new` takes an optional hash to define a few options:
+
+| Name | Description | Default
+|------|-------------|--------
+| `:ppi` | A double determining the pixels per inch of the resulting SVG | `72.0`
+| `:zoom` | A double determining the zoom level of the resulting SVG | `1.0`
+| `:base64` | A boolean determining whether Mathematical's output should be a base64-encoded SVG string | `false`
+| `:maxsize` | A numeral indicating the `MAXSIZE` the output string can be. | `unsigned long`
+| `:format` | A symbol indicating whether you want an `:svg`, `:png`, or `:mathml` output. | `:svg`
+| `:delimiter` | A symbol indicating whether you want an `:DOLLAR` for inline (`$..$`), `:DOUBLE` for display (`$$..$$`), `:PARENS` for inline (`\(..\)`), `:BRACKETS` for display (`[..\]`), or `:ENVIRONMENTS` for parsing bare `\\begin..\\end` environments. You can also pass in an array of symbols to have multiple delimiters considered. | `[:DOLLAR, :DOUBLE]`
+
+Pass these in like this:
+
+``` ruby
+options = { :ppi => 200.0, :zoom => 5.0, :base64 => true }
+renderer = Mathematical.new(options)
+renderer.render('$a \ne b$')
+```
+
+### Supported commands and symbols
+
+Check out [SUPPORTED.md on the mtex2MML website](https://github.com/gjtorikian/mtex2MML/blob/master/SUPPORTED.md).
+
+**Note**: This library makes a few assumptions about the strings that you pass in. It assumes that `$..$` is inline math and `$$..$$` is display math.
+
+## Building from source
+
+To build from source, install the development dependencies for your platform:
+
+**Linux (Debian/Ubuntu):**
+
+    $ sudo apt-get install cmake bison flex pkg-config libglib2.0-dev libgdk-pixbuf2.0-dev libcairo2-dev libpango1.0-dev libxml2-dev
+
+**macOS:**
+
+    $ brew install glib gdk-pixbuf cairo pango cmake pkg-config
+
+Then:
+
+```
+bundle exec rake compile
+```
+
+### Fonts and special notices for Mac OS X
+
+Install the fonts with:
+
+```
+cd ~/Library/Fonts
+curl -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmex10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmmi10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmr10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmsy10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/esint10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/eufm10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/msam10.ttf \
+     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/msbm10.ttf
+```
+
+## Troubleshooting
+
+### Issues building Lasem
+
+If you're having issues building Lasem, or have Lasem already preinstalled, you should set the `MATHEMATICAL_USE_SYSTEM_LASEM` environment variable to skip the build:
+
+* If you use bundler:
+
+        MATHEMATICAL_USE_SYSTEM_LASEM=1 bundle install
+
+* If you use gem install:
+
+        MATHEMATICAL_USE_SYSTEM_LASEM=1 gem install mathematical
+
+### Issues building mtex2mml
+
+If you're having issues building mtex2mml, or have mtex2mml already preinstalled, you should set the `MATHEMATICAL_USE_SYSTEM_MTEX2MML` environment variable to skip the build:
+
+* If you use bundler:
+
+        MATHEMATICAL_USE_SYSTEM_MTEX2MML=1 bundle install
+
+* If you use gem install:
+
+        MATHEMATICAL_USE_SYSTEM_MTEX2MML=1 gem install mathematical
+
+## Benchmark
+
+Run benchmarks with `bundle exec rake benchmark`:
+
+```
+Benchmarking....
+Count: 3868 equations
+Iterations: 1
+                                               user     system      total        real
+Rendering...                               3.280000   0.070000   3.350000 (  4.324458)
+```
+
+## History
+
+There are a smattering of libraries written in various languages to convert math
+into a variety of formats. But there needs to be a sane way to show math
+equations in the browser. With browser support for MathML under attack, it's
+unfortunately not a sustainable solution. A PNG or SVG representation of the
+equation is the safest way to go.
+
+Most advice suggests using [MathJax](http://www.mathjax.org/). While extremely popular
+I dislike the "stuttering" effect caused by pages loading math. JavaScript
+shouldn't be used in situations where server-rendering is a possibility, in my opinion.
+
+To that end, I obsessed over the problem of server-side math rendering for over a
+week. Here was my journey:
+
+* I started out with [`blahtexml`](https://github.com/gvanas/blahtexml), which takes
+TeX equations and converts them to PNG. This wasn't a bad idea, but it took too long;
+for twelve equations, it took eight seconds. It was slow because it shelled out
+to [`LaTeX`](http://www.latex-project.org/), *then* [`dvipng`](http://www.nongnu.org/dvipng/).
+
+  In fact, as I discovered, most projects on the 'Net shell out to `LaTeX`, then
+something else, which makes performance absolutely horrid. I had to find something
+better, with preferably no dependency on `LaTeX`.
+
+* [`mimetex`](http://www.forkosh.com/mimetex.html) was my next attempt. It looked
+great: a pure C implementation that turned TeX equations into a rasterized representation,
+and then into a PNG. The speed was there, but the output image was pretty jagged.
+I tweaked the program to output BMPs, and tried to sharpen those with [`potrace`](http://potrace.sourceforge.net/),
+but the results were less then pleasant. The "update" to `mimetex` is [`mathtex`](http://www.forkosh.com/mathtex.html),
+but it, too, depends on `LaTeX` and `dvipng` binaries to produce images.
+
+* [`pmml2svg`](http://pmml2svg.sourceforge.net/) had potential. It's a set of
+XSLT stylesheets to convert MathML to SVG. Unfortunately, it relies on XSLT 2.0,
+of which there are no Ruby bindings (at the time of this writing, April '14). It
+had to rely on [Saxon](http://saxon.sourceforge.net/) and Java.
+
+* [`tth`](http://hutchinson.belmont.ma.us/tth/) converts TeX to HTML, but the
+output is aesthetically unpleasing, so I passed.
+
+* Wikipedia uses [`texvc`](https://github.com/dlitz/texvc), which is written in OCaml,
+a language I am utterly unfamiliar with. In any event, I could not get the code
+to compile on my machine.
+
+* It took me forever to finally compile [`gtkmathview`](https://github.com/khaledhosny/gtkmathview),
+and when it did, I got a bunch of SVG images with screwed up fonts.
+
+* [`dvisvgm`](http://dvisvgm.sourceforge.net/) worked well, but still depended
+on two external binaries (`LaTeX` to convert the text to dvi, and `dvisvgm` to turn
+it into SVG)
+
+* At one point, I began to try and convert the MathJax code to Ruby to figure out
+how it accomplished its `toSVG` methods. The MathJax codebase, while written by
+geniuses, is incomprehensible, due in part to JavaScript's inability
+to possess a coherent structure.
+
+* Near the end of my wits, I mimicked the behavior of [`mathrender2`](https://github.com/quipper/mathrender2),
+which uses [PhantomJS](http://phantomjs.org/) to embed MathJax onto a fake
+HTML page. This produced exactly what I needed: a bunch of accurate SVG files with
+no intermediate binaries. It was, unfortunately, a bit slow: for an arbitrary
+composition of 880 equations, it took about eight seconds to complete. Could I
+do better?
+
+* I came across [Lasem](https://github.com/LasemProject/lasem),
+which met every need. It has no external binary dependencies (only library packages),
+can convert directly to SVG, and it's fast. The same arbitrary 880 equations were
+rendered in moments.
+
+And thus a wrapper was born.
+
+## More math stuff
+
+Check out [math-to-itex](https://github.com/gjtorikian/math-to-itex/), which quickly
+parses out TeX notation from strings.
+
+With it, you could do something fun like:
+
+``` ruby
+MathToItex(string).convert do |eq, type|
+  svg_content = Mathematical.new(:base64 => true).render(eq)
+
+  # create image tags of math with base64-encoded SVGs
+  %|<img class="#{type.to_s}-math" data-math-type="#{type.to_s}-math" src="#{svg_content}"/>|
+end
+```

data/Rakefile

@@ -0,0 +1,128 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "fileutils"
+require "tmpdir"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+# ─── Extension compilation ─────────────────────────────────────────────────────
+
+require "rake/extensiontask"
+
+CROSS_PLATFORMS = [
+  "x86_64-linux-gnu",
+  "x86_64-linux-musl",
+  "aarch64-linux-gnu",
+  "aarch64-linux-musl",
+]
+
+NATIVE_PLATFORMS = [
+  "arm64-darwin",
+  "x86_64-darwin",
+  "x64-mingw-ucrt",
+]
+
+ALL_PLATFORMS = CROSS_PLATFORMS + NATIVE_PLATFORMS
+
+# Ruby versions to target for precompiled gems
+CROSS_RUBIES = ["3.1.0", "3.2.0", "3.3.0", "3.4.0", "4.0.0"]
+
+spec = Gem::Specification.load("mathematical.gemspec")
+
+Rake::ExtensionTask.new("mathematical", spec) do |ext|
+  ext.lib_dir = File.join("lib", "mathematical")
+  ext.cross_compile = true
+  ext.cross_platform = CROSS_PLATFORMS
+  ext.cross_config_options << "--enable-cross-build"
+
+  ext.cross_compiling do |cross_spec|
+    # Native gems don't need source files — the compiled .so is included
+    cross_spec.files.reject! { |path| File.fnmatch?("ext/**/*", path) }
+    # Include font files in native gems
+    cross_spec.files += Dir.glob("fonts/**/*")
+  end
+end
+
+# Set RUBY_CC_VERSION for cross-compilation
+begin
+  require "rake_compiler_dock"
+  ENV["RUBY_CC_VERSION"] = RakeCompilerDock.ruby_cc_version("3.1", "3.2", "3.3", "3.4", "4.0")
+rescue LoadError
+  ENV["RUBY_CC_VERSION"] = CROSS_RUBIES.join(":")
+end
+
+# ─── Cross-compiled gem tasks (Linux via rake-compiler-dock) ───────────────────
+
+namespace "gem" do
+  CROSS_PLATFORMS.each do |platform|
+    desc "Build native gem for #{platform}"
+    task platform do
+      require "rake_compiler_dock"
+
+      # Both GNU and musl RCD containers are Debian-based (musl uses a cross-compiler,
+      # NOT Alpine). Install deps with apt-get, running as root inside the container.
+      RakeCompilerDock.sh(<<~SCRIPT, platform: platform, verbose: true)
+        set -e
+        sudo apt-get update -qq && sudo apt-get install -y --no-install-recommends \
+          cmake bison flex pkg-config ninja-build python3 python3-pip
+        # RCD containers (Ubuntu 20.04) ship old CMake 3.16 and Meson 0.53;
+        # libxml2 2.12+ needs CMake 3.18+ and glib 2.80+ needs Meson 1.2+
+        pip3 install --upgrade cmake meson packaging
+        export PATH="$(python3 -m site --user-base)/bin:$PATH"
+        # Build static deps from source (Debian lacks .a files for meson-built libs)
+        script/build_static_deps
+        # RCD containers use rbenv; override .ruby-version which may not match
+        export RBENV_VERSION="$(rbenv versions --bare | tail -1)"
+        gem install bundler --no-document
+        bundle install
+        bundle exec rake native:#{platform} gem MAKE="nice make -j$(nproc)"
+      SCRIPT
+    end
+  end
+
+  desc "Build native gems for all Linux platforms"
+  multitask linux: CROSS_PLATFORMS
+
+  desc "Build the source (platform=ruby) gem"
+  task :source do
+    sh "gem build mathematical.gemspec"
+  end
+end
+
+# ─── Default tasks ─────────────────────────────────────────────────────────────
+
+task default: [:test]
+
+Gem::PackageTask.new(spec)
+
+Rake::Task[:test].prerequisites
+
+task build: [:clean]
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+desc "Pretty format C code"
+task :format do
+  puts %x(astyle --indent=spaces=2 --style=1tbs --keep-one-line-blocks \
+        $(ack -n -f --type=cpp --type=cc ext/mathematical/))
+end
+
+desc "Run a benchmark"
+task :benchmark do
+  $LOAD_PATH.unshift("lib")
+  load "script/benchmark.rb"
+end
+
+GEMSPEC = Bundler.load_gemspec("mathematical.gemspec")
+gem_path = Gem::PackageTask.new(GEMSPEC).define
+desc "Package the ruby gem"
+task "package" => [gem_path]

data/ext/README.md

@@ -0,0 +1,21 @@
+Lasem aims to be a C/Gobject based SVG/Mathml renderer and editor, supporting CSS
+style sheets (only rendering is implemented for now). It uses cairo and pango as
+it's rendering abstraction layer, and then support numerous output formats: xlib,
+PNG, SVG, PDF, PS, EPS... It's written by Emmanuel Pacaud.
+
+Lasem was added as a Git submodule of this project.
+
+Some documentation can be found here:
+
+* http://blogs.gnome.org/emmanuel/category/lasem/
+* https://git.gnome.org/browse/lasem/
+
+### Notes on building for OS X
+
+* In *autogen.sh*, rename `libtoolize` to `glibtoolize`
+* Debug with `-d dom,measure,update,render,viewport`
+
+* * *
+
+mtex2MML transforms itex (a dialect of LaTeX) into MathML. mtex2MML is developed by
+me, but was forked from an original project by Paul Gartside and Jacques Distler.

data/fonts/fonts.conf

@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<!--
+  Fontconfig configuration for bundled Computer Modern fonts.
+  This file is loaded via FONTCONFIG_PATH at runtime so that
+  lasem can find the math fonts for SVG/PNG rendering.
+-->
+<fontconfig>
+  <dir prefix="relative">.</dir>
+  <cachedir prefix="xdg">fontconfig</cachedir>
+</fontconfig>

data/lib/mathematical/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ruby-enum"
+
+class Configuration
+  class Delimiters
+    include Ruby::Enum
+
+    define :DEFAULT, 0
+    define :DOLLAR, 1
+    define :DOUBLE, 2
+    define :PARENS, 4
+    define :BRACKETS, 8
+    define :ENVIRONMENTS, 16
+
+    class << self
+      def option_exists?(option)
+        unless Delimiters.key?(option)
+          raise(TypeError, "delimiter type does not exist: #{option}")
+        end
+      end
+    end
+  end
+end

data/lib/mathematical/corrections.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Mathematical
+  module Corrections
+    def apply_corrections(maths)
+      adjust_lt_gt(maths)
+    end
+
+    # from the itex website: http://bit.ly/1Et74ed
+    # It is possible (though probably not recommended) to insert MathML markup
+    # inside itex equations. So "<" and ">" are significant.
+    # To obtain a less-than or greater-than sign, you should use \lt or \gt, respectively.
+    def adjust_lt_gt(maths)
+      maths.gsub("<", '\lt').gsub(">", '\gt')
+    end
+  end
+end

data/lib/mathematical/validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Mathematical
+  module Validator
+    FORMAT_TYPES = [:svg, :png, :mathml].freeze
+    RENDER_TYPES = [:parse, :filter, :text_filter, :strict_filter].freeze
+
+    def validate_config(config)
+      raise(TypeError, "maxsize must be an integer!") unless config[:maxsize].is_a?(Integer)
+      raise(TypeError, "maxsize cannot be less than 0!") if config[:maxsize] < 0
+      raise(TypeError, "format must be a symbol!") unless config[:format].is_a?(Symbol)
+      raise(TypeError, "format type must be one of the following formats: #{FORMAT_TYPES.join(", ")}") unless FORMAT_TYPES.include?(config[:format])
+
+      if config[:delimiter].is_a?(Symbol)
+        Configuration::Delimiters.option_exists?(config[:delimiter])
+      elsif config[:delimiter].is_a?(Array)
+        config[:delimiter] = [nil] if config[:delimiter].empty?
+
+        config[:delimiter].each do |delim|
+          Configuration::Delimiters.option_exists?(delim)
+        end
+      else
+        raise(TypeError, "delimiter type must be a valid symbol or array of symbols")
+      end
+    end
+
+    def validate_content(maths)
+      if maths.is_a?(Array)
+        maths.map { |m| validate_string(m) }
+      else
+        validate_string(maths)
+      end
+    end
+
+    def validate_string(maths)
+      raise(ArgumentError, "input must be string!") unless maths.is_a?(String)
+
+      maths.strip
+    end
+  end
+end

data/lib/mathematical/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Mathematical
+  VERSION = "1.7.0"
+end

data/lib/mathematical.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# Load the precompiled native extension (version-specific) or fall back
+# to the source-compiled extension.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "mathematical/#{Regexp.last_match(1)}/mathematical"
+rescue LoadError
+  require "mathematical/mathematical"
+end
+
+require "mathematical/configuration"
+require "mathematical/corrections"
+require "mathematical/validator"
+require "mathematical/version"
+
+require "base64"
+
+class Mathematical
+  # Set up bundled fonts for fontconfig (used by lasem for SVG/PNG rendering).
+  # This allows SVG/PNG rendering without system font installation.
+  FONT_DIR = File.expand_path("../../fonts", __dir__)
+  if File.directory?(FONT_DIR)
+    existing = ENV.fetch("FONTCONFIG_PATH", "")
+    ENV["FONTCONFIG_PATH"] = existing.empty? ? FONT_DIR : "#{FONT_DIR}:#{existing}"
+  end
+
+  include Corrections
+  include Validator
+
+  DEFAULT_OPTS = {
+    ppi: 72.0,
+    zoom: 1.0,
+    base64: false,
+    maxsize: 0,
+    format: :svg,
+    delimiter: [:DOLLAR, :DOUBLE],
+  }
+
+  XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+
+  MATH_MATCH = %r{<math xmlns.+?</math>}m
+
+  def initialize(options = {})
+    @config = DEFAULT_OPTS.merge(options)
+
+    validate_config(@config)
+
+    @config[:formatInt] = FORMAT_TYPES.index(@config[:format])
+
+    @config[:delimiter] = if @config[:delimiter].is_a?(Symbol)
+      Configuration::Delimiters.to_h[@config[:delimiter]]
+    else
+      @config[:delimiter].map do |delim|
+        Configuration::Delimiters.to_h[delim]
+      end.inject(0, :|)
+    end
+
+    @processer = Mathematical::Process.new(@config)
+  end
+
+  def parse(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:parse))
+    result(result_data)
+  end
+  # TODO: deprecate this?
+  alias_method :render, :parse
+
+  def filter(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:filter))
+    result(result_data)
+  end
+
+  def text_filter(maths)
+    maths = validate_content(maths)
+    widths = []
+    heights = []
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:text_filter))
+    # TODO: can/should be optimized to not do two calls here, but I am thinking
+    # about moving to Rust and don't have time to write safe C...
+    if result_data[:data] && @config[:format] != :mathml
+      result_data[:data].gsub!(MATH_MATCH) do |_match|
+        result = @processer.process(maths, RENDER_TYPES.find_index(:parse))
+        widths << result[:width]
+        heights << result[:height]
+        result[:data]
+      end
+
+      result_data[:width] = widths
+      result_data[:height] = heights
+    end
+
+    result(result_data)
+  end
+
+  def strict_filter(maths)
+    maths = validate_content(maths)
+    result_data = @processer.process(maths, RENDER_TYPES.find_index(:strict_filter))
+    result(result_data)
+  end
+
+  def result(result_data)
+    raise(RuntimeError) if !result_data.is_a?(Hash) && !result_data.is_a?(Array)
+
+    if result_data.is_a?(Array)
+      result_data.map { |d| format_data(d) }
+    else
+      format_data(result_data)
+    end
+  end
+
+  private
+
+  def format_data(result_hash)
+    # we passed in an array of math, and found an unprocessable element
+    return result_hash if result_hash[:exception]
+
+    case @config[:format]
+    when :svg
+      # remove starting <?xml...> tag
+      result_hash[:data] = result_hash[:data].gsub(XML_HEADER, "")
+      result_hash[:data] = svg_to_base64(result_hash[:data]) if @config[:base64]
+
+      result_hash
+    when :png, :mathml # do nothing with these...for now?
+      result_hash
+    end
+  end
+
+  def svg_to_base64(contents)
+    "data:image/svg+xml;base64,#{Base64.strict_encode64(contents)}"
+  end
+end

data/mathematical.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mathematical/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathematical"
+  spec.version       = Mathematical::VERSION
+  spec.authors       = ["Garen Torikian"]
+  spec.email         = ["gjtorikian@gmail.com"]
+  spec.summary       = "Quickly convert math equations into beautiful SVGs/PNGs/MathML."
+  spec.description   = "A very fast way to turn TeX math equations into beautifully rendered SVGs, to embed on the web. This library is mostly written in C and is a general purpose wrapper to GNOME's Lasem."
+  spec.homepage      = "https://github.com/gjtorikian/mathematical"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.1"
+
+  spec.files         = ["LICENSE.txt", "README.md", "Rakefile", "mathematical.gemspec"]
+  spec.files        += Dir.glob("lib/**/*.rb")
+  spec.files        += Dir["ext/**/*"].reject { |f| f =~ /\.svg$|\.mml$|\.png$|\.o$/ }
+  spec.files        += Dir.glob("fonts/**/*")
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/mathematical/extconf.rb"]
+
+  spec.add_dependency("ruby-enum", ">= 0.4", "< 2.0")
+
+  spec.add_development_dependency("benchmark")
+  spec.add_development_dependency("math-to-itex", "~> 0.3")
+  spec.add_development_dependency("minitest", "~> 5.6")
+  spec.add_development_dependency("nokogiri", "~> 1.10")
+  spec.add_development_dependency("rake-compiler", "~> 1.2")
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: mathematical
+version: !ruby/object:Gem::Version
+  version: 1.7.0
+platform: x86_64-linux-gnu
+authors:
+- Garen Torikian
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-enum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: math-to-itex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.6'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A very fast way to turn TeX math equations into beautifully rendered
+  SVGs, to embed on the web. This library is mostly written in C and is a general
+  purpose wrapper to GNOME's Lasem.
+email:
+- gjtorikian@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/README.md
+- fonts/cmex10.ttf
+- fonts/cmmi10.ttf
+- fonts/cmr10.ttf
+- fonts/cmsy10.ttf
+- fonts/eufm10.ttf
+- fonts/fonts.conf
+- fonts/msam10.ttf
+- fonts/msbm10.ttf
+- lib/mathematical.rb
+- lib/mathematical/3.0/mathematical.so
+- lib/mathematical/3.1/mathematical.so
+- lib/mathematical/3.2/mathematical.so
+- lib/mathematical/3.3/mathematical.so
+- lib/mathematical/3.4/mathematical.so
+- lib/mathematical/4.0/mathematical.so
+- lib/mathematical/configuration.rb
+- lib/mathematical/corrections.rb
+- lib/mathematical/validator.rb
+- lib/mathematical/version.rb
+- mathematical.gemspec
+homepage: https://github.com/gjtorikian/mathematical
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Quickly convert math equations into beautiful SVGs/PNGs/MathML.
+test_files: []