hyhyhy 0.0.4

data/lib/hyhyhy/structure/_includes/katex/metrics/parse_tfm.py

@@ -0,0 +1,201 @@
+class CharInfoWord(object):
+    def __init__(self, word):
+        b1, b2, b3, b4 = (word >> 24,
+                          (word & 0xff0000) >> 16,
+                          (word & 0xff00) >> 8,
+                          word & 0xff)
+
+        self.width_index = b1
+        self.height_index = b2 >> 4
+        self.depth_index = b2 & 0x0f
+        self.italic_index = (b3 & 0b11111100) >> 2
+        self.tag = b3 & 0b11
+        self.remainder = b4
+
+    def has_ligkern(self):
+        return self.tag == 1
+
+    def ligkern_start(self):
+        return self.remainder
+
+
+class LigKernProgram(object):
+    def __init__(self, program):
+        self.program = program
+
+    def execute(self, start, next_char):
+        curr_instruction = start
+        while True:
+            instruction = self.program[curr_instruction]
+            (skip, inst_next_char, op, remainder) = instruction
+
+            if inst_next_char == next_char:
+                if op < 128:
+                    # Don't worry about ligatures for now, we only need kerns
+                    return None
+                else:
+                    return 256 * (op - 128) + remainder
+            elif skip >= 128:
+                return None
+            else:
+                curr_instruction += 1 + skip
+
+
+class TfmCharMetrics(object):
+    def __init__(self, width, height, depth, italic, kern_table):
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.italic_correction = italic
+        self.kern_table = kern_table
+
+
+class TfmFile(object):
+    def __init__(self, start_char, end_char, char_info, width_table,
+                 height_table, depth_table, italic_table, ligkern_table,
+                 kern_table):
+        self.start_char = start_char
+        self.end_char = end_char
+        self.char_info = char_info
+        self.width_table = width_table
+        self.height_table = height_table
+        self.depth_table = depth_table
+        self.italic_table = italic_table
+        self.ligkern_program = LigKernProgram(ligkern_table)
+        self.kern_table = kern_table
+
+    def get_char_metrics(self, char_num):
+        if char_num < self.start_char or char_num > self.end_char:
+            raise RuntimeError("Invalid character number")
+
+        info = self.char_info[char_num + self.start_char]
+
+        char_kern_table = {}
+        if info.has_ligkern():
+            for char in range(self.start_char, self.end_char + 1):
+                kern = self.ligkern_program.execute(info.ligkern_start(), char)
+                if kern:
+                    char_kern_table[char] = self.kern_table[kern]
+
+        return TfmCharMetrics(
+            self.width_table[info.width_index],
+            self.height_table[info.height_index],
+            self.depth_table[info.depth_index],
+            self.italic_table[info.italic_index],
+            char_kern_table)
+
+
+class TfmReader(object):
+    def __init__(self, f):
+        self.f = f
+
+    def read_byte(self):
+        return ord(self.f.read(1))
+
+    def read_halfword(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        return (b1 << 8) | b2
+
+    def read_word(self):
+        b1 = self.read_byte()
+        b2 = self.read_byte()
+        b3 = self.read_byte()
+        b4 = self.read_byte()
+        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4
+
+    def read_fixword(self):
+        word = self.read_word()
+
+        neg = False
+        if word & 0x80000000:
+            neg = True
+            word = (-word & 0xffffffff)
+
+        return (-1 if neg else 1) * word / float(1 << 20)
+
+    def read_bcpl(self, length):
+        str_length = self.read_byte()
+        data = self.f.read(length - 1)
+        return data[:str_length]
+
+
+def read_tfm_file(file_name):
+    with open(file_name, 'rb') as f:
+        reader = TfmReader(f)
+
+        # file_size
+        reader.read_halfword()
+        header_size = reader.read_halfword()
+
+        start_char = reader.read_halfword()
+        end_char = reader.read_halfword()
+
+        width_table_size = reader.read_halfword()
+        height_table_size = reader.read_halfword()
+        depth_table_size = reader.read_halfword()
+        italic_table_size = reader.read_halfword()
+
+        ligkern_table_size = reader.read_halfword()
+        kern_table_size = reader.read_halfword()
+
+        # extensible_table_size
+        reader.read_halfword()
+        # parameter_table_size
+        reader.read_halfword()
+
+        # checksum
+        reader.read_word()
+        # design_size
+        reader.read_fixword()
+
+        if header_size > 2:
+            # coding_scheme
+            reader.read_bcpl(40)
+
+        if header_size > 12:
+            # font_family
+            reader.read_bcpl(20)
+
+        for i in range(header_size - 17):
+            reader.read_word()
+
+        char_info = []
+        for i in range(start_char, end_char + 1):
+            char_info.append(CharInfoWord(reader.read_word()))
+
+        width_table = []
+        for i in range(width_table_size):
+            width_table.append(reader.read_fixword())
+
+        height_table = []
+        for i in range(height_table_size):
+            height_table.append(reader.read_fixword())
+
+        depth_table = []
+        for i in range(depth_table_size):
+            depth_table.append(reader.read_fixword())
+
+        italic_table = []
+        for i in range(italic_table_size):
+            italic_table.append(reader.read_fixword())
+
+        ligkern_table = []
+        for i in range(ligkern_table_size):
+            skip = reader.read_byte()
+            next_char = reader.read_byte()
+            op = reader.read_byte()
+            remainder = reader.read_byte()
+
+            ligkern_table.append((skip, next_char, op, remainder))
+
+        kern_table = []
+        for i in range(kern_table_size):
+            kern_table.append(reader.read_fixword())
+
+        # There is more information, like the ligkern, kern, extensible, and
+        # param table, but we don't need these for now
+
+        return TfmFile(start_char, end_char, char_info, width_table,
+                       height_table, depth_table, italic_table,
+                       ligkern_table, kern_table)

data/lib/hyhyhy/structure/_includes/katex/metrics/replace_line.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python2
+
+import sys
+
+with open("../src/fontMetrics.js", "r") as metrics:
+    old_lines = file.readlines(metrics)
+
+replace = sys.stdin.read()
+
+with open("../src/fontMetrics.js", "w") as output:
+    for line in old_lines:
+        if line.startswith("var metricMap"):
+            output.write("var metricMap = ")
+            output.write(replace)
+            output.write(";\n")
+        else:
+            output.write(line)

data/lib/hyhyhy/structure/_includes/katex/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "katex",
+  "version": "0.1.1",
+  "description": "Fast math typesetting for the web.",
+  "main": "katex.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Khan/KaTeX.git"
+  },
+  "files": [
+    "katex.js",
+    "cli.js",
+    "src/"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "browserify": "~2.29.1",
+    "clean-css": "~2.2.15",
+    "express": "~3.3.3",
+    "huxley": "~0.8.1",
+    "jasmine-node": "git://github.com/mhevery/jasmine-node.git#Jasmine2.0",
+    "jshint": "^2.5.6",
+    "less": "~1.7.5",
+    "uglify-js": "~2.4.15"
+  },
+  "bin": "cli.js",
+  "scripts": {
+    "test": "make lint test"
+  }
+}

data/lib/hyhyhy/structure/_includes/katex/server.js

@@ -0,0 +1,77 @@
+var fs = require("fs");
+var path = require("path");
+
+var browserify = require("browserify");
+var express = require("express");
+var less = require("less");
+
+var app = express();
+
+app.use(express.logger());
+
+app.get("/katex.js", function(req, res, next) {
+    var b = browserify();
+    b.add("./katex");
+
+    var stream = b.bundle({standalone: "katex"});
+
+    var body = "";
+    stream.on("data", function(s) { body += s; });
+    stream.on("error", function(e) { next(e); });
+    stream.on("end", function() {
+        res.setHeader("Content-Type", "text/javascript");
+        res.send(body);
+    });
+});
+
+app.get("/katex.css", function(req, res, next) {
+    fs.readFile("static/katex.less", {encoding: "utf8"}, function(err, data) {
+        if (err) {
+            next(err);
+            return;
+        }
+
+        var parser = new less.Parser({
+            paths: ["./static"],
+            filename: "katex.less"
+        });
+
+        parser.parse(data, function(err, tree) {
+            if (err) {
+                next(err);
+                return;
+            }
+
+            res.setHeader("Content-Type", "text/css");
+            res.send(tree.toCSS());
+        });
+    });
+});
+
+app.get("/test/katex-spec.js", function(req, res, next) {
+    var b = browserify();
+    b.add("./test/katex-spec");
+
+    var stream = b.bundle({});
+
+    var body = "";
+    stream.on("data", function(s) { body += s; });
+    stream.on("error", function(e) { next(e); });
+    stream.on("end", function() {
+        res.setHeader("Content-Type", "text/javascript");
+        res.send(body);
+    });
+});
+
+app.use(express.static(path.join(__dirname, "static")));
+app.use(express.static(path.join(__dirname, "build")));
+app.use("/test", express.static(path.join(__dirname, "test")));
+
+app.use(function(err, req, res, next) {
+    console.error(err.stack);
+    res.setHeader("Content-Type", "text/plain");
+    res.send(500, err.stack);
+});
+
+app.listen(7936);
+console.log("Serving on http://0.0.0.0:7936/ ...");

data/lib/hyhyhy/structure/_includes/katex/src/Lexer.js

@@ -0,0 +1,190 @@
+/**
+ * The Lexer class handles tokenizing the input in various ways. Since our
+ * parser expects us to be able to backtrack, the lexer allows lexing from any
+ * given starting point.
+ *
+ * Its main exposed function is the `lex` function, which takes a position to
+ * lex from and a type of token to lex. It defers to the appropriate `_innerLex`
+ * function.
+ *
+ * The various `_innerLex` functions perform the actual lexing of different
+ * kinds.
+ */
+
+var ParseError = require("./ParseError");
+
+// The main lexer class
+function Lexer(input) {
+    this._input = input;
+}
+
+// The resulting token returned from `lex`.
+function Token(text, data, position) {
+    this.text = text;
+    this.data = data;
+    this.position = position;
+}
+
+// "normal" types of tokens. These are tokens which can be matched by a simple
+// regex
+var mathNormals = [
+    /^[/|@.""`0-9a-zA-Z]/, // ords
+    /^[*+-]/, // bins
+    /^[=<>:]/, // rels
+    /^[,;]/, // punctuation
+    /^['\^_{}]/, // misc
+    /^[(\[]/, // opens
+    /^[)\]?!]/, // closes
+    /^~/ // spacing
+];
+
+// These are "normal" tokens like above, but should instead be parsed in text
+// mode.
+var textNormals = [
+    /^[a-zA-Z0-9`!@*()-=+\[\]'";:?\/.,]/, // ords
+    /^[{}]/, // grouping
+    /^~/ // spacing
+];
+
+// Regexes for matching whitespace
+var whitespaceRegex = /^\s*/;
+var whitespaceConcatRegex = /^( +|\\  +)/;
+
+// This regex matches any other TeX function, which is a backslash followed by a
+// word or a single symbol
+var anyFunc = /^\\(?:[a-zA-Z]+|.)/;
+
+/**
+ * This function lexes a single normal token. It takes a position, a list of
+ * "normal" tokens to try, and whether it should completely ignore whitespace or
+ * not.
+ */
+Lexer.prototype._innerLex = function(pos, normals, ignoreWhitespace) {
+    var input = this._input.slice(pos);
+    var whitespace;
+
+    if (ignoreWhitespace) {
+        // Get rid of whitespace.
+        whitespace = input.match(whitespaceRegex)[0];
+        pos += whitespace.length;
+        input = input.slice(whitespace.length);
+    } else {
+        // Do the funky concatenation of whitespace that happens in text mode.
+        whitespace = input.match(whitespaceConcatRegex);
+        if (whitespace !== null) {
+            return new Token(" ", null, pos + whitespace[0].length);
+        }
+    }
+
+    // If there's no more input to parse, return an EOF token
+    if (input.length === 0) {
+        return new Token("EOF", null, pos);
+    }
+
+    var match;
+    if ((match = input.match(anyFunc))) {
+        // If we match a function token, return it
+        return new Token(match[0], null, pos + match[0].length);
+    } else {
+        // Otherwise, we look through the normal token regexes and see if it's
+        // one of them.
+        for (var i = 0; i < normals.length; i++) {
+            var normal = normals[i];
+
+            if ((match = input.match(normal))) {
+                // If it is, return it
+                return new Token(
+                    match[0], null, pos + match[0].length);
+            }
+        }
+    }
+
+    throw new ParseError("Unexpected character: '" + input[0] +
+        "'", this, pos);
+};
+
+// A regex to match a CSS color (like #ffffff or BlueViolet)
+var cssColor = /^(#[a-z0-9]+|[a-z]+)/i;
+
+/**
+ * This function lexes a CSS color.
+ */
+Lexer.prototype._innerLexColor = function(pos) {
+    var input = this._input.slice(pos);
+
+    // Ignore whitespace
+    var whitespace = input.match(whitespaceRegex)[0];
+    pos += whitespace.length;
+    input = input.slice(whitespace.length);
+
+    var match;
+    if ((match = input.match(cssColor))) {
+        // If we look like a color, return a color
+        return new Token(match[0], null, pos + match[0].length);
+    } else {
+        throw new ParseError("Invalid color", this, pos);
+    }
+};
+
+// A regex to match a dimension. Dimensions look like
+// "1.2em" or ".4pt" or "1 ex"
+var sizeRegex = /^(-?)\s*(\d+(?:\.\d*)?|\.\d+)\s*([a-z]{2})/;
+
+/**
+ * This function lexes a dimension.
+ */
+Lexer.prototype._innerLexSize = function(pos) {
+    var input = this._input.slice(pos);
+
+    // Ignore whitespace
+    var whitespace = input.match(whitespaceRegex)[0];
+    pos += whitespace.length;
+    input = input.slice(whitespace.length);
+
+    var match;
+    if ((match = input.match(sizeRegex))) {
+        var unit = match[3];
+        // We only currently handle "em" and "ex" units
+        if (unit !== "em" && unit !== "ex") {
+            throw new ParseError("Invalid unit: '" + unit + "'", this, pos);
+        }
+        return new Token(match[0], {
+                number: +(match[1] + match[2]),
+                unit: unit
+            }, pos + match[0].length);
+    }
+
+    throw new ParseError("Invalid size", this, pos);
+};
+
+/**
+ * This function lexes a string of whitespace.
+ */
+Lexer.prototype._innerLexWhitespace = function(pos) {
+    var input = this._input.slice(pos);
+
+    var whitespace = input.match(whitespaceRegex)[0];
+    pos += whitespace.length;
+
+    return new Token(whitespace, null, pos);
+};
+
+/**
+ * This function lexes a single token starting at `pos` and of the given mode.
+ * Based on the mode, we defer to one of the `_innerLex` functions.
+ */
+Lexer.prototype.lex = function(pos, mode) {
+    if (mode === "math") {
+        return this._innerLex(pos, mathNormals, true);
+    } else if (mode === "text") {
+        return this._innerLex(pos, textNormals, false);
+    } else if (mode === "color") {
+        return this._innerLexColor(pos);
+    } else if (mode === "size") {
+        return this._innerLexSize(pos);
+    } else if (mode === "whitespace") {
+        return this._innerLexWhitespace(pos);
+    }
+};
+
+module.exports = Lexer;