🥮 mooncakes.io

    Areo-Joe/webidl/parser does not have a README file

    Tokens

    source

    An ArrayView represents a view into a section of an array without copying the data. It stores its own start offset and length when it is created, so iteration over a view keeps using those bounds even if the underlying array is later structurally modified.

    Example

    test {
      let arr = [1, 2, 3, 4, 5]
      let view = arr[1:4] // Creates a view of elements at indices 1,2,3
      @test.assert_eq(view[0], 2)
      @test.assert_eq(view.length(), 3)
    }

    Argument

    source
    pub struct Argument {
      extended_attribute_list : ExtendedAttributeList
      argument_rest : ArgumentRest
    }

    ArgumentList

    source
    pub enum ArgumentList {
      Some(Argument, Arguments)
      None
    }

    ArgumentList::iter

    source
    fn ArgumentList::iter(self : ArgumentList) -> Iter[Argument]

    ArgumentList::parse

    source

    ArgumentName

    source
    pub enum ArgumentName {
      ArgumentNameKeyword(ArgumentNameKeyword)
      Identifier(StringView)
    }

    ArgumentNameKeyword

    source
    pub enum ArgumentNameKeyword {
      Attribute
      Callback
      Const
      Constructor
      Deleter
      Dictionary
      Enum
      Getter
      Includes
      Inherit
      Interface
      Iterable
      Maplike
      Mixin
      Namespace
      Partial
      Readonly
      Required
      Setlike
      Setter
      Static
      Stringifier
      Typedef
      Unrestricted
    } derive(
    Debug    )

    ArgumentRest

    source
    pub enum ArgumentRest {
      Optional(TypeWithExtendedAttributes, ArgumentName, Default)
      Ellipsisable(Type, Ellipsis, ArgumentName)
    }

    Arguments

    source
    pub enum Arguments {
      Some(Argument, Arguments)
      None
    }

    Arguments::iter

    source
    fn Arguments::iter(self : Arguments) -> Iter[Argument]

    Arguments::parse

    source

    AsyncIterable

    source
    pub struct AsyncIterable {
      type_with_extended_attributes : TypeWithExtendedAttributes
      optional_type : OptionalType
      optional_argument_list : OptionalArgumentList
    }

    AttributeName

    source
    pub enum AttributeName {
      AttributeNameKeyword(AttributeNameKeyword)
      Identifier(StringView)
    }

    AttributeNameKeyword

    source
    pub enum AttributeNameKeyword {
      Required
    }

    AttributeRest

    source
    pub struct AttributeRest {
      type_with_extended_attributes : TypeWithExtendedAttributes
      attribute_name : AttributeName
    }

    BooleanLiteral

    source
    pub enum BooleanLiteral {
      True
      False
    }

    BufferRelatedType

    source
    pub enum BufferRelatedType {
      ArrayBuffer
      SharedArrayBuffer
      DataView
      Int8Array
      Int16Array
      Int32Array
      Uint8Array
      Uint16Array
      Uint32Array
      Uint8ClampedArray
      BigInt64Array
      BigUint64Array
      Float16Array
      Float32Array
      Float64Array
    } derive(
    Debug    )

    CallbackInterfaceMember

    source
    pub enum CallbackInterfaceMember {
      Const(Const)
      RegularOperation(RegularOperation)
    }

    CallbackInterfaceMembers

    source
    pub enum CallbackInterfaceMembers {
      Some(ExtendedAttributeList, CallbackInterfaceMember, CallbackInterfaceMembers)
      None
    }

    CallbackOrInterfaceOrMixin

    source
    pub enum CallbackOrInterfaceOrMixin {
      Callback(CallbackRestOrInterface)
      Interface(InterfaceOrMixin)
    }

    CallbackRest

    source
    pub struct CallbackRest {
      identifier : StringView
      type_ : Type
      argument_list : ArgumentList
    }

    CallbackRestOrInterface

    source
    pub enum CallbackRestOrInterface {
      CallbackRest(CallbackRest)
      Interface(StringView, CallbackInterfaceMembers)
    }

    Const

    source
    pub struct Const {
      const_type : ConstType
      identifier : StringView
      const_value : ConstValue
    }

    ConstType

    source
    pub enum ConstType {
      PrimitiveType(PrimitiveType)
      Identifier(StringView)
    }

    ConstValue

    source
    pub enum ConstValue {
      BooleanLiteral(BooleanLiteral)
      FloatLiteral(FloatLiteral)
      Integer(StringView)
    }

    Constructor

    source
    pub struct Constructor {
      argument_list : ArgumentList
    }

    Default

    source
    pub enum Default {
      Some(DefaultValue)
      None
    }

    DefaultValue

    source
    pub enum DefaultValue {
      ConstValue(ConstValue)
      String(StringView)
      Brackets
      Braces
      Null
      Undefined
    }

    Definition

    source
    pub enum Definition {
      CallbackOrInterfaceOrMixin(CallbackOrInterfaceOrMixin)
      Namespace(Namespace)
      Partial(Partial)
      Dictionary(Dictionary)
      Enum(Enum)
      Typedef(Typedef)
      IncludesStatement(IncludesStatement)
    }

    Definitions

    source
    pub enum Definitions {
      Some(ExtendedAttributeList, Definition, Definitions)
      None
    }

    Definitions::iter

    source

    Definitions::parse

    source
    #as_free_fn(parse, visibility="pub")
    fn Definitions::parse(input : ArrayView[(
    TokenType    , StringView)]) -> (Definitions, ArrayView[(
    TokenType    , StringView)])

    Dictionary

    source
    pub struct Dictionary {
      identifier : StringView
      inheritance : Inheritance
      dictionary_members : DictionaryMembers
    }

    DictionaryMember

    source
    pub struct DictionaryMember {
      extended_attribute_list : ExtendedAttributeList
      dictionary_member_rest : DictionaryMemberRest
    }

    DictionaryMemberRest

    source
    pub enum DictionaryMemberRest {
      Required(TypeWithExtendedAttributes, StringView)
      Optional(Type, StringView, Default)
    }

    DictionaryMembers

    source
    pub enum DictionaryMembers {
      Some(DictionaryMember, DictionaryMembers)
      None
    }

    DistinguishableType

    source
    pub enum DistinguishableType {
      PrimitiveType(PrimitiveType, Null)
      StringType(StringType, Null)
      Identifier(StringView, Null)
      Sequence(TypeWithExtendedAttributes, Null)
      AsyncSequence(TypeWithExtendedAttributes, Null)
      Object(Null)
      Symbol(Null)
      BufferRelatedType(BufferRelatedType, Null)
      FrozenArray(TypeWithExtendedAttributes, Null)
      ObservableArray(TypeWithExtendedAttributes, Null)
      RecordType(RecordType, Null)
      Undefined(Null)
    }

    Ellipsis

    source
    pub enum Ellipsis {
      Some
      None
    }

    Enum

    source
    pub struct Enum {
      identifier : StringView
      enum_value_list : EnumValueList
    }

    EnumValueList

    source
    pub struct EnumValueList {
      string : StringView
      enum_value_list_comma : EnumValueListComma
    }

    EnumValueList::iter

    source
    fn EnumValueList::iter(self : EnumValueList) -> Iter[StringView]

    EnumValueList::parse

    source

    EnumValueListComma

    source
    pub enum EnumValueListComma {
      Some(EnumValueListString)
      None
    }

    EnumValueListString

    source
    pub enum EnumValueListString {
      Some(StringView, EnumValueListComma)
      None
    }

    ExtendedAttribute

    source

    ExtendedAttributeArgList

    source
    pub struct ExtendedAttributeArgList {
      identifier : StringView
      argument_list : ArgumentList
    }

    ExtendedAttributeDecimal

    source
    pub struct ExtendedAttributeDecimal {
      identifier : StringView
      value : StringView
    }

    ExtendedAttributeIdent

    source
    pub struct ExtendedAttributeIdent {
      identifier : StringView
      value : StringView
    }

    ExtendedAttributeIdentList

    source
    pub struct ExtendedAttributeIdentList {
      identifier : StringView
      identifier_list : IdentifierList
    }

    ExtendedAttributeInner

    source

    ExtendedAttributeInteger

    source
    pub struct ExtendedAttributeInteger {
      identifier : StringView
      value : StringView
    }

    ExtendedAttributeIntegerList

    source
    pub struct ExtendedAttributeIntegerList {
      identifier : StringView
      integer_list : IntegerList
    }

    ExtendedAttributeList

    source
    pub enum ExtendedAttributeList {
      Some(ExtendedAttribute, ExtendedAttributes)
      None
    } derive(
    Debug    )

    ExtendedAttributeNamedArgList

    source
    pub struct ExtendedAttributeNamedArgList {
      identifier : StringView
      value : StringView
      argument_list : ArgumentList
    }

    ExtendedAttributeNoArgs

    source
    pub struct ExtendedAttributeNoArgs {
      identifier : StringView
    }

    ExtendedAttributeRest

    source
    pub enum ExtendedAttributeRest {
      ExtendedAttribute(ExtendedAttribute)
      None
    } derive(
    Debug    )

    ExtendedAttributeString

    source
    pub struct ExtendedAttributeString {
      identifier : StringView
      value : StringView
    }

    ExtendedAttributeWildcard

    source
    pub struct ExtendedAttributeWildcard {
      identifier : StringView
    }

    ExtendedAttributes

    source
    pub enum ExtendedAttributes {
      Some(ExtendedAttribute, ExtendedAttributes)
      None
    } derive(
    Debug    )

    FloatLiteral

    source
    pub enum FloatLiteral {
      Decimal(StringView)
      NegativeInfinity
      Infinity
      NaN
    }

    FloatType

    source
    pub enum FloatType {
      Float
      Double
    }

    IdentifierList

    source
    pub struct IdentifierList {
      identifier : StringView
      identifiers : Identifiers
    }

    IdentifierList::iter

    source
    fn IdentifierList::iter(self : IdentifierList) -> Iter[StringView]

    IdentifierList::parse

    source

    Identifiers

    source
    pub enum Identifiers {
      Some(StringView, Identifiers)
      None
    }

    Identifiers::iter

    source
    fn Identifiers::iter(self : Identifiers) -> Iter[StringView]

    Identifiers::parse

    source

    IncludesStatement

    source
    pub struct IncludesStatement {
      interface_identifier : StringView
      mixin_identifier : StringView
    }

    InheritAttribute

    source
    pub struct InheritAttribute {
      attribute_rest : AttributeRest
    }

    Inheritance

    source
    pub enum Inheritance {
      Some(StringView)
      None
    }

    IntegerList

    source
    pub struct IntegerList {
      integer : StringView
      integers : Integers
    }

    IntegerList::iter

    source
    fn IntegerList::iter(self : IntegerList) -> Iter[StringView]

    IntegerList::parse

    source

    IntegerType

    source
    pub enum IntegerType {
      Short
      Long(OptionalLong)
    }

    Integers

    source
    pub enum Integers {
      Some(StringView, Integers)
      None
    }

    Integers::iter

    source
    fn Integers::iter(self : Integers) -> Iter[StringView]

    Integers::parse

    source

    InterfaceMember

    source
    pub enum InterfaceMember {
      PartialInterfaceMember(PartialInterfaceMember)
      Constructor(Constructor)
    }

    InterfaceMembers

    source
    pub enum InterfaceMembers {
      Some(ExtendedAttributeList, InterfaceMember, InterfaceMembers)
      None
    }

    InterfaceOrMixin

    source
    pub enum InterfaceOrMixin {
      InterfaceRest(InterfaceRest)
      MixinRest(MixinRest)
    }

    InterfaceRest

    source
    pub struct InterfaceRest {
      identifier : StringView
      inheritance : Inheritance
      interface_members : InterfaceMembers
    }

    Iterable

    source
    pub struct Iterable {
      type_with_extended_attributes : TypeWithExtendedAttributes
      optional_type : OptionalType
    }

    MaplikeRest

    source
    pub struct MaplikeRest {
      key_type : TypeWithExtendedAttributes
      value_type : TypeWithExtendedAttributes
    }

    MixinMember

    source
    pub enum MixinMember {
      Const(Const)
      RegularOperation(RegularOperation)
      Stringifier(Stringifier)
      Attribute(OptionalReadOnly, AttributeRest)
    }

    MixinMembers

    source
    pub enum MixinMembers {
      Some(ExtendedAttributeList, MixinMember, MixinMembers)
      None
    }

    MixinRest

    source
    pub struct MixinRest {
      identifier : StringView
      mixin_members : MixinMembers
    }

    Namespace

    source
    pub struct Namespace {
      identifier : StringView
      namespace_members : NamespaceMembers
    }

    NamespaceMember

    source
    pub enum NamespaceMember {
      RegularOperation(RegularOperation)
      ReadOnlyAttribute(AttributeRest)
      Const(Const)
    }

    NamespaceMembers

    source
    pub enum NamespaceMembers {
      Some(ExtendedAttributeList, NamespaceMember, NamespaceMembers)
      None
    }

    Null

    source
    pub enum Null {
      Some
      None
    } derive(
    Debug    )

    Operation

    source
    pub enum Operation {
      RegularOperation(RegularOperation)
      SpecialOperation(SpecialOperation)
    }

    OperationName

    source
    pub enum OperationName {
      OperationNameKeyword(OperationNameKeyword)
      Identifier(StringView)
    }

    OperationNameKeyword

    source
    pub enum OperationNameKeyword {
      Includes
    }

    OperationRest

    source
    pub struct OperationRest {
      optional_operation_name : OptionalOperationName
      argument_list : ArgumentList
    }

    OptionalArgumentList

    source
    pub enum OptionalArgumentList {
      Some(ArgumentList)
      None
    }

    OptionalLong

    source
    pub enum OptionalLong {
      Long
      None
    }

    OptionalOperationName

    source
    pub enum OptionalOperationName {
      Some(OperationName)
      None
    }

    OptionalReadOnly

    source
    pub enum OptionalReadOnly {
      ReadOnly
      None
    } derive(
    Debug    )

    OptionalType

    source
    pub enum OptionalType {
      Some(TypeWithExtendedAttributes)
      None
    }

    Other

    source
    pub enum Other {
      Integer(StringView)
      Decimal(StringView)
      Identifier(StringView)
      String(StringView)
      Other(StringView)
      Minus
      NegativeInfinity
      Dot
      Ellipsis
      Colon
      Semicolon
      LessThan
      Equal
      GreaterThan
      QuestionMark
      Asterisk
      ByteString
      DOMString
      FrozenArray
      Infinity
      NaN
      ObservableArray
      Promise
      USVString
      Any
      Bigint
      Boolean
      Byte
      Double
      False
      Float
      Long
      Null
      Object
      Octet
      Or
      Optional
      Record
      Sequence
      Short
      Symbol
      True
      Unsigned
      Undefined
      ArgumentNameKeyword(ArgumentNameKeyword)
      BufferRelatedType(BufferRelatedType)
    } derive(
    Debug    )

    OtherOrComma

    source
    pub enum OtherOrComma {
      Other(Other)
      Comma
    } derive(
    Debug    )

    Partial

    source
    pub struct Partial {
      partial_definition : PartialDefinition
    }

    PartialDefinition

    source
    pub enum PartialDefinition {
      Interface(PartialInterfaceOrPartialMixin)
      Dictionary(PartialDictionary)
      Namespace(Namespace)
    }

    PartialDictionary

    source
    pub struct PartialDictionary {
      identifier : StringView
      dictionary_members : DictionaryMembers
    }

    PartialInterfaceMember

    source
    pub enum PartialInterfaceMember {
      Const(Const)
      Operation(Operation)
      Stringifier(Stringifier)
      StaticMember(StaticMember)
      Iterable(Iterable)
      AsyncIterable(AsyncIterable)
      ReadOnlyMember(ReadOnlyMember)
      ReadWriteAttribute(ReadWriteAttribute)
      ReadWriteMaplike(ReadWriteMaplike)
      ReadWriteSetlike(ReadWriteSetlike)
      InheritAttribute(InheritAttribute)
    }

    PartialInterfaceMembers

    source
    pub enum PartialInterfaceMembers {
      Some(ExtendedAttributeList, PartialInterfaceMember, PartialInterfaceMembers)
      None
    }

    PartialInterfaceOrPartialMixin

    source
    pub enum PartialInterfaceOrPartialMixin {
      PartialInterfaceRest(PartialInterfaceRest)
      MixinRest(MixinRest)
    }

    PartialInterfaceRest

    source
    pub struct PartialInterfaceRest {
      identifier : StringView
      partial_interface_members : PartialInterfaceMembers
    }

    PrimitiveType

    source
    pub enum PrimitiveType {
      UnsignedIntegerType(UnsignedIntegerType)
      UnrestrictedFloatType(UnrestrictedFloatType)
      Boolean
      Byte
      Octet
      Bigint
    }

    PromiseType

    source
    pub struct PromiseType {
      type_ : Type
    }

    ReadOnlyMember

    source
    pub struct ReadOnlyMember {
      read_only_member_rest : ReadOnlyMemberRest
    }

    ReadOnlyMemberRest

    source
    pub enum ReadOnlyMemberRest {
      Attribute(AttributeRest)
      Maplike(MaplikeRest)
      Setlike(SetlikeRest)
    }

    ReadWriteAttribute

    source
    pub struct ReadWriteAttribute {
      attribute_rest : AttributeRest
    }

    ReadWriteMaplike

    source
    pub struct ReadWriteMaplike {
      maplike_rest : MaplikeRest
    }

    ReadWriteSetlike

    source
    pub struct ReadWriteSetlike {
      setlike_rest : SetlikeRest
    }

    RecordType

    source
    pub struct RecordType {
      string_type : StringType
      type_with_extended_attributes : TypeWithExtendedAttributes
    }

    RegularOperation

    source
    pub struct RegularOperation {
      type_ : Type
      operation_rest : OperationRest
    }

    SetlikeRest

    source
    pub struct SetlikeRest {
      type_with_extended_attributes : TypeWithExtendedAttributes
    }

    SingleType

    source
    pub enum SingleType {
      DistinguishableType(DistinguishableType)
      Any
      PromiseType(PromiseType)
    }

    Special

    source
    pub enum Special {
      Getter
      Setter
      Deleter
    }

    SpecialOperation

    source
    pub struct SpecialOperation {
      special : Special
      regular_operation : RegularOperation
    }

    StaticMember

    source
    pub struct StaticMember {
      static_member_rest : StaticMemberRest
    }

    StaticMemberRest

    source
    pub enum StaticMemberRest {
      Attribute(OptionalReadOnly, AttributeRest)
      RegularOperation(RegularOperation)
    }

    StringType

    source
    pub enum StringType {
      ByteString
      DOMString
      USVString
    } derive(
    Debug    )

    Stringifier

    source
    pub struct Stringifier {
      stringifier_rest : StringifierRest
    }

    StringifierRest

    source
    pub enum StringifierRest {
      Attribute(OptionalReadOnly, AttributeRest)
      Semicolon
    }

    Type

    source
    pub enum Type {
      SingleType(SingleType)
      UnionType(UnionType, Null)
    }

    TypeWithExtendedAttributes

    source
    pub struct TypeWithExtendedAttributes {
      extended_attribute_list : ExtendedAttributeList
      type_ : Type
    }

    Typedef

    source
    pub struct Typedef {
      type_with_extended_attributes : TypeWithExtendedAttributes
      identifier : StringView
    }

    UnionMemberType

    source
    pub enum UnionMemberType {
      UnionType(UnionType, Null)
      DistinguishableTypeWithExtendedAttributeList(DistinguishableType, ExtendedAttributeList)
    }

    UnionMemberTypes

    source
    pub enum UnionMemberTypes {
      Some(UnionMemberType, UnionMemberTypes)
      None
    }

    UnionMemberTypes::iter

    source

    UnionMemberTypes::parse

    source

    UnionType

    source
    pub struct UnionType {
      first_union_member_type : UnionMemberType
      second_union_member_type : UnionMemberType
      union_member_types : UnionMemberTypes
    }

    UnionType::iter

    source

    UnionType::parse

    source

    UnrestrictedFloatType

    source
    pub enum UnrestrictedFloatType {
      UnrestrictedFloatType(FloatType)
      FloatType(FloatType)
    }

    UnsignedIntegerType

    source
    pub enum UnsignedIntegerType {
      UnsignedIntegerType(IntegerType)
      IntegerType(IntegerType)
    }

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io