@withtruing/companion 0.13.3 → 0.14.1

package/dist/whole-read/decode.js

@@ -0,0 +1,234 @@
+const continuation = (value) => value !== undefined && value >= 0x80 && value <= 0xbf;
+function parseUtf8(bytes, startByte) {
+    const characterByteOffsets = [startByte];
+    const characterCodeUnitOffsets = [0];
+    let byte = startByte;
+    let codeUnit = 0;
+    while (byte < bytes.byteLength) {
+        const first = bytes[byte];
+        let width;
+        let codeUnits = 1;
+        if (first <= 0x7f)
+            width = 1;
+        else if (first >= 0xc2 && first <= 0xdf && continuation(bytes[byte + 1]))
+            width = 2;
+        else if (first === 0xe0 && (bytes[byte + 1] ?? 0) >= 0xa0 && (bytes[byte + 1] ?? 0) <= 0xbf
+            && continuation(bytes[byte + 2]))
+            width = 3;
+        else if (first >= 0xe1 && first <= 0xec && continuation(bytes[byte + 1]) && continuation(bytes[byte + 2]))
+            width = 3;
+        else if (first === 0xed && (bytes[byte + 1] ?? 0) >= 0x80 && (bytes[byte + 1] ?? 0) <= 0x9f
+            && continuation(bytes[byte + 2]))
+            width = 3;
+        else if (first >= 0xee && first <= 0xef && continuation(bytes[byte + 1]) && continuation(bytes[byte + 2]))
+            width = 3;
+        else if (first === 0xf0 && (bytes[byte + 1] ?? 0) >= 0x90 && (bytes[byte + 1] ?? 0) <= 0xbf
+            && continuation(bytes[byte + 2]) && continuation(bytes[byte + 3])) {
+            width = 4;
+            codeUnits = 2;
+        }
+        else if (first >= 0xf1 && first <= 0xf3 && continuation(bytes[byte + 1])
+            && continuation(bytes[byte + 2]) && continuation(bytes[byte + 3])) {
+            width = 4;
+            codeUnits = 2;
+        }
+        else if (first === 0xf4 && (bytes[byte + 1] ?? 0) >= 0x80 && (bytes[byte + 1] ?? 0) <= 0x8f
+            && continuation(bytes[byte + 2]) && continuation(bytes[byte + 3])) {
+            width = 4;
+            codeUnits = 2;
+        }
+        else
+            return null;
+        byte += width;
+        codeUnit += codeUnits;
+        characterByteOffsets.push(byte);
+        characterCodeUnitOffsets.push(codeUnit);
+    }
+    return {
+        text: new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes.subarray(startByte)),
+        characterByteOffsets,
+        characterCodeUnitOffsets,
+    };
+}
+const readCodeUnit = (bytes, byte, littleEndian) => littleEndian
+    ? bytes[byte] | (bytes[byte + 1] << 8)
+    : (bytes[byte] << 8) | bytes[byte + 1];
+function parseUtf16(bytes, startByte, littleEndian) {
+    if ((bytes.byteLength - startByte) % 2 !== 0)
+        return null;
+    const characterByteOffsets = [startByte];
+    const characterCodeUnitOffsets = [0];
+    let byte = startByte;
+    let codeUnitOffset = 0;
+    while (byte < bytes.byteLength) {
+        const first = readCodeUnit(bytes, byte, littleEndian);
+        let width = 2;
+        let codeUnits = 1;
+        if (first >= 0xd800 && first <= 0xdbff) {
+            if (byte + 3 >= bytes.byteLength)
+                return null;
+            const second = readCodeUnit(bytes, byte + 2, littleEndian);
+            if (second < 0xdc00 || second > 0xdfff)
+                return null;
+            width = 4;
+            codeUnits = 2;
+        }
+        else if (first >= 0xdc00 && first <= 0xdfff)
+            return null;
+        byte += width;
+        codeUnitOffset += codeUnits;
+        characterByteOffsets.push(byte);
+        characterCodeUnitOffsets.push(codeUnitOffset);
+    }
+    return {
+        text: new TextDecoder(littleEndian ? 'utf-16le' : 'utf-16be', { fatal: true, ignoreBOM: true })
+            .decode(bytes.subarray(startByte)),
+        characterByteOffsets,
+        characterCodeUnitOffsets,
+    };
+}
+function linesFor(text, byteOffsets) {
+    if (text.length === 0)
+        return [];
+    const lines = [];
+    let lineStart = 0;
+    let character = 0;
+    let previousWasCr = false;
+    for (const value of text) {
+        if (value === '\n') {
+            const contentEnd = previousWasCr ? character - 1 : character;
+            lines.push({
+                lineNumber: lines.length + 1,
+                startCharacter: lineStart,
+                contentEndCharacter: contentEnd,
+                endCharacter: character + 1,
+                startByte: byteOffsets[lineStart],
+                contentEndByte: byteOffsets[contentEnd],
+                endByte: byteOffsets[character + 1],
+            });
+            lineStart = character + 1;
+        }
+        previousWasCr = value === '\r';
+        character += 1;
+    }
+    lines.push({
+        lineNumber: lines.length + 1,
+        startCharacter: lineStart,
+        contentEndCharacter: character,
+        endCharacter: character,
+        startByte: byteOffsets[lineStart],
+        contentEndByte: byteOffsets[character],
+        endByte: byteOffsets[character],
+    });
+    return lines;
+}
+const exactIndex = (offsets, byteOffset) => {
+    let low = 0;
+    let high = offsets.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const value = offsets[middle];
+        if (value === byteOffset)
+            return middle;
+        if (value < byteOffset)
+            low = middle + 1;
+        else
+            high = middle - 1;
+    }
+    return -1;
+};
+function mappingFor(parsed) {
+    const characterByteOffsets = parsed.characterByteOffsets;
+    const characterCodeUnitOffsets = parsed.characterCodeUnitOffsets;
+    const characterCount = characterByteOffsets.length - 1;
+    const firstByte = characterByteOffsets[0];
+    const lastByte = characterByteOffsets[characterCount];
+    const validCharacterOffset = (offset) => Number.isInteger(offset) && offset >= 0 && offset <= characterCount;
+    const byteOffsetAtCharacter = (characterOffset) => {
+        if (!validCharacterOffset(characterOffset))
+            throw new RangeError('character offset is outside decoded text');
+        return characterByteOffsets[characterOffset];
+    };
+    const characterOffsetAtByte = (byteOffset) => {
+        if (!Number.isInteger(byteOffset) || byteOffset < firstByte || byteOffset > lastByte) {
+            throw new RangeError('canonical byte offset is outside decoded text');
+        }
+        const characterOffset = exactIndex(characterByteOffsets, byteOffset);
+        if (characterOffset < 0)
+            throw new RangeError('canonical byte offset is inside an encoded character');
+        return characterOffset;
+    };
+    const canonicalSpanForCharacters = (startCharacter, endCharacter) => {
+        if (!validCharacterOffset(startCharacter) || !validCharacterOffset(endCharacter) || startCharacter > endCharacter) {
+            throw new RangeError('invalid character span');
+        }
+        return { startByte: characterByteOffsets[startCharacter], endByte: characterByteOffsets[endCharacter] };
+    };
+    const characterSpanForCanonicalBytes = (startByte, endByte) => {
+        if (startByte > endByte)
+            throw new RangeError('invalid canonical byte span');
+        return {
+            startCharacter: characterOffsetAtByte(startByte),
+            endCharacter: characterOffsetAtByte(endByte),
+        };
+    };
+    return {
+        canonicalByteOffsets: characterByteOffsets,
+        characterCodeUnitOffsets,
+        lines: linesFor(parsed.text, characterByteOffsets),
+        byteOffsetAtCharacter,
+        characterOffsetAtByte,
+        canonicalSpanForCharacters,
+        characterSpanForCanonicalBytes,
+    };
+}
+function successfulDecode(parsed, encoding, bom, canonicalByteLength) {
+    const mapping = mappingFor(parsed);
+    return {
+        status: 'decoded',
+        text: parsed.text,
+        encoding,
+        bom,
+        canonicalByteLength,
+        characterCount: parsed.characterByteOffsets.length - 1,
+        lineCount: mapping.lines.length,
+        mapping,
+    };
+}
+const startsWith = (bytes, prefix) => prefix.every((value, index) => bytes[index] === value);
+/** Strictly decodes canonical blob bytes and retains their original byte positions. */
+export function decodeCanonicalBlob(bytes) {
+    const canonicalByteLength = bytes.byteLength;
+    let encoding = null;
+    let bomLength = 0;
+    if (startsWith(bytes, [0xef, 0xbb, 0xbf])) {
+        encoding = 'utf8';
+        bomLength = 3;
+    }
+    else if (startsWith(bytes, [0xff, 0xfe])) {
+        encoding = 'utf16le';
+        bomLength = 2;
+    }
+    else if (startsWith(bytes, [0xfe, 0xff])) {
+        encoding = 'utf16be';
+        bomLength = 2;
+    }
+    if (encoding) {
+        const bom = { encoding, startByte: 0, endByte: bomLength };
+        const parsed = encoding === 'utf8'
+            ? parseUtf8(bytes, bomLength)
+            : parseUtf16(bytes, bomLength, encoding === 'utf16le');
+        return parsed
+            ? successfulDecode(parsed, encoding, bom, canonicalByteLength)
+            : { status: 'decode_failed', encoding, bom, canonicalByteLength };
+    }
+    const nulLimit = Math.min(8_000, canonicalByteLength);
+    for (let byte = 0; byte < nulLimit; byte += 1) {
+        if (bytes[byte] === 0)
+            return { status: 'nul_bytes', canonicalByteLength, firstNulByte: byte };
+    }
+    const parsed = parseUtf8(bytes, 0);
+    return parsed
+        ? successfulDecode(parsed, 'utf8', null, canonicalByteLength)
+        : { status: 'unsupported_encoding', canonicalByteLength };
+}