SYMBOL INDEX (1397 symbols across 96 files)

FILE: .github/workflows/update-tests/update.py
  function getData (line 20) | def getData():
  function reposFromOrg (line 64) | def reposFromOrg(org, skipRepos=None):
  function filesFromRepo (line 81) | def filesFromRepo(repo, skipFiles=None):
  function processFile (line 107) | def processFile(file):
  function main (line 117) | def main():

FILE: bikeshed/InputSource.py
  class InputContent (line 21) | class InputContent:
    method lines (line 26) | def lines(self) -> list[line.Line]:
    method content (line 58) | def content(self) -> str:
  function inputFromName (line 62) | def inputFromName(sourceName: str, **kwargs: t.Any) -> InputSource:
  class InputSource (line 72) | class InputSource:
    method __str__ (line 81) | def __str__(self) -> str:
    method __repr__ (line 84) | def __repr__(self) -> str:
    method __hash__ (line 87) | def __hash__(self) -> int:
    method __eq__ (line 90) | def __eq__(self, other: object) -> bool:
    method read (line 94) | def read(self) -> InputContent:
    method hasDirectory (line 97) | def hasDirectory(self) -> bool:
    method directory (line 101) | def directory(self) -> str:
    method relative (line 106) | def relative(self, _: t.Any) -> InputSource | None:
    method mtime (line 116) | def mtime(self) -> float | None:
    method cheaplyExists (line 120) | def cheaplyExists(self, _: t.Any) -> bool | None:
    method __getattr__ (line 127) | def __getattr__(self, name: str) -> str:
  class StdinInputSource (line 136) | class StdinInputSource(InputSource):
    method __init__ (line 137) | def __init__(self, sourceName: str, **kwargs: t.Any) -> None:  # pylin...
    method __str__ (line 143) | def __str__(self) -> str:
    method read (line 146) | def read(self) -> InputContent:
  class UrlInputSource (line 150) | class UrlInputSource(InputSource):
    method __init__ (line 151) | def __init__(self, sourceName: str, **kwargs: t.Any) -> None:  # pylin...
    method __str__ (line 156) | def __str__(self) -> str:
    method _fetch (line 164) | def _fetch(self) -> requests.Response:
    method read (line 174) | def read(self) -> InputContent:
    method relative (line 183) | def relative(self, *relativePathSegs: str) -> UrlInputSource:
  class FileInputSource (line 187) | class FileInputSource(InputSource):
    method __init__ (line 188) | def __init__(self, sourceName: str, *, chroot: bool, chrootPath: str |...
    method __str__ (line 199) | def __str__(self) -> str:
    method read (line 202) | def read(self) -> InputContent:
    method hasDirectory (line 209) | def hasDirectory(self) -> bool:
    method directory (line 212) | def directory(self) -> str:
    method relative (line 215) | def relative(self, *relativePathSegs: str) -> FileInputSource:
    method cheaplyExists (line 222) | def cheaplyExists(self, relativePath: str) -> bool:
    method mtime (line 225) | def mtime(self) -> float | None:
  class TarInputSource (line 233) | class TarInputSource(InputSource):
    method __init__ (line 234) | def __init__(self, sourceName: str, *, tarMemberName: str = "index.bs"...
    method __str__ (line 240) | def __str__(self) -> str:
    method read (line 243) | def read(self) -> InputContent:
    method hasDirectory (line 264) | def hasDirectory(self) -> bool:
    method directory (line 267) | def directory(self) -> str:
    method relative (line 272) | def relative(self, *relativePathSegs: str) -> TarInputSource:
    method cheaplyExists (line 278) | def cheaplyExists(self, relativePath: str) -> bool | None:
    method mtime (line 284) | def mtime(self) -> float | None:
    method _openTarFile (line 291) | def _openTarFile(self) -> tarfile.TarFile:

FILE: bikeshed/Spec.py
  class Spec (line 52) | class Spec:
    method __init__ (line 53) | def __init__(
    method initializeState (line 91) | def initializeState(self) -> bool:
    method initMetadata (line 139) | def initMetadata(self, inputContent: InputSource.InputContent) -> None:
    method earlyParse (line 191) | def earlyParse(self, inputContent: InputSource.InputContent) -> list[l...
    method checkValidity (line 200) | def checkValidity(self) -> bool:
    method recordDependencies (line 203) | def recordDependencies(self, *inputSources: InputSource.InputSource) -...
    method preprocess (line 206) | def preprocess(self) -> Spec:
    method assembleDocument (line 212) | def assembleDocument(self) -> Spec:
    method processDocument (line 253) | def processDocument(self) -> Spec:
    method serialize (line 358) | def serialize(self) -> str | None:
    method fixMissingOutputFilename (line 367) | def fixMissingOutputFilename(self, outputFilename: str | None) -> str:
    method finish (line 382) | def finish(self, outputFilename: str | None = None, newline: str | Non...
    method printResultMessage (line 399) | def printResultMessage(self) -> None:
    method watch (line 416) | def watch(self, outputFilename: str | None, port: int | None = None, l...
    method printTargets (line 481) | def printTargets(self) -> None:
    method isOpaqueElement (line 493) | def isOpaqueElement(self, el: t.ElementT) -> bool:
  function printDone (line 503) | def printDone() -> None:
  function findImplicitInputFile (line 518) | def findImplicitInputFile() -> str | None:
  function catchArgparseBug (line 545) | def catchArgparseBug(string: str | None) -> bool:
  function fetchLanguages (line 563) | def fetchLanguages(dataFile: retrieve.DataFileRequester) -> dict[str, la...
  function fetchDoctypes (line 570) | def fetchDoctypes(dataFile: retrieve.DataFileRequester) -> doctypes.Doct...
  function addDomintroStyles (line 574) | def addDomintroStyles(doc: Spec) -> None:
  function checkForMixedIndents (line 583) | def checkForMixedIndents(lines: t.Sequence[l.Line], info: metadata.Inden...
  function FIXMEreplaceMarkdownBlockquotes (line 605) | def FIXMEreplaceMarkdownBlockquotes(text: str) -> str:

FILE: bikeshed/__init__.py
  function verify_python_version (line 11) | def verify_python_version() -> None:

FILE: bikeshed/biblio.py
  class BiblioEntry (line 13) | class BiblioEntry(metaclass=abc.ABCMeta):
    method url (line 24) | def url(self) -> str:
    method toHTML (line 38) | def toHTML(self) -> t.ElementT: ...
    method valid (line 41) | def valid(self) -> bool: ...
    method strip (line 43) | def strip(self) -> BiblioEntry:
  class NormalBiblioEntry (line 57) | class NormalBiblioEntry(BiblioEntry):
    method toHTML (line 64) | def toHTML(self) -> t.ElementT:
    method valid (line 106) | def valid(self) -> bool:
    method strip (line 109) | def strip(self) -> NormalBiblioEntry:
  class SpecBiblioEntry (line 122) | class SpecBiblioEntry(BiblioEntry):
    method __init__ (line 128) | def __init__(self, spec: dict[str, str], preferredStatus: str | None =...
    method valid (line 138) | def valid(self) -> bool:
    method toHTML (line 141) | def toHTML(self) -> t.ElementT:
  class StringBiblioEntry (line 150) | class StringBiblioEntry(BiblioEntry):
    method __init__ (line 159) | def __init__(self, linkText: str, data: str, order: int = 0) -> None:
    method valid (line 173) | def valid(self) -> bool:
    method toHTML (line 176) | def toHTML(self) -> t.ElementT:
  class AliasBiblioEntry (line 180) | class AliasBiblioEntry(BiblioEntry):
    method __init__ (line 188) | def __init__(self, linkText: str, aliasOf: str, order: int = 0) -> None:
    method valid (line 192) | def valid(self) -> bool:
    method toHTML (line 195) | def toHTML(self) -> t.ElementT:
  function processSpecrefBiblioFile (line 199) | def processSpecrefBiblioFile(text: str, storage: t.BiblioStorageT, order...
  function loadBiblioDataFile (line 288) | def loadBiblioDataFile(lines: t.Iterator[str], storage: t.BiblioStorageT...
  function levenshtein (line 339) | def levenshtein(a: str, b: str) -> int:
  function findCloseBiblios (line 360) | def findCloseBiblios(biblioKeys: t.Sequence[str], target: str, n: int = ...
  function dedupBiblioReferences (line 390) | def dedupBiblioReferences(doc: t.SpecT) -> None:

FILE: bikeshed/boilerplate.py
  function boilerplateFromHtml (line 21) | def boilerplateFromHtml(doc: t.SpecT, htmlString: str, context: str) -> ...
  function loadBoilerplate (line 32) | def loadBoilerplate(doc: t.SpecT, filename: str, bpname: str | None = No...
  function addBikeshedVersion (line 40) | def addBikeshedVersion(doc: t.SpecT) -> None:
  function addCanonicalURL (line 74) | def addCanonicalURL(doc: t.SpecT) -> None:
  function addFavicon (line 80) | def addFavicon(doc: t.SpecT) -> None:
  function addSpecVersion (line 86) | def addSpecVersion(doc: t.SpecT) -> None:
  function addHeaderFooter (line 124) | def addHeaderFooter(doc: t.SpecT) -> None:
  function fillWith (line 137) | def fillWith(tag: str, newElements: t.Sequence[t.NodeT], doc: t.SpecT) -...
  function getFillContainer (line 142) | def getFillContainer(tag: str, doc: t.SpecT, default: bool = False) -> t...
  function addLogo (line 171) | def addLogo(doc: t.SpecT) -> None:
  function addCopyright (line 175) | def addCopyright(doc: t.SpecT) -> None:
  function addAbstract (line 179) | def addAbstract(doc: t.SpecT) -> None:
  function addStatusSection (line 188) | def addStatusSection(doc: t.SpecT) -> None:
  function addExpiryNotice (line 192) | def addExpiryNotice(doc: t.SpecT) -> None:
  function addObsoletionNotice (line 204) | def addObsoletionNotice(doc: t.SpecT) -> None:
  function addAtRisk (line 209) | def addAtRisk(doc: t.SpecT) -> None:
  function addStyles (line 238) | def addStyles(doc: t.SpecT) -> None:
  function addCustomBoilerplate (line 244) | def addCustomBoilerplate(doc: t.SpecT) -> None:
  function removeUnwantedBoilerplate (line 252) | def removeUnwantedBoilerplate(doc: t.SpecT) -> None:
  function w3cStylesheetInUse (line 259) | def w3cStylesheetInUse(doc: t.SpecT) -> bool:
  function addBikeshedBoilerplate (line 263) | def addBikeshedBoilerplate(doc: t.SpecT) -> None:
  function addIndexSection (line 278) | def addIndexSection(doc: t.SpecT) -> None:
  function addIndexOfLocallyDefinedTerms (line 296) | def addIndexOfLocallyDefinedTerms(doc: t.SpecT, container: t.ElementT) -...
  function disambiguator (line 339) | def disambiguator(ref: r.RefWrapper, types: set[str] | None, specs: list...
  function addExplicitIndexes (line 350) | def addExplicitIndexes(doc: t.SpecT) -> None:
  class IndexTerm (line 471) | class IndexTerm:
  function htmlFromIndexTerms (line 477) | def htmlFromIndexTerms(entries: t.Mapping[str, list[IndexTerm]]) -> t.El...
  function addIndexOfExternallyDefinedTerms (line 518) | def addIndexOfExternallyDefinedTerms(doc: t.SpecT, container: t.ElementT...
  function addPropertyIndex (line 580) | def addPropertyIndex(doc: t.SpecT) -> None:
  function addIDLSection (line 736) | def addIDLSection(doc: t.SpecT) -> None:
  function addCDDLSection (line 764) | def addCDDLSection(doc: t.SpecT) -> None:
  function addTOCSection (line 821) | def addTOCSection(doc: t.SpecT) -> None:
  function addSpecMetadataSection (line 911) | def addSpecMetadataSection(doc: t.SpecT) -> None:
  function createMdEntry (line 1112) | def createMdEntry(key: str, dirtyVals: t.Sequence[MetadataValueT], doc: ...
  function htmlFromMd (line 1152) | def htmlFromMd(md: MetadataT, otherMd: MetadataT, doc: t.SpecT) -> t.Ele...
  function addReferencesSection (line 1186) | def addReferencesSection(doc: t.SpecT) -> None:
  function addIssuesSection (line 1246) | def addIssuesSection(doc: t.SpecT) -> None:
  function formatBiblioTerm (line 1279) | def formatBiblioTerm(linkText: str) -> str:
  function addDarkmodeIndicators (line 1290) | def addDarkmodeIndicators(doc: t.SpecT) -> None:

FILE: bikeshed/caniuse/caniuse.py
  function addCanIUsePanels (line 13) | def addCanIUsePanels(doc: t.SpecT) -> list[t.ElementT]:
  function canIUsePanelFor (line 59) | def canIUsePanelFor(id: str, feature: CIUFeature, update: str) -> t.Elem...
  function browserCompatSpan (line 85) | def browserCompatSpan(support: CIUSupport) -> t.ElementT:
  function validateCanIUseURLs (line 97) | def validateCanIUseURLs(doc: t.SpecT, canIUseData: CIUData, elements: li...
  class CIUData (line 132) | class CIUData:
    method __init__ (line 133) | def __init__(self, dataFile: t.DataFileRequester) -> None:
    method hasFeature (line 144) | def hasFeature(self, featureName: str) -> bool:
    method getFeature (line 147) | def getFeature(self, featureName: str) -> CIUFeature | None:
  class CIUFeature (line 164) | class CIUFeature:
    method fromJSON (line 170) | def fromJSON(cls, data: CIUData, j: t.JSONObject) -> t.Self:
  class CIUSupport (line 182) | class CIUSupport:
    method fromJSON (line 189) | def fromJSON(cls, data: CIUData, browserName: str, unparsed: str) -> t...

FILE: bikeshed/cddl.py
  class CDDLTerm (line 13) | class CDDLTerm:
  class CDDLMarker (line 19) | class CDDLMarker(cddlparser.ast.Marker):
    method __init__ (line 33) | def __init__(self) -> None:
    method _recordDefinition (line 38) | def _recordDefinition(self, type: str, name: str, dfnFor: str | None =...
    method serializeValue (line 58) | def serializeValue(self, prefix: str, value: str, suffix: str, node: c...
    method serializeName (line 104) | def serializeName(self, name: str, node: cddlparser.ast.CDDLNode) -> str:
    method _getFor (line 180) | def _getFor(self, node: cddlparser.ast.CDDLNode) -> str | None:
  function markupCDDL (line 205) | def markupCDDL(doc: t.SpecT) -> None:
  function markupCDDLBlock (line 223) | def markupCDDLBlock(pre: t.ElementT, doc: t.SpecT) -> set[t.ElementT]:
  function combineCDDLLinkingTexts (line 289) | def combineCDDLLinkingTexts(t1: str | None, t2: str | None) -> str:

FILE: bikeshed/cli.py
  function main (line 12) | def main() -> None:
  function handleUpdate (line 526) | def handleUpdate(options: argparse.Namespace) -> None:
  function handleSpec (line 542) | def handleSpec(options: argparse.Namespace, extras: list[str]) -> None:
  function handleEchidna (line 567) | def handleEchidna(options: argparse.Namespace, extras: list[str]) -> None:
  function handleWatch (line 595) | def handleWatch(options: argparse.Namespace, extras: list[str]) -> None:
  function handleServe (line 609) | def handleServe(options: argparse.Namespace, extras: list[str]) -> None:
  function handleDebug (line 625) | def handleDebug(options: argparse.Namespace, extras: list[str]) -> None:
  function handleRefs (line 663) | def handleRefs(options: argparse.Namespace, extras: list[str]) -> None:
  function handleIssuesList (line 699) | def handleIssuesList(options: argparse.Namespace) -> None:
  function handleSource (line 710) | def handleSource(options: argparse.Namespace) -> None:
  function handleOutline (line 722) | def handleOutline(options: argparse.Namespace) -> None:
  function handleTest (line 734) | def handleTest(options: argparse.Namespace, extras: list[str]) -> None:
  function handleProfile (line 747) | def handleProfile(options: argparse.Namespace) -> None:
  function handleTemplate (line 760) | def handleTemplate(options: argparse.Namespace) -> None:
  function handleWpt (line 772) | def handleWpt(options: argparse.Namespace) -> None:

FILE: bikeshed/conditional.py
  function processConditionals (line 29) | def processConditionals(doc: t.SpecT, container: t.ElementT | None = Non...
  function evalConditions (line 61) | def evalConditions(doc: t.SpecT, el: t.ElementT, conditionString: str) -...
  class Condition (line 83) | class Condition:
  function parseConditions (line 88) | def parseConditions(s: str, el: t.ElementT | None = None) -> t.Generator...

FILE: bikeshed/config/BoolSet.py
  class BoolSet (line 8) | class BoolSet(collections.abc.MutableMapping[str, bool]):
    method __init__ (line 17) | def __init__(self, values: t.Any = None, default: bool = False) -> None:
    method __missing__ (line 27) | def __missing__(self, key: t.Any) -> bool:
    method __contains__ (line 30) | def __contains__(self, key: t.Any) -> bool:
    method __getitem__ (line 36) | def __getitem__(self, key: t.Any) -> bool:
    method __setitem__ (line 39) | def __setitem__(self, key: t.Any, val: bool) -> None:
    method __delitem__ (line 42) | def __delitem__(self, key: t.Any) -> None:
    method __iter__ (line 45) | def __iter__(self) -> t.Iterator[t.Any]:
    method __len__ (line 48) | def __len__(self) -> int:
    method __repr__ (line 51) | def __repr__(self) -> str:
    method hasExplicit (line 60) | def hasExplicit(self, key: t.Any) -> bool:
    method update (line 64) | def update(self, __other: t.SupportsKeysAndGetItem[t.Any, t.Any], **kw...
    method update (line 67) | def update(self, __other: t.Iterable[tuple[t.Any, t.Any]], **kwargs: b...
    method update (line 70) | def update(self, **kwargs: bool) -> None: ...
    method update (line 72) | def update(self, __other: t.Any = None, **kwargs: bool) -> None:

FILE: bikeshed/config/dfnTypes.py
  function adjustKey (line 143) | def adjustKey(text: str, type: str) -> tuple[str, str]:
  function linkTypeIn (line 198) | def linkTypeIn(startTypes: str | t.AbstractSet[str], targetTypes: str | ...

FILE: bikeshed/config/main.py
  function englishFromList (line 10) | def englishFromList(items: t.Iterable[str], conjunction: str = "or") -> ...
  function intersperse (line 21) | def intersperse[IterT, DelimT](
  function flatIntersperse (line 33) | def flatIntersperse[IterT, DelimT](
  function processTextNodes (line 45) | def processTextNodes(
  function reSubObject (line 64) | def reSubObject(
  function reSubObject (line 72) | def reSubObject[SubT](
  function reSubObject (line 79) | def reSubObject[SubT](
  function simplifyText (line 103) | def simplifyText(text: str) -> str:
  function splitForValues (line 117) | def splitForValues(forValues: str) -> list[str]: ...
  function splitForValues (line 121) | def splitForValues(forValues: None) -> None: ...
  function splitForValues (line 124) | def splitForValues(forValues: str | None) -> list[str] | None:
  function groupFromKey (line 136) | def groupFromKey(key: str, length: int = 2) -> str:
  function scriptPath (line 157) | def scriptPath(*pathSegs: str) -> str:
  function docPath (line 163) | def docPath(doc: t.SpecT, *pathSegs: str) -> str | None:
  function chrootPath (line 170) | def chrootPath(rootPath: str, path: str) -> str:
  function doEvery (line 182) | def doEvery(s: float, action: t.Callable[[], t.Any], lastTime: float | N...
  function safeIndex (line 204) | def safeIndex[ValT](coll: t.Sequence[ValT], needle: ValT) -> int | None:...
  function safeIndex (line 208) | def safeIndex[ValT, DefaultT](coll: t.Sequence[ValT], needle: ValT, defa...
  function safeIndex (line 211) | def safeIndex[ValT, DefaultT](

FILE: bikeshed/datablocks.py
  class TransformFuncT (line 14) | class TransformFuncT(t.Protocol):
    method __call__ (line 15) | def __call__(
  function transformDataBlocks (line 23) | def transformDataBlocks(doc: t.SpecT, tree: t.SpecT | t.ElementT) -> None:
  function transformPre (line 61) | def transformPre(data: str, el: t.ElementT, doc: t.SpecT) -> t.ElementT ...
  function transformOpaque (line 83) | def transformOpaque(data: str, el: t.ElementT, doc: t.SpecT) -> t.Elemen...
  function transformRaw (line 93) | def transformRaw(data: str, el: t.ElementT, doc: t.SpecT) -> t.ElementT ...
  function transformSimpleDef (line 100) | def transformSimpleDef(data: str, el: t.ElementT, doc: t.SpecT) -> t.Ele...
  function transformPropdef (line 114) | def transformPropdef(data: str, el: t.ElementT, doc: t.SpecT) -> t.Eleme...
  function blessList (line 203) | def blessList(items: list[str]) -> list[t.SafeHtmlStr]:
  function transformDescdef (line 207) | def transformDescdef(data: str, el: t.ElementT, doc: t.SpecT) -> t.Eleme...
  function transformElementdef (line 249) | def transformElementdef(data: str, el: t.ElementT, doc: t.SpecT) -> t.El...
  function transformArgumentdef (line 319) | def transformArgumentdef(data: str, el: t.ElementT, doc: t.SpecT) -> t.E...
  function parseDefBlock (line 376) | def parseDefBlock(
  function wrapCommaList (line 450) | def wrapCommaList(text: str, tagName: str, type: str) -> list[t.NodeT]:
  function canonicalizeAttrs (line 462) | def canonicalizeAttrs(
  function transformRailroad (line 500) | def transformRailroad(data: str, el: t.ElementT, doc: t.SpecT) -> t.Elem...
  function transformBiblio (line 518) | def transformBiblio(data: str, el: t.ElementT | None, doc: t.SpecT) -> t...
  function transformAnchors (line 527) | def transformAnchors(data: str, el: t.ElementT | None, doc: t.SpecT) -> ...
  function processAnchors (line 534) | def processAnchors(anchors: InfoTreeT, doc: t.SpecT, lineNum: int | None...
  function transformLinkDefaults (line 632) | def transformLinkDefaults(data: str, el: t.ElementT | None, doc: t.SpecT...
  function processLinkDefaults (line 639) | def processLinkDefaults(lds: InfoTreeT, doc: t.SpecT, lineNum: int | Non...
  function transformIgnoredSpecs (line 670) | def transformIgnoredSpecs(data: str, el: t.ElementT | None, doc: t.SpecT...
  function processIgnoredSpecs (line 677) | def processIgnoredSpecs(specs: InfoTreeT, doc: t.SpecT, lineNum: int | N...
  function transformInfo (line 700) | def transformInfo(data: str, el: t.ElementT | None, doc: t.SpecT) -> t.E...
  function processInfo (line 710) | def processInfo(infos: InfoTreeT, doc: t.SpecT, lineNum: int | None = No...
  function transformInclude (line 733) | def transformInclude(data: str, el: t.ElementT, doc: t.SpecT) -> t.Eleme...
  function transformIncludeCode (line 768) | def transformIncludeCode(data: str, el: t.ElementT, doc: t.SpecT) -> t.E...
  function transformIncludeRaw (line 830) | def transformIncludeRaw(data: str, el: t.ElementT, doc: t.SpecT) -> t.El...
  function parseInfoTree (line 850) | def parseInfoTree(lines: list[str], indent: int = 4, lineNum: int | None...
  function removeCommentLines (line 939) | def removeCommentLines(lines: list[str]) -> list[str]:
  function removeBlankLines (line 947) | def removeBlankLines(lines: list[str]) -> list[str]:
  function removeIndent (line 957) | def removeIndent(lines: list[str], tabSize: int) -> list[str]:

FILE: bikeshed/dfnpanels/dfn-panel.js
  function genAllDfnPanels (line 15) | function genAllDfnPanels() {
  function genDfnPanel (line 28) | function genDfnPanel(dfn, { dfnID, url, dfnText, refSections, external }) {
  function hideAllDfnPanels (line 80) | function hideAllDfnPanels() {
  function showDfnPanel (line 85) | function showDfnPanel(dfn) {
  function positionDfnPanel (line 105) | function positionDfnPanel(dfnPanel) {
  function pinDfnPanel (line 121) | function pinDfnPanel(dfnPanel) {
  function hideDfnPanel (line 129) | function hideDfnPanel({dfn, dfnPanel}) {
  function toggleDfnPanel (line 139) | function toggleDfnPanel(dfn) {
  function insertDfnPopupAction (line 147) | function insertDfnPopupAction(dfn) {
  function refocusOnTarget (line 167) | function refocusOnTarget(event) {
  function getBounds (line 178) | function getBounds(el, relativeTo=document.body) {
  function scrollToTargetAndHighlight (line 191) | function scrollToTargetAndHighlight(event) {
  function needsFor (line 207) | function needsFor(type) {
  function refusesFor (line 235) | function refusesFor(type) {
  function linkFormatterFromType (line 252) | function linkFormatterFromType(type) {
  function genLinkingSyntaxes (line 305) | function genLinkingSyntaxes(dfn) {

FILE: bikeshed/dfnpanels/dfnpanels.py
  function addDfnPanels (line 10) | def addDfnPanels(doc: t.SpecT, dfns: list[t.ElementT]) -> None:
  function addExternalDfnPanel (line 59) | def addExternalDfnPanel(termEl: t.ElementT, ref: t.RefWrapper, doc: t.Sp...

FILE: bikeshed/dfns/attributeInfo.py
  function annotateDfns (line 10) | def annotateDfns(doc: t.SpecT) -> None:
  function addAttributeInfoSpans (line 15) | def addAttributeInfoSpans(doc: t.SpecT) -> None:
  function fillAttributeInfoSpans (line 46) | def fillAttributeInfoSpans(doc: t.SpecT) -> None:
  class TargetInfo (line 60) | class TargetInfo:
  function getTargetInfo (line 67) | def getTargetInfo(doc: t.SpecT, el: t.ElementT) -> TargetInfo | None:
  function htmlFromInfo (line 109) | def htmlFromInfo(info: TargetInfo) -> list[t.NodeT]:

FILE: bikeshed/doctypes/manager.py
  class Doctype (line 12) | class Doctype:
    method __str__ (line 17) | def __str__(self) -> str:
  class DoctypeManager (line 22) | class DoctypeManager:
    method fromKdlStr (line 27) | def fromKdlStr(data: str) -> DoctypeManager:
    method getStatuses (line 41) | def getStatuses(self, name: str) -> list[Status]:
    method getStatus (line 50) | def getStatus(self, orgName: str | None, statusName: str, allowGeneric...
    method getGroups (line 66) | def getGroups(self, orgName: str | None, groupName: str) -> list[Group]:
    method getGroup (line 76) | def getGroup(self, orgName: str | None, groupName: str) -> Group | None:
    method getOrg (line 84) | def getOrg(self, orgName: str) -> Org | None:
    method getDoctype (line 87) | def getDoctype(self, orgName: str | None, groupName: str | None, statu...
  class Org (line 93) | class Org:
    method fromKdlNode (line 99) | def fromKdlNode(node: kdl.Node) -> Org:
    method __bool__ (line 110) | def __bool__(self) -> bool:
  class Group (line 118) | class Group:
    method fullName (line 125) | def fullName(self) -> str:
    method fromKdlNode (line 132) | def fromKdlNode(node: kdl.Node, org: Org) -> Group:
    method __bool__ (line 144) | def __bool__(self) -> bool:
  class Status (line 152) | class Status:
    method fullName (line 159) | def fullName(self) -> str:
    method looselyMatch (line 165) | def looselyMatch(self, rawStatus: str) -> bool:
    method fromKdlNode (line 174) | def fromKdlNode(node: kdl.Node, org: Org | None = None) -> Status:
    method __bool__ (line 186) | def __bool__(self) -> bool:

FILE: bikeshed/doctypes/utils.py
  function canonicalize (line 10) | def canonicalize(
  function splitOrg (line 159) | def splitOrg(st: str | None) -> tuple[str | None, str | None]:
  function reconcileOrgs (line 170) | def reconcileOrgs(fromRaw: str | None, fromStatus: str | None, fromGroup...
  function validateW3CStatus (line 203) | def validateW3CStatus(status: Status) -> None:

FILE: bikeshed/extensions.py
  function load (line 6) | def load(doc: t.SpecT) -> None:

FILE: bikeshed/fingerprinting.py
  function addTrackingVector (line 8) | def addTrackingVector(doc: t.SpecT) -> None:
  function trackingVectorImage (line 62) | def trackingVectorImage(

FILE: bikeshed/fonts/fonts.py
  class Font (line 25) | class Font:
    method __init__ (line 29) | def __init__(self, glyphs: Glyphs, md: FontMetadata) -> None:
    method fromPath (line 37) | def fromPath(fontfilepath: str | Path) -> Font:
    method fromKdl (line 47) | def fromKdl(kdlText: str) -> Font:
    method write (line 64) | def write(self, text: str) -> list[str]:
  class Glyph (line 81) | class Glyph:
    method height (line 87) | def height(self) -> int:
    method fromKdl (line 91) | def fromKdl(node: kdl.Node) -> Glyph:
  class FontMetadata (line 135) | class FontMetadata:
  class PartialFontMetadata (line 140) | class PartialFontMetadata:
    method inferFromGlyphs (line 143) | def inferFromGlyphs(self, glyphs: Glyphs) -> FontMetadata:
  function normalizeCharacters (line 149) | def normalizeCharacters(glyphs: Glyphs, md: FontMetadata) -> Glyphs:
  function getMetadata (line 172) | def getMetadata(doc: kdl.Document) -> PartialFontMetadata:
  function inferHeight (line 180) | def inferHeight(glyphs: Glyphs) -> int:
  function main (line 186) | def main() -> None:

FILE: bikeshed/fonts/rewrite.py
  function replaceComments (line 14) | def replaceComments(font: Font, inputFilename: str | None = None, output...
  function getInputLines (line 41) | def getInputLines(inputFilename: str | None) -> tuple[list[str], str]:
  function writeOutputLines (line 67) | def writeOutputLines(outputFilename: str | None, inputFilename: str, lin...

FILE: bikeshed/func.py
  class Functor (line 6) | class Functor:
    method __init__ (line 9) | def __init__(self, val: t.Any) -> None:
    method extract (line 12) | def extract(self) -> t.Any:
    method map (line 15) | def map(self, fn: t.Any) -> t.Any:

FILE: bikeshed/h/dom.py
  function unescape (line 22) | def unescape(string: str) -> str:
  function findAll (line 26) | def findAll(sel: str, context: t.SpecT | t.ElementT) -> list[t.ElementT]:
  function find (line 38) | def find(sel: str, context: t.SpecT | t.ElementT) -> t.ElementT | None:
  function escapeCSSIdent (line 46) | def escapeCSSIdent(val: str) -> str:
  function escapeUrlFrag (line 72) | def escapeUrlFrag(val: str) -> str:
  function validUrlUnit (line 83) | def validUrlUnit(char: str) -> bool:
  function textContent (line 106) | def textContent(el: t.ElementT, exact: bool = False) -> str:
  function textContentIgnoringDecorative (line 118) | def textContentIgnoringDecorative(el: t.ElementT) -> str:
  function innerHTML (line 128) | def innerHTML(el: t.ElementT | None) -> str:
  function outerHTML (line 134) | def outerHTML(el: t.NodeT | None, literal: bool = False, with_tail: bool...
  function printNodeTree (line 144) | def printNodeTree(node: t.NodeT | str, maxDepth: int | None = None, dept...
  function linkTextsFromElement (line 188) | def linkTextsFromElement(el: t.ElementT) -> list[str]:
  class DuplicatedLinkText (line 218) | class DuplicatedLinkText(Exception):
    method __init__ (line 219) | def __init__(self, offendingText: str, allTexts: list[str], el: t.Elem...
    method __unicode__ (line 225) | def __unicode__(self) -> str:
  function firstLinkTextFromElement (line 229) | def firstLinkTextFromElement(el: t.ElementT) -> str | None:
  function serializeTag (line 237) | def serializeTag(el: t.ElementT, includeBs: bool = False, shortenAttrs: ...
  function tagName (line 255) | def tagName(el: t.ElementT | None) -> str | None:
  function foldWhitespace (line 263) | def foldWhitespace(text: str) -> str:
  function sortElements (line 267) | def sortElements(el: t.Iterable[t.ElementT]) -> list[t.ElementT]:
  function safeHtml (line 271) | def safeHtml(
  function safeBikeshedHtml (line 282) | def safeBikeshedHtml(
  function parseHTML (line 291) | def parseHTML(text: t.SafeHtmlStr) -> list[t.NodeT]:
  function parseElements (line 297) | def parseElements(text: t.SafeHtmlStr) -> list[t.ElementT]:
  function parseInto (line 303) | def parseInto(container: t.ElementT, text: t.SafeHtmlStr, allowEmpty: bo...
  function parseDocument (line 309) | def parseDocument(
  function escapeHTML (line 354) | def escapeHTML(text: str) -> str:
  function escapeAttr (line 359) | def escapeAttr(text: str) -> str:
  function clearContents (line 363) | def clearContents(el: t.ElementT) -> t.ElementT:
  function parentElement (line 369) | def parentElement(el: t.ElementT | None, depth: int = 1) -> t.ElementT |...
  function nextSiblingNode (line 377) | def nextSiblingNode(el: t.ElementT) -> t.ElementT | None:
  function nextSiblingElement (line 381) | def nextSiblingElement(el: t.ElementT) -> t.ElementT | None:
  function appendChild (line 391) | def appendChild(parent: t.ElementT, *els: t.NodeT, allowEmpty: t.Literal...
  function appendChild (line 395) | def appendChild(parent: t.ElementT, *els: t.NodeT, allowEmpty: bool) -> ...
  function appendChild (line 398) | def appendChild(parent: t.ElementT, *children: t.NodeT, allowEmpty: bool...
  function prependChild (line 429) | def prependChild(parent: t.ElementT, *children: t.NodeT) -> None:
  function insertBefore (line 445) | def insertBefore(target: t.ElementT, *els: t.NodeT) -> t.ElementT:
  function insertAfter (line 463) | def insertAfter(target: t.ElementT, *els: t.NodeT) -> t.ElementT:
  function removeNode (line 475) | def removeNode(node: t.ElementT) -> t.ElementT:
  function replaceNode (line 495) | def replaceNode(node: t.ElementT, *replacements: t.NodeT) -> t.NodeT | N...
  function transferAttributes (line 506) | def transferAttributes(source: t.ElementT, target: t.ElementT) -> t.Elem...
  function appendContents (line 512) | def appendContents(el: t.ElementT, container: t.ElementT | t.NodeListT) ...
  function replaceContents (line 520) | def replaceContents(el: t.ElementT, newElements: t.ElementT | t.NodeList...
  function replaceWithContents (line 525) | def replaceWithContents(el: t.ElementT) -> t.NodeT | None:
  function moveContents (line 529) | def moveContents(toEl: t.ElementT, fromEl: t.ElementT) -> None:
  function wrapContents (line 534) | def wrapContents(parentEl: t.ElementT, wrapperEl: t.ElementT) -> t.Eleme...
  function headingLevelOfElement (line 540) | def headingLevelOfElement(el: t.ElementT) -> str | None:
  function relevantHeadings (line 547) | def relevantHeadings(startEl: t.ElementT, levels: list[int] | None = Non...
  function sectionName (line 561) | def sectionName(doc: t.SpecT, el: t.ElementT) -> str | None:
  function collectLinksWithSectionNames (line 575) | def collectLinksWithSectionNames(
  function scopingElements (line 600) | def scopingElements(startEl: t.ElementT, tags: list[str]) -> t.Generator...
  function previousElements (line 617) | def previousElements(startEl: t.ElementT, tag: str | None = None, *tags:...
  function childElements (line 628) | def childElements(parentEl: t.ElementT, oddNodes: bool = False) -> t.Gen...
  function siblingElements (line 633) | def siblingElements(el: t.ElementT, preceding: bool = False) -> t.Iterab...
  function ancestorElements (line 637) | def ancestorElements(el: t.ElementT, self: bool = False) -> t.Generator[...
  function childNodes (line 643) | def childNodes(
  function nodeIter (line 705) | def nodeIter(el: t.ElementT, clear: bool = False, skipOddNodes: bool = T...
  function treeAttr (line 733) | def treeAttr(el: t.ElementT, attrName: str) -> str | None:
  function closestAttr (line 744) | def closestAttr(el: t.ElementT, *attrs: str) -> tuple[str, str] | tuple[...
  function closestAncestor (line 757) | def closestAncestor(el: t.ElementT, pred: ElementPredT) -> t.ElementT | ...
  function filterAncestors (line 765) | def filterAncestors(el: t.ElementT, pred: ElementPredT) -> t.Generator[t...
  function hasAncestor (line 772) | def hasAncestor(el: t.ElementT, pred: ElementPredT) -> bool:
  function removeAttr (line 776) | def removeAttr(el: t.ElementT, *attrNames: str) -> t.ElementT:
  function renameAttr (line 784) | def renameAttr(el: t.ElementT, oldAttr: str, newAttr: str) -> t.ElementT:
  function hasAnyAttr (line 794) | def hasAnyAttr(el: t.ElementT, *attrNames: str) -> bool:
  function hasAttr (line 799) | def hasAttr(el: t.ElementT, attrName: str) -> bool:
  function hasAttrs (line 803) | def hasAttrs(el: t.ElementT) -> bool:
  function addClass (line 807) | def addClass(doc: t.SpecT, el: t.ElementT, cls: str) -> t.ElementT:
  function hasClass (line 817) | def hasClass(doc: t.SpecT, el: t.ElementT, cls: str) -> bool:
  function removeClass (line 833) | def removeClass(el: t.ElementT, cls: str) -> t.ElementT:
  function isElement (line 845) | def isElement(node: t.Any) -> t.TypeIs[t.ElementT]:
  function isNode (line 850) | def isNode(node: t.Any) -> t.TypeIs[t.NodeT]:
  function isOddNode (line 854) | def isOddNode(node: t.Any) -> bool:
  function isNormative (line 863) | def isNormative(doc: t.SpecT, el: t.ElementT) -> bool:
  function isEmpty (line 893) | def isEmpty(el: t.ElementT) -> bool:
  function hasChildElements (line 898) | def hasChildElements(el: t.ElementT) -> bool:
  function hasOnlyChild (line 908) | def hasOnlyChild(el: t.ElementT, wsAllowed: bool = True) -> t.ElementT |...
  function isOnlyChild (line 926) | def isOnlyChild(el: t.ElementT, wsAllowed: bool = True) -> bool:
  function fixSurroundingTypography (line 933) | def fixSurroundingTypography(el: t.ElementT) -> t.ElementT:
  function unfixTypography (line 941) | def unfixTypography(text: str) -> str:
  function emptyText (line 949) | def emptyText(text: str | None, wsAllowed: bool = True) -> bool:
  function hashContents (line 960) | def hashContents(el: t.ElementT) -> str:
  function replaceMacrosTextly (line 968) | def replaceMacrosTextly(text: str, macros: t.Mapping[str, str], context:...
  function fixupIDs (line 998) | def fixupIDs(doc: t.SpecT, els: t.Iterable[t.ElementT]) -> None:
  function safeID (line 1003) | def safeID(doc: t.SpecT, id: str) -> str:
  function uniqueID (line 1012) | def uniqueID(*s: str) -> str:
  function addOldIDs (line 1018) | def addOldIDs(els: t.Iterable[t.ElementT]) -> None:
  function dedupIDs (line 1029) | def dedupIDs(doc: t.SpecT) -> None:
  function approximateLineNumber (line 1074) | def approximateLineNumber(el: t.ElementT, setIntermediate: bool = True) ...
  function parseLineNumber (line 1090) | def parseLineNumber(el: t.ElementT) -> int | None:
  function circledDigits (line 1105) | def circledDigits(num: int) -> str:
  function collectIds (line 1116) | def collectIds(el: t.ElementT, ids: dict[str, t.ElementT] | None = None)...
  function collectAutolinks (line 1127) | def collectAutolinks(el: t.ElementT, links: list[t.ElementT] | None = No...
  function collectSyntaxHighlightables (line 1139) | def collectSyntaxHighlightables(el: t.ElementT, els: list[t.ElementT] | ...
  function createElement (line 1149) | def createElement(
  class ElementCreatorFnT (line 1164) | class ElementCreatorFnT(t.Protocol):
    method __call__ (line 1165) | def __call__(
  class ElementCreationHelper (line 1172) | class ElementCreationHelper:
    method __getattr__ (line 1173) | def __getattr__(self, name: str) -> ElementCreatorFnT:

FILE: bikeshed/h/merge.py
  class Tag (line 16) | class Tag(metaclass=abc.ABCMeta):
  class TagStart (line 21) | class TagStart(Tag):
  class TagEnd (line 27) | class TagEnd(Tag):
  class TagStr (line 33) | class TagStr(Tag):
  function mergeTrees (line 41) | def mergeTrees(tree1: t.ElementT, tree2: t.ElementT) -> list[t.NodeT]:
  function digestTree (line 67) | def digestTree(root: t.ElementT, nested: bool = False) -> TagStream:
  function textLength (line 87) | def textLength(el: t.ElementT) -> int:
  function mergeStreams (line 97) | def mergeStreams(s1: TagStream, s2: TagStream) -> TagStream:

FILE: bikeshed/h/parser/main.py
  function nodesFromHtml (line 27) | def nodesFromHtml(
  function initialDocumentParse (line 42) | def initialDocumentParse(
  function strFromNodes (line 60) | def strFromNodes(nodes: t.Iterable[ParserNode], withIlcc: bool = False) ...
  function linesFromNodes (line 83) | def linesFromNodes(nodes: t.Iterable[ParserNode]) -> list[t.EarlyParsedH...
  function debugNodes (line 87) | def debugNodes(nodes: t.Iterable[ParserNode]) -> list[ParserNode]:
  function parseLines (line 95) | def parseLines(
  function parseText (line 120) | def parseText(
  function parseTitle (line 133) | def parseTitle(

FILE: bikeshed/h/parser/nodes.py
  function startTagStr (line 20) | def startTagStr(tagName: str, attrs: t.SafeAttrDict) -> str:
  function sortAttrs (line 34) | def sortAttrs(attrs: t.SafeAttrDict) -> t.Iterator[tuple[str, str]]:
  function startTagStrFromNode (line 45) | def startTagStrFromNode(node: StartTag | SelfClosedTag) -> str:
  class ParserNode (line 56) | class ParserNode(metaclass=ABCMeta):
    method height (line 64) | def height(self) -> int:
    method __str__ (line 68) | def __str__(self) -> str:
  class Text (line 73) | class Text(ParserNode, metaclass=ABCMeta):
  class RawText (line 78) | class RawText(Text):
    method __str__ (line 81) | def __str__(self) -> str:
    method fromStream (line 85) | def fromStream(cls, s: Stream, start: int, end: int, text: str | None ...
    method fromSafeText (line 96) | def fromSafeText(cls, node: SafeText) -> t.Self:
    method curlifyApostrophes (line 106) | def curlifyApostrophes(self, lastNode: ParserNode | None) -> RawText:
    method needsLCCs (line 118) | def needsLCCs(self) -> bool:
  class SafeText (line 127) | class SafeText(Text):
    method __str__ (line 130) | def __str__(self) -> str:
    method fromStream (line 134) | def fromStream(cls, s: Stream, start: int, end: int, text: str | None ...
  class Doctype (line 146) | class Doctype(ParserNode):
    method __str__ (line 149) | def __str__(self) -> str:
    method fromStream (line 153) | def fromStream(cls, s: Stream, start: int, end: int, data: str) -> t.S...
  class StartTag (line 165) | class StartTag(ParserNode):
    method fromStream (line 172) | def fromStream(
    method __str__ (line 192) | def __str__(self) -> str:
    method printEndTag (line 195) | def printEndTag(self) -> str:
    method finalize (line 198) | def finalize(self) -> StartTag:
    method clone (line 204) | def clone(self, **kwargs: t.Any) -> StartTag:
  class SelfClosedTag (line 209) | class SelfClosedTag(ParserNode):
    method fromStream (line 215) | def fromStream(
    method fromStartTag (line 236) | def fromStartTag(cls, tag: StartTag) -> t.Self:
    method __str__ (line 248) | def __str__(self) -> str:
    method finalize (line 273) | def finalize(self) -> SelfClosedTag:
    method clone (line 279) | def clone(self, **kwargs: t.Any) -> SelfClosedTag:
  class EndTag (line 284) | class EndTag(ParserNode):
    method fromStream (line 289) | def fromStream(cls, s: Stream, start: int, end: int, tag: str | StartT...
    method __str__ (line 303) | def __str__(self) -> str:
  class Comment (line 308) | class Comment(ParserNode):
    method fromStream (line 312) | def fromStream(cls, s: Stream, start: int, end: int, data: str) -> t.S...
    method __str__ (line 322) | def __str__(self) -> str:
  class RawElement (line 331) | class RawElement(ParserNode):
    method fromStream (line 337) | def fromStream(cls, s: Stream, start: int, end: int, startTag: StartTa...
    method __str__ (line 349) | def __str__(self) -> str:
  class SafeElement (line 358) | class SafeElement(ParserNode):
    method fromStream (line 364) | def fromStream(cls, s: Stream, start: int, end: int, startTag: StartTa...
    method __str__ (line 376) | def __str__(self) -> str:
  function escapeHTML (line 380) | def escapeHTML(text: str) -> str:
  function escapeAttr (line 385) | def escapeAttr(text: str) -> t.SafeAttrStr:
  function minimalEscapeAttr (line 389) | def minimalEscapeAttr(text: str) -> t.SafeAttrStr:
  function unescapeAttr (line 393) | def unescapeAttr(text: t.SafeAttrStr | t.EmptyLiteralStr) -> str:
  class TagStack (line 398) | class TagStack:
    method printOpenTags (line 404) | def printOpenTags(self) -> list[str]:
    method inOpaqueElement (line 407) | def inOpaqueElement(self) -> bool:
    method inTagContext (line 410) | def inTagContext(self, tagName: str, stopTags: list[str] | None = None...
    method getDeepestFromTag (line 424) | def getDeepestFromTag(self, tagName: str) -> TagStackEntry | None:
    method pushEntry (line 430) | def pushEntry(self, entry: TagStackEntry) -> None:
    method popEntry (line 436) | def popEntry(self) -> TagStackEntry:
    method undo (line 443) | def undo(self, startTag: StartTag) -> None:
    method update (line 453) | def update(self, node: ParserNode) -> None:
    method updateShorthandOpen (line 515) | def updateShorthandOpen(self, startTag: StartTag, sigils: tuple[str, s...
    method updateShorthandClose (line 518) | def updateShorthandClose(
    method cancelShorthandOpen (line 541) | def cancelShorthandOpen(self, startTag: StartTag, sigils: tuple[str, s...
    method autoCloseStart (line 553) | def autoCloseStart(self, tag: str, node: ParserNode) -> None:
    method autoCloseEnd (line 640) | def autoCloseEnd(self, tag: str, node: ParserNode) -> None:
    method virtualClose (line 718) | def virtualClose(
    method virtualCloseUntil (line 743) | def virtualCloseUntil(self, tags: list[str], node: ParserNode, realEnd...
    method virtualCloseShorthand (line 772) | def virtualCloseShorthand(self, s: Stream, i: int, startTag: StartTag)...
    method nearestHeading (line 786) | def nearestHeading(self) -> TagStackEntry | None:
    method verifyTagContext (line 792) | def verifyTagContext(self, node: StartTag) -> None:
  class TagStackEntry (line 822) | class TagStackEntry:
    method __post_init__ (line 827) | def __post_init__(self, opaqueTags: set[str]) -> None:
    method name (line 839) | def name(self) -> str:
  class TagStackShorthandEntry (line 844) | class TagStackShorthandEntry(TagStackEntry):
    method name (line 848) | def name(self) -> str:

FILE: bikeshed/h/parser/parser.py
  function nodesFromStream (line 64) | def nodesFromStream(s: Stream, start: int) -> t.Generator[ParserNode, No...
  function closeOpenElements (line 101) | def closeOpenElements(s: Stream, start: int | None, context: str | Start...
  function generateNodes (line 146) | def generateNodes(s: Stream, start: int) -> t.Generator[ParserNode, None...
  function debugNode (line 160) | def debugNode(node: ParserNode | list[ParserNode]) -> str:
  function generateResults (line 176) | def generateResults(
  function generateExperimentalNodes (line 194) | def generateExperimentalNodes(s: Stream, start: int, coll: list[ParserNo...
  function parseAnything (line 209) | def parseAnything(s: Stream, start: int, experimental: bool = False) -> ...
  function parseNode (line 239) | def parseNode(
  function parseLToEnd (line 489) | def parseLToEnd(s: Stream, start: int, lTag: StartTag) -> ResultT[Parser...
  function parseRepositoryLink (line 566) | def parseRepositoryLink(
  function parseRepositoryStart (line 616) | def parseRepositoryStart(s: Stream, start: int) -> ResultT[tuple[str, st...
  function parseDigits (line 629) | def parseDigits(s: Stream, start: int) -> ResultT[str]:
  function parseAngleStart (line 642) | def parseAngleStart(s: Stream, start: int) -> ResultT[ParserNode | list[...
  function isDatablock (line 773) | def isDatablock(tag: StartTag, loc: str) -> str | None:
  function isDatablockClass (line 791) | def isDatablockClass(text: str) -> bool:
  function smuggleDatablock (line 811) | def smuggleDatablock(el: RawElement | SafeElement, text: str, blockType:...
  function parseStartTag (line 837) | def parseStartTag(s: Stream, start: int) -> ResultT[StartTag | SelfClose...
  function parseTagName (line 913) | def parseTagName(s: Stream, start: int) -> ResultT[str]:
  function parseAttributeList (line 922) | def parseAttributeList(s: Stream, start: int) -> ResultT[dict[str, str]]:
  function parseAttribute (line 983) | def parseAttribute(s: Stream, start: int) -> ResultT[tuple[str, str]]:
  function parseQuotedAttrValue (line 1015) | def parseQuotedAttrValue(s: Stream, start: int) -> ResultT[str]:
  function parseUnquotedAttrValue (line 1043) | def parseUnquotedAttrValue(s: Stream, start: int) -> ResultT[str]:
  function printChAsCharRef (line 1072) | def printChAsCharRef(ch: str | SafeText) -> str:
  class CharRefContext (line 1087) | class CharRefContext(Enum):
  function parseCharRef (line 1093) | def parseCharRef(s: Stream, start: int, context: CharRefContext) -> Resu...
  function parseWhitespace (line 1198) | def parseWhitespace(s: Stream, start: int) -> ResultT[bool]:
  function parseEndTag (line 1208) | def parseEndTag(s: Stream, start: int) -> ResultT[EndTag]:
  function parseComment (line 1238) | def parseComment(s: Stream, start: int) -> ResultT[Comment]:
  function parseDoctype (line 1269) | def parseDoctype(s: Stream, start: int) -> ResultT[Doctype]:
  function parseScriptToEnd (line 1280) | def parseScriptToEnd(s: Stream, start: int) -> OkT[str]:
  function parseStyleToEnd (line 1298) | def parseStyleToEnd(s: Stream, start: int) -> OkT[str]:
  function parseXmpToEnd (line 1314) | def parseXmpToEnd(s: Stream, start: int) -> OkT[str]:
  function parseTitleToEnd (line 1330) | def parseTitleToEnd(s: Stream, start: int) -> ResultT[str]:
  function parseDatablockPreToEnd (line 1366) | def parseDatablockPreToEnd(s: Stream, start: int) -> ResultT[str]:
  function parseOpaqueToEnd (line 1395) | def parseOpaqueToEnd(s: Stream, dataStart: int, startTag: StartTag, star...
  function parseCSSProduction (line 1478) | def parseCSSProduction(s: Stream, start: int) -> ResultT[ParserNode | li...
  function parseRangeComponent (line 1617) | def parseRangeComponent(s: Stream, i: int, val: str) -> tuple[str | None...
  function parseCSSMaybe (line 1648) | def parseCSSMaybe(s: Stream, start: int) -> ResultT[list[ParserNode]]:
  function parseMaybeDecl (line 1667) | def parseMaybeDecl(s: Stream, textStart: int) -> ResultT[list[ParserNode]]:
  function parseMaybeValue (line 1727) | def parseMaybeValue(s: Stream, textStart: int) -> ResultT[list[ParserNod...
  function rawFromDoubleAngles (line 1846) | def rawFromDoubleAngles(text: str) -> str:
  function safeFromDoubleAngles (line 1855) | def safeFromDoubleAngles(text: str) -> str:
  function parseCSSPropdesc (line 1871) | def parseCSSPropdesc(s: Stream, start: int) -> ResultT[SafeText | list[P...
  function parseAutolinkDfn (line 1971) | def parseAutolinkDfn(s: Stream, start: int) -> ResultT[SafeText | list[P...
  function parseAutolinkAbstract (line 2024) | def parseAutolinkAbstract(s: Stream, start: int) -> ResultT[SafeText | l...
  function parseAutolinkHeader (line 2077) | def parseAutolinkHeader(s: Stream, start: int) -> ResultT[SafeText | lis...
  function parseAutolinkIdl (line 2137) | def parseAutolinkIdl(s: Stream, start: int) -> ResultT[ParserNode | list...
  function parseAutolinkCddl (line 2217) | def parseAutolinkCddl(s: Stream, start: int) -> ResultT[ParserNode | lis...
  function parseAutolinkElement (line 2282) | def parseAutolinkElement(s: Stream, start: int) -> ResultT[ParserNode | ...
  function parseShorthandVariable (line 2344) | def parseShorthandVariable(s: Stream, start: int) -> ResultT[ParserNode ...
  function parseAutolinkBiblioSection (line 2361) | def parseAutolinkBiblioSection(s: Stream, start: int) -> ResultT[ParserN...
  class LinkData (line 2405) | class LinkData:
  function parseLinkInfo (line 2411) | def parseLinkInfo(
  function parseLinkText (line 2473) | def parseLinkText(
  function parseBiblioInner (line 2515) | def parseBiblioInner(s: Stream, innerStart: int) -> ResultT[tuple[StartT...
  function parseSectionInner (line 2590) | def parseSectionInner(s: Stream, innerStart: int) -> ResultT[tuple[Start...
  function parseCodeSpan (line 2645) | def parseCodeSpan(s: Stream, start: int) -> ResultT[list[ParserNode]]:
  function parseFencedCodeBlock (line 2690) | def parseFencedCodeBlock(s: Stream, start: int) -> ResultT[SafeElement]:
  class MacroContext (line 2760) | class MacroContext(Enum):
  function parseMacro (line 2766) | def parseMacro(
  function parseMacroToNodes (line 2851) | def parseMacroToNodes(s: Stream, start: int) -> ResultT[ParserNode | lis...
  function parseMacroToAttrs (line 2855) | def parseMacroToAttrs(s: Stream, start: int) -> ResultT[dict[str, str]]:
  function parseMacroToText (line 2859) | def parseMacroToText(s: Stream, start: int) -> ResultT[str]:
  function replaceMacrosInText (line 2868) | def replaceMacrosInText(text: str, macros: dict[str, str], s: Stream, st...
  function isMetadataBlock (line 2921) | def isMetadataBlock(startTag: StartTag) -> bool:
  function parseMetadataBlockToEnd (line 2932) | def parseMetadataBlockToEnd(s: Stream, start: int, startTag: StartTag, i...
  function isMacroStart (line 2972) | def isMacroStart(s: Stream, start: int) -> bool:
  function parseMarkdownLink (line 2982) | def parseMarkdownLink(s: Stream, start: int) -> ResultT[ParserNode | lis...
  function parseMarkdownLinkDestTitle (line 3028) | def parseMarkdownLinkDestTitle(s: Stream, start: int) -> ResultT[tuple[s...
  function parseMarkdownLinkWhitespace (line 3087) | def parseMarkdownLinkWhitespace(s: Stream, start: int) -> ResultT[str]:
  function parseMarkdownLinkAngleDest (line 3104) | def parseMarkdownLinkAngleDest(s: Stream, start: int) -> ResultT[str]:
  function parseMarkdownLinkIdentDest (line 3151) | def parseMarkdownLinkIdentDest(s: Stream, start: int) -> ResultT[str]:
  function parseMarkdownLinkTitle (line 3205) | def parseMarkdownLinkTitle(s: Stream, start: int, startChar: str) -> Res...
  function parseMarkdownEscape (line 3259) | def parseMarkdownEscape(s: Stream, start: int) -> ResultT[str]:
  function isMarkdownEscape (line 3267) | def isMarkdownEscape(s: Stream, start: int) -> bool:
  function htmlifyMarkdownEscapes (line 3307) | def htmlifyMarkdownEscapes(val: str) -> str:
  function markdownEscapeReplacer (line 3311) | def markdownEscapeReplacer(match: t.Match) -> str:

FILE: bikeshed/h/parser/preds.py
  function isXMLishTagname (line 225) | def isXMLishTagname(tagname: str) -> bool:
  function isTagnameChar (line 229) | def isTagnameChar(ch: str) -> bool:
  function isAttrNameChar (line 256) | def isAttrNameChar(ch: str) -> bool:
  function isASCII (line 270) | def isASCII(ch: str) -> bool:
  function isASCIIAlphanum (line 277) | def isASCIIAlphanum(ch: str) -> bool:
  function isASCIIAlpha (line 281) | def isASCIIAlpha(ch: str) -> bool:
  function isASCIILowerAlpha (line 285) | def isASCIILowerAlpha(ch: str) -> bool:
  function isASCIIUpperAlpha (line 291) | def isASCIIUpperAlpha(ch: str) -> bool:
  function isDigit (line 297) | def isDigit(ch: str) -> bool:
  function isHexDigit (line 303) | def isHexDigit(ch: str) -> bool:
  function isWhitespace (line 309) | def isWhitespace(ch: str | int) -> bool:
  function isControl (line 319) | def isControl(ch: str | int) -> bool:
  function isNoncharacter (line 329) | def isNoncharacter(ch: str | int) -> bool:

FILE: bikeshed/h/parser/result.py
  function Ok (line 11) | def Ok[U](val: U, index: int) -> OkT[U]:
  function Err (line 15) | def Err(index: int) -> ErrT:
  function isOk (line 19) | def isOk[U](res: ResultT[U]) -> t.TypeIs[OkT[U]]:
  function isErr (line 23) | def isErr(res: ResultT[t.Any]) -> t.TypeIs[ErrT]:

FILE: bikeshed/h/parser/simpleparser.py
  function parseDocument (line 16) | def parseDocument(text: str) -> tuple[t.ElementT, t.ElementT, t.ElementT]:
  function parseFragment (line 21) | def parseFragment(text: str) -> t.ElementT:
  function parse (line 63) | def parse(s: SimpleStream, start: int) -> tuple[t.ElementT, t.ElementT, ...
  function parseDoctype (line 90) | def parseDoctype(s: SimpleStream, start: int) -> int:
  function parseStartTag (line 97) | def parseStartTag(s: SimpleStream, start: int) -> int:
  function parseEndTag (line 122) | def parseEndTag(s: SimpleStream, start: int) -> int:
  function parseAttributeList (line 132) | def parseAttributeList(s: SimpleStream, start: int) -> tuple[dict[str, s...
  function undoLineBreakSmuggling (line 148) | def undoLineBreakSmuggling(attrs: dict[str, str]) -> None:
  function parseAttribute (line 155) | def parseAttribute(s: SimpleStream, start: int) -> tuple[str, str, int]:
  function parseEscape (line 180) | def parseEscape(s: SimpleStream, start: int) -> tuple[str, int]:
  class SimpleStream (line 227) | class SimpleStream:
    method __init__ (line 237) | def __init__(self, text: str) -> None:
    method __getitem__ (line 249) | def __getitem__(self, key: int) -> str:
    method slice (line 254) | def slice(self, start: int, end: int) -> str:
    method eof (line 257) | def eof(self, i: int) -> bool:
    method finish (line 260) | def finish(self) -> tuple[t.ElementT, t.ElementT, t.ElementT]:
    method startTag (line 276) | def startTag(self, tagName: str, attrs: dict[str, str]) -> None:
    method endTag (line 304) | def endTag(self, tagName: str) -> None:
    method selfClosedTag (line 329) | def selfClosedTag(self, tagName: str, attrs: dict[str, str]) -> None:
    method characters (line 333) | def characters(self, chars: str) -> None:
    method pushEl (line 338) | def pushEl(self, tagName: str) -> None:
    method popEl (line 341) | def popEl(self) -> None:
    method startBody (line 344) | def startBody(self) -> None:
    method autoCloseAll (line 352) | def autoCloseAll(self) -> None:
    method autoCloseEnd (line 358) | def autoCloseEnd(self, tagName: str) -> None:
    method autoCloseStart (line 364) | def autoCloseStart(self, tagName: str) -> None:
    method virtualClose (line 440) | def virtualClose(self, tags: list[str] | set[str], scopes: list[str] |...
  function applyAttrs (line 459) | def applyAttrs(el: t.ElementT, attrList: list[dict[str, str]]) -> t.Elem...

FILE: bikeshed/h/parser/stream.py
  class ParseConfig (line 17) | class ParseConfig:
    method fromSpec (line 36) | def fromSpec(doc: t.SpecT, context: str | None = None) -> ParseConfig:
  class Stream (line 61) | class Stream:
    method __init__ (line 70) | def __init__(self, chars: str, config: ParseConfig, startLine: int = 1...
    method subStream (line 85) | def subStream(self, context: str, chars: str, startLine: int = 1) -> S...
    method __getitem__ (line 89) | def __getitem__(self, key: int) -> str:
    method slice (line 94) | def slice(self, start: int | None, stop: int | None) -> str:
    method eof (line 101) | def eof(self, index: int) -> bool:
    method __len__ (line 104) | def __len__(self) -> int:
    method context (line 108) | def context(self) -> str | None:
    method line (line 111) | def line(self, index: int) -> int:
    method col (line 116) | def col(self, index: int) -> int:
    method loc (line 123) | def loc(self, index: int) -> str:
    method skipTo (line 129) | def skipTo(self, start: int, text: str) -> ResultT[str]:
    method skipToSameLine (line 143) | def skipToSameLine(self, start: int, text: str) -> ResultT[str]:
    method matchRe (line 154) | def matchRe(self, start: int, pattern: t.Pattern) -> ResultT[t.Match]:
    method searchRe (line 161) | def searchRe(self, start: int, pattern: t.Pattern) -> ResultT[t.Match]:
    method skipToNextLine (line 168) | def skipToNextLine(self, start: int) -> OkT[str]:
    method precedingLinebreakIndex (line 174) | def precedingLinebreakIndex(self, start: int) -> int:
    method followingLinebreakIndex (line 179) | def followingLinebreakIndex(self, start: int) -> int:
    method currentLineStart (line 185) | def currentLineStart(self, start: int) -> int:
    method nextLineStart (line 193) | def nextLineStart(self, start: int) -> int:
    method precedingTextOnLine (line 202) | def precedingTextOnLine(self, start: int) -> str:
    method remainingTextOnLine (line 206) | def remainingTextOnLine(self, start: int) -> str:
    method observeResult (line 211) | def observeResult(self, res: ResultT[ParserNode | list[ParserNode]]) -...
    method observeNode (line 219) | def observeNode(self, node: ParserNode) -> None:
    method observeNodes (line 222) | def observeNodes(self, nodes: list[ParserNode]) -> None:
    method observeShorthandOpen (line 226) | def observeShorthandOpen(self, startTag: StartTag, sigils: tuple[str, ...
    method observeShorthandClose (line 229) | def observeShorthandClose(self, s: Stream, i: int, startTag: StartTag,...
    method cancelShorthandOpen (line 232) | def cancelShorthandOpen(self, startTag: StartTag, sigils: tuple[str, s...
    method inOpaqueElement (line 235) | def inOpaqueElement(self) -> bool:
    method inTagContext (line 238) | def inTagContext(self, tagName: str) -> bool:

FILE: bikeshed/h/serializer.py
  class Serializer (line 17) | class Serializer:
    method __init__ (line 95) | def __init__(self, opaqueElements: t.Iterable[str], blockElements: t.I...
    method serialize (line 99) | def serialize(self, root: t.ElementT) -> str:
    method unfuckName (line 108) | def unfuckName(self, n: str) -> str:
    method groupIntoBlocks (line 116) | def groupIntoBlocks(self, nodes: t.Iterable[t.NodeT]) -> Blocks:
    method startTag (line 130) | def startTag(self, tag: str, el: Nodes, write: WriterFn) -> None:
    method endTag (line 158) | def endTag(self, tag: str, write: WriterFn) -> None:
    method isElement (line 163) | def isElement(self, node: t.Any) -> t.TypeGuard[t.ElementT]:
    method isAnonBlock (line 166) | def isAnonBlock(self, block: t.Any) -> bool:
    method isVoidElement (line 169) | def isVoidElement(self, tag: str) -> bool:
    method isRawElement (line 172) | def isRawElement(self, tag: str, el: t.ElementT) -> bool:
    method isOpaqueElement (line 179) | def isOpaqueElement(self, tag: str) -> bool:
    method isInlineElement (line 186) | def isInlineElement(self, tag: str) -> bool:
    method isBlockElement (line 191) | def isBlockElement(self, tag: str) -> bool:
    method isWrapper (line 194) | def isWrapper(self, tag: str) -> bool:
    method needsEndTag (line 197) | def needsEndTag(self, el: t.ElementT, nextEl: Nodes | None = None) -> ...
    method justWS (line 208) | def justWS(self, block: Nodes) -> bool:
    method _writeVoidElement (line 213) | def _writeVoidElement(self, tag: str, el: t.ElementT, write: WriterFn,...
    method _writeRawElement (line 217) | def _writeRawElement(self, tag: str, el: t.ElementT, write: WriterFn, ...
    method _writeOpaqueElement (line 246) | def _writeOpaqueElement(self, tag: str, el: t.ElementT, write: WriterF...
    method _writeInlineElement (line 256) | def _writeInlineElement(self, tag: str, el: Nodes, write: WriterFn, in...
    method _blocksFromChildren (line 267) | def _blocksFromChildren(self, children: t.Iterable[t.NodeT]) -> Nodes:
    method _categorizeBlockChildren (line 270) | def _categorizeBlockChildren(self, el: Nodes) -> tuple[str, Nodes | No...
    method _writeBlockElement (line 295) | def _writeBlockElement(self, tag: str, el: t.ElementT, write: WriterFn...
    method _serializeEl (line 337) | def _serializeEl(
  function pairwise (line 371) | def pairwise(iterable: t.Iterable[PairwiseU]) -> itertools.zip_longest[t...

FILE: bikeshed/headings.py
  function processHeadings (line 7) | def processHeadings(doc: t.SpecT, scope: str = "doc") -> None:
  function resetHeadings (line 29) | def resetHeadings(headings: list[t.ElementT]) -> None:
  function addHeadingIds (line 36) | def addHeadingIds(doc: t.SpecT, headings: list[t.ElementT]) -> None:
  function checkPrivacySecurityHeadings (line 59) | def checkPrivacySecurityHeadings(doc: t.SpecT, headings: list[t.ElementT...
  function addHeadingAlgorithms (line 90) | def addHeadingAlgorithms(headings: list[t.ElementT]) -> None:
  function determineHeadingLevels (line 96) | def determineHeadingLevels(doc: t.SpecT, headings: list[t.ElementT]) -> ...
  function addHeadingBonuses (line 129) | def addHeadingBonuses(headings: list[t.ElementT]) -> None:

FILE: bikeshed/highlight/highlight.py
  function loadCSSLexer (line 18) | def loadCSSLexer() -> lexers.CSSLexer:
  class ColoredText (line 26) | class ColoredText:
  function addSyntaxHighlighting (line 32) | def addSyntaxHighlighting(doc: t.SpecT) -> None:
  function determineHighlightLang (line 56) | def determineHighlightLang(doc: t.SpecT, el: t.ElementT) -> str | t.Lite...
  class LineNumberOptions (line 84) | class LineNumberOptions:
  function determineLineNumbers (line 94) | def determineLineNumbers(doc: t.SpecT, el: t.ElementT) -> LineNumberOpti...
  function highlightEl (line 144) | def highlightEl(doc: t.SpecT, el: t.ElementT, lang: str) -> None:
  function readdWhitespacePrefix (line 157) | def readdWhitespacePrefix(rawText: str, coloredText: t.Deque[ColoredText...
  function highlightWithWebIDL (line 179) | def highlightWithWebIDL(text: str, el: t.ElementT) -> t.Deque[ColoredTex...
  function coloredTextFromWidlStack (line 235) | def coloredTextFromWidlStack(widlText: str) -> t.Deque[ColoredText]:
  function highlightWithPygments (line 280) | def highlightWithPygments(text: str, lang: str, el: t.ElementT) -> t.Deq...
  function mergeHighlighting (line 294) | def mergeHighlighting(el: t.ElementT, coloredText: t.Sequence[ColoredTex...
  function coloredTextFromRawTokens (line 343) | def coloredTextFromRawTokens(rawTokens: t.Sequence[tuple[str, str]]) -> ...
  function normalizeLanguageName (line 430) | def normalizeLanguageName(lang: str | None) -> str | None:
  function normalizeHighlightMarkers (line 441) | def normalizeHighlightMarkers(doc: t.SpecT) -> None:
  function lexerFromLang (line 449) | def lexerFromLang(lang: str) -> pygments.lexer.Lexer | None:
  function addLineWrappers (line 458) | def addLineWrappers(doc: t.SpecT, el: t.ElementT, options: LineNumberOpt...
  function splitNodesByLinebreaks (line 490) | def splitNodesByLinebreaks(nodes: t.NodeListT) -> t.Iterator[list[t.Node...
  function countInternalNewlines (line 515) | def countInternalNewlines(el: t.ElementT) -> int:
  function grouper (line 526) | def grouper[T](

FILE: bikeshed/idl.py
  class IDLUI (line 13) | class IDLUI:
    method fromEl (line 18) | def fromEl(el: t.ElementT) -> IDLUI:
    method formatLineNum (line 23) | def formatLineNum(self, localNum: int) -> str:
    method formatMessage (line 29) | def formatMessage(self, msg: str) -> m.MessageOptions:
    method warn (line 37) | def warn(self, msg: str) -> None:
    method note (line 40) | def note(self, msg: str) -> None:
  class IDLSilent (line 44) | class IDLSilent:
    method warn (line 45) | def warn(self, msg: str) -> None:
    method note (line 48) | def note(self, msg: str) -> None:
  class DebugMarker (line 56) | class DebugMarker(widlparser.protocols.Marker):
    method markup_construct (line 59) | def markup_construct(
    method markup_type (line 69) | def markup_type(self, text: str, construct: widlparser.Construct) -> M...
    method markup_primitive_type (line 75) | def markup_primitive_type(self, text: str, construct: widlparser.Const...
    method markup_buffer_type (line 81) | def markup_buffer_type(self, text: str, construct: widlparser.Construc...
    method markup_string_type (line 87) | def markup_string_type(self, text: str, construct: widlparser.Construc...
    method markup_object_type (line 93) | def markup_object_type(self, text: str, construct: widlparser.Construc...
    method markup_type_name (line 99) | def markup_type_name(
    method markup_name (line 109) | def markup_name(
    method markup_keyword (line 119) | def markup_keyword(
    method markup_enum_value (line 129) | def markup_enum_value(
    method encode (line 139) | def encode(self, text: str) -> str:
  class IDLMarker (line 143) | class IDLMarker(widlparser.protocols.Marker):
    method markup_construct (line 144) | def markup_construct(
    method markup_type (line 153) | def markup_type(
    method markup_primitive_type (line 164) | def markup_primitive_type(
    method markup_string_type (line 171) | def markup_string_type(
    method markup_buffer_type (line 178) | def markup_buffer_type(
    method markup_object_type (line 185) | def markup_object_type(
    method markup_type_name (line 192) | def markup_type_name(self, text: str, construct: widlparser.Construct)...
    method markup_keyword (line 238) | def markup_keyword(self, text: str, construct: widlparser.Construct) -...
    method markup_name (line 285) | def markup_name(
    method markup_enum_value (line 368) | def markup_enum_value(self, text: str, construct: widlparser.Construct...
    method encode (line 377) | def encode(self, text: str) -> str:
    method methodLinkingTexts (line 380) | def methodLinkingTexts(self, method: widlparser.OperationRest) -> list...
  function markupIDL (line 414) | def markupIDL(doc: t.SpecT) -> None:
  function getContentStartingLineNum (line 452) | def getContentStartingLineNum(el: t.ElementT) -> int | None:
  function markupIDLBlock (line 473) | def markupIDLBlock(pre: t.ElementT, doc: t.SpecT) -> set[t.ElementT]:
  function combineIdlLinkingTexts (line 539) | def combineIdlLinkingTexts(t1: str | None, t2: str | None) -> str:
  function normalizeIdlWhitespace (line 548) | def normalizeIdlWhitespace(text: str) -> str:
  function getParser (line 556) | def getParser() -> widlparser.parser.Parser:
  function nodesFromType (line 560) | def nodesFromType(prod: widlparser.productions.Production) -> t.ElementT:
  function _nodesFromProduction (line 564) | def _nodesFromProduction(prod: widlparser.productions.Production | widlp...
  function startTag (line 728) | def startTag(tagName: str, attrs: dict[str, str] | None = None) -> str:
  function endTag (line 737) | def endTag(tagName: str) -> str:

FILE: bikeshed/includes.py
  function processInclusions (line 11) | def processInclusions(doc: t.SpecT) -> None:
  function handleBikeshedInclude (line 30) | def handleBikeshedInclude(el: t.ElementT, doc: t.SpecT) -> None:
  function handleCodeInclude (line 102) | def handleCodeInclude(el: t.ElementT, doc: t.SpecT) -> None:
  function handleRawInclude (line 150) | def handleRawInclude(el: t.ElementT, doc: t.SpecT) -> None:
  function parseRangeString (line 185) | def parseRangeString(rangeStr: str) -> list[RangeItem]:
  function parseSingleRange (line 190) | def parseSingleRange(item: str) -> RangeItem | None:

FILE: bikeshed/inlineTags/__init__.py
  function processTags (line 9) | def processTags(doc: t.SpecT) -> None:

FILE: bikeshed/issuelist.py
  class HeaderInfo (line 28) | class HeaderInfo:
  function printIssueList (line 38) | def printIssueList(infilename: str | None = None, outfilename: str | Non...
  function findIssuesFile (line 87) | def findIssuesFile() -> str | None:
  function extractHeaderInfo (line 113) | def extractHeaderInfo(lines: t.Sequence[str], infilename: str) -> Header...
  function printHelpMessage (line 190) | def printHelpMessage() -> None:
  function printHeader (line 221) | def printHeader(outfile: t.TextIO, hi: HeaderInfo) -> None:
  function attr (line 262) | def attr(text: str) -> str:
  function html (line 266) | def html(text: str) -> str:
  function printIssues (line 270) | def printIssues(outfile: t.TextIO, lines: list[str]) -> None:
  function printScript (line 315) | def printScript(outfile: t.TextIO) -> None:

FILE: bikeshed/language.py
  class Language (line 7) | class Language:

FILE: bikeshed/lexers.py
  class CSSLexer (line 7) | class CSSLexer(RegexLexer):

FILE: bikeshed/line.py
  class Line (line 9) | class Line:
    method __unicode__ (line 13) | def __unicode__(self) -> str:
  function rectify (line 17) | def rectify(lines: list[str] | list[Line]) -> list[Line]:

FILE: bikeshed/lint/accidental2119.py
  function accidental2119 (line 9) | def accidental2119(doc: t.SpecT) -> None:

FILE: bikeshed/lint/brokenLinks.py
  function brokenLinks (line 12) | def brokenLinks(doc: t.SpecT) -> None:

FILE: bikeshed/lint/exampleIDs.py
  function exampleIDs (line 7) | def exampleIDs(doc: t.SpecT) -> None:

FILE: bikeshed/lint/missingExposed.py
  function missingExposed (line 9) | def missingExposed(doc: t.SpecT) -> None:

FILE: bikeshed/lint/requiredIDs.py
  function requiredIDs (line 7) | def requiredIDs(doc: t.SpecT) -> None:

FILE: bikeshed/lint/unusedInternalDfns.py
  function unusedInternalDfns (line 8) | def unusedInternalDfns(doc: t.SpecT) -> None:

FILE: bikeshed/markdown/markdown.py
  class MarkdownConfig (line 13) | class MarkdownConfig:
    method fromSpec (line 19) | def fromSpec(doc: t.SpecT) -> MarkdownConfig:
  class TokenT (line 29) | class TokenT(t.TypedDict, total=False):
  class HeadingTokenT (line 35) | class HeadingTokenT(TokenT, total=False):
  class NumberedTokenT (line 39) | class NumberedTokenT(TokenT):
  class RawTokenT (line 42) | class RawTokenT(t.TypedDict, total=False):
  function parse (line 53) | def parse(
  function parse (line 59) | def parse(
  function parse (line 65) | def parse(
  function tokenizeLines (line 81) | def tokenizeLines(lines: list[l.Line], config: MarkdownConfig) -> list[T...
  function prefixCount (line 231) | def prefixCount(text: str, numSpacesForIndentation: int) -> int:
  function stripPrefix (line 246) | def stripPrefix(token: TokenT, numSpacesForIndentation: int, len: int) -...
  function lineEndsRawBlock (line 273) | def lineEndsRawBlock(line: l.Line, rawToken: RawTokenT) -> bool:
  function stripCommonWsPrefix (line 277) | def stripCommonWsPrefix(tokens: list[TokenT]) -> list[TokenT]:
  function commonPrefix (line 294) | def commonPrefix(line1: str | None, line2: str | None) -> str | None:
  function getWsPrefix (line 310) | def getWsPrefix(line: str) -> str | None:
  function parseTokens (line 320) | def parseTokens(tokens: list[TokenT], config: MarkdownConfig) -> list[l....
  function lineFromStream (line 377) | def lineFromStream(stream: TokenStream, text: str) -> l.Line:
  function startTag (line 385) | def startTag(tagName: str, lineNumber: int, attrs: dict[str, str] | None...
  function endTag (line 394) | def endTag(tagName: str) -> str:
  function parseSingleLineHeading (line 404) | def parseSingleLineHeading(stream: TokenStream) -> list[l.Line]:
  function parseMultiLineHeading (line 416) | def parseMultiLineHeading(stream: TokenStream) -> list[l.Line]:
  function parseHorizontalRule (line 441) | def parseHorizontalRule(stream: TokenStream) -> list[l.Line]:
  function parseParagraph (line 447) | def parseParagraph(stream: TokenStream) -> list[l.Line]:
  function parseBulleted (line 485) | def parseBulleted(stream: TokenStream) -> list[l.Line]:
  function parseNumbered (line 536) | def parseNumbered(stream: TokenStream, start: int = 1) -> list[l.Line]:
  function parseDl (line 590) | def parseDl(stream: TokenStream) -> list[l.Line]:
  function parseBlockquote (line 649) | def parseBlockquote(stream: TokenStream) -> list[l.Line]:
  class TokenStream (line 664) | class TokenStream:
    method __init__ (line 665) | def __init__(
    method __len__ (line 686) | def __len__(self) -> int:
    method ended (line 689) | def ended(self) -> bool:
    method nth (line 692) | def nth(self, i: int) -> TokenT:
    method prev (line 700) | def prev(self, i: int = 1) -> TokenT:
    method curr (line 703) | def curr(self) -> TokenT:
    method next (line 706) | def next(self, i: int = 1) -> TokenT:
    method advance (line 709) | def advance(self, i: int = 1) -> TokenT:
    method __getattr__ (line 715) | def __getattr__(self, name: str) -> t.Any:

FILE: bikeshed/mdn/mdnspeclinks.py
  class MdnFeatureT (line 12) | class MdnFeatureT(t.TypedDict, total=False):
  function addMdnPanels (line 25) | def addMdnPanels(doc: t.SpecT) -> list[t.ElementT]:
  function createAnno (line 56) | def createAnno(className: str, mdnButton: t.ElementT, featureDivs: list[...
  function panelsFromData (line 60) | def panelsFromData(doc: t.SpecT, data: MdnDataT) -> list[t.ElementT]:
  function addSupportRow (line 163) | def addSupportRow(
  function mdnPanelFor (line 242) | def mdnPanelFor(
  function browserCompatSpan (line 289) | def browserCompatSpan(

FILE: bikeshed/messages.py
  class MessageOptions (line 39) | class MessageOptions:
    method die (line 44) | def die(self) -> None:
    method linkerror (line 47) | def linkerror(self) -> None:
    method lint (line 50) | def lint(self) -> None:
    method warn (line 53) | def warn(self) -> None:
  class MessagesState (line 58) | class MessagesState:
    method __post_init__ (line 74) | def __post_init__(self) -> None:
    method record (line 78) | def record(self, category: str, message: str | tuple[str, str]) -> None:
    method replace (line 82) | def replace(self, **kwargs: t.Any) -> MessagesState:
    method shouldDie (line 85) | def shouldDie(self, category: str, timing: str = "early") -> bool:
    method shouldPrint (line 94) | def shouldPrint(self, category: str) -> bool:
    method categoryName (line 104) | def categoryName(categoryNum: int) -> str:
  function wrappedOutput (line 114) | def wrappedOutput() -> bool:
  function p (line 118) | def p(msg: str | tuple[str, str]) -> None:
  function getLineNum (line 141) | def getLineNum(lineNum: str | int | t.ElementT | None = None, el: t.Elem...
  function getApproxLineNumber (line 159) | def getApproxLineNumber(el: t.ElementT) -> str | None:
  function printOpener (line 175) | def printOpener() -> None:
  function printCloser (line 184) | def printCloser() -> None:
  function die (line 205) | def die(msg: str, el: t.ElementT | None = None, lineNum: str | int | Non...
  function linkerror (line 216) | def linkerror(msg: str, el: t.ElementT | None = None, lineNum: str | int...
  function lint (line 233) | def lint(msg: str, el: t.ElementT | None = None, lineNum: str | int | No...
  function warn (line 250) | def warn(msg: str, el: t.ElementT | None = None, lineNum: str | int | No...
  function say (line 261) | def say(msg: str) -> None:
  function success (line 266) | def success(msg: str) -> None:
  function failure (line 274) | def failure(msg: str) -> None:
  function retroactivelyCheckErrorLevel (line 282) | def retroactivelyCheckErrorLevel(level: str | None = None, timing: str =...
  function printColor (line 291) | def printColor(text: str, color: str = "white", *styles: str) -> str:
  function formatMessage (line 330) | def formatMessage(type: str, text: str, lineNum: str | None = None) -> s...
  function errorAndExit (line 386) | def errorAndExit() -> None:
  function withMessageState (line 392) | def withMessageState(
  function messagesSilent (line 414) | def messagesSilent() -> t.Generator[t.TextIO, None, None]:

FILE: bikeshed/metadata.py
  class DurationT (line 23) | class DurationT:
  class LinkCheckerTimeout (line 28) | class LinkCheckerTimeout:
  class MetadataManager (line 33) | class MetadataManager:
    method vshortname (line 35) | def vshortname(self) -> str | None:
    method displayVshortname (line 41) | def displayVshortname(self) -> str | None:
    method __init__ (line 46) | def __init__(self) -> None:
    method addData (line 168) | def addData(self, key: str, val: str, lineNum: str | int | None = None...
    method addParsedData (line 196) | def addParsedData(self, key: str, val: t.Any) -> MetadataManager:
    method computeImplicitMetadata (line 203) | def computeImplicitMetadata(self, doc: t.SpecT) -> None:
    method validate (line 233) | def validate(self, doc: t.SpecT) -> bool:
    method fillTextMacros (line 278) | def fillTextMacros(self, macros: t.DefaultDict[str, str], doc: t.SpecT...
  function parsedTextFromRawLines (line 435) | def parsedTextFromRawLines(lines: list[str], doc: t.SpecT, indent: int, ...
  class ParseFunc (line 446) | class ParseFunc(t.Protocol):
    method __call__ (line 447) | def __call__(self, key: str, val: str, lineNum: str | int | None) -> t...
  function parseDate (line 450) | def parseDate(key: str, val: str, lineNum: str | int | None) -> date | N...
  function parseDateOrDuration (line 460) | def parseDateOrDuration(key: str, val: str, lineNum: str | int | None) -...
  function canonicalizeExpiryDate (line 477) | def canonicalizeExpiryDate(base: date, expires: timedelta | datetime | d...
  function parseLevel (line 492) | def parseLevel(key: str, val: str, lineNum: str | int | None) -> str:
  function parseInteger (line 499) | def parseInteger(key: str, val: str, lineNum: str | int | None) -> int:
  function parseBoolean (line 503) | def parseBoolean(key: str, val: str, lineNum: str | int | None) -> bool ...
  function parseSoftBoolean (line 510) | def parseSoftBoolean(key: str, val: str, lineNum: str | int | None) -> b...
  function boolish (line 520) | def boolish(val: str) -> bool | None:
  function parseWarning (line 528) | def parseWarning(key: str, val: str, lineNum: str | int | None) -> tuple...
  function parseEditor (line 561) | def parseEditor(key: str, val: str, lineNum: None | str | int) -> list[d...
  function parseCommaSeparated (line 640) | def parseCommaSeparated(key: str, val: str, lineNum: str | int | None) -...
  function parseIdList (line 644) | def parseIdList(key: str, val: str, lineNum: str | int | None) -> list[s...
  function parseLinkDefaults (line 648) | def parseLinkDefaults(key: str, val: str, lineNum: str | int | None) -> ...
  function parseBoilerplate (line 675) | def parseBoilerplate(key: str, val: str, lineNum: str | int | None) -> c...
  function parseBiblioDisplay (line 700) | def parseBiblioDisplay(key: str, val: str, lineNum: str | int | None) ->...
  function parseRefStatus (line 708) | def parseRefStatus(key: str, val: str, lineNum: str | int | None) -> str:
  function parseComplainAbout (line 719) | def parseComplainAbout(key: str, val: str, lineNum: str | int | None) ->...
  function parseExternalInfotrees (line 727) | def parseExternalInfotrees(key: str, val: str, lineNum: str | int | None...
  function parseBoolishList (line 737) | def parseBoolishList(
  function parseLinkedText (line 773) | def parseLinkedText(key: str, val: str, lineNum: str | int | None) -> li...
  function parseMarkupShorthands (line 783) | def parseMarkupShorthands(key: str, val: str, lineNum: str | int | None)...
  function parseInlineGithubIssues (line 835) | def parseInlineGithubIssues(key: str, val: str, lineNum: str | int | Non...
  function parseTextMacro (line 848) | def parseTextMacro(key: str, val: str, lineNum: str | int | None) -> lis...
  function parseWorkStatus (line 862) | def parseWorkStatus(key: str, val: str, lineNum: str | int | None) -> st...
  function parseRepository (line 883) | def parseRepository(key: str, val: str, lineNum: str | int | None) -> re...
  function parseTranslateIDs (line 906) | def parseTranslateIDs(key: str, val: str, lineNum: str | int | None) -> ...
  function parseTranslation (line 918) | def parseTranslation(key: str, val: str, lineNum: str | int | None) -> l...
  function parseAudience (line 951) | def parseAudience(key: str, val: str, lineNum: str | int | None) -> list...
  function parseEditorTerm (line 994) | def parseEditorTerm(key: str, val: str, lineNum: str | int | None) -> di...
  function parseMaxToCDepth (line 1005) | def parseMaxToCDepth(key: str, val: str, lineNum: str | int | None) -> i...
  function parseMetadataOrder (line 1025) | def parseMetadataOrder(key: str, val: str, lineNum: str | int | None) ->...
  function parseWptDisplay (line 1030) | def parseWptDisplay(key: str, val: str, lineNum: str | int | None) -> str:
  function parsePreviousVersion (line 1041) | def parsePreviousVersion(key: str, val: str, lineNum: str | int | None) ...
  function parseInlineTagCommand (line 1050) | def parseInlineTagCommand(key: str, val: str, lineNum: str | int | None)...
  function parseDieOn (line 1056) | def parseDieOn(key: str, val: str, lineNum: str | int | None) -> str:
  function parseDieWhen (line 1068) | def parseDieWhen(key: str, val: str, lineNum: str | int | None) -> str:
  function parseIgnoreMdnFailure (line 1080) | def parseIgnoreMdnFailure(key: str, val: str, lineNum: str | int | None)...
  function parseLinkCheckerTimeout (line 1086) | def parseLinkCheckerTimeout(key: str, val: str, lineNum: str | int | Non...
  function parse (line 1100) | def parse(lines: t.Sequence[Line]) -> tuple[list[Line], MetadataManager]:
  class IndentInfo (line 1168) | class IndentInfo:
    method tooShort (line 1175) | def tooShort(self) -> bool:
  function inferIndent (line 1179) | def inferIndent(lines: t.Sequence[Line]) -> IndentInfo:
  function spaceIndentFromLine (line 1229) | def spaceIndentFromLine(line: str) -> int:
  function fromCommandLine (line 1240) | def fromCommandLine(overrides: list[str]) -> MetadataManager:
  function fromJson (line 1259) | def fromJson(data: str, source: str) -> MetadataManager:
  function getSpecRepository (line 1284) | def getSpecRepository(doc: t.SpecT) -> repository.Repository | None:
  function parseDoc (line 1314) | def parseDoc(doc: t.SpecT) -> None:
  function join (line 1339) | def join(*sources: MetadataManager | None) -> MetadataManager:
  class Metadata (line 1357) | class Metadata:
  function joinValue (line 1370) | def joinValue(a: JoinA, b: JoinB) -> JoinB:
  function joinList (line 1374) | def joinList(a: t.Sequence[JoinA], b: t.Sequence[JoinB]) -> t.Sequence[J...
  function joinDict (line 1378) | def joinDict(a: t.Mapping[str, JoinA], b: t.Mapping[str, JoinB]) -> dict...
  function joinBoolSet (line 1385) | def joinBoolSet(a: config.BoolSet, b: config.BoolSet) -> config.BoolSet:
  function joinDdList (line 1392) | def joinDdList(
  function parseLiteral (line 1402) | def parseLiteral(key: str, val: str, lineNum: str | int | None) -> str:
  function parseLiteralOrNone (line 1406) | def parseLiteralOrNone(key: str, val: str, lineNum: str | int | None) ->...
  function parseLiteralCaseless (line 1412) | def parseLiteralCaseless(key: str, val: str, lineNum: str | int | None) ...
  function parseLiteralList (line 1416) | def parseLiteralList(key: str, val: str, lineNum: str | int | None) -> l...

FILE: bikeshed/outline.py
  class OutlineEntry (line 10) | class OutlineEntry:
  function printOutline (line 17) | def printOutline(doc: t.Spec) -> str:
  function generateOutline (line 35) | def generateOutline(doc: t.Spec) -> list[OutlineEntry]:
  function collectHeadings (line 54) | def collectHeadings(

FILE: bikeshed/printjson.py
  function printjson (line 7) | def printjson(x: t.Any, indent: str | int = 2, level: int = 0) -> str:
  function getjson (line 27) | def getjson(x: t.Any) -> t.Any:
  function printjsonobject (line 34) | def printjsonobject(x: t.Any, indent: str, level: int) -> str:
  function printjsonobjectarray (line 50) | def printjsonobjectarray(x: list[dict[str, t.Any]], indent: str, level: ...
  function printjsonsimplearray (line 61) | def printjsonsimplearray(x: list[t.Any], indent: str, level: int) -> str...
  function printjsonprimitive (line 72) | def printjsonprimitive(x: t.Any) -> str:

FILE: bikeshed/publish.py
  function publishEchidna (line 16) | def publishEchidna(
  function prepareTar (line 62) | def prepareTar(doc: t.SpecT, additionalDirectories: list[str] | None = N...

FILE: bikeshed/pyg.py
  class PrismStyle (line 24) | class PrismStyle(style.Style):

FILE: bikeshed/railroaddiagrams.py
  function escapeAttr (line 43) | def escapeAttr(val: Union[str, float]) -> str:
  function escapeHtml (line 49) | def escapeHtml(val: str) -> str:
  function determineGaps (line 53) | def determineGaps(outer: float, inner: float) -> Tuple[float, float]:
  function doubleenumerate (line 63) | def doubleenumerate(seq: Seq[T]) -> Generator[Tuple[int, int, T], None, ...
  function addDebug (line 69) | def addDebug(el: DiagramItem) -> None:
  class DiagramItem (line 75) | class DiagramItem:
    method __init__ (line 76) | def __init__(self, name: str, attrs: Opt[AttrsT] = None, text: Opt[Nod...
    method format (line 95) | def format(self, x: float, y: float, width: float) -> DiagramItem:
    method addTo (line 98) | def addTo(self, parent: DiagramItem) -> DiagramItem:
    method writeSvg (line 102) | def writeSvg(self, write: WriterF) -> None:
    method walk (line 116) | def walk(self, cb: WalkerF) -> None:
  class DiagramMultiContainer (line 120) | class DiagramMultiContainer(DiagramItem):
    method __init__ (line 121) | def __init__(
    method format (line 131) | def format(self, x: float, y: float, width: float) -> DiagramItem:
    method walk (line 134) | def walk(self, cb: WalkerF) -> None:
  class Path (line 140) | class Path:
    method __init__ (line 141) | def __init__(self, x: float, y: float) -> None:
    method m (line 146) | def m(self, x: float, y: float) -> Path:
    method l (line 150) | def l(self, x: float, y: float) -> Path:
    method h (line 154) | def h(self, val: float) -> Path:
    method right (line 158) | def right(self, val: float) -> Path:
    method left (line 161) | def left(self, val: float) -> Path:
    method v (line 164) | def v(self, val: float) -> Path:
    method down (line 168) | def down(self, val: float) -> Path:
    method up (line 171) | def up(self, val: float) -> Path:
    method arc_8 (line 174) | def arc_8(self, start: str, dir: str) -> Path:
    method arc (line 220) | def arc(self, sweep: str) -> Path:
    method addTo (line 231) | def addTo(self, parent: DiagramItem) -> Path:
    method writeSvg (line 235) | def writeSvg(self, write: WriterF) -> None:
    method format (line 241) | def format(self) -> Path:
    method __repr__ (line 245) | def __repr__(self) -> str:
  function wrapString (line 249) | def wrapString(value: Node) -> DiagramItem:
  class Style (line 285) | class Style:
    method __init__ (line 286) | def __init__(self, css: str) -> None:
    method __repr__ (line 289) | def __repr__(self) -> str:
    method addTo (line 292) | def addTo(self, parent: DiagramItem) -> Style:
    method format (line 296) | def format(self) -> Style:
    method writeSvg (line 299) | def writeSvg(self, write: WriterF) -> None:
  class Diagram (line 304) | class Diagram(DiagramMultiContainer):
    method __init__ (line 305) | def __init__(self, *items: Node, **kwargs: str) -> None:
    method __repr__ (line 337) | def __repr__(self) -> str:
    method format (line 344) | def format(
    method writeSvg (line 382) | def writeSvg(self, write: WriterF) -> None:
    method writeStandalone (line 387) | def writeStandalone(self, write: WriterF, css: str | None = None) -> N...
  class Sequence (line 401) | class Sequence(DiagramMultiContainer):
    method __init__ (line 402) | def __init__(self, *items: Node) -> None:
    method __repr__ (line 420) | def __repr__(self) -> str:
    method format (line 424) | def format(self, x: float, y: float, width: float) -> Sequence:
  class Stack (line 442) | class Stack(DiagramMultiContainer):
    method __init__ (line 443) | def __init__(self, *items: Node) -> None:
    method __repr__ (line 462) | def __repr__(self) -> str:
    method format (line 466) | def format(self, x: float, y: float, width: float) -> Stack:
  class OptionalSequence (line 502) | class OptionalSequence(DiagramMultiContainer):
    method __new__ (line 503) | def __new__(cls, *items: Node) -> Any:
    method __init__ (line 509) | def __init__(self, *items: Node) -> None:
    method __repr__ (line 535) | def __repr__(self) -> str:
    method format (line 539) | def format(self, x: float, y: float, width: float) -> OptionalSequence:
  class AlternatingSequence (line 615) | class AlternatingSequence(DiagramMultiContainer):
    method __new__ (line 616) | def __new__(cls, *items: Node) -> AlternatingSequence:
    method __init__ (line 623) | def __init__(self, *items: Node) -> None:
    method __repr__ (line 650) | def __repr__(self) -> str:
    method format (line 654) | def format(self, x: float, y: float, width: float) -> AlternatingSeque...
  class Choice (line 711) | class Choice(DiagramMultiContainer):
    method __init__ (line 712) | def __init__(self, default: int, *items: Node) -> None:
    method __repr__ (line 737) | def __repr__(self) -> str:
    method format (line 741) | def format(self, x: float, y: float, width: float) -> Choice:
  class MultipleChoice (line 787) | class MultipleChoice(DiagramMultiContainer):
    method __init__ (line 788) | def __init__(self, default: int, type: str, *items: Node) -> None:
    method __repr__ (line 817) | def __repr__(self) -> str:
    method format (line 821) | def format(self, x: float, y: float, width: float) -> MultipleChoice:
  class HorizontalChoice (line 908) | class HorizontalChoice(DiagramMultiContainer):
    method __new__ (line 909) | def __new__(cls, *items: Node) -> Any:
    method __init__ (line 915) | def __init__(self, *items: Node) -> None:
    method format (line 952) | def format(self, x: float, y: float, width: float) -> HorizontalChoice:
  function Optional (line 1025) | def Optional(item: Node, skip: bool = False) -> Choice:
  class OneOrMore (line 1029) | class OneOrMore(DiagramItem):
    method __init__ (line 1030) | def __init__(self, item: Node, repeat: Opt[Node] = None) -> None:
    method format (line 1042) | def format(self, x: float, y: float, width: float) -> OneOrMore:
    method walk (line 1065) | def walk(self, cb: WalkerF) -> None:
    method __repr__ (line 1070) | def __repr__(self) -> str:
  function ZeroOrMore (line 1074) | def ZeroOrMore(item: Node, repeat: Opt[Node] = None, skip: bool = False)...
  class Group (line 1079) | class Group(DiagramItem):
    method __init__ (line 1080) | def __init__(self, item: Node, label: Opt[Node] = None) -> None:
    method format (line 1105) | def format(self, x: float, y: float, width: float) -> Group:
    method walk (line 1134) | def walk(self, cb: WalkerF) -> None:
  class Start (line 1141) | class Start(DiagramItem):
    method __init__ (line 1142) | def __init__(self, type: str = "simple", label: Opt[str] = None) -> None:
    method format (line 1154) | def format(self, x: float, y: float, width: float) -> Start:
    method __repr__ (line 1168) | def __repr__(self) -> str:
  class End (line 1172) | class End(DiagramItem):
    method __init__ (line 1173) | def __init__(self, type: str = "simple") -> None:
    method format (line 1181) | def format(self, x: float, y: float, width: float) -> End:
    method __repr__ (line 1188) | def __repr__(self) -> str:
  class Terminal (line 1192) | class Terminal(DiagramItem):
    method __init__ (line 1193) | def __init__(self, text: str, href: Opt[str] = None, title: Opt[str] =...
    method __repr__ (line 1205) | def __repr__(self) -> str:
    method format (line 1208) | def format(self, x: float, y: float, width: float) -> Terminal:
  class NonTerminal (line 1237) | class NonTerminal(DiagramItem):
    method __init__ (line 1238) | def __init__(self, text: str, href: Opt[str] = None, title: Opt[str] =...
    method __repr__ (line 1250) | def __repr__(self) -> str:
    method format (line 1253) | def format(self, x: float, y: float, width: float) -> NonTerminal:
  class Comment (line 1280) | class Comment(DiagramItem):
    method __init__ (line 1281) | def __init__(self, text: str, href: Opt[str] = None, title: Opt[str] =...
    method __repr__ (line 1293) | def __repr__(self) -> str:
    method format (line 1296) | def format(self, x: float, y: float, width: float) -> Comment:
  class Skip (line 1318) | class Skip(DiagramItem):
    method __init__ (line 1319) | def __init__(self) -> None:
    method format (line 1326) | def format(self, x: float, y: float, width: float) -> Skip:
    method __repr__ (line 1330) | def __repr__(self) -> str:

FILE: bikeshed/railroadparser.py
  function parse (line 11) | def parse(string: str) -> rr.Diagram | None:
  class RRCommand (line 103) | class RRCommand:
  function _createDiagram (line 111) | def _createDiagram(command: RRCommand) -> rr.DiagramItem | None:

FILE: bikeshed/refs/external.py
  class ExternalRefsManager (line 9) | class ExternalRefsManager:
    method addRef (line 12) | def addRef(self, specName: str, ref: t.RefWrapper, for_: str | None) -...
    method hasRefs (line 17) | def hasRefs(self) -> bool:
    method addBiblio (line 20) | def addBiblio(self, specName: str, biblio: t.BiblioEntry) -> None:
    method sorted (line 25) | def sorted(self) -> t.Iterable[tuple[str, ExternalRefsSpec]]:
  class ExternalRefsSpec (line 33) | class ExternalRefsSpec:
    method addRef (line 37) | def addRef(self, ref: t.RefWrapper, for_: str | None) -> None:
    method sorted (line 42) | def sorted(self) -> t.Iterable[tuple[str, ExternalRefsGroup]]:
  class ExternalRefsGroup (line 47) | class ExternalRefsGroup:
    method __len__ (line 50) | def __len__(self) -> int:
    method single (line 53) | def single(self) -> t.RefWrapper:
    method sorted (line 60) | def sorted(self) -> t.Generator[tuple[str | None, t.RefWrapper], None,...

FILE: bikeshed/refs/headingdata.py
  class SpecHeadings (line 23) | class SpecHeadings:
    method __init__ (line 24) | def __init__(self, spec: str, data: dict[str, list[str] | dict[str, di...
    method get (line 28) | def get(self, id: str, status: str, el: t.ElementT | None = None) -> d...

FILE: bikeshed/refs/manager.py
  class ReferenceManager (line 20) | class ReferenceManager:
    method __init__ (line 43) | def __init__(
    method initializeRefs (line 107) | def initializeRefs(self, datablocks: t.ModuleType, doc: t.SpecT | None...
    method fetchHeadings (line 184) | def fetchHeadings(self, spec: str) -> headingdata.SpecHeadings:
    method fetchHeading (line 197) | def fetchHeading(
    method initializeBiblio (line 209) | def initializeBiblio(self, doc: t.SpecT) -> None:
    method setSpecData (line 242) | def setSpecData(self, doc: t.SpecT) -> None:
    method removeSameSpecRefs (line 262) | def removeSameSpecRefs(self) -> None:
    method addLocalDfns (line 271) | def addLocalDfns(self, doc: t.SpecT, dfns: t.Iterable[t.ElementT]) -> ...
    method filterObsoletes (line 356) | def filterObsoletes(self, refs: list[RefWrapper]) -> list[RefWrapper]:
    method queryAllRefs (line 365) | def queryAllRefs(self, **kwargs: t.Any) -> list[RefWrapper]:
    method getRef (line 374) | def getRef(
    method getBiblioRef (line 669) | def getBiblioRef(
    method bibliosFromKey (line 771) | def bibliosFromKey(self, key: str) -> list[biblio.BiblioEntry]:
    method _bestCandidateBiblio (line 785) | def _bestCandidateBiblio(self, candidates: list[biblio.BiblioEntry]) -...
    method getLatestBiblioRef (line 788) | def getLatestBiblioRef(self, key: str) -> biblio.BiblioEntry | None:
    method vNamesFromSpecNames (line 811) | def vNamesFromSpecNames(self, specName: str) -> list[str]:
  function simplifyPossibleRefs (line 826) | def simplifyPossibleRefs(refs: list[RefWrapper], alwaysShowFor: bool = F...
  class SimplifiedRef (line 857) | class SimplifiedRef:
  function refToText (line 865) | def refToText(ref: SimplifiedRef) -> str:
  function reportMultiplePossibleRefs (line 872) | def reportMultiplePossibleRefs(
  function reportAmbiguousForlessLink (line 911) | def reportAmbiguousForlessLink(
  function errorFromFailureCategory (line 927) | def errorFromFailureCategory(

FILE: bikeshed/refs/ref-hints.js
  function mkRefHint (line 1) | function mkRefHint(link, ref) {
  function hideAllRefHints (line 64) | function hideAllRefHints() {
  function hideRefHint (line 68) | function hideRefHint(refHint) {
  function showRefHint (line 77) | function showRefHint(link) {
  function setupRefHintEventListeners (line 96) | function setupRefHintEventListeners(link, refHint) {
  function positionRefHint (line 136) | function positionRefHint(refHint) {
  function getBounds (line 154) | function getBounds(el, relativeTo=document.body) {
  function showRefHintListener (line 167) | function showRefHintListener(e) {
  function hideAllHintsListener (line 182) | function hideAllHintsListener(e) {

FILE: bikeshed/refs/source.py
  class RefSource (line 16) | class RefSource:
    method __init__ (line 31) | def __init__(
    method fetchRefs (line 61) | def fetchRefs(self, key: str) -> list[t.RefWrapper]:
    method fetchAllRefs (line 80) | def fetchAllRefs(self) -> list[tuple[str, list[t.RefWrapper]]]:
    method queryRefs (line 100) | def queryRefs(
    method allRefsIterator (line 176) | def allRefsIterator(self) -> t.Generator[t.RefWrapper, None, None]:
    method textRefsIterator (line 181) | def textRefsIterator(self, texts: list[str]) -> t.Generator[t.RefWrapp...
    method forRefsIterator (line 186) | def forRefsIterator(self, targetFors: str | list[str]) -> t.Generator[...
    method _queryRefs (line 194) | def _queryRefs(
    method addMethodVariants (line 338) | def addMethodVariants(self, methodSig: str, forVals: t.Iterable[str], ...
  function filterByFor (line 356) | def filterByFor(refs: t.Sequence[t.RefWrapper], linkFor: str | list[str]...
  function matchFor (line 360) | def matchFor(forVals: list[str], forTest: str | list[str]) -> bool:
  function filterByStatus (line 370) | def filterByStatus(source: RefSource, refs: t.Sequence[t.RefWrapper], st...
  function decodeAnchors (line 396) | def decodeAnchors(linesIter: t.Iterator[str]) -> defaultdict[str, list[t...
  function getArgfulMethodVariants (line 424) | def getArgfulMethodVariants(maybeMethodSig: str, refs: RefSource) -> lis...
  class MethodVariants (line 431) | class MethodVariants:
  class MethodVariant (line 437) | class MethodVariant:

FILE: bikeshed/refs/utils.py
  function filterObsoletes (line 9) | def filterObsoletes(
  function filterOldVersions (line 36) | def filterOldVersions(refs: list[t.RefWrapper], status: str | None = Non...
  function linkTextVariations (line 62) | def linkTextVariations(str: str, linkType: str | None) -> t.Generator[st...
  function stripLineBreaks (line 196) | def stripLineBreaks(obj: U) -> U:
  class LinkFailure (line 206) | class LinkFailure(Enum):

FILE: bikeshed/refs/wrapper.py
  class RefDataT (line 8) | class RefDataT(t.TypedDict, total=False):
  class RefWrapper (line 23) | class RefWrapper:
    method type (line 33) | def type(self) -> str:
    method spec (line 37) | def spec(self) -> str:
    method shortname (line 43) | def shortname(self) -> str:
    method level (line 49) | def level(self) -> str:
    method status (line 55) | def status(self) -> str:
    method url (line 61) | def url(self) -> str:
    method export (line 67) | def export(self) -> bool:
    method normative (line 71) | def normative(self) -> bool:
    method for_ (line 75) | def for_(self) -> list[str]:
    method el (line 79) | def el(self) -> t.ElementT | None:
    method uniquifier (line 83) | def uniquifier(self) -> str | None:
    method refKey (line 86) | def refKey(self) -> str:
    method __eq__ (line 89) | def __eq__(self, other: t.Any) -> bool:
    method __hash__ (line 94) | def __hash__(self) -> int:
    method __json__ (line 97) | def __json__(self) -> dict[str, bool | str | list[str]]:

FILE: bikeshed/repository.py
  class Repository (line 8) | class Repository(metaclass=abc.ABCMeta):
  class UnknownRepository (line 18) | class UnknownRepository(Repository):
    method formatIssueUrl (line 19) | def formatIssueUrl(self) -> str:  # pylint: disable=unused-argument
  class GithubRepository (line 25) | class GithubRepository(Repository):
    method __init__ (line 26) | def __init__(self, ns: str, user: str, repo: str) -> None:
    method formatIssueUrl (line 40) | def formatIssueUrl(self, id: str | None = None) -> str:
    method __str__ (line 45) | def __str__(self) -> str:

FILE: bikeshed/result/main.py
  function isOk (line 8) | def isOk[ValT](x: t.Any) -> t.TypeIs[Ok[ValT]]:
  function isErr (line 12) | def isErr[ErrT](x: t.Any) -> t.TypeIs[Err[ErrT]]:

FILE: bikeshed/retrieve.py
  class DataFileRequester (line 15) | class DataFileRequester:
    method __init__ (line 16) | def __init__(self, fileType: str | None = None, fallback: DataFileRequ...
    method path (line 24) | def path(self, *segs: str, fileType: str | None = None) -> str:
    method fetch (line 28) | def fetch(self, *segs: str, str: t.Literal[True], okayToFail: bool = F...
    method fetch (line 31) | def fetch(
    method fetch (line 40) | def fetch(self, *segs: str, okayToFail: bool = False, fileType: str | ...
    method fetch (line 42) | def fetch(
    method walkFiles (line 70) | def walkFiles(self, *segs: str, fileType: str | None = None) -> t.Gene...
    method _buildPath (line 74) | def _buildPath(self, segs: t.Sequence[str], fileType: str | None = Non...
    method _fail (line 83) | def _fail(self, location: str, str: t.Literal[True], okayToFail: bool)...
    method _fail (line 86) | def _fail(self, location: str, str: t.Literal[False], okayToFail: bool...
    method _fail (line 89) | def _fail(self, location: str, str: bool, okayToFail: bool) -> str | t...
    method _fail (line 91) | def _fail(self, location: str, str: bool, okayToFail: bool) -> str | t...
  function retrieveBoilerplateFile (line 104) | def retrieveBoilerplateFile(

FILE: bikeshed/shorthands/__init__.py
  function run (line 7) | def run(doc: t.SpecT) -> None:

FILE: bikeshed/shorthands/oldShorthands.py
  function transformMarkdownIB (line 8) | def transformMarkdownIB(doc: t.SpecT) -> None:
  function transformProductionGrammars (line 47) | def transformProductionGrammars(doc: t.SpecT) -> None:
  function strongReplacer (line 123) | def strongReplacer(match: t.Match) -> t.NodeT:
  function emReplacer (line 141) | def emReplacer(match: t.Match) -> t.NodeT:
  function escapedReplacer (line 149) | def escapedReplacer(match: t.Match) -> t.NodeT:  # pylint: disable=unuse...
  function addLineNumber (line 164) | def addLineNumber(el: t.ElementT) -> None:

FILE: bikeshed/stringEnum/stringenum.py
  class StringEnum (line 6) | class StringEnum:
    method __init__ (line 15) | def __init__(self, *vals: str) -> None:
    method __iter__ (line 21) | def __iter__(self) -> t.Iterator[str]:
    method __len__ (line 24) | def __len__(self) -> int:
    method __contains__ (line 27) | def __contains__(self, val: str) -> bool:
    method __getitem__ (line 30) | def __getitem__(self, val: str) -> str:
    method __getattr__ (line 33) | def __getattr__(self, name: str) -> str:

FILE: bikeshed/stylescript/dom-helper.js
  function query (line 1) | function query(sel) { return document.querySelector(sel); }
  function queryAll (line 3) | function queryAll(sel) { return [...document.querySelectorAll(sel)]; }
  function iter (line 5) | function iter(obj) {
  function mk (line 12) | function mk(tagname, attrs, ...children) {
  function append (line 164) | function append(el, ...children) {
  function insertAfter (line 172) | function insertAfter(el, ...children) {
  function clearContents (line 179) | function clearContents(el) {
  function parseHTML (line 184) | function parseHTML(markup) {

FILE: bikeshed/stylescript/link-titles.js
  function setTypeTitles (line 1) | function setTypeTitles() {

FILE: bikeshed/stylescript/manager.py
  class JCManager (line 14) | class JCManager:
    method getStyles (line 18) | def getStyles(self, allowList: t.BoolSet) -> list[Style]:
    method getScripts (line 31) | def getScripts(self, allowList: t.BoolSet) -> list[Library | Script]:
    method _addCSS (line 49) | def _addCSS(self, name: str, moduleName: str = "stylescript") -> Style:
    method _addJS (line 54) | def _addJS(self, name: str, moduleName: str = "stylescript") -> Script:
    method addColors (line 59) | def addColors(self) -> None:
    method addMdLists (line 62) | def addMdLists(self) -> None:
    method addAutolinks (line 65) | def addAutolinks(self) -> None:
    method addSelflinks (line 68) | def addSelflinks(self) -> None:
    method addCounters (line 71) | def addCounters(self) -> None:
    method addIssues (line 74) | def addIssues(self) -> None:
    method addMdn (line 77) | def addMdn(self) -> None:
    method addCiu (line 82) | def addCiu(self) -> None:
    method addDomintro (line 87) | def addDomintro(self) -> None:
    method addSyntaxHighlighting (line 90) | def addSyntaxHighlighting(self) -> None:
    method addLineNumbers (line 93) | def addLineNumbers(self) -> None:
    method addLineHighlighting (line 96) | def addLineHighlighting(self) -> None:
    method addExpires (line 99) | def addExpires(self) -> None:
    method addHidedel (line 102) | def addHidedel(self) -> None:
    method addVarClickHighlighting (line 105) | def addVarClickHighlighting(self) -> None:
    method addRefHints (line 113) | def addRefHints(self) -> dict[str, t.Any]:
    method addLinkTitles (line 123) | def addLinkTitles(self) -> dict[str, t.Any]:
    method addCDDLHighlighting (line 129) | def addCDDLHighlighting(self) -> None:
    method addIDLHighlighting (line 132) | def addIDLHighlighting(self) -> None:
    method addRailroad (line 135) | def addRailroad(self) -> None:
    method addWptCSS (line 138) | def addWptCSS(self) -> None:
    method addWpt (line 141) | def addWpt(self, paths: list[str] | None) -> None:
    method addDfnPanels (line 152) | def addDfnPanels(self) -> dict[str, t.Any]:
  class JCResource (line 164) | class JCResource(metaclass=ABCMeta):
    method insertable (line 168) | def insertable(self, allowList: t.BoolSet) -> bool:
    method toElement (line 172) | def toElement(self) -> t.ElementT:
  class Script (line 177) | class Script(JCResource):
    method insertable (line 183) | def insertable(self, allowList: t.BoolSet) -> bool:
    method toElement (line 192) | def toElement(self) -> t.ElementT:
  class Library (line 212) | class Library(JCResource):
    method insertable (line 215) | def insertable(self, allowList: t.BoolSet) -> bool:
    method toElement (line 218) | def toElement(self) -> t.ElementT:
  class Style (line 225) | class Style(JCResource):
    method insertable (line 229) | def insertable(self, allowList: t.BoolSet) -> bool:
    method toElement (line 232) | def toElement(self, darkMode: bool = True) -> t.ElementT:
  function removeInlineDarkStyles (line 253) | def removeInlineDarkStyles(name: str, text: str) -> str:

FILE: bikeshed/stylescript/position-annos.js
  function repositionAnnoPanels (line 1) | function repositionAnnoPanels(){
  function hydratePanels (line 13) | function hydratePanels(panels) {
  function cmpTops (line 47) | function cmpTops(a,b) {

FILE: bikeshed/stylescript/var-click-highlighting.js
  constant COLOR_COUNT (line 11) | const COLOR_COUNT = 7;
  function highlightSameAlgoVars (line 19) | function highlightSameAlgoVars(v) {
  function findAlgoContainer (line 44) | function findAlgoContainer(el) {
  function nameFromVar (line 51) | function nameFromVar(el) {
  function colorCountsFromContainer (line 54) | function colorCountsFromContainer(container) {
  function leastUsedColor (line 63) | function leastUsedColor(colors) {
  function chooseHighlightColor (line 75) | function chooseHighlightColor(container, v) {

FILE: bikeshed/template/main.py
  function getTemplate (line 7) | def getTemplate(variant: str) -> str | None:

FILE: bikeshed/test.py
  class TestFilter (line 23) | class TestFilter:
    method fromOptions (line 29) | def fromOptions(options: argparse.Namespace) -> TestFilter:
  function testPaths (line 33) | def testPaths(filters: TestFilter) -> list[str]:
  function findTestFiles (line 38) | def findTestFiles(filters: TestFilter) -> t.Generator[str, None, None]:
  function allowedPath (line 48) | def allowedPath(filePath: str, filters: TestFilter) -> bool:
  function splitPath (line 74) | def splitPath(path: str) -> list[str]:
  function testNameForPath (line 83) | def testNameForPath(path: str) -> str:
  function sortTests (line 89) | def sortTests(tests: t.Iterable[str]) -> t.Iterable[str]:
  function run (line 93) | def run(
  function rebase (line 144) | def rebase(
  function processTest (line 167) | def processTest(
  function compare (line 186) | def compare(suspect: str, golden: str, path: str) -> bool:
  function addTestMetadata (line 201) | def addTestMetadata(doc: t.SpecT) -> None:
  function replaceExtension (line 213) | def replaceExtension(path: str, newExt: str) -> str:

FILE: bikeshed/translate/translate.py
  function _t (line 4) | def _t(input: str) -> str:

FILE: bikeshed/unsortedJunk.py
  function stripBOM (line 27) | def stripBOM(doc: t.SpecT) -> None:
  function fixManualDefTables (line 36) | def fixManualDefTables(doc: t.SpecT) -> None:
  function canonicalizeShortcuts (line 60) | def canonicalizeShortcuts(el: t.ElementT) -> None:
  function addImplicitAlgorithms (line 124) | def addImplicitAlgorithms(doc: t.SpecT) -> None:
  function checkVarHygiene (line 148) | def checkVarHygiene(doc: t.SpecT) -> None:
  function addVarClickHighlighting (line 208) | def addVarClickHighlighting(doc: t.SpecT) -> None:
  function fixIntraDocumentReferences (line 214) | def fixIntraDocumentReferences(doc: t.SpecT) -> None:
  function fixInterDocumentReferences (line 242) | def fixInterDocumentReferences(doc: t.SpecT) -> None:
  function fillInterDocumentReferenceFromShepherd (line 286) | def fillInterDocumentReferenceFromShepherd(doc: t.SpecT, el: t.ElementT,...
  function fillInterDocumentReferenceFromSpecref (line 309) | def fillInterDocumentReferenceFromSpecref(doc: t.SpecT, el: t.ElementT, ...
  function processDfns (line 333) | def processDfns(doc: t.SpecT) -> None:
  function determineDfnType (line 340) | def determineDfnType(doc: t.SpecT, dfn: t.ElementT, inferCSS: bool = Fal...
  function classifyDfns (line 407) | def classifyDfns(doc: t.SpecT, dfns: list[t.ElementT]) -> None:
  function determineLinkType (line 567) | def determineLinkType(el: t.ElementT) -> str:
  function determineLinkText (line 588) | def determineLinkText(el: t.ElementT) -> str:
  function classifyLink (line 606) | def classifyLink(el: t.ElementT) -> t.ElementT:
  function processBiblioLinks (line 628) | def processBiblioLinks(doc: t.SpecT) -> None:
  function verifyUsageOfAllLocalBiblios (line 700) | def verifyUsageOfAllLocalBiblios(doc: t.SpecT) -> None:
  function processAutolinks (line 721) | def processAutolinks(doc: t.SpecT) -> None:
  function registerBiblioUsage (line 839) | def registerBiblioUsage(doc: t.SpecT, ref: biblio.BiblioEntry, el: t.Ele...
  function decorateAutolink (line 857) | def decorateAutolink(doc: t.SpecT, el: t.ElementT, linkType: str, linkTe...
  function removeMultipleLinks (line 888) | def removeMultipleLinks(doc: t.SpecT) -> None:
  function processIssuesAndExamples (line 912) | def processIssuesAndExamples(doc: t.SpecT) -> None:
  function addSelfLinks (line 969) | def addSelfLinks(doc: t.SpecT) -> None:
  function cleanupHTML (line 1008) | def cleanupHTML(doc: t.SpecT) -> None:
  function finalHackyCleanup (line 1239) | def finalHackyCleanup(text: str) -> str:
  function hackyLineNumbers (line 1245) | def hackyLineNumbers(lines: list[Line]) -> list[Line]:
  function correctFrontMatter (line 1257) | def correctFrontMatter(doc: t.SpecT) -> None:
  function formatElementdefTables (line 1266) | def formatElementdefTables(doc: t.SpecT) -> None:
  function formatArgumentdefTables (line 1306) | def formatArgumentdefTables(doc: t.SpecT) -> None:
  function inlineRemoteIssues (line 1343) | def inlineRemoteIssues(doc: t.SpecT) -> None:
  function addNoteHeaders (line 1479) | def addNoteHeaders(doc: t.SpecT) -> None:
  function lineNumberFromBsLineNumber (line 1498) | def lineNumberFromBsLineNumber(value: str | None) -> int:
  function locateFillContainers (line 1514) | def locateFillContainers(doc: t.SpecT) -> t.FillContainersT:
  function forceCrossorigin (line 1521) | def forceCrossorigin(doc: t.SpecT) -> None:
  function addImageSize (line 1530) | def addImageSize(doc: t.SpecT) -> None:
  function processIDL (line 1614) | def processIDL(doc: t.SpecT) -> None:
  function processCDDL (line 1630) | def processCDDL(doc: t.SpecT) -> None:

FILE: bikeshed/update/main.py
  function update (line 25) | def update(
  function fixupDataFiles (line 78) | def fixupDataFiles(updateMode: UpdateMode = UpdateMode.NONE) -> None:
  function updateReadonlyDataFiles (line 129) | def updateReadonlyDataFiles() -> None:
  function cleanupFiles (line 146) | def cleanupFiles(root: str, touchedPaths: dict[str, set[str] | None], dr...
  function copyanything (line 190) | def copyanything(src: str, dst: str) -> None:
  function livePath (line 201) | def livePath(*segs: str) -> str:
  function readonlyPath (line 205) | def readonlyPath(*segs: str) -> str:
  function getDatafilePaths (line 209) | def getDatafilePaths(basePath: str) -> t.Generator[tuple[str, str], None...
  function probablyHaveInternet (line 216) | def probablyHaveInternet() -> bool:

FILE: bikeshed/update/manifest.py
  function dtNow (line 47) | def dtNow() -> datetime:
  function dtZero (line 51) | def dtZero() -> datetime:
  function createManifest (line 66) | def createManifest(path: str, dryRun: bool = False) -> Manifest:
  function updateByManifest (line 74) | def updateByManifest(path: str, dryRun: bool = False, updateMode: Update...
  function updateFiles (line 186) | async def updateFiles(localPrefix: str, newPaths: list[str]) -> tuple[li...
  function updateFile (line 213) | async def updateFile(localPrefix: str, filePath: str, session: t.Any) ->...
  function errorFromAsyncErr (line 229) | async def errorFromAsyncErr(res: Result[str, t.Awaitable[str]]) -> str |...
  function wrapError (line 239) | def wrapError(retry_state: t.Any) -> Err[t.Awaitable[str]]:
  function downloadFile (line 249) | async def downloadFile(path: str, session: t.Any) -> Result[str, t.Await...
  function saveFile (line 261) | async def saveFile(path: str, data: str) -> Result[str, t.Awaitable[str]]:
  function localizePath (line 270) | def localizePath(root: str, relPath: str) -> str:
  class Manifest (line 280) | class Manifest:
    method fromString (line 287) | def fromString(text: str) -> Manifest | None:
    method legacyFromString (line 297) | def legacyFromString(text: str) -> Manifest | None:
    method fromPath (line 328) | def fromPath(path: str) -> Manifest:
    method __str__ (line 341) | def __str__(self) -> str:
    method daysOld (line 359) | def daysOld(self) -> int:
    method save (line 362) | def save(self, path: str) -> None:
    method hasError (line 366) | def hasError(self) -> bool:
  function keyManifest (line 370) | def keyManifest(entry: tuple[str, t.Any]) -> tuple[int, int | str, str]:
  function hashFile (line 379) | def hashFile(fh: t.TextIO) -> str:
  function getDatafilePaths (line 383) | def getDatafilePaths(basePath: str) -> t.Generator[tuple[str, str], None...
  function printDt (line 394) | def printDt(dt: datetime) -> str:
  function formatDt (line 398) | def formatDt(dt: datetime) -> str:
  function parseDt (line 402) | def parseDt(s: str) -> datetime | None:
  function trystrptime (line 409) | def trystrptime(s: str, format: str) -> datetime | None:

FILE: bikeshed/update/mode.py
  class UpdateMode (line 4) | class UpdateMode(enum.Flag):

FILE: bikeshed/update/updateBackRefs.py
  function findTestFiles (line 10) | def findTestFiles() -> t.Generator[str, None, None]:
  function testNameForPath (line 17) | def testNameForPath(path: str) -> str:
  function update (line 23) | def update(path: str, dryRun: bool = False) -> set[str] | None:  # pylin...
  function processRefs (line 58) | def processRefs(refs: t.Any) -> t.Any:

FILE: bikeshed/update/updateBiblio.py
  function update (line 14) | def update(path: str, dryRun: bool = False) -> set[str] | None:
  function getSpecrefData (line 93) | def getSpecrefData() -> str:
  function getWG21Data (line 101) | def getWG21Data() -> str:
  function getCSSWGData (line 109) | def getCSSWGData() -> list[str]:
  function groupBiblios (line 120) | def groupBiblios(biblios: t.BiblioStorageT) -> tuple[dict[str, t.BiblioS...
  function writeBiblioFile (line 133) | def writeBiblioFile(fh: t.TextIO, biblios: t.BiblioStorageT) -> None:
  function collectNumberedNames (line 183) | def collectNumberedNames(names: t.Sequence[str]) -> defaultdict[str, lis...

FILE: bikeshed/update/updateBoilerplates.py
  function update (line 19) | def update(path: str, dryRun: bool = False) -> set[str] | None:
  function pathsFromManifest (line 47) | def pathsFromManifest(manifest: str) -> list[str]:
  function updateFiles (line 52) | async def updateFiles(localPrefix: str, newPaths: t.Sequence[str]) -> tu...
  function updateFile (line 79) | async def updateFile(localPrefix: str, filePath: str, session: t.Any) ->...
  function errorFromAsyncErr (line 95) | async def errorFromAsyncErr(res: Result[str, t.Awaitable[str]]) -> str |...
  function wrapError (line 105) | def wrapError(retry_state: t.Any) -> Err[t.Awaitable[str]]:
  function downloadFile (line 115) | async def downloadFile(path: str, session: t.Any) -> Result[str, t.Await...
  function saveFile (line 127) | async def saveFile(path: str, data: str) -> Result[str, t.Awaitable[str]]:
  function localizePath (line 136) | def localizePath(root: str, relPath: str) -> str:

FILE: bikeshed/update/updateCanIUse.py
  function update (line 12) | def update(path: str, dryRun: bool = False) -> set[str] | None:

FILE: bikeshed/update/updateCrossRefs.py
  class WebrefHeadingT (line 27) | class WebrefHeadingT(t.TypedDict, total=False):
  class HeadingT (line 35) | class HeadingT(t.TypedDict):
  class WebrefSpecT (line 70) | class WebrefSpecT(t.TypedDict, total=False):
  class SpecT (line 87) | class SpecT(t.TypedDict):
  function update (line 98) | def update(path: str, dryRun: bool = False) -> set[str] | None:
  function gatherWebrefData (line 153) | def gatherWebrefData(specs: SpecsT, anchors: AnchorsT, headings: AllHead...
  function specsFromWebref (line 203) | def specsFromWebref(status: t.Literal["current" | "snapshot"]) -> list[W...
  function anchorsFromWebref (line 218) | def anchorsFromWebref(status: t.Literal["current" | "snapshot"], urlSuff...
  function headingsFromWebref (line 227) | def headingsFromWebref(status: t.Literal["current" | "snapshot"], urlSuf...
  function dataFromWebref (line 237) | def dataFromWebref(url: str) -> t.JSONObject:
  function canonSpecFromWebref (line 252) | def canonSpecFromWebref(rawSpec: WebrefSpecT) -> SpecT:
  function addToAnchors (line 276) | def addToAnchors(
  function addToHeadings (line 309) | def addToHeadings(
  function cleanSpecHeadings (line 375) | def cleanSpecHeadings(headings: AllHeadingsT) -> None:
  function extractMethodData (line 392) | def extractMethodData(anchors: AnchorsT) -> MethodsT:
  function extractForsData (line 421) | def extractForsData(anchors: AnchorsT) -> ForsT:
  function writeAnchorsFile (line 438) | def writeAnchorsFile(anchors: AnchorsT, path: str) -> set[str]:

FILE: bikeshed/update/updateLanguages.py
  function update (line 10) | def update(path: str, dryRun: bool = False) -> set[str] | None:

FILE: bikeshed/update/updateLinkDefaults.py
  function update (line 10) | def update(path: str, dryRun: bool = False) -> set[str] | None:

FILE: bikeshed/update/updateMdn.py
  function update (line 12) | def update(path: str, dryRun: bool = False) -> set[str] | None:

FILE: bikeshed/update/updateWpt.py
  function update (line 11) | def update(path: str, dryRun: bool = False) -> set[str] | None:
  function collectPaths (line 63) | def collectPaths(pathListSoFar: list[str], pathTrie: PathTrie, pathPrefi...

FILE: bikeshed/wpt/wpt.js
  function formatWptResult (line 80) | function formatWptResult({name, version, passes, total}) {

FILE: bikeshed/wpt/wptElement.py
  function processWptElements (line 10) | def processWptElements(doc: t.SpecT) -> None:
  function createHTML (line 113) | def createHTML(
  function appendTestList (line 141) | def appendTestList(
  function testNamesFromEl (line 257) | def testNamesFromEl(el: t.ElementT, pathPrefix: str | None = None) -> li...
  function prefixPlusPath (line 270) | def prefixPlusPath(prefix: str | None, path: str) -> str:
  function prefixInPath (line 280) | def prefixInPath(prefix: str | None, path: str) -> bool:
  function normalizePathSegment (line 287) | def normalizePathSegment(pathSeg: str) -> str: ...
  function normalizePathSegment (line 291) | def normalizePathSegment(pathSeg: None) -> None: ...
  function normalizePathSegment (line 294) | def normalizePathSegment(pathSeg: str | None) -> str | None:
  function checkForOmittedTests (line 305) | def checkForOmittedTests(pathPrefix: str, testData: dict[str, str], seen...
  function loadTestData (line 321) | def loadTestData(doc: t.SpecT) -> dict[str, str]:
  function xor (line 329) | def xor(a: t.Any, b: t.Any) -> bool:
  function commonPathPrefixes (line 333) | def commonPathPrefixes(paths: t.Iterable[str]) -> list[str]:
  function guessTestSuiteUrl (line 352) | def guessTestSuiteUrl(paths: t.Iterable[str]) -> str:

FILE: release.py
  function createRelease (line 8) | def createRelease():
  function inBikeshedRoot (line 125) | def inBikeshedRoot():
  function parseSemver (line 137) | def parseSemver(s):