Module: src/lib/lit-extended

function 𝓟21{$Lambda14} (𝓟22{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟23{values}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟24: [OOV]𝓟[ty]260{TemplateResult})
{
  return 𝓟24 = 𝓟252{CONSTRUCTOR}(𝓟22{strings},𝓟23{values},𝓛8743{String},𝓟39{extendedPartCallback})
}
const 𝓟25{html}: [miss]𝓛[ty]8696{Function} = 𝓟21{$Lambda14};
function 𝓟26{$Lambda15} (𝓟27{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟28{values}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟29: [OOV]𝓟[ty]281{SVGTemplateResult})
{
  return 𝓟29 = 𝓟277{CONSTRUCTOR}(𝓟27{strings},𝓟28{values},𝓛8743{String},𝓟39{extendedPartCallback})
}
const 𝓟30{svg}: [miss]𝓛[ty]8696{Function} = 𝓟26{$Lambda15};
function 𝓟31{$Lambda16} (𝓟32{instance}: [OOV]𝓟[ty]479{TemplateInstance},𝓟33{templatePart}: [OOV]𝓟[ty]321{TemplatePart},𝓟34{node}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]10619{Node})): (𝓟35: [OOV]𝓟[ty]1641{Part})
{
  if (𝓟33{templatePart}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓟33{templatePart}.rawName.startsWith(𝓛8743{String}))
    {
      const 𝓟36{eventName}: [miss]𝓛[ty]10051{String} = 𝓟33{templatePart}.rawName.slice(𝓛8745{Number});
      return 𝓟35 = 𝓟64{CONSTRUCTOR}(𝓟32{instance},𝓟34{node} as 𝓛[ty]10661{Element},𝓟36{eventName})
    }
    if (𝓟33{templatePart}.name.endsWith(𝓛8743{String}))
    {
      const 𝓟37{name}: [miss]𝓛[ty]10051{String} = 𝓟33{templatePart}.name.slice(𝓛8745{Number},𝓛12557{MinusToken}(𝓛8745{Number}));
      return 𝓟35 = 𝓟379{CONSTRUCTOR}(𝓟32{instance},𝓟34{node} as 𝓛[ty]10661{Element},𝓟37{name},𝓟33{templatePart}.strings)
    }
    if (𝓟33{templatePart}.name.endsWith(𝓛8743{String}))
    {
      const 𝓟38{name}: [miss]𝓛[ty]10051{String} = 𝓟33{templatePart}.name.slice(𝓛8745{Number},𝓛12557{MinusToken}(𝓛8745{Number}));
      return 𝓟35 = 𝓟40{CONSTRUCTOR}(𝓟32{instance},𝓟34{node} as 𝓛[ty]10661{Element},𝓟38{name},𝓟33{templatePart}.strings)
    }
    return 𝓟35 = 𝓟52{CONSTRUCTOR}(𝓟32{instance},𝓟34{node} as 𝓛[ty]10661{Element},𝓟33{templatePart}.rawName,𝓟33{templatePart}.strings)
  }
  return 𝓟35 = 𝓟471{defaultPartCallback}(𝓟32{instance},𝓟33{templatePart},𝓟34{node})
}
const 𝓟39{extendedPartCallback}: [miss]𝓛[ty]8696{Function} = 𝓟31{$Lambda16};
function 𝓟40{CONSTRUCTOR} (): (𝓟[ty]44{BooleanAttributePart})
{
  const 𝓟[ty]44{BooleanAttributePart};
  const 𝓟[ty]44{BooleanAttributePart};
}
class 𝓟[ty]44{BooleanAttributePart} extends 𝓟[ty]387{AttributePart}{
  function 𝓟46{setValue} (𝓟47{values}: 𝓛[ty]8670{Array},𝓟48{startIndex}: 𝓛[ty]8655{Number}): (𝓟49: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10033{Void}))
  {
    const 𝓟50{s}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]44{BooleanAttributePart}.strings;
    if (𝓟50{s}.length.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟50{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟50{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})))
    {
      const 𝓟51{value} = 𝓟365{getValue}(𝓟[ty]44{BooleanAttributePart},𝓟47{values}.access(𝓟48{startIndex}));
      if (𝓟51{value}.EqualsEqualsEqualsToken(𝓟374{directiveValue}))
      {
      }
      if (𝓟51{value})
      {
        𝓟[ty]44{BooleanAttributePart}.element.setAttribute(𝓟[ty]44{BooleanAttributePart}.name,𝓛8743{String})
      }
      else
      {
        𝓟[ty]44{BooleanAttributePart}.element.removeAttribute(𝓟[ty]44{BooleanAttributePart}.name)
      }
    }
    else
    {
      𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
    }
  }
}
function 𝓟52{CONSTRUCTOR} (): (𝓟[ty]56{PropertyPart})
{
  const 𝓟[ty]56{PropertyPart};
  const 𝓟[ty]56{PropertyPart};
}
class 𝓟[ty]56{PropertyPart} extends 𝓟[ty]387{AttributePart}{
  function 𝓟58{setValue} (𝓟59{values}: 𝓛[ty]8670{Array},𝓟60{startIndex}: 𝓛[ty]8655{Number}): (𝓟61: 𝓛[ty]10033{Void})
  {
    const 𝓟62{s}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]56{PropertyPart}.strings;
    let 𝓟63{value}: [OOV]any;
    if (𝓟[ty]56{PropertyPart}._equalToPreviousValues(𝓟59{values},𝓟60{startIndex}))
    {
    }
    if (𝓟62{s}.length.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟62{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟62{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})))
    {
      𝓟63{value} ⟵ 𝓟365{getValue}(𝓟[ty]56{PropertyPart},𝓟59{values}.access(𝓟60{startIndex}));
    }
    else
    {
      𝓟63{value} ⟵ 𝓟[ty]56{PropertyPart}._interpolate(𝓟59{values},𝓟60{startIndex});
    }
    if (𝓟63{value}.ExclamationEqualsEqualsToken(𝓟374{directiveValue}))
    {
      𝓟[ty]56{PropertyPart}.element as any.access(𝓟[ty]56{PropertyPart}.name) ⟵ 𝓟63{value};
    }
    𝓟[ty]56{PropertyPart}._previousValues ⟵ 𝓟59{values};
  }
}
function 𝓟64{CONSTRUCTOR} (𝓟65{instance}: [OOV]𝓟[ty]479{TemplateInstance},𝓟66{element}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]10661{Element}),𝓟67{eventName}: 𝓛[ty]10051{String}): (𝓟[ty]71{EventPart})
{
  const 𝓟[ty]71{EventPart};
  const 𝓟[ty]71{EventPart};
  𝓟[ty]71{EventPart}.instance ⟵ 𝓟65{instance};
  𝓟[ty]71{EventPart}.element ⟵ 𝓟66{element};
  𝓟[ty]71{EventPart}.eventName ⟵ 𝓟67{eventName};
}
class 𝓟[ty]71{EventPart} extends 𝓟[ty]1641{Part}{
  𝓟73{instance}: [OOV]𝓟[ty]479{TemplateInstance};
  𝓟74{element}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]10661{Element});
  𝓟75{eventName}: 𝓛[ty]10051{String};
  𝓟76{_listener}: [OOV]any;
  function 𝓟77{setValue} (𝓟78{value}: [OOV]any): (𝓟79: 𝓛[ty]10033{Void})
  {
    const 𝓟80{listener} = 𝓟365{getValue}(𝓟[ty]71{EventPart},𝓟78{value});
    const 𝓟81{previous} = 𝓟[ty]71{EventPart}._listener;
    if (𝓟80{listener}.EqualsEqualsEqualsToken(𝓟81{previous}))
    {
    }
    𝓟[ty]71{EventPart}._listener ⟵ 𝓟80{listener};
    if (𝓟81{previous}.ExclamationEqualsToken(𝓛12563{undefined}))
    {
      𝓟[ty]71{EventPart}.element.removeEventListener(𝓟[ty]71{EventPart}.eventName,𝓟81{previous})
    }
    if (𝓟80{listener}.ExclamationEqualsToken(𝓛12563{undefined}))
    {
      𝓟[ty]71{EventPart}.element.addEventListener(𝓟[ty]71{EventPart}.eventName,𝓟80{listener})
    }
  }
}

Module: tools/src/site

type 𝓟[ty]1650{Outline} extends 𝓛[ty]3199{Map} = {}
type 𝓟[ty]1645{FileData} = {path: 𝓛[ty]2358{ParsedPath}, outPath: 𝓛[ty]10051{String}, attributes: any, body: 𝓛[ty]10051{String}}
type 𝓛[ty]0{ANY} = any
const 𝓟85{glob} = 𝓛2849{promisify}(𝓟549{globcb});
const 𝓟86{exec} = 𝓛2849{promisify}(𝓛8375{exec});
function 𝓟87{CONSTRUCTOR} (): (𝓟[ty]91{CustomRenderer})
{
  const 𝓟[ty]91{CustomRenderer};
  const 𝓟[ty]91{CustomRenderer};
}
class 𝓟[ty]91{CustomRenderer} extends 𝓛[ty]2{<UNKNOWN>}{
  function 𝓟93{code} (𝓟94{code}: 𝓛[ty]10051{String},𝓟95{language}: 𝓛[ty]10051{String},𝓟96{_isEscaped}: 𝓛[ty]8666{Boolean}): (𝓟97: [OOV]any)
  {
    const 𝓟98{prismLanguage} = 𝓟552{Prism}.languages.access(𝓟95{language});
    const 𝓟99{highlighted} = (𝓟98{prismLanguage}.EqualsEqualsEqualsToken(𝓛12563{undefined}) ? 𝓟94{code} : 𝓟552{Prism}.highlight(𝓟94{code},𝓟98{prismLanguage});
    return 𝓟97 = 𝓟181{html}(𝓛12554{$Template}(𝓟95{language},𝓟95{language},𝓟99{highlighted}))
  }
}
𝓟551{marked}.setOptions({renderer: 𝓟87{CONSTRUCTOR}()})
const 𝓟100{docsOutDir} = 𝓛2366{resolve}(𝓛10058{__dirname},𝓛8743{String});
const 𝓟101{docsSrcDir} = 𝓛2366{resolve}(𝓛10058{__dirname},𝓛8743{String});
const 𝓟102{root}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟103{$Async_generateDocs} (): (𝓟104: [miss]𝓛[ty]8654{Promise})
{
  𝓛12547{$Await}(𝓛1{<UNKNOWN>}(𝓟100{docsOutDir}))
  const 𝓟105{fileNames} = 𝓛12547{$Await}(𝓟85{glob}(𝓛8743{String},{cwd: 𝓟101{docsSrcDir}}));
  function 𝓟106{$Async_$Lambda24} (𝓟107{fileName}): (𝓟108: [miss]𝓛[ty]8654{Promise})
  {
    const 𝓟109{filePath} = 𝓛2388{parse}(𝓟107{fileName});
    const 𝓟110{content} = 𝓛12547{$Await}(𝓛7875{readFile}(𝓛2363{join}(𝓟101{docsSrcDir},𝓟107{fileName}),𝓛8743{String}));
    const 𝓟111{pageData}: [miss]𝓛[ty]8642{Object} = 𝓟550{frontMatter}(𝓟110{content});
    const 𝓟112{outPath}: [miss]𝓛[ty]10051{String} = 𝓛12554{$Template}(𝓟109{filePath}.dir,𝓟185{stripOrdering}(𝓟109{filePath}.name));
    return 𝓟108 = 𝓛8757{Array}(𝓟107{fileName},{path: 𝓟109{filePath},outPath: 𝓟112{outPath},attributes: 𝓟111{pageData}.attributes,body: 𝓟111{pageData}.body}) as 𝓛[ty]8670{Array}
  }
  const 𝓟113{files}: [miss]𝓛[ty]3199{Map} = 𝓛2995{Map}.CONSTRUCTOR(𝓛12547{$Await}(𝓛1062{Promise}.all(𝓟105{fileNames}.map(𝓛1{<UNKNOWN>}))));
  {
    const 𝓟114{fileData}: [OOV]𝓟[ty]1645{FileData} = 𝓛12552{$ArrayAccess}(𝓟113{files}.values());
    while (𝓛8744{Boolean})
    {
      const 𝓟115{outDir} = 𝓛2363{join}(𝓟100{docsOutDir},𝓟114{fileData}.path.dir);
      𝓛12547{$Await}(𝓛1{<UNKNOWN>}(𝓟115{outDir}))
      const 𝓟116{body} = 𝓟551{marked}(𝓟114{fileData}.body);
      const 𝓟117{outContent} = 𝓟124{page}(𝓟114{fileData}.outPath,𝓟116{body},𝓟113{files});
      const 𝓟118{outPath} = 𝓛2363{join}(𝓟100{docsOutDir},𝓟114{fileData}.outPath);
      𝓛7909{writeFile}(𝓟118{outPath},𝓟117{outContent})
    }
  }
  𝓛8081{copyFileSync}(𝓛2363{join}(𝓟101{docsSrcDir},𝓛8743{String}),𝓛2363{join}(𝓟100{docsOutDir},𝓛8743{String}))
  𝓛8081{copyFileSync}(𝓛2366{resolve}(𝓛10058{__dirname},𝓛8743{String}),𝓛2363{join}(𝓟100{docsOutDir},𝓛8743{String}))
  𝓛12547{$Await}(𝓛7909{writeFile}(𝓛2363{join}(𝓟100{docsOutDir},𝓛8743{String}),𝓛8743{String}))
  𝓛12547{$Await}(𝓟86{exec}(𝓛8743{String},{cwd: 𝓛8743{String}}))
}
function 𝓟119{$Lambda25} (𝓟120{pagePath}: 𝓛[ty]10051{String},𝓟121{content}: 𝓛[ty]10051{String},𝓟122{files}: (𝓛[ty]10051{String} ≠ 𝓛[ty]3199{Map})): (𝓟123: [OOV]any)
{
  return 𝓟123 = 𝓟181{html}(𝓛12554{$Template}(𝓟102{root},𝓟102{root},𝓟171{sideNav}(𝓟120{pagePath},𝓟122{files}),𝓟128{topNav}(𝓟120{pagePath}.split(𝓛8743{String}).access(𝓛8745{Number})),𝓟121{content}))
}
const 𝓟124{page}: [miss]𝓛[ty]8696{Function} = 𝓟119{$Lambda25};
function 𝓟125{$Lambda26} (𝓟126{section}: 𝓛[ty]10051{String}): (𝓟127: [OOV]any)
{
  return 𝓟127 = 𝓟181{html}(𝓛12554{$Template}((𝓟126{section}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛8743{String} : 𝓛8743{String},𝓟102{root},(𝓟126{section}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛8743{String} : 𝓛8743{String},𝓟102{root},(𝓟126{section}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛8743{String} : 𝓛8743{String},𝓟102{root}))
}
const 𝓟128{topNav}: [miss]𝓛[ty]8696{Function} = 𝓟125{$Lambda26};
function 𝓟129{$Lambda27} (𝓟130{pagePath}: 𝓛[ty]10051{String},𝓟131{files}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]3199{Map})): (𝓟132: [OOV]𝓟[ty]1650{Outline})
{
  const 𝓟133{outline}: [OOV]𝓟[ty]1650{Outline} = 𝓛2995{Map}.CONSTRUCTOR();
  {
    const 𝓟134{fileData}: [OOV]𝓟[ty]1645{FileData} = 𝓛12552{$ArrayAccess}(𝓟131{files}.values());
    while (𝓛8744{Boolean})
    {
      const 𝓟135{parts} = 𝓟134{fileData}.path.dir.split(𝓛2386{sep});
      let 𝓟136{parent}: [OOV]𝓟[ty]1650{Outline} = 𝓟133{outline};
      {
        const 𝓟137{part} = 𝓛12552{$ArrayAccess}(𝓟135{parts});
        while (𝓛8744{Boolean})
        {
          let 𝓟138{child}: [OOV]𝓛[ty]0{ANY} = 𝓟136{parent}.get(𝓟137{part});
          if (𝓟138{child}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
          {
            𝓟138{child} ⟵ 𝓛2995{Map}.CONSTRUCTOR() as 𝓟[ty]1650{Outline};
            𝓟136{parent}.set(𝓟137{part},𝓟138{child})
          }
          if (𝓟138{child}.InstanceOfKeyword(𝓛2995{Map}))
          {
            𝓟136{parent} ⟵ 𝓟138{child};
          }
          else
          {
            𝓛1{<UNKNOWN>}(𝓟138{child})
            𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
          }
        }
      }
      𝓟136{parent}.set(𝓟134{fileData}.path.name,𝓟134{fileData})
    }
  }
  function 𝓟139{sortOutline} (𝓟140{unsorted}: [OOV]𝓟[ty]1650{Outline},𝓟141{sorted}: [OOV]𝓟[ty]1650{Outline}): (𝓟142: [OOV]𝓟[ty]1650{Outline})
  {
    𝓟141{sorted}.set(𝓛8743{String},𝓟140{unsorted}.get(𝓛8743{String}))
    𝓟140{unsorted}.delete(𝓛8743{String})
    function 𝓟143{$Lambda28} (𝓟144{value},𝓟145{key}): (𝓟146: [miss]𝓛[ty]10033{Void})
    {
      if (𝓟144{value}.InstanceOfKeyword(𝓛2995{Map}))
      {
        𝓟144{value} ⟵ 𝓟139{sortOutline}(𝓟144{value},𝓛2995{Map}.CONSTRUCTOR());
      }
      𝓟141{sorted}.set(𝓟145{key},𝓟144{value})
    }
    𝓟140{unsorted}.forEach(𝓟143{$Lambda28})
    return 𝓟142 = 𝓟141{sorted}
  }
  return 𝓟132 = 𝓟139{sortOutline}(𝓟133{outline},𝓛2995{Map}.CONSTRUCTOR())
}
const 𝓟147{getOutline}: [miss]𝓛[ty]8696{Function} = 𝓟129{$Lambda27};
function 𝓟148{$Lambda29} (𝓟149{pagePath}: 𝓛[ty]10051{String},𝓟150{files}: (𝓛[ty]10051{String} ≠ 𝓛[ty]3199{Map})): (𝓟151: [OOV]any)
{
  if (𝓛12548{ExclamationToken}(𝓟149{pagePath}.startsWith(𝓛8743{String})))
  {
    return 𝓟151 = 𝓛8743{String}
  }
  function 𝓟152{$Lambda30} (𝓟153{outline}: [OOV]𝓟[ty]1650{Outline}): (𝓟154: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
  {
    function 𝓟155{$Lambda31} (𝓟156{_}): (𝓟157: [OOV]any)
    {
    }
    return 𝓟154 = 𝓟181{html}(𝓛12554{$Template}(𝓛8757{Array}.from(𝓟153{outline}.entries()).map(𝓟155{$Lambda31})))
  }
  const 𝓟158{renderOutline}: [miss]𝓛[ty]8696{Function} = 𝓟152{$Lambda30};
  function 𝓟159{$Lambda32} (𝓟160{data}: [OOV]𝓟[ty]1645{FileData}): (𝓟161: [OOV]any)
  {
    const 𝓟162{tokens} = 𝓟551{marked}.lexer(𝓟160{data}.body);
    function 𝓟163{$Lambda33} (𝓟164{t}): (𝓟165: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟165 = 𝓟164{t}.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟164{t}.depth.EqualsEqualsEqualsToken(𝓛8745{Number}))
    }
    const 𝓟166{headers}: [miss]𝓛[ty]8670{Array} = 𝓟162{tokens}.filter(𝓟163{$Lambda33}) as 𝓛[ty]8670{Array};
    function 𝓟167{$Lambda34} (𝓟168{header}): (𝓟169: [OOV]any)
    {
      return 𝓟169 = 𝓟181{html}(𝓛12554{$Template}(𝓟168{header}.depth,𝓟189{getId}(𝓟168{header}.text),𝓟168{header}.text.replace(𝓛8743{String},𝓛8743{String})))
    }
    return 𝓟161 = 𝓟181{html}(𝓛12554{$Template}(𝓟166{headers}.map(𝓟167{$Lambda34})))
  }
  const 𝓟170{renderPageOutline}: [miss]𝓛[ty]8696{Function} = 𝓟159{$Lambda32};
  return 𝓟151 = 𝓟181{html}(𝓛12554{$Template}(𝓟158{renderOutline}(𝓟147{getOutline}(𝓟149{pagePath},𝓟150{files}).get(𝓛8743{String}) as 𝓟[ty]1650{Outline})))
}
const 𝓟171{sideNav}: [miss]𝓛[ty]8696{Function} = 𝓟148{$Lambda29};
function 𝓟172{$Lambda35} (𝓟173{strings}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟174{values}: 𝓛[ty]8670{Array}): (𝓟175: [OOV]any)
{
  function 𝓟176{$Lambda36} (𝓟177{acc},𝓟178{v},𝓟179{i}): (𝓟180: [miss]𝓛[ty]10051{String})
  {
    return 𝓟180 = 𝓟177{acc}.PlusToken((𝓛8757{Array}.isArray(𝓟178{v}) ? 𝓟178{v}.join(𝓛8743{String}) : 𝓛8743{String}(𝓟178{v})).PlusToken(𝓟173{strings}.access(𝓟179{i}.PlusToken(𝓛8745{Number})))
  }
  return 𝓟175 = 𝓟174{values}.reduce(𝓟176{$Lambda36},𝓟173{strings}.access(𝓛8745{Number}))
}
const 𝓟181{html}: [miss]𝓛[ty]8696{Function} = 𝓟172{$Lambda35};
function 𝓟182{$Lambda37} (𝓟183{filename}: 𝓛[ty]10051{String}): (𝓟184: [miss]𝓛[ty]10051{String})
{
  return 𝓟184 = 𝓟183{filename}.replace(𝓛8748{RegExp},𝓛8743{String})
}
const 𝓟185{stripOrdering}: [miss]𝓛[ty]8696{Function} = 𝓟182{$Lambda37};
function 𝓟186{$Lambda38} (𝓟187{s}: 𝓛[ty]10051{String}): (𝓟188: [miss]𝓛[ty]10051{String})
{
  return 𝓟188 = 𝓟187{s}.toLowerCase().replace(𝓛8748{RegExp},𝓛8743{String})
}
const 𝓟189{getId}: [miss]𝓛[ty]8696{Function} = 𝓟186{$Lambda38};
𝓛1{<UNKNOWN>}()

Module: src/lit-html

type 𝓟[ty]1649{MultiPart} extends 𝓟[ty]1641{Part} = {setValue: (𝓛[ty]8670{Array},𝓛[ty]8655{Number})->𝓛[ty]10033{Void}}
type 𝓟[ty]1642{PartCallback} = (𝓟[ty]479{TemplateInstance},𝓟[ty]321{TemplatePart},𝓛[ty]10619{Node})->𝓟[ty]1641{Part}
type 𝓟[ty]1647{SinglePart} extends 𝓟[ty]1641{Part} = {setValue: (any)->𝓛[ty]10033{Void}}
type 𝓟[ty]1643{KeyFn} = (any)->any
type 𝓟[ty]1640{TemplateFactory} = (𝓟[ty]260{TemplateResult})->𝓟[ty]357{Template}
type 𝓟[ty]1641{Part} = {instance: 𝓟[ty]479{TemplateInstance}, size: 𝓛[ty]8655{Number}}
const 𝓟241{templateCaches}: [miss]𝓛[ty]3199{Map} = 𝓛2995{Map}.CONSTRUCTOR();
function 𝓟242{$Lambda0} (𝓟243{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟244{values}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟245: [OOV]𝓟[ty]260{TemplateResult})
{
  return 𝓟245 = 𝓟252{CONSTRUCTOR}(𝓟243{strings},𝓟244{values},𝓛8743{String})
}
const 𝓟246{html}: [miss]𝓛[ty]8696{Function} = 𝓟242{$Lambda0};
function 𝓟247{$Lambda1} (𝓟248{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟249{values}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟250: [OOV]𝓟[ty]281{SVGTemplateResult})
{
  return 𝓟250 = 𝓟277{CONSTRUCTOR}(𝓟248{strings},𝓟249{values},𝓛8743{String})
}
const 𝓟251{svg}: [miss]𝓛[ty]8696{Function} = 𝓟247{$Lambda1};
function 𝓟252{CONSTRUCTOR} (𝓟253{strings}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8646{TemplateStringsArray}),𝓟254{values}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8670{Array}),𝓟255{type}: 𝓛[ty]10051{String},𝓟256{partCallback}: [OOV]𝓟[ty]1642{PartCallback}): (𝓟[ty]260{TemplateResult})
{
  const 𝓟[ty]260{TemplateResult};
  const 𝓟[ty]260{TemplateResult};
  𝓟[ty]260{TemplateResult}.strings ⟵ 𝓟253{strings};
  𝓟[ty]260{TemplateResult}.values ⟵ 𝓟254{values};
  𝓟[ty]260{TemplateResult}.type ⟵ 𝓟255{type};
  𝓟[ty]260{TemplateResult}.partCallback ⟵ 𝓟256{partCallback};
}
class 𝓟[ty]260{TemplateResult}{
  𝓟262{strings}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8646{TemplateStringsArray});
  𝓟263{values}: 𝓛[ty]8670{Array};
  𝓟264{type}: 𝓛[ty]10051{String};
  𝓟265{partCallback}: [OOV]𝓟[ty]1642{PartCallback};
  function 𝓟266{getHTML} (): (𝓟267: 𝓛[ty]10051{String})
  {
    const 𝓟268{l}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]260{TemplateResult}.strings.length.MinusToken(𝓛8745{Number});
    let 𝓟269{html}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
    let 𝓟270{isTextBinding}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
    {
      let 𝓟271{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
      while (𝓟271{i}.FirstBinaryOperator(𝓟268{l}))
      {
        {
          const 𝓟272{s}: [miss]𝓛[ty]10051{String} = 𝓟[ty]260{TemplateResult}.strings.access(𝓟271{i});
          𝓟269{html}.FirstCompoundAssignment(𝓟272{s})
          const 𝓟273{closing}: [miss]𝓛[ty]8655{Number} = 𝓟307{findTagClose}(𝓟272{s});
          𝓟270{isTextBinding} ⟵ (𝓟273{closing}.GreaterThanToken(𝓛12557{MinusToken}(𝓛8745{Number})) ? 𝓟273{closing}.FirstBinaryOperator(𝓟272{s}.length) : 𝓟270{isTextBinding};
          𝓟269{html}.FirstCompoundAssignment((𝓟270{isTextBinding} ? 𝓟304{nodeMarker} : 𝓟303{marker}))
        }
        𝓛12546{POST_PlusPlusToken}(𝓟271{i})
      }
    }
    𝓟269{html}.FirstCompoundAssignment(𝓟[ty]260{TemplateResult}.strings.access(𝓟268{l}))
    return 𝓟267 = 𝓟269{html}
  }
  function 𝓟274{getTemplateElement} (): (𝓟275: [OOV]𝓛[ty]10869{HTMLTemplateElement})
  {
    const 𝓟276{template}: [OOV]𝓛[ty]10869{HTMLTemplateElement} = 𝓛12160{document}.createElement(𝓛8743{String});
    𝓟276{template}.innerHTML ⟵ 𝓟[ty]260{TemplateResult}.getHTML();
    return 𝓟275 = 𝓟276{template}
  }
}
function 𝓟277{CONSTRUCTOR} (): (𝓟[ty]281{SVGTemplateResult})
{
  const 𝓟[ty]281{SVGTemplateResult};
  const 𝓟[ty]281{SVGTemplateResult};
}
class 𝓟[ty]281{SVGTemplateResult} extends 𝓟[ty]260{TemplateResult}{
  function 𝓟283{getHTML} (): (𝓟284: 𝓛[ty]10051{String})
  {
    return 𝓟284 = 𝓛12554{$Template}(𝓟[ty]281{SVGTemplateResult}.getHTML())
  }
  function 𝓟285{getTemplateElement} (): (𝓟286: [OOV]𝓛[ty]10869{HTMLTemplateElement})
  {
    const 𝓟287{template}: [OOV]𝓛[ty]10869{HTMLTemplateElement} = 𝓟[ty]281{SVGTemplateResult}.getTemplateElement();
    const 𝓟288{content}: [OOV]𝓛[ty]11362{DocumentFragment} = 𝓟287{template}.content;
    const 𝓟289{svgElement}: [OOV]𝓛[ty]10883{ChildNode} = 𝓟288{content}.firstChild;
    𝓟288{content}.removeChild(𝓟289{svgElement})
    𝓟506{reparentNodes}(𝓟288{content},𝓟289{svgElement}.firstChild)
    return 𝓟286 = 𝓟287{template}
  }
}
function 𝓟290{defaultTemplateFactory} (𝓟291{result}: [OOV]𝓟[ty]260{TemplateResult}): (𝓟292: [OOV]𝓟[ty]357{Template})
{
  let 𝓟293{templateCache}: [miss]𝓛[ty]3199{Map} = 𝓟241{templateCaches}.get(𝓟291{result}.type);
  if (𝓟293{templateCache}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
  {
    𝓟293{templateCache} ⟵ 𝓛2995{Map}.CONSTRUCTOR();
    𝓟241{templateCaches}.set(𝓟291{result}.type,𝓟293{templateCache})
  }
  let 𝓟294{template}: [OOV]𝓟[ty]357{Template} = 𝓟293{templateCache}.get(𝓟291{result}.strings);
  if (𝓟294{template}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
  {
    𝓟294{template} ⟵ 𝓟328{CONSTRUCTOR}(𝓟291{result},𝓟291{result}.getTemplateElement());
    𝓟293{templateCache}.set(𝓟291{result}.strings,𝓟294{template})
  }
  return 𝓟292 = 𝓟294{template}
}
function 𝓟295{render} (𝓟296{result}: [OOV]𝓟[ty]260{TemplateResult},𝓟297{container}: [OOV]any,𝓟298{templateFactory}: [OOV]𝓟[ty]1640{TemplateFactory}): (𝓟299: [miss]𝓛[ty]10033{Void})
{
  const 𝓟300{template}: [OOV]𝓟[ty]357{Template} = 𝓟298{templateFactory}(𝓟296{result});
  let 𝓟301{instance} = 𝓟297{container} as any.__templateInstance as any;
  if (𝓟301{instance}.ExclamationEqualsEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓟301{instance}.template.EqualsEqualsEqualsToken(𝓟300{template})).AmpersandAmpersandToken(𝓟301{instance}._partCallback.EqualsEqualsEqualsToken(𝓟296{result}.partCallback)))
  {
    𝓟301{instance}.update(𝓟296{result}.values)
  }
  𝓟301{instance} ⟵ 𝓟472{CONSTRUCTOR}(𝓟300{template},𝓟296{result}.partCallback,𝓟298{templateFactory});
  𝓟297{container} as any.__templateInstance ⟵ 𝓟301{instance};
  const 𝓟302{fragment} = 𝓟301{instance}._clone();
  𝓟301{instance}.update(𝓟296{result}.values)
  𝓟514{removeNodes}(𝓟297{container},𝓟297{container}.firstChild)
  𝓟297{container}.appendChild(𝓟302{fragment})
}
const 𝓟303{marker}: [miss]𝓛[ty]10051{String} = 𝓛12554{$Template}(𝓛8743{String}(𝓛8746{Math}.random()).slice(𝓛8745{Number}));
const 𝓟304{nodeMarker}: [miss]𝓛[ty]10051{String} = 𝓛12554{$Template}(𝓟303{marker});
const 𝓟305{markerRegex}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp}.CONSTRUCTOR(𝓛12554{$Template}(𝓟303{marker},𝓟304{nodeMarker}));
const 𝓟306{lastAttributeNameRegex}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
function 𝓟307{findTagClose} (𝓟308{str}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]10051{String})): (𝓟309: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
{
  const 𝓟310{close}: [miss]𝓛[ty]8655{Number} = 𝓟308{str}.lastIndexOf(𝓛8743{String});
  const 𝓟311{open}: [miss]𝓛[ty]8655{Number} = 𝓟308{str}.indexOf(𝓛8743{String},𝓟310{close}.PlusToken(𝓛8745{Number}));
  return 𝓟309 = (𝓟311{open}.GreaterThanToken(𝓛12557{MinusToken}(𝓛8745{Number})) ? 𝓟308{str}.length : 𝓟310{close}
}
function 𝓟312{CONSTRUCTOR} (𝓟313{type}: 𝓛[ty]10051{String},𝓟314{index}: 𝓛[ty]8655{Number},𝓟315{name}: 𝓛[ty]10051{String},𝓟316{rawName}: 𝓛[ty]10051{String},𝓟317{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]321{TemplatePart})
{
  const 𝓟[ty]321{TemplatePart};
  const 𝓟[ty]321{TemplatePart};
  𝓟[ty]321{TemplatePart}.rawName ⟵ 𝓟316{rawName};
  𝓟[ty]321{TemplatePart}.type ⟵ 𝓟313{type};
  𝓟[ty]321{TemplatePart}.strings ⟵ 𝓟317{strings};
  𝓟[ty]321{TemplatePart}.name ⟵ 𝓟315{name};
  𝓟[ty]321{TemplatePart}.index ⟵ 𝓟314{index};
}
class 𝓟[ty]321{TemplatePart}{
  𝓟323{name}: 𝓛[ty]10051{String};
  𝓟324{strings}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
  𝓟325{rawName}: 𝓛[ty]10051{String};
  𝓟326{type}: 𝓛[ty]10051{String};
  𝓟327{index}: 𝓛[ty]8655{Number};
}
function 𝓟328{CONSTRUCTOR} (𝓟329{result}: [OOV]𝓟[ty]260{TemplateResult},𝓟330{element}: [OOV]𝓛[ty]10869{HTMLTemplateElement}): (𝓟[ty]357{Template})
{
  const 𝓟[ty]357{Template};
  const 𝓟[ty]357{Template};
  𝓟[ty]357{Template}.parts ⟵ 𝓛8757{Array}();
  𝓟[ty]357{Template}.element ⟵ 𝓟330{element};
  const 𝓟334{content}: [OOV]𝓛[ty]11362{DocumentFragment} = 𝓟[ty]357{Template}.element.content;
  const 𝓟335{walker}: [OOV]𝓛[ty]10402{TreeWalker} = 𝓛12160{document}.createTreeWalker(𝓟334{content},𝓛8745{Number},𝓛12563{undefined} as any,𝓛8744{Boolean});
  let 𝓟336{index}: [miss]𝓛[ty]8655{Number} = 𝓛12557{MinusToken}(𝓛8745{Number});
  let 𝓟337{partIndex}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
  const 𝓟338{nodesToRemove}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
  let 𝓟339{previousNode}: [OOV]any;
  let 𝓟340{currentNode}: [OOV]any;
  while (𝓟335{walker}.nextNode())
  {
    𝓛12546{POST_PlusPlusToken}(𝓟336{index})
    𝓟339{previousNode} ⟵ 𝓟340{currentNode};
    const 𝓟341{node}: [miss]𝓛[ty]10661{Element} = 𝓟340{currentNode}.FirstAssignment(𝓟335{walker}.currentNode as 𝓛[ty]10661{Element});
    if (𝓟341{node}.nodeType.EqualsEqualsEqualsToken(𝓛8745{Number}))
    {
      if (𝓛12548{ExclamationToken}(𝓟341{node}.hasAttributes()))
      {
      }
      const 𝓟342{attributes}: [OOV]𝓛[ty]10515{NamedNodeMap} = 𝓟341{node}.attributes;
      let 𝓟343{count}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
      {
        let 𝓟344{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
        while (𝓟344{i}.FirstBinaryOperator(𝓟342{attributes}.length))
        {
          {
            if (𝓟342{attributes}.access(𝓟344{i}).value.indexOf(𝓟303{marker}).GreaterThanEqualsToken(𝓛8745{Number}))
            {
              𝓛12546{POST_PlusPlusToken}(𝓟343{count})
            }
          }
          𝓛12546{POST_PlusPlusToken}(𝓟344{i})
        }
      }
      while (𝓛12555{POST_MinusMinusToken}(𝓟343{count}).GreaterThanToken(𝓛8745{Number}))
      {
        const 𝓟345{stringForPart}: [miss]𝓛[ty]10051{String} = 𝓟329{result}.strings.access(𝓟337{partIndex});
        const 𝓟346{attributeNameInPart}: [miss]𝓛[ty]10051{String} = 𝓟306{lastAttributeNameRegex}.exec(𝓟345{stringForPart}).access(𝓛8745{Number});
        const 𝓟347{attribute}: [OOV]𝓛[ty]10274{Attr} = 𝓟342{attributes}.getNamedItem(𝓟346{attributeNameInPart});
        const 𝓟348{stringsForAttributeValue}: [miss]𝓛[ty]8670{Array} = 𝓟347{attribute}.value.split(𝓟305{markerRegex});
        𝓟[ty]357{Template}.parts.push(𝓟312{CONSTRUCTOR}(𝓛8743{String},𝓟336{index},𝓟347{attribute}.name,𝓟346{attributeNameInPart},𝓟348{stringsForAttributeValue}))
        𝓟341{node}.removeAttribute(𝓟347{attribute}.name)
        𝓟337{partIndex}.FirstCompoundAssignment(𝓟348{stringsForAttributeValue}.length.MinusToken(𝓛8745{Number}))
      }
    }
    else
    {
      if (𝓟341{node}.nodeType.EqualsEqualsEqualsToken(𝓛8745{Number}))
      {
        const 𝓟349{nodeValue}: [miss]𝓛[ty]10051{String} = 𝓟341{node}.nodeValue;
        if (𝓟349{nodeValue}.indexOf(𝓟303{marker}).FirstBinaryOperator(𝓛8745{Number}))
        {
        }
        const 𝓟350{parent} = 𝓟341{node}.parentNode;
        const 𝓟351{strings}: [miss]𝓛[ty]8670{Array} = 𝓟349{nodeValue}.split(𝓟305{markerRegex});
        const 𝓟352{lastIndex}: [miss]𝓛[ty]8655{Number} = 𝓟351{strings}.length.MinusToken(𝓛8745{Number});
        𝓟337{partIndex}.FirstCompoundAssignment(𝓟352{lastIndex})
        𝓟341{node}.textContent ⟵ 𝓟351{strings}.access(𝓟352{lastIndex});
        {
          let 𝓟353{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
          while (𝓟353{i}.FirstBinaryOperator(𝓟352{lastIndex}))
          {
            {
              𝓟350{parent}.insertBefore(𝓛12160{document}.createTextNode(𝓟351{strings}.access(𝓟353{i})),𝓟341{node})
              𝓟[ty]357{Template}.parts.push(𝓟312{CONSTRUCTOR}(𝓛8743{String},𝓛12546{POST_PlusPlusToken}(𝓟336{index})))
            }
            𝓛12546{POST_PlusPlusToken}(𝓟353{i})
          }
        }
      }
      else
      {
        if (𝓟341{node}.nodeType.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟341{node}.nodeValue.EqualsEqualsEqualsToken(𝓟303{marker})))
        {
          const 𝓟354{parent} = 𝓟341{node}.parentNode;
          const 𝓟355{previousSibling}: [miss]𝓛[ty]10619{Node} = 𝓟341{node}.previousSibling;
          if (𝓟355{previousSibling}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓟355{previousSibling}.ExclamationEqualsEqualsToken(𝓟339{previousNode})).BarBarToken(𝓟355{previousSibling}.nodeType.ExclamationEqualsEqualsToken(𝓛11798{Node}.TEXT_NODE)))
          {
            𝓟354{parent}.insertBefore(𝓛12160{document}.createTextNode(𝓛8743{String}),𝓟341{node})
          }
          else
          {
            𝓛12555{POST_MinusMinusToken}(𝓟336{index})
          }
          𝓟[ty]357{Template}.parts.push(𝓟312{CONSTRUCTOR}(𝓛8743{String},𝓛12546{POST_PlusPlusToken}(𝓟336{index})))
          𝓟338{nodesToRemove}.push(𝓟341{node})
          if (𝓟341{node}.nextSibling.EqualsEqualsEqualsToken(𝓛12563{undefined}))
          {
            𝓟354{parent}.insertBefore(𝓛12160{document}.createTextNode(𝓛8743{String}),𝓟341{node})
          }
          else
          {
            𝓛12555{POST_MinusMinusToken}(𝓟336{index})
          }
          𝓟340{currentNode} ⟵ 𝓟339{previousNode};
          𝓛12546{POST_PlusPlusToken}(𝓟337{partIndex})
        }
      }
    }
  }
  {
    const 𝓟356{n}: [miss]𝓛[ty]10619{Node} = 𝓛12552{$ArrayAccess}(𝓟338{nodesToRemove});
    while (𝓛8744{Boolean})
    {
      𝓟356{n}.parentNode.removeChild(𝓟356{n})
    }
  }
}
class 𝓟[ty]357{Template}{
  𝓟359{parts}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
  𝓟360{element}: [OOV]𝓛[ty]10869{HTMLTemplateElement};
}
function 𝓟361{$Lambda2} (𝓟362{part}: [OOV]𝓟[ty]1641{Part},𝓟363{value}: [OOV]any): (𝓟364: [OOV]any)
{
  if (𝓟373{isDirective}(𝓟363{value}))
  {
    𝓟363{value} ⟵ 𝓟363{value}(𝓟362{part});
    return 𝓟364 = 𝓟374{directiveValue}
  }
  return 𝓟364 = (𝓟363{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}) ? 𝓛12563{undefined} : 𝓟363{value}
}
const 𝓟365{getValue}: [miss]𝓛[ty]8696{Function} = 𝓟361{$Lambda2};
function 𝓟366{$Lambda3} (𝓟367{f}: [OOV]any): (𝓟368: [OOV]any)
{
  𝓟367{f} as any.__litDirective ⟵ 𝓛8744{Boolean};
  return 𝓟368 = 𝓟367{f}
}
const 𝓟369{directive}: [miss]𝓛[ty]8696{Function} = 𝓟366{$Lambda3};
function 𝓟370{$Lambda4} (𝓟371{o}: [OOV]any): (𝓟372: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟372 = 𝓛12550{$TypeOf}(𝓟371{o}).EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟371{o}.__litDirective.EqualsEqualsEqualsToken(𝓛8744{Boolean}))
}
const 𝓟373{isDirective}: [miss]𝓛[ty]8696{Function} = 𝓟370{$Lambda4};
const 𝓟374{directiveValue}: [miss]𝓛[ty]8642{Object} = {};
function 𝓟375{$Lambda5} (𝓟376{value}: [OOV]any): (𝓟377: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟377 = 𝓟376{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓛12548{ExclamationToken}(𝓛12550{$TypeOf}(𝓟376{value}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓛12550{$TypeOf}(𝓟376{value}).EqualsEqualsEqualsToken(𝓛8743{String}))))
}
const 𝓟378{isPrimitiveValue}: [miss]𝓛[ty]8696{Function} = 𝓟375{$Lambda5};
function 𝓟379{CONSTRUCTOR} (𝓟380{instance}: [OOV]𝓟[ty]479{TemplateInstance},𝓟381{element}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10661{Element}),𝓟382{name}: 𝓛[ty]10051{String},𝓟383{strings}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]387{AttributePart})
{
  const 𝓟[ty]387{AttributePart};
  const 𝓟[ty]387{AttributePart};
  𝓟[ty]387{AttributePart}.instance ⟵ 𝓟380{instance};
  𝓟[ty]387{AttributePart}.element ⟵ 𝓟381{element};
  𝓟[ty]387{AttributePart}.name ⟵ 𝓟382{name};
  𝓟[ty]387{AttributePart}.strings ⟵ 𝓟383{strings};
  𝓟[ty]387{AttributePart}.size ⟵ 𝓟383{strings}.length.MinusToken(𝓛8745{Number});
  𝓟[ty]387{AttributePart}._previousValues ⟵ 𝓛8757{Array}();
}
class 𝓟[ty]387{AttributePart} extends 𝓟[ty]1649{MultiPart}{
  𝓟389{name}: 𝓛[ty]10051{String};
  𝓟390{size}: 𝓛[ty]8655{Number};
  𝓟391{instance}: [OOV]𝓟[ty]479{TemplateInstance};
  𝓟392{element}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10661{Element});
  𝓟393{strings}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
  𝓟394{_previousValues}: [OOV]any;
  function 𝓟395{_interpolate} (𝓟396{values}: 𝓛[ty]8670{Array},𝓟397{startIndex}: 𝓛[ty]8655{Number}): (𝓟398: [miss]𝓛[ty]10051{String})
  {
    const 𝓟399{strings}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]387{AttributePart}.strings;
    const 𝓟400{l}: [miss]𝓛[ty]8655{Number} = 𝓟399{strings}.length.MinusToken(𝓛8745{Number});
    let 𝓟401{text}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
    {
      let 𝓟402{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
      while (𝓟402{i}.FirstBinaryOperator(𝓟400{l}))
      {
        {
          𝓟401{text}.FirstCompoundAssignment(𝓟399{strings}.access(𝓟402{i}))
          const 𝓟403{v} = 𝓟365{getValue}(𝓟[ty]387{AttributePart},𝓟396{values}.access(𝓟397{startIndex}.PlusToken(𝓟402{i})));
          if (𝓟403{v}.AmpersandAmpersandToken(𝓟403{v}.ExclamationEqualsEqualsToken(𝓟374{directiveValue})).AmpersandAmpersandToken(𝓛8757{Array}.isArray(𝓟403{v}).BarBarToken(𝓛12550{$TypeOf}(𝓟403{v}).ExclamationEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟403{v}.access(𝓛10031{Symbol}.iterator)))))
          {
            {
              const 𝓟404{t} = 𝓛12552{$ArrayAccess}(𝓟403{v});
              while (𝓛8744{Boolean})
              {
                𝓟401{text}.FirstCompoundAssignment(𝓟404{t})
              }
            }
          }
          else
          {
            𝓟401{text}.FirstCompoundAssignment(𝓟403{v})
          }
        }
        𝓛12546{POST_PlusPlusToken}(𝓟402{i})
      }
    }
    return 𝓟398 = 𝓟401{text}.PlusToken(𝓟399{strings}.access(𝓟400{l}))
  }
  function 𝓟405{_equalToPreviousValues} (𝓟406{values}: 𝓛[ty]8670{Array},𝓟407{startIndex}: 𝓛[ty]8655{Number}): (𝓟408: [miss]𝓛[ty]8666{Boolean})
  {
    {
      let 𝓟409{i}: [miss]𝓛[ty]8655{Number} = 𝓟407{startIndex};
      while (𝓟409{i}.FirstBinaryOperator(𝓟407{startIndex}.PlusToken(𝓟[ty]387{AttributePart}.size)))
      {
        {
          if (𝓟[ty]387{AttributePart}._previousValues.access(𝓟409{i}).ExclamationEqualsEqualsToken(𝓟406{values}.access(𝓟409{i})).BarBarToken(𝓛12548{ExclamationToken}(𝓟378{isPrimitiveValue}(𝓟406{values}.access(𝓟409{i})))))
          {
            return 𝓟408 = 𝓛8744{Boolean}
          }
        }
        𝓛12546{POST_PlusPlusToken}(𝓟409{i})
      }
    }
    return 𝓟408 = 𝓛8744{Boolean}
  }
  function 𝓟410{setValue} (𝓟411{values}: 𝓛[ty]8670{Array},𝓟412{startIndex}: 𝓛[ty]8655{Number}): (𝓟413: 𝓛[ty]10033{Void})
  {
    if (𝓟[ty]387{AttributePart}._equalToPreviousValues(𝓟411{values},𝓟412{startIndex}))
    {
    }
    const 𝓟414{s}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]387{AttributePart}.strings;
    let 𝓟415{value}: [OOV]any;
    if (𝓟414{s}.length.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟414{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟414{s}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})))
    {
      𝓟415{value} ⟵ 𝓟365{getValue}(𝓟[ty]387{AttributePart},𝓟411{values}.access(𝓟412{startIndex}));
      if (𝓛8757{Array}.isArray(𝓟415{value}))
      {
        𝓟415{value} ⟵ 𝓟415{value}.join(𝓛8743{String});
      }
    }
    else
    {
      𝓟415{value} ⟵ 𝓟[ty]387{AttributePart}._interpolate(𝓟411{values},𝓟412{startIndex});
    }
    if (𝓟415{value}.ExclamationEqualsEqualsToken(𝓟374{directiveValue}))
    {
      𝓟[ty]387{AttributePart}.element.setAttribute(𝓟[ty]387{AttributePart}.name,𝓟415{value})
    }
    𝓟[ty]387{AttributePart}._previousValues ⟵ 𝓟411{values};
  }
}
function 𝓟416{CONSTRUCTOR} (𝓟417{instance}: [OOV]𝓟[ty]479{TemplateInstance},𝓟418{startNode}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10619{Node}),𝓟419{endNode}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10619{Node})): (𝓟[ty]423{NodePart})
{
  const 𝓟[ty]423{NodePart};
  const 𝓟[ty]423{NodePart};
  𝓟[ty]423{NodePart}.instance ⟵ 𝓟417{instance};
  𝓟[ty]423{NodePart}.startNode ⟵ 𝓟418{startNode};
  𝓟[ty]423{NodePart}.endNode ⟵ 𝓟419{endNode};
  𝓟[ty]423{NodePart}._previousValue ⟵ 𝓛12563{undefined};
}
class 𝓟[ty]423{NodePart} extends 𝓟[ty]1647{SinglePart}{
  𝓟425{instance}: [OOV]𝓟[ty]479{TemplateInstance};
  𝓟426{startNode}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10619{Node});
  𝓟427{endNode}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10619{Node});
  𝓟428{_previousValue}: [OOV]any;
  function 𝓟432{_insert} (𝓟433{node}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10619{Node})): (𝓟434: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]423{NodePart}.endNode.parentNode.insertBefore(𝓟433{node},𝓟[ty]423{NodePart}.endNode)
  }
  function 𝓟463{clear} (𝓟464{startNode}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]10619{Node})): (𝓟465: [miss]𝓛[ty]10033{Void})
  {
    𝓟514{removeNodes}(𝓟[ty]423{NodePart}.startNode.parentNode,𝓟464{startNode}.nextSibling,𝓟[ty]423{NodePart}.endNode)
  }
  function 𝓟438{_setText} (𝓟439{value}: 𝓛[ty]10051{String}): (𝓟440: 𝓛[ty]10033{Void})
  {
    const 𝓟441{node}: [miss]𝓛[ty]10619{Node} = 𝓟[ty]423{NodePart}.startNode.nextSibling;
    𝓟439{value} ⟵ (𝓟439{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}) ? 𝓛8743{String} : 𝓟439{value};
    if (𝓟441{node}.EqualsEqualsEqualsToken(𝓟[ty]423{NodePart}.endNode.previousSibling).AmpersandAmpersandToken(𝓟441{node}.nodeType.EqualsEqualsEqualsToken(𝓛11798{Node}.TEXT_NODE)))
    {
      𝓟441{node}.textContent ⟵ 𝓟439{value};
    }
    else
    {
      𝓟[ty]423{NodePart}._setNode(𝓛12160{document}.createTextNode(𝓟439{value}))
    }
    𝓟[ty]423{NodePart}._previousValue ⟵ 𝓟439{value};
  }
  function 𝓟435{_setNode} (𝓟436{value}: (𝓛[ty]10051{String} ≠ 𝓛[ty]10619{Node})): (𝓟437: 𝓛[ty]10033{Void})
  {
    if (𝓟[ty]423{NodePart}._previousValue.EqualsEqualsEqualsToken(𝓟436{value}))
    {
    }
    𝓟[ty]423{NodePart}.clear()
    𝓟[ty]423{NodePart}._insert(𝓟436{value})
    𝓟[ty]423{NodePart}._previousValue ⟵ 𝓟436{value};
  }
  function 𝓟429{setValue} (𝓟430{value}: [OOV]any): (𝓟431: 𝓛[ty]10033{Void})
  {
    𝓟430{value} ⟵ 𝓟365{getValue}(𝓟[ty]423{NodePart},𝓟430{value});
    if (𝓟430{value}.EqualsEqualsEqualsToken(𝓟374{directiveValue}))
    {
    }
    if (𝓟378{isPrimitiveValue}(𝓟430{value}))
    {
      if (𝓟430{value}.EqualsEqualsEqualsToken(𝓟[ty]423{NodePart}._previousValue))
      {
      }
      𝓟[ty]423{NodePart}._setText(𝓟430{value})
    }
    else
    {
      if (𝓟430{value}.InstanceOfKeyword(𝓛12563{undefined}))
      {
        𝓟[ty]423{NodePart}._setTemplateResult(𝓟430{value})
      }
      else
      {
        if (𝓛8757{Array}.isArray(𝓟430{value}).BarBarToken(𝓟430{value}.access(𝓛10031{Symbol}.iterator)))
        {
          𝓟[ty]423{NodePart}._setIterable(𝓟430{value})
        }
        else
        {
          if (𝓟430{value}.InstanceOfKeyword(𝓛11798{Node}))
          {
            𝓟[ty]423{NodePart}._setNode(𝓟430{value})
          }
          else
          {
            if (𝓟430{value}.then.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
            {
              𝓟[ty]423{NodePart}._setPromise(𝓟430{value})
            }
            else
            {
              𝓟[ty]423{NodePart}._setText(𝓟430{value})
            }
          }
        }
      }
    }
  }
  function 𝓟447{_setIterable} (𝓟448{value}: [OOV]any): (𝓟449: 𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓛8757{Array}.isArray(𝓟[ty]423{NodePart}._previousValue)))
    {
      𝓟[ty]423{NodePart}.clear()
      𝓟[ty]423{NodePart}._previousValue ⟵ 𝓛8757{Array}();
    }
    const 𝓟450{itemParts}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]423{NodePart}._previousValue as 𝓛[ty]8670{Array};
    let 𝓟451{partIndex}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    {
      const 𝓟452{item} = 𝓛12552{$ArrayAccess}(𝓟448{value});
      while (𝓛8744{Boolean})
      {
        let 𝓟453{itemPart} = 𝓟450{itemParts}.access(𝓟451{partIndex});
        if (𝓟453{itemPart}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
        {
          let 𝓟454{itemStart}: [miss]𝓛[ty]10619{Node} = 𝓟[ty]423{NodePart}.startNode;
          if (𝓟451{partIndex}.GreaterThanToken(𝓛8745{Number}))
          {
            const 𝓟455{previousPart} = 𝓟450{itemParts}.access(𝓟451{partIndex}.MinusToken(𝓛8745{Number}));
            𝓟454{itemStart} ⟵ 𝓟455{previousPart}.endNode.FirstAssignment(𝓛12160{document}.createTextNode(𝓛8743{String}));
            𝓟[ty]423{NodePart}._insert(𝓟454{itemStart})
          }
          𝓟453{itemPart} ⟵ 𝓟416{CONSTRUCTOR}(𝓟[ty]423{NodePart}.instance,𝓟454{itemStart},𝓟[ty]423{NodePart}.endNode);
          𝓟450{itemParts}.push(𝓟453{itemPart})
        }
        𝓟453{itemPart}.setValue(𝓟452{item})
        𝓛12546{POST_PlusPlusToken}(𝓟451{partIndex})
      }
    }
    if (𝓟451{partIndex}.EqualsEqualsEqualsToken(𝓛8745{Number}))
    {
      𝓟[ty]423{NodePart}.clear()
      𝓟[ty]423{NodePart}._previousValue ⟵ 𝓛12563{undefined};
    }
    else
    {
      if (𝓟451{partIndex}.FirstBinaryOperator(𝓟450{itemParts}.length))
      {
        const 𝓟456{lastPart} = 𝓟450{itemParts}.access(𝓟451{partIndex}.MinusToken(𝓛8745{Number}));
        𝓟450{itemParts}.length ⟵ 𝓟451{partIndex};
        𝓟[ty]423{NodePart}.clear(𝓟456{lastPart}.endNode.previousSibling)
        𝓟456{lastPart}.endNode ⟵ 𝓟[ty]423{NodePart}.endNode;
      }
    }
  }
  function 𝓟442{_setTemplateResult} (𝓟443{value}: [OOV]𝓟[ty]260{TemplateResult}): (𝓟444: 𝓛[ty]10033{Void})
  {
    const 𝓟445{template}: [OOV]𝓟[ty]357{Template} = 𝓟[ty]423{NodePart}.instance._getTemplate(𝓟443{value});
    let 𝓟446{instance}: [OOV]𝓟[ty]479{TemplateInstance};
    if (𝓟[ty]423{NodePart}._previousValue.AmpersandAmpersandToken(𝓟[ty]423{NodePart}._previousValue.template.EqualsEqualsEqualsToken(𝓟445{template})))
    {
      𝓟446{instance} ⟵ 𝓟[ty]423{NodePart}._previousValue;
    }
    else
    {
      𝓟446{instance} ⟵ 𝓟472{CONSTRUCTOR}(𝓟445{template},𝓟[ty]423{NodePart}.instance._partCallback,𝓟[ty]423{NodePart}.instance._getTemplate);
      𝓟[ty]423{NodePart}._setNode(𝓟446{instance}._clone())
      𝓟[ty]423{NodePart}._previousValue ⟵ 𝓟446{instance};
    }
    𝓟446{instance}.update(𝓟443{value}.values)
  }
  function 𝓟457{_setPromise} (𝓟458{value}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8654{Promise})): (𝓟459: 𝓛[ty]10033{Void})
  {
    𝓟[ty]423{NodePart}._previousValue ⟵ 𝓟458{value};
    function 𝓟460{$Lambda6} (𝓟461{v}: [OOV]any): (𝓟462: [miss]𝓛[ty]10033{Void})
    {
      if (𝓟[ty]423{NodePart}._previousValue.EqualsEqualsEqualsToken(𝓟458{value}))
      {
        𝓟[ty]423{NodePart}.setValue(𝓟461{v})
      }
    }
    𝓟458{value}.then(𝓟460{$Lambda6})
  }
}
function 𝓟466{$Lambda7} (𝓟467{instance}: [OOV]𝓟[ty]479{TemplateInstance},𝓟468{templatePart}: [OOV]𝓟[ty]321{TemplatePart},𝓟469{node}: (𝓛[ty]10921{HTMLElement} ≠ 𝓛[ty]10619{Node})): (𝓟470: [OOV]𝓟[ty]1641{Part})
{
  if (𝓟468{templatePart}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    return 𝓟470 = 𝓟379{CONSTRUCTOR}(𝓟467{instance},𝓟469{node} as 𝓛[ty]10661{Element},𝓟468{templatePart}.name,𝓟468{templatePart}.strings)
  }
  else
  {
    if (𝓟468{templatePart}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      return 𝓟470 = 𝓟416{CONSTRUCTOR}(𝓟467{instance},𝓟469{node},𝓟469{node}.nextSibling)
    }
  }
  𝓛8749{Error}.CONSTRUCTOR(𝓛12554{$Template}(𝓟468{templatePart}.type))
}
const 𝓟471{defaultPartCallback}: [miss]𝓛[ty]8696{Function} = 𝓟466{$Lambda7};
function 𝓟472{CONSTRUCTOR} (𝓟473{template}: [OOV]𝓟[ty]357{Template},𝓟474{partCallback}: [OOV]𝓟[ty]1642{PartCallback},𝓟475{getTemplate}: [OOV]𝓟[ty]1640{TemplateFactory}): (𝓟[ty]479{TemplateInstance})
{
  const 𝓟[ty]479{TemplateInstance};
  const 𝓟[ty]479{TemplateInstance};
  𝓟[ty]479{TemplateInstance}._parts ⟵ 𝓛8757{Array}();
  𝓟[ty]479{TemplateInstance}.template ⟵ 𝓟473{template};
  𝓟[ty]479{TemplateInstance}._partCallback ⟵ 𝓟474{partCallback};
  𝓟[ty]479{TemplateInstance}._getTemplate ⟵ 𝓟475{getTemplate};
}
class 𝓟[ty]479{TemplateInstance}{
  𝓟481{_parts}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
  𝓟482{_partCallback}: [OOV]𝓟[ty]1642{PartCallback};
  𝓟483{_getTemplate}: [OOV]𝓟[ty]1640{TemplateFactory};
  𝓟484{template}: [OOV]𝓟[ty]357{Template};
  function 𝓟485{update} (𝓟486{values}: 𝓛[ty]8670{Array}): (𝓟487: [miss]𝓛[ty]10033{Void})
  {
    let 𝓟488{valueIndex}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    {
      const 𝓟489{part}: [OOV]𝓟[ty]1641{Part} = 𝓛12552{$ArrayAccess}(𝓟[ty]479{TemplateInstance}._parts);
      while (𝓛8744{Boolean})
      {
        if (𝓟489{part}.size.EqualsEqualsEqualsToken(𝓛12563{undefined}))
        {
          𝓟489{part} as 𝓟[ty]1647{SinglePart}.setValue(𝓟486{values}.access(𝓟488{valueIndex}))
          𝓛12546{POST_PlusPlusToken}(𝓟488{valueIndex})
        }
        else
        {
          𝓟489{part} as 𝓟[ty]1649{MultiPart}.setValue(𝓟486{values},𝓟488{valueIndex})
          𝓟488{valueIndex}.FirstCompoundAssignment(𝓟489{part}.size)
        }
      }
    }
  }
  function 𝓟490{_clone} (): (𝓟491: [OOV]𝓛[ty]11362{DocumentFragment})
  {
    const 𝓟492{fragment}: [OOV]𝓛[ty]11362{DocumentFragment} = 𝓛12160{document}.importNode(𝓟[ty]479{TemplateInstance}.template.element.content,𝓛8744{Boolean});
    const 𝓟493{parts}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]479{TemplateInstance}.template.parts;
    if (𝓟493{parts}.length.GreaterThanToken(𝓛8745{Number}))
    {
      const 𝓟494{walker}: [OOV]𝓛[ty]10402{TreeWalker} = 𝓛12160{document}.createTreeWalker(𝓟492{fragment},𝓛8745{Number},𝓛12563{undefined} as any,𝓛8744{Boolean});
      let 𝓟495{index}: [miss]𝓛[ty]8655{Number} = 𝓛12557{MinusToken}(𝓛8745{Number});
      {
        let 𝓟496{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
        while (𝓟496{i}.FirstBinaryOperator(𝓟493{parts}.length))
        {
          {
            const 𝓟497{part}: [OOV]𝓟[ty]321{TemplatePart} = 𝓟493{parts}.access(𝓟496{i});
            while (𝓟495{index}.FirstBinaryOperator(𝓟497{part}.index))
            {
              𝓛12546{POST_PlusPlusToken}(𝓟495{index})
              𝓟494{walker}.nextNode()
            }
            𝓟[ty]479{TemplateInstance}._parts.push(𝓟[ty]479{TemplateInstance}._partCallback(𝓟[ty]479{TemplateInstance},𝓟497{part},𝓟494{walker}.currentNode))
          }
          𝓛12546{POST_PlusPlusToken}(𝓟496{i})
        }
      }
    }
    return 𝓟491 = 𝓟492{fragment}
  }
}
function 𝓟498{$Lambda8} (𝓟499{container}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]10619{Node}),𝓟500{start}: [OOV]any,𝓟501{end}: [OOV]any,𝓟502{before}: [OOV]any): (𝓟503: 𝓛[ty]10033{Void})
{
  let 𝓟504{node}: [miss]𝓛[ty]10619{Node} = 𝓟500{start};
  while (𝓟504{node}.ExclamationEqualsEqualsToken(𝓟501{end}))
  {
    const 𝓟505{n}: [miss]𝓛[ty]10619{Node} = 𝓟504{node}.nextSibling;
    𝓟499{container}.insertBefore(𝓟504{node},𝓟502{before} as 𝓛[ty]10619{Node})
    𝓟504{node} ⟵ 𝓟505{n};
  }
}
const 𝓟506{reparentNodes}: [miss]𝓛[ty]8696{Function} = 𝓟498{$Lambda8};
function 𝓟507{$Lambda9} (𝓟508{container}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]10619{Node}),𝓟509{startNode}: [OOV]any,𝓟510{endNode}: [OOV]any): (𝓟511: 𝓛[ty]10033{Void})
{
  let 𝓟512{node}: [miss]𝓛[ty]10619{Node} = 𝓟509{startNode};
  while (𝓟512{node}.ExclamationEqualsEqualsToken(𝓟510{endNode}))
  {
    const 𝓟513{n}: [miss]𝓛[ty]10619{Node} = 𝓟512{node}.nextSibling;
    𝓟508{container}.removeChild(𝓟512{node})
    𝓟512{node} ⟵ 𝓟513{n};
  }
}
const 𝓟514{removeNodes}: [miss]𝓛[ty]8696{Function} = 𝓟507{$Lambda9};

LibAcc: 0.5534=57/103, ProjAcc: 1.0000=0/0, Missing: 247

Module: src/lib/shady-render

Module: src/lib/lit-extended

Module: tools/src/site

Module: src/lib/repeat

Module: src/lib/until

Module: src/lit-html

Module: tools/src/serve-site

Module: src/lib/unsafe-html

Module: src/lib/async-replace

Module: src/lib/async-append