three-stdlib
Version:
stand-alone library of threejs examples
1,656 lines • 355 kB
JavaScript
const { parseBuffer } = /* @__PURE__ */ (() => {
var TINF_OK = 0;
var TINF_DATA_ERROR = -3;
function Tree() {
this.table = new Uint16Array(16);
this.trans = new Uint16Array(288);
}
function Data(source, dest) {
this.source = source;
this.sourceIndex = 0;
this.tag = 0;
this.bitcount = 0;
this.dest = dest;
this.destLen = 0;
this.ltree = new Tree();
this.dtree = new Tree();
}
var sltree = new Tree();
var sdtree = new Tree();
var length_bits = new Uint8Array(30);
var length_base = new Uint16Array(30);
var dist_bits = new Uint8Array(30);
var dist_base = new Uint16Array(30);
var clcidx = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
var code_tree = new Tree();
var lengths = new Uint8Array(288 + 32);
function tinf_build_bits_base(bits, base, delta, first) {
var i, sum;
for (i = 0; i < delta; ++i) {
bits[i] = 0;
}
for (i = 0; i < 30 - delta; ++i) {
bits[i + delta] = i / delta | 0;
}
for (sum = first, i = 0; i < 30; ++i) {
base[i] = sum;
sum += 1 << bits[i];
}
}
function tinf_build_fixed_trees(lt, dt) {
var i;
for (i = 0; i < 7; ++i) {
lt.table[i] = 0;
}
lt.table[7] = 24;
lt.table[8] = 152;
lt.table[9] = 112;
for (i = 0; i < 24; ++i) {
lt.trans[i] = 256 + i;
}
for (i = 0; i < 144; ++i) {
lt.trans[24 + i] = i;
}
for (i = 0; i < 8; ++i) {
lt.trans[24 + 144 + i] = 280 + i;
}
for (i = 0; i < 112; ++i) {
lt.trans[24 + 144 + 8 + i] = 144 + i;
}
for (i = 0; i < 5; ++i) {
dt.table[i] = 0;
}
dt.table[5] = 32;
for (i = 0; i < 32; ++i) {
dt.trans[i] = i;
}
}
var offs = new Uint16Array(16);
function tinf_build_tree(t, lengths2, off, num) {
var i, sum;
for (i = 0; i < 16; ++i) {
t.table[i] = 0;
}
for (i = 0; i < num; ++i) {
t.table[lengths2[off + i]]++;
}
t.table[0] = 0;
for (sum = 0, i = 0; i < 16; ++i) {
offs[i] = sum;
sum += t.table[i];
}
for (i = 0; i < num; ++i) {
if (lengths2[off + i]) {
t.trans[offs[lengths2[off + i]]++] = i;
}
}
}
function tinf_getbit(d) {
if (!d.bitcount--) {
d.tag = d.source[d.sourceIndex++];
d.bitcount = 7;
}
var bit = d.tag & 1;
d.tag >>>= 1;
return bit;
}
function tinf_read_bits(d, num, base) {
if (!num) {
return base;
}
while (d.bitcount < 24) {
d.tag |= d.source[d.sourceIndex++] << d.bitcount;
d.bitcount += 8;
}
var val = d.tag & 65535 >>> 16 - num;
d.tag >>>= num;
d.bitcount -= num;
return val + base;
}
function tinf_decode_symbol(d, t) {
while (d.bitcount < 24) {
d.tag |= d.source[d.sourceIndex++] << d.bitcount;
d.bitcount += 8;
}
var sum = 0, cur = 0, len = 0;
var tag = d.tag;
do {
cur = 2 * cur + (tag & 1);
tag >>>= 1;
++len;
sum += t.table[len];
cur -= t.table[len];
} while (cur >= 0);
d.tag = tag;
d.bitcount -= len;
return t.trans[sum + cur];
}
function tinf_decode_trees(d, lt, dt) {
var hlit, hdist, hclen;
var i, num, length;
hlit = tinf_read_bits(d, 5, 257);
hdist = tinf_read_bits(d, 5, 1);
hclen = tinf_read_bits(d, 4, 4);
for (i = 0; i < 19; ++i) {
lengths[i] = 0;
}
for (i = 0; i < hclen; ++i) {
var clen = tinf_read_bits(d, 3, 0);
lengths[clcidx[i]] = clen;
}
tinf_build_tree(code_tree, lengths, 0, 19);
for (num = 0; num < hlit + hdist; ) {
var sym = tinf_decode_symbol(d, code_tree);
switch (sym) {
case 16:
var prev = lengths[num - 1];
for (length = tinf_read_bits(d, 2, 3); length; --length) {
lengths[num++] = prev;
}
break;
case 17:
for (length = tinf_read_bits(d, 3, 3); length; --length) {
lengths[num++] = 0;
}
break;
case 18:
for (length = tinf_read_bits(d, 7, 11); length; --length) {
lengths[num++] = 0;
}
break;
default:
lengths[num++] = sym;
break;
}
}
tinf_build_tree(lt, lengths, 0, hlit);
tinf_build_tree(dt, lengths, hlit, hdist);
}
function tinf_inflate_block_data(d, lt, dt) {
while (1) {
var sym = tinf_decode_symbol(d, lt);
if (sym === 256) {
return TINF_OK;
}
if (sym < 256) {
d.dest[d.destLen++] = sym;
} else {
var length, dist, offs2;
var i;
sym -= 257;
length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
dist = tinf_decode_symbol(d, dt);
offs2 = d.destLen - tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
for (i = offs2; i < offs2 + length; ++i) {
d.dest[d.destLen++] = d.dest[i];
}
}
}
}
function tinf_inflate_uncompressed_block(d) {
var length, invlength;
var i;
while (d.bitcount > 8) {
d.sourceIndex--;
d.bitcount -= 8;
}
length = d.source[d.sourceIndex + 1];
length = 256 * length + d.source[d.sourceIndex];
invlength = d.source[d.sourceIndex + 3];
invlength = 256 * invlength + d.source[d.sourceIndex + 2];
if (length !== (~invlength & 65535)) {
return TINF_DATA_ERROR;
}
d.sourceIndex += 4;
for (i = length; i; --i) {
d.dest[d.destLen++] = d.source[d.sourceIndex++];
}
d.bitcount = 0;
return TINF_OK;
}
function tinf_uncompress(source, dest) {
var d = new Data(source, dest);
var bfinal, btype, res;
do {
bfinal = tinf_getbit(d);
btype = tinf_read_bits(d, 2, 0);
switch (btype) {
case 0:
res = tinf_inflate_uncompressed_block(d);
break;
case 1:
res = tinf_inflate_block_data(d, sltree, sdtree);
break;
case 2:
tinf_decode_trees(d, d.ltree, d.dtree);
res = tinf_inflate_block_data(d, d.ltree, d.dtree);
break;
default:
res = TINF_DATA_ERROR;
}
if (res !== TINF_OK) {
throw new Error("Data error");
}
} while (!bfinal);
if (d.destLen < d.dest.length) {
if (typeof d.dest.slice === "function") {
return d.dest.slice(0, d.destLen);
} else {
return d.dest.subarray(0, d.destLen);
}
}
return d.dest;
}
tinf_build_fixed_trees(sltree, sdtree);
tinf_build_bits_base(length_bits, length_base, 4, 3);
tinf_build_bits_base(dist_bits, dist_base, 2, 1);
length_bits[28] = 0;
length_base[28] = 258;
var tinyInflate = tinf_uncompress;
function derive(v0, v1, v2, v3, t) {
return Math.pow(1 - t, 3) * v0 + 3 * Math.pow(1 - t, 2) * t * v1 + 3 * (1 - t) * Math.pow(t, 2) * v2 + Math.pow(t, 3) * v3;
}
function BoundingBox() {
this.x1 = Number.NaN;
this.y1 = Number.NaN;
this.x2 = Number.NaN;
this.y2 = Number.NaN;
}
BoundingBox.prototype.isEmpty = function() {
return isNaN(this.x1) || isNaN(this.y1) || isNaN(this.x2) || isNaN(this.y2);
};
BoundingBox.prototype.addPoint = function(x, y) {
if (typeof x === "number") {
if (isNaN(this.x1) || isNaN(this.x2)) {
this.x1 = x;
this.x2 = x;
}
if (x < this.x1) {
this.x1 = x;
}
if (x > this.x2) {
this.x2 = x;
}
}
if (typeof y === "number") {
if (isNaN(this.y1) || isNaN(this.y2)) {
this.y1 = y;
this.y2 = y;
}
if (y < this.y1) {
this.y1 = y;
}
if (y > this.y2) {
this.y2 = y;
}
}
};
BoundingBox.prototype.addX = function(x) {
this.addPoint(x, null);
};
BoundingBox.prototype.addY = function(y) {
this.addPoint(null, y);
};
BoundingBox.prototype.addBezier = function(x0, y0, x1, y1, x2, y2, x, y) {
var p0 = [x0, y0];
var p1 = [x1, y1];
var p2 = [x2, y2];
var p3 = [x, y];
this.addPoint(x0, y0);
this.addPoint(x, y);
for (var i = 0; i <= 1; i++) {
var b = 6 * p0[i] - 12 * p1[i] + 6 * p2[i];
var a = -3 * p0[i] + 9 * p1[i] - 9 * p2[i] + 3 * p3[i];
var c = 3 * p1[i] - 3 * p0[i];
if (a === 0) {
if (b === 0) {
continue;
}
var t = -c / b;
if (0 < t && t < 1) {
if (i === 0) {
this.addX(derive(p0[i], p1[i], p2[i], p3[i], t));
}
if (i === 1) {
this.addY(derive(p0[i], p1[i], p2[i], p3[i], t));
}
}
continue;
}
var b2ac = Math.pow(b, 2) - 4 * c * a;
if (b2ac < 0) {
continue;
}
var t1 = (-b + Math.sqrt(b2ac)) / (2 * a);
if (0 < t1 && t1 < 1) {
if (i === 0) {
this.addX(derive(p0[i], p1[i], p2[i], p3[i], t1));
}
if (i === 1) {
this.addY(derive(p0[i], p1[i], p2[i], p3[i], t1));
}
}
var t2 = (-b - Math.sqrt(b2ac)) / (2 * a);
if (0 < t2 && t2 < 1) {
if (i === 0) {
this.addX(derive(p0[i], p1[i], p2[i], p3[i], t2));
}
if (i === 1) {
this.addY(derive(p0[i], p1[i], p2[i], p3[i], t2));
}
}
}
};
BoundingBox.prototype.addQuad = function(x0, y0, x1, y1, x, y) {
var cp1x = x0 + 2 / 3 * (x1 - x0);
var cp1y = y0 + 2 / 3 * (y1 - y0);
var cp2x = cp1x + 1 / 3 * (x - x0);
var cp2y = cp1y + 1 / 3 * (y - y0);
this.addBezier(x0, y0, cp1x, cp1y, cp2x, cp2y, x, y);
};
function Path() {
this.commands = [];
this.fill = "black";
this.stroke = null;
this.strokeWidth = 1;
}
Path.prototype.moveTo = function(x, y) {
this.commands.push({
type: "M",
x,
y
});
};
Path.prototype.lineTo = function(x, y) {
this.commands.push({
type: "L",
x,
y
});
};
Path.prototype.curveTo = Path.prototype.bezierCurveTo = function(x1, y1, x2, y2, x, y) {
this.commands.push({
type: "C",
x1,
y1,
x2,
y2,
x,
y
});
};
Path.prototype.quadTo = Path.prototype.quadraticCurveTo = function(x1, y1, x, y) {
this.commands.push({
type: "Q",
x1,
y1,
x,
y
});
};
Path.prototype.close = Path.prototype.closePath = function() {
this.commands.push({
type: "Z"
});
};
Path.prototype.extend = function(pathOrCommands) {
if (pathOrCommands.commands) {
pathOrCommands = pathOrCommands.commands;
} else if (pathOrCommands instanceof BoundingBox) {
var box = pathOrCommands;
this.moveTo(box.x1, box.y1);
this.lineTo(box.x2, box.y1);
this.lineTo(box.x2, box.y2);
this.lineTo(box.x1, box.y2);
this.close();
return;
}
Array.prototype.push.apply(this.commands, pathOrCommands);
};
Path.prototype.getBoundingBox = function() {
var box = new BoundingBox();
var startX = 0;
var startY = 0;
var prevX = 0;
var prevY = 0;
for (var i = 0; i < this.commands.length; i++) {
var cmd = this.commands[i];
switch (cmd.type) {
case "M":
box.addPoint(cmd.x, cmd.y);
startX = prevX = cmd.x;
startY = prevY = cmd.y;
break;
case "L":
box.addPoint(cmd.x, cmd.y);
prevX = cmd.x;
prevY = cmd.y;
break;
case "Q":
box.addQuad(prevX, prevY, cmd.x1, cmd.y1, cmd.x, cmd.y);
prevX = cmd.x;
prevY = cmd.y;
break;
case "C":
box.addBezier(prevX, prevY, cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y);
prevX = cmd.x;
prevY = cmd.y;
break;
case "Z":
prevX = startX;
prevY = startY;
break;
default:
throw new Error("Unexpected path command " + cmd.type);
}
}
if (box.isEmpty()) {
box.addPoint(0, 0);
}
return box;
};
Path.prototype.draw = function(ctx) {
ctx.beginPath();
for (var i = 0; i < this.commands.length; i += 1) {
var cmd = this.commands[i];
if (cmd.type === "M") {
ctx.moveTo(cmd.x, cmd.y);
} else if (cmd.type === "L") {
ctx.lineTo(cmd.x, cmd.y);
} else if (cmd.type === "C") {
ctx.bezierCurveTo(cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y);
} else if (cmd.type === "Q") {
ctx.quadraticCurveTo(cmd.x1, cmd.y1, cmd.x, cmd.y);
} else if (cmd.type === "Z") {
ctx.closePath();
}
}
if (this.fill) {
ctx.fillStyle = this.fill;
ctx.fill();
}
if (this.stroke) {
ctx.strokeStyle = this.stroke;
ctx.lineWidth = this.strokeWidth;
ctx.stroke();
}
};
Path.prototype.toPathData = function(decimalPlaces) {
decimalPlaces = decimalPlaces !== void 0 ? decimalPlaces : 2;
function floatToString(v) {
if (Math.round(v) === v) {
return "" + Math.round(v);
} else {
return v.toFixed(decimalPlaces);
}
}
function packValues() {
var arguments$1 = arguments;
var s = "";
for (var i2 = 0; i2 < arguments.length; i2 += 1) {
var v = arguments$1[i2];
if (v >= 0 && i2 > 0) {
s += " ";
}
s += floatToString(v);
}
return s;
}
var d = "";
for (var i = 0; i < this.commands.length; i += 1) {
var cmd = this.commands[i];
if (cmd.type === "M") {
d += "M" + packValues(cmd.x, cmd.y);
} else if (cmd.type === "L") {
d += "L" + packValues(cmd.x, cmd.y);
} else if (cmd.type === "C") {
d += "C" + packValues(cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y);
} else if (cmd.type === "Q") {
d += "Q" + packValues(cmd.x1, cmd.y1, cmd.x, cmd.y);
} else if (cmd.type === "Z") {
d += "Z";
}
}
return d;
};
Path.prototype.toSVG = function(decimalPlaces) {
var svg = '<path d="';
svg += this.toPathData(decimalPlaces);
svg += '"';
if (this.fill && this.fill !== "black") {
if (this.fill === null) {
svg += ' fill="none"';
} else {
svg += ' fill="' + this.fill + '"';
}
}
if (this.stroke) {
svg += ' stroke="' + this.stroke + '" stroke-width="' + this.strokeWidth + '"';
}
svg += "/>";
return svg;
};
Path.prototype.toDOMElement = function(decimalPlaces) {
var temporaryPath = this.toPathData(decimalPlaces);
var newPath = document.createElementNS("http://www.w3.org/2000/svg", "path");
newPath.setAttribute("d", temporaryPath);
return newPath;
};
function fail(message) {
throw new Error(message);
}
function argument(predicate, message) {
if (!predicate) {
fail(message);
}
}
var check = { fail, argument, assert: argument };
var LIMIT16 = 32768;
var LIMIT32 = 2147483648;
var decode = {};
var encode = {};
var sizeOf = {};
function constant(v) {
return function() {
return v;
};
}
encode.BYTE = function(v) {
check.argument(v >= 0 && v <= 255, "Byte value should be between 0 and 255.");
return [v];
};
sizeOf.BYTE = constant(1);
encode.CHAR = function(v) {
return [v.charCodeAt(0)];
};
sizeOf.CHAR = constant(1);
encode.CHARARRAY = function(v) {
if (typeof v === "undefined") {
v = "";
console.warn(
"Undefined CHARARRAY encountered and treated as an empty string. This is probably caused by a missing glyph name."
);
}
var b = [];
for (var i = 0; i < v.length; i += 1) {
b[i] = v.charCodeAt(i);
}
return b;
};
sizeOf.CHARARRAY = function(v) {
if (typeof v === "undefined") {
return 0;
}
return v.length;
};
encode.USHORT = function(v) {
return [v >> 8 & 255, v & 255];
};
sizeOf.USHORT = constant(2);
encode.SHORT = function(v) {
if (v >= LIMIT16) {
v = -(2 * LIMIT16 - v);
}
return [v >> 8 & 255, v & 255];
};
sizeOf.SHORT = constant(2);
encode.UINT24 = function(v) {
return [v >> 16 & 255, v >> 8 & 255, v & 255];
};
sizeOf.UINT24 = constant(3);
encode.ULONG = function(v) {
return [v >> 24 & 255, v >> 16 & 255, v >> 8 & 255, v & 255];
};
sizeOf.ULONG = constant(4);
encode.LONG = function(v) {
if (v >= LIMIT32) {
v = -(2 * LIMIT32 - v);
}
return [v >> 24 & 255, v >> 16 & 255, v >> 8 & 255, v & 255];
};
sizeOf.LONG = constant(4);
encode.FIXED = encode.ULONG;
sizeOf.FIXED = sizeOf.ULONG;
encode.FWORD = encode.SHORT;
sizeOf.FWORD = sizeOf.SHORT;
encode.UFWORD = encode.USHORT;
sizeOf.UFWORD = sizeOf.USHORT;
encode.LONGDATETIME = function(v) {
return [0, 0, 0, 0, v >> 24 & 255, v >> 16 & 255, v >> 8 & 255, v & 255];
};
sizeOf.LONGDATETIME = constant(8);
encode.TAG = function(v) {
check.argument(v.length === 4, "Tag should be exactly 4 ASCII characters.");
return [v.charCodeAt(0), v.charCodeAt(1), v.charCodeAt(2), v.charCodeAt(3)];
};
sizeOf.TAG = constant(4);
encode.Card8 = encode.BYTE;
sizeOf.Card8 = sizeOf.BYTE;
encode.Card16 = encode.USHORT;
sizeOf.Card16 = sizeOf.USHORT;
encode.OffSize = encode.BYTE;
sizeOf.OffSize = sizeOf.BYTE;
encode.SID = encode.USHORT;
sizeOf.SID = sizeOf.USHORT;
encode.NUMBER = function(v) {
if (v >= -107 && v <= 107) {
return [v + 139];
} else if (v >= 108 && v <= 1131) {
v = v - 108;
return [(v >> 8) + 247, v & 255];
} else if (v >= -1131 && v <= -108) {
v = -v - 108;
return [(v >> 8) + 251, v & 255];
} else if (v >= -32768 && v <= 32767) {
return encode.NUMBER16(v);
} else {
return encode.NUMBER32(v);
}
};
sizeOf.NUMBER = function(v) {
return encode.NUMBER(v).length;
};
encode.NUMBER16 = function(v) {
return [28, v >> 8 & 255, v & 255];
};
sizeOf.NUMBER16 = constant(3);
encode.NUMBER32 = function(v) {
return [29, v >> 24 & 255, v >> 16 & 255, v >> 8 & 255, v & 255];
};
sizeOf.NUMBER32 = constant(5);
encode.REAL = function(v) {
var value = v.toString();
var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(value);
if (m) {
var epsilon = parseFloat("1e" + ((m[2] ? +m[2] : 0) + m[1].length));
value = (Math.round(v * epsilon) / epsilon).toString();
}
var nibbles = "";
for (var i = 0, ii = value.length; i < ii; i += 1) {
var c = value[i];
if (c === "e") {
nibbles += value[++i] === "-" ? "c" : "b";
} else if (c === ".") {
nibbles += "a";
} else if (c === "-") {
nibbles += "e";
} else {
nibbles += c;
}
}
nibbles += nibbles.length & 1 ? "f" : "ff";
var out = [30];
for (var i$1 = 0, ii$1 = nibbles.length; i$1 < ii$1; i$1 += 2) {
out.push(parseInt(nibbles.substr(i$1, 2), 16));
}
return out;
};
sizeOf.REAL = function(v) {
return encode.REAL(v).length;
};
encode.NAME = encode.CHARARRAY;
sizeOf.NAME = sizeOf.CHARARRAY;
encode.STRING = encode.CHARARRAY;
sizeOf.STRING = sizeOf.CHARARRAY;
decode.UTF8 = function(data, offset, numBytes) {
var codePoints = [];
var numChars = numBytes;
for (var j = 0; j < numChars; j++, offset += 1) {
codePoints[j] = data.getUint8(offset);
}
return String.fromCharCode.apply(null, codePoints);
};
decode.UTF16 = function(data, offset, numBytes) {
var codePoints = [];
var numChars = numBytes / 2;
for (var j = 0; j < numChars; j++, offset += 2) {
codePoints[j] = data.getUint16(offset);
}
return String.fromCharCode.apply(null, codePoints);
};
encode.UTF16 = function(v) {
var b = [];
for (var i = 0; i < v.length; i += 1) {
var codepoint = v.charCodeAt(i);
b[b.length] = codepoint >> 8 & 255;
b[b.length] = codepoint & 255;
}
return b;
};
sizeOf.UTF16 = function(v) {
return v.length * 2;
};
var eightBitMacEncodings = {
// Python: 'mac_croatian'
"x-mac-croatian": "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®Š™´¨≠ŽØ∞±≤≥∆µ∂∑∏š∫ªºΩžø¿¡¬√ƒ≈Ć«Č… ÀÃÕŒœĐ—“”‘’÷◊©⁄€‹›Æ»–·‚„‰ÂćÁčÈÍÎÏÌÓÔđÒÚÛÙıˆ˜¯πË˚¸Êæˇ",
// Python: 'mac_cyrillic'
"x-mac-cyrillic": "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ†°Ґ£§•¶І®©™Ђђ≠Ѓѓ∞±≤≥іµґЈЄєЇїЉљЊњјЅ¬√ƒ≈∆«»… ЋћЌќѕ–—“”‘’÷„ЎўЏџ№Ёёяабвгдежзийклмнопрстуфхцчшщъыьэю",
// http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/GAELIC.TXT
"x-mac-gaelic": "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØḂ±≤≥ḃĊċḊḋḞḟĠġṀæøṁṖṗɼƒſṠ«»… ÀÃÕŒœ–—“”‘’ṡẛÿŸṪ€‹›Ŷŷṫ·Ỳỳ⁊ÂÊÁËÈÍÎÏÌÓÔ♣ÒÚÛÙıÝýŴŵẄẅẀẁẂẃ",
// Python: 'mac_greek'
"x-mac-greek": "Ĺ²É³ÖÜ΅àâä΄¨çéèê룙î‰ôö¦€ùûü†ΓΔΘΛΞΠß®©ΣΪ§≠°·Α±≤≥¥ΒΕΖΗΙΚΜΦΫΨΩάΝ¬ΟΡ≈Τ«»… ΥΧΆΈœ–―“”‘’÷ΉΊΌΎέήίόΏύαβψδεφγηιξκλμνοπώρστθωςχυζϊϋΐΰ",
// Python: 'mac_iceland'
"x-mac-icelandic": "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûüÝ°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€ÐðÞþý·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ",
// http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/INUIT.TXT
"x-mac-inuit": "ᐃᐄᐅᐆᐊᐋᐱᐲᐳᐴᐸᐹᑉᑎᑏᑐᑑᑕᑖᑦᑭᑮᑯᑰᑲᑳᒃᒋᒌᒍᒎᒐᒑ°ᒡᒥᒦ•¶ᒧ®©™ᒨᒪᒫᒻᓂᓃᓄᓅᓇᓈᓐᓯᓰᓱᓲᓴᓵᔅᓕᓖᓗᓘᓚᓛᓪᔨᔩᔪᔫᔭ… ᔮᔾᕕᕖᕗ–—“”‘’ᕘᕙᕚᕝᕆᕇᕈᕉᕋᕌᕐᕿᖀᖁᖂᖃᖄᖅᖏᖐᖑᖒᖓᖔᖕᙱᙲᙳᙴᙵᙶᖖᖠᖡᖢᖣᖤᖥᖦᕼŁł",
// Python: 'mac_latin2'
"x-mac-ce": "ÄĀāÉĄÖÜáąČäčĆć鏟ĎíďĒēĖóėôöõúĚěü†°Ę£§•¶ß®©™ę¨≠ģĮįĪ≤≥īĶ∂∑łĻļĽľĹĺŅņѬ√ńŇ∆«»… ňŐÕőŌ–—“”‘’÷◊ōŔŕŘ‹›řŖŗŠ‚„šŚśÁŤťÍŽžŪÓÔūŮÚůŰűŲųÝýķŻŁżĢˇ",
// Python: 'mac_roman'
macintosh: "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€‹›fifl‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ",
// Python: 'mac_romanian'
"x-mac-romanian": "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ĂȘ∞±≤≥¥µ∂∑∏π∫ªºΩăș¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€‹›Țț‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ",
// Python: 'mac_turkish'
"x-mac-turkish": "ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸĞğİıŞş‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙˆ˜¯˘˙˚¸˝˛ˇ"
};
decode.MACSTRING = function(dataView, offset, dataLength, encoding) {
var table2 = eightBitMacEncodings[encoding];
if (table2 === void 0) {
return void 0;
}
var result = "";
for (var i = 0; i < dataLength; i++) {
var c = dataView.getUint8(offset + i);
if (c <= 127) {
result += String.fromCharCode(c);
} else {
result += table2[c & 127];
}
}
return result;
};
var macEncodingTableCache = typeof WeakMap === "function" && /* @__PURE__ */ new WeakMap();
var macEncodingCacheKeys;
var getMacEncodingTable = function(encoding) {
if (!macEncodingCacheKeys) {
macEncodingCacheKeys = {};
for (var e in eightBitMacEncodings) {
macEncodingCacheKeys[e] = new String(e);
}
}
var cacheKey = macEncodingCacheKeys[encoding];
if (cacheKey === void 0) {
return void 0;
}
if (macEncodingTableCache) {
var cachedTable = macEncodingTableCache.get(cacheKey);
if (cachedTable !== void 0) {
return cachedTable;
}
}
var decodingTable = eightBitMacEncodings[encoding];
if (decodingTable === void 0) {
return void 0;
}
var encodingTable = {};
for (var i = 0; i < decodingTable.length; i++) {
encodingTable[decodingTable.charCodeAt(i)] = i + 128;
}
if (macEncodingTableCache) {
macEncodingTableCache.set(cacheKey, encodingTable);
}
return encodingTable;
};
encode.MACSTRING = function(str, encoding) {
var table2 = getMacEncodingTable(encoding);
if (table2 === void 0) {
return void 0;
}
var result = [];
for (var i = 0; i < str.length; i++) {
var c = str.charCodeAt(i);
if (c >= 128) {
c = table2[c];
if (c === void 0) {
return void 0;
}
}
result[i] = c;
}
return result;
};
sizeOf.MACSTRING = function(str, encoding) {
var b = encode.MACSTRING(str, encoding);
if (b !== void 0) {
return b.length;
} else {
return 0;
}
};
function isByteEncodable(value) {
return value >= -128 && value <= 127;
}
function encodeVarDeltaRunAsZeroes(deltas, pos, result) {
var runLength = 0;
var numDeltas = deltas.length;
while (pos < numDeltas && runLength < 64 && deltas[pos] === 0) {
++pos;
++runLength;
}
result.push(128 | runLength - 1);
return pos;
}
function encodeVarDeltaRunAsBytes(deltas, offset, result) {
var runLength = 0;
var numDeltas = deltas.length;
var pos = offset;
while (pos < numDeltas && runLength < 64) {
var value = deltas[pos];
if (!isByteEncodable(value)) {
break;
}
if (value === 0 && pos + 1 < numDeltas && deltas[pos + 1] === 0) {
break;
}
++pos;
++runLength;
}
result.push(runLength - 1);
for (var i = offset; i < pos; ++i) {
result.push(deltas[i] + 256 & 255);
}
return pos;
}
function encodeVarDeltaRunAsWords(deltas, offset, result) {
var runLength = 0;
var numDeltas = deltas.length;
var pos = offset;
while (pos < numDeltas && runLength < 64) {
var value = deltas[pos];
if (value === 0) {
break;
}
if (isByteEncodable(value) && pos + 1 < numDeltas && isByteEncodable(deltas[pos + 1])) {
break;
}
++pos;
++runLength;
}
result.push(64 | runLength - 1);
for (var i = offset; i < pos; ++i) {
var val = deltas[i];
result.push(val + 65536 >> 8 & 255, val + 256 & 255);
}
return pos;
}
encode.VARDELTAS = function(deltas) {
var pos = 0;
var result = [];
while (pos < deltas.length) {
var value = deltas[pos];
if (value === 0) {
pos = encodeVarDeltaRunAsZeroes(deltas, pos, result);
} else if (value >= -128 && value <= 127) {
pos = encodeVarDeltaRunAsBytes(deltas, pos, result);
} else {
pos = encodeVarDeltaRunAsWords(deltas, pos, result);
}
}
return result;
};
encode.INDEX = function(l) {
var offset = 1;
var offsets = [offset];
var data = [];
for (var i = 0; i < l.length; i += 1) {
var v = encode.OBJECT(l[i]);
Array.prototype.push.apply(data, v);
offset += v.length;
offsets.push(offset);
}
if (data.length === 0) {
return [0, 0];
}
var encodedOffsets = [];
var offSize = 1 + Math.floor(Math.log(offset) / Math.log(2)) / 8 | 0;
var offsetEncoder = [void 0, encode.BYTE, encode.USHORT, encode.UINT24, encode.ULONG][offSize];
for (var i$1 = 0; i$1 < offsets.length; i$1 += 1) {
var encodedOffset = offsetEncoder(offsets[i$1]);
Array.prototype.push.apply(encodedOffsets, encodedOffset);
}
return Array.prototype.concat(encode.Card16(l.length), encode.OffSize(offSize), encodedOffsets, data);
};
sizeOf.INDEX = function(v) {
return encode.INDEX(v).length;
};
encode.DICT = function(m) {
var d = [];
var keys = Object.keys(m);
var length = keys.length;
for (var i = 0; i < length; i += 1) {
var k = parseInt(keys[i], 0);
var v = m[k];
d = d.concat(encode.OPERAND(v.value, v.type));
d = d.concat(encode.OPERATOR(k));
}
return d;
};
sizeOf.DICT = function(m) {
return encode.DICT(m).length;
};
encode.OPERATOR = function(v) {
if (v < 1200) {
return [v];
} else {
return [12, v - 1200];
}
};
encode.OPERAND = function(v, type) {
var d = [];
if (Array.isArray(type)) {
for (var i = 0; i < type.length; i += 1) {
check.argument(v.length === type.length, "Not enough arguments given for type" + type);
d = d.concat(encode.OPERAND(v[i], type[i]));
}
} else {
if (type === "SID") {
d = d.concat(encode.NUMBER(v));
} else if (type === "offset") {
d = d.concat(encode.NUMBER32(v));
} else if (type === "number") {
d = d.concat(encode.NUMBER(v));
} else if (type === "real") {
d = d.concat(encode.REAL(v));
} else {
throw new Error("Unknown operand type " + type);
}
}
return d;
};
encode.OP = encode.BYTE;
sizeOf.OP = sizeOf.BYTE;
var wmm = typeof WeakMap === "function" && /* @__PURE__ */ new WeakMap();
encode.CHARSTRING = function(ops) {
if (wmm) {
var cachedValue = wmm.get(ops);
if (cachedValue !== void 0) {
return cachedValue;
}
}
var d = [];
var length = ops.length;
for (var i = 0; i < length; i += 1) {
var op = ops[i];
d = d.concat(encode[op.type](op.value));
}
if (wmm) {
wmm.set(ops, d);
}
return d;
};
sizeOf.CHARSTRING = function(ops) {
return encode.CHARSTRING(ops).length;
};
encode.OBJECT = function(v) {
var encodingFunction = encode[v.type];
check.argument(encodingFunction !== void 0, "No encoding function for type " + v.type);
return encodingFunction(v.value);
};
sizeOf.OBJECT = function(v) {
var sizeOfFunction = sizeOf[v.type];
check.argument(sizeOfFunction !== void 0, "No sizeOf function for type " + v.type);
return sizeOfFunction(v.value);
};
encode.TABLE = function(table2) {
var d = [];
var length = table2.fields.length;
var subtables = [];
var subtableOffsets = [];
for (var i = 0; i < length; i += 1) {
var field = table2.fields[i];
var encodingFunction = encode[field.type];
check.argument(
encodingFunction !== void 0,
"No encoding function for field type " + field.type + " (" + field.name + ")"
);
var value = table2[field.name];
if (value === void 0) {
value = field.value;
}
var bytes = encodingFunction(value);
if (field.type === "TABLE") {
subtableOffsets.push(d.length);
d = d.concat([0, 0]);
subtables.push(bytes);
} else {
d = d.concat(bytes);
}
}
for (var i$1 = 0; i$1 < subtables.length; i$1 += 1) {
var o = subtableOffsets[i$1];
var offset = d.length;
check.argument(offset < 65536, "Table " + table2.tableName + " too big.");
d[o] = offset >> 8;
d[o + 1] = offset & 255;
d = d.concat(subtables[i$1]);
}
return d;
};
sizeOf.TABLE = function(table2) {
var numBytes = 0;
var length = table2.fields.length;
for (var i = 0; i < length; i += 1) {
var field = table2.fields[i];
var sizeOfFunction = sizeOf[field.type];
check.argument(
sizeOfFunction !== void 0,
"No sizeOf function for field type " + field.type + " (" + field.name + ")"
);
var value = table2[field.name];
if (value === void 0) {
value = field.value;
}
numBytes += sizeOfFunction(value);
if (field.type === "TABLE") {
numBytes += 2;
}
}
return numBytes;
};
encode.RECORD = encode.TABLE;
sizeOf.RECORD = sizeOf.TABLE;
encode.LITERAL = function(v) {
return v;
};
sizeOf.LITERAL = function(v) {
return v.length;
};
function Table(tableName, fields, options) {
if (fields.length && (fields[0].name !== "coverageFormat" || fields[0].value === 1)) {
for (var i = 0; i < fields.length; i += 1) {
var field = fields[i];
this[field.name] = field.value;
}
}
this.tableName = tableName;
this.fields = fields;
if (options) {
var optionKeys = Object.keys(options);
for (var i$1 = 0; i$1 < optionKeys.length; i$1 += 1) {
var k = optionKeys[i$1];
var v = options[k];
if (this[k] !== void 0) {
this[k] = v;
}
}
}
}
Table.prototype.encode = function() {
return encode.TABLE(this);
};
Table.prototype.sizeOf = function() {
return sizeOf.TABLE(this);
};
function ushortList(itemName, list, count) {
if (count === void 0) {
count = list.length;
}
var fields = new Array(list.length + 1);
fields[0] = { name: itemName + "Count", type: "USHORT", value: count };
for (var i = 0; i < list.length; i++) {
fields[i + 1] = { name: itemName + i, type: "USHORT", value: list[i] };
}
return fields;
}
function tableList(itemName, records, itemCallback) {
var count = records.length;
var fields = new Array(count + 1);
fields[0] = { name: itemName + "Count", type: "USHORT", value: count };
for (var i = 0; i < count; i++) {
fields[i + 1] = { name: itemName + i, type: "TABLE", value: itemCallback(records[i], i) };
}
return fields;
}
function recordList(itemName, records, itemCallback) {
var count = records.length;
var fields = [];
fields[0] = { name: itemName + "Count", type: "USHORT", value: count };
for (var i = 0; i < count; i++) {
fields = fields.concat(itemCallback(records[i], i));
}
return fields;
}
function Coverage(coverageTable) {
if (coverageTable.format === 1) {
Table.call(
this,
"coverageTable",
[{ name: "coverageFormat", type: "USHORT", value: 1 }].concat(ushortList("glyph", coverageTable.glyphs))
);
} else if (coverageTable.format === 2) {
Table.call(
this,
"coverageTable",
[{ name: "coverageFormat", type: "USHORT", value: 2 }].concat(
recordList("rangeRecord", coverageTable.ranges, function(RangeRecord) {
return [
{ name: "startGlyphID", type: "USHORT", value: RangeRecord.start },
{ name: "endGlyphID", type: "USHORT", value: RangeRecord.end },
{ name: "startCoverageIndex", type: "USHORT", value: RangeRecord.index }
];
})
)
);
} else {
check.assert(false, "Coverage format must be 1 or 2.");
}
}
Coverage.prototype = Object.create(Table.prototype);
Coverage.prototype.constructor = Coverage;
function ScriptList(scriptListTable) {
Table.call(
this,
"scriptListTable",
recordList("scriptRecord", scriptListTable, function(scriptRecord, i) {
var script = scriptRecord.script;
var defaultLangSys = script.defaultLangSys;
check.assert(
!!defaultLangSys,
"Unable to write GSUB: script " + scriptRecord.tag + " has no default language system."
);
return [
{ name: "scriptTag" + i, type: "TAG", value: scriptRecord.tag },
{
name: "script" + i,
type: "TABLE",
value: new Table(
"scriptTable",
[
{
name: "defaultLangSys",
type: "TABLE",
value: new Table(
"defaultLangSys",
[
{ name: "lookupOrder", type: "USHORT", value: 0 },
{ name: "reqFeatureIndex", type: "USHORT", value: defaultLangSys.reqFeatureIndex }
].concat(ushortList("featureIndex", defaultLangSys.featureIndexes))
)
}
].concat(
recordList("langSys", script.langSysRecords, function(langSysRecord, i2) {
var langSys = langSysRecord.langSys;
return [
{ name: "langSysTag" + i2, type: "TAG", value: langSysRecord.tag },
{
name: "langSys" + i2,
type: "TABLE",
value: new Table(
"langSys",
[
{ name: "lookupOrder", type: "USHORT", value: 0 },
{ name: "reqFeatureIndex", type: "USHORT", value: langSys.reqFeatureIndex }
].concat(ushortList("featureIndex", langSys.featureIndexes))
)
}
];
})
)
)
}
];
})
);
}
ScriptList.prototype = Object.create(Table.prototype);
ScriptList.prototype.constructor = ScriptList;
function FeatureList(featureListTable) {
Table.call(
this,
"featureListTable",
recordList("featureRecord", featureListTable, function(featureRecord, i) {
var feature = featureRecord.feature;
return [
{ name: "featureTag" + i, type: "TAG", value: featureRecord.tag },
{
name: "feature" + i,
type: "TABLE",
value: new Table(
"featureTable",
[{ name: "featureParams", type: "USHORT", value: feature.featureParams }].concat(
ushortList("lookupListIndex", feature.lookupListIndexes)
)
)
}
];
})
);
}
FeatureList.prototype = Object.create(Table.prototype);
FeatureList.prototype.constructor = FeatureList;
function LookupList(lookupListTable, subtableMakers2) {
Table.call(
this,
"lookupListTable",
tableList("lookup", lookupListTable, function(lookupTable) {
var subtableCallback = subtableMakers2[lookupTable.lookupType];
check.assert(!!subtableCallback, "Unable to write GSUB lookup type " + lookupTable.lookupType + " tables.");
return new Table(
"lookupTable",
[
{ name: "lookupType", type: "USHORT", value: lookupTable.lookupType },
{ name: "lookupFlag", type: "USHORT", value: lookupTable.lookupFlag }
].concat(tableList("subtable", lookupTable.subtables, subtableCallback))
);
})
);
}
LookupList.prototype = Object.create(Table.prototype);
LookupList.prototype.constructor = LookupList;
var table = {
Table,
Record: Table,
Coverage,
ScriptList,
FeatureList,
LookupList,
ushortList,
tableList,
recordList
};
function getByte(dataView, offset) {
return dataView.getUint8(offset);
}
function getUShort(dataView, offset) {
return dataView.getUint16(offset, false);
}
function getShort(dataView, offset) {
return dataView.getInt16(offset, false);
}
function getULong(dataView, offset) {
return dataView.getUint32(offset, false);
}
function getFixed(dataView, offset) {
var decimal = dataView.getInt16(offset, false);
var fraction = dataView.getUint16(offset + 2, false);
return decimal + fraction / 65535;
}
function getTag(dataView, offset) {
var tag = "";
for (var i = offset; i < offset + 4; i += 1) {
tag += String.fromCharCode(dataView.getInt8(i));
}
return tag;
}
function getOffset(dataView, offset, offSize) {
var v = 0;
for (var i = 0; i < offSize; i += 1) {
v <<= 8;
v += dataView.getUint8(offset + i);
}
return v;
}
function getBytes(dataView, startOffset, endOffset) {
var bytes = [];
for (var i = startOffset; i < endOffset; i += 1) {
bytes.push(dataView.getUint8(i));
}
return bytes;
}
function bytesToString(bytes) {
var s = "";
for (var i = 0; i < bytes.length; i += 1) {
s += String.fromCharCode(bytes[i]);
}
return s;
}
var typeOffsets = {
byte: 1,
uShort: 2,
short: 2,
uLong: 4,
fixed: 4,
longDateTime: 8,
tag: 4
};
function Parser(data, offset) {
this.data = data;
this.offset = offset;
this.relativeOffset = 0;
}
Parser.prototype.parseByte = function() {
var v = this.data.getUint8(this.offset + this.relativeOffset);
this.relativeOffset += 1;
return v;
};
Parser.prototype.parseChar = function() {
var v = this.data.getInt8(this.offset + this.relativeOffset);
this.relativeOffset += 1;
return v;
};
Parser.prototype.parseCard8 = Parser.prototype.parseByte;
Parser.prototype.parseUShort = function() {
var v = this.data.getUint16(this.offset + this.relativeOffset);
this.relativeOffset += 2;
return v;
};
Parser.prototype.parseCard16 = Parser.prototype.parseUShort;
Parser.prototype.parseSID = Parser.prototype.parseUShort;
Parser.prototype.parseOffset16 = Parser.prototype.parseUShort;
Parser.prototype.parseShort = function() {
var v = this.data.getInt16(this.offset + this.relativeOffset);
this.relativeOffset += 2;
return v;
};
Parser.prototype.parseF2Dot14 = function() {
var v = this.data.getInt16(this.offset + this.relativeOffset) / 16384;
this.relativeOffset += 2;
return v;
};
Parser.prototype.parseULong = function() {
var v = getULong(this.data, this.offset + this.relativeOffset);
this.relativeOffset += 4;
return v;
};
Parser.prototype.parseOffset32 = Parser.prototype.parseULong;
Parser.prototype.parseFixed = function() {
var v = getFixed(this.data, this.offset + this.relativeOffset);
this.relativeOffset += 4;
return v;
};
Parser.prototype.parseString = function(length) {
var dataView = this.data;
var offset = this.offset + this.relativeOffset;
var string = "";
this.relativeOffset += length;
for (var i = 0; i < length; i++) {
string += String.fromCharCode(dataView.getUint8(offset + i));
}
return string;
};
Parser.prototype.parseTag = function() {
return this.parseString(4);
};
Parser.prototype.parseLongDateTime = function() {
var v = getULong(this.data, this.offset + this.relativeOffset + 4);
v -= 2082844800;
this.relativeOffset += 8;
return v;
};
Parser.prototype.parseVersion = function(minorBase) {
var major = getUShort(this.data, this.offset + this.relativeOffset);
var minor = getUShort(this.data, this.offset + this.relativeOffset + 2);
this.relativeOffset += 4;
if (minorBase === void 0) {
minorBase = 4096;
}
return major + minor / minorBase / 10;
};
Parser.prototype.skip = function(type, amount) {
if (amount === void 0) {
amount = 1;
}
this.relativeOffset += typeOffsets[type] * amount;
};
Parser.prototype.parseULongList = function(count) {
if (count === void 0) {
count = this.parseULong();
}
var offsets = new Array(count);
var dataView = this.data;
var offset = this.offset + this.relativeOffset;
for (var i = 0; i < count; i++) {
offsets[i] = dataView.getUint32(offset);
offset += 4;
}
this.relativeOffset += count * 4;
return offsets;
};
Parser.prototype.parseOffset16List = Parser.prototype.parseUShortList = function(count) {
if (count === void 0) {
count = this.parseUShort();
}
var offsets = new Array(count);
var dataView = this.data;
var offset = this.offset + this.relativeOffset;
for (var i = 0; i < count; i++) {
offsets[i] = dataView.getUint16(offset);
offset += 2;
}
this.relativeOffset += count * 2;
return offsets;
};
Parser.prototype.parseShortList = function(count) {
var list = new Array(count);
var dataView = this.data;
var offset = this.offset + this.relativeOffset;
for (var i = 0; i < count; i++) {
list[i] = dataView.getInt16(offset);
offset += 2;
}
this.relativeOffset += count * 2;
return list;
};
Parser.prototype.parseByteList = function(count) {
var list = new Array(count);
var dataView = this.data;
var offset = this.offset + this.relativeOffset;
for (var i = 0; i < count; i++) {
list[i] = dataView.getUint8(offset++);
}
this.relativeOffset += count;
return list;
};
Parser.prototype.parseList = function(count, itemCallback) {
if (!itemCallback) {
itemCallback = count;
count = this.parseUShort();
}
var list = new Array(count);
for (var i = 0; i < count; i++) {
list[i] = itemCallback.call(this);
}
return list;
};
Parser.prototype.parseList32 = function(count, itemCallback) {
if (!itemCallback) {
itemCallback = count;
count = this.parseULong();
}
var list = new Array(count);
for (var i = 0; i < count; i++) {
list[i] = itemCallback.call(this);
}
return list;
};
Parser.prototype.parseRecordList = function(count, recordDescription) {
if (!recordDescription) {
recordDescription = count;
count = this.parseUShort();
}
var records = new Array(count);
var fields = Object.keys(recordDescription);
for (var i = 0; i < count; i++) {
var rec = {};
for (var j = 0; j < fields.length; j++) {
var fieldName = fields[j];
var fieldType = recordDescription[fieldName];
rec[fieldName] = fieldType.call(this);
}
records[i] = rec;
}
return records;
};
Parser.prototype.parseRecordList32 = function(count, recordDescription) {
if (!recordDescription) {
recordDescription = count;
count = this.parseULong();
}
var records = new Array(count);
var fields = Object.keys(recordDescription);
for (var i = 0; i < count; i++) {
var rec = {};
for (var j = 0; j < fields.length; j++) {
var fieldName = fields[j];
var fieldType = recordDescription[fieldName];
rec[fieldName] = fieldType.call(this);
}
records[i] = rec;
}
return records;
};
Parser.prototype.parseStruct = function(description) {
if (typeof description === "function") {
return description.call(this);
} else {
var fields = Object.keys(description);
var struct = {};
for (var j = 0; j < fields.length; j++) {
var fieldName = fields[j];
var fieldType = description[fieldName];
struct[fieldName] = fieldType.call(this);
}
return struct;
}
};
Parser.prototype.parseValueRecord = function(valueFormat) {
if (valueFormat === void 0) {
valueFormat = this.parseUShort();
}
if (valueFormat === 0) {
return;
}
var valueRecord = {};
if (valueFormat & 1) {
valueRecord.xPlacement = this.parseShort();
}
if (valueFormat & 2) {
valueRecord.yPlacement = this.parseShort();
}
if (valueFormat & 4) {
valueRecord.xAdvance = this.parseShort();
}
if (valueFormat & 8) {
valueRecord.yAdvance = this.parseShort();
}
if (valueFormat & 16) {
valueRecord.xPlaDevice = void 0;
this.parseShort();
}
if (valueFormat & 32) {
valueRecord.yPlaDevice = void 0;
this.parseShort();
}
if (valueFormat & 64) {
valueRecord.xAdvDevice = void 0;
this.parseShort();
}
if (valueFormat & 128) {
valueRecord.yAdvDevice = void 0;
this.parseShort();
}
return valueRecord;
};
Parser.prototype.parseValueRecordList = function() {
var valueFormat = this.parseUShort();
var valueCount = this.parseUShort();
var values = new Array(valueCount);
for (var i = 0; i < valueCount; i++) {
values[i] = this.parseValueRecord(valueFormat);
}
return values;
};
Parser.prototype.parsePointer = function(description) {
var structOffset = this.parseOffset16();
if (structOffset > 0) {
return new Parser(this.data, this.offset + structOffset).parseStruct(description);
}
return void 0;
};
Parser.prototype.parsePointer32 = function(description) {
var structOffset = this.parseOffset32();
if (structOffset > 0) {
return new Parser(this.data, this.offset + structOffset).parseStruct(description);
}
return void 0;
};
Parser.prototype.parseListOfLists = function(itemCallback) {
var offsets = this.parseOffset16List();
var count = offsets.length;
var relativeOffset = this.relativeOffset;
var list = new Array(count);
for (var i = 0; i < count; i++) {
var start = offsets[i];
if (start === 0) {
list[i] = void 0;
continue;
}
this.relativeOffset = start;
if (itemCallback) {
var subOffsets = this.parseOffset16List();
var subList = new Array(subOffsets.length);
for (var j = 0; j < subOffsets.length; j++) {
this.relativeOffset = start + subOffsets[j];
subList[j] = itemCallback.call(this);
}
list[i] = subList;
} else {
list[i] = this.parseUShortList();
}
}
this.relativeOffset = relativeOffset;
return list;
};
Parser.prototype.parseCoverage = function() {
var startOffset = this.offset + this.relativeOffset;
var format = this.parseUShort();
var count = this.parseUShort();
if (format === 1) {
return {
format: 1,
glyphs: this.parseUShortList(count)
};
} else if (format === 2) {
var ranges = new Array(count);
for (var i = 0; i < count; i++) {
ranges[i] = {
start: this.parseUShort(),
end: this.parseUShort(),
index: this.parseUShort()
};
}
return {
format: 2,
ranges
};
}
throw new Error("0x" + startOffset.toString(16) + ": Coverage format must be 1 or 2.");
};
Parser.prototype.parseClassDef = function() {
var startOffset = this.offset + this.relativeOffset;
var format = this.parseUShort();
if (format === 1) {
return {
format: 1,
startGlyph: this.parseUShort(),
classes: this.parseUShortList()
};
} else if (format === 2) {
return {
format: 2,
ranges: this.parseRecordList({
start: Parser.uShort,
end: Parser.uShort,
classId: Parser.uShort
})
};
}
throw new Error("0x" + startOffset.toString(16) + ": ClassDef format must be 1 or 2.");
};
Parser.list = function(count, itemCallback) {
return function() {
return this.parseList(count, itemCallback);
};
};
Parser.list32 = function(count, itemCallback) {
return function() {
return this.parseList32(count, itemCallback);
};
};
Parser.recordList = function(count, recordDescription) {
return function() {
return this.parseRecordList(count, recordDescription);
};
};
Parser.recordList32 = function(count, recordDescription) {
return function() {
return