@thomasfosterau/effect-parse 0.4.1 → 0.6.0

package/src/Ascii.ts

@@ -31,6 +31,7 @@ import type { Parser } from "./Parser.js"
 import * as P from "./Parser.js"
 import * as numbers from "./internal/numbers.js"
 import { Key } from "./internal/key.js"
+import { controlCode } from "./internal/node.js"
 import * as Resume from "./internal/resume.js"
 import { codePointPredicate } from "./internal/tokens.js"
 import { literalImpl, range, takeWhileImpl } from "./Token.js"
@@ -183,8 +184,13 @@ const alnumSet = [/*#__PURE__*/ range("a", "z"), /*#__PURE__*/ range("A", "Z"),
 const spaceSet = " \t"
 const multispaceSet = " \t\r\n"
 
-const cls = (set: unknown, min: 0 | 1, description: string, kind: ErrorKind, hint = true): Parser<string> =>
-  takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)
+const cls = (
+  set: Token.StringTokenSet,
+  min: 0 | 1,
+  description: string,
+  kind: ErrorKind,
+  hint = true
+): Parser<string> => takeWhileImpl<string>(set, { min }, false, `${kind.toLowerCase()}${min}`, description, kind, hint)
 
 // -----------------------------------------------------------------------------
 // Character classes
@@ -359,6 +365,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
     const isString = state.inputKind === 0
     let i = start
     while (i < state.end) {
+      // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string
       const c = isString ? (input as string).charCodeAt(i) : (input as Uint8Array)[i]
       if (c === 10) break
       if (c === 13) {
@@ -368,6 +375,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
           if (state.partial) return state.incomplete(1, expectedLineEnding)
           return state.backtrack("LineEnding", expectedLineEnding, i)
         }
+        // SAFETY: `Ascii` parsers run on strings or `Uint8Array`s, and `isString` is `inputKind === 0`, set only for a string
         const d = isString ? (input as string).charCodeAt(i + 1) : (input as Uint8Array)[i + 1]
         if (d === 10) break
         return state.backtrack("LineEnding", expectedLineEnding, i)
@@ -376,6 +384,7 @@ export const tillLineEnding: Parser<string> = /*#__PURE__*/ P.described<string>(
     }
     if (i >= state.end && state.partial) return state.incomplete(1, expectedLineEnding)
     state.pos = i
+    // SAFETY: on string input, the input type of a `Parser<string>`, the slice is a string (`bytes` retypes it for bytes)
     return state.slice(start, i) as string
   },
   "tillLineEnding",
@@ -471,7 +480,7 @@ const unsignedFloat = /*#__PURE__*/ P.alt(
 const floatText = /*#__PURE__*/ numbers.floatText(
   /*#__PURE__*/ P.taken(
     /*#__PURE__*/ P.alt(/*#__PURE__*/ literalImpl("nan", true), /*#__PURE__*/ P.seq(sign, unsignedFloat))
-  ).pipe(/*#__PURE__*/ P.expected("number")) as Parser<string>
+  ).pipe(/*#__PURE__*/ P.expected("number"))
 )
 
 /** @internal */
@@ -501,6 +510,17 @@ export const float: Parser<number> = /*#__PURE__*/ floatText.pipe(
 // Literals
 // -----------------------------------------------------------------------------
 
+/**
+ * The overloads of {@link caseless}.
+ *
+ * @since 0.5.0
+ * @category literals
+ */
+export interface CaselessFn {
+  (literal: string): Parser<string>
+  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>
+}
+
 /**
  * Matches a literal ignoring ASCII case (winnow's `Caseless`, nom's
  * `tag_no_case`). Returns the input as written.
@@ -508,20 +528,19 @@ export const float: Parser<number> = /*#__PURE__*/ floatText.pipe(
  * @since 0.1.0
  * @category literals
  */
-export const caseless: {
-  (literal: string): Parser<string>
-  (literal: Uint8Array): Parser<Uint8Array, never, never, Uint8Array>
-} = (lit: string | Uint8Array): any => literalImpl(lit, true)
+export const caseless: CaselessFn = (lit: string | Uint8Array): any => literalImpl(lit, true)
 
 // -----------------------------------------------------------------------------
 // Escapes
 // -----------------------------------------------------------------------------
 
-const controlCode = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))
+/** The first UTF-16 unit of a control character: what `atControl` compares with a string's units. */
+const firstUnit = (s: string): number => s.charCodeAt(0)
 
 const atControl = (state: State<Input>, control: number): boolean => {
   if (state.pos >= state.end) return false
   const input = state.input
+  // SAFETY: escapes are read from strings or `Uint8Array`s, and `inputKind` 0 is set only for a string
   const c = state.inputKind === 0 ? (input as string).charCodeAt(state.pos) : (input as Uint8Array)[state.pos]
   return c === control
 }
@@ -550,7 +569,7 @@ export const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Inpu
   control: string | number,
   escapable: Parser<B, E2, R2, I2>
 ): Parser<Slice<I & I2>, E | E2, R | R2, I & I2> => {
-  const ctrl = controlCode(control)
+  const ctrl = controlCode(control, firstUnit)
   return takeEscapedImpl(
     normal,
     (state) => {
@@ -559,6 +578,7 @@ export const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Inpu
       return true
     },
     escapable,
+    // SAFETY: the parser runs on input of type `I & I2`, and `State.slice` returns that input's own slice type
     (state, start) => state.slice(start, state.pos) as Slice<I & I2>,
     ctrl,
     undefined
@@ -593,9 +613,11 @@ export const takeEscapedImpl = <A, E, R, I extends Input, B, E2, R2, I2 extends
       const start = state.pos
       let resumed = false
       if (state.resume !== undefined) {
+        // SAFETY: under its own `key`, this parser saves only a resume offset (`suspendAt`) or a `Done`
         const checkpoint = Resume.take(state, key, start) as number | Resume.Done | undefined
         if (checkpoint instanceof Resume.Done) {
           state.pos = checkpoint.pos
+          // SAFETY: a `Done` saved under this parser's `key` holds the `S` it returned
           return checkpoint.value as S
         }
         if (checkpoint !== undefined) {
@@ -664,7 +686,7 @@ export const escaped = <E, R, I extends Input, E2, R2, I2 extends Input>(
   control: string | number,
   escape: Parser<string, E2, R2, I2>
 ): Parser<string, E | E2, R | R2, I & I2> => {
-  const ctrl = controlCode(control)
+  const ctrl = controlCode(control, firstUnit)
   return escapedImpl(
     normal,
     (state) => {
@@ -701,9 +723,11 @@ export const escapedImpl = <E, R, I extends Input, E2, R2, I2 extends Input>(
       let out = ""
       let resumed = false
       if (state.resume !== undefined) {
+        // SAFETY: under its own `key`, this parser saves only an `EscapedCheckpoint` (`suspendAt`) or a `Done`
         const checkpoint = Resume.take(state, key, start) as EscapedCheckpoint | Resume.Done | undefined
         if (checkpoint instanceof Resume.Done) {
           state.pos = checkpoint.pos
+          // SAFETY: a `Done` saved under this parser's `key` holds the string it returned
           return checkpoint.value as string
         }
         if (checkpoint !== undefined) {
@@ -754,6 +778,14 @@ type Bytes<P> =
     ? Parser<A extends string ? Uint8Array : A, E, R, Uint8Array>
     : never
 
+/**
+ * Gives a value the type of another view of the same parsers (see
+ * {@link bytes}).
+ */
+const retype = <T>(value: unknown): T =>
+  // SAFETY: callers pass the byte views' parsers, which are the string parsers themselves (below)
+  value as T
+
 /**
  * The parsers of this module, typed for `Uint8Array` input. Slices are
  * returned as `Uint8Array`s.
@@ -803,7 +835,7 @@ export const bytes: {
   const lit = (s: string) => Token.literal(new TextEncoder().encode(s))
   const crlfB = lit("\r\n")
   const newlineB = lit("\n")
-  return {
+  const views = {
     alpha0,
     alpha1,
     digit0,
@@ -829,5 +861,8 @@ export const bytes: {
     decBigInt,
     hexUint,
     float
-  } as any
+  }
+  // SAFETY: the string parsers run on byte input unchanged (their slices of a `Uint8Array` are `Uint8Array`s),
+  // so only their declared input and slice types differ from the byte views'
+  return retype<typeof bytes>(views)
 })()

package/src/Binary.ts

@@ -44,45 +44,61 @@ export type Endianness = "big" | "little" | "native"
 
 const nativeLittle = /*#__PURE__*/ new Uint8Array(/*#__PURE__*/ new Uint16Array([1]).buffer)[0] === 1
 
-const fixed = <A>(
-  size: number,
-  name: string,
-  read: (view: DataView, offset: number) => A
-): Parser<A, never, never, Uint8Array> => {
+/** Reads a number at an offset of a state's bytes. */
+type Read<A> = (bytes: Uint8Array, offset: number, state: State<Uint8Array>) => A
+
+/**
+ * A `DataView` of a state's bytes, for the numbers integer arithmetic can't
+ * read: created once per state (whose input never changes), as one per
+ * read cost most of a number's time.
+ */
+const viewOf = (state: State<Uint8Array>): DataView => {
+  const b = state.input
+  return (state.view ??= new DataView(b.buffer, b.byteOffset, b.byteLength))
+}
+
+/** A {@link Read} through the state's view. */
+const viewed =
+  <A>(read: (view: DataView, offset: number) => A): Read<A> =>
+  (_, o, s) =>
+    read(viewOf(s), o)
+
+const fixed = <A>(size: number, name: string, read: Read<A>): Parser<A, never, never, Uint8Array> => {
   const expected = [`${size} byte${size === 1 ? "" : "s"}`]
-  return P.make((state: State<Uint8Array>) => {
-    const pos = state.pos
-    const avail = state.end - pos
-    if (avail < size) return state.eoi("Token", expected, size - avail)
-    const bytes = state.input
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-    state.pos = pos + size
-    return read(view, pos)
-  }, name)
+  return P.described(
+    (state: State<Uint8Array>) => {
+      const pos = state.pos
+      const avail = state.end - pos
+      if (avail < size) return state.eoi("Token", expected, size - avail)
+      state.pos = pos + size
+      return read(state.input, pos, state)
+    },
+    name,
+    { _tag: "Fixed", size, read }
+  )
 }
 
-const readU24 = (little: boolean) => (v: DataView, o: number) =>
-  little
-    ? v.getUint8(o) | (v.getUint8(o + 1) << 8) | (v.getUint8(o + 2) << 16)
-    : (v.getUint8(o) << 16) | (v.getUint8(o + 1) << 8) | v.getUint8(o + 2)
+// Integers of up to 32 bits are read from the bytes; the rest through a view
+const readU24 =
+  (little: boolean): Read<number> =>
+  (b, o) =>
+    little ? b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) : (b[o] << 16) | (b[o + 1] << 8) | b[o + 2]
 
-const readI24 = (little: boolean) => {
+const readI24 = (little: boolean): Read<number> => {
   const u = readU24(little)
-  return (v: DataView, o: number) => {
-    const x = u(v, o)
-    return x & 0x800000 ? x - 0x1000000 : x
-  }
+  return (b, o, s) => (u(b, o, s) << 8) >> 8
 }
 
-const readU128 = (little: boolean) => (v: DataView, o: number) => {
-  const a = v.getBigUint64(o, little)
-  const b = v.getBigUint64(o + 8, little)
-  return little ? (b << 64n) | a : (a << 64n) | b
-}
+const readU128 = (little: boolean): Read<bigint> =>
+  viewed((v, o) => {
+    const a = v.getBigUint64(o, little)
+    const b = v.getBigUint64(o + 8, little)
+    return little ? (b << 64n) | a : (a << 64n) | b
+  })
 
-const readI128 = (little: boolean) => {
+const readI128 = (little: boolean): Read<bigint> => {
   const u = readU128(little)
-  return (v: DataView, o: number) => BigInt.asIntN(128, u(v, o))
+  return (b, o, s) => BigInt.asIntN(128, u(b, o, s))
 }
 
 /**
@@ -91,7 +107,7 @@ const readI128 = (little: boolean) => {
  * @since 0.1.0
  * @category integers
  */
-export const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "u8", (v, o) => v.getUint8(o))
+export const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "u8", (b, o) => b[o])
 
 /**
  * A signed byte.
@@ -99,23 +115,31 @@ export const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
  * @since 0.1.0
  * @category integers
  */
-export const i8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "i8", (v, o) => v.getInt8(o))
+export const i8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "i8", (b, o) => (b[o] << 24) >> 24)
 
 /** @since 0.1.0 @category integers */
-export const beU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "beU16", (v, o) =>
-  v.getUint16(o, false)
+export const beU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  2,
+  "beU16",
+  (b, o) => (b[o] << 8) | b[o + 1]
 )
 /** @since 0.1.0 @category integers */
-export const leU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "leU16", (v, o) =>
-  v.getUint16(o, true)
+export const leU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  2,
+  "leU16",
+  (b, o) => b[o] | (b[o + 1] << 8)
 )
 /** @since 0.1.0 @category integers */
-export const beI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "beI16", (v, o) =>
-  v.getInt16(o, false)
+export const beI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  2,
+  "beI16",
+  (b, o) => (((b[o] << 8) | b[o + 1]) << 16) >> 16
 )
 /** @since 0.1.0 @category integers */
-export const leI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "leI16", (v, o) =>
-  v.getInt16(o, true)
+export const leI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  2,
+  "leI16",
+  (b, o) => ((b[o] | (b[o + 1] << 8)) << 16) >> 16
 )
 /** @since 0.1.0 @category integers */
 export const beU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
@@ -142,36 +166,52 @@ export const leI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fix
   /*#__PURE__*/ readI24(true)
 )
 /** @since 0.1.0 @category integers */
-export const beU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beU32", (v, o) =>
-  v.getUint32(o, false)
+export const beU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "beU32",
+  (b, o) => ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0
 )
 /** @since 0.1.0 @category integers */
-export const leU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leU32", (v, o) =>
-  v.getUint32(o, true)
+export const leU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "leU32",
+  (b, o) => (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0
 )
 /** @since 0.1.0 @category integers */
-export const beI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beI32", (v, o) =>
-  v.getInt32(o, false)
+export const beI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "beI32",
+  (b, o) => (b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]
 )
 /** @since 0.1.0 @category integers */
-export const leI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leI32", (v, o) =>
-  v.getInt32(o, true)
+export const leI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "leI32",
+  (b, o) => b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)
 )
 /** @since 0.1.0 @category integers */
-export const beU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beU64", (v, o) =>
-  v.getBigUint64(o, false)
+export const beU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "beU64",
+  /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, false))
 )
 /** @since 0.1.0 @category integers */
-export const leU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leU64", (v, o) =>
-  v.getBigUint64(o, true)
+export const leU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "leU64",
+  /*#__PURE__*/ viewed((v, o) => v.getBigUint64(o, true))
 )
 /** @since 0.1.0 @category integers */
-export const beI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beI64", (v, o) =>
-  v.getBigInt64(o, false)
+export const beI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "beI64",
+  /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, false))
 )
 /** @since 0.1.0 @category integers */
-export const leI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leI64", (v, o) =>
-  v.getBigInt64(o, true)
+export const leI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "leI64",
+  /*#__PURE__*/ viewed((v, o) => v.getBigInt64(o, true))
 )
 /** @since 0.1.0 @category integers */
 export const beU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
@@ -199,20 +239,28 @@ export const leI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fi
 )
 
 /** @since 0.1.0 @category floats */
-export const beF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beF32", (v, o) =>
-  v.getFloat32(o, false)
+export const beF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "beF32",
+  /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, false))
 )
 /** @since 0.1.0 @category floats */
-export const leF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leF32", (v, o) =>
-  v.getFloat32(o, true)
+export const leF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  4,
+  "leF32",
+  /*#__PURE__*/ viewed((v, o) => v.getFloat32(o, true))
 )
 /** @since 0.1.0 @category floats */
-export const beF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beF64", (v, o) =>
-  v.getFloat64(o, false)
+export const beF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "beF64",
+  /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, false))
 )
 /** @since 0.1.0 @category floats */
-export const leF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leF64", (v, o) =>
-  v.getFloat64(o, true)
+export const leF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  8,
+  "leF64",
+  /*#__PURE__*/ viewed((v, o) => v.getFloat64(o, true))
 )
 
 const byEndian =
@@ -286,11 +334,46 @@ export const f64: (endian: Endianness) => Parser<number, never, never, Uint8Arra
   leF64
 )
 
+const MaxCount = /*#__PURE__*/ BigInt(Number.MAX_SAFE_INTEGER)
+
+/**
+ * Whether a length read from the input is a count: a non-negative integer
+ * of at most `Number.MAX_SAFE_INTEGER`. A signed, fractional or `NaN`
+ * length is the input's to choose, so it fails the parse where it was read
+ * (as `Parser.filter` does) and never reaches `Token.take` or
+ * `Parser.repeat`, which throw on one.
+ */
+const isCount = (n: number | bigint): boolean =>
+  Predicate.isBigInt(n) ? n >= 0n && n <= MaxCount : Number.isSafeInteger(n) && n >= 0
+
 const toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(n) : n)
 
+/** How many counts {@link byCount} keeps the parsers of. */
+const CountCache = 256
+
+/**
+ * `build`, keeping the parsers it built for the first {@link CountCache}
+ * counts seen: length-prefixed data repeats a few lengths, and building a
+ * parser per value cost several times the parse.
+ */
+const byCount = <A>(build: (n: number) => A): ((n: number | bigint) => A) => {
+  const built = new Map<number, A>()
+  return (n) => {
+    const count = toCount(n)
+    let a = built.get(count)
+    if (a === undefined) {
+      a = build(count)
+      if (built.size < CountCache) built.set(count, a)
+    }
+    return a
+  }
+}
+
 /**
  * Parses a length with `count`, then takes that many tokens (winnow's
- * `length_take`, nom's `length_data`).
+ * `length_take`, nom's `length_data`). A length that is not a non-negative
+ * integer (a negative `i8`, a fractional float) fails the parse at the
+ * length.
  *
  * @since 0.1.0
  * @category length-prefixed
@@ -298,17 +381,31 @@ const toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(
 export const lengthTake = <E, R, I extends Input = Uint8Array>(
   count: Parser<number | bigint, E, R, I>
 ): Parser<Slice<I>, E, R, I> => {
-  const countStep = count.step
-  return P.make((state: State<I>) => {
-    const n = countStep(state)
-    if (n === Fail) return Fail
-    return (Token.take<I>(toCount(n)).step as any)(state)
-  }, "lengthTake")
+  const take = byCount((n) => Token.take<I>(n).step)
+  // The count compiles with the grammar: the step is built from its (see `Parser.combinator`)
+  return P.combinator(
+    [count],
+    ([countStep]) =>
+      (state: State<I>) => {
+        const start = state.pos
+        // SAFETY: the count parser's step, interpreted or compiled, returns its output (a number or bigint) or `Fail`
+        const n = countStep(state) as number | bigint | Fail
+        if (n === Fail) return Fail
+        // As `Parser.filter` fails: at the length, backtracking
+        if (!isCount(n)) {
+          state.rewind(start)
+          return state.backtrack("Verify")
+        }
+        return take(n)(state)
+      },
+    "lengthTake"
+  )
 }
 
 /**
  * Parses a length with `count`, then applies `parser` that many times
- * (winnow's `length_repeat`, nom's `length_count`).
+ * (winnow's `length_repeat`, nom's `length_count`). A length that is not a
+ * non-negative integer fails the parse at the length.
  *
  * @since 0.1.0
  * @category length-prefixed
@@ -317,7 +414,10 @@ export const lengthRepeat = <E, R, I extends Input, A, E2, R2, I2 extends Input>
   count: Parser<number | bigint, E, R, I>,
   parser: Parser<A, E2, R2, I2>
 ): Parser<Array<A>, E | E2, R | R2, I & I2> =>
-  P.flatMap(count, (n) => P.repeat(parser, toCount(n)) as Parser<Array<A>, E2, R2, I2>)
+  P.flatMap(
+    P.filter(count, isCount),
+    byCount((n) => P.repeat(parser, n))
+  )
 
 /**
  * Parses a length with `count`, takes that many tokens, and applies
@@ -331,4 +431,5 @@ export const lengthAndThen = <E, R, I extends Input, A, E2, R2>(
   count: Parser<number | bigint, E, R, I>,
   parser: Parser<A, E2, R2, Slice<I> & Input>
 ): Parser<A, E | E2, R | R2, I> =>
+  // SAFETY: a slice of an input is itself an input (a string, a `Uint8Array` or an array), so `Slice<I>` is an `Input`
   P.mapParser(lengthTake(count) as Parser<Slice<I> & Input, E, R, I>, P.complete(parser))

package/src/Bits.ts

@@ -24,6 +24,7 @@ import type { State } from "./Input.js"
 import { Fail, Failure } from "./Input.js"
 import type { Parser } from "./Parser.js"
 import { make } from "./Parser.js"
+import { checkCount } from "./internal/node.js"
 
 declare const BitInputBrand: unique symbol
 
@@ -93,7 +94,7 @@ const inUnits = <A>(state: State<any>, factor: number, step: (state: State<any>)
  * @category combinators
  */
 export const bits = <A, E, R>(self: Parser<A, E, R, BitInput>): Parser<A, E, R, Uint8Array> => {
-  const step = self.step as unknown as (state: State<any>) => A | Fail
+  const step = self.step
   return make((state) => inUnits(state, 8, step), "bits")
 }
 
@@ -105,18 +106,24 @@ export const bits = <A, E, R>(self: Parser<A, E, R, BitInput>): Parser<A, E, R,
  * @category combinators
  */
 export const bytes = <A, E, R>(self: Parser<A, E, R, Uint8Array>): Parser<A, E, R, BitInput> => {
-  const step = self.step as (state: State<any>) => A | Fail
+  const step = self.step
   return make((state: State<any>) => inUnits(state, 1 / 8, step), "bytes")
 }
 
 const readBits = (state: State<any>, count: number): number => {
+  // SAFETY: bit-level parsers run inside `bits`, on the `Uint8Array` it was given (`BitInput` only re-indexes it in bits)
   const input = state.input as Uint8Array
   let pos = state.pos
   let value = 0
-  for (let i = 0; i < count; i++) {
-    const byte = input[pos >>> 3]
-    value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1)
-    pos++
+  let left = count
+  // As many bits as the current byte holds at once, not one at a time
+  while (left > 0) {
+    const avail = 8 - (pos & 7)
+    const n = left < avail ? left : avail
+    // Multiplying, not shifting: the value can have up to 53 bits
+    value = value * (1 << n) + ((input[pos >>> 3] >>> (avail - n)) & ((1 << n) - 1))
+    pos += n
+    left -= n
   }
   state.pos = pos
   return value
@@ -130,6 +137,7 @@ const readBits = (state: State<any>, count: number): number => {
  * @category parsers
  */
 export const take = (count: number): Parser<number, never, never, BitInput> => {
+  checkCount(count)
   if (count > 53) throw new RangeError("Bits.take: use Bits.takeBig for more than 53 bits")
   const expected = [`${count} bits`]
   return make((state: State<any>) => {
@@ -146,6 +154,7 @@ export const take = (count: number): Parser<number, never, never, BitInput> => {
  * @category parsers
  */
 export const takeBig = (count: number): Parser<bigint, never, never, BitInput> => {
+  checkCount(count)
   const expected = [`${count} bits`]
   return make((state: State<any>) => {
     const avail = state.end - state.pos
@@ -169,6 +178,7 @@ export const takeBig = (count: number): Parser<bigint, never, never, BitInput> =
  * @category parsers
  */
 export const pattern = (pattern: number, count: number): Parser<number, never, never, BitInput> => {
+  checkCount(count)
   const expected = [`bit pattern ${pattern.toString(2).padStart(count, "0")}`]
   return make((state: State<any>) => {
     const start = state.pos