@ralphschuler.parser combinator

Module: @ralphschuler/parser-combinator

Table of contents

Enumerations

• InputTypes

Classes

• Parser

Type Aliases

• Err
• InputType
• Ok
• ParserState
• ResultType

Variables

• anyChar
• decoder
• digit
• digits
• encoder
• endOfInput
• getData
• letter
• letters
• optionalWhitespace
• peek
• startOfInput
• whitespace

Functions

• anyCharExcept
• anyOfString
• anythingExcept
• between
• char
• choice
• composeParsers
• coroutine
• decide
• either
• errorMapTo
• everyCharUntil
• everythingUntil
• exactly
• fail
• getCharacterLength
• getNextCharWidth
• getString
• getUtf8Char
• lookAhead
• many
• many1
• mapData
• mapTo
• namedSequenceOf
• parse
• pipeParsers
• possibly
• recursiveParser
• regex
• sepBy
• sepBy1
• sequenceOf
• setData
• skip
• str
• succeedWith
• takeLeft
• takeRight
• tapParser
• toPromise
• toValue
• updateData
• updateError
• updateParserState
• updateResult
• withData

Type Aliases

Err

Ƭ Err<E, D>: Object

Type parameters

Name
E
D

Type declaration

Name	Type
data	D
error	E
index	number
isError	true

Defined in

parser.ts:75

---

InputType

Ƭ InputType: string | ArrayBuffer | DataView | TypedArray

Defined in

inputTypes.ts:12

---

Ok

Ƭ Ok<T, D>: Object

Type parameters

Name
T
D

Type declaration

Name	Type
data	D
index	number
isError	false
result	T

Defined in

parser.ts:82

---

ParserState

Ƭ ParserState<T, E, D>: { dataView: DataView ; inputType: InputType } & InternalResultType<T, E, D>

Type parameters

Name
T
E
D

Defined in

parser.ts:60

---

ResultType

Ƭ ResultType<T, E, D>: Err<E, D> | Ok<T, D>

Type parameters

Name
T
E
D

Defined in

parser.ts:73

Variables

anyChar

• Const anyChar: Parser<string>

Defined in

index.ts:314

---

decoder

• Const decoder: TextDecoder

Defined in

unicode.ts:17

---

digit

• Const digit: Parser<string>

Defined in

index.ts:414

---

digits

• Const digits: Parser<string>

Defined in

index.ts:439

---

encoder

• Const encoder: TextEncoder

Defined in

unicode.ts:16

---

endOfInput

• Const endOfInput: Parser<null, string, any>

Defined in

index.ts:802

---

getData

• Const getData: Parser<any, any, any>

Defined in

index.ts:16

---

letter

• Const letter: Parser<string>

Defined in

index.ts:444

---

letters

• Const letters: Parser<string>

Defined in

index.ts:469

---

optionalWhitespace

• Const optionalWhitespace: Parser<string | null>

Defined in

index.ts:828

---

peek

• Const peek: Parser<number>

Defined in

index.ts:332

---

startOfInput

• Const startOfInput: Parser<null, string, any>

Defined in

index.ts:788

---

whitespace

• Const whitespace: Parser<string>

Defined in

index.ts:820

Functions

anyCharExcept

▸ anyCharExcept(parser): Parser<number, string, any>

Parameters

Name	Type
parser	Parser<any, string, any>

Returns

Parser<number, string, any>

Defined in

index.ts:728

---

anyOfString

▸ anyOfString(s): Parser<string>

Parameters

Name	Type
s	string

Returns

Parser<string>

Defined in

index.ts:474

---

anythingExcept

▸ anythingExcept(parser): Parser<number, string, any>

Parameters

Name	Type
parser	Parser<any, string, any>

Returns

Parser<number, string, any>

Defined in

index.ts:710

---

between

▸ between<L, T, R>(leftParser): (rightParser: Parser<R>) => (parser: Parser<T>) => Parser<T>

Type parameters

Name
L
T
R

Parameters

Name	Type
leftParser	Parser<L, string, any>

Returns

fn

▸ (rightParser): (parser: Parser<T>) => Parser<T>

Parameters

Name	Type
rightParser	Parser<R>

Returns

fn

▸ (parser): Parser<T>

Parameters

Name	Type
parser	Parser<T>

Returns

Parser<T>

Defined in

index.ts:662

---

char

▸ char(c): Parser<string, string, any>

Parameters

Name	Type
c	string

Returns

Parser<string, string, any>

Defined in

index.ts:283

---

choice

▸ choice<A>(«destructured»): Parser<A>

Type parameters

Name
A

Parameters

Name	Type
«destructured»	[Parser<A, string, any>]

Returns

Parser<A>

Defined in

index.ts:623

▸ choice<A, B>(«destructured»): Parser<A | B>

Type parameters

Name
A
B

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>]

Returns

Parser<A | B>

Defined in

index.ts:624

▸ choice<A, B, C>(«destructured»): Parser<A | B | C>

Type parameters

Name
A
B
C

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>]

Returns

Parser<A | B | C>

Defined in

index.ts:625

▸ choice<A, B, C, D>(«destructured»): Parser<A | B | C | D>

Type parameters

Name
A
B
C
D

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>]

Returns

Parser<A | B | C | D>

Defined in

index.ts:626

▸ choice<A, B, C, D, E>(«destructured»): Parser<A | B | C | D | E>

Type parameters

Name
A
B
C
D
E

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>]

Returns

Parser<A | B | C | D | E>

Defined in

index.ts:627

▸ choice<A, B, C, D, E, F>(«destructured»): Parser<A | B | C | D | E | F>

Type parameters

Name
A
B
C
D
E
F

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>]

Returns

Parser<A | B | C | D | E | F>

Defined in

index.ts:628

▸ choice<A, B, C, D, E, F, G>(«destructured»): Parser<A | B | C | D | E | F | G>

Type parameters

Name
A
B
C
D
E
F
G

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G>

Defined in

index.ts:629

▸ choice<A, B, C, D, E, F, G, H>(«destructured»): Parser<A | B | C | D | E | F | G | H>

Type parameters

Name
A
B
C
D
E
F
G
H

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H>

Defined in

index.ts:630

▸ choice<A, B, C, D, E, F, G, H, I>(«destructured»): Parser<A | B | C | D | E | F | G | H | I>

Type parameters

Name
A
B
C
D
E
F
G
H
I

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>, Parser<I, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I>

Defined in

index.ts:631

▸ choice<A, B, C, D, E, F, G, H, I, J>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J>

Defined in

index.ts:632

▸ choice<A, B, C, D, E, F, G, H, I, J, K>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J | K>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J | K>

Defined in

index.ts:633

▸ choice<A, B, C, D, E, F, G, H, I, J, K, L>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J | K | L>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J | K | L>

Defined in

index.ts:634

▸ choice<A, B, C, D, E, F, G, H, I, J, K, L, M>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J | K | L | M>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J | K | L | M>

Defined in

index.ts:635

▸ choice<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J | K | L | M | N>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J | K | L | M | N>

Defined in

index.ts:636

▸ choice<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(«destructured»): Parser<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>

Defined in

index.ts:637

▸ choice(parsers): Parser<any>

Parameters

Name	Type
parsers	Parser<any, string, any>[]

Returns

Parser<any>

Defined in

index.ts:638

---

composeParsers

▸ composeParsers<A, B>(«destructured»): Parser<A>

Type parameters

Name
A
B

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>]

Returns

Parser<A>

Defined in

index.ts:72

▸ composeParsers<A, B, C>(«destructured»): Parser<A>

Type parameters

Name
A
B
C

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>]

Returns

Parser<A>

Defined in

index.ts:73

▸ composeParsers<A, B, C, D>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>]

Returns

Parser<A>

Defined in

index.ts:74

▸ composeParsers<A, B, C, D, E>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>]

Returns

Parser<A>

Defined in

index.ts:75

▸ composeParsers<A, B, C, D, E, F>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>]

Returns

Parser<A>

Defined in

index.ts:76

▸ composeParsers<A, B, C, D, E, F, G>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:77

▸ composeParsers<A, B, C, D, E, F, G, H>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>]

Returns

Parser<A>

Defined in

index.ts:78

▸ composeParsers<A, B, C, D, E, F, G, H, I>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>, Parser<I, string, any>]

Returns

Parser<A>

Defined in

index.ts:79

▸ composeParsers<A, B, C, D, E, F, G, H, I, J>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:80

▸ composeParsers<A, B, C, D, E, F, G, H, I, J, K>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:81

▸ composeParsers<A, B, C, D, E, F, G, H, I, J, K, L>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:82

▸ composeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:83

▸ composeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:84

▸ composeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(«destructured»): Parser<A>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<A>

Defined in

index.ts:85

▸ composeParsers(parsers): Parser<any>

Parameters

Name	Type
parsers	Parser<any, string, any>[]

Returns

Parser<any>

Defined in

index.ts:86

---

coroutine

▸ coroutine<T>(parserFn): Parser<T>

Type parameters

Name
T

Parameters

Name	Type
parserFn	ParserFn<T>

Returns

Parser<T>

Defined in

index.ts:147

---

decide

▸ decide<T, T2, E2, D2>(fn): Parser<T2, E2, D2>

Type parameters

Name
T
T2
E2
D2

Parameters

Name	Type
fn	(value: T) => Parser<T2, E2, D2>

Returns

Parser<T2, E2, D2>

Defined in

index.ts:109

---

either

▸ either<T>(parser): Parser<{ isError: boolean ; value: T }>

Type parameters

Name
T

Parameters

Name	Type
parser	Parser<T, string, any>

Returns

Parser<{ isError: boolean ; value: T }>

Defined in

index.ts:129

---

errorMapTo

▸ errorMapTo<E, E2, D>(fn): Parser<any, E, D>

Type parameters

Name
E
E2
D

Parameters

Name	Type
fn	(error: E, index: number, data: D) => E2

Returns

Parser<any, E, D>

Defined in

index.ts:275

---

everyCharUntil

▸ everyCharUntil(parser): Parser<string, string, any>

Parameters

Name	Type
parser	Parser<any, string, any>

Returns

Parser<string, string, any>

Defined in

index.ts:706

---

everythingUntil

▸ everythingUntil(parser): Parser<number[]>

Parameters

Name	Type
parser	Parser<any, string, any>

Returns

Parser<number[]>

Defined in

index.ts:671

---

exactly

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T]>

Type parameters

Name	Type
T	T
N	extends 1

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T]>

Defined in

index.ts:182

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T]>

Type parameters

Name	Type
T	T
N	extends 2

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T]>

Defined in

index.ts:183

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T]>

Type parameters

Name	Type
T	T
N	extends 3

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T]>

Defined in

index.ts:184

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 4

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T]>

Defined in

index.ts:185

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 5

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T]>

Defined in

index.ts:186

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 6

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T]>

Defined in

index.ts:187

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 7

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T]>

Defined in

index.ts:188

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 8

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T]>

Defined in

index.ts:189

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 9

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:190

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 10

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:191

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 11

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:192

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 12

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:193

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 13

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:194

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 14

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:195

▸ exactly<T, N>(n): (p: Parser<T>) => Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Type parameters

Name	Type
T	T
N	extends 15

Parameters

Name	Type
n	N

Returns

fn

▸ (p): Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]>

Defined in

index.ts:196

▸ exactly<T>(n): (p: Parser<T>) => Parser<T[]>

Type parameters

Name
T

Parameters

Name	Type
n	number

Returns

fn

▸ (p): Parser<T[]>

Parameters

Name	Type
p	Parser<T>

Returns

Parser<T[]>

Defined in

index.ts:197

---

fail

▸ fail<E, D>(errorMessage): Parser<any, E, D>

Type parameters

Name
E
D

Parameters

Name	Type
errorMessage	E

Returns

Parser<any, E, D>

Defined in

index.ts:118

---

getCharacterLength

▸ getCharacterLength(str): number

Parameters

Name	Type
str	string

Returns

number

Defined in

unicode.ts:43

---

getNextCharWidth

▸ getNextCharWidth(index, dataView): 1 | 2 | 3 | 4

Parameters

Name	Type
index	number
dataView	DataView

Returns

1 | 2 | 3 | 4

Defined in

unicode.ts:27

---

getString

▸ getString(index, length, dataView): string

Parameters

Name	Type
index	number
length	number
dataView	DataView

Returns

string

Defined in

unicode.ts:19

---

getUtf8Char

▸ getUtf8Char(index, length, dataView): string

Parameters

Name	Type
index	number
length	number
dataView	DataView

Returns

string

Defined in

unicode.ts:36

---

lookAhead

▸ lookAhead<T, E, D>(parser): Parser<T, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
parser	Parser<T, E, D>

Returns

Parser<T, E, D>

Defined in

index.ts:756

---

many

▸ many<T>(parser): Parser<T[], string, any>

Type parameters

Name
T

Parameters

Name	Type
parser	Parser<T, string, any>

Returns

Parser<T[], string, any>

Defined in

index.ts:225

---

many1

▸ many1<T>(parser): Parser<T[], string, any>

Type parameters

Name
T

Parameters

Name	Type
parser	Parser<T, string, any>

Returns

Parser<T[], string, any>

Defined in

index.ts:252

---

mapData

▸ mapData<T, E, D2>(fn): Parser<T, E, D2>

Type parameters

Name
T
E
D2

Parameters

Name	Type
fn	(data: any) => D2

Returns

Parser<T, E, D2>

Defined in

index.ts:30

---

mapTo

▸ mapTo<T>(fn): Parser<T>

Type parameters

Name
T

Parameters

Name	Type
fn	(x: any) => T

Returns

Parser<T>

Defined in

index.ts:267

---

namedSequenceOf

▸ namedSequenceOf(pairedParsers): Parser<any[]>

Parameters

Name	Type
pairedParsers	[string, Parser<any, string, any>][]

Returns

Parser<any[]>

Defined in

index.ts:501

---

parse

▸ parse<T, E, D>(parser): (target: InputType) => ResultType<T, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
parser	Parser<T, E, D>

Returns

fn

▸ (target): ResultType<T, E, D>

Parameters

Name	Type
target	InputType

Returns

ResultType<T, E, D>

Defined in

index.ts:102

---

pipeParsers

▸ pipeParsers<A>(«destructured»): Parser<A>

Type parameters

Name
A

Parameters

Name	Type
«destructured»	[Parser<A, string, any>]

Returns

Parser<A>

Defined in

index.ts:45

▸ pipeParsers<A, B>(«destructured»): Parser<B>

Type parameters

Name
A
B

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>]

Returns

Parser<B>

Defined in

index.ts:46

▸ pipeParsers<A, B, C>(«destructured»): Parser<C>

Type parameters

Name
A
B
C

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>]

Returns

Parser<C>

Defined in

index.ts:47

▸ pipeParsers<A, B, C, D>(«destructured»): Parser<D>

Type parameters

Name
A
B
C
D

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>]

Returns

Parser<D>

Defined in

index.ts:48

▸ pipeParsers<A, B, C, D, E>(«destructured»): Parser<E>

Type parameters

Name
A
B
C
D
E

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>]

Returns

Parser<E>

Defined in

index.ts:49

▸ pipeParsers<A, B, C, D, E, F>(«destructured»): Parser<F>

Type parameters

Name
A
B
C
D
E
F

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>]

Returns

Parser<F>

Defined in

index.ts:50

▸ pipeParsers<A, B, C, D, E, F, G>(«destructured»): Parser<G>

Type parameters

Name
A
B
C
D
E
F
G

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<G>

Defined in

index.ts:51

▸ pipeParsers<A, B, C, D, E, F, G, H>(«destructured»): Parser<H>

Type parameters

Name
A
B
C
D
E
F
G
H

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>]

Returns

Parser<H>

Defined in

index.ts:52

▸ pipeParsers<A, B, C, D, E, F, G, H, I>(«destructured»): Parser<I>

Type parameters

Name
A
B
C
D
E
F
G
H
I

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>, Parser<I, string, any>]

Returns

Parser<I>

Defined in

index.ts:53

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J>(«destructured»): Parser<J>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<J>

Defined in

index.ts:54

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J, K>(«destructured»): Parser<K>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<K>

Defined in

index.ts:55

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J, K, L>(«destructured»): Parser<L>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<L>

Defined in

index.ts:56

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M>(«destructured»): Parser<M>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<M>

Defined in

index.ts:57

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(«destructured»): Parser<N>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<N>

Defined in

index.ts:58

▸ pipeParsers<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(«destructured»): Parser<O>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<O>

Defined in

index.ts:59

▸ pipeParsers(parsers): Parser<any>

Parameters

Name	Type
parsers	Parser<any, string, any>[]

Returns

Parser<any>

Defined in

index.ts:60

---

possibly

▸ possibly<T, E, D>(parser): Parser<T | null, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
parser	Parser<T, E, D>

Returns

Parser<T | null, E, D>

Defined in

index.ts:767

---

recursiveParser

▸ recursiveParser<T, E, D>(parserThunk): Parser<T, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
parserThunk	() => Parser<T, E, D>

Returns

Parser<T, E, D>

Defined in

index.ts:831

---

regex

▸ regex(re): Parser<string>

Parameters

Name	Type
re	RegExp

Returns

Parser<string>

Defined in

index.ts:377

---

sepBy

▸ sepBy<S, T, E, D>(sepParser): (valueParser: Parser<T, E, D>) => Parser<T[]>

Type parameters

Name
S
T
E
D

Parameters

Name	Type
sepParser	Parser<S, E, D>

Returns

fn

▸ (valueParser): Parser<T[]>

Parameters

Name	Type
valueParser	Parser<T, E, D>

Returns

Parser<T[]>

Defined in

index.ts:563

---

sepBy1

▸ sepBy1<S, T>(sepParser): (valueParser: Parser<T, string, any>) => Parser<T[], string, any>

Type parameters

Name
S
T

Parameters

Name	Type
sepParser	Parser<S, string, any>

Returns

fn

▸ (valueParser): Parser<T[], string, any>

Parameters

Name	Type
valueParser	Parser<T, string, any>

Returns

Parser<T[], string, any>

Defined in

index.ts:604

---

sequenceOf

▸ sequenceOf<A>(«destructured»): Parser<[A]>

Type parameters

Name
A

Parameters

Name	Type
«destructured»	[Parser<A, string, any>]

Returns

Parser<[A]>

Defined in

index.ts:523

▸ sequenceOf<A, B>(«destructured»): Parser<[A, B]>

Type parameters

Name
A
B

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>]

Returns

Parser<[A, B]>

Defined in

index.ts:524

▸ sequenceOf<A, B, C>(«destructured»): Parser<[A, B, C]>

Type parameters

Name
A
B
C

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>]

Returns

Parser<[A, B, C]>

Defined in

index.ts:525

▸ sequenceOf<A, B, C, D>(«destructured»): Parser<[A, B, C, D]>

Type parameters

Name
A
B
C
D

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>]

Returns

Parser<[A, B, C, D]>

Defined in

index.ts:526

▸ sequenceOf<A, B, C, D, E>(«destructured»): Parser<[A, B, C, D, E]>

Type parameters

Name
A
B
C
D
E

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>]

Returns

Parser<[A, B, C, D, E]>

Defined in

index.ts:527

▸ sequenceOf<A, B, C, D, E, F>(«destructured»): Parser<[A, B, C, D, E, F]>

Type parameters

Name
A
B
C
D
E
F

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>]

Returns

Parser<[A, B, C, D, E, F]>

Defined in

index.ts:528

▸ sequenceOf<A, B, C, D, E, F, G>(«destructured»): Parser<[A, B, C, D, E, F, G]>

Type parameters

Name
A
B
C
D
E
F
G

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G]>

Defined in

index.ts:529

▸ sequenceOf<A, B, C, D, E, F, G, H>(«destructured»): Parser<[A, B, C, D, E, F, G, H]>

Type parameters

Name
A
B
C
D
E
F
G
H

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H]>

Defined in

index.ts:530

▸ sequenceOf<A, B, C, D, E, F, G, H, I>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I]>

Type parameters

Name
A
B
C
D
E
F
G
H
I

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>, Parser<H, string, any>, Parser<I, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I]>

Defined in

index.ts:531

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J]>

Defined in

index.ts:532

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J, K>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J, K]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J, K]>

Defined in

index.ts:533

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J, K, L>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J, K, L]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J, K, L]>

Defined in

index.ts:534

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J, K, L, M>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M]>

Defined in

index.ts:535

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N]>

Defined in

index.ts:536

▸ sequenceOf<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(«destructured»): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]>

Type parameters

Name
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O

Parameters

Name	Type
«destructured»	[Parser<A, string, any>, Parser<B, string, any>, Parser<C, string, any>, Parser<D, string, any>, Parser<E, string, any>, Parser<F, string, any>, Parser<G, string, any>]

Returns

Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]>

Defined in

index.ts:537

▸ sequenceOf(parsers): Parser<any[]>

Parameters

Name	Type
parsers	Parser<any, string, any>[]

Returns

Parser<any[]>

Defined in

index.ts:538

---

setData

▸ setData<T, E, D2>(data): Parser<T, E, D2>

Type parameters

Name
T
E
D2

Parameters

Name	Type
data	D2

Returns

Parser<T, E, D2>

Defined in

index.ts:22

---

skip

▸ skip<E, D>(parser): Parser<null, E, D>

Type parameters

Name
E
D

Parameters

Name	Type
parser	Parser<any, E, D>

Returns

Parser<null, E, D>

Defined in

index.ts:777

---

str

▸ str(s): Parser<string>

Parameters

Name	Type
s	string

Returns

Parser<string>

Defined in

index.ts:346

---

succeedWith

▸ succeedWith<T, E, D>(x): Parser<T, E, D>

Type parameters

Name	Type
T	T
E	any
D	null

Parameters

Name	Type
x	T

Returns

Parser<T, E, D>

Defined in

parser.ts:256

---

takeLeft

▸ takeLeft<L, R>(leftParser): (rightParser: Parser<R, string, any>) => Parser<undefined | L, string, any>

Type parameters

Name
L
R

Parameters

Name	Type
leftParser	Parser<L, string, any>

Returns

fn

▸ (rightParser): Parser<undefined | L, string, any>

Parameters

Name	Type
rightParser	Parser<R, string, any>

Returns

Parser<undefined | L, string, any>

Defined in

index.ts:845

---

takeRight

▸ takeRight<L, R>(leftParser): (rightParser: Parser<R, string, any>) => Parser<R, string, any>

Type parameters

Name
L
R

Parameters

Name	Type
leftParser	Parser<L, string, any>

Returns

fn

▸ (rightParser): Parser<R, string, any>

Parameters

Name	Type
rightParser	Parser<R, string, any>

Returns

Parser<R, string, any>

Defined in

index.ts:838

---

tapParser

▸ tapParser<T, E, D>(fn): Parser<T, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
fn	(state: ParserState<T, E, D>) => void

Returns

Parser<T, E, D>

Defined in

index.ts:94

---

toPromise

▸ toPromise<T, E, D>(result): Promise<Awaited<T>>

Type parameters

Name
T
E
D

Parameters

Name	Type
result	ResultType<T, E, D>

Returns

Promise<Awaited<T>>

Defined in

index.ts:852

---

toValue

▸ toValue<T, E, D>(result): T

Type parameters

Name
T
E
D

Parameters

Name	Type
result	ResultType<T, E, D>

Returns

T

Defined in

index.ts:863

---

updateData

▸ updateData<T, E, D, D2>(state, data): ParserState<T, E, D2>

Type parameters

Name
T
E
D
D2

Parameters

Name	Type
state	ParserState<T, E, D>
data	D2

Returns

ParserState<T, E, D2>

Defined in

parser.ts:47

---

updateError

▸ updateError<T, E, D, E2>(state, error): ParserState<T, E2, D>

Type parameters

Name
T
E
D
E2

Parameters

Name	Type
state	ParserState<T, E, D>
error	E2

Returns

ParserState<T, E2, D>

Defined in

parser.ts:41

---

updateParserState

▸ updateParserState<T, E, D, T2>(state, result, index): ParserState<T2, E, D>

Type parameters

Name
T
E
D
T2

Parameters

Name	Type
state	ParserState<T, E, D>
result	T2
index	number

Returns

ParserState<T2, E, D>

Defined in

parser.ts:50

---

updateResult

▸ updateResult<T, E, D, T2>(state, result): ParserState<T2, E, D>

Type parameters

Name
T
E
D
T2

Parameters

Name	Type
state	ParserState<T, E, D>
result	T2

Returns

ParserState<T2, E, D>

Defined in

parser.ts:44

---

withData

▸ withData<T, E, D>(parser): (data: D) => Parser<T, E, D>

Type parameters

Name
T
E
D

Parameters

Name	Type
parser	Parser<T, E, any>

Returns

fn

▸ (data): Parser<T, E, D>

Parameters

Name	Type
data	D

Returns

Parser<T, E, D>

Defined in

index.ts:38