pdf-parser.js 5.2.26 → 5.2.28

package/dist/cff-bounds.js

@@ -16,6 +16,11 @@ const CS_OPERAND_MEDIUM_BIAS = 108;
 const CS_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
 const CS_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
 const BYTE_RADIX = 256;
+const INT16_SIGN_BIT = 32768;
+const INT16_MODULUS = 65536;
+const CS_OPERAND_INT16_TOTAL_LENGTH = 3;
+const CS_OPERAND_FIXED_BYTE_LENGTH = 4;
+const CS_OPERAND_FIXED_TOTAL_LENGTH = 5;
 const FIXED_POINT_SCALE = 65536;
 const OP_HSTEM = 1;
 const OP_VSTEM = 3;
@@ -52,6 +57,13 @@ const SUBR_BIAS_MEDIUM = 1131;
 const SUBR_BIAS_LARGE = 32768;
 const HINT_MASK_BITS_PER_BYTE = 8;
 const STEM_ARGS_PER_STEM = 2;
+const CURVE_ARG_COUNT = 6;
+const CURVE_DY2_OFFSET = 3;
+const CURVE_DX3_OFFSET = 4;
+const CURVE_DY3_OFFSET = 5;
+const QUAD_CURVE_ARG_COUNT = 4;
+const QUAD_CURVE_LAST_OFFSET = 3;
+const QUAD_CURVE_WITH_EXTRA_ARG_COUNT = 5;
 const MAX_OPERAND_STACK = 48;
 const MAX_SUBR_DEPTH = 10;
 const MAX_OPERATIONS_PER_GLYPH = 1e5;
@@ -61,28 +73,48 @@ function subrBias(count) {
 	if (count < SUBR_BIAS_MEDIUM_LIMIT) return SUBR_BIAS_MEDIUM;
 	return SUBR_BIAS_LARGE;
 }
-function includePoint(box, x, y) {
-	box.minX = Math.min(box.minX, x);
-	box.minY = Math.min(box.minY, y);
-	box.maxX = Math.max(box.maxX, x);
-	box.maxY = Math.max(box.maxY, y);
-	box.drawn = true;
-}
+var BoundsBox = class {
+	minX = Infinity;
+	minY = Infinity;
+	maxX = -Infinity;
+	maxY = -Infinity;
+	drawn = false;
+	includePoint(x, y) {
+		this.minX = Math.min(this.minX, x);
+		this.minY = Math.min(this.minY, y);
+		this.maxX = Math.max(this.maxX, x);
+		this.maxY = Math.max(this.maxY, y);
+		this.drawn = true;
+	}
+	includeXExtent(value) {
+		this.minX = Math.min(this.minX, value);
+		this.maxX = Math.max(this.maxX, value);
+	}
+	includeYExtent(value) {
+		this.minY = Math.min(this.minY, value);
+		this.maxY = Math.max(this.maxY, value);
+	}
+	markDrawn() {
+		this.drawn = true;
+	}
+};
+const CUBIC_BERNSTEIN_COEFFICIENT = 3;
+const QUADRATIC_FORMULA_COEFFICIENT = 4;
 function cubicAt(p0, p1, p2, p3, t) {
 	const s = 1 - t;
-	return s * s * s * p0 + 3 * s * s * t * p1 + 3 * s * t * t * p2 + t * t * t * p3;
+	return s * s * s * p0 + CUBIC_BERNSTEIN_COEFFICIENT * s * s * t * p1 + CUBIC_BERNSTEIN_COEFFICIENT * s * t * t * p2 + t * t * t * p3;
 }
 function includeCubicAxis(p0, p1, p2, p3, apply) {
 	apply(p0);
 	apply(p3);
-	const a = -p0 + 3 * p1 - 3 * p2 + p3;
+	const a = -p0 + CUBIC_BERNSTEIN_COEFFICIENT * p1 - CUBIC_BERNSTEIN_COEFFICIENT * p2 + p3;
 	const b = 2 * (p0 - 2 * p1 + p2);
 	const c = p1 - p0;
 	const roots = [];
 	if (a === 0) {
 		if (b !== 0) roots.push(-c / b);
 	} else {
-		const discriminant = b * b - 4 * a * c;
+		const discriminant = b * b - QUADRATIC_FORMULA_COEFFICIENT * a * c;
 		if (discriminant >= 0) {
 			const root = Math.sqrt(discriminant);
 			roots.push((-b + root) / (2 * a), (-b - root) / (2 * a));
@@ -92,14 +124,12 @@ function includeCubicAxis(p0, p1, p2, p3, apply) {
 }
 function includeCubic(box, x0, y0, x1, y1, x2, y2, x3, y3) {
 	includeCubicAxis(x0, x1, x2, x3, (value) => {
-		box.minX = Math.min(box.minX, value);
-		box.maxX = Math.max(box.maxX, value);
+		box.includeXExtent(value);
 	});
 	includeCubicAxis(y0, y1, y2, y3, (value) => {
-		box.minY = Math.min(box.minY, value);
-		box.maxY = Math.max(box.maxY, value);
+		box.includeYExtent(value);
 	});
-	box.drawn = true;
+	box.markDrawn();
 }
 function curveTo(state, dx1, dy1, dx2, dy2, dx3, dy3) {
 	const x0 = state.x;
@@ -115,10 +145,10 @@ function curveTo(state, dx1, dy1, dx2, dy2, dx3, dy3) {
 	state.y = y3;
 }
 function lineTo(state, dx, dy) {
-	includePoint(state.box, state.x, state.y);
+	state.box.includePoint(state.x, state.y);
 	state.x += dx;
 	state.y += dy;
-	includePoint(state.box, state.x, state.y);
+	state.box.includePoint(state.x, state.y);
 }
 function moveTo(state, dx, dy) {
 	state.x += dx;
@@ -135,15 +165,15 @@ function readOperand(code, offset) {
 		if (!hasBytes(code, offset + 1, 2)) return;
 		const raw = u16(code, offset + 1);
 		return {
-			value: raw >= 32768 ? raw - 65536 : raw,
-			endOffset: offset + 3
+			value: raw >= INT16_SIGN_BIT ? raw - INT16_MODULUS : raw,
+			endOffset: offset + CS_OPERAND_INT16_TOTAL_LENGTH
 		};
 	}
 	if (b0 === CS_OPERAND_FIXED) {
-		if (!hasBytes(code, offset + 1, 4)) return;
+		if (!hasBytes(code, offset + 1, CS_OPERAND_FIXED_BYTE_LENGTH)) return;
 		return {
 			value: (u32(code, offset + 1) | 0) / FIXED_POINT_SCALE,
-			endOffset: offset + 5
+			endOffset: offset + CS_OPERAND_FIXED_TOTAL_LENGTH
 		};
 	}
 	if (b0 >= CS_OPERAND_SMALL_FIRST && b0 <= CS_OPERAND_SMALL_LAST) return {
@@ -230,20 +260,20 @@ function execute(code, state, context, depth) {
 				break;
 			}
 			case OP_RRCURVETO:
-				for (let k = 0; k + 5 < stack.length; k += 6) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				for (let k = 0; k + CURVE_DY3_OFFSET < stack.length; k += CURVE_ARG_COUNT) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + CURVE_DY2_OFFSET], stack[k + CURVE_DX3_OFFSET], stack[k + CURVE_DY3_OFFSET]);
 				stack.length = 0;
 				break;
 			case OP_RCURVELINE: {
 				let k = 0;
-				for (; k + 5 < stack.length - 2; k += 6) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				for (; k + CURVE_DY3_OFFSET < stack.length - 2; k += CURVE_ARG_COUNT) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + CURVE_DY2_OFFSET], stack[k + CURVE_DX3_OFFSET], stack[k + CURVE_DY3_OFFSET]);
 				if (k + 1 < stack.length) lineTo(state, stack[k], stack[k + 1]);
 				stack.length = 0;
 				break;
 			}
 			case OP_RLINECURVE: {
 				let k = 0;
-				for (; k + 1 < stack.length - 6; k += 2) lineTo(state, stack[k], stack[k + 1]);
-				if (k + 5 < stack.length) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				for (; k + 1 < stack.length - CURVE_ARG_COUNT; k += 2) lineTo(state, stack[k], stack[k + 1]);
+				if (k + CURVE_DY3_OFFSET < stack.length) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + CURVE_DY2_OFFSET], stack[k + CURVE_DX3_OFFSET], stack[k + CURVE_DY3_OFFSET]);
 				stack.length = 0;
 				break;
 			}
@@ -251,14 +281,14 @@ function execute(code, state, context, depth) {
 			case OP_HHCURVETO: {
 				let k = 0;
 				let firstCross = 0;
-				if (stack.length % 4 === 1) {
+				if (stack.length % QUAD_CURVE_ARG_COUNT === 1) {
 					firstCross = stack[0];
 					k = 1;
 				}
-				for (; k + 3 < stack.length; k += 4) {
+				for (; k + QUAD_CURVE_LAST_OFFSET < stack.length; k += QUAD_CURVE_ARG_COUNT) {
 					const cross = k <= 1 ? firstCross : 0;
-					if (b0 === OP_VVCURVETO) curveTo(state, cross, stack[k], stack[k + 1], stack[k + 2], 0, stack[k + 3]);
-					else curveTo(state, stack[k], cross, stack[k + 1], stack[k + 2], stack[k + 3], 0);
+					if (b0 === OP_VVCURVETO) curveTo(state, cross, stack[k], stack[k + 1], stack[k + 2], 0, stack[k + QUAD_CURVE_LAST_OFFSET]);
+					else curveTo(state, stack[k], cross, stack[k + 1], stack[k + 2], stack[k + QUAD_CURVE_LAST_OFFSET], 0);
 				}
 				stack.length = 0;
 				break;
@@ -267,11 +297,11 @@ function execute(code, state, context, depth) {
 			case OP_HVCURVETO: {
 				let horizontal = b0 === OP_HVCURVETO;
 				let k = 0;
-				while (stack.length - k >= 4) {
-					const extra = stack.length - k === 5 ? stack[k + 4] : 0;
-					if (horizontal) curveTo(state, stack[k], 0, stack[k + 1], stack[k + 2], extra, stack[k + 3]);
-					else curveTo(state, 0, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], extra);
-					k += 4;
+				while (stack.length - k >= QUAD_CURVE_ARG_COUNT) {
+					const extra = stack.length - k === QUAD_CURVE_WITH_EXTRA_ARG_COUNT ? stack[k + QUAD_CURVE_ARG_COUNT] : 0;
+					if (horizontal) curveTo(state, stack[k], 0, stack[k + 1], stack[k + 2], extra, stack[k + QUAD_CURVE_LAST_OFFSET]);
+					else curveTo(state, 0, stack[k], stack[k + 1], stack[k + 2], stack[k + QUAD_CURVE_LAST_OFFSET], extra);
+					k += QUAD_CURVE_ARG_COUNT;
 					horizontal = !horizontal;
 				}
 				stack.length = 0;
@@ -306,25 +336,29 @@ function execute(code, state, context, depth) {
 	}
 	return true;
 }
+const FLEX_ARG_COUNT = 13;
+const HFLEX_ARG_COUNT = 7;
+const HFLEX1_ARG_COUNT = 9;
+const FLEX1_ARG_COUNT = 11;
 function executeEscaped(operator, state) {
 	const stack = state.stack;
 	const startY = state.y;
 	if (operator === ESC_FLEX) {
-		if (stack.length < 13) return false;
+		if (stack.length < FLEX_ARG_COUNT) return false;
 		curveTo(state, stack[0], stack[1], stack[2], stack[3], stack[4], stack[5]);
 		curveTo(state, stack[6], stack[7], stack[8], stack[9], stack[10], stack[11]);
 		stack.length = 0;
 		return true;
 	}
 	if (operator === ESC_HFLEX) {
-		if (stack.length < 7) return false;
+		if (stack.length < HFLEX_ARG_COUNT) return false;
 		curveTo(state, stack[0], 0, stack[1], stack[2], stack[3], 0);
 		curveTo(state, stack[4], 0, stack[5], -stack[2], stack[6], 0);
 		stack.length = 0;
 		return true;
 	}
 	if (operator === ESC_HFLEX1) {
-		if (stack.length < 9) return false;
+		if (stack.length < HFLEX1_ARG_COUNT) return false;
 		curveTo(state, stack[0], stack[1], stack[2], stack[3], stack[4], 0);
 		const dy5 = stack[7];
 		curveTo(state, stack[5], 0, stack[6], dy5, stack[8], startY - (state.y + dy5));
@@ -332,7 +366,7 @@ function executeEscaped(operator, state) {
 		return true;
 	}
 	if (operator === ESC_FLEX1) {
-		if (stack.length < 11) return false;
+		if (stack.length < FLEX1_ARG_COUNT) return false;
 		const startX = state.x;
 		let dx = 0;
 		let dy = 0;
@@ -407,13 +441,7 @@ function computeBounds(glyphId, context) {
 		stems: 0,
 		widthParsed: false,
 		operations: 0,
-		box: {
-			minX: Infinity,
-			minY: Infinity,
-			maxX: -Infinity,
-			maxY: -Infinity,
-			drawn: false
-		}
+		box: new BoundsBox()
 	};
 	if (!execute(code, state, context, 0) || !state.box.drawn) return;
 	return {

package/dist/cff.cjs

@@ -12,6 +12,7 @@ const INDEX_COUNT_SIZE = 2;
 const INDEX_OFF_SIZE_SIZE = 1;
 const MIN_OFF_SIZE = 1;
 const MAX_OFF_SIZE = 4;
+const OFF_SIZE_3_BYTES = 3;
 const DICT_OPERATOR_MAX = 21;
 const DICT_OPERATOR_ESCAPE = 12;
 const DICT_OPERAND_INT16 = 28;
@@ -28,6 +29,12 @@ const DICT_OPERAND_MEDIUM_BIAS = 108;
 const DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
 const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
 const BYTE_RADIX = 256;
+const INT16_SIGN_BIT = 32768;
+const UINT16_MODULUS = 65536;
+const DICT_OPERAND_INT16_TOTAL_SIZE = 3;
+const INT32_SIZE_BYTES = 4;
+const DICT_OPERAND_INT32_TOTAL_SIZE = 5;
+const REAL_NIBBLE_DIGIT_MAX = 9;
 const REAL_NIBBLE_DECIMAL_POINT = 10;
 const REAL_NIBBLE_EXPONENT = 11;
 const REAL_NIBBLE_NEGATIVE_EXPONENT = 12;
@@ -39,7 +46,7 @@ const LOW_NIBBLE_MASK = 15;
 function readOffsetAt(bytes, offset, offSize) {
 	if (offSize === 1) return require_sfnt.u8(bytes, offset);
 	if (offSize === 2) return require_sfnt.u16(bytes, offset);
-	if (offSize === 3) return require_sfnt.u24(bytes, offset);
+	if (offSize === OFF_SIZE_3_BYTES) return require_sfnt.u24(bytes, offset);
 	return require_sfnt.u32(bytes, offset);
 }
 function readCffIndex(bytes, offset) {
@@ -80,7 +87,7 @@ function readRealOperand(data, start) {
 				endOffset: i + 1
 			};
 			if (nibble === REAL_NIBBLE_RESERVED) return;
-			if (nibble <= 9) text += String(nibble);
+			if (nibble <= REAL_NIBBLE_DIGIT_MAX) text += String(nibble);
 			else if (nibble === REAL_NIBBLE_DECIMAL_POINT) text += ".";
 			else if (nibble === REAL_NIBBLE_EXPONENT) text += "E";
 			else if (nibble === REAL_NIBBLE_NEGATIVE_EXPONENT) text += "E-";
@@ -109,14 +116,14 @@ function parseCffDict(data) {
 		if (b0 === DICT_OPERAND_INT16) {
 			if (!require_sfnt.hasBytes(data, i + 1, 2)) return;
 			const raw = require_sfnt.u16(data, i + 1);
-			operands.push(raw >= 32768 ? raw - 65536 : raw);
-			i += 3;
+			operands.push(raw >= INT16_SIGN_BIT ? raw - UINT16_MODULUS : raw);
+			i += DICT_OPERAND_INT16_TOTAL_SIZE;
 			continue;
 		}
 		if (b0 === DICT_OPERAND_INT32) {
-			if (!require_sfnt.hasBytes(data, i + 1, 4)) return;
+			if (!require_sfnt.hasBytes(data, i + 1, INT32_SIZE_BYTES)) return;
 			operands.push(require_sfnt.u32(data, i + 1) | 0);
-			i += 5;
+			i += DICT_OPERAND_INT32_TOTAL_SIZE;
 			continue;
 		}
 		if (b0 === DICT_OPERAND_REAL) {

package/dist/cff.js

@@ -11,6 +11,7 @@ const INDEX_COUNT_SIZE = 2;
 const INDEX_OFF_SIZE_SIZE = 1;
 const MIN_OFF_SIZE = 1;
 const MAX_OFF_SIZE = 4;
+const OFF_SIZE_3_BYTES = 3;
 const DICT_OPERATOR_MAX = 21;
 const DICT_OPERATOR_ESCAPE = 12;
 const DICT_OPERAND_INT16 = 28;
@@ -27,6 +28,12 @@ const DICT_OPERAND_MEDIUM_BIAS = 108;
 const DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
 const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
 const BYTE_RADIX = 256;
+const INT16_SIGN_BIT = 32768;
+const UINT16_MODULUS = 65536;
+const DICT_OPERAND_INT16_TOTAL_SIZE = 3;
+const INT32_SIZE_BYTES = 4;
+const DICT_OPERAND_INT32_TOTAL_SIZE = 5;
+const REAL_NIBBLE_DIGIT_MAX = 9;
 const REAL_NIBBLE_DECIMAL_POINT = 10;
 const REAL_NIBBLE_EXPONENT = 11;
 const REAL_NIBBLE_NEGATIVE_EXPONENT = 12;
@@ -38,7 +45,7 @@ const LOW_NIBBLE_MASK = 15;
 function readOffsetAt(bytes, offset, offSize) {
 	if (offSize === 1) return u8(bytes, offset);
 	if (offSize === 2) return u16(bytes, offset);
-	if (offSize === 3) return u24(bytes, offset);
+	if (offSize === OFF_SIZE_3_BYTES) return u24(bytes, offset);
 	return u32(bytes, offset);
 }
 function readCffIndex(bytes, offset) {
@@ -79,7 +86,7 @@ function readRealOperand(data, start) {
 				endOffset: i + 1
 			};
 			if (nibble === REAL_NIBBLE_RESERVED) return;
-			if (nibble <= 9) text += String(nibble);
+			if (nibble <= REAL_NIBBLE_DIGIT_MAX) text += String(nibble);
 			else if (nibble === REAL_NIBBLE_DECIMAL_POINT) text += ".";
 			else if (nibble === REAL_NIBBLE_EXPONENT) text += "E";
 			else if (nibble === REAL_NIBBLE_NEGATIVE_EXPONENT) text += "E-";
@@ -108,14 +115,14 @@ function parseCffDict(data) {
 		if (b0 === DICT_OPERAND_INT16) {
 			if (!hasBytes(data, i + 1, 2)) return;
 			const raw = u16(data, i + 1);
-			operands.push(raw >= 32768 ? raw - 65536 : raw);
-			i += 3;
+			operands.push(raw >= INT16_SIGN_BIT ? raw - UINT16_MODULUS : raw);
+			i += DICT_OPERAND_INT16_TOTAL_SIZE;
 			continue;
 		}
 		if (b0 === DICT_OPERAND_INT32) {
-			if (!hasBytes(data, i + 1, 4)) return;
+			if (!hasBytes(data, i + 1, INT32_SIZE_BYTES)) return;
 			operands.push(u32(data, i + 1) | 0);
-			i += 5;
+			i += DICT_OPERAND_INT32_TOTAL_SIZE;
 			continue;
 		}
 		if (b0 === DICT_OPERAND_REAL) {

package/dist/cmap-table.cjs

@@ -4,17 +4,28 @@ const require_sfnt = require("./sfnt.cjs");
 const CMAP_HEADER_SIZE = 4;
 const SUBTABLE_RECORD_SIZE = 8;
 const MAX_UNICODE_CODE_POINT = 1114111;
+const SUBTABLE_RECORD_OFFSET_FIELD = 4;
+const CMAP_FORMAT_4 = 4;
+const CMAP_FORMAT_6 = 6;
+const CMAP_FORMAT_12 = 12;
+const INT16_SIGN_BIT = 32768;
+const UINT16_MODULUS = 65536;
+const UINT16_MASK = 65535;
 const FORMAT_4_HEADER_SIZE = 14;
+const FORMAT_4_SEG_COUNT_X2_FIELD = 6;
+const FORMAT_4_PARALLEL_ARRAY_COUNT = 4;
+const MAX_BMP_CODE_POINT = 65535;
+const LAST_MAPPABLE_BMP_CODE = 65534;
 function parseFormat4(bytes, subtableOffset) {
 	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_4_HEADER_SIZE)) return;
-	const segCountX2 = require_sfnt.u16(bytes, subtableOffset + 6);
+	const segCountX2 = require_sfnt.u16(bytes, subtableOffset + FORMAT_4_SEG_COUNT_X2_FIELD);
 	if (segCountX2 === 0 || segCountX2 % 2 !== 0) return;
 	const segCount = segCountX2 / 2;
 	const endCodesOffset = subtableOffset + FORMAT_4_HEADER_SIZE;
 	const startCodesOffset = endCodesOffset + segCountX2 + 2;
 	const idDeltasOffset = startCodesOffset + segCountX2;
 	const idRangeOffsetsOffset = idDeltasOffset + segCountX2;
-	if (!require_sfnt.hasBytes(bytes, endCodesOffset, segCountX2 * 4 + 2)) return;
+	if (!require_sfnt.hasBytes(bytes, endCodesOffset, segCountX2 * FORMAT_4_PARALLEL_ARRAY_COUNT + 2)) return;
 	const segments = [];
 	for (let i = 0; i < segCount; i++) {
 		const idRangeOffsetPos = idRangeOffsetsOffset + i * 2;
@@ -22,27 +33,27 @@ function parseFormat4(bytes, subtableOffset) {
 		segments.push({
 			endCode: require_sfnt.u16(bytes, endCodesOffset + i * 2),
 			startCode: require_sfnt.u16(bytes, startCodesOffset + i * 2),
-			idDelta: rawDelta >= 32768 ? rawDelta - 65536 : rawDelta,
+			idDelta: rawDelta >= INT16_SIGN_BIT ? rawDelta - UINT16_MODULUS : rawDelta,
 			idRangeOffsetPos,
 			idRangeOffset: require_sfnt.u16(bytes, idRangeOffsetPos)
 		});
 	}
 	const lookup = (codePoint) => {
-		if (codePoint > 65535) return;
+		if (codePoint > MAX_BMP_CODE_POINT) return;
 		for (const segment of segments) {
 			if (codePoint < segment.startCode || codePoint > segment.endCode) continue;
-			if (segment.idRangeOffset === 0) return codePoint + segment.idDelta & 65535;
+			if (segment.idRangeOffset === 0) return codePoint + segment.idDelta & UINT16_MASK;
 			const glyphIndexAddress = segment.idRangeOffsetPos + segment.idRangeOffset + (codePoint - segment.startCode) * 2;
 			if (!require_sfnt.hasBytes(bytes, glyphIndexAddress, 2)) return;
 			const glyphId = require_sfnt.u16(bytes, glyphIndexAddress);
-			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & 65535;
+			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & UINT16_MASK;
 		}
 	};
 	return {
 		lookup,
 		forEachMapping(visit) {
 			for (const segment of segments) {
-				const end = Math.min(segment.endCode, 65534);
+				const end = Math.min(segment.endCode, LAST_MAPPABLE_BMP_CODE);
 				for (let code = segment.startCode; code <= end; code++) {
 					const glyphId = lookup(code);
 					if (glyphId !== void 0 && glyphId !== 0) visit(code, glyphId);
@@ -52,10 +63,13 @@ function parseFormat4(bytes, subtableOffset) {
 	};
 }
 const FORMAT_12_HEADER_SIZE = 16;
+const FORMAT_12_NUM_GROUPS_FIELD = 12;
 const FORMAT_12_GROUP_SIZE = 12;
+const FORMAT_12_GROUP_END_CHAR_CODE_FIELD = 4;
+const FORMAT_12_GROUP_START_GLYPH_ID_FIELD = 8;
 function parseFormat12(bytes, subtableOffset) {
 	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_12_HEADER_SIZE)) return;
-	const numGroups = require_sfnt.u32(bytes, subtableOffset + 12);
+	const numGroups = require_sfnt.u32(bytes, subtableOffset + FORMAT_12_NUM_GROUPS_FIELD);
 	const groupsOffset = subtableOffset + FORMAT_12_HEADER_SIZE;
 	if (!require_sfnt.hasBytes(bytes, groupsOffset, numGroups * FORMAT_12_GROUP_SIZE)) return;
 	const groups = [];
@@ -63,8 +77,8 @@ function parseFormat12(bytes, subtableOffset) {
 		const recordOffset = groupsOffset + i * FORMAT_12_GROUP_SIZE;
 		groups.push({
 			startCharCode: require_sfnt.u32(bytes, recordOffset),
-			endCharCode: require_sfnt.u32(bytes, recordOffset + 4),
-			startGlyphId: require_sfnt.u32(bytes, recordOffset + 8)
+			endCharCode: require_sfnt.u32(bytes, recordOffset + FORMAT_12_GROUP_END_CHAR_CODE_FIELD),
+			startGlyphId: require_sfnt.u32(bytes, recordOffset + FORMAT_12_GROUP_START_GLYPH_ID_FIELD)
 		});
 	}
 	return {
@@ -80,18 +94,20 @@ function parseFormat12(bytes, subtableOffset) {
 	};
 }
 const FORMAT_0_SIZE = 262;
+const FORMAT_0_GLYPH_ID_ARRAY_OFFSET = 6;
+const MAX_FORMAT_0_CODE = 255;
 function parseFormat0(bytes, subtableOffset) {
 	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_0_SIZE)) return;
-	const glyphIdArrayOffset = subtableOffset + 6;
+	const glyphIdArrayOffset = subtableOffset + FORMAT_0_GLYPH_ID_ARRAY_OFFSET;
 	const lookup = (codePoint) => {
-		if (codePoint < 0 || codePoint > 255) return;
+		if (codePoint < 0 || codePoint > MAX_FORMAT_0_CODE) return;
 		const glyphId = require_sfnt.u8(bytes, glyphIdArrayOffset + codePoint);
 		return glyphId === 0 ? void 0 : glyphId;
 	};
 	return {
 		lookup,
 		forEachMapping(visit) {
-			for (let code = 0; code <= 255; code++) {
+			for (let code = 0; code <= MAX_FORMAT_0_CODE; code++) {
 				const glyphId = lookup(code);
 				if (glyphId !== void 0) visit(code, glyphId);
 			}
@@ -99,10 +115,12 @@ function parseFormat0(bytes, subtableOffset) {
 	};
 }
 const FORMAT_6_HEADER_SIZE = 10;
+const FORMAT_6_FIRST_CODE_FIELD = 6;
+const FORMAT_6_ENTRY_COUNT_FIELD = 8;
 function parseFormat6(bytes, subtableOffset) {
 	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_6_HEADER_SIZE)) return;
-	const firstCode = require_sfnt.u16(bytes, subtableOffset + 6);
-	const entryCount = require_sfnt.u16(bytes, subtableOffset + 8);
+	const firstCode = require_sfnt.u16(bytes, subtableOffset + FORMAT_6_FIRST_CODE_FIELD);
+	const entryCount = require_sfnt.u16(bytes, subtableOffset + FORMAT_6_ENTRY_COUNT_FIELD);
 	const glyphIdArrayOffset = subtableOffset + FORMAT_6_HEADER_SIZE;
 	if (!require_sfnt.hasBytes(bytes, glyphIdArrayOffset, entryCount * 2)) return;
 	const lookup = (codePoint) => {
@@ -122,19 +140,29 @@ function parseFormat6(bytes, subtableOffset) {
 		}
 	};
 }
+const PLATFORM_WINDOWS = 3;
+const PLATFORM_UNICODE = 0;
+const ENCODING_WINDOWS_UCS4 = 10;
+const ENCODING_WINDOWS_UNICODE_BMP = 1;
+const RANK_WINDOWS_UCS4_FORMAT_12 = 0;
+const RANK_UNICODE_FORMAT_12 = 1;
+const RANK_OTHER_FORMAT_12 = 2;
+const RANK_WINDOWS_BMP_FORMAT_4 = 3;
+const RANK_OTHER_FORMAT_4 = 4;
+const RANK_FORMAT_6 = 5;
 function preferenceRank(subtable) {
-	if (subtable.format === 12) {
-		if (subtable.platformId === 3 && subtable.encodingId === 10) return 0;
-		if (subtable.platformId === 0) return 1;
-		return 2;
+	if (subtable.format === CMAP_FORMAT_12) {
+		if (subtable.platformId === PLATFORM_WINDOWS && subtable.encodingId === ENCODING_WINDOWS_UCS4) return RANK_WINDOWS_UCS4_FORMAT_12;
+		if (subtable.platformId === PLATFORM_UNICODE) return RANK_UNICODE_FORMAT_12;
+		return RANK_OTHER_FORMAT_12;
 	}
-	if (subtable.format === 4) return subtable.platformId === 3 && subtable.encodingId === 1 ? 3 : 4;
-	return 5;
+	if (subtable.format === CMAP_FORMAT_4) return subtable.platformId === PLATFORM_WINDOWS && subtable.encodingId === ENCODING_WINDOWS_UNICODE_BMP ? RANK_WINDOWS_BMP_FORMAT_4 : RANK_OTHER_FORMAT_4;
+	return RANK_FORMAT_6;
 }
 function parseSubtable(bytes, record) {
-	if (record.format === 12) return parseFormat12(bytes, record.offset);
-	if (record.format === 4) return parseFormat4(bytes, record.offset);
-	if (record.format === 6) return parseFormat6(bytes, record.offset);
+	if (record.format === CMAP_FORMAT_12) return parseFormat12(bytes, record.offset);
+	if (record.format === CMAP_FORMAT_4) return parseFormat4(bytes, record.offset);
+	if (record.format === CMAP_FORMAT_6) return parseFormat6(bytes, record.offset);
 	return record.format === 0 ? parseFormat0(bytes, record.offset) : void 0;
 }
 function readCmapSubtables(font) {
@@ -145,7 +173,7 @@ function readCmapSubtables(font) {
 	const subtables = [];
 	for (let i = 0; i < numTables; i++) {
 		const recordOffset = CMAP_HEADER_SIZE + i * SUBTABLE_RECORD_SIZE;
-		const offset = require_sfnt.u32(cmapBytes, recordOffset + 4);
+		const offset = require_sfnt.u32(cmapBytes, recordOffset + SUBTABLE_RECORD_OFFSET_FIELD);
 		if (!require_sfnt.hasBytes(cmapBytes, offset, 2)) continue;
 		const record = {
 			platformId: require_sfnt.u16(cmapBytes, recordOffset),
@@ -164,7 +192,7 @@ function readCmapSubtables(font) {
 	return subtables;
 }
 function buildCmapLookup(font) {
-	return readCmapSubtables(font).filter((s) => s.format === 4 || s.format === 6 || s.format === 12).sort((a, b) => preferenceRank(a) - preferenceRank(b))[0]?.lookup;
+	return readCmapSubtables(font).filter((s) => s.format === CMAP_FORMAT_4 || s.format === CMAP_FORMAT_6 || s.format === CMAP_FORMAT_12).sort((a, b) => preferenceRank(a) - preferenceRank(b))[0]?.lookup;
 }
 //#endregion
 exports.buildCmapLookup = buildCmapLookup;