ag-psd 31.0.1 → 31.0.2

package/src/imageResources.ts

@@ -38,7 +38,9 @@ const MEASUREMENT_UNITS = [undefined, 'Inches', 'Centimeters', 'Points', 'Picas'
 const hex = '0123456789abcdef';
 
 function charToNibble(code: number) {
-	return code <= 57 ? code - 48 : code - 87;
+	if (code <= 57) return code - 48; // '0'-'9'
+	if (code >= 97) return code - 87; // 'a'-'f'
+	return code - 55; // 'A'-'F'
 }
 
 function byteAt(value: string, index: number) {
@@ -68,11 +70,13 @@ function readEncodedString(reader: PsdReader) {
 	}
 
 	if (notAscii) {
-		const decoder = new TextDecoder('gbk');
-		return decoder.decode(buffer)
-	} else {
-		return decodeString(buffer);
+		try {
+			const decoder = new TextDecoder('gbk');
+			return decoder.decode(buffer)
+		} catch { }
 	}
+
+	return decodeString(buffer);
 }
 
 function writeEncodedString(writer: PsdWriter, value: string) {
@@ -1397,7 +1401,7 @@ MOCK_HANDLERS && addHandler(
 	},
 );
 
-const FrmD = createEnum<'auto' | 'none' | 'dispose'>('FrmD', '', {
+const FrmD = createEnum<'auto' | 'none' | 'dispose'>('FrmD', 'auto', {
 	auto: 'Auto',
 	none: 'None',
 	dispose: 'Disp',

package/src/jpeg.ts

@@ -24,7 +24,6 @@ interface DecodedComponent {
 interface Decoded {
   width: number;
   height: number;
-  comments: string[];
   exifBuffer: Uint8Array | undefined;
   jfif: any;
   adobe: any;
@@ -623,7 +622,6 @@ function parse(data: Uint8Array) {
   const self: Decoded = {
     width: 0,
     height: 0,
-    comments: [],
     adobe: undefined,
     components: [],
     exifBuffer: undefined,
@@ -731,11 +729,12 @@ function parse(data: Uint8Array) {
         const appData = readDataBlock();
 
         if (fileMarker === 0xFFFE) {
-          let comment = '';
-          for (let ii = 0; ii < appData.byteLength; ii++) {
-            comment += String.fromCharCode(appData[ii]);
-          }
-          self.comments.push(comment);
+          // ignore comments
+          // let comment = '';
+          // for (let ii = 0; ii < appData.byteLength; ii++) {
+          //   comment += String.fromCharCode(appData[ii]);
+          // }
+          // self.comments.push(comment);
         }
 
         if (fileMarker === 0xFFE0) {
@@ -1125,6 +1124,19 @@ export function decodeJpeg(encoded: Uint8Array, createImageData: (width: number,
         }
       }
       break;
+    case 2:
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const Y = data[i++];
+          const A = data[i++];
+
+          imageDataArray[j++] = Y;
+          imageDataArray[j++] = Y;
+          imageDataArray[j++] = Y;
+          imageDataArray[j++] = A;
+        }
+      }
+      break;
     case 3:
       for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {

package/src/psd.ts

@@ -2,7 +2,7 @@ export type BlendMode = 'pass through' | 'normal' | 'dissolve' | 'darken' | 'mul
 	'color burn' | 'linear burn' | 'darker color' | 'lighten' | 'screen' | 'color dodge' |
 	'linear dodge' | 'lighter color' | 'overlay' | 'soft light' | 'hard light' |
 	'vivid light' | 'linear light' | 'pin light' | 'hard mix' | 'difference' | 'exclusion' |
-	'subtract' | 'divide' | 'hue' | 'saturation' | 'color' | 'luminosity';
+	'subtract' | 'divide' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'linear height' | 'height' | 'subtraction';
 
 export const enum ColorMode {
 	Bitmap = 0,
@@ -10,6 +10,8 @@ export const enum ColorMode {
 	Indexed = 2,
 	RGB = 3,
 	CMYK = 4,
+	// 5
+	// 6
 	Multichannel = 7,
 	Duotone = 8,
 	Lab = 9,
@@ -183,7 +185,7 @@ export interface EffectNoiseGradient {
 	name: string;
 	type: 'noise';
 	roughness?: number;
-	colorModel?: 'rgb' | 'hsb' | 'lab';
+	colorModel?: 'rgb' | 'hsb' | 'lab' | 'hsl';
 	randomSeed?: number;
 	restrictColors?: boolean;
 	addTransparency?: boolean;

package/src/psdReader.ts

@@ -10,7 +10,7 @@ interface ChannelInfo {
 }
 
 export const supportedColorModes = [ColorMode.Bitmap, ColorMode.Grayscale, ColorMode.RGB, ColorMode.Indexed];
-const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', 'multichannel', 'duotone', 'lab'];
+const colorModes = ['bitmap', 'grayscale', 'indexed', 'RGB', 'CMYK', '', '', 'multichannel', 'duotone', 'lab'];
 
 function setupGrayscale(data: PixelData) {
 	const size = data.width * data.height * 4;
@@ -234,7 +234,9 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 	Object.assign(reader, readOptions);
 	reader.large = version === 2;
 	reader.globalAlpha = false;
-	if (!reader.totalMemoryLimit) reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
+	if (!('totalMemoryLimit' in reader)) { // setting totalMemoryLimit to undefined explicitly disables memory limit
+		reader.totalMemoryLimit = 2 * 1024 * 1024 * 1024; // default 2GB memory limit
+	}
 
 	// color mode data
 	readSection(reader, 1, left => {
@@ -287,7 +289,7 @@ export function readPsd(reader: PsdReader, readOptions: ReadOptions = {}) {
 
 	const { layersGroup, layerGroupsEnabledId, ...rest } = imageResources;
 
-	if (Object.keys(rest)) {
+	if (Object.keys(rest).length) {
 		psd.imageResources = rest;
 	}
 
@@ -408,6 +410,7 @@ function readLayerRecord(reader: PsdReader, psd: Psd, imageResources: InternalIm
 	layer.left = readInt32(reader);
 	layer.bottom = readInt32(reader);
 	layer.right = readInt32(reader);
+	if (!isValidBoxSize(layer, reader)) throw new Error('Invalid layer size');
 
 	const channelCount = readUint16(reader);
 	const channels: ChannelInfo[] = [];
@@ -461,6 +464,13 @@ function readLayerRecord(reader: PsdReader, psd: Psd, imageResources: InternalIm
 	return { layer, channels };
 }
 
+function isValidBoxSize(box: { top?: number; left?: number; bottom?: number; right?: number; }, reader: PsdReader) {
+	const width = (box.right || 0) - (box.left || 0);
+	const height = (box.bottom || 0) - (box.top || 0);
+	const maxSize = reader.large ? 300000 : 30000;
+	return width >= 0 && height >= 0 && width <= maxSize && height <= maxSize;
+}
+
 function readLayerMaskData(reader: PsdReader, layer: Layer) {
 	return readSection<LayerMaskData | undefined>(reader, 1, left => {
 		if (!left()) return undefined;
@@ -472,6 +482,8 @@ function readLayerMaskData(reader: PsdReader, layer: Layer) {
 		mask.left = readInt32(reader);
 		mask.bottom = readInt32(reader);
 		mask.right = readInt32(reader);
+		if (!isValidBoxSize(mask, reader)) throw new Error('Invalid mask size');
+
 		mask.defaultColor = readUint8(reader);
 
 		const flags = readUint8(reader);
@@ -493,6 +505,7 @@ function readLayerMaskData(reader: PsdReader, layer: Layer) {
 			realMask.left = readInt32(reader);
 			realMask.bottom = readInt32(reader);
 			realMask.right = readInt32(reader);
+			if (!isValidBoxSize(realMask, reader)) throw new Error('Invalid realMask size');
 		}
 
 		if (flags & LayerMaskFlags.MaskHasParametersAppliedToIt) {
@@ -668,8 +681,8 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 	if (!layer.rawData) return undefined;
 
 	const { colorMode, bitsPerChannel, channels, large } = layer.rawData;
-	const layerWidth = (layer.right || 0) - (layer.left || 0);
-	const layerHeight = (layer.bottom || 0) - (layer.top || 0);
+	const layerWidth = Math.max(0, (layer.right || 0) - (layer.left || 0));
+	const layerHeight = Math.max(0, (layer.bottom || 0) - (layer.top || 0));
 	const cmyk = colorMode === ColorMode.CMYK;
 
 	let imageData: PixelData | undefined;
@@ -702,9 +715,8 @@ function getDataFromLayer(layer: Layer, read: LayerDataType, throwForMissingFeat
 			const mask = id === ChannelID.UserMask ? layer.mask : layer.realMask;
 			if (!mask) throw new Error(`Missing layer ${id === ChannelID.UserMask ? 'mask' : 'real mask'} data`);
 
-			const maskWidth = (mask.right || 0) - (mask.left || 0);
-			const maskHeight = (mask.bottom || 0) - (mask.top || 0);
-			if (maskWidth < 0 || maskHeight < 0 || maskWidth > 30000 || maskHeight > 30000) throw new Error('Invalid mask size');
+			const maskWidth = Math.max(0, (mask.right || 0) - (mask.left || 0));
+			const maskHeight = Math.max(0, (mask.bottom || 0) - (mask.top || 0));
 
 			if (maskWidth && maskHeight) {
 				maskData = createImageDataBitDepth(maskWidth, maskHeight, bitsPerChannel, 4, memoryLimit);
@@ -1174,6 +1186,7 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 	let lengths: Uint16Array | Uint32Array;
 
 	if (large) {
+		consumeMemory(reader, offsets.length * height * 4);
 		lengths = new Uint32Array(offsets.length * height);
 
 		for (let o = 0, li = 0; o < offsets.length; o++) {
@@ -1182,6 +1195,7 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 			}
 		}
 	} else {
+		consumeMemory(reader, offsets.length * height * 2);
 		lengths = new Uint16Array(offsets.length * height);
 
 		for (let o = 0, li = 0; o < offsets.length; o++) {
@@ -1234,6 +1248,8 @@ export function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined,
 			}
 		}
 	}
+
+	recoverMemory(reader, lengths.byteLength);
 }
 
 export function readSection<T>(
@@ -1357,7 +1373,9 @@ export function readPattern(reader: PsdReader): PatternInfo {
 	const channelsCount = readUint32(reader);
 	const width = right - left;
 	const height = bottom - top;
-	const data = new Uint8Array(width * height * 4);
+	const size = width * height * 4;
+	consumeMemory(reader, size);
+	const data = new Uint8Array(size);
 
 	for (let i = 3; i < data.byteLength; i += 4) {
 		data[i] = 255;
@@ -1423,6 +1441,8 @@ export function readPattern(reader: PsdReader): PatternInfo {
 				if (reader.throwForMissingFeatures) throw new Error('Invalid color pattern');
 			}
 		} else if (compressionMode === 1) {
+			consumeMemory(reader, w * h);
+
 			const pixelData: PixelData = { data, width, height };
 			const tempData: PixelData = { data: new Uint8Array(w * h), width: w, height: h };
 			const cdataReader = createReader(cdata.buffer, cdata.byteOffset, cdata.byteLength);
@@ -1442,6 +1462,8 @@ export function readPattern(reader: PsdReader): PatternInfo {
 				// TODO:
 				throw new Error('Indexed pattern color mode not implemented');
 			}
+
+			recoverMemory(reader, w * h);
 		} else {
 			throw new Error('Invalid pattern compression mode');
 		}
@@ -1468,3 +1490,16 @@ function copyChannelToRGBA(srcData: PixelData, dstData: PixelData, ox: number, o
 		}
 	}
 }
+
+function consumeMemory(reader: PsdReader, size: number) {
+	if (reader.totalMemoryLimit !== undefined) {
+		if (reader.totalMemoryLimit < size) throw new Error('Exceeded memory limit');
+		reader.totalMemoryLimit -= size;
+	}
+}
+
+function recoverMemory(reader: PsdReader, size: number) {
+	if (reader.totalMemoryLimit !== undefined) {
+		reader.totalMemoryLimit += size;
+	}
+}

package/src/psdWriter.ts

@@ -157,8 +157,16 @@ function getLargestLayerSize(layers: Layer[] = []): number {
 	let max = 0;
 
 	for (const layer of layers) {
-		if (layer.canvas || layer.imageData) {
-			const { width, height } = getLayerDimentions(layer);
+		const { width, height } = getLayerDimentions(layer);
+		max = Math.max(max, 2 * height + 2 * width * height);
+
+		if (layer.mask) {
+			const { width, height } = getLayerDimentions(layer.mask);
+			max = Math.max(max, 2 * height + 2 * width * height);
+		}
+
+		if (layer.realMask) {
+			const { width, height } = getLayerDimentions(layer.realMask);
 			max = Math.max(max, 2 * height + 2 * width * height);
 		}
 
@@ -472,7 +480,7 @@ function writeGlobalLayerMaskInfo(writer: PsdWriter, info: GlobalLayerMaskInfo |
 			writeUint16(writer, info.colorSpace2);
 			writeUint16(writer, info.colorSpace3);
 			writeUint16(writer, info.colorSpace4);
-			writeUint16(writer, info.opacity * 0xff);
+			writeUint16(writer, Math.round(info.opacity * 0xff));
 			writeUint8(writer, info.kind);
 			writeZeros(writer, 3);
 		}

package/src/utf8.ts

@@ -1,168 +1,178 @@
-function charLengthInBytes(code: number): number {
-	if ((code & 0xffffff80) === 0) {
-		return 1;
-	} else if ((code & 0xfffff800) === 0) {
-		return 2;
-	} else if ((code & 0xffff0000) === 0) {
-		return 3;
-	} else {
-		return 4;
-	}
-}
-
-export function stringLengthInBytes(value: string): number {
-	let result = 0;
-
-	for (let i = 0; i < value.length; i++) {
-		const code = value.charCodeAt(i);
-
-		// high surrogate
-		if (code >= 0xd800 && code <= 0xdbff) {
-			if ((i + 1) < value.length) {
-				const extra = value.charCodeAt(i + 1);
-
-				// low surrogate
-				if ((extra & 0xfc00) === 0xdc00) {
-					i++;
-					result += charLengthInBytes(((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-				}
-			}
-		} else {
-			result += charLengthInBytes(code);
-		}
-	}
-
-	return result;
-}
-
-function writeCharacter(buffer: Uint8Array | Buffer, offset: number, code: number): number {
-	const length = charLengthInBytes(code);
-
-	switch (length) {
-		case 1:
-			buffer[offset] = code;
-			break;
-		case 2:
-			buffer[offset] = ((code >> 6) & 0x1f) | 0xc0;
-			buffer[offset + 1] = (code & 0x3f) | 0x80;
-			break;
-		case 3:
-			buffer[offset] = ((code >> 12) & 0x0f) | 0xe0;
-			buffer[offset + 1] = ((code >> 6) & 0x3f) | 0x80;
-			buffer[offset + 2] = (code & 0x3f) | 0x80;
-			break;
-		default:
-			buffer[offset] = ((code >> 18) & 0x07) | 0xf0;
-			buffer[offset + 1] = ((code >> 12) & 0x3f) | 0x80;
-			buffer[offset + 2] = ((code >> 6) & 0x3f) | 0x80;
-			buffer[offset + 3] = (code & 0x3f) | 0x80;
-			break;
-	}
-
-	return length;
-}
-
-export function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number {
-	for (let i = 0; i < value.length; i++) {
-		const code = value.charCodeAt(i);
-
-		// high surrogate
-		if (code >= 0xd800 && code <= 0xdbff) {
-			if ((i + 1) < value.length) {
-				const extra = value.charCodeAt(i + 1);
-
-				// low surrogate
-				if ((extra & 0xfc00) === 0xdc00) {
-					i++;
-					const fullCode = ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-					offset += writeCharacter(buffer, offset, fullCode);
-				}
-			}
-		} else {
-			offset += writeCharacter(buffer, offset, code);
-		}
-	}
-
-	return offset;
-}
-
-export function encodeString(value: string): Uint8Array {
-	if (value.length > 1000 && typeof TextEncoder !== 'undefined') {
-		return (new TextEncoder()).encode(value);
-	}
-
-	const buffer = new Uint8Array(stringLengthInBytes(value));
-	encodeStringTo(buffer, 0, value);
-	return buffer;
-}
-
-function continuationByte(buffer: Uint8Array, index: number): number {
-	if (index >= buffer.length) {
-		throw Error('Invalid byte index');
-	}
-
-	const continuationByte = buffer[index];
-
-	if ((continuationByte & 0xC0) === 0x80) {
-		return continuationByte & 0x3F;
-	} else {
-		throw Error('Invalid continuation byte');
-	}
-}
-
-export function decodeString(value: Uint8Array): string {
-	if (value.byteLength > 1000 && typeof TextDecoder !== 'undefined') {
-		return (new TextDecoder()).decode(value);
-	}
-
-	let result: string[] = [];
-
-	for (let i = 0; i < value.length;) {
-		const byte1 = value[i++];
-		let code: number;
-
-		if ((byte1 & 0x80) === 0) {
-			code = byte1;
-		} else if ((byte1 & 0xe0) === 0xc0) {
-			const byte2 = continuationByte(value, i++);
-			code = ((byte1 & 0x1f) << 6) | byte2;
-
-			if (code < 0x80) {
-				throw Error('Invalid continuation byte');
-			}
-		} else if ((byte1 & 0xf0) === 0xe0) {
-			const byte2 = continuationByte(value, i++);
-			const byte3 = continuationByte(value, i++);
-			code = ((byte1 & 0x0f) << 12) | (byte2 << 6) | byte3;
-
-			if (code < 0x0800) {
-				throw Error('Invalid continuation byte');
-			}
-
-			if (code >= 0xd800 && code <= 0xdfff) {
-				throw Error(`Lone surrogate U+${code.toString(16).toUpperCase()} is not a scalar value`);
-			}
-		} else if ((byte1 & 0xf8) === 0xf0) {
-			const byte2 = continuationByte(value, i++);
-			const byte3 = continuationByte(value, i++);
-			const byte4 = continuationByte(value, i++);
-			code = ((byte1 & 0x0f) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
-
-			if (code < 0x010000 || code > 0x10ffff) {
-				throw Error('Invalid continuation byte');
-			}
-		} else {
-			throw Error('Invalid UTF-8 detected');
-		}
-
-		if (code > 0xffff) {
-			code -= 0x10000;
-			result.push(String.fromCharCode(code >>> 10 & 0x3ff | 0xd800));
-			code = 0xdc00 | code & 0x3ff;
-		}
-
-		result.push(String.fromCharCode(code));
-	}
-
-	return result.join('');
-}
+function charLengthInBytes(code: number): number {
+	if ((code & 0xffffff80) === 0) {
+		return 1;
+	} else if ((code & 0xfffff800) === 0) {
+		return 2;
+	} else if ((code & 0xffff0000) === 0) {
+		return 3;
+	} else {
+		return 4;
+	}
+}
+
+// Reads a scalar value at index `i`, replacing unpaired surrogates with U+FFFD,
+// matching how TextEncoder converts a string to a sequence of Unicode scalar values.
+function codePointAt(value: string, i: number): { code: number; size: number } {
+	const code = value.charCodeAt(i);
+
+	// high surrogate
+	if (code >= 0xd800 && code <= 0xdbff && (i + 1) < value.length) {
+		const extra = value.charCodeAt(i + 1);
+
+		// low surrogate
+		if (extra >= 0xdc00 && extra <= 0xdfff) {
+			return { code: ((code & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000, size: 2 };
+		}
+	}
+
+	// unpaired surrogate (lone high or lone low)
+	if (code >= 0xd800 && code <= 0xdfff) {
+		return { code: 0xfffd, size: 1 };
+	}
+
+	return { code, size: 1 };
+}
+
+export function stringLengthInBytes(value: string): number {
+	let result = 0;
+
+	for (let i = 0; i < value.length;) {
+		const { code, size } = codePointAt(value, i);
+		result += charLengthInBytes(code);
+		i += size;
+	}
+
+	return result;
+}
+
+function writeCharacter(buffer: Uint8Array | Buffer, offset: number, code: number): number {
+	const length = charLengthInBytes(code);
+
+	switch (length) {
+		case 1:
+			buffer[offset] = code;
+			break;
+		case 2:
+			buffer[offset] = ((code >> 6) & 0x1f) | 0xc0;
+			buffer[offset + 1] = (code & 0x3f) | 0x80;
+			break;
+		case 3:
+			buffer[offset] = ((code >> 12) & 0x0f) | 0xe0;
+			buffer[offset + 1] = ((code >> 6) & 0x3f) | 0x80;
+			buffer[offset + 2] = (code & 0x3f) | 0x80;
+			break;
+		default:
+			buffer[offset] = ((code >> 18) & 0x07) | 0xf0;
+			buffer[offset + 1] = ((code >> 12) & 0x3f) | 0x80;
+			buffer[offset + 2] = ((code >> 6) & 0x3f) | 0x80;
+			buffer[offset + 3] = (code & 0x3f) | 0x80;
+			break;
+	}
+
+	return length;
+}
+
+export function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number {
+	for (let i = 0; i < value.length;) {
+		const { code, size } = codePointAt(value, i);
+		offset += writeCharacter(buffer, offset, code);
+		i += size;
+	}
+
+	return offset;
+}
+
+export function encodeString(value: string): Uint8Array {
+	if (value.length > 1000 && typeof TextEncoder !== 'undefined') {
+		return (new TextEncoder()).encode(value);
+	}
+
+	const buffer = new Uint8Array(stringLengthInBytes(value));
+	encodeStringTo(buffer, 0, value);
+	return buffer;
+}
+
+// UTF-8 decoder implementing the WHATWG Encoding Standard's non-fatal error handling,
+// so malformed byte sequences are replaced with U+FFFD instead of throwing, matching TextDecoder.
+export function decodeString(value: Uint8Array): string {
+	if (value.byteLength > 1000 && typeof TextDecoder !== 'undefined') {
+		return (new TextDecoder()).decode(value);
+	}
+
+	const result: string[] = [];
+
+	function pushCodePoint(code: number) {
+		if (code > 0xffff) {
+			code -= 0x10000;
+			result.push(String.fromCharCode((code >>> 10 & 0x3ff) | 0xd800));
+			code = 0xdc00 | (code & 0x3ff);
+		}
+
+		result.push(String.fromCharCode(code));
+	}
+
+	let codePoint = 0;
+	let bytesSeen = 0;
+	let bytesNeeded = 0;
+	let lowerBoundary = 0x80;
+	let upperBoundary = 0xbf;
+
+	for (let i = 0; i < value.length; i++) {
+		const byte = value[i];
+
+		if (bytesNeeded === 0) {
+			if (byte <= 0x7f) {
+				pushCodePoint(byte);
+			} else if (byte >= 0xc2 && byte <= 0xdf) {
+				bytesNeeded = 1;
+				codePoint = byte & 0x1f;
+			} else if (byte >= 0xe0 && byte <= 0xef) {
+				if (byte === 0xe0) lowerBoundary = 0xa0;
+				if (byte === 0xed) upperBoundary = 0x9f;
+				bytesNeeded = 2;
+				codePoint = byte & 0x0f;
+			} else if (byte >= 0xf0 && byte <= 0xf4) {
+				if (byte === 0xf0) lowerBoundary = 0x90;
+				if (byte === 0xf4) upperBoundary = 0x8f;
+				bytesNeeded = 3;
+				codePoint = byte & 0x07;
+			} else {
+				// invalid leading byte
+				pushCodePoint(0xfffd);
+			}
+
+			continue;
+		}
+
+		if (byte < lowerBoundary || byte > upperBoundary) {
+			// invalid continuation byte: emit replacement and reprocess this byte as a new sequence start
+			codePoint = 0;
+			bytesNeeded = 0;
+			bytesSeen = 0;
+			lowerBoundary = 0x80;
+			upperBoundary = 0xbf;
+			pushCodePoint(0xfffd);
+			i--;
+			continue;
+		}
+
+		lowerBoundary = 0x80;
+		upperBoundary = 0xbf;
+		codePoint = (codePoint << 6) | (byte & 0x3f);
+		bytesSeen++;
+
+		if (bytesSeen !== bytesNeeded) continue;
+
+		pushCodePoint(codePoint);
+		codePoint = 0;
+		bytesNeeded = 0;
+		bytesSeen = 0;
+	}
+
+	// truncated sequence at end of input
+	if (bytesNeeded !== 0) {
+		pushCodePoint(0xfffd);
+	}
+
+	return result.join('');
+}