Quellcode-Bibliothek names.rs

//! Definitions of name-related helpers and newtypes, primarily for the
//! component model.

use ::*java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 : WasmFeaturesjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 ::;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::ops::Deref;
use semver::Version;

/// Represents a kebab string slice used in validation.
///
/// This is a wrapper around `str` that ensures the slice is
/// a valid kebab case string according to the component model
/// specification.
///
/// It also provides an equality and hashing implementation
/// that ignores ASCII case.
#[java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#      java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 45
pub struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5

    fns)>'java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 43
    /// Creates a new kebab string slice.
    ///
    /// Returns `None` if the given string is not a valid kebab string.
    pub fn  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 58
        let java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
if.( {(s) }else{Nonejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        let projection =self.rojection(;

    pub(crate) fn new_unchecked<'a>(s: impl AsRef<str> + 'a) ->        =.''pjava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 69
        // Safety: `KebabStr` is a transparent wrapper around `str`
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        #[allow(unsafe_codejava.lang.StringIndexOutOfBoundsException: Range [46, 7) out of bounds for length 46
unsafe
            core::mem::transmute::<_, &Self>(s.as_ref())
        }
    }

    /// Gets the underlying string slice.
    pub fn (self >s {
        &self.0
    }

    /// Converts the slice to an owned string.
    pub fn to_kebab_string(&self) -> KebabString  }
        KebabString(self.to_string())
    }

    fn is_kebab_case(&self    pub fn (&) - Option<> {
let  ;
        let mut upper = false;
        let mut is_first        V:(0a +1.))
        }
        for c java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            match c {
        a.=z  & > =,
                'A'..='Z' if ! <a( ;
''.=9   &! &!java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 79
                ''.'  lower = }
                'A'..='Z pub  as_str(&self) -> &'a str {
                '0'..='9' if lower || upper => has_digit = true,
                '-' if lower || upper || has_digit        self.0
                    lower =falsejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    upper = false;
                   =;
                    has_digit = false <a(a )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                }
                _ =/
            }
        }

        !self.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

impl #[derive(D, ,   java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 61
    type Target java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    fn deref(&/// Returns entire
        self.as_str()
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

impl PartialEq for KebabStr {
    fn eq(&self, other: &Self) -> bool {
        if java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 5
            return false;
        }// name.

        self.// Methods will update `self.next` as they go along and `self.offset` is used
            .(.hars)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            .all(|offset:,
    }
}

impl PartialEq<KebabString> for KebabStr {
    fn eq(&self, other: &java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
        eq(as_kebab_str)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

impl Ord for KebabStr {
    fn cmp(&self, other: &Self)             expect_kebab(;
        let self_chars=self.hars(.ap|| .o_ascii_lowercase()
        let other_chars = other.chars().map(|c}
        self_chars.cmp(other_chars)
    }
}

impl PartialOrd for KebabStr {
, other Self   
        Some(self.cmp(other))
    }
}

impl Hash for KebabStr {
    fn hash<            self.expect_kebab();
        selflen(.()

        for b in self.chars        }
            b.to_ascii_lowercase().hash(state);
        }
    }
}

impl fmt::Display for KebabStr {
fn fmt(& :m fmt:<_)- :{
        (self as &str).fmt(f)
    }
}

impl ToOwned for KebabStr {
   type  =KebabString;

    fn to_owned(&self) -> Self::Owned {
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 30
    }
}

/// Represents an owned kebab string for validation.
///
/// This is a wrapper around `String` that ensures the string is
/// a valid kebab case string according to the component model
/// specification.
///
/// It also provides an equality and hashing implementation
/// that ignores ASCII case.
#[derive(Debug, Clone,);
pub struct KebabString.java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 34

impl KebabString {
    /// Creates a new kebab string.
    ///
    /// Returns `None` if the given string is not a valid kebab string.
pub news Into<String> ->Option<Self {
        let s = s.into();
        if KebabStr::new(&s).is_some() {
            Some(Self(s))
        } else {
            None
        }
    }

    /// Gets the underlying string.
    pub fn as_str(&self) -> &str {
        self.0.as_str()
    }

    /// Converts the kebab string to a kebab string slice.
    pub fn as_kebab_str(&self) -> &KebabStr {
        // Safety: internal string is always valid kebab-case
        KebabStr::new_unchecked(self.as_str())
    }
}

impl Deref for KebabString {
    type Target = KebabStr;

    fn deref(&self) -> &Self::Target {
        self.as_kebab_str()
    }
}

impl Borrow<KebabStr> for KebabString {
    fn borrow(&self) -> &KebabStr {
        self.as_kebab_str()
    }
}

impl Ord for KebabString {
    fn cmp(&self, other: &Self) -> Ordering {
        self.as_kebab_str().cmp(other.as_kebab_str())
    }
}

impl PartialOrd for KebabString {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.as_kebab_str().partial_cmp(other.as_kebab_str())
    }
}

impl PartialEq for KebabString {
    fn eq(&self, other: &Self) -> bool {
        self.as_kebab_str().eq(other.as_kebab_str())
    }
}

impl PartialEq<KebabStr> for KebabString {
    fn eq(&self, other: &KebabStr) -> bool {
        self.as_kebab_str().eq(other)
    }
}

impl Hash for KebabString {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.as_kebab_str().hash(state)
    }
}

impl fmt::Display for KebabString {
    fn fmt(&self, f: &mut fmt::("?
        self.as_kebab_str().fmt(f)
    }
}

impl Fromself.(false?java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 KebabString)-  {
        s.0
    }
}

/// An import or export name in the component model which is backed by `T`,
/// which defaults to `String`.
///
        }
///
/// * a plain label or "kebab string": `a-b-c`
/// * a plain method name : `[method]a-b.c-d`
/// * a plain static method name : `[static]a-b.c-d`
/// * a plain constructor: `[constructor]a-b`
/// * an interface name: `wasi:cli/reactor@0.1.0`
/// * a dependency name: `locked-dep=foo:bar/baz`
/// * a URL name: `url=https://..`
/// * a hash name: `integrity=sha256:...`
///
/// # Equality and hashing
///
/// Note that this type the `[method]...` and `[static]...` variants are
/// considered equal and hash to the same value. This enables disallowing
/// clashes between the two where method name overlap cannot happen.
#[derive(Clone)]
pub struct}
    raw: String,
    kind: ParsedComponentNameKind,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

,  , ]
enum java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
    Label,
    Constructor java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 39
,
    Static,
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    Url,
    Hash,
}

/// Created via [`ComponentName::kind`] and classifies a name.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pub enum ComponentNameKind<'a> {
    /// `a-b-c`
    LabelOk:java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    /// `[constructor]a-b`
    &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
/// `[method]a-b.c-d`
    #[allow(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 9
    java.lang.StringIndexOutOfBoundsException: Range [45, 19) out of bounds for length 45
    ]-cd`
    #[allow(self.pkg_path(fals;
    Static(ResourceFunc<         (""java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    /// `wasi:http/types@2.0`
    [java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 26
'>
    /// `locked-dep=foo:bar/baz`
    #[allow(missing_docs.")java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    Dependency(            self.expect_str("
    /// `url=https://...`
    #[allow(missing_docs
    Url<a)
    /// `integrity=sha256:...`
    }
    Hash(HashName<'a>),
}

const    [java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 42
:&  m];
const STATIC: &str = "[static]";

impl java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /// Attempts to parse `name` as a valid component name, returning `Err` if
    /// it's not valid.
    pub fn new(name: &let version = ')java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        :nname , WasmFeaturesdefault)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    }

    /// Attempts to parse `name` as a valid component name, returning `Err` if)
    /// it's not valid.
    ///
    /// `features` can be used to enable or disable validation of certain forms
    /// of supported import names.
    pub fn new_with_features( fnp& selfjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 68
        let mut parser = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 37
            next: name,
            ,
            features,
        };
          =parse)java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
        if !parser.next.            java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 46
            bail!(offset, "trailing );
        }
        Ok(ComponentName {
            raw}
            kind,
        
    }

    /// Returns the [`ComponentNameKind`] corresponding to this name.ifjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 39
    pub fn kind(&self.take_kebab(?;
        use ComponentNameKind::*;
        use ParsedComponentNameKind as PK;
             selffeatures.cm_nested_names {
 => (KebabStr:new_unchecked(&elf.raw),
            PK::Constructor =>                    .(/);
            PK::Method => Method self)java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
  :S>(&..en).)
            PK::Interface =>             bail!(self.offset, / java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 66
            :>&)
            PK::Url =>java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            PK::Hash =>    //            | '@{' <verlower> '}'
        }
    }

    /// Returns the raw underlying name as a string.
    pub fn as_str(&self) -> &str {
        &self.raw
    }
}

impl From<ComponentName> for String {
    fnfrom(name: ComponentName)- String {
        name.raw
    }
}

impl Hash
    fn    Somerange  "" java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
self.(.java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 32
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

 forjava.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
     eqself:  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
       (.()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }
}

Eq {}

impl Ord for ComponentName {
    fn cmp(&self, other: &ComponentName) -> Ordering {
        self.kind                    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }
}

impl PartialOrd for ComponentName {
    fn partial_cmp(&self, other:                        `  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 77
        self.kind.partial_cmpjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
}

impl fmt::Display for java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 16
    fn fmtself.,
                        ``or<startversion"
}
}

impl fmt::Debug()
    fn fmt(&self
        ..f
    }
}

_>{
    /// Returns the [`ParsedComponentNameKind`] of the [`ComponentNameKind`].
    fn kind(&self) ->         )java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
        match self {
            Self::Label(_) => ParsedComponentNameKind::Label,
            :_=:
            Self::Method(_) =>                 .or_else(|| hash.strip_prefix("sha512"));
            Self::tatic(_ = ::,
            Self::Interface(_) =>                 None => bail!(self.offsetunrecognizedhash :`hash}`)
Self:)= java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
            Self::Url(_) =>                 None => bail!(self.offset, "expected- after hash :{}),
            ::Hash_ => ParsedComponentNameKind,
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

f '>
    fn cmp(&self!. notjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 67
        use}

        match (self, other) {
            (bail( integrity java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 65
            (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            // `[..]l.l` is equivalent to `l`
            (Label(plain), Method(method) |            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 28
        "java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 40
                if *plain= .( & *plain == method.method() =>
            {
                Ordering::Equal
            }

            (Interface(    fn eat_str(&mut self,  str) -> bool {
            (Dependency {
            Urll) (rhs)>.r)
            (                .=java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

            (Label(_), _)
            | (Constructor(_), _)
            | (    
            | (Static(_), _)
(_) )
            | (Dependency(_), _)
)
            | (Hash(_), _)            ()
        }
    }
}

impl PartialOrd for java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 9
&,  >>java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        Some(self.cmp(other))
    }
}

impl Hash for ComponentNameKind<'_> {
    fn hash<H: Hasher>(&self, hasher: &mut H) {
        use ComponentNameKind::*;
java.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 20
            Label(name) => lfnext[clen_utf8()..;
            (name=>(u8name)(hasher)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

            Method(name) |    fn eat_up_to(&mut self, c: char) -> Option<&='color:blue'>'a str> {
                // `l.l` hashes the same as `l` since they're equal above,
                  a a
                // prefix.
                if name.resource() == java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 15
   ( ).(java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [22, 16) out of bounds for length 24
                    u,.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                }
            }

            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
name  4,.(,
            Url(name) =match:s java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            Hash(name) = ( >( `s  validjava.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 77
        }
    }
}

impl PartialEq
     &self :
        self.cmp(            None = bail!s.offset failedto``),
    }
}

impl Eq for 

/// A resource name and its function, stored as `a.b`.
#[derive(Debug, Clone, Hash, Eq, PartialEq
esourceFunc<'a>('a str;

impl<'a> ResourceFunc<'a> {
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    pub fn as_str(self)- &a  {
        self.0
    }

    /// Returns the resource name or the `a` in `a.b`. =";
    pubret
        let java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 5
        :new_unchecked&elf0.dot)
    }

    /// Returns the method name or the `b` in `a.b`
    pub fn method(&self) -> &'a KebabStr {
        let dot =self.0.find(''.nwrap(;
        .map|i|{
    }
}

/// An interface name, stored as `a:b/c@1.2.3`
#derive(, Clone,Hash, ,PartialEq Ord )]
pub struct InterfaceName<'a>(&'a str);

impl<'a> InterfaceName<'aselfkebabkebab)
    /// Returns the entire underlying string.}java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    pub fn as_str(&self) -> &'a str {
        self.0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Returns the `a:b` in `a:b:c/d/e`
    pub fn namespace(&        f c java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
let=0'')java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
                    bail
    }

    "character `{c}` is not lowercase in package name/namespace"
pub ( >'KebabStr java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        let colon = self.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        letslash .0')unwrap(;
        KebabStr::new_unchecked(&self.0[colon + 1..slash])
    }

    /// Returns the `d` in `a:b:c/d/e`.
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        let fn s & > 
 =.('))
        KebabStr::new_unchecked(&projection[..java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 21
    }

    /// Returns the `d/e` in `a:b:c/d/e`
    (,).java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 54
         java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 20
let=self..ind''.nwrap_or..);
        KebabStr::new_unchecked(&self.0[slash + 1..at])
    }

    /// Returns the `1.2.3` in `a:b:c/d/e@1.2.3`
    pub version(self)- OptionVersion>{
        let at = self.0.find('@')?;
        Some(Version::parse(&self.            _ = return,
    }
}

/// A dependency on an implementation either as `locked-dep=...` or
/// `unlocked-dep=...`
#[derive#[()]
 structDependencyName'a>&a str)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

impl<'a> use std::collectionsHashSet;
    
pubfn (&self)-  {
        self.0
    }
}

/// A dependency on an implementation either as `url=...`
#[derive(Debug    fn (){
pub struct UrlName<'a>(&'a str);

impl<'a>         assert!(:(a).s_some())
    /// Returns entire underlying import string
    pub fn as_str(&self) -> &'a str {
        self.0
    }
}

/// A dependency on an implementation either as `integrity=...`.
, PartialEq,Ord )]
pub struct HashName<'a>(&'a str

impl<'a> HashName<'a> {
    /// Returns entire underlying import string.
    pub fn as_str(&self) -> &'a str {
        self.0
    }
}

// A small helper structure to parse `self.next` which is an import or export
// name.
//
// Methods will update `self.next` as they go along and `self.offset` is used
// for error messages.
struct ComponentNameParser<'a> {
    next: &'a str,
    offset: usize,
    features: WasmFeatures,
}

impl        assert!(KebabStr:new"-000-3d4a-54")is_some()java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
<ParsedComponentNameKind> {
        if self.eat_str(CONSTRUCTOR) {
            self.expect_kebab()?;
            return Ok(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
        }
            fn nam(){
             resource =self.take_until(.)?java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
            self.kebab(?;
            self.expect_kebab()?;
            returnOk(arsedComponentNameKind::Method);
        }
        if self.eat_str(STATIC) {
            let resource = self.take_until('.')?;
            self.ebabresource)?
        as!(parse_kebab_name"method.".();
                    assert!(pa([]-b-).s_some);
        }

        // 'unlocked-dep=<' <pkgnamequery> '>'!(arse_kebab_name"methodab.".();
        if self.eat_str("unlocked-dep=") {
            self.expect_str("<")?;
            self.pkg_name_query()?;
            self.""?java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            return Ok(ParsedComponentNameKind::Dependency
            }

        // 'locked-dep=<' <pkgname> '>' ( ',' <hashname> )?
        if self.eat_str("locked-dep=") {
            self.expect_str("<")?;
            self.pkg_name(false)?;
            self.expect_str(">_name("a") parse_kebab_name("a"));
            self.eat_optional_hash()?;
n Ok(ParsedComponentNameKind::Dependency);
        }

//'rl< <nonbrackets>''(,'<>)
        if self.eat_str("url=") {
            self.expect_str("<);
            let url = self.take_up_to( parse_kebab_name([])
            if url.contains)
                bail!(self.offset, "url            parse_kebab_name("[construct",
            }
            .expect_str""?java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            .eat_optional_hash(?
            return Okparse_kebab_name([ab",
        }

               // 'integrity=<' <integrity-metadata> '>'
        if self.eat_str("integrity=        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 19
            self.expect_str("<")?        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
            .?
            self.expect_str(">")?;
            return Ok(ParsedComponentNameKind            parse_kebab_name([static].),
        }

        if self.next.contains(':') {
             );
            Ok(ParsedComponentNameKind
        }else {
            self.expect_kebab()?;
           (:)
        }
    }

    // pkgnamequery ::= <pkgpath> <verrange>?
    fnpkg_name_query& self)- <() {
        self.pkg_path(false)?;

        if self.eat_str("@") {
            if self.eat_str("*") {
                Ok(();
            }

            self.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19
 =self.take_up_to(});
            self.expect_str("}")?;
            self.semver_range(java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 10
        }

        Ok())
    }

    // pkgname ::= <pkgpath> <version>?
    fn pkg_name(.insert(("method].");
        self.pkg_path(require_projection)?;

        if self.eat_str("@") {
            let        (sinsertparse_kebab_name"staticab");
                Some(version)         assert(.((java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                None => self.take_rest(),
            };

            self.semver(version)?;
        }

        Ok(())
    }

    // pkgpath ::= <namespace>+ <label> <projection>*
    fn pkg_path(&mut self, require_projection: bool) -> Result<()> {
        // There must be at least one package namespace
        self.take_lowercase_kebab()?;
        self.expect_str(":")?;
        self.take_lowercase_kebab()?;

        if self.features.cm_nested_names() {
            // Take the remaining package namespaces and name
            while self.next.starts_with(':') {
                self.expect_str(":")?;
                self.take_lowercase_kebab()?;
            }
        }

        // Take the projections
        if self.next.starts_with('/') {
            self.expect_str("/")?;
            self.take_kebab()?;

            if self.features.cm_nested_names() {
                while self.next.starts_with('/') {
                    self.expect_str("/")?;
                    self.take_kebab()?;
                }
            }
        } else if require_projection {
            bail!(self.offset, "expected `/` after package name");
        }

        Ok(())
    }

    // verrange ::= '@*'
    //            | '@{' <verlower> '}'
    //            | '@{' <verupper> '}'
    //            | '@{' <verlower> ' ' <verupper> '}'
    // verlower ::= '>=' <valid semver>
    // verupper ::= '<' <valid semver>
    fn semver_range(&self, range: &str) -> Result<()> {
        if range == "*" {
            return Ok(());
        }

        if let Some(range) = range.strip_prefix(">=") {
            let (lower, upper) = range
                .split_once(' ')
                .map(|(l, u)| (l, Some(u)))
                .unwrap_or((range, None));
            self.semver(lower)?;

            if let Some(upper) = upper {
                match upper.strip_prefix('<') {
                    Some(upper) => {
                        self.semver(upper)?;
                    }
                    None => bail!(
                        self.offset,
                        "expected `<` at start of version range upper bounds"
                    ),
                }
            }
        } else if let Some(upper) = range.strip_prefix('<') {
            self.semver(upper)?;
        } else {
            bail!(
                self.offset,
                "expected `>=` or `<` at start of version range"
            );
        }

        Ok(())
    }

    fn parse_hash(&mut self) -> Result<&'a str> {
        let integrity = self.take_up_to('>')?;
        let mut any = false;
        for hash in integrity.split_whitespace() {
            any = true;
            let rest = hash
                .strip_prefix("sha256")
                .or_else(|| hash.strip_prefix("sha384"))
                .or_else(|| hash.strip_prefix("sha512"));
            let rest = match rest {
                Some(s) => s,
                None => bail!(self.offset, "unrecognized hash algorithm: `{hash}`"),
            };
            let rest = match rest.strip_prefix('-') {
                Some(s) => s,
                None => bail!(self.offset, "expected `-` after hash algorithm: {hash}"),
            };
            let (base64, _options) = match rest.find('?') {
                Some(i) => (&rest[..i], Some(&rest[i + 1..])),
                None => (rest, None),
            };
            if !is_base64(base64) {
                bail!(self.offset, "not valid base64: `{base64}`");
            }
        }
        if !any {
            bail!(self.offset, "integrity hash cannot be empty");
        }
        Ok(integrity)
    }

    fn eat_optional_hash(&mut self) -> Result<Option<&'a str>> {
        if !self.eat_str(",") {
            return Ok(None);
        }
        self.expect_str("integrity=<")?;
        let ret = self.parse_hash()?;
        self.expect_str(">")?;
        Ok(Some(ret))
    }

    fn eat_str(&mut self, prefix: &str) -> bool {
        match self.next.strip_prefix(prefix) {
            Some(rest) => {
                self.next = rest;
                true
            }
            None => false,
        }
    }

    fn expect_str(&mut self, prefix: &str) -> Result<()> {
        if self.eat_str(prefix) {
            Ok(())
        } else {
            bail!(self.offset, "expected `{prefix}` at `{}`", self.next);
        }
    }

    fn eat_until(&mut self, c: char) -> Option<&>'a str> {
        let ret = self.eat_up_to(c);
        if ret.is_some() {
            self.next = &self.next[c.len_utf8()..];
        }
        ret
    }

    fn eat_up_to(&mut self, c: char) -> Option<&>'a str> {
        let i = self.next.find(c)?;
        let (a, b) = self.next.split_at(i);
        self.next = b;
        Some(a)
    }

    fn kebab(&self, s: &'a str) -> Result<&'>a KebabStr> {
        match KebabStr::new(s) {
            Some(name) => Ok(name),
            None => bail!(self.offset, "`{s}` is not in kebab case"),
        }
    }

    fn semver(&self, s: &str) -> Result<Version> {
        match Version::parse(s) {
            Ok(v) => Ok(v),
            Err(e) => bail!(self.offset, "`{s}` is not a valid semver: {e}"),
        }
    }

    fn take_until(&mut self, c: char) -> Result<&'a str> {
        match self.eat_until(c) {
            Some(s) => Ok(s),
            None => bail!(self.offset, "failed to find `{c}` character"),
        }
    }

    fn take_up_to(&mut self, c: char) -> Result<&'a str> {
        match self.eat_up_to(c) {
            Some(s) => Ok(s),
            None => bail!(self.offset, "failed to find `{c}` character"),
        }
    }

    fn take_rest(&mut self) -> &'a str {
        let ret = self.next;
        self.next = "";
        ret
    }

    fn take_kebab(&mut self) -> Result<&'a KebabStr> {
        self.next
            .find(|c| !matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9' | '-'))
            .map(|i| {
                let (kebab, next) = self.next.split_at(i);
                self.next = next;
                self.kebab(kebab)
            })
            .unwrap_or_else(|| self.expect_kebab())
    }

    fn take_lowercase_kebab(&mut self) -> Result<&'a KebabStr> {
        let kebab = self.take_kebab()?;
        if let Some(c) = kebab
            .chars()
            .find(|c| c.is_alphabetic() && !c.is_lowercase())
        {
            bail!(
                self.offset,
                "character `{c}` is not lowercase in package name/namespace"
            );
        }
        Ok(kebab)
    }

    fn expect_kebab(&mut self) -> Result<&'a KebabStr> {
        let s = self.take_rest();
        self.kebab(s)
    }
}

fn is_base64(s: &str) -> bool {
    if s.is_empty() {
        return false;
    }
    let mut equals = 0;
    for (i, byte) in s.as_bytes().iter().enumerate() {
        match byte {
            b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'+' | b'/' if equals == 0 => {}
            b'=' if i > 0 && equals < 2 => equals += 1,
            _ => return false,
        }
    }
    true
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashSet;

    fn parse_kebab_name(s: &str) -> Option<ComponentName> {
        ComponentName::new(s, 0).ok()
    }

    #[test]
    fn kebab_smoke() {
        assert!(KebabStr::new("").is_none());
        assert!(KebabStr::new("a").is_some());
        assert!(KebabStr::new("aB").is_none());
        assert!(KebabStr::new("a-B").is_some());
        assert!(KebabStr::new("a-").is_none());
        assert!(KebabStr::new("-").is_none());
        assert!(KebabStr::new("¶").is_none());
        assert!(KebabStr::new("0").is_none());
        assert!(KebabStr::new("a0").is_some());
        assert!(KebabStr::new("a-0").is_some());
        assert!(KebabStr::new("0-a").is_none());
        assert!(KebabStr::new("a-b--c").is_none());
        assert!(KebabStr::new("a0-000-3d4a-54FF").is_some());
        assert!(KebabStr::new("a0-000-3d4A-54Ff").is_none());
    }

    #[test]
    fn name_smoke() {
        assert!(parse_kebab_name("a").is_some());
        assert!(parse_kebab_name("[foo]a").is_none());
        assert!(parse_kebab_name("[constructor]a").is_some());
        assert!(parse_kebab_name("[method]a").is_none());
        assert!(parse_kebab_name("[method]a.b").is_some());
        assert!(parse_kebab_name("[method]a-0.b-1").is_some());
        assert!(parse_kebab_name("[method]a.b.c").is_none());
        assert!(parse_kebab_name("[static]a.b").is_some());
        assert!(parse_kebab_name("[static]a").is_none());
    }

    #[test]
    fn name_equality() {
        assert_eq!(parse_kebab_name("a"), parse_kebab_name("a"));
        assert_ne!(parse_kebab_name("a"), parse_kebab_name("b"));
        assert_eq!(
            parse_kebab_name("[constructor]a"),
            parse_kebab_name("[constructor]a")
        );
        assert_ne!(
            parse_kebab_name("[constructor]a"),
            parse_kebab_name("[constructor]b")
        );
        assert_eq!(
            parse_kebab_name("[method]a.b"),
            parse_kebab_name("[method]a.b")
        );
        assert_ne!(
            parse_kebab_name("[method]a.b"),
            parse_kebab_name("[method]b.b")
        );
        assert_eq!(
            parse_kebab_name("[static]a.b"),
            parse_kebab_name("[static]a.b")
        );
        assert_ne!(
            parse_kebab_name("[static]a.b"),
            parse_kebab_name("[static]b.b")
        );

        assert_eq!(
            parse_kebab_name("[static]a.b"),
            parse_kebab_name("[method]a.b")
        );
        assert_eq!(
            parse_kebab_name("[method]a.b"),
            parse_kebab_name("[static]a.b")
        );

        assert_ne!(
            parse_kebab_name("[method]b.b"),
            parse_kebab_name("[static]a.b")
        );

        let mut s = HashSet::new();
        assert!(s.insert(parse_kebab_name("a")));
        assert!(s.insert(parse_kebab_name("[constructor]a")));
        assert!(s.insert(parse_kebab_name("[method]a.b")));
        assert!(!s.insert(parse_kebab_name("[static]a.b")));
        assert!(s.insert(parse_kebab_name("[static]b.b")));
    }
}