goscript 0.0.38 → 0.0.39

package/gs/bytes/godoc.txt

@@ -0,0 +1,69 @@
+package bytes // import "bytes"
+
+Package bytes implements functions for the manipulation of byte slices. It is
+analogous to the facilities of the strings package.
+
+const MinRead = 512
+var ErrTooLarge = errors.New("bytes.Buffer: too large")
+func Clone(b []byte) []byte
+func Compare(a, b []byte) int
+func Contains(b, subslice []byte) bool
+func ContainsAny(b []byte, chars string) bool
+func ContainsFunc(b []byte, f func(rune) bool) bool
+func ContainsRune(b []byte, r rune) bool
+func Count(s, sep []byte) int
+func Cut(s, sep []byte) (before, after []byte, found bool)
+func CutPrefix(s, prefix []byte) (after []byte, found bool)
+func CutSuffix(s, suffix []byte) (before []byte, found bool)
+func Equal(a, b []byte) bool
+func EqualFold(s, t []byte) bool
+func Fields(s []byte) [][]byte
+func FieldsFunc(s []byte, f func(rune) bool) [][]byte
+func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte]
+func FieldsSeq(s []byte) iter.Seq[[]byte]
+func HasPrefix(s, prefix []byte) bool
+func HasSuffix(s, suffix []byte) bool
+func Index(s, sep []byte) int
+func IndexAny(s []byte, chars string) int
+func IndexByte(b []byte, c byte) int
+func IndexFunc(s []byte, f func(r rune) bool) int
+func IndexRune(s []byte, r rune) int
+func Join(s [][]byte, sep []byte) []byte
+func LastIndex(s, sep []byte) int
+func LastIndexAny(s []byte, chars string) int
+func LastIndexByte(s []byte, c byte) int
+func LastIndexFunc(s []byte, f func(r rune) bool) int
+func Lines(s []byte) iter.Seq[[]byte]
+func Map(mapping func(r rune) rune, s []byte) []byte
+func Repeat(b []byte, count int) []byte
+func Replace(s, old, new []byte, n int) []byte
+func ReplaceAll(s, old, new []byte) []byte
+func Runes(s []byte) []rune
+func Split(s, sep []byte) [][]byte
+func SplitAfter(s, sep []byte) [][]byte
+func SplitAfterN(s, sep []byte, n int) [][]byte
+func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte]
+func SplitN(s, sep []byte, n int) [][]byte
+func SplitSeq(s, sep []byte) iter.Seq[[]byte]
+func Title(s []byte) []byte
+func ToLower(s []byte) []byte
+func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
+func ToTitle(s []byte) []byte
+func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
+func ToUpper(s []byte) []byte
+func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte
+func ToValidUTF8(s, replacement []byte) []byte
+func Trim(s []byte, cutset string) []byte
+func TrimFunc(s []byte, f func(r rune) bool) []byte
+func TrimLeft(s []byte, cutset string) []byte
+func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
+func TrimPrefix(s, prefix []byte) []byte
+func TrimRight(s []byte, cutset string) []byte
+func TrimRightFunc(s []byte, f func(r rune) bool) []byte
+func TrimSpace(s []byte) []byte
+func TrimSuffix(s, suffix []byte) []byte
+type Buffer struct{ ... }
+    func NewBuffer(buf []byte) *Buffer
+    func NewBufferString(s string) *Buffer
+type Reader struct{ ... }
+    func NewReader(b []byte) *Reader

package/gs/bytes/index.ts

@@ -0,0 +1,69 @@
+export {
+  Buffer,
+  ErrTooLarge,
+  MinRead,
+  NewBuffer,
+  NewBufferString,
+} from './buffer.gs.js'
+export {
+  Clone,
+  Compare,
+  Contains,
+  ContainsAny,
+  ContainsFunc,
+  ContainsRune,
+  Count,
+  Cut,
+  CutPrefix,
+  CutSuffix,
+  Equal,
+  EqualFold,
+  Fields,
+  FieldsFunc,
+  HasPrefix,
+  HasSuffix,
+  Index,
+  IndexAny,
+  IndexByte,
+  IndexFunc,
+  IndexRune,
+  Join,
+  LastIndex,
+  LastIndexAny,
+  LastIndexByte,
+  LastIndexFunc,
+  Map,
+  Repeat,
+  Replace,
+  ReplaceAll,
+  Runes,
+  Split,
+  SplitAfter,
+  SplitAfterN,
+  SplitN,
+  Title,
+  ToLower,
+  ToLowerSpecial,
+  ToTitle,
+  ToTitleSpecial,
+  ToUpper,
+  ToUpperSpecial,
+  ToValidUTF8,
+  Trim,
+  TrimFunc,
+  TrimLeft,
+  TrimLeftFunc,
+  TrimPrefix,
+  TrimRight,
+  TrimRightFunc,
+  TrimSpace,
+  TrimSuffix,
+} from './bytes.gs.js'
+export {
+  FieldsFuncSeq,
+  FieldsSeq,
+  Lines,
+  SplitAfterSeq,
+  SplitSeq,
+} from './iter.gs.js'
+export { NewReader, Reader } from './reader.gs.js'

package/gs/bytes/iter.gs.ts

@@ -0,0 +1,149 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Index, IndexByte, asciiSpace } from "./bytes.gs.js";
+
+import * as iter from "@goscript/iter/index.js"
+
+import * as unicode from "@goscript/unicode/index.js"
+
+import * as utf8 from "@goscript/unicode/utf8/index.js"
+
+// Lines returns an iterator over the newline-terminated lines in the byte slice s.
+// The lines yielded by the iterator include their terminating newlines.
+// If s is empty, the iterator yields no lines at all.
+// If s does not end in a newline, the final yielded line will not end in a newline.
+// It returns a single-use iterator.
+export function Lines(s: $.Bytes): iter.Seq<$.Bytes> {
+	return (_yield: ((p0: $.Bytes) => boolean) | null): void => {
+		for (; $.len(s) > 0; ) {
+			let line: $.Bytes = new Uint8Array(0)
+			{
+				let i = IndexByte(s, 10)
+				if (i >= 0) {
+					[line, s] = [$.goSlice(s, undefined, i + 1), $.goSlice(s, i + 1, undefined)]
+				} else {
+					[line, s] = [s, null]
+				}
+			}
+			if (!_yield!($.goSlice(line, undefined, $.len(line), $.len(line)))) {
+				return 
+			}
+		}
+		return 
+	}
+}
+
+// explodeSeq returns an iterator over the runes in s.
+export function explodeSeq(s: $.Bytes): iter.Seq<$.Bytes> {
+	return (_yield: ((p0: $.Bytes) => boolean) | null): void => {
+		for (; $.len(s) > 0; ) {
+			let [, size] = utf8.DecodeRune(s)
+			if (!_yield!($.goSlice(s, undefined, size, size))) {
+				return 
+			}
+			s = $.goSlice(s, size, undefined)
+		}
+	}
+}
+
+// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
+// bytes of sep to include in the results (none or all).
+export function splitSeq(s: $.Bytes, sep: $.Bytes, sepSave: number): iter.Seq<$.Bytes> {
+	if ($.len(sep) == 0) {
+		return explodeSeq(s)
+	}
+	return (_yield: ((p0: $.Bytes) => boolean) | null): void => {
+		for (; ; ) {
+			let i = Index(s, sep)
+			if (i < 0) {
+				break
+			}
+			let frag = $.goSlice(s, undefined, i + sepSave)
+			if (!_yield!($.goSlice(frag, undefined, $.len(frag), $.len(frag)))) {
+				return 
+			}
+			s = $.goSlice(s, i + $.len(sep), undefined)
+		}
+		_yield!($.goSlice(s, undefined, $.len(s), $.len(s)))
+	}
+}
+
+// SplitSeq returns an iterator over all subslices of s separated by sep.
+// The iterator yields the same subslices that would be returned by [Split](s, sep),
+// but without constructing a new slice containing the subslices.
+// It returns a single-use iterator.
+export function SplitSeq(s: $.Bytes, sep: $.Bytes): iter.Seq<$.Bytes> {
+	return splitSeq(s, sep, 0)
+}
+
+// SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
+// The iterator yields the same subslices that would be returned by [SplitAfter](s, sep),
+// but without constructing a new slice containing the subslices.
+// It returns a single-use iterator.
+export function SplitAfterSeq(s: $.Bytes, sep: $.Bytes): iter.Seq<$.Bytes> {
+	return splitSeq(s, sep, $.len(sep))
+}
+
+// FieldsSeq returns an iterator over subslices of s split around runs of
+// whitespace characters, as defined by [unicode.IsSpace].
+// The iterator yields the same subslices that would be returned by [Fields](s),
+// but without constructing a new slice containing the subslices.
+export function FieldsSeq(s: $.Bytes): iter.Seq<$.Bytes> {
+	return (_yield: ((p0: $.Bytes) => boolean) | null): void => {
+		let start = -1
+		for (let i = 0; i < $.len(s); ) {
+			let size = 1
+			let r = (s![i] as number)
+			let isSpace = asciiSpace![s![i]] != 0
+			if (r >= utf8.RuneSelf) {
+				;[r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
+				isSpace = unicode.IsSpace(r)
+			}
+			if (isSpace) {
+				if (start >= 0) {
+					if (!_yield!($.goSlice(s, start, i, i))) {
+						return 
+					}
+					start = -1
+				}
+			} else if (start < 0) {
+				start = i
+			}
+			i += size
+		}
+		if (start >= 0) {
+			_yield!($.goSlice(s, start, $.len(s), $.len(s)))
+		}
+	}
+}
+
+// FieldsFuncSeq returns an iterator over subslices of s split around runs of
+// Unicode code points satisfying f(c).
+// The iterator yields the same subslices that would be returned by [FieldsFunc](s),
+// but without constructing a new slice containing the subslices.
+export function FieldsFuncSeq(s: $.Bytes, f: ((p0: number) => boolean) | null): iter.Seq<$.Bytes> {
+	return (_yield: ((p0: $.Bytes) => boolean) | null): void => {
+		let start = -1
+		for (let i = 0; i < $.len(s); ) {
+			let size = 1
+			let r = (s![i] as number)
+			if (r >= utf8.RuneSelf) {
+				;[r, size] = utf8.DecodeRune($.goSlice(s, i, undefined))
+			}
+			if (f!(r)) {
+				if (start >= 0) {
+					if (!_yield!($.goSlice(s, start, i, i))) {
+						return 
+					}
+					start = -1
+				}
+			} else if (start < 0) {
+				start = i
+			}
+			i += size
+		}
+		if (start >= 0) {
+			_yield!($.goSlice(s, start, $.len(s), $.len(s)))
+		}
+	}
+}
+

package/gs/bytes/reader.gs.ts

@@ -0,0 +1,230 @@
+import * as $ from "@goscript/builtin/builtin.js";
+const { copy } = $;
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as io from "@goscript/io/index.js"
+
+import * as utf8 from "@goscript/unicode/utf8/index.js"
+
+export class Reader {
+	public get s(): $.Bytes {
+		return this._fields.s.value
+	}
+	public set s(value: $.Bytes) {
+		this._fields.s.value = value
+	}
+
+	// current reading index
+	public get i(): number {
+		return this._fields.i.value
+	}
+	public set i(value: number) {
+		this._fields.i.value = value
+	}
+
+	// index of previous rune; or < 0
+	public get prevRune(): number {
+		return this._fields.prevRune.value
+	}
+	public set prevRune(value: number) {
+		this._fields.prevRune.value = value
+	}
+
+	public _fields: {
+		s: $.VarRef<$.Bytes>;
+		i: $.VarRef<number>;
+		prevRune: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{i?: number, prevRune?: number, s?: $.Bytes}>) {
+		this._fields = {
+			s: $.varRef(init?.s ?? new Uint8Array(0)),
+			i: $.varRef(init?.i ?? 0),
+			prevRune: $.varRef(init?.prevRune ?? 0)
+		}
+	}
+
+	public clone(): Reader {
+		const cloned = new Reader()
+		cloned._fields = {
+			s: $.varRef(this._fields.s.value),
+			i: $.varRef(this._fields.i.value),
+			prevRune: $.varRef(this._fields.prevRune.value)
+		}
+		return cloned
+	}
+
+	// Len returns the number of bytes of the unread portion of the
+	// slice.
+	public Len(): number {
+		const r = this
+		if (r.i >= ($.len(r.s) as number)) {
+			return 0
+		}
+		return $.int(($.len(r.s) as number) - r.i)
+	}
+
+	// Size returns the original length of the underlying byte slice.
+	// Size is the number of bytes available for reading via [Reader.ReadAt].
+	// The result is unaffected by any method calls except [Reader.Reset].
+	public Size(): number {
+		const r = this
+		return ($.len(r.s) as number)
+	}
+
+	// Read implements the [io.Reader] interface.
+	public Read(b: $.Bytes): [number, $.GoError] {
+		const r = this
+		if (r.i >= ($.len(r.s) as number)) {
+			return [0, io.EOF]
+		}
+		r.prevRune = -1
+		const n = $.copy($.bytesToUint8Array(b), $.bytesToUint8Array($.goSlice(r.s, r.i, undefined)))
+		r.i += (n as number)
+		return [n, null]
+	}
+
+	// ReadAt implements the [io.ReaderAt] interface.
+	public ReadAt(b: $.Bytes, off: number): [number, $.GoError] {
+		const r = this
+		if (off < 0) {
+			return [0, errors.New("bytes.Reader.ReadAt: negative offset")]
+		}
+		if (off >= ($.len(r.s) as number)) {
+			return [0, io.EOF]
+		}
+		const n = $.copy($.bytesToUint8Array(b), $.bytesToUint8Array($.goSlice(r.s, off, undefined)))
+		let err: $.GoError = null
+		if (n < $.len(b)) {
+			err = io.EOF
+		}
+		return [n, err]
+	}
+
+	// ReadByte implements the [io.ByteReader] interface.
+	public ReadByte(): [number, $.GoError] {
+		const r = this
+		r.prevRune = -1
+		if (r.i >= ($.len(r.s) as number)) {
+			return [0, io.EOF]
+		}
+		let b = r.s![r.i]
+		r.i++
+		return [b, null]
+	}
+
+	// UnreadByte complements [Reader.ReadByte] in implementing the [io.ByteScanner] interface.
+	public UnreadByte(): $.GoError {
+		const r = this
+		if (r.i <= 0) {
+			return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
+		}
+		r.prevRune = -1
+		r.i--
+		return null
+	}
+
+	// ReadRune implements the [io.RuneReader] interface.
+	public ReadRune(): [number, number, $.GoError] {
+		const r = this
+		if (r.i >= ($.len(r.s) as number)) {
+			r.prevRune = -1
+			return [0, 0, io.EOF]
+		}
+		r.prevRune = $.int(r.i)
+		{
+			let c = r.s![r.i]
+			if (c < utf8.RuneSelf) {
+				r.i++
+				return [(c as number), 1, null]
+			}
+		}
+		const [ch, size] = utf8.DecodeRune($.goSlice(r.s, r.i, undefined))
+		r.i += (size as number)
+		return [ch, size, null]
+	}
+
+	// UnreadRune complements [Reader.ReadRune] in implementing the [io.RuneScanner] interface.
+	public UnreadRune(): $.GoError {
+		const r = this
+		if (r.i <= 0) {
+			return errors.New("bytes.Reader.UnreadRune: at beginning of slice")
+		}
+		if (r.prevRune < 0) {
+			return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune")
+		}
+		r.i = (r.prevRune as number)
+		r.prevRune = -1
+		return null
+	}
+
+	// Seek implements the [io.Seeker] interface.
+	public Seek(offset: number, whence: number): [number, $.GoError] {
+		const r = this
+		r.prevRune = -1
+		let abs: number = 0
+		switch (whence) {
+			case io.SeekStart:
+				abs = offset
+				break
+			case io.SeekCurrent:
+				abs = r.i + offset
+				break
+			case io.SeekEnd:
+				abs = ($.len(r.s) as number) + offset
+				break
+			default:
+				return [0, errors.New("bytes.Reader.Seek: invalid whence")]
+				break
+		}
+		if (abs < 0) {
+			return [0, errors.New("bytes.Reader.Seek: negative position")]
+		}
+		r.i = abs
+		return [abs, null]
+	}
+
+	// WriteTo implements the [io.WriterTo] interface.
+	public WriteTo(w: io.Writer): [number, $.GoError] {
+		const r = this
+		r.prevRune = -1
+		if (r.i >= ($.len(r.s) as number)) {
+			return [0, null]
+		}
+		const b = $.goSlice(r.s, r.i, undefined)
+		const [m, err] = w!.Write($.bytesToUint8Array(b))
+		if (m > $.len(b)) {
+			$.panic("bytes.Reader.WriteTo: invalid Write count")
+		}
+		r.i += (m as number)
+		const n = (m as number)
+		if (m != $.len(b) && err == null) {
+			return [n, io.ErrShortWrite]
+		}
+		return [n, err]
+	}
+
+	// Reset resets the [Reader] to be reading from b.
+	public Reset(b: $.Bytes): void {
+		const r = this
+		r.s = b
+		r.i = 0
+		r.prevRune = -1
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'Reader',
+	  new Reader(),
+	  [{ name: "Len", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Size", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Read", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadAt", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "off", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadByte", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadByte", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadRune", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadRune", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Seek", args: [{ name: "offset", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "whence", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteTo", args: [{ name: "w", type: "Writer" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Reset", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [] }],
+	  Reader,
+	  {"s": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "i": { kind: $.TypeKind.Basic, name: "number" }, "prevRune": { kind: $.TypeKind.Basic, name: "number" }}
+	);
+}
+
+// NewReader returns a new [Reader] reading from b.
+export function NewReader(b: $.Bytes): Reader | null {
+	return new Reader({})
+}
+

package/gs/internal/bytealg/index.ts

@@ -1,12 +1,31 @@
 // Placeholder bytealg module for reflect package compatibility
 
+// Helper function to normalize bytes input
+function normalizeBytes(b: any): any[] {
+  if (b === null || b === undefined) {
+    return []
+  }
+  if (Array.isArray(b)) {
+    return b
+  }
+  if (b instanceof Uint8Array) {
+    return Array.from(b)
+  }
+  if (b && typeof b === 'object' && 'data' in b && Array.isArray(b.data)) {
+    return b.data
+  }
+  return []
+}
+
 // Equal reports whether a and b are the same length and contain the same bytes.
-export function Equal(a: Uint8Array | any[], b: Uint8Array | any[]): boolean {
-  if (a.length !== b.length) {
+export function Equal(a: any, b: any): boolean {
+  const aNorm = normalizeBytes(a)
+  const bNorm = normalizeBytes(b)
+  if (aNorm.length !== bNorm.length) {
     return false
   }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
+  for (let i = 0; i < aNorm.length; i++) {
+    if (aNorm[i] !== bNorm[i]) {
       return false
     }
   }
@@ -14,21 +33,117 @@ export function Equal(a: Uint8Array | any[], b: Uint8Array | any[]): boolean {
 }
 
 // Compare returns an integer comparing two byte slices lexicographically.
-export function Compare(a: Uint8Array | any[], b: Uint8Array | any[]): number {
-  const minLen = Math.min(a.length, b.length)
+export function Compare(a: any, b: any): number {
+  const aNorm = normalizeBytes(a)
+  const bNorm = normalizeBytes(b)
+  const minLen = Math.min(aNorm.length, bNorm.length)
   for (let i = 0; i < minLen; i++) {
-    if (a[i] < b[i]) {
+    if (aNorm[i] < bNorm[i]) {
       return -1
     }
-    if (a[i] > b[i]) {
+    if (aNorm[i] > bNorm[i]) {
       return 1
     }
   }
-  if (a.length < b.length) {
+  if (aNorm.length < bNorm.length) {
     return -1
   }
-  if (a.length > b.length) {
+  if (aNorm.length > bNorm.length) {
     return 1
   }
   return 0
 }
+
+// Additional functions needed by bytes package
+export function Count(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  let count = 0
+  for (let i = 0; i < sNorm.length; i++) {
+    if (sNorm[i] === b) {
+      count++
+    }
+  }
+  return count
+}
+
+export function IndexByte(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  for (let i = 0; i < sNorm.length; i++) {
+    if (sNorm[i] === b) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function LastIndexByte(s: any, b: number): number {
+  const sNorm = normalizeBytes(s)
+  for (let i = sNorm.length - 1; i >= 0; i--) {
+    if (sNorm[i] === b) {
+      return i
+    }
+  }
+  return -1
+}
+
+export function Index(s: any, sep: any): number {
+  const sNorm = normalizeBytes(s)
+  const sepNorm = normalizeBytes(sep)
+  if (sepNorm.length === 0) return 0
+  if (sepNorm.length > sNorm.length) return -1
+
+  for (let i = 0; i <= sNorm.length - sepNorm.length; i++) {
+    let found = true
+    for (let j = 0; j < sepNorm.length; j++) {
+      if (sNorm[i + j] !== sepNorm[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+  return -1
+}
+
+export function LastIndexRabinKarp(s: any, sep: any): number {
+  const sNorm = normalizeBytes(s)
+  const sepNorm = normalizeBytes(sep)
+  // Simple implementation
+  for (let i = sNorm.length - sepNorm.length; i >= 0; i--) {
+    let found = true
+    for (let j = 0; j < sepNorm.length; j++) {
+      if (sNorm[i + j] !== sepNorm[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) return i
+  }
+  return -1
+}
+
+export function IndexRabinKarp(s: any, sep: any): number {
+  return Index(s, sep)
+}
+
+export function IndexByteString(s: string, b: number): number {
+  const char = String.fromCharCode(b)
+  return s.indexOf(char)
+}
+
+export function IndexString(s: string, substr: string): number {
+  return s.indexOf(substr)
+}
+
+export function MakeNoZero(n: number): Uint8Array {
+  return new Uint8Array(n)
+}
+
+export function Cutover(_n: number): number {
+  // TODO: Implement Cutover function
+  return 10 // Simple threshold
+}
+
+// Constants needed by bytes package
+export const MaxBruteForce = 64
+export const MaxLen = 32