🥮 mooncakes.io
    Sign in

    moonbit-community/graphql/parser does not have a README file

    ParseError

    source
    pub(all) suberror ParseError {
      GraphQLParseError(String, Pos)
    } derive(Eq)

    Error raised by tokenizer, query parser, and schema parser.

    Each parse error carries the source position where parsing failed.
    impl Show for ParseError

    ParseError::equal

    source
    fn ParseError::equal(ParseError, ParseError) -> Bool

    ParseError::not_equal

    source
    fn ParseError::not_equal(x : ParseError, y : ParseError) -> Bool

    ParseError::output

    source
    fn ParseError::output(self : ParseError, logger : &Logger) -> Unit

    ParseError::to_string

    source
    fn ParseError::to_string(self : ParseError) -> String

    Render a parse error with line and column context.

    Directive

    source
    pub(all) struct Directive {
      position : Pos
      name : String
      arguments : Array[(String, Value)]
    } derive(Eq, 
    Debug    )

    GraphQL directive use with parsed arguments.

    Directive::equal

    source
    fn Directive::equal(Directive, Directive) -> Bool

    Directive::not_equal

    source
    fn Directive::not_equal(x : Directive, y : Directive) -> Bool

    Directive::to_repr

    source

    DirectiveDefinition

    source
    pub(all) struct DirectiveDefinition {
      position : Pos
      description : String?
      name : String
      arguments : Array[InputValue]
      repeatable : Bool
      locations : Array[DirectiveLocation]
    } derive(Eq, 
    Debug    )

    SDL directive definition.

    DirectiveDefinition::equal

    source

    DirectiveDefinition::not_equal

    source

    DirectiveDefinition::to_repr

    source

    DirectiveLocation

    source
    pub(all) enum DirectiveLocation {
      LocationQuery
      LocationMutation
      LocationSubscription
      LocationField
      LocationFragmentDefinition
      LocationFragmentSpread
      LocationInlineFragment
      LocationSchema
      LocationScalar
      LocationObject
      LocationFieldDefinition
      LocationArgumentDefinition
      LocationInterface
      LocationUnion
      LocationEnum
      LocationEnumValue
      LocationInputObject
      LocationInputFieldDefinition
      LocationVariableDefinition
    } derive(Eq, 
    Debug    )

    GraphQL directive location.

    DirectiveLocation::as_string

    source
    fn DirectiveLocation::as_string(self : DirectiveLocation) -> String

    Return the canonical GraphQL spec name for a directive location.

    DirectiveLocation::equal

    source

    DirectiveLocation::is_query

    source
    fn DirectiveLocation::is_query(self : DirectiveLocation) -> Bool

    Return true when this location belongs to executable GraphQL documents.

    DirectiveLocation::is_schema

    source
    fn DirectiveLocation::is_schema(self : DirectiveLocation) -> Bool

    Return true when this location belongs to GraphQL SDL.

    DirectiveLocation::not_equal

    source
    fn DirectiveLocation::not_equal(x : DirectiveLocation, y : DirectiveLocation) -> Bool

    DirectiveLocation::to_repr

    source

    EnumType

    source
    pub(all) struct EnumType {
      position : Pos
      description : String?
      name : String
      directives : Array[Directive]
      values : Array[EnumValue]
    } derive(Eq, 
    Debug    )

    SDL enum type definition.

    EnumType::equal

    source
    fn EnumType::equal(EnumType, EnumType) -> Bool

    EnumType::not_equal

    source
    fn EnumType::not_equal(x : EnumType, y : EnumType) -> Bool

    EnumType::to_repr

    source

    EnumTypeExtension

    source
    pub(all) struct EnumTypeExtension {
      position : Pos
      name : String
      directives : Array[Directive]
      values : Array[EnumValue]
    } derive(Eq, 
    Debug    )

    SDL enum type extension.

    EnumTypeExtension::equal

    source

    EnumTypeExtension::not_equal

    source
    fn EnumTypeExtension::not_equal(x : EnumTypeExtension, y : EnumTypeExtension) -> Bool

    EnumTypeExtension::to_repr

    source

    EnumValue

    source
    pub(all) struct EnumValue {
      position : Pos
      description : String?
      name : String
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    SDL enum value definition.

    EnumValue::equal

    source
    fn EnumValue::equal(EnumValue, EnumValue) -> Bool

    EnumValue::not_equal

    source
    fn EnumValue::not_equal(x : EnumValue, y : EnumValue) -> Bool

    EnumValue::to_repr

    source

    Field

    source
    pub(all) struct Field {
      position : Pos
      field_alias : String?
      name : String
      arguments : Array[(String, Value)]
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Field selection with optional alias, arguments, directives, and nested selection set.

    Field::equal

    source
    fn Field::equal(Field, Field) -> Bool

    Field::not_equal

    source
    fn Field::not_equal(x : Field, y : Field) -> Bool

    Field::to_repr

    source

    FragmentDefinition

    source
    pub(all) struct FragmentDefinition {
      position : Pos
      name : String
      type_condition : TypeCondition
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Named fragment definition.

    FragmentDefinition::equal

    source

    FragmentDefinition::not_equal

    source

    FragmentDefinition::to_repr

    source

    FragmentSpread

    source
    pub(all) struct FragmentSpread {
      position : Pos
      fragment_name : String
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    Reference to a named fragment.

    FragmentSpread::equal

    source

    FragmentSpread::not_equal

    source
    fn FragmentSpread::not_equal(x : FragmentSpread, y : FragmentSpread) -> Bool

    FragmentSpread::to_repr

    source

    GqlType

    source
    pub(all) enum GqlType {
      NamedType(String)
      ListType(GqlType)
      NonNullType(GqlType)
    } derive(Eq, 
    Debug    )

    GraphQL type reference used by variable, field, and input definitions.

    GqlType::equal

    source
    fn GqlType::equal(GqlType, GqlType) -> Bool

    GqlType::not_equal

    source
    fn GqlType::not_equal(x : GqlType, y : GqlType) -> Bool

    GqlType::to_repr

    source

    InlineFragment

    source
    pub(all) struct InlineFragment {
      position : Pos
      type_condition : TypeCondition?
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Inline fragment with optional type condition.

    InlineFragment::equal

    source

    InlineFragment::not_equal

    source
    fn InlineFragment::not_equal(x : InlineFragment, y : InlineFragment) -> Bool

    InlineFragment::to_repr

    source

    InputObjectType

    source
    pub(all) struct InputObjectType {
      position : Pos
      description : String?
      name : String
      directives : Array[Directive]
      fields : Array[InputValue]
    } derive(Eq, 
    Debug    )

    SDL input object type definition.

    InputObjectType::equal

    source

    InputObjectType::not_equal

    source
    fn InputObjectType::not_equal(x : InputObjectType, y : InputObjectType) -> Bool

    InputObjectType::to_repr

    source

    InputObjectTypeExtension

    source
    pub(all) struct InputObjectTypeExtension {
      position : Pos
      name : String
      directives : Array[Directive]
      fields : Array[InputValue]
    } derive(Eq, 
    Debug    )

    SDL input object type extension.

    InputObjectTypeExtension::equal

    source

    InputObjectTypeExtension::not_equal

    source

    InputObjectTypeExtension::to_repr

    source

    InputValue

    source
    pub(all) struct InputValue {
      position : Pos
      description : String?
      name : String
      value_type : GqlType
      default_value : Value?
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    SDL input field or argument definition.

    InputValue::equal

    source
    fn InputValue::equal(InputValue, InputValue) -> Bool

    InputValue::not_equal

    source
    fn InputValue::not_equal(x : InputValue, y : InputValue) -> Bool

    InputValue::to_repr

    source

    InterfaceType

    source
    pub(all) struct InterfaceType {
      position : Pos
      description : String?
      name : String
      implements_interfaces : Array[String]
      directives : Array[Directive]
      fields : Array[SchemaField]
    } derive(Eq, 
    Debug    )

    SDL interface type definition.

    InterfaceType::equal

    source

    InterfaceType::not_equal

    source
    fn InterfaceType::not_equal(x : InterfaceType, y : InterfaceType) -> Bool

    InterfaceType::to_repr

    source

    InterfaceTypeExtension

    source
    pub(all) struct InterfaceTypeExtension {
      position : Pos
      name : String
      implements_interfaces : Array[String]
      directives : Array[Directive]
      fields : Array[SchemaField]
    } derive(Eq, 
    Debug    )

    SDL interface type extension.

    InterfaceTypeExtension::equal

    source

    InterfaceTypeExtension::not_equal

    source

    InterfaceTypeExtension::to_repr

    source

    Mutation

    source
    pub(all) struct Mutation {
      position : Pos
      name : String?
      variable_definitions : Array[VariableDefinition]
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Parsed mutation operation.

    Mutation::equal

    source
    fn Mutation::equal(Mutation, Mutation) -> Bool

    Mutation::not_equal

    source
    fn Mutation::not_equal(x : Mutation, y : Mutation) -> Bool

    Mutation::to_repr

    source

    Number

    source
    pub(all) struct Number {
      value : Int64
    } derive(Eq, 
    Debug    )

    Integer literal wrapper.

    GraphQL integer literals are parsed as Int64 so tooling can preserve the full accepted input range before application-level coercion.

    Number::as_int64

    source
    fn Number::as_int64(self : Number) -> Int64

    Return the parsed integer literal as Int64.

    Number::equal

    source
    fn Number::equal(Number, Number) -> Bool

    Number::not_equal

    source
    fn Number::not_equal(x : Number, y : Number) -> Bool

    Number::to_repr

    source

    ObjectType

    source
    pub(all) struct ObjectType {
      position : Pos
      description : String?
      name : String
      implements_interfaces : Array[String]
      directives : Array[Directive]
      fields : Array[SchemaField]
    } derive(Eq, 
    Debug    )

    SDL object type definition.

    ObjectType::equal

    source
    fn ObjectType::equal(ObjectType, ObjectType) -> Bool

    ObjectType::not_equal

    source
    fn ObjectType::not_equal(x : ObjectType, y : ObjectType) -> Bool

    ObjectType::to_repr

    source

    ObjectTypeExtension

    source
    pub(all) struct ObjectTypeExtension {
      position : Pos
      name : String
      implements_interfaces : Array[String]
      directives : Array[Directive]
      fields : Array[SchemaField]
    } derive(Eq, 
    Debug    )

    SDL object type extension.

    ObjectTypeExtension::equal

    source

    ObjectTypeExtension::not_equal

    source

    ObjectTypeExtension::to_repr

    source

    OperationDefinition

    source
    pub(all) enum OperationDefinition {
      SelectionSetOperation(SelectionSet)
      QueryOperation(Query)
      MutationOperation(Mutation)
      SubscriptionOperation(Subscription)
    } derive(Eq, 
    Debug    )

    GraphQL operation definition, including shorthand selection-set operations.

    OperationDefinition::equal

    source

    OperationDefinition::not_equal

    source

    OperationDefinition::to_repr

    source

    Pos

    source
    pub(all) struct Pos {
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    1-based source position in a GraphQL document.

    Pos::equal

    source
    fn Pos::equal(Pos, Pos) -> Bool

    Pos::not_equal

    source
    fn Pos::not_equal(x : Pos, y : Pos) -> Bool

    Pos::to_repr

    source

    Query

    source
    pub(all) struct Query {
      position : Pos
      name : String?
      variable_definitions : Array[VariableDefinition]
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Parsed query operation.

    Query::equal

    source
    fn Query::equal(Query, Query) -> Bool

    Query::not_equal

    source
    fn Query::not_equal(x : Query, y : Query) -> Bool

    Query::to_repr

    source

    QueryDefinition

    source
    pub(all) enum QueryDefinition {
      OperationDefinition(OperationDefinition)
      FragmentDefinition(FragmentDefinition)
    } derive(Eq, 
    Debug    )

    Top-level executable document definition.

    QueryDefinition::equal

    source

    QueryDefinition::not_equal

    source
    fn QueryDefinition::not_equal(x : QueryDefinition, y : QueryDefinition) -> Bool

    QueryDefinition::to_repr

    source

    QueryDocument

    source
    pub(all) struct QueryDocument {
      definitions : Array[QueryDefinition]
    } derive(Eq, 
    Debug    )

    Parsed executable GraphQL document.

    QueryDocument::equal

    source

    QueryDocument::format

    source
    fn QueryDocument::format(self : QueryDocument, style? : Style) -> String

    Format an executable GraphQL document with a stable canonical layout.

    QueryDocument::not_equal

    source
    fn QueryDocument::not_equal(x : QueryDocument, y : QueryDocument) -> Bool

    QueryDocument::output

    source
    fn QueryDocument::output(self : QueryDocument, logger : &Logger) -> Unit

    QueryDocument::to_repr

    source

    QueryDocument::to_string

    source
    fn QueryDocument::to_string(self : QueryDocument) -> String

    Format an executable GraphQL document using the default style.

    ScalarType

    source
    pub(all) struct ScalarType {
      position : Pos
      description : String?
      name : String
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    SDL scalar type definition.

    ScalarType::equal

    source
    fn ScalarType::equal(ScalarType, ScalarType) -> Bool

    ScalarType::not_equal

    source
    fn ScalarType::not_equal(x : ScalarType, y : ScalarType) -> Bool

    ScalarType::to_repr

    source

    ScalarTypeExtension

    source
    pub(all) struct ScalarTypeExtension {
      position : Pos
      name : String
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    SDL scalar type extension.

    ScalarTypeExtension::equal

    source

    ScalarTypeExtension::not_equal

    source

    ScalarTypeExtension::to_repr

    source

    SchemaDefinition

    source
    pub(all) enum SchemaDefinition {
      SchemaDef(SchemaDefinitionData)
      TypeDef(TypeDefinition)
      TypeExt(TypeExtension)
      DirectiveDef(DirectiveDefinition)
    } derive(Eq, 
    Debug    )

    Top-level SDL definition.

    SchemaDefinition::equal

    source

    SchemaDefinition::not_equal

    source
    fn SchemaDefinition::not_equal(x : SchemaDefinition, y : SchemaDefinition) -> Bool

    SchemaDefinition::to_repr

    source

    SchemaDefinitionData

    source
    pub(all) struct SchemaDefinitionData {
      position : Pos
      directives : Array[Directive]
      query : String?
      mutation : String?
      subscription : String?
    } derive(Eq, 
    Debug    )

    Explicit schema { ... } root operation mapping.

    SchemaDefinitionData::equal

    source

    SchemaDefinitionData::not_equal

    source

    SchemaDefinitionData::to_repr

    source

    SchemaDocument

    source
    pub(all) struct SchemaDocument {
      definitions : Array[SchemaDefinition]
    } derive(Eq, 
    Debug    )

    Parsed GraphQL schema document.

    SchemaDocument::equal

    source

    SchemaDocument::format

    source
    fn SchemaDocument::format(self : SchemaDocument, style? : Style) -> String

    Format an SDL document with a stable canonical layout.

    SchemaDocument::not_equal

    source
    fn SchemaDocument::not_equal(x : SchemaDocument, y : SchemaDocument) -> Bool

    SchemaDocument::output

    source
    fn SchemaDocument::output(self : SchemaDocument, logger : &Logger) -> Unit

    SchemaDocument::to_repr

    source

    SchemaDocument::to_string

    source
    fn SchemaDocument::to_string(self : SchemaDocument) -> String

    Format an SDL document using the default style.

    SchemaField

    source
    pub(all) struct SchemaField {
      position : Pos
      description : String?
      name : String
      arguments : Array[InputValue]
      field_type : GqlType
      directives : Array[Directive]
    } derive(Eq, 
    Debug    )

    SDL object or interface field definition.

    SchemaField::equal

    source
    fn SchemaField::equal(SchemaField, SchemaField) -> Bool

    SchemaField::not_equal

    source
    fn SchemaField::not_equal(x : SchemaField, y : SchemaField) -> Bool

    SchemaField::to_repr

    source

    Selection

    source
    pub(all) enum Selection {
      FieldSelection(Field)
      FragmentSpreadSelection(FragmentSpread)
      InlineFragmentSelection(InlineFragment)
    } derive(Eq, 
    Debug    )

    GraphQL field, fragment spread, or inline fragment selection.

    Selection::equal

    source
    fn Selection::equal(Selection, Selection) -> Bool

    Selection::not_equal

    source
    fn Selection::not_equal(x : Selection, y : Selection) -> Bool

    Selection::to_repr

    source

    SelectionSet

    source
    pub(all) struct SelectionSet {
      span : (Pos, Pos)
      items : Array[Selection]
    } derive(Eq, 
    Debug    )

    Non-empty selection set with start and end source positions.

    SelectionSet::equal

    source

    SelectionSet::not_equal

    source
    fn SelectionSet::not_equal(x : SelectionSet, y : SelectionSet) -> Bool

    SelectionSet::to_repr

    source

    Style

    source
    pub(all) struct Style {
      indent : Int
      multiline_arguments : Bool
    } derive(Eq, 
    Debug    )

    Pretty-printer options for parsed query and schema documents.

    Style::default

    source
    fn Style::default() -> Style

    Default formatting style: two-space indentation and inline arguments.

    Style::equal

    source
    fn Style::equal(Style, Style) -> Bool

    Style::not_equal

    source
    fn Style::not_equal(x : Style, y : Style) -> Bool

    Style::to_repr

    source

    Style::with_indent

    source
    fn Style::with_indent(self : Style, indent : Int) -> Style

    Return a copy of the style with a new indentation width.

    Style::with_multiline_arguments

    source
    fn Style::with_multiline_arguments(self : Style, multiline_arguments : Bool) -> Style

    Return a copy of the style with multiline argument formatting toggled.

    Subscription

    source
    pub(all) struct Subscription {
      position : Pos
      name : String?
      variable_definitions : Array[VariableDefinition]
      directives : Array[Directive]
      selection_set : SelectionSet
    } derive(Eq, 
    Debug    )

    Parsed subscription operation.

    Subscription::equal

    source

    Subscription::not_equal

    source
    fn Subscription::not_equal(x : Subscription, y : Subscription) -> Bool

    Subscription::to_repr

    source

    Token

    source
    pub(all) struct Token {
      kind : TokenKind
      value : String
      position : Pos
      start_offset : Int
      end_offset : Int
      next_offset : Int
    } derive(Eq, 
    Debug    )

    GraphQL token with source span and the offset after ignored trivia.

    start_offset and end_offset cover the token itself. next_offset points to the next non-ignored source position after whitespace and comments.

    Token::equal

    source
    fn Token::equal(Token, Token) -> Bool

    Token::not_equal

    source
    fn Token::not_equal(x : Token, y : Token) -> Bool

    Token::to_repr

    source

    TokenKind

    source
    pub(all) enum TokenKind {
      TkPunctuator
      TkName
      TkIntValue
      TkFloatValue
      TkStringValue
      TkBlockString
      TkEof
    } derive(Eq, 
    Debug    )

    Token category emitted by the GraphQL tokenizer.
    impl Show for TokenKind

    TokenKind::equal

    source
    fn TokenKind::equal(TokenKind, TokenKind) -> Bool

    TokenKind::not_equal

    source
    fn TokenKind::not_equal(x : TokenKind, y : TokenKind) -> Bool

    TokenKind::output

    source
    fn TokenKind::output(self : TokenKind, logger : &Logger) -> Unit

    TokenKind::to_repr

    source

    TokenKind::to_string

    source
    fn TokenKind::to_string(self : TokenKind) -> String

    TypeCondition

    source
    pub(all) enum TypeCondition {
      On(String)
    } derive(Eq, 
    Debug    )

    Fragment type condition.

    TypeCondition::equal

    source

    TypeCondition::not_equal

    source
    fn TypeCondition::not_equal(x : TypeCondition, y : TypeCondition) -> Bool

    TypeCondition::to_repr

    source

    TypeDefinition

    source
    pub(all) enum TypeDefinition {
      ScalarTypeDef(ScalarType)
      ObjectTypeDef(ObjectType)
      InterfaceTypeDef(InterfaceType)
      UnionTypeDef(UnionType)
      EnumTypeDef(EnumType)
      InputObjectTypeDef(InputObjectType)
    } derive(Eq, 
    Debug    )

    SDL type definition.

    TypeDefinition::equal

    source

    TypeDefinition::not_equal

    source
    fn TypeDefinition::not_equal(x : TypeDefinition, y : TypeDefinition) -> Bool

    TypeDefinition::to_repr

    source

    TypeExtension

    source
    pub(all) enum TypeExtension {
      ScalarTypeExt(ScalarTypeExtension)
      ObjectTypeExt(ObjectTypeExtension)
      InterfaceTypeExt(InterfaceTypeExtension)
      UnionTypeExt(UnionTypeExtension)
      EnumTypeExt(EnumTypeExtension)
      InputObjectTypeExt(InputObjectTypeExtension)
    } derive(Eq, 
    Debug    )

    SDL type extension.

    TypeExtension::equal

    source

    TypeExtension::not_equal

    source
    fn TypeExtension::not_equal(x : TypeExtension, y : TypeExtension) -> Bool

    TypeExtension::to_repr

    source

    UnionType

    source
    pub(all) struct UnionType {
      position : Pos
      description : String?
      name : String
      directives : Array[Directive]
      types : Array[String]
    } derive(Eq, 
    Debug    )

    SDL union type definition.

    UnionType::equal

    source
    fn UnionType::equal(UnionType, UnionType) -> Bool

    UnionType::not_equal

    source
    fn UnionType::not_equal(x : UnionType, y : UnionType) -> Bool

    UnionType::to_repr

    source

    UnionTypeExtension

    source
    pub(all) struct UnionTypeExtension {
      position : Pos
      name : String
      directives : Array[Directive]
      types : Array[String]
    } derive(Eq, 
    Debug    )

    SDL union type extension.

    UnionTypeExtension::equal

    source

    UnionTypeExtension::not_equal

    source

    UnionTypeExtension::to_repr

    source

    Value

    source
    pub(all) enum Value {
      Variable(String)
      IntValue(Number)
      FloatValue(Double)
      StringValue(String)
      BooleanValue(Bool)
      NullValue
      EnumValue(String)
      ListValue(Array[Value])
      ObjectValue(Array[(String, Value)])
    } derive(Eq, 
    Debug    )

    GraphQL literal or variable value.

    This representation preserves GraphQL-specific distinctions such as enum values versus strings and variables versus their eventual runtime values.

    Value::equal

    source
    fn Value::equal(Value, Value) -> Bool

    Value::not_equal

    source
    fn Value::not_equal(x : Value, y : Value) -> Bool

    Value::to_repr

    source

    VariableDefinition

    source
    pub(all) struct VariableDefinition {
      position : Pos
      name : String
      var_type : GqlType
      default_value : Value?
    } derive(Eq, 
    Debug    )

    Variable declaration from an operation definition.

    VariableDefinition::equal

    source

    VariableDefinition::not_equal

    source

    VariableDefinition::to_repr

    source

    consume_definition

    source
    fn consume_definition(source : String) -> (QueryDefinition, String) raise ParseError

    Parse the first executable GraphQL definition and return the unconsumed tail.

    This is useful for stream-like tooling that receives concatenated GraphQL definitions and wants to consume them one at a time.

    minify_query

    source
    fn minify_query(source : String) -> String raise ParseError

    Minify an executable GraphQL document while preserving token boundaries.

    The result removes ignored whitespace and comments, inserting a single space only when two adjacent non-punctuator tokens would otherwise merge.

    parse_query

    source
    fn parse_query(source : String) -> QueryDocument raise ParseError

    Parse a complete executable GraphQL document.

    The document may contain operations and fragment definitions. Empty input and trailing tokens raise ParseError.

    parse_schema

    source
    fn parse_schema(source : String) -> SchemaDocument raise ParseError

    Parse a complete GraphQL SDL document.

    The parser accepts schema definitions, type definitions, type extensions, and directive definitions, preserving descriptions and source positions in the returned AST.

    tokenize

    source
    fn tokenize(source : String) -> Array[Token] raise ParseError

    Tokenize a GraphQL source document.

    The returned array always ends with a TkEof token. Whitespace, commas, and comments are skipped but reflected in token offsets.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io