pdf-parser.js 5.2.26 → 5.2.28

package/dist/lexer.js

@@ -1,43 +1,78 @@
 import { isAsciiWhitespace } from "./bytes/reader.js";
 //#region src/lexer.ts
+const LEFT_PAREN = 40;
+const RIGHT_PAREN = 41;
+const LESS_THAN = 60;
+const GREATER_THAN = 62;
+const LEFT_BRACKET = 91;
+const RIGHT_BRACKET = 93;
+const LEFT_BRACE = 123;
+const RIGHT_BRACE = 125;
+const SOLIDUS = 47;
+const PERCENT_SIGN = 37;
+const REVERSE_SOLIDUS = 92;
+const NUMBER_SIGN = 35;
+const PLUS_SIGN = 43;
+const MINUS_SIGN = 45;
+const FULL_STOP = 46;
+const LINE_FEED = 10;
+const CARRIAGE_RETURN = 13;
+const HORIZONTAL_TAB = 9;
+const BACKSPACE = 8;
+const FORM_FEED = 12;
+const DIGIT_ZERO = 48;
+const DIGIT_SEVEN = 55;
+const DIGIT_NINE = 57;
+const UPPER_A = 65;
+const UPPER_F = 70;
+const LOWER_A = 97;
+const LOWER_B = 98;
+const LOWER_F = 102;
+const LOWER_N = 110;
+const LOWER_R = 114;
+const LOWER_T = 116;
+const HEX_DIGIT_ALPHA_OFFSET = 10;
+const HEX_RADIX = 16;
+const OCTAL_RADIX = 8;
+const BYTE_MASK = 255;
 const DELIMITER_BYTES = /* @__PURE__ */ new Set([
-	40,
-	41,
-	60,
-	62,
-	91,
-	93,
-	123,
-	125,
-	47,
-	37
+	LEFT_PAREN,
+	RIGHT_PAREN,
+	LESS_THAN,
+	GREATER_THAN,
+	LEFT_BRACKET,
+	RIGHT_BRACKET,
+	LEFT_BRACE,
+	RIGHT_BRACE,
+	SOLIDUS,
+	PERCENT_SIGN
 ]);
 function isRegularByte(byte) {
 	return !isAsciiWhitespace(byte) && !DELIMITER_BYTES.has(byte);
 }
 function isDigit(byte) {
-	return byte !== void 0 && byte >= 48 && byte <= 57;
+	return byte !== void 0 && byte >= DIGIT_ZERO && byte <= DIGIT_NINE;
 }
 function isHexDigit(byte) {
-	return byte !== void 0 && (byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102);
+	return byte !== void 0 && (byte >= DIGIT_ZERO && byte <= DIGIT_NINE || byte >= UPPER_A && byte <= UPPER_F || byte >= LOWER_A && byte <= LOWER_F);
 }
 function hexDigitValue(byte) {
-	if (byte >= 48 && byte <= 57) return byte - 48;
-	if (byte >= 65 && byte <= 70) return byte - 65 + 10;
-	return byte - 97 + 10;
+	if (byte >= DIGIT_ZERO && byte <= DIGIT_NINE) return byte - DIGIT_ZERO;
+	if (byte >= UPPER_A && byte <= UPPER_F) return byte - UPPER_A + HEX_DIGIT_ALPHA_OFFSET;
+	return byte - LOWER_A + HEX_DIGIT_ALPHA_OFFSET;
 }
 function skipWhitespaceAndComments(reader) {
 	for (;;) {
 		reader.skipWhitespace();
-		if (reader.peek() !== 37) return;
-		while (!reader.atEnd() && reader.peek() !== 10 && reader.peek() !== 13) reader.next();
+		if (reader.peek() !== PERCENT_SIGN) return;
+		while (!reader.atEnd() && reader.peek() !== LINE_FEED && reader.peek() !== CARRIAGE_RETURN) reader.next();
 	}
 }
 function readNumberToken(reader) {
 	const start = reader.offset;
-	if (reader.peek() === 43 || reader.peek() === 45) reader.next();
+	if (reader.peek() === PLUS_SIGN || reader.peek() === MINUS_SIGN) reader.next();
 	while (isDigit(reader.peek())) reader.next();
-	if (reader.peek() === 46) {
+	if (reader.peek() === FULL_STOP) {
 		reader.next();
 		while (isDigit(reader.peek())) reader.next();
 	}
@@ -53,11 +88,11 @@ function readNameToken(reader) {
 	for (;;) {
 		const byte = reader.peek();
 		if (byte === void 0 || !isRegularByte(byte)) break;
-		if (byte === 35 && isHexDigit(reader.peek(1)) && isHexDigit(reader.peek(2))) {
+		if (byte === NUMBER_SIGN && isHexDigit(reader.peek(1)) && isHexDigit(reader.peek(2))) {
 			reader.next();
 			const hi = hexDigitValue(reader.next());
 			const lo = hexDigitValue(reader.next());
-			bytes.push(hi * 16 + lo);
+			bytes.push(hi * HEX_RADIX + lo);
 		} else bytes.push(reader.next());
 	}
 	return {
@@ -72,38 +107,38 @@ function readLiteralStringToken(reader) {
 	for (;;) {
 		const byte = reader.next();
 		if (byte === void 0) break;
-		if (byte === 92) {
+		if (byte === REVERSE_SOLIDUS) {
 			const esc = reader.next();
 			if (esc === void 0) break;
-			if (esc === 110) bytes.push(10);
-			else if (esc === 114) bytes.push(13);
-			else if (esc === 116) bytes.push(9);
-			else if (esc === 98) bytes.push(8);
-			else if (esc === 102) bytes.push(12);
-			else if (esc === 40 || esc === 41 || esc === 92) bytes.push(esc);
-			else if (esc === 13) {
-				if (reader.peek() === 10) reader.next();
-			} else if (esc === 10) {} else if (esc >= 48 && esc <= 55) {
-				let value = esc - 48;
-				for (let i = 0; i < 2 && reader.peek() !== void 0 && reader.peek() >= 48 && reader.peek() <= 55; i++) value = value * 8 + (reader.next() - 48);
-				bytes.push(value & 255);
+			if (esc === LOWER_N) bytes.push(LINE_FEED);
+			else if (esc === LOWER_R) bytes.push(CARRIAGE_RETURN);
+			else if (esc === LOWER_T) bytes.push(HORIZONTAL_TAB);
+			else if (esc === LOWER_B) bytes.push(BACKSPACE);
+			else if (esc === LOWER_F) bytes.push(FORM_FEED);
+			else if (esc === LEFT_PAREN || esc === RIGHT_PAREN || esc === REVERSE_SOLIDUS) bytes.push(esc);
+			else if (esc === CARRIAGE_RETURN) {
+				if (reader.peek() === LINE_FEED) reader.next();
+			} else if (esc === LINE_FEED) {} else if (esc >= DIGIT_ZERO && esc <= DIGIT_SEVEN) {
+				let value = esc - DIGIT_ZERO;
+				for (let i = 0; i < 2 && reader.peek() !== void 0 && reader.peek() >= DIGIT_ZERO && reader.peek() <= DIGIT_SEVEN; i++) value = value * OCTAL_RADIX + (reader.next() - DIGIT_ZERO);
+				bytes.push(value & BYTE_MASK);
 			} else bytes.push(esc);
 			continue;
 		}
-		if (byte === 40) {
+		if (byte === LEFT_PAREN) {
 			depth++;
 			bytes.push(byte);
 			continue;
 		}
-		if (byte === 41) {
+		if (byte === RIGHT_PAREN) {
 			depth--;
 			if (depth === 0) break;
 			bytes.push(byte);
 			continue;
 		}
-		if (byte === 13) {
-			if (reader.peek() === 10) reader.next();
-			bytes.push(10);
+		if (byte === CARRIAGE_RETURN) {
+			if (reader.peek() === LINE_FEED) reader.next();
+			bytes.push(LINE_FEED);
 			continue;
 		}
 		bytes.push(byte);
@@ -118,12 +153,12 @@ function readHexStringToken(reader) {
 	const digits = [];
 	for (;;) {
 		const byte = reader.next();
-		if (byte === void 0 || byte === 62) break;
+		if (byte === void 0 || byte === GREATER_THAN) break;
 		if (isHexDigit(byte)) digits.push(hexDigitValue(byte));
 	}
 	if (digits.length % 2 === 1) digits.push(0);
 	const bytes = new Uint8Array(digits.length / 2);
-	for (let i = 0; i < bytes.length; i++) bytes[i] = digits[i * 2] * 16 + digits[i * 2 + 1];
+	for (let i = 0; i < bytes.length; i++) bytes[i] = digits[i * 2] * HEX_RADIX + digits[i * 2 + 1];
 	return {
 		kind: "hexString",
 		value: bytes
@@ -141,18 +176,18 @@ function nextToken(reader) {
 	skipWhitespaceAndComments(reader);
 	const byte = reader.peek();
 	if (byte === void 0) return;
-	if (byte === 47) return readNameToken(reader);
-	if (byte === 40) return readLiteralStringToken(reader);
-	if (byte === 60) {
-		if (reader.peek(1) === 60) {
+	if (byte === SOLIDUS) return readNameToken(reader);
+	if (byte === LEFT_PAREN) return readLiteralStringToken(reader);
+	if (byte === LESS_THAN) {
+		if (reader.peek(1) === LESS_THAN) {
 			reader.next();
 			reader.next();
 			return { kind: "dictStart" };
 		}
 		return readHexStringToken(reader);
 	}
-	if (byte === 62) {
-		if (reader.peek(1) === 62) {
+	if (byte === GREATER_THAN) {
+		if (reader.peek(1) === GREATER_THAN) {
 			reader.next();
 			reader.next();
 			return { kind: "dictEnd" };
@@ -160,19 +195,19 @@ function nextToken(reader) {
 		reader.next();
 		return nextToken(reader);
 	}
-	if (byte === 91) {
+	if (byte === LEFT_BRACKET) {
 		reader.next();
 		return { kind: "arrayStart" };
 	}
-	if (byte === 93) {
+	if (byte === RIGHT_BRACKET) {
 		reader.next();
 		return { kind: "arrayEnd" };
 	}
-	if (byte === 123 || byte === 125) {
+	if (byte === LEFT_BRACE || byte === RIGHT_BRACE) {
 		reader.next();
 		return nextToken(reader);
 	}
-	if (byte === 43 || byte === 45 || byte === 46 || isDigit(byte)) return readNumberToken(reader);
+	if (byte === PLUS_SIGN || byte === MINUS_SIGN || byte === FULL_STOP || isDigit(byte)) return readNumberToken(reader);
 	return readKeywordToken(reader);
 }
 //#endregion

package/dist/math-content-write.cjs

@@ -9,6 +9,8 @@ function toPdfX(positioned, itemXPt) {
 function toPdfY(positioned, itemYPt) {
 	return positioned.yPt + positioned.box.heightPt - itemYPt;
 }
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
 function writeRgbOperator(writer, color, operator) {
 	writer.writeAscii(`${require_serialize.formatNumber(color.r)} ${require_serialize.formatNumber(color.g)} ${require_serialize.formatNumber(color.b)} ${operator}\n`);
 }
@@ -22,8 +24,8 @@ function encodeGlyphRunToCids(font, text) {
 	}
 	const bytes = new Uint8Array(gids.length * 2);
 	gids.forEach((gid, index) => {
-		bytes[index * 2] = gid >> 8 & 255;
-		bytes[index * 2 + 1] = gid & 255;
+		bytes[index * 2] = gid >> BITS_PER_BYTE & BYTE_MASK;
+		bytes[index * 2 + 1] = gid & BYTE_MASK;
 	});
 	return bytes;
 }
@@ -41,13 +43,15 @@ function writeGlyphRun(writer, positioned, item, ctx) {
 	writer.writeAscii("ET\n");
 }
 function cidBytes(glyphId) {
-	return new Uint8Array([glyphId >> 8 & 255, glyphId & 255]);
+	return new Uint8Array([glyphId >> BITS_PER_BYTE & BYTE_MASK, glyphId & BYTE_MASK]);
 }
+const UTF16_BOM_HIGH_BYTE = 254;
+const UTF16_BOM_LOW_BYTE = 255;
 function utf16BeWithBom(text) {
-	const bytes = [254, 255];
+	const bytes = [UTF16_BOM_HIGH_BYTE, UTF16_BOM_LOW_BYTE];
 	for (let i = 0; i < text.length; i++) {
 		const unit = text.charCodeAt(i);
-		bytes.push(unit >> 8 & 255, unit & 255);
+		bytes.push(unit >> BITS_PER_BYTE & BYTE_MASK, unit & BYTE_MASK);
 	}
 	return new Uint8Array(bytes);
 }

package/dist/math-content-write.js

@@ -8,6 +8,8 @@ function toPdfX(positioned, itemXPt) {
 function toPdfY(positioned, itemYPt) {
 	return positioned.yPt + positioned.box.heightPt - itemYPt;
 }
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
 function writeRgbOperator(writer, color, operator) {
 	writer.writeAscii(`${formatNumber(color.r)} ${formatNumber(color.g)} ${formatNumber(color.b)} ${operator}\n`);
 }
@@ -21,8 +23,8 @@ function encodeGlyphRunToCids(font, text) {
 	}
 	const bytes = new Uint8Array(gids.length * 2);
 	gids.forEach((gid, index) => {
-		bytes[index * 2] = gid >> 8 & 255;
-		bytes[index * 2 + 1] = gid & 255;
+		bytes[index * 2] = gid >> BITS_PER_BYTE & BYTE_MASK;
+		bytes[index * 2 + 1] = gid & BYTE_MASK;
 	});
 	return bytes;
 }
@@ -40,13 +42,15 @@ function writeGlyphRun(writer, positioned, item, ctx) {
 	writer.writeAscii("ET\n");
 }
 function cidBytes(glyphId) {
-	return new Uint8Array([glyphId >> 8 & 255, glyphId & 255]);
+	return new Uint8Array([glyphId >> BITS_PER_BYTE & BYTE_MASK, glyphId & BYTE_MASK]);
 }
+const UTF16_BOM_HIGH_BYTE = 254;
+const UTF16_BOM_LOW_BYTE = 255;
 function utf16BeWithBom(text) {
-	const bytes = [254, 255];
+	const bytes = [UTF16_BOM_HIGH_BYTE, UTF16_BOM_LOW_BYTE];
 	for (let i = 0; i < text.length; i++) {
 		const unit = text.charCodeAt(i);
-		bytes.push(unit >> 8 & 255, unit & 255);
+		bytes.push(unit >> BITS_PER_BYTE & BYTE_MASK, unit & BYTE_MASK);
 	}
 	return new Uint8Array(bytes);
 }

package/dist/math-font-write.cjs

@@ -10,9 +10,10 @@ function buildWidthsArray(font, usedGlyphs) {
 	for (const glyphId of [...usedGlyphs.keys()].sort((a, b) => a - b)) entries.push(require_objects.pdfNum(glyphId), require_objects.pdfArray([require_objects.pdfNum(font.glyphSpaceWidth(glyphId))]));
 	return require_objects.pdfArray(entries);
 }
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 function buildFontDescriptor(font, fontFileRef) {
 	const d = font.descriptor;
-	const scale = 1e3 / d.unitsPerEm;
+	const scale = GLYPH_SPACE_UNITS_PER_EM / d.unitsPerEm;
 	return require_objects.pdfDict({
 		Type: require_objects.pdfName("FontDescriptor"),
 		FontName: require_objects.pdfName("STIXTwoMath-Regular"),

package/dist/math-font-write.d.cts

@@ -1,4 +1,4 @@
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.cjs";
 import { MathFont } from "./math-font.cjs";
 //#region src/math-font-write.d.ts
 interface MathFontObjectRefs {

package/dist/math-font-write.d.ts

@@ -1,4 +1,4 @@
-import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.js";
 import { MathFont } from "./math-font.js";
 //#region src/math-font-write.d.ts
 interface MathFontObjectRefs {

package/dist/math-font-write.js

@@ -9,9 +9,10 @@ function buildWidthsArray(font, usedGlyphs) {
 	for (const glyphId of [...usedGlyphs.keys()].sort((a, b) => a - b)) entries.push(pdfNum(glyphId), pdfArray([pdfNum(font.glyphSpaceWidth(glyphId))]));
 	return pdfArray(entries);
 }
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 function buildFontDescriptor(font, fontFileRef) {
 	const d = font.descriptor;
-	const scale = 1e3 / d.unitsPerEm;
+	const scale = GLYPH_SPACE_UNITS_PER_EM / d.unitsPerEm;
 	return pdfDict({
 		Type: pdfName("FontDescriptor"),
 		FontName: pdfName("STIXTwoMath-Regular"),

package/dist/math-font.cjs

@@ -8,6 +8,15 @@ const require_math_stretch = require("./math-stretch.cjs");
 const require_math_table = require("./math-table.cjs");
 let byte_codec = require("byte-codec");
 //#region src/math-font.ts
+const HEAD_UNITS_PER_EM_OFFSET = 18;
+const HEAD_X_MIN_OFFSET = 36;
+const HEAD_Y_MIN_OFFSET = 38;
+const HEAD_X_MAX_OFFSET = 40;
+const HEAD_Y_MAX_OFFSET = 42;
+const HHEA_ASCENDER_OFFSET = 4;
+const HHEA_DESCENDER_OFFSET = 6;
+const OS2_CAP_HEIGHT_OFFSET = 88;
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 function toPt(designUnits, unitsPerEm, sizePt) {
 	return designUnits / unitsPerEm * sizePt;
 }
@@ -124,12 +133,12 @@ function loadMathFont() {
 	const os2Bytes = require_sfnt.sfntTableBytes(sfnt, "OS/2");
 	const cffBytes = require_sfnt.sfntTableBytes(sfnt, "CFF ");
 	if (headBytes === void 0 || hheaBytes === void 0 || cffBytes === void 0) throw new Error("embedded math font is missing a required sfnt table (head/hhea/CFF )");
-	const unitsPerEm = require_sfnt.u16(headBytes, 18);
-	const ascentDesignUnits = require_sfnt.i16(hheaBytes, 4);
-	const descentDesignUnits = require_sfnt.i16(hheaBytes, 6);
-	const bboxMin = [require_sfnt.i16(headBytes, 36), require_sfnt.i16(headBytes, 38)];
-	const bboxMax = [require_sfnt.i16(headBytes, 40), require_sfnt.i16(headBytes, 42)];
-	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : require_sfnt.i16(os2Bytes, 88);
+	const unitsPerEm = require_sfnt.u16(headBytes, HEAD_UNITS_PER_EM_OFFSET);
+	const ascentDesignUnits = require_sfnt.i16(hheaBytes, HHEA_ASCENDER_OFFSET);
+	const descentDesignUnits = require_sfnt.i16(hheaBytes, HHEA_DESCENDER_OFFSET);
+	const bboxMin = [require_sfnt.i16(headBytes, HEAD_X_MIN_OFFSET), require_sfnt.i16(headBytes, HEAD_Y_MIN_OFFSET)];
+	const bboxMax = [require_sfnt.i16(headBytes, HEAD_X_MAX_OFFSET), require_sfnt.i16(headBytes, HEAD_Y_MAX_OFFSET)];
+	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : require_sfnt.i16(os2Bytes, OS2_CAP_HEIGHT_OFFSET);
 	const cmap = require_cmap_table.buildCmapLookup(sfnt);
 	if (cmap === void 0) throw new Error("embedded math font has no readable cmap subtable");
 	const hmtx = require_hmtx_table.parseHmtx(sfnt);
@@ -148,7 +157,7 @@ function loadMathFont() {
 			italicAngle: 0
 		},
 		glyphId: (codePoint) => cmap(codePoint),
-		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm,
+		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * GLYPH_SPACE_UNITS_PER_EM / unitsPerEm,
 		glyphInkBounds: (glyphId) => inkBounds?.bounds(glyphId),
 		minConnectorOverlap: math.variants.minConnectorOverlap,
 		stretchyConstruction: (codePoint, axis) => {

package/dist/math-font.js

@@ -7,6 +7,15 @@ import { assembleStretchyGlyph, scaleMathStretchConstruction } from "./math-stre
 import { parseMathTable } from "./math-table.js";
 import { base64ToBytes } from "byte-codec";
 //#region src/math-font.ts
+const HEAD_UNITS_PER_EM_OFFSET = 18;
+const HEAD_X_MIN_OFFSET = 36;
+const HEAD_Y_MIN_OFFSET = 38;
+const HEAD_X_MAX_OFFSET = 40;
+const HEAD_Y_MAX_OFFSET = 42;
+const HHEA_ASCENDER_OFFSET = 4;
+const HHEA_DESCENDER_OFFSET = 6;
+const OS2_CAP_HEIGHT_OFFSET = 88;
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 function toPt(designUnits, unitsPerEm, sizePt) {
 	return designUnits / unitsPerEm * sizePt;
 }
@@ -123,12 +132,12 @@ function loadMathFont() {
 	const os2Bytes = sfntTableBytes(sfnt, "OS/2");
 	const cffBytes = sfntTableBytes(sfnt, "CFF ");
 	if (headBytes === void 0 || hheaBytes === void 0 || cffBytes === void 0) throw new Error("embedded math font is missing a required sfnt table (head/hhea/CFF )");
-	const unitsPerEm = u16(headBytes, 18);
-	const ascentDesignUnits = i16(hheaBytes, 4);
-	const descentDesignUnits = i16(hheaBytes, 6);
-	const bboxMin = [i16(headBytes, 36), i16(headBytes, 38)];
-	const bboxMax = [i16(headBytes, 40), i16(headBytes, 42)];
-	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : i16(os2Bytes, 88);
+	const unitsPerEm = u16(headBytes, HEAD_UNITS_PER_EM_OFFSET);
+	const ascentDesignUnits = i16(hheaBytes, HHEA_ASCENDER_OFFSET);
+	const descentDesignUnits = i16(hheaBytes, HHEA_DESCENDER_OFFSET);
+	const bboxMin = [i16(headBytes, HEAD_X_MIN_OFFSET), i16(headBytes, HEAD_Y_MIN_OFFSET)];
+	const bboxMax = [i16(headBytes, HEAD_X_MAX_OFFSET), i16(headBytes, HEAD_Y_MAX_OFFSET)];
+	const capHeight = os2Bytes === void 0 ? ascentDesignUnits : i16(os2Bytes, OS2_CAP_HEIGHT_OFFSET);
 	const cmap = buildCmapLookup(sfnt);
 	if (cmap === void 0) throw new Error("embedded math font has no readable cmap subtable");
 	const hmtx = parseHmtx(sfnt);
@@ -147,7 +156,7 @@ function loadMathFont() {
 			italicAngle: 0
 		},
 		glyphId: (codePoint) => cmap(codePoint),
-		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * 1e3 / unitsPerEm,
+		glyphSpaceWidth: (glyphId) => hmtx.advanceWidth(glyphId) * GLYPH_SPACE_UNITS_PER_EM / unitsPerEm,
 		glyphInkBounds: (glyphId) => inkBounds?.bounds(glyphId),
 		minConnectorOverlap: math.variants.minConnectorOverlap,
 		stretchyConstruction: (codePoint, axis) => {

package/dist/math-table.cjs

@@ -34,15 +34,20 @@ const MATH_VALUE_RECORD_INDEX = {
 const MATH_VALUE_RECORDS_START = 8;
 const MATH_VALUE_RECORD_SIZE = 4;
 const RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET = 212;
+const MATH_TABLE_HEADER_CONSTANTS_OFFSET_FIELD = 4;
+const MATH_TABLE_HEADER_GLYPH_INFO_OFFSET_FIELD = 6;
+const MATH_TABLE_HEADER_VARIANTS_OFFSET_FIELD = 8;
+const PERCENT_SCALE_DENOMINATOR = 100;
+const MATH_VALUE_TABLE_HEADER_SIZE = 4;
 function mathValueRecord(bytes, constantsOffset, index) {
 	return require_sfnt.i16(bytes, constantsOffset + MATH_VALUE_RECORDS_START + index * MATH_VALUE_RECORD_SIZE);
 }
 function parseMathConstants(bytes, mathTableOffset) {
-	const constantsOffset = mathTableOffset + require_sfnt.u16(bytes, mathTableOffset + 4);
+	const constantsOffset = mathTableOffset + require_sfnt.u16(bytes, mathTableOffset + MATH_TABLE_HEADER_CONSTANTS_OFFSET_FIELD);
 	const field = (index) => mathValueRecord(bytes, constantsOffset, index);
 	return {
-		scriptPercentScaleDown: require_sfnt.i16(bytes, constantsOffset + 0) / 100,
-		scriptScriptPercentScaleDown: require_sfnt.i16(bytes, constantsOffset + 2) / 100,
+		scriptPercentScaleDown: require_sfnt.i16(bytes, constantsOffset + 0) / PERCENT_SCALE_DENOMINATOR,
+		scriptScriptPercentScaleDown: require_sfnt.i16(bytes, constantsOffset + 2) / PERCENT_SCALE_DENOMINATOR,
 		axisHeight: field(MATH_VALUE_RECORD_INDEX.axisHeight),
 		subscriptShiftDown: field(MATH_VALUE_RECORD_INDEX.subscriptShiftDown),
 		subscriptBaselineDropMin: field(MATH_VALUE_RECORD_INDEX.subscriptBaselineDropMin),
@@ -77,11 +82,11 @@ function parseGlyphValueTable(bytes, tableOffset) {
 	const coverage = require_ot_layout_common.parseCoverage(bytes, tableOffset + require_sfnt.u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
 	if (coverage === void 0) return values;
-	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + MATH_VALUE_TABLE_HEADER_SIZE + coverageIndex * MATH_VALUE_RECORD_SIZE));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
-	const glyphInfoOffset = mathTableOffset + require_sfnt.u16(bytes, mathTableOffset + 6);
+	const glyphInfoOffset = mathTableOffset + require_sfnt.u16(bytes, mathTableOffset + MATH_TABLE_HEADER_GLYPH_INFO_OFFSET_FIELD);
 	const italicsInfoOffset = require_sfnt.u16(bytes, glyphInfoOffset + 0);
 	const topAccentOffset = require_sfnt.u16(bytes, glyphInfoOffset + 2);
 	return {
@@ -93,6 +98,13 @@ const MATH_GLYPH_VARIANT_RECORD_SIZE = 4;
 const GLYPH_PART_RECORD_SIZE = 10;
 const GLYPH_PART_FLAG_EXTENDER = 1;
 const MATH_VARIANTS_HEADER_SIZE = 10;
+const GLYPH_PART_END_CONNECTOR_OFFSET = 4;
+const GLYPH_PART_FULL_ADVANCE_OFFSET = 6;
+const GLYPH_PART_FLAGS_OFFSET = 8;
+const MATH_GLYPH_CONSTRUCTION_HEADER_SIZE = 4;
+const MATH_VARIANTS_HORIZONTAL_COVERAGE_OFFSET_FIELD = 4;
+const MATH_VARIANTS_VERTICAL_COUNT_FIELD = 6;
+const MATH_VARIANTS_HORIZONTAL_COUNT_FIELD = 8;
 function parseGlyphAssembly(bytes, assemblyOffset) {
 	const partCount = require_sfnt.u16(bytes, assemblyOffset + MATH_VALUE_RECORD_SIZE);
 	const parts = [];
@@ -101,9 +113,9 @@ function parseGlyphAssembly(bytes, assemblyOffset) {
 		parts.push({
 			glyphId: require_sfnt.u16(bytes, recordOffset),
 			startConnectorLength: require_sfnt.u16(bytes, recordOffset + 2),
-			endConnectorLength: require_sfnt.u16(bytes, recordOffset + 4),
-			fullAdvance: require_sfnt.u16(bytes, recordOffset + 6),
-			isExtender: (require_sfnt.u16(bytes, recordOffset + 8) & GLYPH_PART_FLAG_EXTENDER) !== 0
+			endConnectorLength: require_sfnt.u16(bytes, recordOffset + GLYPH_PART_END_CONNECTOR_OFFSET),
+			fullAdvance: require_sfnt.u16(bytes, recordOffset + GLYPH_PART_FULL_ADVANCE_OFFSET),
+			isExtender: (require_sfnt.u16(bytes, recordOffset + GLYPH_PART_FLAGS_OFFSET) & GLYPH_PART_FLAG_EXTENDER) !== 0
 		});
 	}
 	return {
@@ -116,7 +128,7 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 	const variantCount = require_sfnt.u16(bytes, constructionOffset + 2);
 	const variants = [];
 	for (let i = 0; i < variantCount; i++) {
-		const recordOffset = constructionOffset + 4 + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
+		const recordOffset = constructionOffset + MATH_GLYPH_CONSTRUCTION_HEADER_SIZE + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
 		variants.push({
 			glyphId: require_sfnt.u16(bytes, recordOffset),
 			advanceMeasurement: require_sfnt.u16(bytes, recordOffset + 2)
@@ -139,7 +151,7 @@ function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count,
 	return constructions;
 }
 function parseMathVariants(bytes, mathTableOffset) {
-	const variantsTableOffset = require_sfnt.u16(bytes, mathTableOffset + 8);
+	const variantsTableOffset = require_sfnt.u16(bytes, mathTableOffset + MATH_TABLE_HEADER_VARIANTS_OFFSET_FIELD);
 	if (variantsTableOffset === 0) return {
 		minConnectorOverlap: 0,
 		vertical: /* @__PURE__ */ new Map(),
@@ -147,9 +159,9 @@ function parseMathVariants(bytes, mathTableOffset) {
 	};
 	const variantsOffset = mathTableOffset + variantsTableOffset;
 	const verticalCoverageOffset = require_sfnt.u16(bytes, variantsOffset + 2);
-	const horizontalCoverageOffset = require_sfnt.u16(bytes, variantsOffset + 4);
-	const verticalCount = require_sfnt.u16(bytes, variantsOffset + 6);
-	const horizontalCount = require_sfnt.u16(bytes, variantsOffset + 8);
+	const horizontalCoverageOffset = require_sfnt.u16(bytes, variantsOffset + MATH_VARIANTS_HORIZONTAL_COVERAGE_OFFSET_FIELD);
+	const verticalCount = require_sfnt.u16(bytes, variantsOffset + MATH_VARIANTS_VERTICAL_COUNT_FIELD);
+	const horizontalCount = require_sfnt.u16(bytes, variantsOffset + MATH_VARIANTS_HORIZONTAL_COUNT_FIELD);
 	const verticalArrayOffset = variantsOffset + MATH_VARIANTS_HEADER_SIZE;
 	const horizontalArrayOffset = verticalArrayOffset + verticalCount * 2;
 	return {

package/dist/math-table.js

@@ -33,15 +33,20 @@ const MATH_VALUE_RECORD_INDEX = {
 const MATH_VALUE_RECORDS_START = 8;
 const MATH_VALUE_RECORD_SIZE = 4;
 const RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET = 212;
+const MATH_TABLE_HEADER_CONSTANTS_OFFSET_FIELD = 4;
+const MATH_TABLE_HEADER_GLYPH_INFO_OFFSET_FIELD = 6;
+const MATH_TABLE_HEADER_VARIANTS_OFFSET_FIELD = 8;
+const PERCENT_SCALE_DENOMINATOR = 100;
+const MATH_VALUE_TABLE_HEADER_SIZE = 4;
 function mathValueRecord(bytes, constantsOffset, index) {
 	return i16(bytes, constantsOffset + MATH_VALUE_RECORDS_START + index * MATH_VALUE_RECORD_SIZE);
 }
 function parseMathConstants(bytes, mathTableOffset) {
-	const constantsOffset = mathTableOffset + u16(bytes, mathTableOffset + 4);
+	const constantsOffset = mathTableOffset + u16(bytes, mathTableOffset + MATH_TABLE_HEADER_CONSTANTS_OFFSET_FIELD);
 	const field = (index) => mathValueRecord(bytes, constantsOffset, index);
 	return {
-		scriptPercentScaleDown: i16(bytes, constantsOffset + 0) / 100,
-		scriptScriptPercentScaleDown: i16(bytes, constantsOffset + 2) / 100,
+		scriptPercentScaleDown: i16(bytes, constantsOffset + 0) / PERCENT_SCALE_DENOMINATOR,
+		scriptScriptPercentScaleDown: i16(bytes, constantsOffset + 2) / PERCENT_SCALE_DENOMINATOR,
 		axisHeight: field(MATH_VALUE_RECORD_INDEX.axisHeight),
 		subscriptShiftDown: field(MATH_VALUE_RECORD_INDEX.subscriptShiftDown),
 		subscriptBaselineDropMin: field(MATH_VALUE_RECORD_INDEX.subscriptBaselineDropMin),
@@ -76,11 +81,11 @@ function parseGlyphValueTable(bytes, tableOffset) {
 	const coverage = parseCoverage(bytes, tableOffset + u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
 	if (coverage === void 0) return values;
-	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, i16(bytes, tableOffset + MATH_VALUE_TABLE_HEADER_SIZE + coverageIndex * MATH_VALUE_RECORD_SIZE));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
-	const glyphInfoOffset = mathTableOffset + u16(bytes, mathTableOffset + 6);
+	const glyphInfoOffset = mathTableOffset + u16(bytes, mathTableOffset + MATH_TABLE_HEADER_GLYPH_INFO_OFFSET_FIELD);
 	const italicsInfoOffset = u16(bytes, glyphInfoOffset + 0);
 	const topAccentOffset = u16(bytes, glyphInfoOffset + 2);
 	return {
@@ -92,6 +97,13 @@ const MATH_GLYPH_VARIANT_RECORD_SIZE = 4;
 const GLYPH_PART_RECORD_SIZE = 10;
 const GLYPH_PART_FLAG_EXTENDER = 1;
 const MATH_VARIANTS_HEADER_SIZE = 10;
+const GLYPH_PART_END_CONNECTOR_OFFSET = 4;
+const GLYPH_PART_FULL_ADVANCE_OFFSET = 6;
+const GLYPH_PART_FLAGS_OFFSET = 8;
+const MATH_GLYPH_CONSTRUCTION_HEADER_SIZE = 4;
+const MATH_VARIANTS_HORIZONTAL_COVERAGE_OFFSET_FIELD = 4;
+const MATH_VARIANTS_VERTICAL_COUNT_FIELD = 6;
+const MATH_VARIANTS_HORIZONTAL_COUNT_FIELD = 8;
 function parseGlyphAssembly(bytes, assemblyOffset) {
 	const partCount = u16(bytes, assemblyOffset + MATH_VALUE_RECORD_SIZE);
 	const parts = [];
@@ -100,9 +112,9 @@ function parseGlyphAssembly(bytes, assemblyOffset) {
 		parts.push({
 			glyphId: u16(bytes, recordOffset),
 			startConnectorLength: u16(bytes, recordOffset + 2),
-			endConnectorLength: u16(bytes, recordOffset + 4),
-			fullAdvance: u16(bytes, recordOffset + 6),
-			isExtender: (u16(bytes, recordOffset + 8) & GLYPH_PART_FLAG_EXTENDER) !== 0
+			endConnectorLength: u16(bytes, recordOffset + GLYPH_PART_END_CONNECTOR_OFFSET),
+			fullAdvance: u16(bytes, recordOffset + GLYPH_PART_FULL_ADVANCE_OFFSET),
+			isExtender: (u16(bytes, recordOffset + GLYPH_PART_FLAGS_OFFSET) & GLYPH_PART_FLAG_EXTENDER) !== 0
 		});
 	}
 	return {
@@ -115,7 +127,7 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 	const variantCount = u16(bytes, constructionOffset + 2);
 	const variants = [];
 	for (let i = 0; i < variantCount; i++) {
-		const recordOffset = constructionOffset + 4 + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
+		const recordOffset = constructionOffset + MATH_GLYPH_CONSTRUCTION_HEADER_SIZE + i * MATH_GLYPH_VARIANT_RECORD_SIZE;
 		variants.push({
 			glyphId: u16(bytes, recordOffset),
 			advanceMeasurement: u16(bytes, recordOffset + 2)
@@ -138,7 +150,7 @@ function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count,
 	return constructions;
 }
 function parseMathVariants(bytes, mathTableOffset) {
-	const variantsTableOffset = u16(bytes, mathTableOffset + 8);
+	const variantsTableOffset = u16(bytes, mathTableOffset + MATH_TABLE_HEADER_VARIANTS_OFFSET_FIELD);
 	if (variantsTableOffset === 0) return {
 		minConnectorOverlap: 0,
 		vertical: /* @__PURE__ */ new Map(),
@@ -146,9 +158,9 @@ function parseMathVariants(bytes, mathTableOffset) {
 	};
 	const variantsOffset = mathTableOffset + variantsTableOffset;
 	const verticalCoverageOffset = u16(bytes, variantsOffset + 2);
-	const horizontalCoverageOffset = u16(bytes, variantsOffset + 4);
-	const verticalCount = u16(bytes, variantsOffset + 6);
-	const horizontalCount = u16(bytes, variantsOffset + 8);
+	const horizontalCoverageOffset = u16(bytes, variantsOffset + MATH_VARIANTS_HORIZONTAL_COVERAGE_OFFSET_FIELD);
+	const verticalCount = u16(bytes, variantsOffset + MATH_VARIANTS_VERTICAL_COUNT_FIELD);
+	const horizontalCount = u16(bytes, variantsOffset + MATH_VARIANTS_HORIZONTAL_COUNT_FIELD);
 	const verticalArrayOffset = variantsOffset + MATH_VARIANTS_HEADER_SIZE;
 	const horizontalArrayOffset = verticalArrayOffset + verticalCount * 2;
 	return {

package/dist/matrix.cjs

@@ -48,8 +48,9 @@ function scaleMatrix(sx, sy) {
 	];
 }
 const BEZIER_KAPPA = .5522847498;
+const DEGREES_PER_HALF_TURN = 180;
 function rotationMatrix(degrees) {
-	const radians = degrees * Math.PI / 180;
+	const radians = degrees * Math.PI / DEGREES_PER_HALF_TURN;
 	const cos = Math.cos(radians);
 	const sin = Math.sin(radians);
 	return [
@@ -68,7 +69,7 @@ function matrixScaleY(m) {
 	return Math.hypot(m[2], m[3]);
 }
 function matrixRotationDegrees(m) {
-	return Math.atan2(m[1], m[0]) * 180 / Math.PI;
+	return Math.atan2(m[1], m[0]) * DEGREES_PER_HALF_TURN / Math.PI;
 }
 function rotatePointAboutCenter(point, center, degrees) {
 	const relative = {