🥮 mooncakes.io
README

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 issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io