From 8135bf19a683c5ae46d7f5ce7ed6e2476e4492eb Mon Sep 17 00:00:00 2001 From: linguist <22963968+lowlighter@users.noreply.github.com> Date: Mon, 28 Dec 2020 01:25:40 +0100 Subject: [PATCH] Hotfix missing variable declaration in music plugin --- action/dist/index.js | 2 +- src/plugins/music/index.mjs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/action/dist/index.js b/action/dist/index.js index 68838958..9d1d697d 100644 --- a/action/dist/index.js +++ b/action/dist/index.js @@ -1,4 +1,4 @@ -module.exports=(()=>{var _Mathhypot=Math.hypot,_Mathacos=Math.acos,_Mathtan=Math.tan,_Mathasin=Math.asin,_Mathsin=Math.sin,_Mathcos=Math.cos,_MathPI=Math.PI,_Mathsqrt=Math.sqrt,_NumberisInteger=Number.isInteger,_NumberPOSITIVE_INFINITY=Number.POSITIVE_INFINITY,_NumberNEGATIVE_INFINITY=Number.NEGATIVE_INFINITY,_Stringprototype=String.prototype,_NumberMAX_SAFE_INTEGER=Number.MAX_SAFE_INTEGER,_StringfromCharCode=String.fromCharCode,_Mathabs=Math.abs,_Mathpow=Math.pow,_Mathround=Math.round,_Mathfloor=Math.floor,_Mathceil=Math.ceil,_Mathmax=Math.max,_Mathmin=Math.min;function __webpack_require__(e){if(__webpack_module_cache__[e])return __webpack_module_cache__[e].exports;var t=__webpack_module_cache__[e]={exports:{}},r=!0;try{__webpack_modules__[e].call(t.exports,t,t.exports,__webpack_require__),r=!1}finally{r&&delete __webpack_module_cache__[e]}return t.exports}var __webpack_modules__={45274:(e,t,r)=>{"use strict";async function n({log:e=!0}={}){const t=e?console.debug:()=>null;t(`metrics/setup > setup`);const n="src/templates",a={templates:{},settings:{},statics:r.ab+"html",node_modules:b.resolve("node_modules")};if(t(`metrics/setup > load settings.json`),y.existsSync(r.ab+"settings.json")?(a.settings=JSON.parse(`${await y.promises.readFile(b.resolve("settings.json"))}`),t(`metrics/setup > load settings.json > success`)):t(`metrics/setup > load settings.json > (missing)`),a.settings.templates||(a.settings.templates={default:"classic",enabled:[]}),a.settings.plugins||(a.settings.plugins={}),a.settings.plugins.base={parts:["header","activity","community","repositories","metadata"]},a.settings.debug&&t(S.inspect(a.settings,{depth:1/0,maxStringLength:256})),t(`metrics/setup > load package.json`),y.existsSync(r.ab+"package.json")?(a.package=JSON.parse(`${await y.promises.readFile(b.resolve("package.json"))}`),t(`metrics/setup > load package.json > success`)):(t(`metrics/setup > load package.json > (missing)`),a.package={version:"2.9.0",author:"lowlighter"}),y.existsSync(r.ab+"templates"))for(const e of await y.promises.readdir(n)){if(/.*[.]mjs$/.test(e))continue;t(`metrics/setup > load template [${e}]`);const r=[`${n}/${e}/query.graphql`,`${n}/${e}/image.svg`,`${n}/${e}/style.css`,`${n}/${e}/fonts.css`],[o,i,s,l]=await Promise.all(r.map(async e=>`${await y.promises.readFile(b.resolve(e))}`));a.templates[e]={query:o,image:i,style:s,fonts:l},t(`metrics/setup > load template [${e}] > success`),a.settings.debug&&Object.defineProperty(a.templates,e,{get(){t(`metrics/setup > reload template [${e}]`);const[n,a,o,i]=r.map(e=>`${y.readFileSync(b.resolve(e))}`);return t(`metrics/setup > reload template [${e}] > success`),{query:n,image:a,style:o,fonts:i}}})}else t(`metrics/setup > load templates from build`),a.templates=JSON.parse(Buffer.from(`{"classic":{"query":"query Metrics {\r\n  user(login: $login) {\r\n    databaseId\r\n    name\r\n    login\r\n    createdAt\r\n    avatarUrl\r\n    websiteUrl\r\n    isHireable\r\n    twitterUsername\r\n    gists {\r\n      totalCount\r\n    }\r\n    repositories(last: $repositories, isFork: false, ownerAffiliations: OWNER) {\r\n      totalCount\r\n      totalDiskUsage\r\n      nodes {\r\n        name\r\n        watchers {\r\n          totalCount\r\n        }\r\n        stargazers {\r\n          totalCount\r\n        }\r\n        languages(first: 4) {\r\n          edges {\r\n            size\r\n            node {\r\n              color\r\n              name\r\n            }\r\n          }\r\n        }\r\n        issues_open: issues(states: OPEN) {\r\n          totalCount\r\n        }\r\n        issues_closed: issues(states: CLOSED) {\r\n          totalCount\r\n        }\r\n        pr_open: pullRequests(states: OPEN) {\r\n          totalCount\r\n        }\r\n        pr_merged: pullRequests(states: MERGED) {\r\n          totalCount\r\n        }\r\n        releases {\r\n          totalCount\r\n        }\r\n        forkCount\r\n        licenseInfo {\r\n          spdxId\r\n        }\r\n      }\r\n    }\r\n    packages {\r\n      totalCount\r\n    }\r\n    starredRepositories {\r\n      totalCount\r\n    }\r\n    watching {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsSponsor {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsMaintainer {\r\n      totalCount\r\n    }\r\n    contributionsCollection {\r\n      totalRepositoriesWithContributedCommits\r\n      totalCommitContributions\r\n      restrictedContributionsCount\r\n      totalIssueContributions\r\n      totalPullRequestContributions\r\n      totalPullRequestReviewContributions\r\n    }\r\n    calendar:contributionsCollection(from: $calendar.from, to: $calendar.to) {\r\n      contributionCalendar {\r\n        weeks {\r\n          contributionDays {\r\n            color\r\n          }\r\n        }\r\n      }\r\n    }\r\n    repositoriesContributedTo {\r\n      totalCount\r\n    }\r\n    followers {\r\n      totalCount\r\n    }\r\n    following {\r\n      totalCount\r\n    }\r\n    issueComments {\r\n      totalCount\r\n    }\r\n    organizations {\r\n      totalCount\r\n    }\r\n  }\r\n}\r\n","image":"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"480\" height=\"<%= 12\r\n  + (!!base.header)*80 + (user.isHireable)*16\r\n  + (!!base.metadata)*38\r\n  + ((!!base.activity)||(!!base.community))*128\r\n  + (!!base.repositories)*108\r\n  + ((!!base.repositories)*((!!plugins.traffic)||(!!plugins.lines)))*16\r\n  + (!!plugins.followup)*68\r\n  + (!!plugins.pagespeed)*126 + (plugins.pagespeed?.detailed ?? 0)*6*20\r\n  + (!!plugins.habits)*28 + (!!plugins.habits?.facts)*58 + (!!plugins.habits?.charts)*226\r\n  + (!!plugins.languages)*96\r\n  + (!!plugins.music)*64 + (plugins.music?.tracks?.length ? 14+Math.max(0, plugins.music.tracks.length-1)*36 : 0)\r\n  + (!!plugins.posts)*64 + (plugins.posts?.list?.length ?? 0)*40\r\n  + (!!plugins.isocalendar)*192 + (plugins.isocalendar?.duration === 'full-year')*100\r\n  + (!!plugins.gists)*68\r\n  + (!!plugins.topics)*160\r\n  + (!!plugins.projects)*22 + (plugins.projects?.list?.length ?? 0)*60 + (!!plugins.projects?.error)*22\r\n  + (!!plugins.tweets)*64 + (plugins.tweets?.list?.length ?? 0)*90\r\n  + Math.max(0, (((!!base.metadata)+(!!base.header)+((!!base.activity)||(!!base.community))+(!!base.repositories)+((!!plugins.habits))+(!!plugins.pagespeed)+(!!plugins.languages)+(!!plugins.music)+(!!plugins.posts)+(!!plugins.isocalendar)+(!!plugins.gists)+(!!plugins.topics)+(!!plugins.projects))-1))*4\r\n%>\">\r\n\r\n  <defs><style><%= fonts %></style></defs>\r\n\r\n  <style>\r\n    <%= style %>\r\n  </style>\r\n\r\n  <foreignObject x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\r\n    <div xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n\r\n      <% if (base.header) { %>\r\n        <section>\r\n          <h1 class=\"field\">\r\n            <img class=\"avatar\" src=\"data:image/png;base64,<%= computed.avatar %>\" width=\"20\" height=\"20\" />\r\n            <span><%= user.name || user.login %></span>\r\n          </h1>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field <%= computed.cakeday ? 'cakeday' : '' %>\">\r\n                <% if (computed.cakeday) { %>\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 1.5a1.25 1.25 0 100 2.5h2.309c-.233-.818-.542-1.401-.878-1.793-.43-.502-.915-.707-1.431-.707zM2 2.75c0 .45.108.875.3 1.25h-.55A1.75 1.75 0 000 5.75v2c0 .698.409 1.3 1 1.582v4.918c0 .966.784 1.75 1.75 1.75h10.5A1.75 1.75 0 0015 14.25V9.332c.591-.281 1-.884 1-1.582v-2A1.75 1.75 0 0014.25 4h-.55a2.75 2.75 0 00-2.45-4c-.984 0-1.874.42-2.57 1.23A5.086 5.086 0 008 2.274a5.086 5.086 0 00-.68-1.042C6.623.42 5.733 0 4.75 0A2.75 2.75 0 002 2.75zM8.941 4h2.309a1.25 1.25 0 100-2.5c-.516 0-1 .205-1.43.707-.337.392-.646.975-.879 1.793zm-1.84 1.5H1.75a.25.25 0 00-.25.25v2c0 .138.112.25.25.25h5.5V5.5h-.149zm1.649 0V8h5.5a.25.25 0 00.25-.25v-2a.25.25 0 00-.25-.25h-5.5zm0 4h4.75v4.75a.25.25 0 01-.25.25h-4.5v-5zm-1.5 0v5h-4.5a.25.25 0 01-.25-.25V9.5h4.75z\"></path></svg>\r\n                  Joined GitHub <%= computed.registration %>\r\n                <% } else { %>\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm.5 4.75a.75.75 0 00-1.5 0v3.5a.75.75 0 00.471.696l2.5 1a.75.75 0 00.557-1.392L8.5 7.742V4.75z\"></path></svg>\r\n                  Joined GitHub <%= computed.registration %>\r\n                <% } %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.5 3.5a2 2 0 100 4 2 2 0 000-4zM2 5.5a3.5 3.5 0 115.898 2.549 5.507 5.507 0 013.034 4.084.75.75 0 11-1.482.235 4.001 4.001 0 00-7.9 0 .75.75 0 01-1.482-.236A5.507 5.507 0 013.102 8.05 3.49 3.49 0 012 5.5zM11 4a.75.75 0 100 1.5 1.5 1.5 0 01.666 2.844.75.75 0 00-.416.672v.352a.75.75 0 00.574.73c1.2.289 2.162 1.2 2.522 2.372a.75.75 0 101.434-.44 5.01 5.01 0 00-2.56-3.012A3 3 0 0011 4z\"></path></svg>\r\n                Followed by <%= user.followers.totalCount %> user<%= s(user.followers.totalCount) %>\r\n              </div>\r\n              <% if (user.isHireable) { %>\r\n                <div class=\"field hire\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M6.75 0A1.75 1.75 0 005 1.75V3H1.75A1.75 1.75 0 000 4.75v8.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0016 13.25v-8.5A1.75 1.75 0 0014.25 3H11V1.75A1.75 1.75 0 009.25 0h-2.5zM9.5 3V1.75a.25.25 0 00-.25-.25h-2.5a.25.25 0 00-.25.25V3h3zM5 4.5H1.75a.25.25 0 00-.25.25V6a2 2 0 002 2h9a2 2 0 002-2V4.75a.25.25 0 00-.25-.25H5zm-1.5 5a3.484 3.484 0 01-2-.627v4.377c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25V8.873a3.484 3.484 0 01-2 .627h-9z\"></path></svg>\r\n                  Available for hire !\r\n                </div>\r\n              <% } %>\r\n            </section>\r\n            <section>\r\n              <div class=\"field calendar\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 <%= computed.calendar.length*15 %> 11\" width=\"<%= computed.calendar.length*15 %>\" height=\"16\">\r\n                  <g>\r\n                    <% for (const [x, {color}] of Object.entries(computed.calendar)) { %>\r\n                      <rect class=\"day\" x=\"<%= x*15 %>\" y=\"0\" width=\"11\" height=\"11\" fill=\"<%= color %>\" rx=\"2\" ry=\"2\" />\r\n                    <% } %>\r\n                  </g>\r\n                </svg>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1 2.5A2.5 2.5 0 013.5 0h8.75a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0V1.5h-8a1 1 0 00-1 1v6.708A2.492 2.492 0 013.5 9h3.25a.75.75 0 010 1.5H3.5a1 1 0 100 2h5.75a.75.75 0 010 1.5H3.5A2.5 2.5 0 011 11.5v-9zm13.23 7.79a.75.75 0 001.06-1.06l-2.505-2.505a.75.75 0 00-1.06 0L9.22 9.229a.75.75 0 001.06 1.061l1.225-1.224v6.184a.75.75 0 001.5 0V9.066l1.224 1.224z\"></path></svg>\r\n                Contributed to <%= user.repositoriesContributedTo.totalCount %> repositor<%= s(user.repositoriesContributedTo.totalCount, \"y\") %>\r\n              </div>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <div class=\"row\">\r\n        <% if (base.activity) { %>\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 1.75a.75.75 0 00-1.5 0v12.5c0 .414.336.75.75.75h14.5a.75.75 0 000-1.5H1.5V1.75zm14.28 2.53a.75.75 0 00-1.06-1.06L10 7.94 7.53 5.47a.75.75 0 00-1.06 0L3.22 8.72a.75.75 0 001.06 1.06L7 7.06l2.47 2.47a.75.75 0 001.06 0l5.25-5.25z\"></path></svg>\r\n              Activity\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M10.5 7.75a2.5 2.5 0 11-5 0 2.5 2.5 0 015 0zm1.43.75a4.002 4.002 0 01-7.86 0H.75a.75.75 0 110-1.5h3.32a4.001 4.001 0 017.86 0h3.32a.75.75 0 110 1.5h-3.32z\"></path></svg>\r\n              <%= computed.commits %> Commit<%= s(computed.commits) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 1.75a.25.25 0 01.25-.25h8.5a.25.25 0 01.25.25v7.736a.75.75 0 101.5 0V1.75A1.75 1.75 0 0011.25 0h-8.5A1.75 1.75 0 001 1.75v11.5c0 .966.784 1.75 1.75 1.75h3.17a.75.75 0 000-1.5H2.75a.25.25 0 01-.25-.25V1.75zM4.75 4a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5zM4 7.75A.75.75 0 014.75 7h2a.75.75 0 010 1.5h-2A.75.75 0 014 7.75zm11.774 3.537a.75.75 0 00-1.048-1.074L10.7 14.145 9.281 12.72a.75.75 0 00-1.062 1.058l1.943 1.95a.75.75 0 001.055.008l4.557-4.45z\"></path></svg>\r\n              <%= user.contributionsCollection.totalPullRequestReviewContributions %> Pull request<%= s(user.contributionsCollection.totalPullRequestReviewContributions) %> reviewed\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.177 3.073L9.573.677A.25.25 0 0110 .854v4.792a.25.25 0 01-.427.177L7.177 3.427a.25.25 0 010-.354zM3.75 2.5a.75.75 0 100 1.5.75.75 0 000-1.5zm-2.25.75a2.25 2.25 0 113 2.122v5.256a2.251 2.251 0 11-1.5 0V5.372A2.25 2.25 0 011.5 3.25zM11 2.5h-1V4h1a1 1 0 011 1v5.628a2.251 2.251 0 101.5 0V5A2.5 2.5 0 0011 2.5zm1 10.25a.75.75 0 111.5 0 .75.75 0 01-1.5 0zM3.75 12a.75.75 0 100 1.5.75.75 0 000-1.5z\"></path></svg>\r\n              <%= user.contributionsCollection.totalPullRequestContributions %> Pull request<%= s(user.contributionsCollection.totalPullRequestContributions) %> opened\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n              <%= user.contributionsCollection.totalIssueContributions %> Issue<%= s(user.contributionsCollection.totalIssueContributions) %> opened\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.75 2.5a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h4.5a.25.25 0 00.25-.25v-7.5a.25.25 0 00-.25-.25H2.75zM1 2.75C1 1.784 1.784 1 2.75 1h10.5c.966 0 1.75.784 1.75 1.75v7.5A1.75 1.75 0 0113.25 12H9.06l-2.573 2.573A1.457 1.457 0 014 13.543V12H2.75A1.75 1.75 0 011 10.25v-7.5z\"></path></svg>\r\n              <%= user.issueComments.totalCount %> issue comment<%= s(user.issueComments.totalCount) %>\r\n            </div>\r\n          </section>\r\n        <% } %>\r\n        <% if (base.community) { %>\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.326 1.973a1.2 1.2 0 011.49-.832c.387.112.977.307 1.575.602.586.291 1.243.71 1.7 1.296.022.027.042.056.061.084A13.22 13.22 0 018 3c.67 0 1.289.037 1.861.108l.051-.07c.457-.586 1.114-1.004 1.7-1.295a9.654 9.654 0 011.576-.602 1.2 1.2 0 011.49.832c.14.493.356 1.347.479 2.29.079.604.123 1.28.07 1.936.541.977.773 2.11.773 3.301C16 13 14.5 15 8 15s-8-2-8-5.5c0-1.034.238-2.128.795-3.117-.08-.712-.034-1.46.052-2.12.122-.943.34-1.797.479-2.29zM8 13.065c6 0 6.5-2 6-4.27C13.363 5.905 11.25 5 8 5s-5.363.904-6 3.796c-.5 2.27 0 4.27 6 4.27z\"></path><path d=\"M4 8a1 1 0 012 0v1a1 1 0 01-2 0V8zm2.078 2.492c-.083-.264.146-.492.422-.492h3c.276 0 .505.228.422.492C9.67 11.304 8.834 12 8 12c-.834 0-1.669-.696-1.922-1.508zM10 8a1 1 0 112 0v1a1 1 0 11-2 0V8z\"></path></svg>              Community stats\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 14.25c0 .138.112.25.25.25H4v-1.25a.75.75 0 01.75-.75h2.5a.75.75 0 01.75.75v1.25h2.25a.25.25 0 00.25-.25V1.75a.25.25 0 00-.25-.25h-8.5a.25.25 0 00-.25.25v12.5zM1.75 16A1.75 1.75 0 010 14.25V1.75C0 .784.784 0 1.75 0h8.5C11.216 0 12 .784 12 1.75v12.5c0 .085-.006.168-.018.25h2.268a.25.25 0 00.25-.25V8.285a.25.25 0 00-.111-.208l-1.055-.703a.75.75 0 11.832-1.248l1.055.703c.487.325.779.871.779 1.456v5.965A1.75 1.75 0 0114.25 16h-3.5a.75.75 0 01-.197-.026c-.099.017-.2.026-.303.026h-3a.75.75 0 01-.75-.75V14h-1v1.25a.75.75 0 01-.75.75h-3zM3 3.75A.75.75 0 013.75 3h.5a.75.75 0 010 1.5h-.5A.75.75 0 013 3.75zM3.75 6a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM3 9.75A.75.75 0 013.75 9h.5a.75.75 0 010 1.5h-.5A.75.75 0 013 9.75zM7.75 9a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM7 6.75A.75.75 0 017.75 6h.5a.75.75 0 010 1.5h-.5A.75.75 0 017 6.75zM7.75 3a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5z\"></path></svg>\r\n              Member of <%= user.organizations.totalCount %> organization<%= s(user.organizations.totalCount) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.5 3.5a2 2 0 100 4 2 2 0 000-4zM2 5.5a3.5 3.5 0 115.898 2.549 5.507 5.507 0 013.034 4.084.75.75 0 11-1.482.235 4.001 4.001 0 00-7.9 0 .75.75 0 01-1.482-.236A5.507 5.507 0 013.102 8.05 3.49 3.49 0 012 5.5zM11 4a.75.75 0 100 1.5 1.5 1.5 0 01.666 2.844.75.75 0 00-.416.672v.352a.75.75 0 00.574.73c1.2.289 2.162 1.2 2.522 2.372a.75.75 0 101.434-.44 5.01 5.01 0 00-2.56-3.012A3 3 0 0011 4z\"></path></svg>\r\n              Following <%= user.following.totalCount %> user<%= s(user.followers.totalCount) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.25 2.5c-1.336 0-2.75 1.164-2.75 3 0 2.15 1.58 4.144 3.365 5.682A20.565 20.565 0 008 13.393a20.561 20.561 0 003.135-2.211C12.92 9.644 14.5 7.65 14.5 5.5c0-1.836-1.414-3-2.75-3-1.373 0-2.609.986-3.029 2.456a.75.75 0 01-1.442 0C6.859 3.486 5.623 2.5 4.25 2.5zM8 14.25l-.345.666-.002-.001-.006-.003-.018-.01a7.643 7.643 0 01-.31-.17 22.075 22.075 0 01-3.434-2.414C2.045 10.731 0 8.35 0 5.5 0 2.836 2.086 1 4.25 1 5.797 1 7.153 1.802 8 3.02 8.847 1.802 10.203 1 11.75 1 13.914 1 16 2.836 16 5.5c0 2.85-2.045 5.231-3.885 6.818a22.08 22.08 0 01-3.744 2.584l-.018.01-.006.003h-.002L8 14.25zm0 0l.345.666a.752.752 0 01-.69 0L8 14.25z\"></path></svg>\r\n              Sponsoring <%= user.sponsorshipsAsSponsor.totalCount %> repositor<%= s(user.sponsorshipsAsSponsor.totalCount, \"y\") %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n              Starred <%= user.starredRepositories.totalCount %> repositor<%= s(user.starredRepositories.totalCount, \"y\") %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.679 7.932c.412-.621 1.242-1.75 2.366-2.717C5.175 4.242 6.527 3.5 8 3.5c1.473 0 2.824.742 3.955 1.715 1.124.967 1.954 2.096 2.366 2.717a.119.119 0 010 .136c-.412.621-1.242 1.75-2.366 2.717C10.825 11.758 9.473 12.5 8 12.5c-1.473 0-2.824-.742-3.955-1.715C2.92 9.818 2.09 8.69 1.679 8.068a.119.119 0 010-.136zM8 2c-1.981 0-3.67.992-4.933 2.078C1.797 5.169.88 6.423.43 7.1a1.619 1.619 0 000 1.798c.45.678 1.367 1.932 2.637 3.024C4.329 13.008 6.019 14 8 14c1.981 0 3.67-.992 4.933-2.078 1.27-1.091 2.187-2.345 2.637-3.023a1.619 1.619 0 000-1.798c-.45-.678-1.367-1.932-2.637-3.023C11.671 2.992 9.981 2 8 2zm0 8a2 2 0 100-4 2 2 0 000 4z\"></path></svg>\r\n              Watching <%= user.watching.totalCount %> repositor<%= s(user.watching.totalCount, \"y\") %>\r\n            </div>\r\n          </section>\r\n        <% } %>\r\n      </div>\r\n\r\n      <% if (base.repositories) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2 2.5A2.5 2.5 0 014.5 0h8.75a.75.75 0 01.75.75v12.5a.75.75 0 01-.75.75h-2.5a.75.75 0 110-1.5h1.75v-2h-8a1 1 0 00-.714 1.7.75.75 0 01-1.072 1.05A2.495 2.495 0 012 11.5v-9zm10.5-1V9h-8c-.356 0-.694.074-1 .208V2.5a1 1 0 011-1h8zM5 12.25v3.25a.25.25 0 00.4.2l1.45-1.087a.25.25 0 01.3 0L8.6 15.7a.25.25 0 00.4-.2v-3.25a.25.25 0 00-.25-.25h-3.5a.25.25 0 00-.25.25z\"></path></svg>\r\n            <%= user.repositories.totalCount %> Repositor<%= s(user.repositories.totalCount, \"y\") %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8.75.75a.75.75 0 00-1.5 0V2h-.984c-.305 0-.604.08-.869.23l-1.288.737A.25.25 0 013.984 3H1.75a.75.75 0 000 1.5h.428L.066 9.192a.75.75 0 00.154.838l.53-.53-.53.53v.001l.002.002.002.002.006.006.016.015.045.04a3.514 3.514 0 00.686.45A4.492 4.492 0 003 11c.88 0 1.556-.22 2.023-.454a3.515 3.515 0 00.686-.45l.045-.04.016-.015.006-.006.002-.002.001-.002L5.25 9.5l.53.53a.75.75 0 00.154-.838L3.822 4.5h.162c.305 0 .604-.08.869-.23l1.289-.737a.25.25 0 01.124-.033h.984V13h-2.5a.75.75 0 000 1.5h6.5a.75.75 0 000-1.5h-2.5V3.5h.984a.25.25 0 01.124.033l1.29.736c.264.152.563.231.868.231h.162l-2.112 4.692a.75.75 0 00.154.838l.53-.53-.53.53v.001l.002.002.002.002.006.006.016.015.045.04a3.517 3.517 0 00.686.45A4.492 4.492 0 0013 11c.88 0 1.556-.22 2.023-.454a3.512 3.512 0 00.686-.45l.045-.04.01-.01.006-.005.006-.006.002-.002.001-.002-.529-.531.53.53a.75.75 0 00.154-.838L13.823 4.5h.427a.75.75 0 000-1.5h-2.234a.25.25 0 01-.124-.033l-1.29-.736A1.75 1.75 0 009.735 2H8.75V.75zM1.695 9.227c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327l-1.305 2.9zm10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327l-1.305 2.9z\"></path></svg>\r\n                <% if (computed.licenses.favorite.length) { %>\r\n                  Prefer <%= computed.licenses.favorite %> license\r\n                <% } else { %>\r\n                  No license preference\r\n                <% } %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 7.775V2.75a.25.25 0 01.25-.25h5.025a.25.25 0 01.177.073l6.25 6.25a.25.25 0 010 .354l-5.025 5.025a.25.25 0 01-.354 0l-6.25-6.25a.25.25 0 01-.073-.177zm-1.5 0V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 010 2.474l-5.026 5.026a1.75 1.75 0 01-2.474 0l-6.25-6.25A1.75 1.75 0 011 7.775zM6 5a1 1 0 100 2 1 1 0 000-2z\"></path></svg>\r\n                <%= computed.repositories.releases %> Release<%= s(computed.repositories.releases) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8.878.392a1.75 1.75 0 00-1.756 0l-5.25 3.045A1.75 1.75 0 001 4.951v6.098c0 .624.332 1.2.872 1.514l5.25 3.045a1.75 1.75 0 001.756 0l5.25-3.045c.54-.313.872-.89.872-1.514V4.951c0-.624-.332-1.2-.872-1.514L8.878.392zM7.875 1.69a.25.25 0 01.25 0l4.63 2.685L8 7.133 3.245 4.375l4.63-2.685zM2.5 5.677v5.372c0 .09.047.171.125.216l4.625 2.683V8.432L2.5 5.677zm6.25 8.271l4.625-2.683a.25.25 0 00.125-.216V5.677L8.75 8.432v5.516z\"></path></svg>\r\n                <%= user.packages.totalCount %> Package<%= s(user.packages.totalCount) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path xmlns=\"http://www.w3.org/2000/svg\" fill-rule=\"evenodd\" d=\"M2.5 3.5c0-.133.058-.318.282-.55.227-.237.592-.484 1.1-.708C4.899 1.795 6.354 1.5 8 1.5c1.647 0 3.102.295 4.117.742.51.224.874.47 1.101.707.224.233.282.418.282.551 0 .133-.058.318-.282.55-.227.237-.592.484-1.1.708C11.101 5.205 9.646 5.5 8 5.5c-1.647 0-3.102-.295-4.117-.742-.51-.224-.874-.47-1.101-.707-.224-.233-.282-.418-.282-.551zM1 3.5c0-.626.292-1.165.7-1.59.406-.422.956-.767 1.579-1.041C4.525.32 6.195 0 8 0c1.805 0 3.475.32 4.722.869.622.274 1.172.62 1.578 1.04.408.426.7.965.7 1.591v9c0 .626-.292 1.165-.7 1.59-.406.422-.956.767-1.579 1.041C11.476 15.68 9.806 16 8 16c-1.805 0-3.475-.32-4.721-.869-.623-.274-1.173-.62-1.579-1.04-.408-.426-.7-.965-.7-1.591v-9zM2.5 8V5.724c.241.15.503.286.779.407C4.525 6.68 6.195 7 8 7c1.805 0 3.475-.32 4.722-.869.275-.121.537-.257.778-.407V8c0 .133-.058.318-.282.55-.227.237-.592.484-1.1.708C11.101 9.705 9.646 10 8 10c-1.647 0-3.102-.295-4.117-.742-.51-.224-.874-.47-1.101-.707C2.558 8.318 2.5 8.133 2.5 8zm0 2.225V12.5c0 .133.058.318.282.55.227.237.592.484 1.1.708 1.016.447 2.471.742 4.118.742 1.647 0 3.102-.295 4.117-.742.51-.224.874-.47 1.101-.707.224-.233.282-.418.282-.551v-2.275c-.241.15-.503.285-.778.406-1.247.549-2.917.869-4.722.869-1.805 0-3.475-.32-4.721-.869a6.236 6.236 0 01-.779-.406z\"></path></svg>\r\n                <%= computed.diskUsage %> used\r\n              </div>\r\n              <% if (plugins.lines) { %>\r\n                  <div class=\"field <%= plugins.lines.error ? 'error' : '' %>\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.75 1.5a.25.25 0 00-.25.25v12.5c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V4.664a.25.25 0 00-.073-.177l-2.914-2.914a.25.25 0 00-.177-.073H2.75zM1 1.75C1 .784 1.784 0 2.75 0h7.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V1.75zm7 1.5a.75.75 0 01.75.75v1.5h1.5a.75.75 0 010 1.5h-1.5v1.5a.75.75 0 01-1.5 0V7h-1.5a.75.75 0 010-1.5h1.5V4A.75.75 0 018 3.25zm-3 8a.75.75 0 01.75-.75h4.5a.75.75 0 010 1.5h-4.5a.75.75 0 01-.75-.75z\"></path></svg>\r\n                    <% if (plugins.lines.error) { %>\r\n                      <%= plugins.lines.error.message %>\r\n                    <% } else { %>\r\n                      <%= plugins.lines.added %> added, <%= plugins.lines.deleted %> removed\r\n                    <% } %>\r\n                  </div>\r\n              <% } %>\r\n            </section>\r\n            <section>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.25 2.5c-1.336 0-2.75 1.164-2.75 3 0 2.15 1.58 4.144 3.365 5.682A20.565 20.565 0 008 13.393a20.561 20.561 0 003.135-2.211C12.92 9.644 14.5 7.65 14.5 5.5c0-1.836-1.414-3-2.75-3-1.373 0-2.609.986-3.029 2.456a.75.75 0 01-1.442 0C6.859 3.486 5.623 2.5 4.25 2.5zM8 14.25l-.345.666-.002-.001-.006-.003-.018-.01a7.643 7.643 0 01-.31-.17 22.075 22.075 0 01-3.434-2.414C2.045 10.731 0 8.35 0 5.5 0 2.836 2.086 1 4.25 1 5.797 1 7.153 1.802 8 3.02 8.847 1.802 10.203 1 11.75 1 13.914 1 16 2.836 16 5.5c0 2.85-2.045 5.231-3.885 6.818a22.08 22.08 0 01-3.744 2.584l-.018.01-.006.003h-.002L8 14.25zm0 0l.345.666a.752.752 0 01-.69 0L8 14.25z\"></path></svg>\r\n                <%= user.sponsorshipsAsMaintainer.totalCount %> Sponsor<%= s(user.sponsorshipsAsMaintainer.totalCount) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n                <%= computed.repositories.stargazers %> Stargazer<%= s(computed.repositories.stargazers) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5 3.25a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm0 2.122a2.25 2.25 0 10-1.5 0v.878A2.25 2.25 0 005.75 8.5h1.5v2.128a2.251 2.251 0 101.5 0V8.5h1.5a2.25 2.25 0 002.25-2.25v-.878a2.25 2.25 0 10-1.5 0v.878a.75.75 0 01-.75.75h-4.5A.75.75 0 015 6.25v-.878zm3.75 7.378a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm3-8.75a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                <%= computed.repositories.forks %> Fork<%= s(computed.repositories.forks) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.679 7.932c.412-.621 1.242-1.75 2.366-2.717C5.175 4.242 6.527 3.5 8 3.5c1.473 0 2.824.742 3.955 1.715 1.124.967 1.954 2.096 2.366 2.717a.119.119 0 010 .136c-.412.621-1.242 1.75-2.366 2.717C10.825 11.758 9.473 12.5 8 12.5c-1.473 0-2.824-.742-3.955-1.715C2.92 9.818 2.09 8.69 1.679 8.068a.119.119 0 010-.136zM8 2c-1.981 0-3.67.992-4.933 2.078C1.797 5.169.88 6.423.43 7.1a1.619 1.619 0 000 1.798c.45.678 1.367 1.932 2.637 3.024C4.329 13.008 6.019 14 8 14c1.981 0 3.67-.992 4.933-2.078 1.27-1.091 2.187-2.345 2.637-3.023a1.619 1.619 0 000-1.798c-.45-.678-1.367-1.932-2.637-3.023C11.671 2.992 9.981 2 8 2zm0 8a2 2 0 100-4 2 2 0 000 4z\"></path></svg>\r\n                <%= computed.repositories.watchers %> Watcher<%= s(computed.repositories.watchers) %>\r\n              </div>\r\n              <% if (plugins.traffic) { %>\r\n                  <div class=\"field <%= plugins.traffic.error ? 'error' : '' %>\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M0 1.75A.75.75 0 01.75 1h4.253c1.227 0 2.317.59 3 1.501A3.744 3.744 0 0111.006 1h4.245a.75.75 0 01.75.75v10.5a.75.75 0 01-.75.75h-4.507a2.25 2.25 0 00-1.591.659l-.622.621a.75.75 0 01-1.06 0l-.622-.621A2.25 2.25 0 005.258 13H.75a.75.75 0 01-.75-.75V1.75zm8.755 3a2.25 2.25 0 012.25-2.25H14.5v9h-3.757c-.71 0-1.4.201-1.992.572l.004-7.322zm-1.504 7.324l.004-5.073-.002-2.253A2.25 2.25 0 005.003 2.5H1.5v9h3.757a3.75 3.75 0 011.994.574z\"></path></svg>\r\n                    <% if (plugins.traffic.error) { %>\r\n                      <%= plugins.traffic.error.message %>\r\n                    <% } else { %>\r\n                      <%= plugins.traffic.views.count %> view<%= s(plugins.traffic.views.count) %> in last two weeks\r\n                    <% } %>\r\n                  </div>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.followup) { %>\r\n        <div class=\"row\">\r\n\r\n          <section class=\"column\">\r\n            <h3>Issues</h3>\r\n            <% if (plugins.followup.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.followup.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"220\" height=\"8\">\r\n                <mask id=\"issues-bar\">\r\n                  <rect x=\"0\" y=\"0\" width=\"220\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                </mask>\r\n                <rect mask=\"url(#issues-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.followup.issues.count ? 0 : 220 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                <rect mask=\"url(#issues-bar)\" x=\"0\" y=\"0\" width=\"<%= (plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" height=\"8\" fill=\"#d73a49\"/>\r\n                <rect mask=\"url(#issues-bar)\" x=\"<%= (plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" y=\"0\" width=\"<%= (1-plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" height=\"8\" fill=\"#28a745\"/>\r\n              </svg>\r\n              <div class=\"field horizontal fill-width\">\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#d73a49\" fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 0110.65-5.003.75.75 0 00.959-1.153 8 8 0 102.592 8.33.75.75 0 10-1.444-.407A6.5 6.5 0 011.5 8zM8 12a1 1 0 100-2 1 1 0 000 2zm0-8a.75.75 0 01.75.75v3.5a.75.75 0 11-1.5 0v-3.5A.75.75 0 018 4zm4.78 4.28l3-3a.75.75 0 00-1.06-1.06l-2.47 2.47-.97-.97a.749.749 0 10-1.06 1.06l1.5 1.5a.75.75 0 001.06 0z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.issues.closed %> Closed</span>\r\n                </div>\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#28a745\" fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.issues.open %> Open</span>\r\n                </div>\r\n              </div>\r\n            <% } %>\r\n          </section>\r\n\r\n          <section class=\"column\">\r\n            <h3>Pull requests</h3>\r\n            <% if (plugins.followup.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.followup.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"220\" height=\"8\">\r\n                <mask id=\"pr-bar\">\r\n                  <rect x=\"0\" y=\"0\" width=\"220\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                </mask>\r\n                <rect mask=\"url(#pr-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.followup.pr.count ? 0 : 220 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                <rect mask=\"url(#pr-bar)\" x=\"0\" y=\"0\" width=\"<%= (plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" height=\"8\" fill=\"#6f42c1\"/>\r\n                <rect mask=\"url(#pr-bar)\" x=\"<%= (plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" y=\"0\" width=\"<%= (1-plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" height=\"8\" fill=\"#28a745\"/>\r\n              </svg>\r\n              <div class=\"field horizontal fill-width\">\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#6f42c1\" fill-rule=\"evenodd\" d=\"M5 3.254V3.25v.005a.75.75 0 110-.005v.004zm.45 1.9a2.25 2.25 0 10-1.95.218v5.256a2.25 2.25 0 101.5 0V7.123A5.735 5.735 0 009.25 9h1.378a2.251 2.251 0 100-1.5H9.25a4.25 4.25 0 01-3.8-2.346zM12.75 9a.75.75 0 100-1.5.75.75 0 000 1.5zm-8.5 4.5a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.pr.merged %> Merged</span>\r\n                </div>\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#28a745\" fill-rule=\"evenodd\" d=\"M7.177 3.073L9.573.677A.25.25 0 0110 .854v4.792a.25.25 0 01-.427.177L7.177 3.427a.25.25 0 010-.354zM3.75 2.5a.75.75 0 100 1.5.75.75 0 000-1.5zm-2.25.75a2.25 2.25 0 113 2.122v5.256a2.251 2.251 0 11-1.5 0V5.372A2.25 2.25 0 011.5 3.25zM11 2.5h-1V4h1a1 1 0 011 1v5.628a2.251 2.251 0 101.5 0V5A2.5 2.5 0 0011 2.5zm1 10.25a.75.75 0 111.5 0 .75.75 0 01-1.5 0zM3.75 12a.75.75 0 100 1.5.75.75 0 000-1.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.pr.open %> Open</span>\r\n                </div>\r\n              </div>\r\n            <% } %>\r\n          </section>\r\n\r\n        </div>\r\n      <% } %>\r\n\r\n      <% if (plugins.languages) { %>\r\n        <section class=\"column\">\r\n          <h3>Most used languages</h3>\r\n          <% if (plugins.languages.error) { %>\r\n            <section>\r\n              <div class=\"field error\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                <%= plugins.languages.error.message %>\r\n              </div>\r\n            </section>\r\n          <% } else { %>\r\n            <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"460\" height=\"8\">\r\n              <mask id=\"languages-bar\">\r\n                <rect x=\"0\" y=\"0\" width=\"460\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n              </mask>\r\n              <rect mask=\"url(#languages-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.languages.favorites.length ? 0 : 460 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n              <% for (const {name, value, color, x} of plugins.languages.favorites) { %>\r\n                <rect mask=\"url(#languages-bar)\" x=\"<%= x*460 %>\" y=\"0\" width=\"<%= value*460 %>\" height=\"8\" fill=\"<%= color %>\"/>\r\n              <% } %>\r\n            </svg>\r\n            <div class=\"field center horizontal-wrap fill-width\">\r\n              <% for (const {name, value, color} of plugins.languages.favorites) { %>\r\n                <div class=\"field center no-wrap language\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"<%= color %>\" fill-rule=\"evenodd\" d=\"M8 4a4 4 0 100 8 4 4 0 000-8z\"></path></svg>\r\n                  <%= name %>\r\n                </div>\r\n              <% } %>\r\n            </div>\r\n          <% } %>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.projects) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 0A1.75 1.75 0 000 1.75v12.5C0 15.216.784 16 1.75 16h12.5A1.75 1.75 0 0016 14.25V1.75A1.75 1.75 0 0014.25 0H1.75zM1.5 1.75a.25.25 0 01.25-.25h12.5a.25.25 0 01.25.25v12.5a.25.25 0 01-.25.25H1.75a.25.25 0 01-.25-.25V1.75zM11.75 3a.75.75 0 00-.75.75v7.5a.75.75 0 001.5 0v-7.5a.75.75 0 00-.75-.75zm-8.25.75a.75.75 0 011.5 0v5.5a.75.75 0 01-1.5 0v-5.5zM8 3a.75.75 0 00-.75.75v3.5a.75.75 0 001.5 0v-3.5A.75.75 0 008 3z\"></path></svg>\r\n            <%= plugins.projects.totalCount %> Project<%= s(plugins.projects.totalCount) %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.projects.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.projects.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <% for (const {name, updated, progress} of plugins.projects.list) { %>\r\n                  <div class=\"row fill-width\">\r\n                    <section>\r\n                      <div class=\"field\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M0 3.75C0 2.784.784 2 1.75 2h12.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0114.25 14H1.75A1.75 1.75 0 010 12.25v-8.5zm1.75-.25a.25.25 0 00-.25.25v8.5c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25v-8.5a.25.25 0 00-.25-.25H1.75zM3.5 6.25a.75.75 0 01.75-.75h7a.75.75 0 010 1.5h-7a.75.75 0 01-.75-.75zm.75 2.25a.75.75 0 000 1.5h4a.75.75 0 000-1.5h-4z\"></path></svg>\r\n                        <%= name %>\r\n                      </div>\r\n                    </section>\r\n                  </div>\r\n                  <div class=\"row\">\r\n                    <section>\r\n                      <div class=\"field\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm.5 4.75a.75.75 0 00-1.5 0v3.5a.75.75 0 00.471.696l2.5 1a.75.75 0 00.557-1.392L8.5 7.742V4.75z\"></path></svg>\r\n                        Updated <%= updated %>\r\n                      </div>\r\n                    </section>\r\n                    <% if (progress.enabled) { %>\r\n                      <section>\r\n                        <div class=\"field\">\r\n                          <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 1.75a.25.25 0 01.25-.25h8.5a.25.25 0 01.25.25v7.736a.75.75 0 101.5 0V1.75A1.75 1.75 0 0011.25 0h-8.5A1.75 1.75 0 001 1.75v11.5c0 .966.784 1.75 1.75 1.75h3.17a.75.75 0 000-1.5H2.75a.25.25 0 01-.25-.25V1.75zM4.75 4a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5zM4 7.75A.75.75 0 014.75 7h2a.75.75 0 010 1.5h-2A.75.75 0 014 7.75zm11.774 3.537a.75.75 0 00-1.048-1.074L10.7 14.145 9.281 12.72a.75.75 0 00-1.062 1.058l1.943 1.95a.75.75 0 001.055.008l4.557-4.45z\"></path></svg>\r\n                          <%= [progress.done ? `${progress.done} done` : \"\", progress.doing ? `${progress.doing} doing` : \"\", progress.todo ? `${progress.todo} todo` : \"\"].filter(str => str).join(\" · \") %>\r\n                        </div>\r\n                      </section>\r\n                    <% } %>\r\n                  </div>\r\n                  <% if (progress.enabled) { %>\r\n                    <div class=\"field center horizontal-wrap \">\r\n                      <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"460\" height=\"8\">\r\n                        <mask id=\"project-bar\">\r\n                          <rect x=\"0\" y=\"0\" width=\"460\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                        </mask>\r\n                        <rect mask=\"url(#project-bar)\" x=\"0\" y=\"0\" width=\"<%= (progress.done/progress.total)*460 %>\" height=\"8\" fill=\"#28A745\"/>\r\n                        <rect mask=\"url(#project-bar)\" x=\"<%= (progress.done/progress.total)*460 %>\" y=\"0\" width=\"<%= (progress.doing/progress.total)*460 %>\" height=\"8\" fill=\"#6F42C1\"/>\r\n                        <rect mask=\"url(#project-bar)\" x=\"<%= ((progress.done+progress.doing)/progress.total)*460 %>\" y=\"0\" width=\"<%= (progress.todo/progress.total)*460 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                      </svg>\r\n                    </div>\r\n                  <% } %>\r\n                <% } %>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.gists) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v12.5c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25V1.75a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0114.25 16H1.75A1.75 1.75 0 010 14.25V1.75zm9.22 3.72a.75.75 0 000 1.06L10.69 8 9.22 9.47a.75.75 0 101.06 1.06l2-2a.75.75 0 000-1.06l-2-2a.75.75 0 00-1.06 0zM6.78 6.53a.75.75 0 00-1.06-1.06l-2 2a.75.75 0 000 1.06l2 2a.75.75 0 101.06-1.06L5.31 8l1.47-1.47z\"></path></svg>\r\n            <%= plugins.gists.totalCount %> Gist<%= s(plugins.gists.totalCount) %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.gists.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.gists.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n                  <%= plugins.gists.stargazers %> Stargazer<%= s(plugins.gists.stargazers) %>\r\n                </div>\r\n              </section>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5 3.25a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm0 2.122a2.25 2.25 0 10-1.5 0v.878A2.25 2.25 0 005.75 8.5h1.5v2.128a2.251 2.251 0 101.5 0V8.5h1.5a2.25 2.25 0 002.25-2.25v-.878a2.25 2.25 0 10-1.5 0v.878a.75.75 0 01-.75.75h-4.5A.75.75 0 015 6.25v-.878zm3.75 7.378a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm3-8.75a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                  <%= plugins.gists.forks %> Fork<%= s(plugins.gists.forks) %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.pagespeed) { %>\r\n        <div class=\"row\">\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M14.064 0a8.75 8.75 0 00-6.187 2.563l-.459.458c-.314.314-.616.641-.904.979H3.31a1.75 1.75 0 00-1.49.833L.11 7.607a.75.75 0 00.418 1.11l3.102.954c.037.051.079.1.124.145l2.429 2.428c.046.046.094.088.145.125l.954 3.102a.75.75 0 001.11.418l2.774-1.707a1.75 1.75 0 00.833-1.49V9.485c.338-.288.665-.59.979-.904l.458-.459A8.75 8.75 0 0016 1.936V1.75A1.75 1.75 0 0014.25 0h-.186zM10.5 10.625c-.088.06-.177.118-.266.175l-2.35 1.521.548 1.783 1.949-1.2a.25.25 0 00.119-.213v-2.066zM3.678 8.116L5.2 5.766c.058-.09.117-.178.176-.266H3.309a.25.25 0 00-.213.119l-1.2 1.95 1.782.547zm5.26-4.493A7.25 7.25 0 0114.063 1.5h.186a.25.25 0 01.25.25v.186a7.25 7.25 0 01-2.123 5.127l-.459.458a15.21 15.21 0 01-2.499 2.02l-2.317 1.5-2.143-2.143 1.5-2.317a15.25 15.25 0 012.02-2.5l.458-.458h.002zM12 5a1 1 0 11-2 0 1 1 0 012 0zm-8.44 9.56a1.5 1.5 0 10-2.12-2.12c-.734.73-1.047 2.332-1.15 3.003a.23.23 0 00.265.265c.671-.103 2.273-.416 3.005-1.148z\"></path></svg>\r\n              PageSpeed Insights\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z\"></path></svg>\r\n              <%= user.websiteUrl %>\r\n            </div>\r\n          </section>\r\n        </div>\r\n        <% if (plugins.pagespeed.error) { %>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field error\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                <%= plugins.pagespeed.error.message %>\r\n              </div>\r\n            </section>\r\n          </div>\r\n        <% } else { %>\r\n          <section>\r\n            <div class=\"row fill-width\">\r\n              <section class=\"categories\">\r\n                <% for (const {score, title} of plugins.pagespeed.scores) { %>\r\n                  <div class=\"categorie column\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 120 120\" width=\"50\" height=\"50\" class=\"gauge <%= !Number.isNaN(score) ? (score >= 0.9 ? 'high' : score >= 0.5 ? 'average' : 'low') : '' %>\">\r\n                      <circle class=\"gauge-base\" r=\"53\" cx=\"60\" cy=\"60\"></circle>\r\n                      <% if (!Number.isNaN(score)) { %>\r\n                        <circle class=\"gauge-arc\" transform=\"rotate(-90 60 60)\" r=\"53\" cx=\"60\" cy=\"60\" stroke-dasharray=\"<%= score * 329 %> 329\"></circle>\r\n                        <text x=\"60\" y=\"60\" dominant-baseline=\"central\" ><%= Math.round(score*100) %></text>\r\n                      <% } else { %>\r\n                        <text x=\"60\" y=\"60\" dominant-baseline=\"central\" >-</text>\r\n                      <% } %>\r\n                    </svg>\r\n                    <span class=\"title\"><%= title %></span>\r\n                  </div>\r\n                <% } %>\r\n              </section>\r\n            </div>\r\n          </section>\r\n          <% if (plugins.pagespeed.detailed) { %>\r\n            <div class=\"audits row\">\r\n              <section>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.75.75A.75.75 0 016.5 0h3a.75.75 0 010 1.5h-.75v1l-.001.041a6.718 6.718 0 013.464 1.435l.007-.006.75-.75a.75.75 0 111.06 1.06l-.75.75-.006.007a6.75 6.75 0 11-10.548 0L2.72 5.03l-.75-.75a.75.75 0 011.06-1.06l.75.75.007.006A6.718 6.718 0 017.25 2.541a.756.756 0 010-.041v-1H6.5a.75.75 0 01-.75-.75zM8 14.5A5.25 5.25 0 108 4a5.25 5.25 0 000 10.5zm.389-6.7l1.33-1.33a.75.75 0 111.061 1.06L9.45 8.861A1.502 1.502 0 018 10.75a1.5 1.5 0 11.389-2.95z\"></path></svg>\r\n                    Time to interactive\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 106.016 4.035.75.75 0 011.388-.57 8 8 0 11-4.37-4.37.75.75 0 01-.569 1.389A6.479 6.479 0 008 1.5zm6.28.22a.75.75 0 010 1.06l-4.063 4.064a2.5 2.5 0 11-1.06-1.06L13.22 1.72a.75.75 0 011.06 0zM7 8a1 1 0 112 0 1 1 0 01-2 0z\"></path></svg>\r\n                    Speed Index\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.643 3.143L.427 1.927A.25.25 0 000 2.104V5.75c0 .138.112.25.25.25h3.646a.25.25 0 00.177-.427L2.715 4.215a6.5 6.5 0 11-1.18 4.458.75.75 0 10-1.493.154 8.001 8.001 0 101.6-5.684zM7.75 4a.75.75 0 01.75.75v2.992l2.028.812a.75.75 0 01-.557 1.392l-2.5-1A.75.75 0 017 8.25v-3.5A.75.75 0 017.75 4z\"></path></svg>\r\n                    Total Blocking Time\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M11.134 1.535C9.722 2.562 8.16 4.057 6.889 5.312 5.8 6.387 5.041 7.401 4.575 8.294a3.745 3.745 0 00-3.227 1.054c-.43.431-.69 1.066-.86 1.657a11.982 11.982 0 00-.358 1.914A21.263 21.263 0 000 15.203v.054l.75-.007-.007.75h.054a14.404 14.404 0 00.654-.012 21.243 21.243 0 001.63-.118c.62-.07 1.3-.18 1.914-.357.592-.17 1.226-.43 1.657-.861a3.745 3.745 0 001.055-3.217c.908-.461 1.942-1.216 3.04-2.3 1.279-1.262 2.764-2.825 3.775-4.249.501-.706.923-1.428 1.125-2.096.2-.659.235-1.469-.368-2.07-.606-.607-1.42-.55-2.069-.34-.66.213-1.376.646-2.076 1.155zm-3.95 8.48a3.76 3.76 0 00-1.19-1.192 9.758 9.758 0 011.161-1.607l1.658 1.658a9.853 9.853 0 01-1.63 1.142zM.742 16l.007-.75-.75.008A.75.75 0 00.743 16zM12.016 2.749c-1.224.89-2.605 2.189-3.822 3.384l1.718 1.718c1.21-1.205 2.51-2.597 3.387-3.833.47-.662.78-1.227.912-1.662.134-.444.032-.551.009-.575h-.001V1.78c-.014-.014-.112-.113-.548.027-.432.14-.995.462-1.655.942zM1.62 13.089a19.56 19.56 0 00-.104 1.395 19.55 19.55 0 001.396-.104 10.528 10.528 0 001.668-.309c.526-.151.856-.325 1.011-.48a2.25 2.25 0 00-3.182-3.182c-.155.155-.329.485-.48 1.01a10.515 10.515 0 00-.309 1.67z\"></path></svg>\r\n                    First Contentful Paint\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 2.5a.25.25 0 00-.25.25v10.5c0 .138.112.25.25.25h.94a.76.76 0 01.03-.03l6.077-6.078a1.75 1.75 0 012.412-.06L14.5 10.31V2.75a.25.25 0 00-.25-.25H1.75zm12.5 11H4.81l5.048-5.047a.25.25 0 01.344-.009l4.298 3.889v.917a.25.25 0 01-.25.25zm1.75-.25V2.75A1.75 1.75 0 0014.25 1H1.75A1.75 1.75 0 000 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0016 13.25zM5.5 6a.5.5 0 11-1 0 .5.5 0 011 0zM7 6a2 2 0 11-4 0 2 2 0 014 0z\"></path></svg>\r\n                    Largest Contentful Paint\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.75 14A1.75 1.75 0 016 12.25v-8.5C6 2.784 6.784 2 7.75 2h6.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0114.25 14h-6.5zm-.25-1.75c0 .138.112.25.25.25h6.5a.25.25 0 00.25-.25v-8.5a.25.25 0 00-.25-.25h-6.5a.25.25 0 00-.25.25v8.5zM4.9 3.508a.75.75 0 01-.274 1.025.25.25 0 00-.126.217v6.5a.25.25 0 00.126.217.75.75 0 01-.752 1.298A1.75 1.75 0 013 11.25v-6.5c0-.649.353-1.214.874-1.516a.75.75 0 011.025.274zM1.625 5.533a.75.75 0 10-.752-1.299A1.75 1.75 0 000 5.75v4.5c0 .649.353 1.214.874 1.515a.75.75 0 10.752-1.298.25.25 0 01-.126-.217v-4.5a.25.25 0 01.126-.217z\"></path></svg>\r\n                    Cumulative Layout Shift\r\n                  </div>\r\n              </section>\r\n              <section>\r\n                <% for (const {score, suffix = \"\", threshold} of [\r\n                  {score:plugins.pagespeed.metrics.interactive/1000, suffix:\"s\", threshold:[3.785, 7.3]},\r\n                  {score:plugins.pagespeed.metrics.speedIndex/1000, suffix:\"s\", threshold:[3.387, 5.8]},\r\n                  {score:plugins.pagespeed.metrics.totalBlockingTime/1000, suffix:\"s\", threshold:[.287, .6]},\r\n                  {score:plugins.pagespeed.metrics.firstContentfulPaint/1000, suffix:\"s\", threshold:[2.336, 4]},\r\n                  {score:plugins.pagespeed.metrics.largestContentfulPaint/1000, suffix:\"s\", threshold:[2.5, 4]},\r\n                  {score:+plugins.pagespeed.metrics.cumulativeLayoutShift, threshold:[.1, .25]}\r\n                ]) { %>\r\n                <div class=\"field\">\r\n                  <div class=\"audit text\">\r\n                    <% if (!Number.isNaN(score)) { %>\r\n                      <%= score.toFixed(2).replace(/[.]0+$/, \"\") %> <%= suffix %>\r\n                    <% } else { %>\r\n                      N/A\r\n                    <% } %>\r\n                  </div>\r\n                  <% if (Number.isNaN(score)) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm3.28 5.78a.75.75 0 00-1.06-1.06l-5.5 5.5a.75.75 0 101.06 1.06l5.5-5.5z\"></path></svg>\r\n                  <% } else if (score <= threshold[0]) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit high\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM0 8a8 8 0 1116 0A8 8 0 010 8zm11.78-1.72a.75.75 0 00-1.06-1.06L6.75 9.19 5.28 7.72a.75.75 0 00-1.06 1.06l2 2a.75.75 0 001.06 0l4.5-4.5z\"></path></svg>\r\n                  <% } else if (score <= threshold[1]) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit average\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n                  <% } else { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit low\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.47.22A.75.75 0 015 0h6a.75.75 0 01.53.22l4.25 4.25c.141.14.22.331.22.53v6a.75.75 0 01-.22.53l-4.25 4.25A.75.75 0 0111 16H5a.75.75 0 01-.53-.22L.22 11.53A.75.75 0 010 11V5a.75.75 0 01.22-.53L4.47.22zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5H5.31zM8 4a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0v-3.5A.75.75 0 018 4zm0 8a1 1 0 100-2 1 1 0 000 2z\"></path></svg>\r\n                  <% } %>\r\n                </div>\r\n                <% } %>\r\n              </section>\r\n            </div>\r\n          <% } %>\r\n        <% } %>\r\n      <% } %>\r\n\r\n      <% if (plugins.habits) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 01-1.484.211c-.04-.282-.163-.547-.37-.847a8.695 8.695 0 00-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.75.75 0 01-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75zM6 15.25a.75.75 0 01.75-.75h2.5a.75.75 0 010 1.5h-2.5a.75.75 0 01-.75-.75zM5.75 12a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5z\"></path></svg>\r\n            Coding habits and recent activity\r\n          </h2>\r\n          <% if (plugins.habits.facts) { %>\r\n            <div class=\"row\">\r\n              <% if (plugins.habits.error) { %>\r\n                <section>\r\n                  <div class=\"field error\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                    <%= plugins.habits.error.message %>\r\n                  </div>\r\n                </section>\r\n              <% } else { %>\r\n                <ul class=\"habits\">\r\n                  <% if (plugins.habits.indents.style) { %>\r\n                    <li>Use <%= plugins.habits.indents.style %> for indents</li>\r\n                  <% } %>\r\n                  <% if (!Number.isNaN(plugins.habits.commits.hour)) { %>\r\n                    <li>Mostly push code around <%= plugins.habits.commits.hour %>:00</li>\r\n                  <% } %>\r\n                  <% if (plugins.habits.commits.day) { %>\r\n                    <li>Mostly active on <%= plugins.habits.commits.day.toLocaleLowerCase() %></li>\r\n                  <% } %>\r\n                </ul>\r\n              <% } %>\r\n            </div>\r\n          <% } %>\r\n        </section>\r\n\r\n        <% if (plugins.habits.charts) { %>\r\n          <% if (!Number.isNaN(plugins.habits.commits.hour)) { %>\r\n            <section class=\"column chart\">\r\n              <h3>Commit activity per time of the day</h3>\r\n              <div class=\"chart-bars\">\r\n                <% for (let h = 0; h < 24; h++) { const p = (plugins.habits.commits.hours[h]??0)/(plugins.habits.commits.hours.max??1); %>\r\n                  <div class=\"entry\">\r\n                    <span class=\"value\"><%= plugins.habits.commits.hours[h] %></span>\r\n                    <div class=\"bar\" style=\"height: <%= p*50 %>px; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                    <%= `${h}`.padStart(2, 0) %>\r\n                  </div>\r\n                <% } %>\r\n              </div>\r\n            </section>\r\n          <% } %>\r\n\r\n          <div class=\"row\">\r\n            <% if (!Number.isNaN(plugins.habits.commits.day)) { %>\r\n              <section class=\"column chart\">\r\n                <h3>Commit activity per day</h3>\r\n                <div class=\"chart-bars\">\r\n                  <% for (let d = 0; d < 7; d++) { const p = (plugins.habits.commits.days[d]??0)/(plugins.habits.commits.days.max??1); %>\r\n                    <div class=\"entry\">\r\n                      <span class=\"value\"><%= plugins.habits.commits.days[d] %></span>\r\n                      <div class=\"bar\" style=\"height: <%= p*50 %>px; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                      <%= [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"][d] %>\r\n                    </div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n            <% if (plugins.habits.linguist.available) { %>\r\n              <section class=\"column chart\">\r\n                <h3>Language activity</h3>\r\n                <div class=\"chart-bars horizontal\">\r\n                  <% for (const [language, p] of plugins.habits.linguist.ordered) { %>\r\n                    <div class=\"entry\">\r\n                      <span class=\"name\"><%= language %></span>\r\n                      <div class=\"bar\" style=\"width: <%= p*80 %>%; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                      <span class=\"value\"><%= Math.round(100*p) %>%</span>\r\n                    </div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        <% } %>\r\n      <% } %>\r\n\r\n      <% if (plugins.topics) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M14.184 1.143a1.75 1.75 0 00-2.502-.57L.912 7.916a1.75 1.75 0 00-.53 2.32l.447.775a1.75 1.75 0 002.275.702l11.745-5.656a1.75 1.75 0 00.757-2.451l-1.422-2.464zm-1.657.669a.25.25 0 01.358.081l1.422 2.464a.25.25 0 01-.108.35l-2.016.97-1.505-2.605 1.85-1.26zM9.436 3.92l1.391 2.41-5.42 2.61-.942-1.63 4.97-3.39zM3.222 8.157l-1.466 1a.25.25 0 00-.075.33l.447.775a.25.25 0 00.325.1l1.598-.769-.83-1.436zm6.253 2.306a.75.75 0 00-.944-.252l-1.809.87a.75.75 0 00-.293.253L4.38 14.326a.75.75 0 101.238.848l1.881-2.75v2.826a.75.75 0 001.5 0v-2.826l1.881 2.75a.75.75 0 001.238-.848l-2.644-3.863z\"></path></svg>\r\n            Starred topics\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.topics.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.topics.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <div class=\"topics fill-width\">\r\n                  <% for (const {name, description} of plugins.topics.list) { %>\r\n                    <div class=\"label\" title=\"<%= description %>\"><%= name.toLocaleLowerCase() %></div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.music) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zM6.379 5.227A.25.25 0 006 5.442v5.117a.25.25 0 00.379.214l4.264-2.559a.25.25 0 000-.428L6.379 5.227z\"></path></svg>\r\n            <%= plugins.music.mode %>\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.music.provider) { %>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.002 2.725a.75.75 0 01.797-.699C8.79 2.42 13.58 7.21 13.974 13.201a.75.75 0 11-1.497.098 10.502 10.502 0 00-9.776-9.776.75.75 0 01-.7-.798zM2 13a1 1 0 112 0 1 1 0 01-2 0zm.84-5.95a.75.75 0 00-.179 1.489c2.509.3 4.5 2.291 4.8 4.8a.75.75 0 101.49-.178A7.003 7.003 0 002.838 7.05z\"></path></svg>\r\n                  From <%= plugins.music.provider %>\r\n                </div>\r\n              <% } %>\r\n              <% if (plugins.music.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.music.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <% if (plugins.music.tracks.length) { %>\r\n                  <div class=\"tracklist\">\r\n                    <% for (const {name = \"\", artist = \"\", artwork = \"\"} of plugins.music.tracks) { %>\r\n                      <div class=\"track\">\r\n                        <img src=\"data:image/png;base64,<%= artwork %>\" width=\"32\" height=\"32\" alt=\"\"/>\r\n                        <div class=\"infos\">\r\n                          <div class=\"name\"><%= name %></div>\r\n                          <div class=\"artist\"><%= artist %></div>\r\n                        </div>\r\n                      </div>\r\n                    <% } %>\r\n                  </div>\r\n                <% } else { %>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                    No music recently listened\r\n                  </div>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.posts) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.456.734a1.75 1.75 0 012.826.504l.613 1.327a3.081 3.081 0 002.084 1.707l2.454.584c1.332.317 1.8 1.972.832 2.94L11.06 10l3.72 3.72a.75.75 0 11-1.061 1.06L10 11.06l-2.204 2.205c-.968.968-2.623.5-2.94-.832l-.584-2.454a3.081 3.081 0 00-1.707-2.084l-1.327-.613a1.75 1.75 0 01-.504-2.826L4.456.734zM5.92 1.866a.25.25 0 00-.404-.072L1.794 5.516a.25.25 0 00.072.404l1.328.613A4.582 4.582 0 015.73 9.63l.584 2.454a.25.25 0 00.42.12l5.47-5.47a.25.25 0 00-.12-.42L9.63 5.73a4.581 4.581 0 01-3.098-2.537L5.92 1.866z\"></path></svg>\r\n            Recent articles\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.posts.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.posts.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.002 2.725a.75.75 0 01.797-.699C8.79 2.42 13.58 7.21 13.974 13.201a.75.75 0 11-1.497.098 10.502 10.502 0 00-9.776-9.776.75.75 0 01-.7-.798zM2 13a1 1 0 112 0 1 1 0 01-2 0zm.84-5.95a.75.75 0 00-.179 1.489c2.509.3 4.5 2.291 4.8 4.8a.75.75 0 101.49-.178A7.003 7.003 0 002.838 7.05z\"></path></svg>\r\n                  From <%= plugins.posts.source %>\r\n                </div>\r\n                <% if (plugins.posts.list.length) { %>\r\n                  <% for (const {title, date} of plugins.posts.list) { %>\r\n                    <div class=\"field post\">\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 0a.75.75 0 01.75.75V2h5V.75a.75.75 0 011.5 0V2h1.25c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V3.75C1 2.784 1.784 2 2.75 2H4V.75A.75.75 0 014.75 0zm0 3.5h8.5a.25.25 0 01.25.25V6h-11V3.75a.25.25 0 01.25-.25h2zm-2.25 4v6.75c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V7.5h-11z\"></path></svg>\r\n                      <div class=\"infos\">\r\n                        <div class=\"date\"><%= date %></div>\r\n                        <div class=\"title\"><%= title %></div>\r\n                      </div>\r\n                    </div>\r\n                  <% } %>\r\n                <% } else { %>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                    No recent posts\r\n                  </div>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.tweets) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 273.5 222.3\" width=\"16\" height=\"16\"><path d=\"M273.5 26.3a109.77 109.77 0 0 1-32.2 8.8 56.07 56.07 0 0 0 24.7-31 113.39 113.39 0 0 1-35.7 13.6 56.1 56.1 0 0 0-97 38.4 54 54 0 0 0 1.5 12.8A159.68 159.68 0 0 1 19.1 10.3a56.12 56.12 0 0 0 17.4 74.9 56.06 56.06 0 0 1-25.4-7v.7a56.11 56.11 0 0 0 45 55 55.65 55.65 0 0 1-14.8 2 62.39 62.39 0 0 1-10.6-1 56.24 56.24 0 0 0 52.4 39 112.87 112.87 0 0 1-69.7 24 119 119 0 0 1-13.4-.8 158.83 158.83 0 0 0 86 25.2c103.2 0 159.6-85.5 159.6-159.6 0-2.4-.1-4.9-.2-7.3a114.25 114.25 0 0 0 28.1-29.1\"></path></svg>\r\n            Latest tweets\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.tweets.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.tweets.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <div class=\"field <%= !plugins.tweets.profile ? 'error' : '' %>\">\r\n                  <% if (plugins.tweets.profile?.verified) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M9.585.52a2.678 2.678 0 00-3.17 0l-.928.68a1.178 1.178 0 01-.518.215L3.83 1.59a2.678 2.678 0 00-2.24 2.24l-.175 1.14a1.178 1.178 0 01-.215.518l-.68.928a2.678 2.678 0 000 3.17l.68.928c.113.153.186.33.215.518l.175 1.138a2.678 2.678 0 002.24 2.24l1.138.175c.187.029.365.102.518.215l.928.68a2.678 2.678 0 003.17 0l.928-.68a1.17 1.17 0 01.518-.215l1.138-.175a2.678 2.678 0 002.241-2.241l.175-1.138c.029-.187.102-.365.215-.518l.68-.928a2.678 2.678 0 000-3.17l-.68-.928a1.179 1.179 0 01-.215-.518L14.41 3.83a2.678 2.678 0 00-2.24-2.24l-1.138-.175a1.179 1.179 0 01-.518-.215L9.585.52zM7.303 1.728c.415-.305.98-.305 1.394 0l.928.68c.348.256.752.423 1.18.489l1.136.174c.51.078.909.478.987.987l.174 1.137c.066.427.233.831.489 1.18l.68.927c.305.415.305.98 0 1.394l-.68.928a2.678 2.678 0 00-.489 1.18l-.174 1.136a1.178 1.178 0 01-.987.987l-1.137.174a2.678 2.678 0 00-1.18.489l-.927.68c-.415.305-.98.305-1.394 0l-.928-.68a2.678 2.678 0 00-1.18-.489l-1.136-.174a1.178 1.178 0 01-.987-.987l-.174-1.137a2.678 2.678 0 00-.489-1.18l-.68-.927a1.178 1.178 0 010-1.394l.68-.928c.256-.348.423-.752.489-1.18l.174-1.136c.078-.51.478-.909.987-.987l1.137-.174a2.678 2.678 0 001.18-.489l.927-.68zM11.28 6.78a.75.75 0 00-1.06-1.06L7 8.94 5.78 7.72a.75.75 0 00-1.06 1.06l1.75 1.75a.75.75 0 001.06 0l3.75-3.75z\"></path></svg>\r\n                  <% } else { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 2.37a6.5 6.5 0 006.5 11.26.75.75 0 01.75 1.298 8 8 0 113.994-7.273.754.754 0 01.006.095v1.5a2.75 2.75 0 01-5.072 1.475A4 4 0 1112 8v1.25a1.25 1.25 0 002.5 0V7.867a6.5 6.5 0 00-9.75-5.496V2.37zM10.5 8a2.5 2.5 0 10-5 0 2.5 2.5 0 005 0z\"></path></svg>\r\n                  <% } %>\r\n                  <%= plugins.tweets.username %>\r\n                  <% if (!plugins.tweets.profile) { %>\r\n                    : twitter username not found\r\n                  <% } %>\r\n                </div>\r\n                <% if (plugins.tweets.profile) { %>\r\n                  <% if (plugins.tweets.list.length) { %>\r\n                    <% for (const {text, created_at} of plugins.tweets.list) { %>\r\n                      <div class=\"tweet\">\r\n                        <%- text %>\r\n                        <div class=\"date\"><%= new Date(created_at).toGMTString() %></div>\r\n                      </div>\r\n                    <% } %>\r\n                  <% } else { %>\r\n                    <div class=\"field\">\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                      No recent tweets\r\n                    </div>\r\n                  <% } %>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.isocalendar) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 0a.75.75 0 01.75.75V2h5V.75a.75.75 0 011.5 0V2h1.25c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V3.75C1 2.784 1.784 2 2.75 2H4V.75A.75.75 0 014.75 0zm0 3.5h8.5a.25.25 0 01.25.25V6h-11V3.75a.25.25 0 01.25-.25h2zm-2.25 4v6.75c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V7.5h-11z\"></path></svg>\r\n            Contributions calendar\r\n          </h2>\r\n          <div class=\"row\">\r\n            <section>\r\n              <% if (plugins.isocalendar.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.isocalendar.error.message %>\r\n                </div>\r\n              <% } %>\r\n            </section>\r\n            <% if (!plugins.isocalendar.error) { %>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.998 14.5c2.832 0 5-1.98 5-4.5 0-1.463-.68-2.19-1.879-3.383l-.036-.037c-1.013-1.008-2.3-2.29-2.834-4.434-.322.256-.63.579-.864.953-.432.696-.621 1.58-.046 2.73.473.947.67 2.284-.278 3.232-.61.61-1.545.84-2.403.633a2.788 2.788 0 01-1.436-.874A3.21 3.21 0 003 10c0 2.53 2.164 4.5 4.998 4.5zM9.533.753C9.496.34 9.16.009 8.77.146 7.035.75 4.34 3.187 5.997 6.5c.344.689.285 1.218.003 1.5-.419.419-1.54.487-2.04-.832-.173-.454-.659-.762-1.035-.454C2.036 7.44 1.5 8.702 1.5 10c0 3.512 2.998 6 6.498 6s6.5-2.5 6.5-6c0-2.137-1.128-3.26-2.312-4.438-1.19-1.184-2.436-2.425-2.653-4.81z\"></path></svg>\r\n                  Current streak <%= plugins.isocalendar.streak.current %> day<%= s(plugins.isocalendar.streak.current) %>\r\n                </div>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 1.75a.75.75 0 00-1.5 0v12.5c0 .414.336.75.75.75h14.5a.75.75 0 000-1.5H1.5V1.75zm14.28 2.53a.75.75 0 00-1.06-1.06L10 7.94 7.53 5.47a.75.75 0 00-1.06 0L3.22 8.72a.75.75 0 001.06 1.06L7 7.06l2.47 2.47a.75.75 0 001.06 0l5.25-5.25z\"></path></svg>\r\n                  ~<%= plugins.isocalendar.average %> commits per day\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n          <% if (plugins.isocalendar.svg) { %>\r\n            <%- plugins.isocalendar.svg %>\r\n          <% } %>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (base.metadata) { %>\r\n        <footer>\r\n          <span>These metrics <%= !computed.token.scopes.includes(\"repo\") ? \"does not include all\" : \"includes\" %> private contributions<% if ((config.timezone?.name)&&(!config.timezone?.error)) { %>, timezone <%= config.timezone.name %><% } %></span>\r\n          <span>Last updated <%= new Date().toGMTString() %> with lowlighter/metrics@<%= meta.version %></span>\r\n        </footer>\r\n      <% } %>\r\n\r\n    </div>\r\n  </foreignObject>\r\n</svg>","style":"/* SVG global context */\r\n  svg {\r\n    font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji;\r\n    font-size: 14px;\r\n    color: #777777;\r\n  }\r\n\r\n/* Headers */\r\n  h1, h2, h3 {\r\n    margin: 8px 0 2px;\r\n    padding: 0;\r\n    color: #0366d6;\r\n    font-weight: normal;\r\n  }\r\n  h1 svg, h2 svg, h3 svg {\r\n    fill: currentColor;\r\n  }\r\n  h1 {\r\n    font-size: 20px;\r\n    font-weight: bold;\r\n  }\r\n  h2 {\r\n    font-size: 16px;\r\n  }\r\n  h3 {\r\n    font-size: 14px;\r\n  }\r\n\r\n/* Fields */\r\n  section > .field {\r\n    margin-left: 5px;\r\n    margin-right: 5px;\r\n  }\r\n  .field {\r\n    display: flex;\r\n    align-items: center;\r\n    margin-bottom: 2px;\r\n    white-space: nowrap;\r\n  }\r\n  .field svg {\r\n    margin: 0 8px;\r\n    fill: #959da5;\r\n    flex-shrink: 0;\r\n  }\r\n  .field.error {\r\n    color: #cb2431;\r\n  }\r\n  .field.error svg {\r\n    fill: #cb2431;\r\n  }\r\n\r\n/* Displays */\r\n  .row {\r\n    display: flex;\r\n  }\r\n  .row section {\r\n    flex: 1 1 0;\r\n  }\r\n  .column {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n  }\r\n  .center {\r\n    justify-content: center;\r\n  }\r\n  .horizontal {\r\n    justify-content: space-around;\r\n  }\r\n  .horizontal-wrap {\r\n    flex-wrap: wrap;\r\n  }\r\n  .horizontal .field {\r\n    flex: 1 1 0;\r\n  }\r\n  .no-wrap {\r\n    white-space: nowrap;\r\n  }\r\n  .fill-width {\r\n    width: 100%;\r\n  }\r\n\r\n/* User avatar */\r\n  .avatar {\r\n    background-color: #000000;\r\n    border-radius: 50%;\r\n    margin: 0 6px;\r\n  }\r\n\r\n/* Commit calendar */\r\n  .calendar.field {\r\n    margin: 4px 0;\r\n    margin-left: 7px;\r\n  }\r\n  .calendar .day {\r\n    outline: 1px solid rgba(27,31,35,.04);\r\n    outline-offset: -1px;\r\n  }\r\n\r\n/* Progress bars */\r\n  svg.bar {\r\n    margin: 4px 0;\r\n  }\r\n\r\n/* Language */\r\n  .field.language {\r\n    margin: 0 8px;\r\n    flex-grow: 0;\r\n  }\r\n\r\n  .field.language small {\r\n    margin-left: 4px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Labels */\r\n  .label {\r\n    background-color: #F1F8FF;\r\n    color: #0366D6;\r\n    padding: 0 10px;\r\n    font-weight: 500;\r\n    line-height: 22px;\r\n    margin: 2px 5px;\r\n    white-space: nowrap;\r\n    border-radius: 32px;\r\n    font-size: 12px;\r\n  }\r\n\r\n  .label:hover {\r\n    background-color: #DDEEFF;\r\n    cursor: pointer;\r\n  }\r\n\r\n/* Habits */\r\n  .habits {\r\n    margin: 0;\r\n    list-style-type: none;\r\n    padding-left: 37px;\r\n  }\r\n\r\n/* Footer */\r\n  footer {\r\n    margin-top: 8px;\r\n    font-size: 10px;\r\n    font-style: italic;\r\n    color: #666666;\r\n    text-align: right;\r\n    display: flex;\r\n    flex-direction: column;\r\n    justify-content: flex-end;\r\n  }\r\n\r\n/* Speed test categories */\r\n  .categories {\r\n    display: flex;\r\n    align-items: center;\r\n    justify-content: space-around;\r\n    margin-top: 4px;\r\n  }\r\n  .categorie {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    flex: 1 1 0;\r\n  }\r\n\r\n/* Gauges */\r\n  .gauge {\r\n    stroke-linecap: round;\r\n    fill: none;\r\n  }\r\n  .gauge.high {\r\n    color: #18b663;\r\n  }\r\n  .gauge.average {\r\n    color: #fb8c00;\r\n  }\r\n  .gauge.low {\r\n    color: #e53935;\r\n  }\r\n  .gauge-base, .gauge-arc {\r\n    stroke: currentColor;\r\n    stroke-width: 10;\r\n  }\r\n  .gauge-base {\r\n    stroke-opacity: .2;\r\n  }\r\n  .gauge-arc {\r\n    fill: none;\r\n    stroke-dashoffset: 0;\r\n    animation-delay: 250ms;\r\n    animation: animation-gauge 1s ease forwards\r\n  }\r\n  .gauge text {\r\n    fill: currentColor;\r\n    font-size: 40px;\r\n    font-family: monospace;\r\n    text-anchor: middle;\r\n    font-weight: 600;\r\n  }\r\n  .gauge .title {\r\n    font-size: 18px;\r\n    color: #777777;\r\n  }\r\n  @keyframes animation-gauge {\r\n    from {\r\n      stroke-dasharray: 0 329;\r\n    }\r\n  }\r\n  .audits {\r\n    margin-top: 8px;\r\n  }\r\n  .audit.text {\r\n    min-width: 42px;\r\n  }\r\n  .audit svg {\r\n    margin: 0;\r\n  }\r\n  .audit.high {\r\n    fill: #18b663;\r\n  }\r\n  .audit.average {\r\n    fill: #fb8c00;\r\n  }\r\n  .audit.low {\r\n    fill: #e53935;\r\n  }\r\n\r\n/* Music plugin */\r\n  .tracklist {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: flex-start;\r\n    margin-left: 28px;\r\n    margin-top: 4px;\r\n    width: 100%;\r\n  }\r\n  .track {\r\n    display: flex;\r\n    align-items: center;\r\n    justify-content: center;\r\n    margin-bottom: 4px;\r\n  }\r\n  .track img {\r\n    margin: 0 10px;\r\n    border-radius: 7px;\r\n  }\r\n  .track .name {\r\n    font-size: 14px;\r\n    line-height: 14px;\r\n  }\r\n  .track .artist {\r\n    font-size: 12px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Posts plugin */\r\n  .post {\r\n    align-items: flex-start;\r\n  }\r\n  .post .infos {\r\n    display: flex;\r\n    margin-bottom: 4px;\r\n  }\r\n  .post .infos .title {\r\n    font-size: 14px;\r\n    width: 400px;\r\n    white-space: normal;\r\n    overflow: hidden;\r\n    text-overflow: ellipsis;\r\n    max-height: 40px;;\r\n  }\r\n  .post .infos .date {\r\n    flex-shrink: 0;\r\n    font-size: 12px;\r\n    color: #666666;\r\n    width: 40px;\r\n    padding-top: 1px;\r\n  }\r\n\r\n/* Topics */\r\n  .topics {\r\n    display: flex;\r\n    flex-wrap: wrap;\r\n  }\r\n\r\n/* Tweets */\r\n  .tweet {\r\n    font-size: 13px;\r\n    margin-top: 6px;\r\n    margin-bottom: 16px;\r\n    margin-left: 18px;\r\n    border-left: 3px solid #777777B2;\r\n    padding-left: 6px;\r\n  }\r\n\r\n  .tweet .mention, .tweet .link, .tweet .hashtag {\r\n    color: #0366d6;\r\n  }\r\n\r\n  .tweet .date {\r\n    margin: 6px 0;\r\n    font-size: 12px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Charts and graphs */\r\n  .chart {\r\n    padding: 0 8px;\r\n  }\r\n\r\n  .chart-bars {\r\n    display: flex;\r\n    justify-content: space-between;\r\n    align-items: flex-end;\r\n    width: 100%;\r\n    margin: 8px 0 4px;\r\n  }\r\n\r\n  .chart-bars .entry {\r\n    flex: 1 1 0;\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    font-size: 10px;\r\n    color: #666666;\r\n  }\r\n\r\n  .chart-bars .entry .value {\r\n    font-size: 9px;\r\n  }\r\n\r\n  .chart-bars .bar {\r\n    width: 7px;\r\n    background-color: var(--color-calendar-graph-day-bg);\r\n    border: 1px solid var(--color-calendar-graph-day-border);\r\n    border-radius: 5px;\r\n  }\r\n\r\n  .chart-bars.horizontal {\r\n    flex-direction: column;\r\n    align-items: space-between;\r\n    height: 100%;\r\n  }\r\n\r\n  .chart-bars.horizontal .entry {\r\n    align-items: center;\r\n    flex-direction: row;\r\n    width: 100%;\r\n  }\r\n\r\n  .chart-bars.horizontal .entry .name {\r\n    flex-shrink: 0;\r\n    text-align: right;\r\n    min-width: 30%;\r\n  }\r\n\r\n  .chart-bars.horizontal .bar {\r\n    height: 7px;\r\n    width: auto;\r\n    margin: 0 6px;\r\n  }\r\n\r\n/* Fade animation */\r\n  .af {\r\n    opacity: 0;\r\n    animation: animation-fade 1s ease forwards;\r\n  }\r\n  @keyframes animation-fade {\r\n    from {\r\n      opacity: 0;\r\n    }\r\n    to {\r\n      opacity: 1;\r\n    }\r\n  }\r\n\r\n/* Cake day */\r\n  .cakeday, .cakeday svg {\r\n    animation: animation-rainbow 1.2s;\r\n    animation-iteration-count: infinite;\r\n    animation-timing-function: steps(1);\r\n  }\r\n\r\n/* Rainbow animation */\r\n  @keyframes animation-rainbow {\r\n    0%, 100%{ color: #7F00FF; fill: #7F00FF; }\r\n    14% { color: #A933FF; fill: #A933FF; }\r\n    29%{ color: #007FFF; fill: #007FFF; }\r\n    43%{ color: #00FF7F; fill: #00FF7F; }\r\n\t\t57%{ color: #FFFF00; fill: #FFFF00; }\r\n\t\t71%{ color: #FF7F00; fill: #FF7F00; }\r\n\t\t86%{ color: #FF0000; fill: #FF0000; }\r\n  }\r\n\r\n/* Calendar */\r\n  :root {\r\n    --color-calendar-graph-day-bg: #ebedf0;\r\n    --color-calendar-graph-day-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-bg: #9be9a8;\r\n    --color-calendar-graph-day-L2-bg: #40c463;\r\n    --color-calendar-graph-day-L3-bg: #30a14e;\r\n    --color-calendar-graph-day-L4-bg: #216e39;\r\n    --color-calendar-halloween-graph-day-L1-bg: #ffee4a;\r\n    --color-calendar-halloween-graph-day-L2-bg: #ffc501;\r\n    --color-calendar-halloween-graph-day-L3-bg: #fe9600;\r\n    --color-calendar-halloween-graph-day-L4-bg: #03001c;\r\n    --color-calendar-graph-day-L4-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L3-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L2-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-border: rgba(27,31,35,0.06);\r\n  }","fonts":""},"terminal":{"query":"query Metrics {\r\n  user(login: $login) {\r\n    databaseId\r\n    name\r\n    login\r\n    createdAt\r\n    avatarUrl\r\n    websiteUrl\r\n    isHireable\r\n    twitterUsername\r\n    gists {\r\n      totalCount\r\n    }\r\n    repositories(last: $repositories, isFork: false, ownerAffiliations: OWNER) {\r\n      totalCount\r\n      totalDiskUsage\r\n      nodes {\r\n        name\r\n        watchers {\r\n          totalCount\r\n        }\r\n        stargazers {\r\n          totalCount\r\n        }\r\n        languages(first: 4) {\r\n          edges {\r\n            size\r\n            node {\r\n              color\r\n              name\r\n            }\r\n          }\r\n        }\r\n        issues_open: issues(states: OPEN) {\r\n          totalCount\r\n        }\r\n        issues_closed: issues(states: CLOSED) {\r\n          totalCount\r\n        }\r\n        pr_open: pullRequests(states: OPEN) {\r\n          totalCount\r\n        }\r\n        pr_merged: pullRequests(states: MERGED) {\r\n          totalCount\r\n        }\r\n        releases {\r\n          totalCount\r\n        }\r\n        forkCount\r\n        licenseInfo {\r\n          spdxId\r\n        }\r\n      }\r\n    }\r\n    packages {\r\n      totalCount\r\n    }\r\n    starredRepositories {\r\n      totalCount\r\n    }\r\n    watching {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsSponsor {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsMaintainer {\r\n      totalCount\r\n    }\r\n    contributionsCollection {\r\n      totalRepositoriesWithContributedCommits\r\n      totalCommitContributions\r\n      restrictedContributionsCount\r\n      totalIssueContributions\r\n      totalPullRequestContributions\r\n      totalPullRequestReviewContributions\r\n    }\r\n    calendar:contributionsCollection(from: $calendar.from, to: $calendar.to) {\r\n      contributionCalendar {\r\n        weeks {\r\n          contributionDays {\r\n            color\r\n          }\r\n        }\r\n      }\r\n    }\r\n    repositoriesContributedTo {\r\n      totalCount\r\n    }\r\n    followers {\r\n      totalCount\r\n    }\r\n    following {\r\n      totalCount\r\n    }\r\n    issueComments {\r\n      totalCount\r\n    }\r\n    organizations {\r\n      totalCount\r\n    }\r\n  }\r\n}\r\n","image":"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"480\" height=\"<%= 48\r\n  + (!!base.header)*62\r\n  + (!!base.metadata)*108\r\n  + (!!base.activity)*108\r\n  + (!!base.community)*94\r\n  + (!!base.repositories)*142\r\n  + ((!!base.repositories)*(!!plugins.traffic))*18\r\n  + ((!!base.repositories)*(!!plugins.followup))*102\r\n  + ((!!base.repositories)*(!!plugins.lines))*34\r\n  + (!!plugins.pagespeed)*110 + (plugins.pagespeed?.detailed ?? 0)*6*16\r\n  + (!!plugins.languages)*124\r\n  + (!!plugins.gists)*58\r\n  + Math.max(0, (((!!base.metadata)+(!!base.header)+((!!base.activity)||(!!base.community))+(!!base.repositories)+(!!plugins.pagespeed)+(!!plugins.languages)+(!!plugins.gists))-1))*20\r\n%>\">\r\n  <%\r\n    meta.$ = `<span class=\"ps1-path\">${`${user.login}`.toLocaleLowerCase()}@metrics</span>:<span class=\"ps1-location\">~</span>${computed.token.scopes.includes(\"repo\") ? \"#\" : \"$\"}`\r\n    meta.animations = !meta.placeholder ? {stdin:.16, stdout:.28, length:(2+Object.keys(base).length+Object.keys(plugins).length)} : {stdin:0, stdout:0, length:0}\r\n  %>\r\n\r\n  <defs><style><%= fonts %></style></defs>\r\n\r\n  <style>\r\n    <%= style %>\r\n      .stdin, .stdout {\r\n        animation-duration: <%= meta.animations.stdin %>s;\r\n      }\r\n      .stdout {\r\n        animation-duration: <%= meta.animations.stdout %>s;\r\n      }\r\n      <% for (let i = 0, d = 0; i < meta.animations.length; i++, d+=meta.animations.stdin+meta.animations.stdout) { %>\r\n        .stdin:nth-of-type(<%= i+1 %>) {\r\n          animation-delay: <%= d %>s;\r\n        }\r\n        .stdout:nth-of-type(<%= i+2 %>) {\r\n          animation-delay: <%= d+meta.animations.stdin %>s;\r\n        }\r\n        <% if (i === meta.animations.length-1) { %>\r\n          footer {\r\n            animation-delay: <%= d %>s;\r\n          }\r\n        <% } %>\r\n      <% } %>\r\n  </style>\r\n\r\n  <foreignObject x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\r\n    <div xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n\r\n      <div class=\"header\">\r\n        <span class=\"title\"></span>\r\n        <div class=\"buttons\">\r\n          <div class=\"button\">─</div>\r\n          <div class=\"button\">□</div>\r\n          <div class=\"button exit\">✕</div>\r\n        </div>\r\n      </div>\r\n\r\n<pre><%# -%>\r\n<% if (base.metadata) { %>\r\n<div class=\"banner\"><%# -%>\r\nGitHub metrics generator <%= meta.version %>\r\nThese generated metrics comes with ABSOLUTELY NO\r\nWARRANTY, to the extent permitted by applicable law.\r\n\r\nLast generated: <%= new Date().toGMTString() %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.header) { %>\r\n<div class=\"stdin\"><%- meta.$ %> whoami</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<b><%= user.name || user.login %></b> registered=<%= computed.registration.match(/^.+? [ym]/)[0].replace(/ /g, \"\") %>, uid=<%= `${user.databaseId}`.substr(-4) %>, gid=<%= user.organizations.totalCount %>\r\n  contributed to <%= user.repositoriesContributedTo.totalCount %> repositor<%= s(user.repositoriesContributedTo.totalCount, \"y\") %> <b><% for (const [x, {color}] of Object.entries(computed.calendar)) { -%><span style=\"color:<%= color %>\">#</span><% } %></b>\r\n  followed by <b><%= user.followers.totalCount %></b> user<%= s(user.followers.totalCount) %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if ((base.activity)||(base.community)) { %>\r\n<div class=\"stdin\"><%- meta.$ %> git status</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (base.activity) { -%>\r\n<b>Recent activity</b>\r\n  <b><%= `${computed.commits}`.padStart(5) %></b> commit<%= s(computed.commits) %>\r\n  <b><%= `${user.contributionsCollection.totalPullRequestReviewContributions}`.padStart(5) %></b> pull request<%= s(user.contributionsCollection.totalPullRequestReviewContributions) %> reviewed\r\n  <b><%= `${user.contributionsCollection.totalPullRequestContributions}`.padStart(5) %></b> pull request<%= s(user.contributionsCollection.totalPullRequestContributions) %> opened\r\n  <b><%= `${user.contributionsCollection.totalIssueContributions}`.padStart(5) %></b> issue<%= s(user.contributionsCollection.totalIssueContributions) %> opened\r\n  <b><%= `${user.issueComments.totalCount}`.padStart(5) %></b> issue comment<%= s(user.issueComments.totalCount) %>\r\n<% } -%>\r\n<% if ((base.activity)&&(base.community)) { -%>\r\n\r\n<% } -%>\r\n<% if (base.community) { -%>\r\n<b>Tracked activity</b>\r\n  <b><%= `${user.following.totalCount}`.padStart(5) %></b> user<%= s(user.followers.totalCount) %> followed\r\n  <b><%= `${user.sponsorshipsAsSponsor.totalCount}`.padStart(5) %></b> repositor<%= s(user.sponsorshipsAsSponsor.totalCount, \"y\") %> sponsored\r\n  <b><%= `${user.starredRepositories.totalCount}`.padStart(5) %></b> repositor<%= s(user.starredRepositories.totalCount, \"y\") %> starred\r\n  <b><%= `${user.watching.totalCount}`.padStart(5) %></b> repositor<%= s(user.watching.totalCount, \"y\") %> watched\r\n<% } -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.repositories) { %>\r\n<div class=\"stdin\"><%- meta.$ %> ls -lh github/repositories</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\nTotal <%= user.repositories.totalCount %> repositor<%= s(user.repositories.totalCount, \"y\") %> - <%= computed.diskUsage %>\r\n<% if (plugins.traffic) { if (plugins.traffic.error) { -%>\r\n----  <b>     </b>  views <span class=\"error\">(<%= plugins.traffic.error.message %>)</span>\r\n<% } else { -%>\r\n-r--  <b><%= `${plugins.traffic.views.count}`.padStart(5) %></b>  views\r\n<% }} -%>\r\n-r--  <b><%= `${computed.repositories.stargazers}`.padStart(5) %></b>  stargazer<%= s(computed.repositories.stargazers) %>\r\n-r--  <b><%= `${computed.repositories.forks}`.padStart(5) %></b>  fork<%= s(computed.repositories.forks) %>\r\n-r--  <b><%= `${computed.repositories.watchers}`.padStart(5) %></b>  watcher<%= s(computed.repositories.watchers) %>\r\ndr-x  <b><%= `${user.packages.totalCount}`.padStart(5) %></b>  package<%= s(user.packages.totalCount) %>\r\n<% if (plugins.followup) { if (plugins.followup.error) { -%>\r\nd---  <b>     </b>  ISSUES <span class=\"error\">(<%= plugins.followup.error.message %>)</span>\r\nd---  <b>     </b>  PULL_REQUESTS <span class=\"error\">(<%= plugins.followup.error.message %>)</span>\r\n<% } else { -%>\r\ndr-x  <b><%= `${plugins.followup.issues.count}`.padStart(5) %></b>  ISSUES\r\n-r--  <b><%= `${plugins.followup.issues.open}`.padStart(5) %></b>  ├── open\r\n-r--  <b><%= `${plugins.followup.issues.closed}`.padStart(5) %></b>  └── closed\r\ndr-x  <b><%= `${plugins.followup.issues.count}`.padStart(5) %></b>  PULL_REQUESTS\r\n-r--  <b><%= `${plugins.followup.pr.open}`.padStart(5) %></b>  ├── open\r\n-r--  <b><%= `${plugins.followup.pr.merged}`.padStart(5) %></b>  └── merged\r\n<% }} -%>\r\n<% if (computed.licenses.favorite.length) { -%>\r\ndr-x         LICENSE\r\n-r--         └── <%= computed.licenses.favorite %>\r\n<% } -%>\r\n<% if (plugins.lines) { if (plugins.lines.error) { %>\r\n<span class=\"diff error\">@@ <%= plugins.lines.error.message %> @@</span><% } else { %>\r\n<span class=\"diff\">@@ -<%= plugins.lines.deleted %> +<%= plugins.lines.added %> @@</span>\r\n<% }} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.gists) { %>\r\n<div class=\"stdin\"><%- meta.$ %> ls -lh github/gists</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\nTotal <%= plugins.gists.totalCount %> gist<%= s(plugins.gists.totalCount) %>\r\n-r--  <b><%= `${plugins.gists.stargazers}`.padStart(5) %></b>  stargazer<%= s(plugins.gists.stargazers) %>\r\n-r--  <b><%= `${plugins.gists.forks}`.padStart(5) %></b>  fork<%= s(plugins.gists.forks) %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.languages) { %>\r\n<div class=\"stdin\"><%- meta.$ %> locale</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (plugins.languages.error) { -%>\r\n<span class=\"error\"><%= plugins.languages.error.message %></span><%# -%>\r\n<% } else { for (const {name, value} of plugins.languages.favorites) { -%>\r\n<b><%= name.toLocaleUpperCase().padEnd(12) %></b> [<%= \"#\".repeat(Math.ceil(100*value/5)).padEnd(20) %>] <%= (100*value).toFixed(2).padEnd(5) %>%\r\n<% }} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.pagespeed) { %>\r\n<div class=\"stdin\"><%- meta.$ %> curl -<%= plugins.pagespeed.detailed ? \"v\" : \"\" %>I <%= user.websiteUrl %></div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (plugins.pagespeed.error) { -%>\r\n<span class=\"error\"><%= plugins.pagespeed.error.message %></span><% } else { -%>\r\n<b>User-Agent</b>: Google PageSpeed API\r\n<b>Location</b>: <%= user.websiteUrl %>\r\n<% for (const {score, title} of plugins.pagespeed.scores) { -%>\r\n<b><%= `X-${title.replace(/ /g, \"-\")}` %></b>: <%= !Number.isNaN(score) ? Math.round(score*100) : \"-\" %>%\r\n<% } -%>\r\n<% if (plugins.pagespeed.detailed) { for (const {name, score, suffix = \"\", threshold} of [\r\n  {name:\"Time to interactive\", score:plugins.pagespeed.metrics.interactive/1000, suffix:\"s\", threshold:[3.785, 7.3]},\r\n  {name:\"Speed Index\", score:plugins.pagespeed.metrics.speedIndex/1000, suffix:\"s\", threshold:[3.387, 5.8]},\r\n  {name:\"Total Blocking Time\", score:plugins.pagespeed.metrics.totalBlockingTime/1000, suffix:\"s\", threshold:[.287, .6]},\r\n  {name:\"First Contentful Paint\", score:plugins.pagespeed.metrics.firstContentfulPaint/1000, suffix:\"s\", threshold:[2.336, 4]},\r\n  {name:\"Largest Contentful Paint\", score:plugins.pagespeed.metrics.largestContentfulPaint/1000, suffix:\"s\", threshold:[2.5, 4]},\r\n  {name:\"Cumulative Layout Shift\", score:+plugins.pagespeed.metrics.cumulativeLayoutShift, threshold:[.1, .25]}\r\n]) { -%>\r\n<b>&gt; <%= name %></b>: <%= !Number.isNaN(score) ? score : \"-\" %><%= suffix %> <% if (Number.isNaN(score)) { %><% } else if (score <= threshold[0]) { %>(ok +)<% } else if (score <= threshold[1]) { %>(ok)<% } else { %>(bad)<% } %>\r\n<% }}} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.metadata) { -%>\r\n\r\n<footer>Connection reset by <%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %></footer><%# -%>\r\n<% } -%></pre>\r\n\r\n    </div>\r\n  </foreignObject>\r\n</svg>\r\n\r\n","style":"/* SVG global context */\r\n  svg {\r\n    font-family: 'Courier Prime';\r\n    font-size: 14px;\r\n    color: #777777;\r\n  }\r\n\r\n/* Title bar */\r\n  .header {\r\n    position: absolute;\r\n    top: 0;\r\n    display: flex;\r\n    justify-content: space-between;\r\n    width: 100%;\r\n    height: 20px;\r\n    align-items: center;\r\n    padding: 0 8px;\r\n    box-sizing: border-box;\r\n    border-top-left-radius: 5px;\r\n    border-top-right-radius: 5px;\r\n    background: linear-gradient(#504b45 0%,#3c3b37 100%);\r\n  }\r\n\r\n  .title {\r\n    color: #d5d0ce;\r\n    font-size: 16px;\r\n  }\r\n\r\n  .buttons {\r\n    display: flex;\r\n    align-items: center;\r\n  }\r\n\r\n  .button {\r\n    color: black;\r\n    display: flex;\r\n    justify-content: center;\r\n    margin-right: 5px;\r\n    font-size: 8px;\r\n    height: 12px;\r\n    width: 12px;\r\n    border-radius: 100%;\r\n    background: linear-gradient(#7d7871 0%, #595953 100%);\r\n    text-shadow: 0px 1px 0px rgba(255,255,255,0.2);\r\n  }\r\n\r\n  .button.exit {\r\n    background: linear-gradient(#f37458 0%, #de4c12 100%);\r\n  }\r\n\r\n/* Terminal */\r\n  pre, .banner, footer {\r\n    margin: 0;\r\n    font-family: 'Courier Prime';\r\n    color: #DDDDDD;\r\n  }\r\n  pre {\r\n    background: #42092B;\r\n    padding: 12px;\r\n    border-radius: 5px;\r\n  }\r\n  .banner, footer {\r\n    color: #AE9DA7;\r\n  }\r\n\r\n/* Prompt */\r\n  .ps1-path {\r\n    color: #7EDA29;\r\n  }\r\n\r\n  .ps1-location {\r\n    color: #4878c0;\r\n  }\r\n\r\n/* Diff */\r\n  .diff {\r\n    color: #3A96DD;\r\n  }\r\n\r\n/* Error */\r\n  .error {\r\n    color: #cb2431;\r\n  }\r\n\r\n/* Animations */\r\n  .stdin, footer {\r\n    width: 0%;\r\n    white-space: nowrap;\r\n    overflow: hidden;\r\n    animation-name: stdin-animation;\r\n    animation-fill-mode: both;\r\n  }\r\n\r\n  .stdout {\r\n    max-height: 0%;\r\n    overflow: hidden;\r\n    animation-name: stdout-animation;\r\n    animation-fill-mode: both;\r\n  }\r\n\r\n  @keyframes stdin-animation {\r\n    0% { width: 0%; }\r\n    100% { width: 100%; }\r\n  }\r\n\r\n  @keyframes stdout-animation {\r\n    0% { max-height: 0; }\r\n    100% { max-height: 360px; }\r\n  }\r\n\r\n/* Calendar */\r\n  :root {\r\n    --color-calendar-graph-day-bg: #ebedf0;\r\n    --color-calendar-graph-day-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-bg: #9be9a8;\r\n    --color-calendar-graph-day-L2-bg: #40c463;\r\n    --color-calendar-graph-day-L3-bg: #30a14e;\r\n    --color-calendar-graph-day-L4-bg: #216e39;\r\n    --color-calendar-halloween-graph-day-L1-bg: #ffee4a;\r\n    --color-calendar-halloween-graph-day-L2-bg: #ffc501;\r\n    --color-calendar-halloween-graph-day-L3-bg: #fe9600;\r\n    --color-calendar-halloween-graph-day-L4-bg: #03001c;\r\n    --color-calendar-graph-day-L4-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L3-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L2-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-border: rgba(27,31,35,0.06);\r\n  }","fonts":"@font-face {\r\n  font-family: 'Courier Prime';\r\n  src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff');\r\n  font-weight: normal;\r\n  font-style: normal;\r\n  font-display: swap;\r\n}\r\n\r\n@font-face {\r\n  font-family: 'Courier Prime';\r\n  src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff');\r\n  font-weight: bold;\r\n  font-style: normal;\r\n  font-display: swap;\r\n}\r\n"}}`,"base64").toString("utf8"));return t(`metrics/setup > setup > success`),a}async function a({login:e,imports:t,q:r},{enabled:n=!1,token:a=""}={}){try{if(!n||!r.music)return null;const o={get provider(){return _[s]?.name??""},get mode(){return w[l]??"Unconfigured music plugin"}};let i=null,{"music.provider":s="","music.mode":l="","music.playlist":d=null,"music.limit":p=4}=r;if(d&&!l&&(l="playlist"),d&&!s)for(const[e,{embed:t}]of Object.entries(_))t.test(d)&&(s=e);if(l||(l="recent"),!(s in _))throw{error:{message:s?`Unsupported provider "${s}"`:`Missing provider`},...o};if(!(l in w))throw{error:{message:`Unsupported mode "${l}"`},...o};if("playlist"===l){if(!d)throw{error:{message:`Missing playlist url`},...o};if(!_[s].embed.test(d))throw{error:{message:`Unsupported playlist url format`},...o}}switch(p=_Mathmax(1,_Mathmin(100,+p)),console.debug(`metrics/compute/${e}/plugins > music > processing mode ${l} with provider ${s}`),l){case"playlist":{console.debug(`metrics/compute/${e}/plugins > music > starting browser`);const r=await t.puppeteer.launch({headless:!0,executablePath:process.env.PUPPETEER_BROWSER_PATH,args:["--no-sandbox","--disable-extensions","--disable-setuid-sandbox","--disable-dev-shm-usage"]});console.debug(`metrics/compute/${e}/plugins > music > started ${await r.version()}`);const n=await r.newPage();console.debug(`metrics/compute/${e}/plugins > music > loading page`),await n.goto(d);const a=n.mainFrame();switch(s){case"apple":{await a.waitForSelector(".tracklist.playlist"),i=[...(await a.evaluate(()=>[...document.querySelectorAll(".tracklist li")].map(e=>({name:e.querySelector(".tracklist__track__name").innerText,artist:e.querySelector(".tracklist__track__sub").innerText,artwork:e.querySelector(".tracklist__track__artwork img").src}))))];break}case"spotify":{await a.waitForSelector("table"),i=[...(await a.evaluate(()=>[...document.querySelectorAll("table tr")].map(e=>({name:e.querySelector("td:nth-child(2) div:nth-child(1)").innerText,artist:e.querySelector("td:nth-child(2) div:nth-child(2)").innerText,artwork:window.getComputedStyle(document.querySelector("button[title=Play]").parentNode,null).backgroundImage.match(/^url\("(https:...+)"\)$/)[1]}))))];break}default:throw{error:{message:`Unsupported mode "${l}" for provider "${s}"`},...o};}console.debug(`metrics/compute/${e}/plugins > music > closing browser`),await r.close(),Array.isArray(i)&&(console.debug(`metrics/compute/${e}/plugins > music > found ${i.length} tracks`),console.debug(t.util.inspect(i,{depth:1/0,maxStringLength:256})),i=t.shuffle(i));break}case"recent":{const r=Date.now()-86400000;switch(s){case"spotify":{const[n,s,l]=a.split(",").map(e=>e.trim());if(!n||!s||!l)throw{error:{message:`Spotify token must contain client id/secret and refresh token`}};try{console.debug(`metrics/compute/${e}/plugins > music > requesting access token with spotify refresh token`);const{data:{access_token:a}}=await t.axios.post("https://accounts.spotify.com/api/token",`${new t.url.URLSearchParams({grant_type:"refresh_token",refresh_token:l,client_id:n,client_secret:s})}`,{headers:{"Content-Type":"application/x-www-form-urlencoded"}});console.debug(`metrics/compute/${e}/plugins > music > got access token`),console.debug(`metrics/compute/${e}/plugins > music > querying spotify api`),i=(await t.axios(`https://api.spotify.com/v1/me/player/recently-played?limit=${p}&after=${r}`,{headers:{Accept:"application/json","Content-Type":"application/json",Authorization:`Bearer ${a}`}})).data.items.map(({track:e})=>({name:e.name,artist:e.artists[0].name,artwork:e.album.images[0].url}))}catch(e){if(e.isAxiosError){const t=e.response?.status,r=e.response.data?.error_description??null;throw message=`API returned ${t}${r?` (${r})`:""}`,e=e.response?.data??null,{error:{message,instance:e},...o}}throw e}break}default:throw{error:{message:`Unsupported mode "${l}" for provider "${s}"`},...o};}break}default:throw{error:{message:`Unsupported mode "${l}"`},...o};}if(Array.isArray(i)){0 music > keeping only ${p} tracks`),i=i.slice(0,p)),console.debug(`metrics/compute/${e}/plugins > music > loading artworks`);for(const r of i)console.debug(`metrics/compute/${e}/plugins > music > processing ${r.name}`),r.artwork=await t.imgb64(r.artwork);return{...o,tracks:i}}throw{error:{message:`An error occured (could not retrieve tracks)`}}}catch(e){if(e.error?.message)throw e;throw{error:{message:"An error occured",instance:e}}}}async function o({login:e,q:t,dflags:r},{conf:n,data:a,rest:o,graphql:i,plugins:l},{s:d,pending:s,imports:p}){const c=a.computed={commits:0,sponsorships:0,licenses:{favorite:"",used:{}},token:{},repositories:{watchers:0,stargazers:0,issues_open:0,issues_closed:0,pr_open:0,pr_merged:0,forks:0,releases:0}},u=p.imgb64(a.user.avatarUrl);if(a.plugins={},console.debug(`metrics/compute/${e} > formatting common metrics`),t["config.timezone"]){const r=a.config.timezone={name:t["config.timezone"],offset:0};try{r.offset=+(1e3*(60*(60*new Date().toLocaleString("fr",{timeZoneName:"short",timeZone:r.name}).match(/UTC[+](?\d+)/)?.groups?.offset)))||0,console.debug(`metrics/compute/${e} > timezone set to ${r.name} (${0 failed to use timezone "${r.name}"`)}}for(const u of Object.keys(p.plugins))s.push((async()=>{try{console.debug(`metrics/compute/${e}/plugins > ${u} > started`),a.plugins[u]=await p.plugins[u]({login:e,q:t,imports:p,data:a,computed:c,rest:o,graphql:i},l[u]),console.debug(`metrics/compute/${e}/plugins > ${u} > completed (${null===a.plugins[u]?"skipped":"success"})`)}catch(t){console.debug(`metrics/compute/${e}/plugins > ${u} > completed (error)`),a.plugins[u]=t}finally{const e={name:u,result:a.plugins[u]};return console.debug(p.util.inspect(e,{depth:1/0,maxStringLength:256})),e}})());for(const u of a.user.repositories.nodes){for(const e of["watchers","stargazers","issues_open","issues_closed","pr_open","pr_merged","releases"])c.repositories[e]+=u[e].totalCount;c.repositories.forks+=u.forkCount,u.licenseInfo&&(c.licenses.used[u.licenseInfo.spdxId]=(c.licenses.used[u.licenseInfo.spdxId]??0)+1)}c.diskUsage=`${p.bytes(1e3*a.user.repositories.totalDiskUsage)}`,c.licenses.favorite=Object.entries(c.licenses.used).sort(([e,t],[r,n])=>n-t).slice(0,1).map(([e,t])=>e)??"",c.commits+=a.user.contributionsCollection.totalCommitContributions+a.user.contributionsCollection.restrictedContributionsCount;const m=(Date.now()-new Date(a.user.createdAt).getTime())/31536000000,g=_Mathfloor(m),h=_Mathceil(12*(m-g));c.registration=g?`${g} year${d(g)} ago`:`${h} month${d(h)} ago`,c.cakeday=[new Date,new Date(a.user.createdAt)].map(e=>e.toISOString().match(/(?\d{2}-\d{2})(?=T)/)?.groups?.mmdd).every((e,t,r)=>e===r[0]),c.calendar=a.user.calendar.contributionCalendar.weeks.flatMap(({contributionDays:e})=>e).slice(0,14).reverse(),c.avatar=(await u)||"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",c.token.scopes=(await o.request("HEAD /")).headers["x-oauth-scopes"].split(", "),a.meta={version:n.package.version,author:n.package.author},(r.includes("--cakeday")||t["dflag.cakeday"])&&(console.debug(`metrics/compute/${e} > applying dflag --cakeday`),c.cakeday=!0),(r.includes("--hireable")||t["dflag.hireable"])&&(console.debug(`metrics/compute/${e} > applying dflag --hireable`),a.user.isHireable=!0)}async function i({login:e,q:t,dflags:r=[]},{graphql:n,rest:a,plugins:o,conf:i,die:h=!1}){try{console.debug(`metrics/compute/${e} > start`),console.debug(S.inspect(t,{depth:1/0,maxStringLength:256}));const f=t.template||i.settings.templates.default,y=_Mathmax(0,+t.repositories)||i.settings.repositories||100,_=[],w=(e,t="")=>1 graphql query`),Object.assign(M,await n(s.replace(/[$]login/,`"${e}"`).replace(/[$]repositories/,`${y}`).replace(/[$]calendar.to/,`"${new Date().toISOString()}"`).replace(/[$]calendar.from/,`"${new Date(Date.now()-1209600000).toISOString()}"`))),console.debug(`metrics/compute/${e} > compute`);const g=E[f].default||E[f];await g({login:e,q:t,dflags:r},{conf:i,data:M,rest:a,graphql:n,plugins:o},{s:w,pending:_,imports:{plugins:T,url:O,imgb64:k,axios:C,puppeteer:A,run:m,fs:L,os:z,paths:b,util:S,format:l,bytes:d,shuffle:p,htmlescape:c,urlexpand:u}});const x=await Promise.all(_);{const e=x.filter(({result:e=null})=>e?.error);if(!h)console.warn(`${e.length} error${w(e.length)} found, ignoring...`),console.warn(S.inspect(e,{depth:1/0,maxStringLength:256}));else if(e.length)throw new Error(`${e.length} error${w(e.length)} found...`)}}console.debug(`metrics/compute/${e} > render`);let W=await x.render(P,{...M,s:w,style:R,fonts:I},{async:!0});if(i.optimize&&!t.raw){console.debug(`metrics/compute/${e} > optimize`);const t=new v({full:!0,plugins:[{cleanupAttrs:!0},{inlineStyles:!1}]}),{data:r}=await t.optimize(W);W=r}return console.debug(`metrics/compute/${e} > success`),W}catch(e){if(Array.isArray(e.errors)&&"NOT_FOUND"===e.errors[0].type)throw new Error("user not found");throw e}}function l(e){for(const{u:t,v:r}of[{u:"b",v:1000000000},{u:"m",v:1000000},{u:"k",v:1000}])if(1<=e/r)return`${(e/r).toFixed(2).substr(0,4).replace(/[.]0*$/,"")}${t}`;return e}function d(e){for(const{u:t,v:r}of[{u:"E",v:1000000000000000000},{u:"P",v:1000000000000000},{u:"T",v:1000000000000},{u:"G",v:1000000000},{u:"M",v:1000000},{u:"k",v:1000}])if(1<=e/r)return`${(e/r).toFixed(2).substr(0,4).replace(/[.]0*$/,"")} ${t}B`;return`${e} byte${1":!0,'"':!0,"'":!0}){return e.replace(/&(?!(?:amp|lt|gt|quot|apos);)/g,t["&"]?"&":"&").replace(//g,t[">"]?">":">").replace(/"/g,t["\""]?""":"\"").replace(/'/g,t["'"]?"'":"'")}async function u(e){try{return(await C.get(e)).request.res.responseUrl}catch{return e}}async function m(e,t){return await new Promise((r,n)=>{console.debug(`metrics/command > ${e}`);const a=P.exec(e,t);let[o,i]=["",""];a.stdout.on("data",e=>o+=e),a.stderr.on("data",e=>i+=e),a.on("close",t=>(console.debug(`metrics/command > ${e} > exited with code ${t}`),0===t?r(o):n(i)))})}function g({data:e,conf:t,q:r}){const n=e=>"object"==typeof e?new Proxy(e,{get(e,t){return t===Symbol.toPrimitive?()=>"##":t===Symbol.iterator?Reflect.get(e,t):/^plugins$/.test(t)?Reflect.get(e,t):/^error/.test(t)?void 0:n(t in e?Reflect.get(e,t):{})}}):e,a=Object.entries(t.settings.plugins).filter(([e,t])=>t.enabled).map(([e])=>e).filter(e=>e in r&&r[e]);Object.assign(e,{s(e,t){return"y"===t?"ies":"s"},meta:{version:t.package.version,author:t.package.author,placeholder:!0},user:n({name:`############`,websiteUrl:`########################`,isHireable:!1}),computed:n({avatar:"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mOcOnfpfwAGfgLYttYINwAAAABJRU5ErkJggg==",registration:"## years ago",cakeday:!1,calendar:Array(14).fill({color:"#ebedf0"}),licenses:{favorite:`########`},token:{scopes:[]}}),plugins:Object.fromEntries(a.map(e=>[e,n({posts:{source:"########",list:Array("posts.limit"in r?_Mathmax(+r["posts.limit"]||0,0):2).fill({title:"###### ###### ####### ######",date:"####"})},music:{provider:"########",tracks:Array("music.limit"in r?_Mathmax(+r["music.limit"]||0,0):4).fill({name:"##########",artist:"######",artwork:"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mOcOnfpfwAGfgLYttYINwAAAABJRU5ErkJggg=="})},pagespeed:{detailed:!!r["pagespeed.detailed"],scores:["Performance","Accessibility","Best Practices","SEO"].map(e=>({title:e,score:NaN}))},followup:{issues:{count:0},pr:{count:0}},habits:{facts:!!(r["habits.facts"]??1),charts:!!r["habits.charts"],indents:{style:`########`},commits:{day:"####"},linguist:{ordered:[]}},languages:{favorites:Array(7).fill(null).map((e,t)=>({x:t,name:"######",color:"#ebedf0",value:1/(t+1)}))},topics:{list:[...Array("topics.limit"in r?_Mathmax(+r["topics.limit"]||0,0):12).fill(null).map(()=>({name:"######",description:"",icon:null})),{name:`And ## more...`,description:"",icon:null}]},projects:{list:[...Array("projects.limit"in r?_Mathmax(+r["projects.limit"]||0,0):4).fill(null).map(()=>({name:"########",updated:"########",progress:{enabled:!0,todo:"##",doing:"##",done:"##",total:"##"}}))]},tweets:{profile:{username:"########",verified:!1},list:[...Array("tweets.limit"in r?_Mathmax(+r["tweets.limit"]||0,0):2).fill(null).map(()=>({text:"###### ###### ####### ######".repeat(4),created_at:Date.now()}))]}}[e]??{})]))})}r.r(t);var h={};r.r(h),r.d(h,{default:()=>n});var f={};r.r(f),r.d(f,{default:()=>i});var y=r(35747),b=r(85622),S=r(31669),x=r(58509),v=r(20485),k=r(67192),C=r(2390);const _={apple:{name:"Apple Music",embed:/^https:..embed.music.apple.com.\w+.playlist/},spotify:{name:"Spotify",embed:/^https:..open.spotify.com.embed.playlist/}},w={playlist:"Suggested tracks",recent:"Recently played"},T={followup:async function({computed:e,q:t},{enabled:r=!1}={}){try{if(!r||!t.followup)return null;const n={issues:{get count(){return this.open+this.closed},get open(){return e.repositories.issues_open},get closed(){return e.repositories.issues_closed}},pr:{get count(){return this.open+this.merged},get open(){return e.repositories.pr_open},get merged(){return e.repositories.pr_merged}}};return n}catch(e){throw{error:{message:"An error occured",instance:e}}}},gists:async function({login:e,graphql:t,q:r},{enabled:n=!1}={}){try{if(!n||!r.gists)return null;console.debug(`metrics/compute/${e}/plugins > gists > querying api`);const{user:{gists:a}}=await t(` +module.exports=(()=>{var _Mathhypot=Math.hypot,_Mathacos=Math.acos,_Mathtan=Math.tan,_Mathasin=Math.asin,_Mathsin=Math.sin,_Mathcos=Math.cos,_MathPI=Math.PI,_Mathsqrt=Math.sqrt,_NumberisInteger=Number.isInteger,_NumberPOSITIVE_INFINITY=Number.POSITIVE_INFINITY,_NumberNEGATIVE_INFINITY=Number.NEGATIVE_INFINITY,_Stringprototype=String.prototype,_NumberMAX_SAFE_INTEGER=Number.MAX_SAFE_INTEGER,_StringfromCharCode=String.fromCharCode,_Mathabs=Math.abs,_Mathpow=Math.pow,_Mathround=Math.round,_Mathfloor=Math.floor,_Mathceil=Math.ceil,_Mathmax=Math.max,_Mathmin=Math.min;function __webpack_require__(e){if(__webpack_module_cache__[e])return __webpack_module_cache__[e].exports;var t=__webpack_module_cache__[e]={exports:{}},r=!0;try{__webpack_modules__[e].call(t.exports,t,t.exports,__webpack_require__),r=!1}finally{r&&delete __webpack_module_cache__[e]}return t.exports}var __webpack_modules__={45274:(e,t,r)=>{"use strict";async function n({log:e=!0}={}){const t=e?console.debug:()=>null;t(`metrics/setup > setup`);const n="src/templates",a={templates:{},settings:{},statics:r.ab+"html",node_modules:b.resolve("node_modules")};if(t(`metrics/setup > load settings.json`),y.existsSync(r.ab+"settings.json")?(a.settings=JSON.parse(`${await y.promises.readFile(b.resolve("settings.json"))}`),t(`metrics/setup > load settings.json > success`)):t(`metrics/setup > load settings.json > (missing)`),a.settings.templates||(a.settings.templates={default:"classic",enabled:[]}),a.settings.plugins||(a.settings.plugins={}),a.settings.plugins.base={parts:["header","activity","community","repositories","metadata"]},a.settings.debug&&t(S.inspect(a.settings,{depth:1/0,maxStringLength:256})),t(`metrics/setup > load package.json`),y.existsSync(r.ab+"package.json")?(a.package=JSON.parse(`${await y.promises.readFile(b.resolve("package.json"))}`),t(`metrics/setup > load package.json > success`)):(t(`metrics/setup > load package.json > (missing)`),a.package={version:"2.9.0",author:"lowlighter"}),y.existsSync(r.ab+"templates"))for(const e of await y.promises.readdir(n)){if(/.*[.]mjs$/.test(e))continue;t(`metrics/setup > load template [${e}]`);const r=[`${n}/${e}/query.graphql`,`${n}/${e}/image.svg`,`${n}/${e}/style.css`,`${n}/${e}/fonts.css`],[o,i,s,l]=await Promise.all(r.map(async e=>`${await y.promises.readFile(b.resolve(e))}`));a.templates[e]={query:o,image:i,style:s,fonts:l},t(`metrics/setup > load template [${e}] > success`),a.settings.debug&&Object.defineProperty(a.templates,e,{get(){t(`metrics/setup > reload template [${e}]`);const[n,a,o,i]=r.map(e=>`${y.readFileSync(b.resolve(e))}`);return t(`metrics/setup > reload template [${e}] > success`),{query:n,image:a,style:o,fonts:i}}})}else t(`metrics/setup > load templates from build`),a.templates=JSON.parse(Buffer.from(`{"classic":{"query":"query Metrics {\r\n  user(login: $login) {\r\n    databaseId\r\n    name\r\n    login\r\n    createdAt\r\n    avatarUrl\r\n    websiteUrl\r\n    isHireable\r\n    twitterUsername\r\n    gists {\r\n      totalCount\r\n    }\r\n    repositories(last: $repositories, isFork: false, ownerAffiliations: OWNER) {\r\n      totalCount\r\n      totalDiskUsage\r\n      nodes {\r\n        name\r\n        watchers {\r\n          totalCount\r\n        }\r\n        stargazers {\r\n          totalCount\r\n        }\r\n        languages(first: 4) {\r\n          edges {\r\n            size\r\n            node {\r\n              color\r\n              name\r\n            }\r\n          }\r\n        }\r\n        issues_open: issues(states: OPEN) {\r\n          totalCount\r\n        }\r\n        issues_closed: issues(states: CLOSED) {\r\n          totalCount\r\n        }\r\n        pr_open: pullRequests(states: OPEN) {\r\n          totalCount\r\n        }\r\n        pr_merged: pullRequests(states: MERGED) {\r\n          totalCount\r\n        }\r\n        releases {\r\n          totalCount\r\n        }\r\n        forkCount\r\n        licenseInfo {\r\n          spdxId\r\n        }\r\n      }\r\n    }\r\n    packages {\r\n      totalCount\r\n    }\r\n    starredRepositories {\r\n      totalCount\r\n    }\r\n    watching {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsSponsor {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsMaintainer {\r\n      totalCount\r\n    }\r\n    contributionsCollection {\r\n      totalRepositoriesWithContributedCommits\r\n      totalCommitContributions\r\n      restrictedContributionsCount\r\n      totalIssueContributions\r\n      totalPullRequestContributions\r\n      totalPullRequestReviewContributions\r\n    }\r\n    calendar:contributionsCollection(from: $calendar.from, to: $calendar.to) {\r\n      contributionCalendar {\r\n        weeks {\r\n          contributionDays {\r\n            color\r\n          }\r\n        }\r\n      }\r\n    }\r\n    repositoriesContributedTo {\r\n      totalCount\r\n    }\r\n    followers {\r\n      totalCount\r\n    }\r\n    following {\r\n      totalCount\r\n    }\r\n    issueComments {\r\n      totalCount\r\n    }\r\n    organizations {\r\n      totalCount\r\n    }\r\n  }\r\n}\r\n","image":"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"480\" height=\"<%= 12\r\n  + (!!base.header)*80 + (user.isHireable)*16\r\n  + (!!base.metadata)*38\r\n  + ((!!base.activity)||(!!base.community))*128\r\n  + (!!base.repositories)*108\r\n  + ((!!base.repositories)*((!!plugins.traffic)||(!!plugins.lines)))*16\r\n  + (!!plugins.followup)*68\r\n  + (!!plugins.pagespeed)*126 + (plugins.pagespeed?.detailed ?? 0)*6*20\r\n  + (!!plugins.habits)*28 + (!!plugins.habits?.facts)*58 + (!!plugins.habits?.charts)*226\r\n  + (!!plugins.languages)*96\r\n  + (!!plugins.music)*64 + (plugins.music?.tracks?.length ? 14+Math.max(0, plugins.music.tracks.length-1)*36 : 0)\r\n  + (!!plugins.posts)*64 + (plugins.posts?.list?.length ?? 0)*40\r\n  + (!!plugins.isocalendar)*192 + (plugins.isocalendar?.duration === 'full-year')*100\r\n  + (!!plugins.gists)*68\r\n  + (!!plugins.topics)*160\r\n  + (!!plugins.projects)*22 + (plugins.projects?.list?.length ?? 0)*60 + (!!plugins.projects?.error)*22\r\n  + (!!plugins.tweets)*64 + (plugins.tweets?.list?.length ?? 0)*90\r\n  + Math.max(0, (((!!base.metadata)+(!!base.header)+((!!base.activity)||(!!base.community))+(!!base.repositories)+((!!plugins.habits))+(!!plugins.pagespeed)+(!!plugins.languages)+(!!plugins.music)+(!!plugins.posts)+(!!plugins.isocalendar)+(!!plugins.gists)+(!!plugins.topics)+(!!plugins.projects))-1))*4\r\n%>\">\r\n\r\n  <defs><style><%= fonts %></style></defs>\r\n\r\n  <style>\r\n    <%= style %>\r\n  </style>\r\n\r\n  <foreignObject x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\r\n    <div xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n\r\n      <% if (base.header) { %>\r\n        <section>\r\n          <h1 class=\"field\">\r\n            <img class=\"avatar\" src=\"data:image/png;base64,<%= computed.avatar %>\" width=\"20\" height=\"20\" />\r\n            <span><%= user.name || user.login %></span>\r\n          </h1>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field <%= computed.cakeday ? 'cakeday' : '' %>\">\r\n                <% if (computed.cakeday) { %>\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 1.5a1.25 1.25 0 100 2.5h2.309c-.233-.818-.542-1.401-.878-1.793-.43-.502-.915-.707-1.431-.707zM2 2.75c0 .45.108.875.3 1.25h-.55A1.75 1.75 0 000 5.75v2c0 .698.409 1.3 1 1.582v4.918c0 .966.784 1.75 1.75 1.75h10.5A1.75 1.75 0 0015 14.25V9.332c.591-.281 1-.884 1-1.582v-2A1.75 1.75 0 0014.25 4h-.55a2.75 2.75 0 00-2.45-4c-.984 0-1.874.42-2.57 1.23A5.086 5.086 0 008 2.274a5.086 5.086 0 00-.68-1.042C6.623.42 5.733 0 4.75 0A2.75 2.75 0 002 2.75zM8.941 4h2.309a1.25 1.25 0 100-2.5c-.516 0-1 .205-1.43.707-.337.392-.646.975-.879 1.793zm-1.84 1.5H1.75a.25.25 0 00-.25.25v2c0 .138.112.25.25.25h5.5V5.5h-.149zm1.649 0V8h5.5a.25.25 0 00.25-.25v-2a.25.25 0 00-.25-.25h-5.5zm0 4h4.75v4.75a.25.25 0 01-.25.25h-4.5v-5zm-1.5 0v5h-4.5a.25.25 0 01-.25-.25V9.5h4.75z\"></path></svg>\r\n                  Joined GitHub <%= computed.registration %>\r\n                <% } else { %>\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm.5 4.75a.75.75 0 00-1.5 0v3.5a.75.75 0 00.471.696l2.5 1a.75.75 0 00.557-1.392L8.5 7.742V4.75z\"></path></svg>\r\n                  Joined GitHub <%= computed.registration %>\r\n                <% } %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.5 3.5a2 2 0 100 4 2 2 0 000-4zM2 5.5a3.5 3.5 0 115.898 2.549 5.507 5.507 0 013.034 4.084.75.75 0 11-1.482.235 4.001 4.001 0 00-7.9 0 .75.75 0 01-1.482-.236A5.507 5.507 0 013.102 8.05 3.49 3.49 0 012 5.5zM11 4a.75.75 0 100 1.5 1.5 1.5 0 01.666 2.844.75.75 0 00-.416.672v.352a.75.75 0 00.574.73c1.2.289 2.162 1.2 2.522 2.372a.75.75 0 101.434-.44 5.01 5.01 0 00-2.56-3.012A3 3 0 0011 4z\"></path></svg>\r\n                Followed by <%= user.followers.totalCount %> user<%= s(user.followers.totalCount) %>\r\n              </div>\r\n              <% if (user.isHireable) { %>\r\n                <div class=\"field hire\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M6.75 0A1.75 1.75 0 005 1.75V3H1.75A1.75 1.75 0 000 4.75v8.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0016 13.25v-8.5A1.75 1.75 0 0014.25 3H11V1.75A1.75 1.75 0 009.25 0h-2.5zM9.5 3V1.75a.25.25 0 00-.25-.25h-2.5a.25.25 0 00-.25.25V3h3zM5 4.5H1.75a.25.25 0 00-.25.25V6a2 2 0 002 2h9a2 2 0 002-2V4.75a.25.25 0 00-.25-.25H5zm-1.5 5a3.484 3.484 0 01-2-.627v4.377c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25V8.873a3.484 3.484 0 01-2 .627h-9z\"></path></svg>\r\n                  Available for hire !\r\n                </div>\r\n              <% } %>\r\n            </section>\r\n            <section>\r\n              <div class=\"field calendar\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 <%= computed.calendar.length*15 %> 11\" width=\"<%= computed.calendar.length*15 %>\" height=\"16\">\r\n                  <g>\r\n                    <% for (const [x, {color}] of Object.entries(computed.calendar)) { %>\r\n                      <rect class=\"day\" x=\"<%= x*15 %>\" y=\"0\" width=\"11\" height=\"11\" fill=\"<%= color %>\" rx=\"2\" ry=\"2\" />\r\n                    <% } %>\r\n                  </g>\r\n                </svg>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1 2.5A2.5 2.5 0 013.5 0h8.75a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0V1.5h-8a1 1 0 00-1 1v6.708A2.492 2.492 0 013.5 9h3.25a.75.75 0 010 1.5H3.5a1 1 0 100 2h5.75a.75.75 0 010 1.5H3.5A2.5 2.5 0 011 11.5v-9zm13.23 7.79a.75.75 0 001.06-1.06l-2.505-2.505a.75.75 0 00-1.06 0L9.22 9.229a.75.75 0 001.06 1.061l1.225-1.224v6.184a.75.75 0 001.5 0V9.066l1.224 1.224z\"></path></svg>\r\n                Contributed to <%= user.repositoriesContributedTo.totalCount %> repositor<%= s(user.repositoriesContributedTo.totalCount, \"y\") %>\r\n              </div>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <div class=\"row\">\r\n        <% if (base.activity) { %>\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 1.75a.75.75 0 00-1.5 0v12.5c0 .414.336.75.75.75h14.5a.75.75 0 000-1.5H1.5V1.75zm14.28 2.53a.75.75 0 00-1.06-1.06L10 7.94 7.53 5.47a.75.75 0 00-1.06 0L3.22 8.72a.75.75 0 001.06 1.06L7 7.06l2.47 2.47a.75.75 0 001.06 0l5.25-5.25z\"></path></svg>\r\n              Activity\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M10.5 7.75a2.5 2.5 0 11-5 0 2.5 2.5 0 015 0zm1.43.75a4.002 4.002 0 01-7.86 0H.75a.75.75 0 110-1.5h3.32a4.001 4.001 0 017.86 0h3.32a.75.75 0 110 1.5h-3.32z\"></path></svg>\r\n              <%= computed.commits %> Commit<%= s(computed.commits) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 1.75a.25.25 0 01.25-.25h8.5a.25.25 0 01.25.25v7.736a.75.75 0 101.5 0V1.75A1.75 1.75 0 0011.25 0h-8.5A1.75 1.75 0 001 1.75v11.5c0 .966.784 1.75 1.75 1.75h3.17a.75.75 0 000-1.5H2.75a.25.25 0 01-.25-.25V1.75zM4.75 4a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5zM4 7.75A.75.75 0 014.75 7h2a.75.75 0 010 1.5h-2A.75.75 0 014 7.75zm11.774 3.537a.75.75 0 00-1.048-1.074L10.7 14.145 9.281 12.72a.75.75 0 00-1.062 1.058l1.943 1.95a.75.75 0 001.055.008l4.557-4.45z\"></path></svg>\r\n              <%= user.contributionsCollection.totalPullRequestReviewContributions %> Pull request<%= s(user.contributionsCollection.totalPullRequestReviewContributions) %> reviewed\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.177 3.073L9.573.677A.25.25 0 0110 .854v4.792a.25.25 0 01-.427.177L7.177 3.427a.25.25 0 010-.354zM3.75 2.5a.75.75 0 100 1.5.75.75 0 000-1.5zm-2.25.75a2.25 2.25 0 113 2.122v5.256a2.251 2.251 0 11-1.5 0V5.372A2.25 2.25 0 011.5 3.25zM11 2.5h-1V4h1a1 1 0 011 1v5.628a2.251 2.251 0 101.5 0V5A2.5 2.5 0 0011 2.5zm1 10.25a.75.75 0 111.5 0 .75.75 0 01-1.5 0zM3.75 12a.75.75 0 100 1.5.75.75 0 000-1.5z\"></path></svg>\r\n              <%= user.contributionsCollection.totalPullRequestContributions %> Pull request<%= s(user.contributionsCollection.totalPullRequestContributions) %> opened\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n              <%= user.contributionsCollection.totalIssueContributions %> Issue<%= s(user.contributionsCollection.totalIssueContributions) %> opened\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.75 2.5a.25.25 0 00-.25.25v7.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h4.5a.25.25 0 00.25-.25v-7.5a.25.25 0 00-.25-.25H2.75zM1 2.75C1 1.784 1.784 1 2.75 1h10.5c.966 0 1.75.784 1.75 1.75v7.5A1.75 1.75 0 0113.25 12H9.06l-2.573 2.573A1.457 1.457 0 014 13.543V12H2.75A1.75 1.75 0 011 10.25v-7.5z\"></path></svg>\r\n              <%= user.issueComments.totalCount %> issue comment<%= s(user.issueComments.totalCount) %>\r\n            </div>\r\n          </section>\r\n        <% } %>\r\n        <% if (base.community) { %>\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.326 1.973a1.2 1.2 0 011.49-.832c.387.112.977.307 1.575.602.586.291 1.243.71 1.7 1.296.022.027.042.056.061.084A13.22 13.22 0 018 3c.67 0 1.289.037 1.861.108l.051-.07c.457-.586 1.114-1.004 1.7-1.295a9.654 9.654 0 011.576-.602 1.2 1.2 0 011.49.832c.14.493.356 1.347.479 2.29.079.604.123 1.28.07 1.936.541.977.773 2.11.773 3.301C16 13 14.5 15 8 15s-8-2-8-5.5c0-1.034.238-2.128.795-3.117-.08-.712-.034-1.46.052-2.12.122-.943.34-1.797.479-2.29zM8 13.065c6 0 6.5-2 6-4.27C13.363 5.905 11.25 5 8 5s-5.363.904-6 3.796c-.5 2.27 0 4.27 6 4.27z\"></path><path d=\"M4 8a1 1 0 012 0v1a1 1 0 01-2 0V8zm2.078 2.492c-.083-.264.146-.492.422-.492h3c.276 0 .505.228.422.492C9.67 11.304 8.834 12 8 12c-.834 0-1.669-.696-1.922-1.508zM10 8a1 1 0 112 0v1a1 1 0 11-2 0V8z\"></path></svg>              Community stats\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 14.25c0 .138.112.25.25.25H4v-1.25a.75.75 0 01.75-.75h2.5a.75.75 0 01.75.75v1.25h2.25a.25.25 0 00.25-.25V1.75a.25.25 0 00-.25-.25h-8.5a.25.25 0 00-.25.25v12.5zM1.75 16A1.75 1.75 0 010 14.25V1.75C0 .784.784 0 1.75 0h8.5C11.216 0 12 .784 12 1.75v12.5c0 .085-.006.168-.018.25h2.268a.25.25 0 00.25-.25V8.285a.25.25 0 00-.111-.208l-1.055-.703a.75.75 0 11.832-1.248l1.055.703c.487.325.779.871.779 1.456v5.965A1.75 1.75 0 0114.25 16h-3.5a.75.75 0 01-.197-.026c-.099.017-.2.026-.303.026h-3a.75.75 0 01-.75-.75V14h-1v1.25a.75.75 0 01-.75.75h-3zM3 3.75A.75.75 0 013.75 3h.5a.75.75 0 010 1.5h-.5A.75.75 0 013 3.75zM3.75 6a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM3 9.75A.75.75 0 013.75 9h.5a.75.75 0 010 1.5h-.5A.75.75 0 013 9.75zM7.75 9a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5zM7 6.75A.75.75 0 017.75 6h.5a.75.75 0 010 1.5h-.5A.75.75 0 017 6.75zM7.75 3a.75.75 0 000 1.5h.5a.75.75 0 000-1.5h-.5z\"></path></svg>\r\n              Member of <%= user.organizations.totalCount %> organization<%= s(user.organizations.totalCount) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.5 3.5a2 2 0 100 4 2 2 0 000-4zM2 5.5a3.5 3.5 0 115.898 2.549 5.507 5.507 0 013.034 4.084.75.75 0 11-1.482.235 4.001 4.001 0 00-7.9 0 .75.75 0 01-1.482-.236A5.507 5.507 0 013.102 8.05 3.49 3.49 0 012 5.5zM11 4a.75.75 0 100 1.5 1.5 1.5 0 01.666 2.844.75.75 0 00-.416.672v.352a.75.75 0 00.574.73c1.2.289 2.162 1.2 2.522 2.372a.75.75 0 101.434-.44 5.01 5.01 0 00-2.56-3.012A3 3 0 0011 4z\"></path></svg>\r\n              Following <%= user.following.totalCount %> user<%= s(user.followers.totalCount) %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.25 2.5c-1.336 0-2.75 1.164-2.75 3 0 2.15 1.58 4.144 3.365 5.682A20.565 20.565 0 008 13.393a20.561 20.561 0 003.135-2.211C12.92 9.644 14.5 7.65 14.5 5.5c0-1.836-1.414-3-2.75-3-1.373 0-2.609.986-3.029 2.456a.75.75 0 01-1.442 0C6.859 3.486 5.623 2.5 4.25 2.5zM8 14.25l-.345.666-.002-.001-.006-.003-.018-.01a7.643 7.643 0 01-.31-.17 22.075 22.075 0 01-3.434-2.414C2.045 10.731 0 8.35 0 5.5 0 2.836 2.086 1 4.25 1 5.797 1 7.153 1.802 8 3.02 8.847 1.802 10.203 1 11.75 1 13.914 1 16 2.836 16 5.5c0 2.85-2.045 5.231-3.885 6.818a22.08 22.08 0 01-3.744 2.584l-.018.01-.006.003h-.002L8 14.25zm0 0l.345.666a.752.752 0 01-.69 0L8 14.25z\"></path></svg>\r\n              Sponsoring <%= user.sponsorshipsAsSponsor.totalCount %> repositor<%= s(user.sponsorshipsAsSponsor.totalCount, \"y\") %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n              Starred <%= user.starredRepositories.totalCount %> repositor<%= s(user.starredRepositories.totalCount, \"y\") %>\r\n            </div>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.679 7.932c.412-.621 1.242-1.75 2.366-2.717C5.175 4.242 6.527 3.5 8 3.5c1.473 0 2.824.742 3.955 1.715 1.124.967 1.954 2.096 2.366 2.717a.119.119 0 010 .136c-.412.621-1.242 1.75-2.366 2.717C10.825 11.758 9.473 12.5 8 12.5c-1.473 0-2.824-.742-3.955-1.715C2.92 9.818 2.09 8.69 1.679 8.068a.119.119 0 010-.136zM8 2c-1.981 0-3.67.992-4.933 2.078C1.797 5.169.88 6.423.43 7.1a1.619 1.619 0 000 1.798c.45.678 1.367 1.932 2.637 3.024C4.329 13.008 6.019 14 8 14c1.981 0 3.67-.992 4.933-2.078 1.27-1.091 2.187-2.345 2.637-3.023a1.619 1.619 0 000-1.798c-.45-.678-1.367-1.932-2.637-3.023C11.671 2.992 9.981 2 8 2zm0 8a2 2 0 100-4 2 2 0 000 4z\"></path></svg>\r\n              Watching <%= user.watching.totalCount %> repositor<%= s(user.watching.totalCount, \"y\") %>\r\n            </div>\r\n          </section>\r\n        <% } %>\r\n      </div>\r\n\r\n      <% if (base.repositories) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2 2.5A2.5 2.5 0 014.5 0h8.75a.75.75 0 01.75.75v12.5a.75.75 0 01-.75.75h-2.5a.75.75 0 110-1.5h1.75v-2h-8a1 1 0 00-.714 1.7.75.75 0 01-1.072 1.05A2.495 2.495 0 012 11.5v-9zm10.5-1V9h-8c-.356 0-.694.074-1 .208V2.5a1 1 0 011-1h8zM5 12.25v3.25a.25.25 0 00.4.2l1.45-1.087a.25.25 0 01.3 0L8.6 15.7a.25.25 0 00.4-.2v-3.25a.25.25 0 00-.25-.25h-3.5a.25.25 0 00-.25.25z\"></path></svg>\r\n            <%= user.repositories.totalCount %> Repositor<%= s(user.repositories.totalCount, \"y\") %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8.75.75a.75.75 0 00-1.5 0V2h-.984c-.305 0-.604.08-.869.23l-1.288.737A.25.25 0 013.984 3H1.75a.75.75 0 000 1.5h.428L.066 9.192a.75.75 0 00.154.838l.53-.53-.53.53v.001l.002.002.002.002.006.006.016.015.045.04a3.514 3.514 0 00.686.45A4.492 4.492 0 003 11c.88 0 1.556-.22 2.023-.454a3.515 3.515 0 00.686-.45l.045-.04.016-.015.006-.006.002-.002.001-.002L5.25 9.5l.53.53a.75.75 0 00.154-.838L3.822 4.5h.162c.305 0 .604-.08.869-.23l1.289-.737a.25.25 0 01.124-.033h.984V13h-2.5a.75.75 0 000 1.5h6.5a.75.75 0 000-1.5h-2.5V3.5h.984a.25.25 0 01.124.033l1.29.736c.264.152.563.231.868.231h.162l-2.112 4.692a.75.75 0 00.154.838l.53-.53-.53.53v.001l.002.002.002.002.006.006.016.015.045.04a3.517 3.517 0 00.686.45A4.492 4.492 0 0013 11c.88 0 1.556-.22 2.023-.454a3.512 3.512 0 00.686-.45l.045-.04.01-.01.006-.005.006-.006.002-.002.001-.002-.529-.531.53.53a.75.75 0 00.154-.838L13.823 4.5h.427a.75.75 0 000-1.5h-2.234a.25.25 0 01-.124-.033l-1.29-.736A1.75 1.75 0 009.735 2H8.75V.75zM1.695 9.227c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L3 6.327l-1.305 2.9zm10 0c.285.135.718.273 1.305.273s1.02-.138 1.305-.273L13 6.327l-1.305 2.9z\"></path></svg>\r\n                <% if (computed.licenses.favorite.length) { %>\r\n                  Prefer <%= computed.licenses.favorite %> license\r\n                <% } else { %>\r\n                  No license preference\r\n                <% } %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 7.775V2.75a.25.25 0 01.25-.25h5.025a.25.25 0 01.177.073l6.25 6.25a.25.25 0 010 .354l-5.025 5.025a.25.25 0 01-.354 0l-6.25-6.25a.25.25 0 01-.073-.177zm-1.5 0V2.75C1 1.784 1.784 1 2.75 1h5.025c.464 0 .91.184 1.238.513l6.25 6.25a1.75 1.75 0 010 2.474l-5.026 5.026a1.75 1.75 0 01-2.474 0l-6.25-6.25A1.75 1.75 0 011 7.775zM6 5a1 1 0 100 2 1 1 0 000-2z\"></path></svg>\r\n                <%= computed.repositories.releases %> Release<%= s(computed.repositories.releases) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8.878.392a1.75 1.75 0 00-1.756 0l-5.25 3.045A1.75 1.75 0 001 4.951v6.098c0 .624.332 1.2.872 1.514l5.25 3.045a1.75 1.75 0 001.756 0l5.25-3.045c.54-.313.872-.89.872-1.514V4.951c0-.624-.332-1.2-.872-1.514L8.878.392zM7.875 1.69a.25.25 0 01.25 0l4.63 2.685L8 7.133 3.245 4.375l4.63-2.685zM2.5 5.677v5.372c0 .09.047.171.125.216l4.625 2.683V8.432L2.5 5.677zm6.25 8.271l4.625-2.683a.25.25 0 00.125-.216V5.677L8.75 8.432v5.516z\"></path></svg>\r\n                <%= user.packages.totalCount %> Package<%= s(user.packages.totalCount) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path xmlns=\"http://www.w3.org/2000/svg\" fill-rule=\"evenodd\" d=\"M2.5 3.5c0-.133.058-.318.282-.55.227-.237.592-.484 1.1-.708C4.899 1.795 6.354 1.5 8 1.5c1.647 0 3.102.295 4.117.742.51.224.874.47 1.101.707.224.233.282.418.282.551 0 .133-.058.318-.282.55-.227.237-.592.484-1.1.708C11.101 5.205 9.646 5.5 8 5.5c-1.647 0-3.102-.295-4.117-.742-.51-.224-.874-.47-1.101-.707-.224-.233-.282-.418-.282-.551zM1 3.5c0-.626.292-1.165.7-1.59.406-.422.956-.767 1.579-1.041C4.525.32 6.195 0 8 0c1.805 0 3.475.32 4.722.869.622.274 1.172.62 1.578 1.04.408.426.7.965.7 1.591v9c0 .626-.292 1.165-.7 1.59-.406.422-.956.767-1.579 1.041C11.476 15.68 9.806 16 8 16c-1.805 0-3.475-.32-4.721-.869-.623-.274-1.173-.62-1.579-1.04-.408-.426-.7-.965-.7-1.591v-9zM2.5 8V5.724c.241.15.503.286.779.407C4.525 6.68 6.195 7 8 7c1.805 0 3.475-.32 4.722-.869.275-.121.537-.257.778-.407V8c0 .133-.058.318-.282.55-.227.237-.592.484-1.1.708C11.101 9.705 9.646 10 8 10c-1.647 0-3.102-.295-4.117-.742-.51-.224-.874-.47-1.101-.707C2.558 8.318 2.5 8.133 2.5 8zm0 2.225V12.5c0 .133.058.318.282.55.227.237.592.484 1.1.708 1.016.447 2.471.742 4.118.742 1.647 0 3.102-.295 4.117-.742.51-.224.874-.47 1.101-.707.224-.233.282-.418.282-.551v-2.275c-.241.15-.503.285-.778.406-1.247.549-2.917.869-4.722.869-1.805 0-3.475-.32-4.721-.869a6.236 6.236 0 01-.779-.406z\"></path></svg>\r\n                <%= computed.diskUsage %> used\r\n              </div>\r\n              <% if (plugins.lines) { %>\r\n                  <div class=\"field <%= plugins.lines.error ? 'error' : '' %>\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.75 1.5a.25.25 0 00-.25.25v12.5c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V4.664a.25.25 0 00-.073-.177l-2.914-2.914a.25.25 0 00-.177-.073H2.75zM1 1.75C1 .784 1.784 0 2.75 0h7.586c.464 0 .909.184 1.237.513l2.914 2.914c.329.328.513.773.513 1.237v9.586A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V1.75zm7 1.5a.75.75 0 01.75.75v1.5h1.5a.75.75 0 010 1.5h-1.5v1.5a.75.75 0 01-1.5 0V7h-1.5a.75.75 0 010-1.5h1.5V4A.75.75 0 018 3.25zm-3 8a.75.75 0 01.75-.75h4.5a.75.75 0 010 1.5h-4.5a.75.75 0 01-.75-.75z\"></path></svg>\r\n                    <% if (plugins.lines.error) { %>\r\n                      <%= plugins.lines.error.message %>\r\n                    <% } else { %>\r\n                      <%= plugins.lines.added %> added, <%= plugins.lines.deleted %> removed\r\n                    <% } %>\r\n                  </div>\r\n              <% } %>\r\n            </section>\r\n            <section>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.25 2.5c-1.336 0-2.75 1.164-2.75 3 0 2.15 1.58 4.144 3.365 5.682A20.565 20.565 0 008 13.393a20.561 20.561 0 003.135-2.211C12.92 9.644 14.5 7.65 14.5 5.5c0-1.836-1.414-3-2.75-3-1.373 0-2.609.986-3.029 2.456a.75.75 0 01-1.442 0C6.859 3.486 5.623 2.5 4.25 2.5zM8 14.25l-.345.666-.002-.001-.006-.003-.018-.01a7.643 7.643 0 01-.31-.17 22.075 22.075 0 01-3.434-2.414C2.045 10.731 0 8.35 0 5.5 0 2.836 2.086 1 4.25 1 5.797 1 7.153 1.802 8 3.02 8.847 1.802 10.203 1 11.75 1 13.914 1 16 2.836 16 5.5c0 2.85-2.045 5.231-3.885 6.818a22.08 22.08 0 01-3.744 2.584l-.018.01-.006.003h-.002L8 14.25zm0 0l.345.666a.752.752 0 01-.69 0L8 14.25z\"></path></svg>\r\n                <%= user.sponsorshipsAsMaintainer.totalCount %> Sponsor<%= s(user.sponsorshipsAsMaintainer.totalCount) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n                <%= computed.repositories.stargazers %> Stargazer<%= s(computed.repositories.stargazers) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5 3.25a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm0 2.122a2.25 2.25 0 10-1.5 0v.878A2.25 2.25 0 005.75 8.5h1.5v2.128a2.251 2.251 0 101.5 0V8.5h1.5a2.25 2.25 0 002.25-2.25v-.878a2.25 2.25 0 10-1.5 0v.878a.75.75 0 01-.75.75h-4.5A.75.75 0 015 6.25v-.878zm3.75 7.378a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm3-8.75a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                <%= computed.repositories.forks %> Fork<%= s(computed.repositories.forks) %>\r\n              </div>\r\n              <div class=\"field\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.679 7.932c.412-.621 1.242-1.75 2.366-2.717C5.175 4.242 6.527 3.5 8 3.5c1.473 0 2.824.742 3.955 1.715 1.124.967 1.954 2.096 2.366 2.717a.119.119 0 010 .136c-.412.621-1.242 1.75-2.366 2.717C10.825 11.758 9.473 12.5 8 12.5c-1.473 0-2.824-.742-3.955-1.715C2.92 9.818 2.09 8.69 1.679 8.068a.119.119 0 010-.136zM8 2c-1.981 0-3.67.992-4.933 2.078C1.797 5.169.88 6.423.43 7.1a1.619 1.619 0 000 1.798c.45.678 1.367 1.932 2.637 3.024C4.329 13.008 6.019 14 8 14c1.981 0 3.67-.992 4.933-2.078 1.27-1.091 2.187-2.345 2.637-3.023a1.619 1.619 0 000-1.798c-.45-.678-1.367-1.932-2.637-3.023C11.671 2.992 9.981 2 8 2zm0 8a2 2 0 100-4 2 2 0 000 4z\"></path></svg>\r\n                <%= computed.repositories.watchers %> Watcher<%= s(computed.repositories.watchers) %>\r\n              </div>\r\n              <% if (plugins.traffic) { %>\r\n                  <div class=\"field <%= plugins.traffic.error ? 'error' : '' %>\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M0 1.75A.75.75 0 01.75 1h4.253c1.227 0 2.317.59 3 1.501A3.744 3.744 0 0111.006 1h4.245a.75.75 0 01.75.75v10.5a.75.75 0 01-.75.75h-4.507a2.25 2.25 0 00-1.591.659l-.622.621a.75.75 0 01-1.06 0l-.622-.621A2.25 2.25 0 005.258 13H.75a.75.75 0 01-.75-.75V1.75zm8.755 3a2.25 2.25 0 012.25-2.25H14.5v9h-3.757c-.71 0-1.4.201-1.992.572l.004-7.322zm-1.504 7.324l.004-5.073-.002-2.253A2.25 2.25 0 005.003 2.5H1.5v9h3.757a3.75 3.75 0 011.994.574z\"></path></svg>\r\n                    <% if (plugins.traffic.error) { %>\r\n                      <%= plugins.traffic.error.message %>\r\n                    <% } else { %>\r\n                      <%= plugins.traffic.views.count %> view<%= s(plugins.traffic.views.count) %> in last two weeks\r\n                    <% } %>\r\n                  </div>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.followup) { %>\r\n        <div class=\"row\">\r\n\r\n          <section class=\"column\">\r\n            <h3>Issues</h3>\r\n            <% if (plugins.followup.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.followup.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"220\" height=\"8\">\r\n                <mask id=\"issues-bar\">\r\n                  <rect x=\"0\" y=\"0\" width=\"220\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                </mask>\r\n                <rect mask=\"url(#issues-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.followup.issues.count ? 0 : 220 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                <rect mask=\"url(#issues-bar)\" x=\"0\" y=\"0\" width=\"<%= (plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" height=\"8\" fill=\"#d73a49\"/>\r\n                <rect mask=\"url(#issues-bar)\" x=\"<%= (plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" y=\"0\" width=\"<%= (1-plugins.followup.issues.closed/plugins.followup.issues.count)*220 || 0 %>\" height=\"8\" fill=\"#28a745\"/>\r\n              </svg>\r\n              <div class=\"field horizontal fill-width\">\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#d73a49\" fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 0110.65-5.003.75.75 0 00.959-1.153 8 8 0 102.592 8.33.75.75 0 10-1.444-.407A6.5 6.5 0 011.5 8zM8 12a1 1 0 100-2 1 1 0 000 2zm0-8a.75.75 0 01.75.75v3.5a.75.75 0 11-1.5 0v-3.5A.75.75 0 018 4zm4.78 4.28l3-3a.75.75 0 00-1.06-1.06l-2.47 2.47-.97-.97a.749.749 0 10-1.06 1.06l1.5 1.5a.75.75 0 001.06 0z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.issues.closed %> Closed</span>\r\n                </div>\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#28a745\" fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.issues.open %> Open</span>\r\n                </div>\r\n              </div>\r\n            <% } %>\r\n          </section>\r\n\r\n          <section class=\"column\">\r\n            <h3>Pull requests</h3>\r\n            <% if (plugins.followup.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.followup.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"220\" height=\"8\">\r\n                <mask id=\"pr-bar\">\r\n                  <rect x=\"0\" y=\"0\" width=\"220\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                </mask>\r\n                <rect mask=\"url(#pr-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.followup.pr.count ? 0 : 220 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                <rect mask=\"url(#pr-bar)\" x=\"0\" y=\"0\" width=\"<%= (plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" height=\"8\" fill=\"#6f42c1\"/>\r\n                <rect mask=\"url(#pr-bar)\" x=\"<%= (plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" y=\"0\" width=\"<%= (1-plugins.followup.pr.merged/plugins.followup.pr.count)*220 || 0 %>\" height=\"8\" fill=\"#28a745\"/>\r\n              </svg>\r\n              <div class=\"field horizontal fill-width\">\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#6f42c1\" fill-rule=\"evenodd\" d=\"M5 3.254V3.25v.005a.75.75 0 110-.005v.004zm.45 1.9a2.25 2.25 0 10-1.95.218v5.256a2.25 2.25 0 101.5 0V7.123A5.735 5.735 0 009.25 9h1.378a2.251 2.251 0 100-1.5H9.25a4.25 4.25 0 01-3.8-2.346zM12.75 9a.75.75 0 100-1.5.75.75 0 000 1.5zm-8.5 4.5a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.pr.merged %> Merged</span>\r\n                </div>\r\n                <div class=\"field center\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"#28a745\" fill-rule=\"evenodd\" d=\"M7.177 3.073L9.573.677A.25.25 0 0110 .854v4.792a.25.25 0 01-.427.177L7.177 3.427a.25.25 0 010-.354zM3.75 2.5a.75.75 0 100 1.5.75.75 0 000-1.5zm-2.25.75a2.25 2.25 0 113 2.122v5.256a2.251 2.251 0 11-1.5 0V5.372A2.25 2.25 0 011.5 3.25zM11 2.5h-1V4h1a1 1 0 011 1v5.628a2.251 2.251 0 101.5 0V5A2.5 2.5 0 0011 2.5zm1 10.25a.75.75 0 111.5 0 .75.75 0 01-1.5 0zM3.75 12a.75.75 0 100 1.5.75.75 0 000-1.5z\"></path></svg>\r\n                  <span class=\"no-wrap\"><%= plugins.followup.pr.open %> Open</span>\r\n                </div>\r\n              </div>\r\n            <% } %>\r\n          </section>\r\n\r\n        </div>\r\n      <% } %>\r\n\r\n      <% if (plugins.languages) { %>\r\n        <section class=\"column\">\r\n          <h3>Most used languages</h3>\r\n          <% if (plugins.languages.error) { %>\r\n            <section>\r\n              <div class=\"field error\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                <%= plugins.languages.error.message %>\r\n              </div>\r\n            </section>\r\n          <% } else { %>\r\n            <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"460\" height=\"8\">\r\n              <mask id=\"languages-bar\">\r\n                <rect x=\"0\" y=\"0\" width=\"460\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n              </mask>\r\n              <rect mask=\"url(#languages-bar)\" x=\"0\" y=\"0\" width=\"<%= plugins.languages.favorites.length ? 0 : 460 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n              <% for (const {name, value, color, x} of plugins.languages.favorites) { %>\r\n                <rect mask=\"url(#languages-bar)\" x=\"<%= x*460 %>\" y=\"0\" width=\"<%= value*460 %>\" height=\"8\" fill=\"<%= color %>\"/>\r\n              <% } %>\r\n            </svg>\r\n            <div class=\"field center horizontal-wrap fill-width\">\r\n              <% for (const {name, value, color} of plugins.languages.favorites) { %>\r\n                <div class=\"field center no-wrap language\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill=\"<%= color %>\" fill-rule=\"evenodd\" d=\"M8 4a4 4 0 100 8 4 4 0 000-8z\"></path></svg>\r\n                  <%= name %>\r\n                </div>\r\n              <% } %>\r\n            </div>\r\n          <% } %>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.projects) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 0A1.75 1.75 0 000 1.75v12.5C0 15.216.784 16 1.75 16h12.5A1.75 1.75 0 0016 14.25V1.75A1.75 1.75 0 0014.25 0H1.75zM1.5 1.75a.25.25 0 01.25-.25h12.5a.25.25 0 01.25.25v12.5a.25.25 0 01-.25.25H1.75a.25.25 0 01-.25-.25V1.75zM11.75 3a.75.75 0 00-.75.75v7.5a.75.75 0 001.5 0v-7.5a.75.75 0 00-.75-.75zm-8.25.75a.75.75 0 011.5 0v5.5a.75.75 0 01-1.5 0v-5.5zM8 3a.75.75 0 00-.75.75v3.5a.75.75 0 001.5 0v-3.5A.75.75 0 008 3z\"></path></svg>\r\n            <%= plugins.projects.totalCount %> Project<%= s(plugins.projects.totalCount) %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.projects.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.projects.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <% for (const {name, updated, progress} of plugins.projects.list) { %>\r\n                  <div class=\"row fill-width\">\r\n                    <section>\r\n                      <div class=\"field\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M0 3.75C0 2.784.784 2 1.75 2h12.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0114.25 14H1.75A1.75 1.75 0 010 12.25v-8.5zm1.75-.25a.25.25 0 00-.25.25v8.5c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25v-8.5a.25.25 0 00-.25-.25H1.75zM3.5 6.25a.75.75 0 01.75-.75h7a.75.75 0 010 1.5h-7a.75.75 0 01-.75-.75zm.75 2.25a.75.75 0 000 1.5h4a.75.75 0 000-1.5h-4z\"></path></svg>\r\n                        <%= name %>\r\n                      </div>\r\n                    </section>\r\n                  </div>\r\n                  <div class=\"row\">\r\n                    <section>\r\n                      <div class=\"field\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm.5 4.75a.75.75 0 00-1.5 0v3.5a.75.75 0 00.471.696l2.5 1a.75.75 0 00.557-1.392L8.5 7.742V4.75z\"></path></svg>\r\n                        Updated <%= updated %>\r\n                      </div>\r\n                    </section>\r\n                    <% if (progress.enabled) { %>\r\n                      <section>\r\n                        <div class=\"field\">\r\n                          <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.5 1.75a.25.25 0 01.25-.25h8.5a.25.25 0 01.25.25v7.736a.75.75 0 101.5 0V1.75A1.75 1.75 0 0011.25 0h-8.5A1.75 1.75 0 001 1.75v11.5c0 .966.784 1.75 1.75 1.75h3.17a.75.75 0 000-1.5H2.75a.25.25 0 01-.25-.25V1.75zM4.75 4a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5zM4 7.75A.75.75 0 014.75 7h2a.75.75 0 010 1.5h-2A.75.75 0 014 7.75zm11.774 3.537a.75.75 0 00-1.048-1.074L10.7 14.145 9.281 12.72a.75.75 0 00-1.062 1.058l1.943 1.95a.75.75 0 001.055.008l4.557-4.45z\"></path></svg>\r\n                          <%= [progress.done ? `${progress.done} done` : \"\", progress.doing ? `${progress.doing} doing` : \"\", progress.todo ? `${progress.todo} todo` : \"\"].filter(str => str).join(\" · \") %>\r\n                        </div>\r\n                      </section>\r\n                    <% } %>\r\n                  </div>\r\n                  <% if (progress.enabled) { %>\r\n                    <div class=\"field center horizontal-wrap \">\r\n                      <svg class=\"bar\" xmlns=\"http://www.w3.org/2000/svg\" width=\"460\" height=\"8\">\r\n                        <mask id=\"project-bar\">\r\n                          <rect x=\"0\" y=\"0\" width=\"460\" height=\"8\" fill=\"white\" rx=\"5\"/>\r\n                        </mask>\r\n                        <rect mask=\"url(#project-bar)\" x=\"0\" y=\"0\" width=\"<%= (progress.done/progress.total)*460 %>\" height=\"8\" fill=\"#28A745\"/>\r\n                        <rect mask=\"url(#project-bar)\" x=\"<%= (progress.done/progress.total)*460 %>\" y=\"0\" width=\"<%= (progress.doing/progress.total)*460 %>\" height=\"8\" fill=\"#6F42C1\"/>\r\n                        <rect mask=\"url(#project-bar)\" x=\"<%= ((progress.done+progress.doing)/progress.total)*460 %>\" y=\"0\" width=\"<%= (progress.todo/progress.total)*460 %>\" height=\"8\" fill=\"#d1d5da\"/>\r\n                      </svg>\r\n                    </div>\r\n                  <% } %>\r\n                <% } %>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.gists) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v12.5c0 .138.112.25.25.25h12.5a.25.25 0 00.25-.25V1.75a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0114.25 16H1.75A1.75 1.75 0 010 14.25V1.75zm9.22 3.72a.75.75 0 000 1.06L10.69 8 9.22 9.47a.75.75 0 101.06 1.06l2-2a.75.75 0 000-1.06l-2-2a.75.75 0 00-1.06 0zM6.78 6.53a.75.75 0 00-1.06-1.06l-2 2a.75.75 0 000 1.06l2 2a.75.75 0 101.06-1.06L5.31 8l1.47-1.47z\"></path></svg>\r\n            <%= plugins.gists.totalCount %> Gist<%= s(plugins.gists.totalCount) %>\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.gists.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.gists.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z\"></path></svg>\r\n                  <%= plugins.gists.stargazers %> Stargazer<%= s(plugins.gists.stargazers) %>\r\n                </div>\r\n              </section>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5 3.25a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm0 2.122a2.25 2.25 0 10-1.5 0v.878A2.25 2.25 0 005.75 8.5h1.5v2.128a2.251 2.251 0 101.5 0V8.5h1.5a2.25 2.25 0 002.25-2.25v-.878a2.25 2.25 0 10-1.5 0v.878a.75.75 0 01-.75.75h-4.5A.75.75 0 015 6.25v-.878zm3.75 7.378a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm3-8.75a.75.75 0 100-1.5.75.75 0 000 1.5z\"></path></svg>\r\n                  <%= plugins.gists.forks %> Fork<%= s(plugins.gists.forks) %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.pagespeed) { %>\r\n        <div class=\"row\">\r\n          <section>\r\n            <h2 class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M14.064 0a8.75 8.75 0 00-6.187 2.563l-.459.458c-.314.314-.616.641-.904.979H3.31a1.75 1.75 0 00-1.49.833L.11 7.607a.75.75 0 00.418 1.11l3.102.954c.037.051.079.1.124.145l2.429 2.428c.046.046.094.088.145.125l.954 3.102a.75.75 0 001.11.418l2.774-1.707a1.75 1.75 0 00.833-1.49V9.485c.338-.288.665-.59.979-.904l.458-.459A8.75 8.75 0 0016 1.936V1.75A1.75 1.75 0 0014.25 0h-.186zM10.5 10.625c-.088.06-.177.118-.266.175l-2.35 1.521.548 1.783 1.949-1.2a.25.25 0 00.119-.213v-2.066zM3.678 8.116L5.2 5.766c.058-.09.117-.178.176-.266H3.309a.25.25 0 00-.213.119l-1.2 1.95 1.782.547zm5.26-4.493A7.25 7.25 0 0114.063 1.5h.186a.25.25 0 01.25.25v.186a7.25 7.25 0 01-2.123 5.127l-.459.458a15.21 15.21 0 01-2.499 2.02l-2.317 1.5-2.143-2.143 1.5-2.317a15.25 15.25 0 012.02-2.5l.458-.458h.002zM12 5a1 1 0 11-2 0 1 1 0 012 0zm-8.44 9.56a1.5 1.5 0 10-2.12-2.12c-.734.73-1.047 2.332-1.15 3.003a.23.23 0 00.265.265c.671-.103 2.273-.416 3.005-1.148z\"></path></svg>\r\n              PageSpeed Insights\r\n            </h2>\r\n            <div class=\"field\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.775 3.275a.75.75 0 001.06 1.06l1.25-1.25a2 2 0 112.83 2.83l-2.5 2.5a2 2 0 01-2.83 0 .75.75 0 00-1.06 1.06 3.5 3.5 0 004.95 0l2.5-2.5a3.5 3.5 0 00-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 010-2.83l2.5-2.5a2 2 0 012.83 0 .75.75 0 001.06-1.06 3.5 3.5 0 00-4.95 0l-2.5 2.5a3.5 3.5 0 004.95 4.95l1.25-1.25a.75.75 0 00-1.06-1.06l-1.25 1.25a2 2 0 01-2.83 0z\"></path></svg>\r\n              <%= user.websiteUrl %>\r\n            </div>\r\n          </section>\r\n        </div>\r\n        <% if (plugins.pagespeed.error) { %>\r\n          <div class=\"row\">\r\n            <section>\r\n              <div class=\"field error\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                <%= plugins.pagespeed.error.message %>\r\n              </div>\r\n            </section>\r\n          </div>\r\n        <% } else { %>\r\n          <section>\r\n            <div class=\"row fill-width\">\r\n              <section class=\"categories\">\r\n                <% for (const {score, title} of plugins.pagespeed.scores) { %>\r\n                  <div class=\"categorie column\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 120 120\" width=\"50\" height=\"50\" class=\"gauge <%= !Number.isNaN(score) ? (score >= 0.9 ? 'high' : score >= 0.5 ? 'average' : 'low') : '' %>\">\r\n                      <circle class=\"gauge-base\" r=\"53\" cx=\"60\" cy=\"60\"></circle>\r\n                      <% if (!Number.isNaN(score)) { %>\r\n                        <circle class=\"gauge-arc\" transform=\"rotate(-90 60 60)\" r=\"53\" cx=\"60\" cy=\"60\" stroke-dasharray=\"<%= score * 329 %> 329\"></circle>\r\n                        <text x=\"60\" y=\"60\" dominant-baseline=\"central\" ><%= Math.round(score*100) %></text>\r\n                      <% } else { %>\r\n                        <text x=\"60\" y=\"60\" dominant-baseline=\"central\" >-</text>\r\n                      <% } %>\r\n                    </svg>\r\n                    <span class=\"title\"><%= title %></span>\r\n                  </div>\r\n                <% } %>\r\n              </section>\r\n            </div>\r\n          </section>\r\n          <% if (plugins.pagespeed.detailed) { %>\r\n            <div class=\"audits row\">\r\n              <section>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M5.75.75A.75.75 0 016.5 0h3a.75.75 0 010 1.5h-.75v1l-.001.041a6.718 6.718 0 013.464 1.435l.007-.006.75-.75a.75.75 0 111.06 1.06l-.75.75-.006.007a6.75 6.75 0 11-10.548 0L2.72 5.03l-.75-.75a.75.75 0 011.06-1.06l.75.75.007.006A6.718 6.718 0 017.25 2.541a.756.756 0 010-.041v-1H6.5a.75.75 0 01-.75-.75zM8 14.5A5.25 5.25 0 108 4a5.25 5.25 0 000 10.5zm.389-6.7l1.33-1.33a.75.75 0 111.061 1.06L9.45 8.861A1.502 1.502 0 018 10.75a1.5 1.5 0 11.389-2.95z\"></path></svg>\r\n                    Time to interactive\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 106.016 4.035.75.75 0 011.388-.57 8 8 0 11-4.37-4.37.75.75 0 01-.569 1.389A6.479 6.479 0 008 1.5zm6.28.22a.75.75 0 010 1.06l-4.063 4.064a2.5 2.5 0 11-1.06-1.06L13.22 1.72a.75.75 0 011.06 0zM7 8a1 1 0 112 0 1 1 0 01-2 0z\"></path></svg>\r\n                    Speed Index\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.643 3.143L.427 1.927A.25.25 0 000 2.104V5.75c0 .138.112.25.25.25h3.646a.25.25 0 00.177-.427L2.715 4.215a6.5 6.5 0 11-1.18 4.458.75.75 0 10-1.493.154 8.001 8.001 0 101.6-5.684zM7.75 4a.75.75 0 01.75.75v2.992l2.028.812a.75.75 0 01-.557 1.392l-2.5-1A.75.75 0 017 8.25v-3.5A.75.75 0 017.75 4z\"></path></svg>\r\n                    Total Blocking Time\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M11.134 1.535C9.722 2.562 8.16 4.057 6.889 5.312 5.8 6.387 5.041 7.401 4.575 8.294a3.745 3.745 0 00-3.227 1.054c-.43.431-.69 1.066-.86 1.657a11.982 11.982 0 00-.358 1.914A21.263 21.263 0 000 15.203v.054l.75-.007-.007.75h.054a14.404 14.404 0 00.654-.012 21.243 21.243 0 001.63-.118c.62-.07 1.3-.18 1.914-.357.592-.17 1.226-.43 1.657-.861a3.745 3.745 0 001.055-3.217c.908-.461 1.942-1.216 3.04-2.3 1.279-1.262 2.764-2.825 3.775-4.249.501-.706.923-1.428 1.125-2.096.2-.659.235-1.469-.368-2.07-.606-.607-1.42-.55-2.069-.34-.66.213-1.376.646-2.076 1.155zm-3.95 8.48a3.76 3.76 0 00-1.19-1.192 9.758 9.758 0 011.161-1.607l1.658 1.658a9.853 9.853 0 01-1.63 1.142zM.742 16l.007-.75-.75.008A.75.75 0 00.743 16zM12.016 2.749c-1.224.89-2.605 2.189-3.822 3.384l1.718 1.718c1.21-1.205 2.51-2.597 3.387-3.833.47-.662.78-1.227.912-1.662.134-.444.032-.551.009-.575h-.001V1.78c-.014-.014-.112-.113-.548.027-.432.14-.995.462-1.655.942zM1.62 13.089a19.56 19.56 0 00-.104 1.395 19.55 19.55 0 001.396-.104 10.528 10.528 0 001.668-.309c.526-.151.856-.325 1.011-.48a2.25 2.25 0 00-3.182-3.182c-.155.155-.329.485-.48 1.01a10.515 10.515 0 00-.309 1.67z\"></path></svg>\r\n                    First Contentful Paint\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 2.5a.25.25 0 00-.25.25v10.5c0 .138.112.25.25.25h.94a.76.76 0 01.03-.03l6.077-6.078a1.75 1.75 0 012.412-.06L14.5 10.31V2.75a.25.25 0 00-.25-.25H1.75zm12.5 11H4.81l5.048-5.047a.25.25 0 01.344-.009l4.298 3.889v.917a.25.25 0 01-.25.25zm1.75-.25V2.75A1.75 1.75 0 0014.25 1H1.75A1.75 1.75 0 000 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0016 13.25zM5.5 6a.5.5 0 11-1 0 .5.5 0 011 0zM7 6a2 2 0 11-4 0 2 2 0 014 0z\"></path></svg>\r\n                    Largest Contentful Paint\r\n                  </div>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.75 14A1.75 1.75 0 016 12.25v-8.5C6 2.784 6.784 2 7.75 2h6.5c.966 0 1.75.784 1.75 1.75v8.5A1.75 1.75 0 0114.25 14h-6.5zm-.25-1.75c0 .138.112.25.25.25h6.5a.25.25 0 00.25-.25v-8.5a.25.25 0 00-.25-.25h-6.5a.25.25 0 00-.25.25v8.5zM4.9 3.508a.75.75 0 01-.274 1.025.25.25 0 00-.126.217v6.5a.25.25 0 00.126.217.75.75 0 01-.752 1.298A1.75 1.75 0 013 11.25v-6.5c0-.649.353-1.214.874-1.516a.75.75 0 011.025.274zM1.625 5.533a.75.75 0 10-.752-1.299A1.75 1.75 0 000 5.75v4.5c0 .649.353 1.214.874 1.515a.75.75 0 10.752-1.298.25.25 0 01-.126-.217v-4.5a.25.25 0 01.126-.217z\"></path></svg>\r\n                    Cumulative Layout Shift\r\n                  </div>\r\n              </section>\r\n              <section>\r\n                <% for (const {score, suffix = \"\", threshold} of [\r\n                  {score:plugins.pagespeed.metrics.interactive/1000, suffix:\"s\", threshold:[3.785, 7.3]},\r\n                  {score:plugins.pagespeed.metrics.speedIndex/1000, suffix:\"s\", threshold:[3.387, 5.8]},\r\n                  {score:plugins.pagespeed.metrics.totalBlockingTime/1000, suffix:\"s\", threshold:[.287, .6]},\r\n                  {score:plugins.pagespeed.metrics.firstContentfulPaint/1000, suffix:\"s\", threshold:[2.336, 4]},\r\n                  {score:plugins.pagespeed.metrics.largestContentfulPaint/1000, suffix:\"s\", threshold:[2.5, 4]},\r\n                  {score:+plugins.pagespeed.metrics.cumulativeLayoutShift, threshold:[.1, .25]}\r\n                ]) { %>\r\n                <div class=\"field\">\r\n                  <div class=\"audit text\">\r\n                    <% if (!Number.isNaN(score)) { %>\r\n                      <%= score.toFixed(2).replace(/[.]0+$/, \"\") %> <%= suffix %>\r\n                    <% } else { %>\r\n                      N/A\r\n                    <% } %>\r\n                  </div>\r\n                  <% if (Number.isNaN(score)) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zm3.28 5.78a.75.75 0 00-1.06-1.06l-5.5 5.5a.75.75 0 101.06 1.06l5.5-5.5z\"></path></svg>\r\n                  <% } else if (score <= threshold[0]) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit high\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM0 8a8 8 0 1116 0A8 8 0 010 8zm11.78-1.72a.75.75 0 00-1.06-1.06L6.75 9.19 5.28 7.72a.75.75 0 00-1.06 1.06l2 2a.75.75 0 001.06 0l4.5-4.5z\"></path></svg>\r\n                  <% } else if (score <= threshold[1]) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit average\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z\"></path></svg>\r\n                  <% } else { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"audit low\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.47.22A.75.75 0 015 0h6a.75.75 0 01.53.22l4.25 4.25c.141.14.22.331.22.53v6a.75.75 0 01-.22.53l-4.25 4.25A.75.75 0 0111 16H5a.75.75 0 01-.53-.22L.22 11.53A.75.75 0 010 11V5a.75.75 0 01.22-.53L4.47.22zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5H5.31zM8 4a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0v-3.5A.75.75 0 018 4zm0 8a1 1 0 100-2 1 1 0 000 2z\"></path></svg>\r\n                  <% } %>\r\n                </div>\r\n                <% } %>\r\n              </section>\r\n            </div>\r\n          <% } %>\r\n        <% } %>\r\n      <% } %>\r\n\r\n      <% if (plugins.habits) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 01-1.484.211c-.04-.282-.163-.547-.37-.847a8.695 8.695 0 00-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.75.75 0 01-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75zM6 15.25a.75.75 0 01.75-.75h2.5a.75.75 0 010 1.5h-2.5a.75.75 0 01-.75-.75zM5.75 12a.75.75 0 000 1.5h4.5a.75.75 0 000-1.5h-4.5z\"></path></svg>\r\n            Coding habits and recent activity\r\n          </h2>\r\n          <% if (plugins.habits.facts) { %>\r\n            <div class=\"row\">\r\n              <% if (plugins.habits.error) { %>\r\n                <section>\r\n                  <div class=\"field error\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                    <%= plugins.habits.error.message %>\r\n                  </div>\r\n                </section>\r\n              <% } else { %>\r\n                <ul class=\"habits\">\r\n                  <% if (plugins.habits.indents.style) { %>\r\n                    <li>Use <%= plugins.habits.indents.style %> for indents</li>\r\n                  <% } %>\r\n                  <% if (!Number.isNaN(plugins.habits.commits.hour)) { %>\r\n                    <li>Mostly push code around <%= plugins.habits.commits.hour %>:00</li>\r\n                  <% } %>\r\n                  <% if (plugins.habits.commits.day) { %>\r\n                    <li>Mostly active on <%= plugins.habits.commits.day.toLocaleLowerCase() %></li>\r\n                  <% } %>\r\n                </ul>\r\n              <% } %>\r\n            </div>\r\n          <% } %>\r\n        </section>\r\n\r\n        <% if (plugins.habits.charts) { %>\r\n          <% if (!Number.isNaN(plugins.habits.commits.hour)) { %>\r\n            <section class=\"column chart\">\r\n              <h3>Commit activity per time of the day</h3>\r\n              <div class=\"chart-bars\">\r\n                <% for (let h = 0; h < 24; h++) { const p = (plugins.habits.commits.hours[h]??0)/(plugins.habits.commits.hours.max??1); %>\r\n                  <div class=\"entry\">\r\n                    <span class=\"value\"><%= plugins.habits.commits.hours[h] %></span>\r\n                    <div class=\"bar\" style=\"height: <%= p*50 %>px; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                    <%= `${h}`.padStart(2, 0) %>\r\n                  </div>\r\n                <% } %>\r\n              </div>\r\n            </section>\r\n          <% } %>\r\n\r\n          <div class=\"row\">\r\n            <% if (!Number.isNaN(plugins.habits.commits.day)) { %>\r\n              <section class=\"column chart\">\r\n                <h3>Commit activity per day</h3>\r\n                <div class=\"chart-bars\">\r\n                  <% for (let d = 0; d < 7; d++) { const p = (plugins.habits.commits.days[d]??0)/(plugins.habits.commits.days.max??1); %>\r\n                    <div class=\"entry\">\r\n                      <span class=\"value\"><%= plugins.habits.commits.days[d] %></span>\r\n                      <div class=\"bar\" style=\"height: <%= p*50 %>px; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                      <%= [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"][d] %>\r\n                    </div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n            <% if (plugins.habits.linguist.available) { %>\r\n              <section class=\"column chart\">\r\n                <h3>Language activity</h3>\r\n                <div class=\"chart-bars horizontal\">\r\n                  <% for (const [language, p] of plugins.habits.linguist.ordered) { %>\r\n                    <div class=\"entry\">\r\n                      <span class=\"name\"><%= language %></span>\r\n                      <div class=\"bar\" style=\"width: <%= p*80 %>%; background-color: var(--color-calendar-graph-day-L<%= Math.ceil(p/0.25) %>-bg)\"></div>\r\n                      <span class=\"value\"><%= Math.round(100*p) %>%</span>\r\n                    </div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        <% } %>\r\n      <% } %>\r\n\r\n      <% if (plugins.topics) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M14.184 1.143a1.75 1.75 0 00-2.502-.57L.912 7.916a1.75 1.75 0 00-.53 2.32l.447.775a1.75 1.75 0 002.275.702l11.745-5.656a1.75 1.75 0 00.757-2.451l-1.422-2.464zm-1.657.669a.25.25 0 01.358.081l1.422 2.464a.25.25 0 01-.108.35l-2.016.97-1.505-2.605 1.85-1.26zM9.436 3.92l1.391 2.41-5.42 2.61-.942-1.63 4.97-3.39zM3.222 8.157l-1.466 1a.25.25 0 00-.075.33l.447.775a.25.25 0 00.325.1l1.598-.769-.83-1.436zm6.253 2.306a.75.75 0 00-.944-.252l-1.809.87a.75.75 0 00-.293.253L4.38 14.326a.75.75 0 101.238.848l1.881-2.75v2.826a.75.75 0 001.5 0v-2.826l1.881 2.75a.75.75 0 001.238-.848l-2.644-3.863z\"></path></svg>\r\n            Starred topics\r\n          </h2>\r\n          <div class=\"row\">\r\n            <% if (plugins.topics.error) { %>\r\n              <section>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.topics.error.message %>\r\n                </div>\r\n              </section>\r\n            <% } else { %>\r\n              <section>\r\n                <div class=\"topics fill-width\">\r\n                  <% for (const {name, description} of plugins.topics.list) { %>\r\n                    <div class=\"label\" title=\"<%= description %>\"><%= name.toLocaleLowerCase() %></div>\r\n                  <% } %>\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.music) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 8a6.5 6.5 0 1113 0 6.5 6.5 0 01-13 0zM8 0a8 8 0 100 16A8 8 0 008 0zM6.379 5.227A.25.25 0 006 5.442v5.117a.25.25 0 00.379.214l4.264-2.559a.25.25 0 000-.428L6.379 5.227z\"></path></svg>\r\n            <%= plugins.music.mode %>\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.music.provider) { %>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.002 2.725a.75.75 0 01.797-.699C8.79 2.42 13.58 7.21 13.974 13.201a.75.75 0 11-1.497.098 10.502 10.502 0 00-9.776-9.776.75.75 0 01-.7-.798zM2 13a1 1 0 112 0 1 1 0 01-2 0zm.84-5.95a.75.75 0 00-.179 1.489c2.509.3 4.5 2.291 4.8 4.8a.75.75 0 101.49-.178A7.003 7.003 0 002.838 7.05z\"></path></svg>\r\n                  From <%= plugins.music.provider %>\r\n                </div>\r\n              <% } %>\r\n              <% if (plugins.music.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.music.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <% if (plugins.music.tracks.length) { %>\r\n                  <div class=\"tracklist\">\r\n                    <% for (const {name = \"\", artist = \"\", artwork = \"\"} of plugins.music.tracks) { %>\r\n                      <div class=\"track\">\r\n                        <img src=\"data:image/png;base64,<%= artwork %>\" width=\"32\" height=\"32\" alt=\"\"/>\r\n                        <div class=\"infos\">\r\n                          <div class=\"name\"><%= name %></div>\r\n                          <div class=\"artist\"><%= artist %></div>\r\n                        </div>\r\n                      </div>\r\n                    <% } %>\r\n                  </div>\r\n                <% } else { %>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                    No music recently listened\r\n                  </div>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.posts) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.456.734a1.75 1.75 0 012.826.504l.613 1.327a3.081 3.081 0 002.084 1.707l2.454.584c1.332.317 1.8 1.972.832 2.94L11.06 10l3.72 3.72a.75.75 0 11-1.061 1.06L10 11.06l-2.204 2.205c-.968.968-2.623.5-2.94-.832l-.584-2.454a3.081 3.081 0 00-1.707-2.084l-1.327-.613a1.75 1.75 0 01-.504-2.826L4.456.734zM5.92 1.866a.25.25 0 00-.404-.072L1.794 5.516a.25.25 0 00.072.404l1.328.613A4.582 4.582 0 015.73 9.63l.584 2.454a.25.25 0 00.42.12l5.47-5.47a.25.25 0 00-.12-.42L9.63 5.73a4.581 4.581 0 01-3.098-2.537L5.92 1.866z\"></path></svg>\r\n            Recent articles\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.posts.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.posts.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.002 2.725a.75.75 0 01.797-.699C8.79 2.42 13.58 7.21 13.974 13.201a.75.75 0 11-1.497.098 10.502 10.502 0 00-9.776-9.776.75.75 0 01-.7-.798zM2 13a1 1 0 112 0 1 1 0 01-2 0zm.84-5.95a.75.75 0 00-.179 1.489c2.509.3 4.5 2.291 4.8 4.8a.75.75 0 101.49-.178A7.003 7.003 0 002.838 7.05z\"></path></svg>\r\n                  From <%= plugins.posts.source %>\r\n                </div>\r\n                <% if (plugins.posts.list.length) { %>\r\n                  <% for (const {title, date} of plugins.posts.list) { %>\r\n                    <div class=\"field post\">\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 0a.75.75 0 01.75.75V2h5V.75a.75.75 0 011.5 0V2h1.25c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V3.75C1 2.784 1.784 2 2.75 2H4V.75A.75.75 0 014.75 0zm0 3.5h8.5a.25.25 0 01.25.25V6h-11V3.75a.25.25 0 01.25-.25h2zm-2.25 4v6.75c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V7.5h-11z\"></path></svg>\r\n                      <div class=\"infos\">\r\n                        <div class=\"date\"><%= date %></div>\r\n                        <div class=\"title\"><%= title %></div>\r\n                      </div>\r\n                    </div>\r\n                  <% } %>\r\n                <% } else { %>\r\n                  <div class=\"field\">\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                    No recent posts\r\n                  </div>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.tweets) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 273.5 222.3\" width=\"16\" height=\"16\"><path d=\"M273.5 26.3a109.77 109.77 0 0 1-32.2 8.8 56.07 56.07 0 0 0 24.7-31 113.39 113.39 0 0 1-35.7 13.6 56.1 56.1 0 0 0-97 38.4 54 54 0 0 0 1.5 12.8A159.68 159.68 0 0 1 19.1 10.3a56.12 56.12 0 0 0 17.4 74.9 56.06 56.06 0 0 1-25.4-7v.7a56.11 56.11 0 0 0 45 55 55.65 55.65 0 0 1-14.8 2 62.39 62.39 0 0 1-10.6-1 56.24 56.24 0 0 0 52.4 39 112.87 112.87 0 0 1-69.7 24 119 119 0 0 1-13.4-.8 158.83 158.83 0 0 0 86 25.2c103.2 0 159.6-85.5 159.6-159.6 0-2.4-.1-4.9-.2-7.3a114.25 114.25 0 0 0 28.1-29.1\"></path></svg>\r\n            Latest tweets\r\n          </h2>\r\n          <div class=\"row fill-width\">\r\n            <section>\r\n              <% if (plugins.tweets.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.tweets.error.message %>\r\n                </div>\r\n              <% } else { %>\r\n                <div class=\"field <%= !plugins.tweets.profile ? 'error' : '' %>\">\r\n                  <% if (plugins.tweets.profile?.verified) { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M9.585.52a2.678 2.678 0 00-3.17 0l-.928.68a1.178 1.178 0 01-.518.215L3.83 1.59a2.678 2.678 0 00-2.24 2.24l-.175 1.14a1.178 1.178 0 01-.215.518l-.68.928a2.678 2.678 0 000 3.17l.68.928c.113.153.186.33.215.518l.175 1.138a2.678 2.678 0 002.24 2.24l1.138.175c.187.029.365.102.518.215l.928.68a2.678 2.678 0 003.17 0l.928-.68a1.17 1.17 0 01.518-.215l1.138-.175a2.678 2.678 0 002.241-2.241l.175-1.138c.029-.187.102-.365.215-.518l.68-.928a2.678 2.678 0 000-3.17l-.68-.928a1.179 1.179 0 01-.215-.518L14.41 3.83a2.678 2.678 0 00-2.24-2.24l-1.138-.175a1.179 1.179 0 01-.518-.215L9.585.52zM7.303 1.728c.415-.305.98-.305 1.394 0l.928.68c.348.256.752.423 1.18.489l1.136.174c.51.078.909.478.987.987l.174 1.137c.066.427.233.831.489 1.18l.68.927c.305.415.305.98 0 1.394l-.68.928a2.678 2.678 0 00-.489 1.18l-.174 1.136a1.178 1.178 0 01-.987.987l-1.137.174a2.678 2.678 0 00-1.18.489l-.927.68c-.415.305-.98.305-1.394 0l-.928-.68a2.678 2.678 0 00-1.18-.489l-1.136-.174a1.178 1.178 0 01-.987-.987l-.174-1.137a2.678 2.678 0 00-.489-1.18l-.68-.927a1.178 1.178 0 010-1.394l.68-.928c.256-.348.423-.752.489-1.18l.174-1.136c.078-.51.478-.909.987-.987l1.137-.174a2.678 2.678 0 001.18-.489l.927-.68zM11.28 6.78a.75.75 0 00-1.06-1.06L7 8.94 5.78 7.72a.75.75 0 00-1.06 1.06l1.75 1.75a.75.75 0 001.06 0l3.75-3.75z\"></path></svg>\r\n                  <% } else { %>\r\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 2.37a6.5 6.5 0 006.5 11.26.75.75 0 01.75 1.298 8 8 0 113.994-7.273.754.754 0 01.006.095v1.5a2.75 2.75 0 01-5.072 1.475A4 4 0 1112 8v1.25a1.25 1.25 0 002.5 0V7.867a6.5 6.5 0 00-9.75-5.496V2.37zM10.5 8a2.5 2.5 0 10-5 0 2.5 2.5 0 005 0z\"></path></svg>\r\n                  <% } %>\r\n                  <%= plugins.tweets.username %>\r\n                  <% if (!plugins.tweets.profile) { %>\r\n                    : twitter username not found\r\n                  <% } %>\r\n                </div>\r\n                <% if (plugins.tweets.profile) { %>\r\n                  <% if (plugins.tweets.list.length) { %>\r\n                    <% for (const {text, created_at} of plugins.tweets.list) { %>\r\n                      <div class=\"tweet\">\r\n                        <%- text %>\r\n                        <div class=\"date\"><%= new Date(created_at).toGMTString() %></div>\r\n                      </div>\r\n                    <% } %>\r\n                  <% } else { %>\r\n                    <div class=\"field\">\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.75 1.5a.25.25 0 00-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 01.75.75v2.19l2.72-2.72a.75.75 0 01.53-.22h6.5a.25.25 0 00.25-.25v-9.5a.25.25 0 00-.25-.25H1.75zM0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0114.25 13H8.06l-2.573 2.573A1.457 1.457 0 013 14.543V13H1.75A1.75 1.75 0 010 11.25v-9.5zM9 9a1 1 0 11-2 0 1 1 0 012 0zm-.25-5.25a.75.75 0 00-1.5 0v2.5a.75.75 0 001.5 0v-2.5z\"></path></svg>\r\n                      No recent tweets\r\n                    </div>\r\n                  <% } %>\r\n                <% } %>\r\n              <% } %>\r\n            </section>\r\n          </div>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (plugins.isocalendar) { %>\r\n        <section>\r\n          <h2 class=\"field\">\r\n            <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M4.75 0a.75.75 0 01.75.75V2h5V.75a.75.75 0 011.5 0V2h1.25c.966 0 1.75.784 1.75 1.75v10.5A1.75 1.75 0 0113.25 16H2.75A1.75 1.75 0 011 14.25V3.75C1 2.784 1.784 2 2.75 2H4V.75A.75.75 0 014.75 0zm0 3.5h8.5a.25.25 0 01.25.25V6h-11V3.75a.25.25 0 01.25-.25h2zm-2.25 4v6.75c0 .138.112.25.25.25h10.5a.25.25 0 00.25-.25V7.5h-11z\"></path></svg>\r\n            Contributions calendar\r\n          </h2>\r\n          <div class=\"row\">\r\n            <section>\r\n              <% if (plugins.isocalendar.error) { %>\r\n                <div class=\"field error\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z\"></path></svg>\r\n                  <%= plugins.isocalendar.error.message %>\r\n                </div>\r\n              <% } %>\r\n            </section>\r\n            <% if (!plugins.isocalendar.error) { %>\r\n              <section>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M7.998 14.5c2.832 0 5-1.98 5-4.5 0-1.463-.68-2.19-1.879-3.383l-.036-.037c-1.013-1.008-2.3-2.29-2.834-4.434-.322.256-.63.579-.864.953-.432.696-.621 1.58-.046 2.73.473.947.67 2.284-.278 3.232-.61.61-1.545.84-2.403.633a2.788 2.788 0 01-1.436-.874A3.21 3.21 0 003 10c0 2.53 2.164 4.5 4.998 4.5zM9.533.753C9.496.34 9.16.009 8.77.146 7.035.75 4.34 3.187 5.997 6.5c.344.689.285 1.218.003 1.5-.419.419-1.54.487-2.04-.832-.173-.454-.659-.762-1.035-.454C2.036 7.44 1.5 8.702 1.5 10c0 3.512 2.998 6 6.498 6s6.5-2.5 6.5-6c0-2.137-1.128-3.26-2.312-4.438-1.19-1.184-2.436-2.425-2.653-4.81z\"></path></svg>\r\n                  Current streak <%= plugins.isocalendar.streak.current %> day<%= s(plugins.isocalendar.streak.current) %>\r\n                </div>\r\n                <div class=\"field\">\r\n                  <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\"><path fill-rule=\"evenodd\" d=\"M1.5 1.75a.75.75 0 00-1.5 0v12.5c0 .414.336.75.75.75h14.5a.75.75 0 000-1.5H1.5V1.75zm14.28 2.53a.75.75 0 00-1.06-1.06L10 7.94 7.53 5.47a.75.75 0 00-1.06 0L3.22 8.72a.75.75 0 001.06 1.06L7 7.06l2.47 2.47a.75.75 0 001.06 0l5.25-5.25z\"></path></svg>\r\n                  ~<%= plugins.isocalendar.average %> commits per day\r\n                </div>\r\n              </section>\r\n            <% } %>\r\n          </div>\r\n          <% if (plugins.isocalendar.svg) { %>\r\n            <%- plugins.isocalendar.svg %>\r\n          <% } %>\r\n        </section>\r\n      <% } %>\r\n\r\n      <% if (base.metadata) { %>\r\n        <footer>\r\n          <span>These metrics <%= !computed.token.scopes.includes(\"repo\") ? \"does not include all\" : \"includes\" %> private contributions<% if ((config.timezone?.name)&&(!config.timezone?.error)) { %>, timezone <%= config.timezone.name %><% } %></span>\r\n          <span>Last updated <%= new Date().toGMTString() %> with lowlighter/metrics@<%= meta.version %></span>\r\n        </footer>\r\n      <% } %>\r\n\r\n    </div>\r\n  </foreignObject>\r\n</svg>","style":"/* SVG global context */\r\n  svg {\r\n    font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial, sans-serif, Apple Color Emoji, Segoe UI Emoji;\r\n    font-size: 14px;\r\n    color: #777777;\r\n  }\r\n\r\n/* Headers */\r\n  h1, h2, h3 {\r\n    margin: 8px 0 2px;\r\n    padding: 0;\r\n    color: #0366d6;\r\n    font-weight: normal;\r\n  }\r\n  h1 svg, h2 svg, h3 svg {\r\n    fill: currentColor;\r\n  }\r\n  h1 {\r\n    font-size: 20px;\r\n    font-weight: bold;\r\n  }\r\n  h2 {\r\n    font-size: 16px;\r\n  }\r\n  h3 {\r\n    font-size: 14px;\r\n  }\r\n\r\n/* Fields */\r\n  section > .field {\r\n    margin-left: 5px;\r\n    margin-right: 5px;\r\n  }\r\n  .field {\r\n    display: flex;\r\n    align-items: center;\r\n    margin-bottom: 2px;\r\n    white-space: nowrap;\r\n  }\r\n  .field svg {\r\n    margin: 0 8px;\r\n    fill: #959da5;\r\n    flex-shrink: 0;\r\n  }\r\n  .field.error {\r\n    color: #cb2431;\r\n  }\r\n  .field.error svg {\r\n    fill: #cb2431;\r\n  }\r\n\r\n/* Displays */\r\n  .row {\r\n    display: flex;\r\n  }\r\n  .row section {\r\n    flex: 1 1 0;\r\n  }\r\n  .column {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n  }\r\n  .center {\r\n    justify-content: center;\r\n  }\r\n  .horizontal {\r\n    justify-content: space-around;\r\n  }\r\n  .horizontal-wrap {\r\n    flex-wrap: wrap;\r\n  }\r\n  .horizontal .field {\r\n    flex: 1 1 0;\r\n  }\r\n  .no-wrap {\r\n    white-space: nowrap;\r\n  }\r\n  .fill-width {\r\n    width: 100%;\r\n  }\r\n\r\n/* User avatar */\r\n  .avatar {\r\n    background-color: #000000;\r\n    border-radius: 50%;\r\n    margin: 0 6px;\r\n  }\r\n\r\n/* Commit calendar */\r\n  .calendar.field {\r\n    margin: 4px 0;\r\n    margin-left: 7px;\r\n  }\r\n  .calendar .day {\r\n    outline: 1px solid rgba(27,31,35,.04);\r\n    outline-offset: -1px;\r\n  }\r\n\r\n/* Progress bars */\r\n  svg.bar {\r\n    margin: 4px 0;\r\n  }\r\n\r\n/* Language */\r\n  .field.language {\r\n    margin: 0 8px;\r\n    flex-grow: 0;\r\n  }\r\n\r\n  .field.language small {\r\n    margin-left: 4px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Labels */\r\n  .label {\r\n    background-color: #F1F8FF;\r\n    color: #0366D6;\r\n    padding: 0 10px;\r\n    font-weight: 500;\r\n    line-height: 22px;\r\n    margin: 2px 5px;\r\n    white-space: nowrap;\r\n    border-radius: 32px;\r\n    font-size: 12px;\r\n  }\r\n\r\n  .label:hover {\r\n    background-color: #DDEEFF;\r\n    cursor: pointer;\r\n  }\r\n\r\n/* Habits */\r\n  .habits {\r\n    margin: 0;\r\n    list-style-type: none;\r\n    padding-left: 37px;\r\n  }\r\n\r\n/* Footer */\r\n  footer {\r\n    margin-top: 8px;\r\n    font-size: 10px;\r\n    font-style: italic;\r\n    color: #666666;\r\n    text-align: right;\r\n    display: flex;\r\n    flex-direction: column;\r\n    justify-content: flex-end;\r\n  }\r\n\r\n/* Speed test categories */\r\n  .categories {\r\n    display: flex;\r\n    align-items: center;\r\n    justify-content: space-around;\r\n    margin-top: 4px;\r\n  }\r\n  .categorie {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    flex: 1 1 0;\r\n  }\r\n\r\n/* Gauges */\r\n  .gauge {\r\n    stroke-linecap: round;\r\n    fill: none;\r\n  }\r\n  .gauge.high {\r\n    color: #18b663;\r\n  }\r\n  .gauge.average {\r\n    color: #fb8c00;\r\n  }\r\n  .gauge.low {\r\n    color: #e53935;\r\n  }\r\n  .gauge-base, .gauge-arc {\r\n    stroke: currentColor;\r\n    stroke-width: 10;\r\n  }\r\n  .gauge-base {\r\n    stroke-opacity: .2;\r\n  }\r\n  .gauge-arc {\r\n    fill: none;\r\n    stroke-dashoffset: 0;\r\n    animation-delay: 250ms;\r\n    animation: animation-gauge 1s ease forwards\r\n  }\r\n  .gauge text {\r\n    fill: currentColor;\r\n    font-size: 40px;\r\n    font-family: monospace;\r\n    text-anchor: middle;\r\n    font-weight: 600;\r\n  }\r\n  .gauge .title {\r\n    font-size: 18px;\r\n    color: #777777;\r\n  }\r\n  @keyframes animation-gauge {\r\n    from {\r\n      stroke-dasharray: 0 329;\r\n    }\r\n  }\r\n  .audits {\r\n    margin-top: 8px;\r\n  }\r\n  .audit.text {\r\n    min-width: 42px;\r\n  }\r\n  .audit svg {\r\n    margin: 0;\r\n  }\r\n  .audit.high {\r\n    fill: #18b663;\r\n  }\r\n  .audit.average {\r\n    fill: #fb8c00;\r\n  }\r\n  .audit.low {\r\n    fill: #e53935;\r\n  }\r\n\r\n/* Music plugin */\r\n  .tracklist {\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: flex-start;\r\n    margin-left: 28px;\r\n    margin-top: 4px;\r\n    width: 100%;\r\n  }\r\n  .track {\r\n    display: flex;\r\n    align-items: center;\r\n    justify-content: center;\r\n    margin-bottom: 4px;\r\n  }\r\n  .track img {\r\n    margin: 0 10px;\r\n    border-radius: 7px;\r\n  }\r\n  .track .name {\r\n    font-size: 14px;\r\n    line-height: 14px;\r\n  }\r\n  .track .artist {\r\n    font-size: 12px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Posts plugin */\r\n  .post {\r\n    align-items: flex-start;\r\n  }\r\n  .post .infos {\r\n    display: flex;\r\n    margin-bottom: 4px;\r\n  }\r\n  .post .infos .title {\r\n    font-size: 14px;\r\n    width: 400px;\r\n    white-space: normal;\r\n    overflow: hidden;\r\n    text-overflow: ellipsis;\r\n    max-height: 40px;;\r\n  }\r\n  .post .infos .date {\r\n    flex-shrink: 0;\r\n    font-size: 12px;\r\n    color: #666666;\r\n    width: 40px;\r\n    padding-top: 1px;\r\n  }\r\n\r\n/* Topics */\r\n  .topics {\r\n    display: flex;\r\n    flex-wrap: wrap;\r\n  }\r\n\r\n/* Tweets */\r\n  .tweet {\r\n    font-size: 13px;\r\n    margin-top: 6px;\r\n    margin-bottom: 16px;\r\n    margin-left: 18px;\r\n    border-left: 3px solid #777777B2;\r\n    padding-left: 6px;\r\n  }\r\n\r\n  .tweet .mention, .tweet .link, .tweet .hashtag {\r\n    color: #0366d6;\r\n  }\r\n\r\n  .tweet .date {\r\n    margin: 6px 0;\r\n    font-size: 12px;\r\n    color: #666666;\r\n  }\r\n\r\n/* Charts and graphs */\r\n  .chart {\r\n    padding: 0 8px;\r\n  }\r\n\r\n  .chart-bars {\r\n    display: flex;\r\n    justify-content: space-between;\r\n    align-items: flex-end;\r\n    width: 100%;\r\n    margin: 8px 0 4px;\r\n  }\r\n\r\n  .chart-bars .entry {\r\n    flex: 1 1 0;\r\n    display: flex;\r\n    flex-direction: column;\r\n    align-items: center;\r\n    font-size: 10px;\r\n    color: #666666;\r\n  }\r\n\r\n  .chart-bars .entry .value {\r\n    font-size: 9px;\r\n  }\r\n\r\n  .chart-bars .bar {\r\n    width: 7px;\r\n    background-color: var(--color-calendar-graph-day-bg);\r\n    border: 1px solid var(--color-calendar-graph-day-border);\r\n    border-radius: 5px;\r\n  }\r\n\r\n  .chart-bars.horizontal {\r\n    flex-direction: column;\r\n    align-items: space-between;\r\n    height: 100%;\r\n  }\r\n\r\n  .chart-bars.horizontal .entry {\r\n    align-items: center;\r\n    flex-direction: row;\r\n    width: 100%;\r\n  }\r\n\r\n  .chart-bars.horizontal .entry .name {\r\n    flex-shrink: 0;\r\n    text-align: right;\r\n    min-width: 30%;\r\n  }\r\n\r\n  .chart-bars.horizontal .bar {\r\n    height: 7px;\r\n    width: auto;\r\n    margin: 0 6px;\r\n  }\r\n\r\n/* Fade animation */\r\n  .af {\r\n    opacity: 0;\r\n    animation: animation-fade 1s ease forwards;\r\n  }\r\n  @keyframes animation-fade {\r\n    from {\r\n      opacity: 0;\r\n    }\r\n    to {\r\n      opacity: 1;\r\n    }\r\n  }\r\n\r\n/* Cake day */\r\n  .cakeday, .cakeday svg {\r\n    animation: animation-rainbow 1.2s;\r\n    animation-iteration-count: infinite;\r\n    animation-timing-function: steps(1);\r\n  }\r\n\r\n/* Rainbow animation */\r\n  @keyframes animation-rainbow {\r\n    0%, 100%{ color: #7F00FF; fill: #7F00FF; }\r\n    14% { color: #A933FF; fill: #A933FF; }\r\n    29%{ color: #007FFF; fill: #007FFF; }\r\n    43%{ color: #00FF7F; fill: #00FF7F; }\r\n\t\t57%{ color: #FFFF00; fill: #FFFF00; }\r\n\t\t71%{ color: #FF7F00; fill: #FF7F00; }\r\n\t\t86%{ color: #FF0000; fill: #FF0000; }\r\n  }\r\n\r\n/* Calendar */\r\n  :root {\r\n    --color-calendar-graph-day-bg: #ebedf0;\r\n    --color-calendar-graph-day-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-bg: #9be9a8;\r\n    --color-calendar-graph-day-L2-bg: #40c463;\r\n    --color-calendar-graph-day-L3-bg: #30a14e;\r\n    --color-calendar-graph-day-L4-bg: #216e39;\r\n    --color-calendar-halloween-graph-day-L1-bg: #ffee4a;\r\n    --color-calendar-halloween-graph-day-L2-bg: #ffc501;\r\n    --color-calendar-halloween-graph-day-L3-bg: #fe9600;\r\n    --color-calendar-halloween-graph-day-L4-bg: #03001c;\r\n    --color-calendar-graph-day-L4-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L3-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L2-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-border: rgba(27,31,35,0.06);\r\n  }","fonts":""},"terminal":{"query":"query Metrics {\r\n  user(login: $login) {\r\n    databaseId\r\n    name\r\n    login\r\n    createdAt\r\n    avatarUrl\r\n    websiteUrl\r\n    isHireable\r\n    twitterUsername\r\n    gists {\r\n      totalCount\r\n    }\r\n    repositories(last: $repositories, isFork: false, ownerAffiliations: OWNER) {\r\n      totalCount\r\n      totalDiskUsage\r\n      nodes {\r\n        name\r\n        watchers {\r\n          totalCount\r\n        }\r\n        stargazers {\r\n          totalCount\r\n        }\r\n        languages(first: 4) {\r\n          edges {\r\n            size\r\n            node {\r\n              color\r\n              name\r\n            }\r\n          }\r\n        }\r\n        issues_open: issues(states: OPEN) {\r\n          totalCount\r\n        }\r\n        issues_closed: issues(states: CLOSED) {\r\n          totalCount\r\n        }\r\n        pr_open: pullRequests(states: OPEN) {\r\n          totalCount\r\n        }\r\n        pr_merged: pullRequests(states: MERGED) {\r\n          totalCount\r\n        }\r\n        releases {\r\n          totalCount\r\n        }\r\n        forkCount\r\n        licenseInfo {\r\n          spdxId\r\n        }\r\n      }\r\n    }\r\n    packages {\r\n      totalCount\r\n    }\r\n    starredRepositories {\r\n      totalCount\r\n    }\r\n    watching {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsSponsor {\r\n      totalCount\r\n    }\r\n    sponsorshipsAsMaintainer {\r\n      totalCount\r\n    }\r\n    contributionsCollection {\r\n      totalRepositoriesWithContributedCommits\r\n      totalCommitContributions\r\n      restrictedContributionsCount\r\n      totalIssueContributions\r\n      totalPullRequestContributions\r\n      totalPullRequestReviewContributions\r\n    }\r\n    calendar:contributionsCollection(from: $calendar.from, to: $calendar.to) {\r\n      contributionCalendar {\r\n        weeks {\r\n          contributionDays {\r\n            color\r\n          }\r\n        }\r\n      }\r\n    }\r\n    repositoriesContributedTo {\r\n      totalCount\r\n    }\r\n    followers {\r\n      totalCount\r\n    }\r\n    following {\r\n      totalCount\r\n    }\r\n    issueComments {\r\n      totalCount\r\n    }\r\n    organizations {\r\n      totalCount\r\n    }\r\n  }\r\n}\r\n","image":"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"480\" height=\"<%= 48\r\n  + (!!base.header)*62\r\n  + (!!base.metadata)*108\r\n  + (!!base.activity)*108\r\n  + (!!base.community)*94\r\n  + (!!base.repositories)*142\r\n  + ((!!base.repositories)*(!!plugins.traffic))*18\r\n  + ((!!base.repositories)*(!!plugins.followup))*102\r\n  + ((!!base.repositories)*(!!plugins.lines))*34\r\n  + (!!plugins.pagespeed)*110 + (plugins.pagespeed?.detailed ?? 0)*6*16\r\n  + (!!plugins.languages)*124\r\n  + (!!plugins.gists)*58\r\n  + Math.max(0, (((!!base.metadata)+(!!base.header)+((!!base.activity)||(!!base.community))+(!!base.repositories)+(!!plugins.pagespeed)+(!!plugins.languages)+(!!plugins.gists))-1))*20\r\n%>\">\r\n  <%\r\n    meta.$ = `<span class=\"ps1-path\">${`${user.login}`.toLocaleLowerCase()}@metrics</span>:<span class=\"ps1-location\">~</span>${computed.token.scopes.includes(\"repo\") ? \"#\" : \"$\"}`\r\n    meta.animations = !meta.placeholder ? {stdin:.16, stdout:.28, length:(2+Object.keys(base).length+Object.keys(plugins).length)} : {stdin:0, stdout:0, length:0}\r\n  %>\r\n\r\n  <defs><style><%= fonts %></style></defs>\r\n\r\n  <style>\r\n    <%= style %>\r\n      .stdin, .stdout {\r\n        animation-duration: <%= meta.animations.stdin %>s;\r\n      }\r\n      .stdout {\r\n        animation-duration: <%= meta.animations.stdout %>s;\r\n      }\r\n      <% for (let i = 0, d = 0; i < meta.animations.length; i++, d+=meta.animations.stdin+meta.animations.stdout) { %>\r\n        .stdin:nth-of-type(<%= i+1 %>) {\r\n          animation-delay: <%= d %>s;\r\n        }\r\n        .stdout:nth-of-type(<%= i+2 %>) {\r\n          animation-delay: <%= d+meta.animations.stdin %>s;\r\n        }\r\n        <% if (i === meta.animations.length-1) { %>\r\n          footer {\r\n            animation-delay: <%= d %>s;\r\n          }\r\n        <% } %>\r\n      <% } %>\r\n  </style>\r\n\r\n  <foreignObject x=\"0\" y=\"0\" width=\"100%\" height=\"100%\">\r\n    <div xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n\r\n      <div class=\"header\">\r\n        <span class=\"title\"></span>\r\n        <div class=\"buttons\">\r\n          <div class=\"button\">─</div>\r\n          <div class=\"button\">□</div>\r\n          <div class=\"button exit\">✕</div>\r\n        </div>\r\n      </div>\r\n\r\n<pre><%# -%>\r\n<% if (base.metadata) { %>\r\n<div class=\"banner\"><%# -%>\r\nGitHub metrics generator <%= meta.version %>\r\nThese generated metrics comes with ABSOLUTELY NO\r\nWARRANTY, to the extent permitted by applicable law.\r\n\r\nLast generated: <%= new Date().toGMTString() %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.header) { %>\r\n<div class=\"stdin\"><%- meta.$ %> whoami</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<b><%= user.name || user.login %></b> registered=<%= computed.registration.match(/^.+? [ym]/)[0].replace(/ /g, \"\") %>, uid=<%= `${user.databaseId}`.substr(-4) %>, gid=<%= user.organizations.totalCount %>\r\n  contributed to <%= user.repositoriesContributedTo.totalCount %> repositor<%= s(user.repositoriesContributedTo.totalCount, \"y\") %> <b><% for (const [x, {color}] of Object.entries(computed.calendar)) { -%><span style=\"color:<%= color %>\">#</span><% } %></b>\r\n  followed by <b><%= user.followers.totalCount %></b> user<%= s(user.followers.totalCount) %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if ((base.activity)||(base.community)) { %>\r\n<div class=\"stdin\"><%- meta.$ %> git status</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (base.activity) { -%>\r\n<b>Recent activity</b>\r\n  <b><%= `${computed.commits}`.padStart(5) %></b> commit<%= s(computed.commits) %>\r\n  <b><%= `${user.contributionsCollection.totalPullRequestReviewContributions}`.padStart(5) %></b> pull request<%= s(user.contributionsCollection.totalPullRequestReviewContributions) %> reviewed\r\n  <b><%= `${user.contributionsCollection.totalPullRequestContributions}`.padStart(5) %></b> pull request<%= s(user.contributionsCollection.totalPullRequestContributions) %> opened\r\n  <b><%= `${user.contributionsCollection.totalIssueContributions}`.padStart(5) %></b> issue<%= s(user.contributionsCollection.totalIssueContributions) %> opened\r\n  <b><%= `${user.issueComments.totalCount}`.padStart(5) %></b> issue comment<%= s(user.issueComments.totalCount) %>\r\n<% } -%>\r\n<% if ((base.activity)&&(base.community)) { -%>\r\n\r\n<% } -%>\r\n<% if (base.community) { -%>\r\n<b>Tracked activity</b>\r\n  <b><%= `${user.following.totalCount}`.padStart(5) %></b> user<%= s(user.followers.totalCount) %> followed\r\n  <b><%= `${user.sponsorshipsAsSponsor.totalCount}`.padStart(5) %></b> repositor<%= s(user.sponsorshipsAsSponsor.totalCount, \"y\") %> sponsored\r\n  <b><%= `${user.starredRepositories.totalCount}`.padStart(5) %></b> repositor<%= s(user.starredRepositories.totalCount, \"y\") %> starred\r\n  <b><%= `${user.watching.totalCount}`.padStart(5) %></b> repositor<%= s(user.watching.totalCount, \"y\") %> watched\r\n<% } -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.repositories) { %>\r\n<div class=\"stdin\"><%- meta.$ %> ls -lh github/repositories</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\nTotal <%= user.repositories.totalCount %> repositor<%= s(user.repositories.totalCount, \"y\") %> - <%= computed.diskUsage %>\r\n<% if (plugins.traffic) { if (plugins.traffic.error) { -%>\r\n----  <b>     </b>  views <span class=\"error\">(<%= plugins.traffic.error.message %>)</span>\r\n<% } else { -%>\r\n-r--  <b><%= `${plugins.traffic.views.count}`.padStart(5) %></b>  views\r\n<% }} -%>\r\n-r--  <b><%= `${computed.repositories.stargazers}`.padStart(5) %></b>  stargazer<%= s(computed.repositories.stargazers) %>\r\n-r--  <b><%= `${computed.repositories.forks}`.padStart(5) %></b>  fork<%= s(computed.repositories.forks) %>\r\n-r--  <b><%= `${computed.repositories.watchers}`.padStart(5) %></b>  watcher<%= s(computed.repositories.watchers) %>\r\ndr-x  <b><%= `${user.packages.totalCount}`.padStart(5) %></b>  package<%= s(user.packages.totalCount) %>\r\n<% if (plugins.followup) { if (plugins.followup.error) { -%>\r\nd---  <b>     </b>  ISSUES <span class=\"error\">(<%= plugins.followup.error.message %>)</span>\r\nd---  <b>     </b>  PULL_REQUESTS <span class=\"error\">(<%= plugins.followup.error.message %>)</span>\r\n<% } else { -%>\r\ndr-x  <b><%= `${plugins.followup.issues.count}`.padStart(5) %></b>  ISSUES\r\n-r--  <b><%= `${plugins.followup.issues.open}`.padStart(5) %></b>  ├── open\r\n-r--  <b><%= `${plugins.followup.issues.closed}`.padStart(5) %></b>  └── closed\r\ndr-x  <b><%= `${plugins.followup.issues.count}`.padStart(5) %></b>  PULL_REQUESTS\r\n-r--  <b><%= `${plugins.followup.pr.open}`.padStart(5) %></b>  ├── open\r\n-r--  <b><%= `${plugins.followup.pr.merged}`.padStart(5) %></b>  └── merged\r\n<% }} -%>\r\n<% if (computed.licenses.favorite.length) { -%>\r\ndr-x         LICENSE\r\n-r--         └── <%= computed.licenses.favorite %>\r\n<% } -%>\r\n<% if (plugins.lines) { if (plugins.lines.error) { %>\r\n<span class=\"diff error\">@@ <%= plugins.lines.error.message %> @@</span><% } else { %>\r\n<span class=\"diff\">@@ -<%= plugins.lines.deleted %> +<%= plugins.lines.added %> @@</span>\r\n<% }} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.gists) { %>\r\n<div class=\"stdin\"><%- meta.$ %> ls -lh github/gists</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\nTotal <%= plugins.gists.totalCount %> gist<%= s(plugins.gists.totalCount) %>\r\n-r--  <b><%= `${plugins.gists.stargazers}`.padStart(5) %></b>  stargazer<%= s(plugins.gists.stargazers) %>\r\n-r--  <b><%= `${plugins.gists.forks}`.padStart(5) %></b>  fork<%= s(plugins.gists.forks) %>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.languages) { %>\r\n<div class=\"stdin\"><%- meta.$ %> locale</div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (plugins.languages.error) { -%>\r\n<span class=\"error\"><%= plugins.languages.error.message %></span><%# -%>\r\n<% } else { for (const {name, value} of plugins.languages.favorites) { -%>\r\n<b><%= name.toLocaleUpperCase().padEnd(12) %></b> [<%= \"#\".repeat(Math.ceil(100*value/5)).padEnd(20) %>] <%= (100*value).toFixed(2).padEnd(5) %>%\r\n<% }} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (plugins.pagespeed) { %>\r\n<div class=\"stdin\"><%- meta.$ %> curl -<%= plugins.pagespeed.detailed ? \"v\" : \"\" %>I <%= user.websiteUrl %></div><%# -%>\r\n<div class=\"stdout\"><%# -%>\r\n<% if (plugins.pagespeed.error) { -%>\r\n<span class=\"error\"><%= plugins.pagespeed.error.message %></span><% } else { -%>\r\n<b>User-Agent</b>: Google PageSpeed API\r\n<b>Location</b>: <%= user.websiteUrl %>\r\n<% for (const {score, title} of plugins.pagespeed.scores) { -%>\r\n<b><%= `X-${title.replace(/ /g, \"-\")}` %></b>: <%= !Number.isNaN(score) ? Math.round(score*100) : \"-\" %>%\r\n<% } -%>\r\n<% if (plugins.pagespeed.detailed) { for (const {name, score, suffix = \"\", threshold} of [\r\n  {name:\"Time to interactive\", score:plugins.pagespeed.metrics.interactive/1000, suffix:\"s\", threshold:[3.785, 7.3]},\r\n  {name:\"Speed Index\", score:plugins.pagespeed.metrics.speedIndex/1000, suffix:\"s\", threshold:[3.387, 5.8]},\r\n  {name:\"Total Blocking Time\", score:plugins.pagespeed.metrics.totalBlockingTime/1000, suffix:\"s\", threshold:[.287, .6]},\r\n  {name:\"First Contentful Paint\", score:plugins.pagespeed.metrics.firstContentfulPaint/1000, suffix:\"s\", threshold:[2.336, 4]},\r\n  {name:\"Largest Contentful Paint\", score:plugins.pagespeed.metrics.largestContentfulPaint/1000, suffix:\"s\", threshold:[2.5, 4]},\r\n  {name:\"Cumulative Layout Shift\", score:+plugins.pagespeed.metrics.cumulativeLayoutShift, threshold:[.1, .25]}\r\n]) { -%>\r\n<b>&gt; <%= name %></b>: <%= !Number.isNaN(score) ? score : \"-\" %><%= suffix %> <% if (Number.isNaN(score)) { %><% } else if (score <= threshold[0]) { %>(ok +)<% } else if (score <= threshold[1]) { %>(ok)<% } else { %>(bad)<% } %>\r\n<% }}} -%>\r\n</div><% } -%>\r\n<%# ============================================================= -%>\r\n<% if (base.metadata) { -%>\r\n\r\n<footer>Connection reset by <%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %>.<%= Math.floor(256*Math.random()) %></footer><%# -%>\r\n<% } -%></pre>\r\n\r\n    </div>\r\n  </foreignObject>\r\n</svg>\r\n\r\n","style":"/* SVG global context */\r\n  svg {\r\n    font-family: 'Courier Prime';\r\n    font-size: 14px;\r\n    color: #777777;\r\n  }\r\n\r\n/* Title bar */\r\n  .header {\r\n    position: absolute;\r\n    top: 0;\r\n    display: flex;\r\n    justify-content: space-between;\r\n    width: 100%;\r\n    height: 20px;\r\n    align-items: center;\r\n    padding: 0 8px;\r\n    box-sizing: border-box;\r\n    border-top-left-radius: 5px;\r\n    border-top-right-radius: 5px;\r\n    background: linear-gradient(#504b45 0%,#3c3b37 100%);\r\n  }\r\n\r\n  .title {\r\n    color: #d5d0ce;\r\n    font-size: 16px;\r\n  }\r\n\r\n  .buttons {\r\n    display: flex;\r\n    align-items: center;\r\n  }\r\n\r\n  .button {\r\n    color: black;\r\n    display: flex;\r\n    justify-content: center;\r\n    margin-right: 5px;\r\n    font-size: 8px;\r\n    height: 12px;\r\n    width: 12px;\r\n    border-radius: 100%;\r\n    background: linear-gradient(#7d7871 0%, #595953 100%);\r\n    text-shadow: 0px 1px 0px rgba(255,255,255,0.2);\r\n  }\r\n\r\n  .button.exit {\r\n    background: linear-gradient(#f37458 0%, #de4c12 100%);\r\n  }\r\n\r\n/* Terminal */\r\n  pre, .banner, footer {\r\n    margin: 0;\r\n    font-family: 'Courier Prime';\r\n    color: #DDDDDD;\r\n  }\r\n  pre {\r\n    background: #42092B;\r\n    padding: 12px;\r\n    border-radius: 5px;\r\n  }\r\n  .banner, footer {\r\n    color: #AE9DA7;\r\n  }\r\n\r\n/* Prompt */\r\n  .ps1-path {\r\n    color: #7EDA29;\r\n  }\r\n\r\n  .ps1-location {\r\n    color: #4878c0;\r\n  }\r\n\r\n/* Diff */\r\n  .diff {\r\n    color: #3A96DD;\r\n  }\r\n\r\n/* Error */\r\n  .error {\r\n    color: #cb2431;\r\n  }\r\n\r\n/* Animations */\r\n  .stdin, footer {\r\n    width: 0%;\r\n    white-space: nowrap;\r\n    overflow: hidden;\r\n    animation-name: stdin-animation;\r\n    animation-fill-mode: both;\r\n  }\r\n\r\n  .stdout {\r\n    max-height: 0%;\r\n    overflow: hidden;\r\n    animation-name: stdout-animation;\r\n    animation-fill-mode: both;\r\n  }\r\n\r\n  @keyframes stdin-animation {\r\n    0% { width: 0%; }\r\n    100% { width: 100%; }\r\n  }\r\n\r\n  @keyframes stdout-animation {\r\n    0% { max-height: 0; }\r\n    100% { max-height: 360px; }\r\n  }\r\n\r\n/* Calendar */\r\n  :root {\r\n    --color-calendar-graph-day-bg: #ebedf0;\r\n    --color-calendar-graph-day-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-bg: #9be9a8;\r\n    --color-calendar-graph-day-L2-bg: #40c463;\r\n    --color-calendar-graph-day-L3-bg: #30a14e;\r\n    --color-calendar-graph-day-L4-bg: #216e39;\r\n    --color-calendar-halloween-graph-day-L1-bg: #ffee4a;\r\n    --color-calendar-halloween-graph-day-L2-bg: #ffc501;\r\n    --color-calendar-halloween-graph-day-L3-bg: #fe9600;\r\n    --color-calendar-halloween-graph-day-L4-bg: #03001c;\r\n    --color-calendar-graph-day-L4-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L3-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L2-border: rgba(27,31,35,0.06);\r\n    --color-calendar-graph-day-L1-border: rgba(27,31,35,0.06);\r\n  }","fonts":"@font-face {\r\n  font-family: 'Courier Prime';\r\n  src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff');\r\n  font-weight: normal;\r\n  font-style: normal;\r\n  font-display: swap;\r\n}\r\n\r\n@font-face {\r\n  font-family: 'Courier Prime';\r\n  src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff');\r\n  font-weight: bold;\r\n  font-style: normal;\r\n  font-display: swap;\r\n}\r\n"}}`,"base64").toString("utf8"));return t(`metrics/setup > setup > success`),a}async function a({login:e,imports:t,q:r},{enabled:n=!1,token:a=""}={}){try{if(!n||!r.music)return null;const o={get provider(){return _[s]?.name??""},get mode(){return w[l]??"Unconfigured music plugin"}};let i=null,{"music.provider":s="","music.mode":l="","music.playlist":d=null,"music.limit":p=4}=r;if(d&&!l&&(l="playlist"),d&&!s)for(const[e,{embed:t}]of Object.entries(_))t.test(d)&&(s=e);if(l||(l="recent"),!(s in _))throw{error:{message:s?`Unsupported provider "${s}"`:`Missing provider`},...o};if(!(l in w))throw{error:{message:`Unsupported mode "${l}"`},...o};if("playlist"===l){if(!d)throw{error:{message:`Missing playlist url`},...o};if(!_[s].embed.test(d))throw{error:{message:`Unsupported playlist url format`},...o}}switch(p=_Mathmax(1,_Mathmin(100,+p)),console.debug(`metrics/compute/${e}/plugins > music > processing mode ${l} with provider ${s}`),l){case"playlist":{console.debug(`metrics/compute/${e}/plugins > music > starting browser`);const r=await t.puppeteer.launch({headless:!0,executablePath:process.env.PUPPETEER_BROWSER_PATH,args:["--no-sandbox","--disable-extensions","--disable-setuid-sandbox","--disable-dev-shm-usage"]});console.debug(`metrics/compute/${e}/plugins > music > started ${await r.version()}`);const n=await r.newPage();console.debug(`metrics/compute/${e}/plugins > music > loading page`),await n.goto(d);const a=n.mainFrame();switch(s){case"apple":{await a.waitForSelector(".tracklist.playlist"),i=[...(await a.evaluate(()=>[...document.querySelectorAll(".tracklist li")].map(e=>({name:e.querySelector(".tracklist__track__name").innerText,artist:e.querySelector(".tracklist__track__sub").innerText,artwork:e.querySelector(".tracklist__track__artwork img").src}))))];break}case"spotify":{await a.waitForSelector("table"),i=[...(await a.evaluate(()=>[...document.querySelectorAll("table tr")].map(e=>({name:e.querySelector("td:nth-child(2) div:nth-child(1)").innerText,artist:e.querySelector("td:nth-child(2) div:nth-child(2)").innerText,artwork:window.getComputedStyle(document.querySelector("button[title=Play]").parentNode,null).backgroundImage.match(/^url\("(https:...+)"\)$/)[1]}))))];break}default:throw{error:{message:`Unsupported mode "${l}" for provider "${s}"`},...o};}console.debug(`metrics/compute/${e}/plugins > music > closing browser`),await r.close(),Array.isArray(i)&&(console.debug(`metrics/compute/${e}/plugins > music > found ${i.length} tracks`),console.debug(t.util.inspect(i,{depth:1/0,maxStringLength:256})),i=t.shuffle(i));break}case"recent":{const r=Date.now()-86400000;switch(s){case"spotify":{const[n,s,l]=a.split(",").map(e=>e.trim());if(!n||!s||!l)throw{error:{message:`Spotify token must contain client id/secret and refresh token`}};try{console.debug(`metrics/compute/${e}/plugins > music > requesting access token with spotify refresh token`);const{data:{access_token:a}}=await t.axios.post("https://accounts.spotify.com/api/token",`${new t.url.URLSearchParams({grant_type:"refresh_token",refresh_token:l,client_id:n,client_secret:s})}`,{headers:{"Content-Type":"application/x-www-form-urlencoded"}});console.debug(`metrics/compute/${e}/plugins > music > got access token`),console.debug(`metrics/compute/${e}/plugins > music > querying spotify api`),i=(await t.axios(`https://api.spotify.com/v1/me/player/recently-played?limit=${p}&after=${r}`,{headers:{Accept:"application/json","Content-Type":"application/json",Authorization:`Bearer ${a}`}})).data.items.map(({track:e})=>({name:e.name,artist:e.artists[0].name,artwork:e.album.images[0].url}))}catch(e){if(e.isAxiosError){const t=e.response?.status,r=e.response.data?.error_description??null,n=`API returned ${t}${r?` (${r})`:""}`;throw e=e.response?.data??null,{error:{message:n,instance:e},...o}}throw e}break}default:throw{error:{message:`Unsupported mode "${l}" for provider "${s}"`},...o};}break}default:throw{error:{message:`Unsupported mode "${l}"`},...o};}if(Array.isArray(i)){0 music > keeping only ${p} tracks`),i=i.slice(0,p)),console.debug(`metrics/compute/${e}/plugins > music > loading artworks`);for(const r of i)console.debug(`metrics/compute/${e}/plugins > music > processing ${r.name}`),r.artwork=await t.imgb64(r.artwork);return{...o,tracks:i}}throw{error:{message:`An error occured (could not retrieve tracks)`}}}catch(e){if(e.error?.message)throw e;throw{error:{message:"An error occured",instance:e}}}}async function o({login:e,q:t,dflags:r},{conf:n,data:a,rest:o,graphql:i,plugins:l},{s:d,pending:s,imports:p}){const c=a.computed={commits:0,sponsorships:0,licenses:{favorite:"",used:{}},token:{},repositories:{watchers:0,stargazers:0,issues_open:0,issues_closed:0,pr_open:0,pr_merged:0,forks:0,releases:0}},u=p.imgb64(a.user.avatarUrl);if(a.plugins={},console.debug(`metrics/compute/${e} > formatting common metrics`),t["config.timezone"]){const r=a.config.timezone={name:t["config.timezone"],offset:0};try{r.offset=+(1e3*(60*(60*new Date().toLocaleString("fr",{timeZoneName:"short",timeZone:r.name}).match(/UTC[+](?\d+)/)?.groups?.offset)))||0,console.debug(`metrics/compute/${e} > timezone set to ${r.name} (${0 failed to use timezone "${r.name}"`)}}for(const u of Object.keys(p.plugins))s.push((async()=>{try{console.debug(`metrics/compute/${e}/plugins > ${u} > started`),a.plugins[u]=await p.plugins[u]({login:e,q:t,imports:p,data:a,computed:c,rest:o,graphql:i},l[u]),console.debug(`metrics/compute/${e}/plugins > ${u} > completed (${null===a.plugins[u]?"skipped":"success"})`)}catch(t){console.debug(`metrics/compute/${e}/plugins > ${u} > completed (error)`),a.plugins[u]=t}finally{const e={name:u,result:a.plugins[u]};return console.debug(p.util.inspect(e,{depth:1/0,maxStringLength:256})),e}})());for(const u of a.user.repositories.nodes){for(const e of["watchers","stargazers","issues_open","issues_closed","pr_open","pr_merged","releases"])c.repositories[e]+=u[e].totalCount;c.repositories.forks+=u.forkCount,u.licenseInfo&&(c.licenses.used[u.licenseInfo.spdxId]=(c.licenses.used[u.licenseInfo.spdxId]??0)+1)}c.diskUsage=`${p.bytes(1e3*a.user.repositories.totalDiskUsage)}`,c.licenses.favorite=Object.entries(c.licenses.used).sort(([e,t],[r,n])=>n-t).slice(0,1).map(([e,t])=>e)??"",c.commits+=a.user.contributionsCollection.totalCommitContributions+a.user.contributionsCollection.restrictedContributionsCount;const m=(Date.now()-new Date(a.user.createdAt).getTime())/31536000000,g=_Mathfloor(m),h=_Mathceil(12*(m-g));c.registration=g?`${g} year${d(g)} ago`:`${h} month${d(h)} ago`,c.cakeday=[new Date,new Date(a.user.createdAt)].map(e=>e.toISOString().match(/(?\d{2}-\d{2})(?=T)/)?.groups?.mmdd).every((e,t,r)=>e===r[0]),c.calendar=a.user.calendar.contributionCalendar.weeks.flatMap(({contributionDays:e})=>e).slice(0,14).reverse(),c.avatar=(await u)||"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",c.token.scopes=(await o.request("HEAD /")).headers["x-oauth-scopes"].split(", "),a.meta={version:n.package.version,author:n.package.author},(r.includes("--cakeday")||t["dflag.cakeday"])&&(console.debug(`metrics/compute/${e} > applying dflag --cakeday`),c.cakeday=!0),(r.includes("--hireable")||t["dflag.hireable"])&&(console.debug(`metrics/compute/${e} > applying dflag --hireable`),a.user.isHireable=!0)}async function i({login:e,q:t,dflags:r=[]},{graphql:n,rest:a,plugins:o,conf:i,die:h=!1}){try{console.debug(`metrics/compute/${e} > start`),console.debug(S.inspect(t,{depth:1/0,maxStringLength:256}));const f=t.template||i.settings.templates.default,y=_Mathmax(0,+t.repositories)||i.settings.repositories||100,_=[],w=(e,t="")=>1 graphql query`),Object.assign(M,await n(s.replace(/[$]login/,`"${e}"`).replace(/[$]repositories/,`${y}`).replace(/[$]calendar.to/,`"${new Date().toISOString()}"`).replace(/[$]calendar.from/,`"${new Date(Date.now()-1209600000).toISOString()}"`))),console.debug(`metrics/compute/${e} > compute`);const g=E[f].default||E[f];await g({login:e,q:t,dflags:r},{conf:i,data:M,rest:a,graphql:n,plugins:o},{s:w,pending:_,imports:{plugins:T,url:O,imgb64:k,axios:C,puppeteer:A,run:m,fs:L,os:z,paths:b,util:S,format:l,bytes:d,shuffle:p,htmlescape:c,urlexpand:u}});const x=await Promise.all(_);{const e=x.filter(({result:e=null})=>e?.error);if(!h)console.warn(`${e.length} error${w(e.length)} found, ignoring...`),console.warn(S.inspect(e,{depth:1/0,maxStringLength:256}));else if(e.length)throw new Error(`${e.length} error${w(e.length)} found...`)}}console.debug(`metrics/compute/${e} > render`);let W=await x.render(P,{...M,s:w,style:R,fonts:I},{async:!0});if(i.optimize&&!t.raw){console.debug(`metrics/compute/${e} > optimize`);const t=new v({full:!0,plugins:[{cleanupAttrs:!0},{inlineStyles:!1}]}),{data:r}=await t.optimize(W);W=r}return console.debug(`metrics/compute/${e} > success`),W}catch(e){if(Array.isArray(e.errors)&&"NOT_FOUND"===e.errors[0].type)throw new Error("user not found");throw e}}function l(e){for(const{u:t,v:r}of[{u:"b",v:1000000000},{u:"m",v:1000000},{u:"k",v:1000}])if(1<=e/r)return`${(e/r).toFixed(2).substr(0,4).replace(/[.]0*$/,"")}${t}`;return e}function d(e){for(const{u:t,v:r}of[{u:"E",v:1000000000000000000},{u:"P",v:1000000000000000},{u:"T",v:1000000000000},{u:"G",v:1000000000},{u:"M",v:1000000},{u:"k",v:1000}])if(1<=e/r)return`${(e/r).toFixed(2).substr(0,4).replace(/[.]0*$/,"")} ${t}B`;return`${e} byte${1":!0,'"':!0,"'":!0}){return e.replace(/&(?!(?:amp|lt|gt|quot|apos);)/g,t["&"]?"&":"&").replace(//g,t[">"]?">":">").replace(/"/g,t["\""]?""":"\"").replace(/'/g,t["'"]?"'":"'")}async function u(e){try{return(await C.get(e)).request.res.responseUrl}catch{return e}}async function m(e,t){return await new Promise((r,n)=>{console.debug(`metrics/command > ${e}`);const a=P.exec(e,t);let[o,i]=["",""];a.stdout.on("data",e=>o+=e),a.stderr.on("data",e=>i+=e),a.on("close",t=>(console.debug(`metrics/command > ${e} > exited with code ${t}`),0===t?r(o):n(i)))})}function g({data:e,conf:t,q:r}){const n=e=>"object"==typeof e?new Proxy(e,{get(e,t){return t===Symbol.toPrimitive?()=>"##":t===Symbol.iterator?Reflect.get(e,t):/^plugins$/.test(t)?Reflect.get(e,t):/^error/.test(t)?void 0:n(t in e?Reflect.get(e,t):{})}}):e,a=Object.entries(t.settings.plugins).filter(([e,t])=>t.enabled).map(([e])=>e).filter(e=>e in r&&r[e]);Object.assign(e,{s(e,t){return"y"===t?"ies":"s"},meta:{version:t.package.version,author:t.package.author,placeholder:!0},user:n({name:`############`,websiteUrl:`########################`,isHireable:!1}),computed:n({avatar:"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mOcOnfpfwAGfgLYttYINwAAAABJRU5ErkJggg==",registration:"## years ago",cakeday:!1,calendar:Array(14).fill({color:"#ebedf0"}),licenses:{favorite:`########`},token:{scopes:[]}}),plugins:Object.fromEntries(a.map(e=>[e,n({posts:{source:"########",list:Array("posts.limit"in r?_Mathmax(+r["posts.limit"]||0,0):2).fill({title:"###### ###### ####### ######",date:"####"})},music:{provider:"########",tracks:Array("music.limit"in r?_Mathmax(+r["music.limit"]||0,0):4).fill({name:"##########",artist:"######",artwork:"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mOcOnfpfwAGfgLYttYINwAAAABJRU5ErkJggg=="})},pagespeed:{detailed:!!r["pagespeed.detailed"],scores:["Performance","Accessibility","Best Practices","SEO"].map(e=>({title:e,score:NaN}))},followup:{issues:{count:0},pr:{count:0}},habits:{facts:!!(r["habits.facts"]??1),charts:!!r["habits.charts"],indents:{style:`########`},commits:{day:"####"},linguist:{ordered:[]}},languages:{favorites:Array(7).fill(null).map((e,t)=>({x:t,name:"######",color:"#ebedf0",value:1/(t+1)}))},topics:{list:[...Array("topics.limit"in r?_Mathmax(+r["topics.limit"]||0,0):12).fill(null).map(()=>({name:"######",description:"",icon:null})),{name:`And ## more...`,description:"",icon:null}]},projects:{list:[...Array("projects.limit"in r?_Mathmax(+r["projects.limit"]||0,0):4).fill(null).map(()=>({name:"########",updated:"########",progress:{enabled:!0,todo:"##",doing:"##",done:"##",total:"##"}}))]},tweets:{profile:{username:"########",verified:!1},list:[...Array("tweets.limit"in r?_Mathmax(+r["tweets.limit"]||0,0):2).fill(null).map(()=>({text:"###### ###### ####### ######".repeat(4),created_at:Date.now()}))]}}[e]??{})]))})}r.r(t);var h={};r.r(h),r.d(h,{default:()=>n});var f={};r.r(f),r.d(f,{default:()=>i});var y=r(35747),b=r(85622),S=r(31669),x=r(58509),v=r(20485),k=r(67192),C=r(2390);const _={apple:{name:"Apple Music",embed:/^https:..embed.music.apple.com.\w+.playlist/},spotify:{name:"Spotify",embed:/^https:..open.spotify.com.embed.playlist/}},w={playlist:"Suggested tracks",recent:"Recently played"},T={followup:async function({computed:e,q:t},{enabled:r=!1}={}){try{if(!r||!t.followup)return null;const n={issues:{get count(){return this.open+this.closed},get open(){return e.repositories.issues_open},get closed(){return e.repositories.issues_closed}},pr:{get count(){return this.open+this.merged},get open(){return e.repositories.pr_open},get merged(){return e.repositories.pr_merged}}};return n}catch(e){throw{error:{message:"An error occured",instance:e}}}},gists:async function({login:e,graphql:t,q:r},{enabled:n=!1}={}){try{if(!n||!r.gists)return null;console.debug(`metrics/compute/${e}/plugins > gists > querying api`);const{user:{gists:a}}=await t(` query Gists { user(login: "${e}") { gists(last: 100) { diff --git a/src/plugins/music/index.mjs b/src/plugins/music/index.mjs index a8d4c7f4..6700a3a2 100644 --- a/src/plugins/music/index.mjs +++ b/src/plugins/music/index.mjs @@ -148,7 +148,7 @@ if (error.isAxiosError) { const status = error.response?.status const description = error.response.data?.error_description ?? null - message = `API returned ${status}${description ? ` (${description})` : ""}` + const message = `API returned ${status}${description ? ` (${description})` : ""}` error = error.response?.data ?? null throw {error:{message, instance:error}, ...raw} }