{#if editComment && state !== "read"}

      {@const editComment_ = editComment}

      <ExtendedTextarea

        {body}

        {enableAttachments}

        submitInProgress={state === "submit"}

  export let body: string | undefined = undefined;

  export let placeholder: string | undefined = undefined;

  export let submitCaption: string | undefined = undefined;

  export let enableAttachments: boolean = false;

  export let inline: boolean = false;

  export let focus: boolean = false;

{#if state !== "collapsed"}

  <ExtendedTextarea

    {inline}

    {placeholder}

    {submitCaption}

  export let submitCaption: string = "Comment";

  export let focus: boolean = false;

  export let inline: boolean = false;

  export let body: string = "";

  export let submitInProgress: boolean = false;

  </Radio>

  {#if preview}

    <div class="preview">

    </div>

  {:else}

    <input

  // If present, resolve all relative links with respect to this URL

  export let linkBaseUrl: string | undefined = undefined;

  export let path: string = "/";

  // If present, means we are in a preview context,

  // use this for image previews instead of /raw URLs.

  export let embeds: EmbedWithOid[] | undefined = undefined;

  {#if createReply}

    <div id={`reply-${root.id}`} class="reply">

      <CommentToggleInput

        inline

        placeholder="Reply to comment"

        on:click={toggleReply}

import md5 from "md5";

import bs58 from "bs58";

import twemojiModule from "twemoji";

  await navigator.clipboard.writeText(text);

}

export function formatLocationHash(hash: string | null): number | null {

  if (hash && hash.match(/^#L[0-9]+$/)) return parseInt(hash.slice(2));

  return null;

  export let baseUrl: BaseUrl;

  export let expanded: boolean = false;

  export let patchId: string;

  export let patchState: PatchState;

  export let projectHead: string;

          {#if revisionDescription && !first}

            <div class="revision-description txt-small">

              <Markdown

                content={revisionDescription} />

            </div>

          {/if}

          <div class="connector" />

          <Thread

            enableAttachments

            thread={element.inner}

            {canEditComment}

            {editComment}

            {createReply}

            class:positive-review={review.verdict === "accept"}

            class:negative-review={review.verdict === "reject"}>

            <CommentComponent

              caption={formatVerdict(review.verdict)}

              authorId={author}

              authorAlias={review.author.alias}

              timestamp={review.timestamp}

              body={review.summary ?? ""}>

              <div slot="icon" style:color={verdictIconColor(review.verdict)}>

                {#if review.verdict === "accept"}

  export let baseUrl: BaseUrl;

  export let issue: Issue;

  export let project: Project;

  export let tracking: boolean;

  const api = new HttpdClient(baseUrl);

  const items: [string, IssueState][] = [

        <div slot="description">

          {#if issueState !== "read"}

            <ExtendedTextarea

              enableAttachments

              body={issue.discussion[0].body}

              submitCaption="Save"

            <div class="markdown">

              <Markdown

                content={issue.discussion[0].body}

            </div>

          {/if}

          <div class="reactions">

            <ThreadComponent

              enableAttachments

              {thread}

              canEditComment={partial(

                role.isDelegateOrAuthor,

                session?.publicKey,

      {/if}

      {#if session}

        <CommentToggleInput

          placeholder="Leave your comment"

          enableAttachments

          submit={partial(createComment, session.id)} />

  export let baseUrl: BaseUrl;

  export let project: Project;

  export let tracking: boolean;

  let newEmbeds: EmbedWithOid[] = [];

              {:else if !issueText}

                <p class="txt-missing">No description</p>

              {:else}

              {/if}

            </svelte:fragment>

            <div class="author" slot="author">

  export let baseUrl: BaseUrl;

  export let patch: Patch;

  export let project: Project;

  export let view: PatchView;

  export let tracking: boolean;

          <div class="revision-description">

            {#if session && patchState !== "read"}

              <ExtendedTextarea

                body={newDescription}

                submitCaption="Save"

                submitInProgress={patchState === "submit"}

            {:else if description}

              <Markdown

                content={description}

            {:else}

              <span class="txt-missing">No description available</span>

            {/if}

            index > 0 ? patch.revisions[index - 1] : undefined}

          <RevisionComponent

            {baseUrl}

            projectId={project.id}

            {timelines}

            projectDefaultBranch={project.defaultBranch}

              {#if session && view.name === "activity"}

                <div class="connector" />

                <CommentToggleInput

                  enableAttachments

                  placeholder="Leave your comment"

                  submit={partial(

  import type { BlobResult } from "./router";

  import type { Route } from "@app/lib/router";

  import { HttpdClient } from "@httpd-client";

  import Button from "@app/components/Button.svelte";

  import FilePath from "@app/components/FilePath.svelte";

  export let baseUrl: BaseUrl;

  export let blobResult: BlobResult;

  export let branches: string[];

  export let path: string;

            {path}

            blob={blobResult.blob}

            highlighted={blobResult.highlighted}

        {:else}

          <File>

            <FilePath

        revision: string | undefined;

        tree: Tree;

        path: string;

        blobResult: BlobResult;

        tracking: boolean;

      };

      params: {

        baseUrl: BaseUrl;

        project: Project;

        issue: Issue;

        tracking: boolean;

      };

      params: {

        baseUrl: BaseUrl;

        project: Project;

        tracking: boolean;

      };

    }

      params: {

        baseUrl: BaseUrl;

        project: Project;

        patch: Patch;

        view: PatchView;

        tracking: boolean;

  route: ProjectRoute,

): Promise<ProjectLoadedRoute | LoadErrorRoute | NotFoundRoute> {

  const api = new HttpdClient(route.node);

  try {

    if (route.resource === "project.source") {

        params: {

          baseUrl: route.node,

          project,

          issue,

          tracking,

        },

        params: {

          baseUrl: route.node,

          project,

          tracking,

        },

      };

  route: ProjectTreeRoute,

): Promise<ProjectLoadedRoute> {

  const api = new HttpdClient(route.node);

  const [project, peers, branchMap, tracking] = await Promise.all([

    api.project.getById(route.project),

      peers,

      peer: route.peer,

      branches: Object.keys(branchMap || {}),

      revision: route.revision,

      tree,

      path,

  route: ProjectPatchRoute,

): Promise<ProjectLoadedRoute> {

  const api = new HttpdClient(route.node);

  const [project, patch, tracking] = await Promise.all([

    api.project.getById(route.project),

    api.project.getPatchById(route.project, route.patch),

    params: {

      baseUrl: route.node,

      project,

      patch,

      view,

      tracking,