bend-kit-router

Releases (3):
  0.2.0.0  0x9606cc4b1afb0de13a7da7c0f6fc3a82  indexed  https://jend.leeeet.dev/files.txt?path=bend-kit-router@0.2.0.0
  0.1.1.1  0x3d28a7f089678dce31938494fe1c556b  unindexed  https://jend.leeeet.dev/files.txt?path=bend-kit-router@0.1.1.1
  0.1.1.0  0xf2239decc78af956c471ebf7f2f50374  unindexed  https://jend.leeeet.dev/files.txt?path=bend-kit-router@0.1.1.0

Definitions (106, 1 to 100 shown):
  Router.Segment (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Segment)
   type Segment is Data:
     Literal{text: String}
     Parameter{name: String}
  Router.Entry (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Entry)
   type Entry<-A: Data> is Data:
     Entry{method: String, pattern: String, action: A, groups: List<&2, U32>}
  Router.Handler (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Handler)
   type Handler<-A: Data> is Data:
     Handler{method: String, pattern: String, segments: List<&2, Segment>, action: A}
  Router.Path (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Path)
   type Path<-A: Data> is Data:
     Path{segments: List<&2, Segment>, handlers: List<&2, Handler<A>>, groups: List<&2, U32>, allow: String}
  Router.Table (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Table)
   type Table<-A: Data> is Data:
     Table{paths: List<&2, Path<A>>, allow: String}
  Router.Error (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Error)
   type Error is Data:
     InvalidPattern{pattern: String}
     InvalidMethod{method: String}
     Duplicate{method: String, pattern: String}
     GroupConflict{pattern: String}
     BadTarget{}
  Router.Choice (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Choice)
   type Choice<-A: Data> is Data:
     Found{action: A, params: Map<&2, String>, groups: List<&2, U32>, method: String, pattern: String}
     MethodMissing{groups: List<&2, U32>, allow: String}
     Options{groups: List<&2, U32>, allow: String}
     NotFound{}
  Router.Resolved (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Resolved)
   type Resolved<-A: Data> is Data:
     Resolved{target: Target.Target, choice: Choice<A>}
  Router.Hidden (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Hidden)
   type Hidden is Data:
     Hidden{pattern: String, methods: String}
  Router.Description (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=Description)
   type Description is Data:
     Description{method: String, pattern: String, groups: List<&2, U32>, hidden: List<&2, Hidden>}
  Router.scalar (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=scalar)
   def scalar(+c: U32) -> Bool:
  Router.literal.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=literal.valid)
   def literal.valid(s: String) -> Bool:
  Router.name.tail (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=name.tail)
   def name.tail(s: String) -> Bool:
  Router.name.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=name.valid)
   def name.valid(s: String) -> Bool:
  Router.member (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=member)
   def member(xs: List<&2, String>, +s: String) -> Bool:
  Router.pattern.segment (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=pattern.segment)
   def pattern.segment(s: String, names: List<&2, String>) -> Maybe<&2, Segment>:
  Router.pattern.names (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=pattern.names)
   def pattern.names(segment: Segment, names: List<&2, String>) -> List<&2, String>:
  Router.pattern.parts (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=pattern.parts)
   def pattern.parts(xs: List<&2, String>, +names: List<&2, String>, acc: List<&2, Segment>) -> Maybe<&2, List<&2, Segment>>:
  Router.pattern (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=pattern)
   def pattern(s: String) -> Maybe<&2, List<&2, Segment>>:
  Router.token (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=token)
   def token(+c: U32) -> Bool:
  Router.method.tail (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=method.tail)
   def method.tail(s: String) -> Bool:
  Router.method.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=method.valid)
   def method.valid(s: String) -> Bool:
  Router.continue (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=continue)
   def continue(ok: Bool, later: Unit -> Bool) -> Bool:
  Router.matches (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=matches)
   def matches(pat: List<&2, Segment>, got: List<&2, String>) -> Bool:
  Router.capture (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=capture)
   def capture(pat: List<&2, Segment>, got: List<&2, String>, acc: Map<&2, String>) -> Map<&2, String>:
  Router.shape (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=shape)
   def shape(a: List<&2, Segment>, b: List<&2, Segment>) -> Bool:
  Router.specific (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=specific)
   def specific(a: List<&2, Segment>, b: List<&2, Segment>) -> Bool:
  Router.groups.eq (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=groups.eq)
   def groups.eq(a: List<&2, U32>, b: List<&2, U32>) -> Bool:
  Router.handler.has (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=handler.has)
   def handler.has(~A: Data, xs: List<&2, Handler<A>>, +method: String) -> Bool:
  Router.insert.merge (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=insert.merge)
   def insert.merge(~A: Data, duplicate: Bool, same_groups: Bool, entry: Handler<A>, segments: List<&2, Segment>, handlers: List<&2, Handler<A>>, groups: List<&2, U32>, rest: List<&2, Path<A>>) -> Result<&2, &2, Error, List<&2, Path<A>>>:
  Router.insert.branch (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=insert.branch)
   def insert.branch(~A: Data, same: Bool, segments: List<&2, Segment>, +handlers: List<&2, Handler<A>>, +old_groups: List<&2, U32>, allowed: String, tail: List<&2, Path<A>>, entry: Handler<A>, groups: List<&2, U32>, rest: Unit -> Result<&2, &2, Error, List<&2, Path<A>>>) -> Result<&2, &2, Error, List<&2, Path<A>>>:
  Router.insert (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=insert)
   # ponytail: preparation merges shapes in O(routes²); replace with a shape index if construction becomes a bottleneck.
   def insert(~A: Data, paths: List<&2, Path<A>>, +entry: Handler<A>, +groups: List<&2, U32>) -> Result<&2, &2, Error, List<&2, Path<A>>>:
  Router.method.prepend (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=method.prepend)
   def method.prepend(get: Bool, method: String, tail: List<&2, String>) -> List<&2, String>:
  Router.method.names (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=method.names)
   def method.names(~A: Data, xs: List<&2, Handler<A>>) -> List<&2, String>:
  Router.unique (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=unique)
   def unique(xs: List<&2, String>, prev: String, +acc: List<&2, String>) -> List<&2, String>:
  Router.allow (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=allow)
   def allow(xs: List<&2, String>) -> String:
  Router.finish.paths (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=finish.paths)
   def finish.paths(~A: Data, paths: List<&2, Path<A>>) -> List<&2, Path<A>>:
  Router.all.methods (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=all.methods)
   def all.methods(~A: Data, paths: List<&2, Path<A>>) -> List<&2, String>:
  Router.prepare.pattern (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=prepare.pattern)
   def prepare.pattern(~A: Data, parsed: Maybe<&2, List<&2, Segment>>, method: String, pattern: String, action: A, groups: List<&2, U32>, paths: List<&2, Path<A>>) -> Result<&2, &2, Error, List<&2, Path<A>>>:
  Router.prepare.entry (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=prepare.entry)
   def prepare.entry(~A: Data, valid: Bool, entry: Entry<A>, paths: List<&2, Path<A>>) -> Result<&2, &2, Error, List<&2, Path<A>>>:
  Router.prepare.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=prepare.go)
   def prepare.go(~A: Data, entries: List<&2, Entry<A>>, paths: List<&2, Path<A>>) -> Result<&2, &2, Error, Table<A>>:
  Router.prepare (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=prepare)
   def prepare(~A: Data, entries: List<&2, Entry<A>>) -> Result<&2, &2, Error, Table<A>>:
  Router.best.compare (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=best.compare)
   def best.compare(~A: Data, candidate: Path<A>, old: Path<A>) -> Maybe<&2, Path<A>>:
  Router.best.pick (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=best.pick)
   def best.pick(~A: Data, best: Maybe<&2, Path<A>>, candidate: Path<A>) -> Maybe<&2, Path<A>>:
  Router.best.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=best.step)
   def best.step(~A: Data, matched: Bool, candidate: Path<A>, best: Maybe<&2, Path<A>>) -> Maybe<&2, Path<A>>:
  Router.best (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=best)
   # ponytail: lookup scans prepared paths in O(routes × segments); use a trie if measured dispatch cost warrants it.
   def best(~A: Data, paths: List<&2, Path<A>>, +segments: List<&2, String>, acc: Maybe<&2, Path<A>>) -> Maybe<&2, Path<A>>:
  Router.handler.next (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=handler.next)
   def handler.next(~A: Data, same: Bool, here: Handler<A>, later: Unit -> Maybe<&2, Handler<A>>) -> Maybe<&2, Handler<A>>:
  Router.handler (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=handler)
   def handler(~A: Data, xs: List<&2, Handler<A>>, +method: String) -> Maybe<&2, Handler<A>>:
  Router.chosen (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=chosen)
   def chosen(~A: Data, hit: Maybe<&2, Handler<A>>, segments: List<&2, String>, +groups: List<&2, U32>, +allowed: String, options: Bool) -> Choice<A>:
  Router.choose.fallback (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=choose.fallback)
   def choose.fallback(~A: Data, head: Bool, handlers: List<&2, Handler<A>>, method: String, segments: List<&2, String>, groups: List<&2, U32>, allowed: String) -> Choice<A>:
  Router.choose.method (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=choose.method)
   def choose.method(~A: Data, direct: Maybe<&2, Handler<A>>, +handlers: List<&2, Handler<A>>, +method: String, segments: List<&2, String>, groups: List<&2, U32>, allowed: String) -> Choice<A>:
  Router.choose.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=choose.path)
   def choose.path(~A: Data, path: Maybe<&2, Path<A>>, +method: String, segments: List<&2, String>) -> Choice<A>:
  Router.resolve.star (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=resolve.star)
   def resolve.star(~A: Data, star: Bool, paths: List<&2, Path<A>>, allowed: String, target: Target.Target, method: String, +segments: List<&2, String>) -> Resolved<A>:
  Router.resolve.target (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=resolve.target)
   def resolve.target(~A: Data, parsed: Maybe<&2, Target.Target>, table: Table<A>, method: String) -> Result<&2, &2, Error, Resolved<A>>:
  Router.resolve (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=resolve)
   def resolve(~A: Data, table: Table<A>, +method: String, target: String) -> Result<&2, &2, Error, Resolved<A>>:
  Router.route.match (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route.match)
   def route.match(ok: Bool, ss: List<&2, Segment>, got: List<&2, String>) -> Maybe<&2, Map<&2, String>>:
  Router.route.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route.path)
   def route.path(star: Bool, +ss: List<&2, Segment>, +got: List<&2, String>) -> Maybe<&2, Map<&2, String>>:
  Router.route.target (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route.target)
   def route.target(parsed: Maybe<&2, Target.Target>, +ss: List<&2, Segment>) -> Maybe<&2, Map<&2, String>>:
  Router.route.pattern (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route.pattern)
   def route.pattern(parsed: Maybe<&2, List<&2, Segment>>, path: String, method: String) -> Maybe<&2, Map<&2, String>>:
  Router.route.method (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route.method)
   def route.method(same: Bool, p: String, path: String, method: String) -> Maybe<&2, Map<&2, String>>:
  Router.route (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=route)
   def route(want: String, +method: String, pattern: String, path: String) -> Maybe<&2, Map<&2, String>>:
  Router.overlap (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=overlap)
   def overlap(a: List<&2, Segment>, b: List<&2, Segment>) -> Bool:
  Router.unavailable.prepend (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=unavailable.prepend)
   def unavailable.prepend(keep: Bool, h: String, tail: List<&2, String>) -> List<&2, String>:
  Router.unavailable (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=unavailable)
   def unavailable(xs: List<&2, String>, +present: List<&2, String>) -> List<&2, String>:
  Router.hidden.add (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=hidden.add)
   def hidden.add(empty: Bool, pattern: String, methods: String, tail: List<&2, Hidden>) -> List<&2, Hidden>:
  Router.hidden.handlers (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=hidden.handlers)
   def hidden.handlers(~A: Data, handlers: List<&2, Handler<A>>, +present: List<&2, String>, tail: List<&2, Hidden>) -> List<&2, Hidden>:
  Router.hidden.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=hidden.path)
   def hidden.path(~A: Data, hides: Bool, handlers: List<&2, Handler<A>>, present: List<&2, String>, tail: List<&2, Hidden>) -> List<&2, Hidden>:
  Router.hidden.scan (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=hidden.scan)
   def hidden.scan(~A: Data, paths: List<&2, Path<A>>, +segments: List<&2, Segment>, +methods: List<&2, String>) -> List<&2, Hidden>:
  Router.description.handlers (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=description.handlers)
   def description.handlers(~A: Data, handlers: List<&2, Handler<A>>, +groups: List<&2, U32>, +hidden: List<&2, Hidden>) -> List<&2, Description>:
  Router.description.paths (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=description.paths)
   def description.paths(~A: Data, paths: List<&2, Path<A>>, +all: List<&2, Path<A>>) -> List<&2, Description>:
  Router.describe (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/router.bend&name=describe)
   def describe(~A: Data, table: Table<A>) -> List<&2, Description>:
  Target.Query (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=Query)
   type Query is Data:
     Query{key: String, value: String}
  Target.Target (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=Target)
   type Target is Data:
     Target{segments: List<&2, String>, query: List<&2, Query>, authority: Maybe<&2, String>, star: Bool}
  Target.Utf (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=Utf)
   type Utf is Data:
     Utf{need: U32, lo: U32, hi: U32, cp: U32, out: String}
  Target.between (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=between)
   def between(+c: U32, lo: U32, hi: U32) -> Bool:
  Target.utf.lead (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=utf.lead)
   def utf.lead(+c: U32, out: String, ascii: Bool) -> Maybe<&2, Utf>:
  Target.utf.more (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=utf.more)
   def utf.more(ok: Bool, +need: U32, +cp: U32, +out: String) -> Maybe<&2, Utf>:
  Target.utf.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=utf.step)
   def utf.step(idle: Bool, +c: U32, need: U32, lo: U32, hi: U32, cp: U32, out: String) -> Maybe<&2, Utf>:
  Target.utf.finish (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=utf.finish)
   def utf.finish(st: Maybe<&2, Utf>) -> Maybe<&2, String>:
  Target.utf.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=utf.go)
   def utf.go(s: String, st: Maybe<&2, Utf>) -> Maybe<&2, String>:
  Target.text.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=text.valid)
   def text.valid(s: String, +slash: Bool) -> Bool:
  Target.decoded.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=decoded.valid)
   def decoded.valid(+s: String, slash: Bool) -> Maybe<&2, String>:
  Target.decoded (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=decoded)
   def decoded(st: Maybe<&2, String>, slash: Bool) -> Maybe<&2, String>:
  Target.percent.got (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=percent.got)
   def percent.got(st: Maybe<&2, String>, slash: Bool) -> Maybe<&2, String>:
  Target.percent (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=percent)
   def percent(s: String, slash: Bool) -> Maybe<&2, String>:
  Target.segments (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=segments)
   def segments(xs: List<&2, String>) -> Maybe<&2, List<&2, String>>:
  Target.split.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=split.path)
   def split.path(+path: String) -> List<&2, String>:
  Target.plus (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=plus)
   def plus(s: String) -> String:
  Target.query.pair (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=query.pair)
   def query.pair(pair: String & String) -> Maybe<&2, Query>:
  Target.query.field (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=query.field)
   def query.field(field: String) -> Maybe<&2, Query>:
  Target.query (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=query)
   def query(xs: List<&2, String>, acc: List<&2, Query>) -> Maybe<&2, List<&2, Query>>:
  Target.raw.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=raw.valid)
   def raw.valid(s: String) -> Bool:
  Target.origin (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=origin)
   def origin(path: String, q: String, authority: Maybe<&2, String>) -> Maybe<&2, Target>:
  Target.origin.split (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=origin.split)
   def origin.split(pair: String & String, authority: Maybe<&2, String>) -> Maybe<&2, Target>:
  Target.alpha (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=alpha)
   def alpha(+c: U32) -> Bool:
  Target.scheme.tail (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=scheme.tail)
   def scheme.tail(s: String) -> Bool:
  Target.scheme (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=scheme)
   def scheme(s: String) -> Bool:
  Target.authority.take (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=authority.take)
   def authority.take(s: String, acc: String) -> String & String:
  Target.absolute.authority (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=absolute.authority)
   def absolute.authority(ok: Bool, authority: String, path: String) -> Maybe<&2, Target>:
  Target.absolute.taken (https://jend.leeeet.dev/definition.txt?path=bend-kit-router@0.2.0.0/target.bend&name=absolute.taken)
   def absolute.taken(pair: String & String) -> Maybe<&2, Target>:
More: https://jend.leeeet.dev/packages/bend-kit-router.txt?definitions_offset=100