type IriParser[A] = 
@thy1016/moonttl/parserc.Parser
Parser[Char, Result[A, IriError]]

type Predicate = ArrayView[Byte]

using @moonbitlang/core/ref { type Ref }

type ResParser[A] = (Result[A, IriError], 
@thy1016/moonttl/parserc.Seq
Seq[Char])?

type Span = (Int, Int)

pub trait DebugLogger {
  fn info(Self, String) -> Unit
  fn error(Self, String) -> Unit
  fn warn(Self, String) -> Unit
}

pub trait ErrOut {
  fn message(self : Self) -> String
  fn err_kind(self : Self) -> String
}

pub trait ParserEngine {
  fn error_recovery_state(Self) -> Self
  fn create_pending(Self) -> PendingQuad
  fn step(Self, pending : PendingQuad, token : Token) -> StepResult
  fn is_complete(Self, pending : PendingQuad) -> Bool
  fn recognize_end(Self, pending : PendingQuad, results : Array[(Int, Int)]) -> Unit
}

pub(all) suberror IriError {
  NoScheme(Int)
  InvalidScheme(Char, Int)
  InvalidCharacter(Char, Int)
  InvalidPath(Int)
  InvalidAuthority(String)
  InvalidPercentEncoding(Int)
  UnexpectedEnd(Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) suberror LanguageTagParseError {
  TagParseErr(TagParseErr)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) suberror ParseError {
  InvalidErrMessage(String)
  InvalidToken(String, (Int, Int))
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) suberror TagParseErr {
  EmptyExtension
  EmptyPrivateUse
  ForbiddenChar
  InvalidSubtag(Int, StringView)
  InvalidLanguage
  SubtagTooLong
  EmptySubtag
  TooManyExtlangs
  InvalidLanguageLength
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum BaseDirection {
  Ltr
  Rtl
} derive(Eq, Hash, ToJson, 
@moonbitlang/core/debug.Debug
Debug)

type ConsoleLogger

pub(all) struct ExtensionsIterator {
  input : StringView
  subtags : Array[StringView]
  index : Int
}

pub(all) enum GraphName {
  None
  Iri(ArrayView[Byte])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct IriR {
  scheme : StringView
  authority : StringView?
  path : StringView
  query : StringView?
  fragment : StringView?
} derive(Default, Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct LanguageTag {
  tag : StringView
  positions : TagElementsPositions
} derive(Default, Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Lexerc {
  ptr : 
@moonbitlang/core/ref.Ref
Ref[Void]
  data : FixedArray[Byte]
  offset : Int
  token_buf : FixedArray[Byte]
}

type MuteLogger

pub(all) struct NQuadsEngine {
  lexer : Lexerc
  pending : PendingQuad
}

pub(all) enum Object {
  Iri(ArrayView[Byte])
  BNode(ArrayView[Byte])
  Literal(ArrayView[Byte])
  PrefName(ArrayView[Byte])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Parser[E] {
  lexer : Lexerc
  engine : E
  pending : PendingQuad
  errors : Array[ParseError]
  data : ArrayView[Byte]
}

pub struct ParserIter[E] {
  parser : Parser[E]
}

pub struct PendingQuad {
  subj : (Int, Int)?
  pred : (Int, Int)?
  obj : (Int, Int)?
  graph : (Int, Int)?
  has_dot : Bool
  state : PendingState
  line : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum PendingState {
  ExpectSubject
  ExpectPredicate
  ExpectObject
  ExpectDotOrGraph
  ExpectGraph
  ExpectDot
  Complete
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct QuadEmit {
  subject : Subject
  predicate : ArrayView[Byte]
  object : Object
  graph_name : GraphName
  line : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct QuadSpan {
  subj : (Int, Int)
  pred : (Int, Int)
  obj : (Int, Int)
  graph : (Int, Int)?
  line : Int
  subj_type : TermType
  obj_type : TermType
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Range {
  start : Int
  end : Int
} derive(Default, Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Serializer {
  data : ArrayView[Byte]
  mode : StringView
}

pub struct SliceParser[E] {
  inner : ParserIter[E]
  data : ArrayView[Byte]
  lenient : Bool
}

pub(all) enum StepResult {
  Continue
  Emit
  SkipLine
  Error(ParseError)
}

pub(all) enum Subject {
  Iri(ArrayView[Byte])
  BNode(ArrayView[Byte])
  PrefName(ArrayView[Byte])
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum SubtagType {
  PrivateUseIntro
  ExtensionIntro(Char)
  Alphabetic(Int)
  Numeric(Int)
  Alphanumeric(Int)
  Invalid
}

type TagElementsPositions derive(Default, Eq, Hash, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum TermType {
  Unknown
  Iri
  BNode
  Literal
  PrefName
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Token {
  Dot((Int, Int))
  Semicolon((Int, Int))
  Comma((Int, Int))
  Iri((Int, Int))
  Literal((Int, Int))
  BlankNode((Int, Int))
  PrefName((Int, Int))
  Unknown((Int, Int))
  EOF(Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

type Void

let MAX_BUFFER_SIZE : Int

let MIN_BUFFER_SIZE : Int

let MIN_PARALLEL_CHUNK_SIZE : Int

fn array_to_view(arr : ArrayView[Byte]) -> BytesView

fn array_view_has_prefix(data : ArrayView[Byte], prefix : Bytes) -> Bool

fn array_view_memchr(target : Byte, data : ArrayView[Byte]) -> Int?

fn array_view_memchr2(c1 : Byte, c2 : Byte, data : ArrayView[Byte]) -> Int?

fn classify_subtag(s : StringView) -> SubtagType

fn end_offset(span : (Int, Int)) -> Int

fn find_newline_in_range(bytes : BytesView, start : Int, end : Int) -> Int?

fn fn_remove_dot_segments(path : StringView) -> StringView

fn from_str_radix(s : String, radix : Int) -> Result[UInt, String]

async fn get_ntriples_file_chunks(file : 
@moonbitlang/async/fs.File
File, file_size : Int64, n_chunks : Int) -> Result[Array[(Int64, Int64)], String]