diff --git a/assets/js/bitstring.mjs b/assets/js/bitstring.mjs index 40168b7a9..d80dd9937 100644 --- a/assets/js/bitstring.mjs +++ b/assets/js/bitstring.mjs @@ -247,6 +247,27 @@ export default class Bitstring { } } + // Decodes a UTF-8 sequence starting at the given position. + // Returns the decoded Unicode code point value. + // bytes: Uint8Array containing the UTF-8 encoded data + // start: byte index where the sequence begins + // length: number of bytes in the UTF-8 sequence (1-4) + static decodeUtf8CodePoint(bytes, start, length) { + if (length === 1) return bytes[start]; + + // First byte masks: 2-byte=0x1f, 3-byte=0x0f, 4-byte=0x07 + const firstByteMasks = {2: 0x1f, 3: 0x0f, 4: 0x07}; + + let codePoint = bytes[start] & firstByteMasks[length]; + + // Process continuation bytes (all use 0x3f mask, shift by 6 each) + for (let i = 1; i < length; i++) { + codePoint = (codePoint << 6) | (bytes[start + i] & 0x3f); + } + + return codePoint; + } + static fromBits(bits) { const bitCount = bits.length; const byteCount = Math.ceil(bitCount / 8); @@ -572,6 +593,69 @@ export default class Bitstring { return bitstring.text !== false; } + // Validates that a code point is within UTF-8 rules: + // - Not an overlong encoding (using more bytes than necessary) + // - Not a UTF-16 surrogate (U+D800–U+DFFF) + // - Not above maximum Unicode (U+10FFFF) + static isValidUtf8CodePoint(codePoint, encodingLength) { + // Check for overlong encodings (security issue) + const minValueForLength = {1: 0, 2: 0x80, 3: 0x800, 4: 0x10000}; + + // Reject code points that could have been encoded with fewer bytes (overlong) + if (codePoint < minValueForLength[encodingLength]) return false; + // Reject UTF-16 surrogates (U+D800–U+DFFF) + if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; + // Reject code points beyond Unicode range (> U+10FFFF) + if (codePoint > 0x10ffff) return false; + + return true; + } + + // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). + static isValidUtf8ContinuationByte(byte) { + return (byte & 0xc0) === 0x80; + } + + // Validates a UTF-8 sequence at the given position assuming the leader byte + // has already been confirmed valid for `length` (e.g. via getUtf8SequenceLength). + // Checks: sufficient bytes, valid continuation bytes, and valid code point. + // Precondition: `length` is the value returned by getUtf8SequenceLength(bytes[start]). + static isValidUtf8Sequence(bytes, start, length) { + // Check if we have enough bytes + if (start + length > bytes.length) return false; + + // Verify all continuation bytes have correct pattern (10xxxxxx) + for (let i = 1; i < length; i++) { + if (!$.isValidUtf8ContinuationByte(bytes[start + i])) return false; + } + + // Decode and validate the code point value + const codePoint = $.decodeUtf8CodePoint(bytes, start, length); + + return $.isValidUtf8CodePoint(codePoint, length); + } + + // Checks if there's a truncated (incomplete) UTF-8 sequence at the given position. + // Returns true if bytes could be a valid prefix of a UTF-8 sequence. + // bytes: Uint8Array containing UTF-8 encoded data + // start: byte index to check for truncation + static isTruncatedUtf8Sequence(bytes, start) { + const leaderByte = bytes[start]; + const expectedLength = $.getUtf8SequenceLength(leaderByte); + + if (expectedLength === false) return false; + + const availableBytes = bytes.length - start; + if (availableBytes >= expectedLength) return false; + + // Check all available continuation bytes + for (let i = 1; i < availableBytes; i++) { + if (!$.isValidUtf8ContinuationByte(bytes[start + i])) return false; + } + + return true; + } + static maybeResolveHex(bitstring) { if (bitstring.hex === null) { $.maybeSetBytesFromText(bitstring); diff --git a/assets/js/erlang/unicode.mjs b/assets/js/erlang/unicode.mjs index 8479f3528..a433c4ff0 100644 --- a/assets/js/erlang/unicode.mjs +++ b/assets/js/erlang/unicode.mjs @@ -95,101 +95,20 @@ const Erlang_Unicode = { // and rejecting overlong encodings, surrogates, and out-of-range values. // Time complexity: O(n) where n is the number of bytes. const findValidUtf8Length = (bytes) => { - // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). - const isValidContinuation = (byte) => (byte & 0xc0) === 0x80; - - // Decodes a UTF-8 sequence starting at the given position. - // Returns the decoded Unicode code point value. - const decodeCodePoint = (start, length) => { - if (length === 1) { - return bytes[start]; - } - - if (length === 2) { - return ((bytes[start] & 0x1f) << 6) | (bytes[start + 1] & 0x3f); - } - - if (length === 3) { - return ( - ((bytes[start] & 0x0f) << 12) | - ((bytes[start + 1] & 0x3f) << 6) | - (bytes[start + 2] & 0x3f) - ); - } - - // length === 4 - return ( - ((bytes[start] & 0x07) << 18) | - ((bytes[start + 1] & 0x3f) << 12) | - ((bytes[start + 2] & 0x3f) << 6) | - (bytes[start + 3] & 0x3f) - ); - }; - - // Validates that a code point is within UTF-8 rules: - // - Not an overlong encoding (using more bytes than necessary) - // - Not a UTF-16 surrogate (U+D800–U+DFFF) - // - Not above maximum Unicode (U+10FFFF) - const isValidCodePoint = (codePoint, encodingLength) => { - // Check for overlong encodings (security issue) - const minValueForLength = [0, 0, 0x80, 0x800, 0x10000]; - if (codePoint < minValueForLength[encodingLength]) return false; - - // Reject UTF-16 surrogates (U+D800–U+DFFF) - if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; - - // Reject code points beyond Unicode range (> U+10FFFF) - if (codePoint > 0x10ffff) return false; - - return true; - }; - - // Validates a complete UTF-8 sequence at the given position. - // Checks: sufficient bytes, valid continuations, and valid code point. - const isValidSequence = (start, length) => { - // Check if we have enough bytes - if (start + length > bytes.length) return false; - - // Verify all continuation bytes have correct pattern (10xxxxxx) - for (let i = 1; i < length; i++) { - if (!isValidContinuation(bytes[start + i])) return false; - } - - // Decode and validate the code point value - const codePoint = decodeCodePoint(start, length); - - return isValidCodePoint(codePoint, length); - }; - - // Checks if there's a truncated (incomplete) sequence at position. - // Returns true if bytes could be a valid prefix of a UTF-8 sequence. - const isTruncatedSequence = (start) => { - const leaderByte = bytes[start]; - const expectedLength = Bitstring.getUtf8SequenceLength(leaderByte); - - if (expectedLength === false) return false; - - const availableBytes = bytes.length - start; - if (availableBytes >= expectedLength) return false; - - // Check all available continuation bytes - for (let i = 1; i < availableBytes; i++) { - if (!isValidContinuation(bytes[start + i])) return false; - } - - return true; - }; - - // Main loop: scan forward, validating each sequence + // Scan forward, validating each sequence let pos = 0; while (pos < bytes.length) { const seqLength = Bitstring.getUtf8SequenceLength(bytes[pos]); - if (seqLength === false || !isValidSequence(pos, seqLength)) break; + if ( + seqLength === false || + !Bitstring.isValidUtf8Sequence(bytes, pos, seqLength) + ) + break; pos += seqLength; } - return {validLength: pos, isTruncated: isTruncatedSequence(pos)}; + return pos; }; // Converts a binary to a list of codepoints. @@ -221,7 +140,7 @@ const Erlang_Unicode = { const handleInvalidUtf8FromBinary = (invalidBinary) => { Bitstring.maybeSetBytesFromText(invalidBinary); const bytes = invalidBinary.bytes ?? new Uint8Array(0); - const {validLength, isTruncated} = findValidUtf8Length(bytes); + const validLength = findValidUtf8Length(bytes); const validPrefix = Bitstring.fromBytes(bytes.slice(0, validLength)); const invalidRest = Bitstring.fromBytes(bytes.slice(validLength)); @@ -229,6 +148,8 @@ const Erlang_Unicode = { const codepoints = validLength > 0 ? convertBinaryToCodepoints(validPrefix) : []; + const isTruncated = Bitstring.isTruncatedUtf8Sequence(bytes, validLength); + if (isTruncated) { return createIncompleteTuple(codepoints, invalidRest); } @@ -248,7 +169,8 @@ const Erlang_Unicode = { // Check if it's a truncated sequence Bitstring.maybeSetBytesFromText(invalidBinary); const bytes = invalidBinary.bytes ?? new Uint8Array(0); - const {isTruncated} = findValidUtf8Length(bytes); + const validLength = findValidUtf8Length(bytes); + const isTruncated = Bitstring.isTruncatedUtf8Sequence(bytes, validLength); if (isTruncated) { // Incomplete: rest is the binary directly (not wrapped in list) @@ -384,78 +306,16 @@ const Erlang_Unicode = { // and rejecting overlong encodings, surrogates, and out-of-range values. // Time complexity: O(n) where n is the number of bytes. const findValidUtf8Length = (bytes) => { - // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). - const isValidContinuation = (byte) => (byte & 0xc0) === 0x80; - - // Decodes a UTF-8 sequence starting at the given position. - // Returns the decoded Unicode code point value. - const decodeCodePoint = (start, length) => { - if (length === 1) { - return bytes[start]; - } - - if (length === 2) { - return ((bytes[start] & 0x1f) << 6) | (bytes[start + 1] & 0x3f); - } - - if (length === 3) { - return ( - ((bytes[start] & 0x0f) << 12) | - ((bytes[start + 1] & 0x3f) << 6) | - (bytes[start + 2] & 0x3f) - ); - } - - // length === 4 - return ( - ((bytes[start] & 0x07) << 18) | - ((bytes[start + 1] & 0x3f) << 12) | - ((bytes[start + 2] & 0x3f) << 6) | - (bytes[start + 3] & 0x3f) - ); - }; - - // Validates that a code point is within UTF-8 rules: - // - Not an overlong encoding (using more bytes than necessary) - // - Not a UTF-16 surrogate (U+D800–U+DFFF) - // - Not above maximum Unicode (U+10FFFF) - const isValidCodePoint = (codePoint, encodingLength) => { - // Check for overlong encodings (security issue) - const minValueForLength = [0, 0, 0x80, 0x800, 0x10000]; - if (codePoint < minValueForLength[encodingLength]) return false; - - // Reject UTF-16 surrogates (U+D800–U+DFFF) - if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; - - // Reject code points beyond Unicode range (> U+10FFFF) - if (codePoint > 0x10ffff) return false; - - return true; - }; - - // Validates a complete UTF-8 sequence at the given position. - // Checks: sufficient bytes, valid continuations, and valid code point. - const isValidSequence = (start, length) => { - // Check if we have enough bytes - if (start + length > bytes.length) return false; - - // Verify all continuation bytes have correct pattern (10xxxxxx) - for (let i = 1; i < length; i++) { - if (!isValidContinuation(bytes[start + i])) return false; - } - - // Decode and validate the code point value - const codePoint = decodeCodePoint(start, length); - - return isValidCodePoint(codePoint, length); - }; - - // Main loop: scan forward, validating each sequence + // Scan forward, validating each sequence let pos = 0; while (pos < bytes.length) { const seqLength = Bitstring.getUtf8SequenceLength(bytes[pos]); - if (seqLength === false || !isValidSequence(pos, seqLength)) break; + if ( + seqLength === false || + !Bitstring.isValidUtf8Sequence(bytes, pos, seqLength) + ) + break; pos += seqLength; } @@ -700,76 +560,16 @@ const Erlang_Unicode = { // and rejecting overlong encodings, surrogates, and out-of-range values. // Time complexity: O(n) where n is the number of bytes. const findValidUtf8Length = (bytes) => { - // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). - const isValidContinuation = (byte) => (byte & 0xc0) === 0x80; - - // Decodes a UTF-8 sequence starting at the given position. - // Returns the decoded Unicode code point value. - const decodeCodePoint = (start, length) => { - if (length === 1) { - return bytes[start]; - } - - if (length === 2) { - return ((bytes[start] & 0x1f) << 6) | (bytes[start + 1] & 0x3f); - } - - if (length === 3) { - return ( - ((bytes[start] & 0x0f) << 12) | - ((bytes[start + 1] & 0x3f) << 6) | - (bytes[start + 2] & 0x3f) - ); - } - // length === 4 - return ( - ((bytes[start] & 0x07) << 18) | - ((bytes[start + 1] & 0x3f) << 12) | - ((bytes[start + 2] & 0x3f) << 6) | - (bytes[start + 3] & 0x3f) - ); - }; - - // Validates that a code point is within UTF-8 rules: - // - Not an overlong encoding (using more bytes than necessary) - // - Not a UTF-16 surrogate (U+D800–U+DFFF) - // - Not above maximum Unicode (U+10FFFF) - const isValidCodePoint = (codePoint, encodingLength) => { - // Check for overlong encodings (security issue) - const minValueForLength = [0, 0, 0x80, 0x800, 0x10000]; - if (codePoint < minValueForLength[encodingLength]) return false; - - // Reject UTF-16 surrogates (U+D800–U+DFFF) - if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; - - // Reject code points beyond Unicode range (> U+10FFFF) - if (codePoint > 0x10ffff) return false; - - return true; - }; - - // Validates a complete UTF-8 sequence at the given position. - // Checks: sufficient bytes, valid continuations, and valid code point. - const isValidSequence = (start, length) => { - // Check if we have enough bytes - if (start + length > bytes.length) return false; - - // Verify all continuation bytes have correct pattern (10xxxxxx) - for (let i = 1; i < length; i++) { - if (!isValidContinuation(bytes[start + i])) return false; - } - - // Decode and validate the code point value - const codePoint = decodeCodePoint(start, length); - - return isValidCodePoint(codePoint, length); - }; - - // Main loop: scan forward, validating each sequence + // Scan forward, validating each sequence let pos = 0; + while (pos < bytes.length) { const seqLength = Bitstring.getUtf8SequenceLength(bytes[pos]); - if (seqLength === false || !isValidSequence(pos, seqLength)) break; + if ( + seqLength === false || + !Bitstring.isValidUtf8Sequence(bytes, pos, seqLength) + ) + break; pos += seqLength; } @@ -867,76 +667,16 @@ const Erlang_Unicode = { // and rejecting overlong encodings, surrogates, and out-of-range values. // Time complexity: O(n) where n is the number of bytes. const findValidUtf8Length = (bytes) => { - // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). - const isValidContinuation = (byte) => (byte & 0xc0) === 0x80; - - // Decodes a UTF-8 sequence starting at the given position. - // Returns the decoded Unicode code point value. - const decodeCodePoint = (start, length) => { - if (length === 1) { - return bytes[start]; - } - - if (length === 2) { - return ((bytes[start] & 0x1f) << 6) | (bytes[start + 1] & 0x3f); - } - - if (length === 3) { - return ( - ((bytes[start] & 0x0f) << 12) | - ((bytes[start + 1] & 0x3f) << 6) | - (bytes[start + 2] & 0x3f) - ); - } - - // length === 4 - return ( - ((bytes[start] & 0x07) << 18) | - ((bytes[start + 1] & 0x3f) << 12) | - ((bytes[start + 2] & 0x3f) << 6) | - (bytes[start + 3] & 0x3f) - ); - }; - - // Validates that a code point is within UTF-8 rules: - // - Not an overlong encoding (using more bytes than necessary) - // - Not a UTF-16 surrogate (U+D800–U+DFFF) - // - Not above maximum Unicode (U+10FFFF) - const isValidCodePoint = (codePoint, encodingLength) => { - // Check for overlong encodings (security issue) - const minValueForLength = [0, 0, 0x80, 0x800, 0x10000]; - if (codePoint < minValueForLength[encodingLength]) return false; - - // Reject UTF-16 surrogates (U+D800–U+DFFF) - if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; - - // Reject code points beyond Unicode range (> U+10FFFF) - if (codePoint > 0x10ffff) return false; - - return true; - }; - - // Validates a complete UTF-8 sequence at the given position. - // Checks: sufficient bytes, valid continuations, and valid code point. - const isValidSequence = (start, length) => { - // Check if we have enough bytes - if (start + length > bytes.length) return false; - - // Verify all continuation bytes have correct pattern (10xxxxxx) - for (let i = 1; i < length; i++) { - if (!isValidContinuation(bytes[start + i])) return false; - } - - // Decode and validate the code point value - const codePoint = decodeCodePoint(start, length); - return isValidCodePoint(codePoint, length); - }; - - // Main loop: scan forward, validating each sequence + // scan forward, validating each sequence let pos = 0; + while (pos < bytes.length) { const seqLength = Bitstring.getUtf8SequenceLength(bytes[pos]); - if (seqLength === false || !isValidSequence(pos, seqLength)) break; + if ( + seqLength === false || + !Bitstring.isValidUtf8Sequence(bytes, pos, seqLength) + ) + break; pos += seqLength; } @@ -1033,79 +773,15 @@ const Erlang_Unicode = { // and rejecting overlong encodings, surrogates, and out-of-range values. // Time complexity: O(n) where n is the number of bytes. const findValidUtf8Length = (bytes) => { - // Checks if a byte is a valid UTF-8 continuation byte (10xxxxxx). - const isValidContinuation = (byte) => (byte & 0xc0) === 0x80; - - // Decodes a UTF-8 sequence starting at the given position. - // Returns the decoded Unicode code point value. - const decodeCodePoint = (start, length) => { - if (length === 1) { - return bytes[start]; - } - - if (length === 2) { - return ((bytes[start] & 0x1f) << 6) | (bytes[start + 1] & 0x3f); - } - - if (length === 3) { - return ( - ((bytes[start] & 0x0f) << 12) | - ((bytes[start + 1] & 0x3f) << 6) | - (bytes[start + 2] & 0x3f) - ); - } - - // length === 4 - return ( - ((bytes[start] & 0x07) << 18) | - ((bytes[start + 1] & 0x3f) << 12) | - ((bytes[start + 2] & 0x3f) << 6) | - (bytes[start + 3] & 0x3f) - ); - }; - - // Validates that a code point is within UTF-8 rules: - // - Not an overlong encoding (using more bytes than necessary) - // - Not a UTF-16 surrogate (U+D800–U+DFFF) - // - Not above maximum Unicode (U+10FFFF) - const isValidCodePoint = (codePoint, encodingLength) => { - // Check for overlong encodings (security issue) - const minValueForLength = [0, 0, 0x80, 0x800, 0x10000]; - if (codePoint < minValueForLength[encodingLength]) return false; - - // Reject UTF-16 surrogates (U+D800–U+DFFF) - if (codePoint >= 0xd800 && codePoint <= 0xdfff) return false; - - // Reject code points beyond Unicode range (> U+10FFFF) - if (codePoint > 0x10ffff) return false; - - return true; - }; - - // Validates a complete UTF-8 sequence at the given position. - // Checks: sufficient bytes, valid continuations, and valid code point. - const isValidSequence = (start, length) => { - // Check if we have enough bytes - if (start + length > bytes.length) return false; - - // Verify all continuation bytes have correct pattern (10xxxxxx) - for (let i = 1; i < length; i++) { - if (!isValidContinuation(bytes[start + i])) { - return false; - } - } - - // Decode and validate the code point value - const codePoint = decodeCodePoint(start, length); - - return isValidCodePoint(codePoint, length); - }; - - // Main loop: scan forward, validating each sequence + // Scan forward, validating each sequence let pos = 0; while (pos < bytes.length) { const seqLength = Bitstring.getUtf8SequenceLength(bytes[pos]); - if (seqLength === false || !isValidSequence(pos, seqLength)) break; + if ( + seqLength === false || + !Bitstring.isValidUtf8Sequence(bytes, pos, seqLength) + ) + break; pos += seqLength; } diff --git a/test/javascript/bitstring_test.mjs b/test/javascript/bitstring_test.mjs index d822d1ffa..dd371b89b 100644 --- a/test/javascript/bitstring_test.mjs +++ b/test/javascript/bitstring_test.mjs @@ -1231,6 +1231,43 @@ describe("Bitstring", () => { }); }); + describe("decodeUtf8CodePoint()", () => { + it("decodes 1-byte UTF-8 sequence (ASCII)", () => { + // 'A' = 0x41 = U+0041 + const bytes = new Uint8Array([0x41]); + const codePoint = Bitstring.decodeUtf8CodePoint(bytes, 0, 1); + assert.equal(codePoint, 0x41); + }); + + it("decodes 2-byte UTF-8 sequence", () => { + // '£' = 0xC2 0xA3 = U+00A3 (pound sign) + const bytes = new Uint8Array([0xc2, 0xa3]); + const codePoint = Bitstring.decodeUtf8CodePoint(bytes, 0, 2); + assert.equal(codePoint, 0xa3); + }); + + it("decodes 3-byte UTF-8 sequence", () => { + // '€' = 0xE2 0x82 0xAC = U+20AC (euro sign) + const bytes = new Uint8Array([0xe2, 0x82, 0xac]); + const codePoint = Bitstring.decodeUtf8CodePoint(bytes, 0, 3); + assert.equal(codePoint, 0x20ac); + }); + + it("decodes 4-byte UTF-8 sequence", () => { + // '𐍈' = 0xF0 0x90 0x8D 0x88 = U+10348 (Gothic letter hwair) + const bytes = new Uint8Array([0xf0, 0x90, 0x8d, 0x88]); + const codePoint = Bitstring.decodeUtf8CodePoint(bytes, 0, 4); + assert.equal(codePoint, 0x10348); + }); + + it("decodes from non-zero start position", () => { + // Test decoding '£' starting at position 2 + const bytes = new Uint8Array([0x41, 0x42, 0xc2, 0xa3]); + const codePoint = Bitstring.decodeUtf8CodePoint(bytes, 2, 2); + assert.equal(codePoint, 0xa3); + }); + }); + describe("fromBits()", () => { it("empty", () => { const result = Bitstring.fromBits([]); @@ -5227,6 +5264,185 @@ describe("Bitstring", () => { }); }); + describe("isTruncatedUtf8Sequence()", () => { + // Happy path: truncated 2-byte sequence + it("returns true for truncated 2-byte sequence with valid continuation byte", () => { + // 0xC2 requires 2 bytes, but only 1 byte available (0x80 is valid continuation) + const bytes = new Uint8Array([0xc2]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), true); + }); + + // Happy path: truncated 3-byte sequence + it("returns true for truncated 3-byte sequence with valid continuation bytes", () => { + // 0xE2 requires 3 bytes, but only 2 bytes available (both valid continuations) + const bytes = new Uint8Array([0xe2, 0x82]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), true); + }); + + // Happy path: truncated 4-byte sequence + it("returns true for truncated 4-byte sequence with valid continuation bytes", () => { + // 0xF0 requires 4 bytes, but only 3 bytes available (all valid continuations) + const bytes = new Uint8Array([0xf0, 0x90, 0x8d]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), true); + }); + + // Edge case: start position in middle of data + it("returns true for truncated sequence starting at non-zero position", () => { + // Valid ASCII prefix, then truncated 2-byte sequence + const bytes = new Uint8Array([0x41, 0xc2]); // 'A' + truncated '£' + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 1), true); + }); + + // Edge case: multiple valid continuation bytes before truncation + it("returns true for 4-byte sequence with 2 valid continuation bytes (truncated)", () => { + // 0xF0 (4-byte) with 2 valid continuation bytes available + const bytes = new Uint8Array([0xf0, 0x90, 0x8d]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), true); + }); + + // False path: invalid leader byte + it("returns false for invalid leader byte", () => { + // 0xC0 is invalid (overlong encoding marker) + const bytes = new Uint8Array([0xc0]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + + // False path: invalid leader byte (out of range) + it("returns false for leader byte >= 0xF5", () => { + // 0xF5 and above are invalid (> U+10FFFF) + const bytes = new Uint8Array([0xf5]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + + // False path: enough bytes available + it("returns false when enough bytes are available for complete sequence", () => { + // 0xC2 requires 2 bytes, and 2 bytes are available + const bytes = new Uint8Array([0xc2, 0xa3]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + + // False path: invalid continuation byte in truncated sequence + it("returns false when continuation byte is invalid", () => { + // 0xC2 requires 2 bytes, but only 1 available with invalid continuation (0x00) + const bytes = new Uint8Array([0xc2, 0x00]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + + // False path: ASCII byte + it("returns false for ASCII byte (1-byte sequence)", () => { + // ASCII bytes are 1-byte sequences, always complete + const bytes = new Uint8Array([0x41]); // 'A' + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + + // False path: truncated sequence with invalid continuation at end + it("returns false when truncated sequence has invalid continuation byte at start", () => { + // 0xE2 requires 3 bytes, 2 available, but second byte (0x00) is invalid continuation + const bytes = new Uint8Array([0xe2, 0x00]); + assert.equal(Bitstring.isTruncatedUtf8Sequence(bytes, 0), false); + }); + }); + + describe("isValidUtf8CodePoint()", () => { + it("valid codepoint", () => { + assert.isTrue(Bitstring.isValidUtf8CodePoint(0x41, 1)); // ASCII 'A' + assert.isTrue(Bitstring.isValidUtf8CodePoint(0xa9, 2)); // © (copyright) + assert.isTrue(Bitstring.isValidUtf8CodePoint(0x20ac, 3)); // € (euro) + assert.isTrue(Bitstring.isValidUtf8CodePoint(0x10348, 4)); // 𐍈 (Gothic letter) + assert.isTrue(Bitstring.isValidUtf8CodePoint(0x10ffff, 4)); // Maximum valid Unicode + }); + + it("overlong encoding (codepoint too small for encoding length)", () => { + // 'A' (0x41) must use 1 byte, not 2 + assert.isFalse(Bitstring.isValidUtf8CodePoint(0x41, 2)); + // 0x7FF requires 2 bytes, but attempting 3-byte encoding + assert.isFalse(Bitstring.isValidUtf8CodePoint(0x7ff, 3)); + // 0xFFFF requires 3 bytes, but attempting 4-byte encoding + assert.isFalse(Bitstring.isValidUtf8CodePoint(0xffff, 4)); + }); + + it("UTF-16 surrogate (U+D800–U+DFFF)", () => { + assert.isFalse(Bitstring.isValidUtf8CodePoint(0xd800, 3)); // Start of surrogate range + assert.isFalse(Bitstring.isValidUtf8CodePoint(0xdc00, 3)); // Middle of surrogate range + assert.isFalse(Bitstring.isValidUtf8CodePoint(0xdfff, 3)); // End of surrogate range + }); + + it("beyond Unicode range (> U+10FFFF)", () => { + assert.isFalse(Bitstring.isValidUtf8CodePoint(0x110000, 4)); + assert.isFalse(Bitstring.isValidUtf8CodePoint(0x200000, 4)); + }); + }); + + describe("isValidUtf8ContinuationByte()", () => { + it("valid continuation byte (10xxxxxx pattern)", () => { + assert.isTrue(Bitstring.isValidUtf8ContinuationByte(0x80)); // 10000000 + assert.isTrue(Bitstring.isValidUtf8ContinuationByte(0xbf)); // 10111111 + }); + + it("invalid continuation byte (not 10xxxxxx pattern)", () => { + assert.isFalse(Bitstring.isValidUtf8ContinuationByte(0x00)); // 00000000 (ASCII) + assert.isFalse(Bitstring.isValidUtf8ContinuationByte(0x7f)); // 01111111 (ASCII) + assert.isFalse(Bitstring.isValidUtf8ContinuationByte(0xc0)); // 11000000 (2-byte start) + assert.isFalse(Bitstring.isValidUtf8ContinuationByte(0xff)); // 11111111 (invalid) + }); + }); + + describe("isValidUtf8Sequence()", () => { + it("valid 1-byte sequence (ASCII)", () => { + // ASCII 'A' + const bytes = new Uint8Array([0x41]); + assert.isTrue(Bitstring.isValidUtf8Sequence(bytes, 0, 1)); + }); + + it("valid 2-byte sequence", () => { + // é (U+00E9): 0xC3 0xA9 + const bytes = new Uint8Array([0xc3, 0xa9]); + assert.isTrue(Bitstring.isValidUtf8Sequence(bytes, 0, 2)); + }); + + it("valid 3-byte sequence", () => { + // € (U+20AC): 0xE2 0x82 0xAC + const bytes = new Uint8Array([0xe2, 0x82, 0xac]); + assert.isTrue(Bitstring.isValidUtf8Sequence(bytes, 0, 3)); + }); + + it("valid 4-byte sequence", () => { + // 𐍈 (U+10348): 0xF0 0x90 0x8D 0x88 + const bytes = new Uint8Array([0xf0, 0x90, 0x8d, 0x88]); + assert.isTrue(Bitstring.isValidUtf8Sequence(bytes, 0, 4)); + }); + + it("not enough bytes available", () => { + const bytes = new Uint8Array([0xc3, 0xa9]); // 2 bytes + // Try to validate 3-byte sequence starting at position 0 + assert.isFalse(Bitstring.isValidUtf8Sequence(bytes, 0, 3)); + }); + + it("invalid continuation byte", () => { + // 0xC3 starts a 2-byte sequence, but 0x41 (ASCII 'A') is not a valid continuation + const bytes = new Uint8Array([0xc3, 0x41]); + assert.isFalse(Bitstring.isValidUtf8Sequence(bytes, 0, 2)); + }); + + it("overlong encoding", () => { + // 'A' (0x41) encoded as 2-byte sequence: 0xC1 0x81 (overlong) + const bytes = new Uint8Array([0xc1, 0x81]); + assert.isFalse(Bitstring.isValidUtf8Sequence(bytes, 0, 2)); + }); + + it("UTF-16 surrogate", () => { + // U+D800 (surrogate) encoded as 3-byte sequence: 0xED 0xA0 0x80 + const bytes = new Uint8Array([0xed, 0xa0, 0x80]); + assert.isFalse(Bitstring.isValidUtf8Sequence(bytes, 0, 3)); + }); + + it("beyond Unicode range", () => { + // U+110000 (beyond max) encoded as 4-byte sequence: 0xF4 0x90 0x80 0x80 + const bytes = new Uint8Array([0xf4, 0x90, 0x80, 0x80]); + assert.isFalse(Bitstring.isValidUtf8Sequence(bytes, 0, 4)); + }); + }); + describe("maybeResolveHex()", () => { it("when hex field is already set", () => { const bitstring = Type.bitstring("Hologram");