goscript 0.2.6 → 0.2.7

package/gs/strconv/quote.gs.ts

@@ -1,165 +1,393 @@
 import * as $ from "@goscript/builtin/index.js";
+import * as unicode from "@goscript/unicode/index.js";
 import { ErrSyntax } from "./atoi.gs.js";
 
+const lowerhex = "0123456789abcdef";
+
+// hexEscape emits Go's \xNN, \uNNNN, or \UNNNNNNNN escape with width hex digits.
+function hexEscape(prefix: string, value: number, width: number): string {
+	let out = prefix;
+	for (let shift = (width - 1) * 4; shift >= 0; shift -= 4) {
+		out += lowerhex[(value >> shift) & 0xf];
+	}
+	return out;
+}
+
+// appendEscapedRune returns the Go-escaped form of one rune, matching
+// strconv.appendEscapedRune: printable runes pass through, the standard control
+// escapes (\a \b \f \n \r \t \v) are emitted by name, control and DEL bytes
+// become \xNN, invalid runes fold to U+FFFD, and the rest become \u/\U. This
+// replaces the prior JSON.stringify / fromCharCode shortcuts, which used the
+// wrong escape set and truncated runes above U+FFFF.
+function appendEscapedRune(
+	r: number,
+	quote: number,
+	asciiOnly: boolean,
+	graphicOnly: boolean,
+): string {
+	if (r === quote || r === 0x5c /* backslash */) {
+		return "\\" + String.fromCharCode(r);
+	}
+	if (asciiOnly) {
+		if (r < 0x80 && unicode.IsPrint(r)) {
+			return String.fromCharCode(r);
+		}
+	} else if (unicode.IsPrint(r) || (graphicOnly && unicode.IsGraphic(r))) {
+		return $.runeToString(r);
+	}
+	switch (r) {
+		case 0x07:
+			return "\\a";
+		case 0x08:
+			return "\\b";
+		case 0x0c:
+			return "\\f";
+		case 0x0a:
+			return "\\n";
+		case 0x0d:
+			return "\\r";
+		case 0x09:
+			return "\\t";
+		case 0x0b:
+			return "\\v";
+	}
+	if (r < 0x20 || r === 0x7f) {
+		return hexEscape("\\x", r & 0xff, 2);
+	}
+	if (r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff)) {
+		r = 0xfffd; // !utf8.ValidRune: fold to RuneError before emitting \u.
+	}
+	if (r < 0x10000) {
+		return hexEscape("\\u", r, 4);
+	}
+	return hexEscape("\\U", r, 8);
+}
+
+// quoteWith renders s as a Go quoted literal using quote as the delimiter.
+function quoteWith(
+	s: string,
+	quote: number,
+	asciiOnly: boolean,
+	graphicOnly: boolean,
+): string {
+	let out = String.fromCharCode(quote);
+	for (const ch of s) {
+		out += appendEscapedRune(ch.codePointAt(0)!, quote, asciiOnly, graphicOnly);
+	}
+	return out + String.fromCharCode(quote);
+}
+
+// quoteRuneWith renders a single rune as a Go quoted character literal.
+function quoteRuneWith(
+	r: number,
+	quote: number,
+	asciiOnly: boolean,
+	graphicOnly: boolean,
+): string {
+	return (
+		String.fromCharCode(quote) +
+		appendEscapedRune(r, quote, asciiOnly, graphicOnly) +
+		String.fromCharCode(quote)
+	);
+}
+
 // Quote returns a double-quoted Go string literal representing s.
 // The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for control characters and non-printable characters.
 export function Quote(s: string): string {
-	return JSON.stringify(s);
+	return quoteWith(s, 0x22 /* " */, false, false);
 }
 
 // QuoteToASCII returns a double-quoted Go string literal representing s.
 // The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for control characters and non-ASCII characters.
 export function QuoteToASCII(s: string): string {
-	// For simplicity, use JSON.stringify and then escape non-ASCII
-	const quoted = JSON.stringify(s);
-	return quoted.replace(/[\u0080-\uFFFF]/g, (match) => {
-		const code = match.charCodeAt(0);
-		if (code <= 0xFF) {
-			return '\\x' + code.toString(16).padStart(2, '0');
-		} else {
-			return '\\u' + code.toString(16).padStart(4, '0');
-		}
-	});
+	return quoteWith(s, 0x22, true, false);
 }
 
 // QuoteToGraphic returns a double-quoted Go string literal representing s.
 // The returned string leaves Unicode graphic characters unchanged.
 export function QuoteToGraphic(s: string): string {
-	return Quote(s); // Simplified
+	return quoteWith(s, 0x22, false, true);
 }
 
 // QuoteRune returns a single-quoted Go character literal representing the rune.
 export function QuoteRune(r: number): string {
-	const char = String.fromCharCode(r);
-	if (r === 39) { // single quote
-		return "'\\'";
-	}
-	if (r === 92) { // backslash  
-		return "'\\\\'";
-	}
-	if (r >= 32 && r <= 126) { // printable ASCII
-		return "'" + char + "'";
-	}
-	// Use escape sequences for non-printable
-	if (r <= 0xFF) {
-		return "'\\x" + r.toString(16).padStart(2, '0') + "'";
-	}
-	return "'\\u" + r.toString(16).padStart(4, '0') + "'";
+	return quoteRuneWith(r, 0x27 /* ' */, false, false);
 }
 
 // QuoteRuneToASCII returns a single-quoted Go character literal representing the rune.
 export function QuoteRuneToASCII(r: number): string {
-	return QuoteRune(r); // Same as QuoteRune for simplicity
+	return quoteRuneWith(r, 0x27, true, false);
 }
 
 // QuoteRuneToGraphic returns a single-quoted Go character literal representing the rune.
 export function QuoteRuneToGraphic(r: number): string {
-	return QuoteRune(r); // Same as QuoteRune for simplicity
+	return quoteRuneWith(r, 0x27, false, true);
 }
 
-// CanBackquote reports whether the string s can be represented unchanged as a single-line backquoted string.
+// CanBackquote reports whether the string s can be represented unchanged as a
+// single-line backquoted string. Go decodes UTF-8 runes: a tab is allowed, but
+// other control bytes below space, a backtick, DEL, an invalid byte
+// (utf8.RuneError at width 1), and a BOM (U+FEFF, invisible) are rejected.
 export function CanBackquote(s: string): boolean {
-	// Check if string contains backticks or control characters
-	for (let i = 0; i < s.length; i++) {
-		const c = s.charCodeAt(i);
-		if (c === 96 || c < 32 || c === 127) { // backtick or control character
+	const bytes = $.stringToBytes(s);
+	let i = 0;
+	while (i < bytes.length) {
+		const [r, wid] = decodeRune(bytes, i);
+		i += wid;
+		if (wid > 1) {
+			if (r === 0xfeff) {
+				return false; // BOMs are invisible and should not be quoted.
+			}
+			continue; // Other multibyte runes are valid and assumed printable.
+		}
+		if (r === 0xfffd) {
+			return false; // utf8.RuneError from an invalid single byte.
+		}
+		if ((r < 0x20 && r !== 0x09) || r === 0x60 || r === 0x7f) {
 			return false;
 		}
 	}
 	return true;
 }
 
-// Unquote interprets s as a single-quoted, double-quoted, or backquoted Go string literal.
-export function Unquote(s: string): [string, $.GoError] {
-	const n = s.length;
-	if (n < 2) {
-		return ["", ErrSyntax];
+// unhex returns the value of the hex digit byte b and whether b is a hex digit.
+function unhex(b: number): [number, boolean] {
+	if (b >= 0x30 && b <= 0x39) {
+		return [b - 0x30, true];
 	}
-
-	const quote = s[0];
-	if (quote !== s[n-1]) {
-		return ["", ErrSyntax];
+	if (b >= 0x61 && b <= 0x66) {
+		return [b - 0x61 + 10, true];
+	}
+	if (b >= 0x41 && b <= 0x46) {
+		return [b - 0x41 + 10, true];
 	}
+	return [0, false];
+}
 
-	s = s.slice(1, n-1);
+// decodeRune decodes the UTF-8 rune at bytes[pos], returning the rune and the
+// number of bytes consumed. Invalid sequences decode to U+FFFD with width 1,
+// matching utf8.DecodeRune.
+function decodeRune(bytes: Uint8Array, pos: number): [number, number] {
+	const b0 = bytes[pos];
+	if (b0 < 0x80) {
+		return [b0, 1];
+	}
+	let size: number;
+	let r: number;
+	if ((b0 & 0xe0) === 0xc0) {
+		size = 2;
+		r = b0 & 0x1f;
+	} else if ((b0 & 0xf0) === 0xe0) {
+		size = 3;
+		r = b0 & 0x0f;
+	} else if ((b0 & 0xf8) === 0xf0) {
+		size = 4;
+		r = b0 & 0x07;
+	} else {
+		return [0xfffd, 1];
+	}
+	if (pos + size > bytes.length) {
+		return [0xfffd, 1];
+	}
+	for (let j = 1; j < size; j++) {
+		const cb = bytes[pos + j];
+		if ((cb & 0xc0) !== 0x80) {
+			return [0xfffd, 1];
+		}
+		r = (r << 6) | (cb & 0x3f);
+	}
+	return [r, size];
+}
 
-	if (quote === '`') {
-		// Backquoted string - no escapes processed
-		if (s.includes('`')) {
-			return ["", ErrSyntax];
+// unquoteCharBytes decodes the first character or byte in the escaped byte
+// sequence starting at pos, returning [value, multibyte, newPos, err]. It is the
+// byte-oriented core shared by the exported UnquoteChar and Unquote so that
+// \xNN raw bytes and multibyte source runes round-trip exactly as in Go.
+function unquoteCharBytes(
+	bytes: Uint8Array,
+	pos: number,
+	quote: number,
+): [number, boolean, number, $.GoError] {
+	if (pos >= bytes.length) {
+		return [0, false, pos, ErrSyntax];
+	}
+	const c = bytes[pos];
+	if (c === quote && (quote === 0x27 || quote === 0x22)) {
+		return [0, false, pos, ErrSyntax];
+	}
+	if (c >= 0x80) {
+		const [r, size] = decodeRune(bytes, pos);
+		return [r, true, pos + size, null];
+	}
+	if (c !== 0x5c /* backslash */) {
+		return [c, false, pos + 1, null];
+	}
+	if (pos + 1 >= bytes.length) {
+		return [0, false, pos, ErrSyntax];
+	}
+	const e = bytes[pos + 1];
+	let p = pos + 2;
+	switch (e) {
+		case 0x61: // \a
+			return [0x07, false, p, null];
+		case 0x62: // \b
+			return [0x08, false, p, null];
+		case 0x66: // \f
+			return [0x0c, false, p, null];
+		case 0x6e: // \n
+			return [0x0a, false, p, null];
+		case 0x72: // \r
+			return [0x0d, false, p, null];
+		case 0x74: // \t
+			return [0x09, false, p, null];
+		case 0x76: // \v
+			return [0x0b, false, p, null];
+		case 0x78: // \x
+		case 0x75: // \u
+		case 0x55: { // \U
+			const n = e === 0x78 ? 2 : e === 0x75 ? 4 : 8;
+			if (p + n > bytes.length) {
+				return [0, false, pos, ErrSyntax];
+			}
+			let v = 0;
+			for (let j = 0; j < n; j++) {
+				const [x, ok] = unhex(bytes[p + j]);
+				if (!ok) {
+					return [0, false, pos, ErrSyntax];
+				}
+				v = (v << 4) | x;
+			}
+			p += n;
+			if (e === 0x78) {
+				return [v, false, p, null]; // single byte
+			}
+			if (v < 0 || v > 0x10ffff || (v >= 0xd800 && v <= 0xdfff)) {
+				return [0, false, pos, ErrSyntax]; // !utf8.ValidRune
+			}
+			return [v, true, p, null];
 		}
-		if (s.includes('\r')) {
-			return ["", ErrSyntax]; 
+		case 0x30:
+		case 0x31:
+		case 0x32:
+		case 0x33:
+		case 0x34:
+		case 0x35:
+		case 0x36:
+		case 0x37: { // octal \N
+			let v = e - 0x30;
+			if (p + 2 > bytes.length) {
+				return [0, false, pos, ErrSyntax];
+			}
+			for (let j = 0; j < 2; j++) {
+				const x = bytes[p + j] - 0x30;
+				if (x < 0 || x > 7) {
+					return [0, false, pos, ErrSyntax];
+				}
+				v = (v << 3) | x;
+			}
+			p += 2;
+			if (v > 255) {
+				return [0, false, pos, ErrSyntax];
+			}
+			return [v, false, p, null];
 		}
-		return [s, null];
+		case 0x5c: // backslash
+			return [0x5c, false, p, null];
+		case 0x27: // '
+		case 0x22: // "
+			if (e !== quote) {
+				return [0, false, pos, ErrSyntax];
+			}
+			return [e, false, p, null];
+		default:
+			return [0, false, pos, ErrSyntax];
 	}
+}
 
-	if (quote !== '"' && quote !== "'") {
-		return ["", ErrSyntax];
+// UnquoteChar decodes the first character or byte in the escaped string or
+// character literal represented by the string s. quote is the delimiting byte
+// (' or "), or 0 to disallow neither.
+export function UnquoteChar(s: string, quote: number): [number, boolean, string, $.GoError] {
+	const bytes = $.stringToBytes(s);
+	const [value, multibyte, newPos, err] = unquoteCharBytes(bytes, 0, quote);
+	if (err !== null) {
+		return [0, false, "", err];
 	}
+	return [value, multibyte, $.bytesToString(bytes.subarray(newPos)), null];
+}
 
-	// Use JSON.parse for double-quoted strings as a starting point
-	if (quote === '"') {
-		try {
-			const result = JSON.parse('"' + s + '"');
-			return [result, null];
-		} catch {
-			return ["", ErrSyntax];
-		}
+// Unquote interprets s as a single-quoted, double-quoted, or backquoted Go
+// string literal, returning the string value that s quotes.
+export function Unquote(s: string): [string, $.GoError] {
+	const bytes = $.stringToBytes(s);
+	const n = bytes.length;
+	if (n < 2) {
+		return ["", ErrSyntax];
 	}
+	const quote = bytes[0];
+	if (quote !== bytes[n - 1]) {
+		return ["", ErrSyntax];
+	}
+	const inner = bytes.subarray(1, n - 1);
 
-	// Single-quoted string - should contain single rune
-	if (quote === "'") {
-		// Simplified: just handle basic cases
-		if (s.length === 1) {
-			return [s, null];
+	if (quote === 0x60 /* ` */) {
+		for (let i = 0; i < inner.length; i++) {
+			if (inner[i] === 0x60) {
+				return ["", ErrSyntax];
+			}
 		}
-		if (s.length === 2 && s[0] === '\\') {
-			switch (s[1]) {
-				case 'n': return ['\n', null];
-				case 't': return ['\t', null];
-				case 'r': return ['\r', null];
-				case '\\': return ['\\', null];
-				case "'": return ["'", null];
-				default: return ["", ErrSyntax];
+		if (inner.includes(0x0d)) {
+			const out: number[] = [];
+			for (let i = 0; i < inner.length; i++) {
+				if (inner[i] !== 0x0d) {
+					out.push(inner[i]);
+				}
 			}
+			return [$.bytesToString(Uint8Array.from(out)), null];
 		}
-		return ["", ErrSyntax];
+		return [$.bytesToString(inner), null];
 	}
 
-	return ["", ErrSyntax];
-}
-
-// UnquoteChar decodes the first character or byte in the escaped string or character literal represented by the string s.
-export function UnquoteChar(s: string, quote: number): [number, boolean, string, $.GoError] {
-	// Simplified implementation
-	if (s.length === 0) {
-		return [0, false, "", ErrSyntax];
-	}
-	
-	const c = s.charCodeAt(0);
-	if (c === quote) {
-		return [0, false, "", ErrSyntax];
+	if (quote !== 0x22 && quote !== 0x27) {
+		return ["", ErrSyntax];
 	}
-	
-	if (c !== 92) { // not backslash
-		return [c, c >= 128, s.slice(1), null];
+	if (inner.includes(0x0a)) {
+		return ["", ErrSyntax]; // newline not allowed in " or ' literal
 	}
-	
-	// Handle escape sequence - simplified
-	if (s.length < 2) {
-		return [0, false, "", ErrSyntax];
+
+	// Fast path: no escape and no embedded quote byte.
+	if (!inner.includes(0x5c) && !inner.includes(quote)) {
+		if (quote === 0x22) {
+			return [$.bytesToString(inner), null];
+		}
+		// single-quoted: must hold exactly one rune
+		const [r, size] = decodeRune(inner, 0);
+		if (size === inner.length && (r !== 0xfffd || size !== 1)) {
+			return [$.bytesToString(inner), null];
+		}
 	}
-	
-	switch (s[1]) {
-		case 'n': return [10, false, s.slice(2), null];  // \n
-		case 't': return [9, false, s.slice(2), null];   // \t
-		case 'r': return [13, false, s.slice(2), null];  // \r
-		case '\\': return [92, false, s.slice(2), null]; // \\
-		case '"': return [34, false, s.slice(2), null];  // \"
-		case "'": return [39, false, s.slice(2), null];  // \'
-		default: return [0, false, "", ErrSyntax];
+
+	const out: number[] = [];
+	let pos = 0;
+	while (pos < inner.length) {
+		const [c, multibyte, newPos, err] = unquoteCharBytes(inner, pos, quote);
+		if (err !== null) {
+			return ["", err];
+		}
+		pos = newPos;
+		if (c < 0x80 || !multibyte) {
+			out.push(c & 0xff);
+		} else {
+			const enc = $.stringToBytes($.runeToString(c));
+			for (let j = 0; j < enc.length; j++) {
+				out.push(enc[j]);
+			}
+		}
+		if (quote === 0x27 && pos < inner.length) {
+			return ["", ErrSyntax]; // single-quoted must be one character
+		}
 	}
+	return [$.bytesToString(Uint8Array.from(out)), null];
 }
 
 // QuotedPrefix returns the quoted string (as understood by Unquote) at the prefix of s.
@@ -235,11 +463,10 @@ export function AppendQuoteRuneToGraphic(dst: $.Bytes, r: number): $.Bytes {
 
 // IsPrint reports whether the rune is defined as printable by Go.
 export function IsPrint(r: number): boolean {
-	// Simplified: consider ASCII printable characters
-	return r >= 32 && r <= 126;
+	return unicode.IsPrint(r);
 }
 
 // IsGraphic reports whether the rune is defined as a Graphic by Unicode.
 export function IsGraphic(r: number): boolean {
-	return IsPrint(r); // Simplified
-} 
+	return unicode.IsGraphic(r);
+}

package/gs/strconv/quote.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  CanBackquote,
+  Quote,
+  QuoteRune,
+  QuoteToASCII,
+  Unquote,
+  UnquoteChar,
+} from './quote.gs.js'
+
+// Expected outputs are the literal strings Go's strconv produces (go1.26.4).
+describe('strconv.Quote (Go escape semantics)', () => {
+  it('passes printable ASCII and Unicode through unchanged', () => {
+    expect(Quote('hello')).toBe('"hello"')
+    // CJK is printable; Go leaves graphic Unicode in place.
+    expect(Quote('背景')).toBe('"背景"')
+    // U+1F600 is graphic; not truncated and not escaped.
+    expect(Quote('😀')).toBe('"😀"')
+  })
+
+  it('escapes the quote and backslash', () => {
+    expect(Quote('a"b\\c')).toBe('"a\\"b\\\\c"')
+  })
+
+  it('uses Go named escapes including \\a and \\v that JSON lacks', () => {
+    expect(Quote('a\tb\n')).toBe('"a\\tb\\n"')
+    expect(Quote('\x07\x0b')).toBe('"\\a\\v"')
+  })
+
+  it('uses \\xNN for control bytes and DEL, not \\uNNNN', () => {
+    expect(Quote('\x00\x1f')).toBe('"\\x00\\x1f"')
+    expect(Quote('\x7f')).toBe('"\\x7f"')
+  })
+})
+
+describe('strconv.QuoteToASCII', () => {
+  it('escapes non-ASCII as \\u and astral as \\U', () => {
+    expect(QuoteToASCII('背景')).toBe('"\\u80cc\\u666f"')
+    expect(QuoteToASCII('😀')).toBe('"\\U0001f600"')
+    expect(QuoteToASCII('hi')).toBe('"hi"')
+  })
+})
+
+describe('strconv.QuoteRune', () => {
+  it('quotes printable, control, and astral runes like Go', () => {
+    expect(QuoteRune('a'.charCodeAt(0))).toBe("'a'")
+    expect(QuoteRune(0x09)).toBe("'\\t'")
+    expect(QuoteRune(0x1f600)).toBe("'😀'")
+    expect(QuoteRune(0x27)).toBe("'\\''")
+    expect(QuoteRune(0x00)).toBe("'\\x00'")
+  })
+
+  it('folds an invalid rune to the U+FFFD escape', () => {
+    expect(QuoteRune(0x110000)).toBe("'\\ufffd'")
+  })
+})
+
+// Ground truth captured from go1.26.4 strconv.Unquote / CanBackquote /
+// UnquoteChar over the same inputs.
+describe('strconv.Unquote (Go escape decoding)', () => {
+  it('decodes \\x, octal, \\u, and \\U escapes', () => {
+    expect(Unquote('"\\x41"')).toEqual(['A', null])
+    expect(Unquote('"\\101"')).toEqual(['A', null]) // octal 101 = 'A'
+    expect(Unquote('"\\u0041"')).toEqual(['A', null])
+    expect(Unquote('"\\U0001F600"')).toEqual(['😀', null])
+  })
+
+  it('decodes named escapes and passes printable Unicode through', () => {
+    expect(Unquote('"a\\tb"')).toEqual(['a\tb', null])
+    expect(Unquote('"é"')).toEqual(['é', null])
+  })
+
+  it('handles backquoted strings without processing escapes', () => {
+    expect(Unquote('`raw\\tno-escape`')).toEqual(['raw\\tno-escape', null])
+    expect(Unquote('`with`back`')[1]).not.toBeNull() // embedded backtick fails
+  })
+
+  it('requires single-quoted literals to hold exactly one rune', () => {
+    expect(Unquote("'a'")).toEqual(['a', null])
+    expect(Unquote("'\\x41'")).toEqual(['A', null])
+    expect(Unquote("'ab'")[1]).not.toBeNull()
+  })
+
+  it('rejects malformed input', () => {
+    expect(Unquote('"')[1]).not.toBeNull()
+    expect(Unquote('"\\x4"')[1]).not.toBeNull() // short hex
+    expect(Unquote('"a')[1]).not.toBeNull() // unterminated
+  })
+})
+
+describe('strconv.CanBackquote (Go control rules)', () => {
+  it('allows tab but rejects other control bytes, backtick, DEL, and BOM', () => {
+    expect(CanBackquote('a\tb')).toBe(true)
+    expect(CanBackquote('plain text')).toBe(true)
+    expect(CanBackquote('a\nb')).toBe(false)
+    expect(CanBackquote('a`b')).toBe(false)
+    expect(CanBackquote('a\x7fb')).toBe(false)
+    expect(CanBackquote('\uFEFF')).toBe(false)
+  })
+})
+
+describe('strconv.UnquoteChar (tail + multibyte)', () => {
+  it('decodes one escape and returns the remaining tail', () => {
+    expect(UnquoteChar('\\x41rest', 0x22)).toEqual([0x41, false, 'rest', null])
+  })
+
+  it('flags multibyte runes from \\u escapes', () => {
+    expect(UnquoteChar('\\u00e9z', 0x22)).toEqual([0xe9, true, 'z', null])
+  })
+})

package/gs/strings/reader.test.ts

@@ -126,8 +126,8 @@ describe('strings/Reader', () => {
     it('should seek from start', () => {
       const r = new Reader({ s: 'hello world' })
 
-      const [pos, err] = r.Seek(6, io.SeekStart)
-      expect(pos).toBe(6)
+      const [pos, err] = r.Seek(6n, io.SeekStart)
+      expect(pos).toBe(6n)
       expect(err).toBeNull()
       expect(r.Len()).toBe(5)
     })
@@ -136,32 +136,32 @@ describe('strings/Reader', () => {
       const r = new Reader({ s: 'hello world' })
       r.ReadByte() // advance to position 1
 
-      const [pos, err] = r.Seek(2, io.SeekCurrent)
-      expect(pos).toBe(3)
+      const [pos, err] = r.Seek(2n, io.SeekCurrent)
+      expect(pos).toBe(3n)
       expect(err).toBeNull()
     })
 
     it('should seek from end', () => {
       const r = new Reader({ s: 'hello world' })
 
-      const [pos, err] = r.Seek(-5, io.SeekEnd)
-      expect(pos).toBe(6)
+      const [pos, err] = r.Seek(-5n, io.SeekEnd)
+      expect(pos).toBe(6n)
       expect(err).toBeNull()
     })
 
     it('should handle invalid whence in seek', () => {
       const r = new Reader({ s: 'hello' })
 
-      const [pos, err] = r.Seek(0, 999)
-      expect(pos).toBe(0)
+      const [pos, err] = r.Seek(0n, 999)
+      expect(pos).toBe(0n)
       expect(err).not.toBeNull()
     })
 
     it('should handle negative position in seek', () => {
       const r = new Reader({ s: 'hello' })
 
-      const [pos, err] = r.Seek(-10, io.SeekStart)
-      expect(pos).toBe(0)
+      const [pos, err] = r.Seek(-10n, io.SeekStart)
+      expect(pos).toBe(0n)
       expect(err).not.toBeNull()
     })