@stats-forge/github-stats-forge-core 0.1.0 → 0.2.0

package/src/fetchers/stats.ts

@@ -2,27 +2,31 @@ import { calculateRank } from '../calculateRank.ts';
 import type { CardConfig } from '../common/config.ts';
 import { GITHUB_USERNAME_PATTERN } from '../common/constants.ts';
 import type { GitHubDateRange } from '../common/date.ts';
-import { getGitHubYearRange, toGitHubDateTime } from '../common/date.ts';
+import {
+  getWidestRange,
+  toContributionRanges,
+  toGitHubDateTime,
+  toRange,
+  toYearRanges,
+} from '../common/date.ts';
 import { CardError, USER_NOT_FOUND } from '../common/error.ts';
 import { createGraphQLFetcher, httpRequest } from '../common/http.ts';
 import type { FetcherContext, GraphQLResponse } from '../common/http.ts';
 import { logger } from '../common/log.ts';
-import { buildSearchFilter, chunkArray, parseOwnerAffiliations } from '../common/ops.ts';
-import { wrapTextMultiline } from '../common/render.ts';
+import { buildSearchFilter, parseOwnerAffiliations } from '../common/ops.ts';
 import { retryer } from '../common/retryer.ts';
 import type { FetcherResponse } from '../common/retryer.ts';
 import { buildContributionsDocument } from '../graphql/contributionsDocument.ts';
 import { UserInfoDocument, UserReposDocument } from '../graphql/generated/stats.ts';
 import type {
+  RangeContributionsFragment,
   RepoNodeFragment,
   UserInfoQuery,
   UserInfoQueryVariables,
 } from '../graphql/generated/stats.ts';
-import {
-  MAX_REPOSITORIES_LIMIT,
-  buildReposContributedToDocument,
-} from '../graphql/reposContributedToDocument.ts';
 
+import { fetchReposContributedTo } from './contributed-to.ts';
+import { graphqlError } from './graphql-error.ts';
 import type { RepoUserStats, StatsData } from './types.ts';
 
 /** The subset of the stats response `statsFetcher` returns and threads on. */
@@ -46,7 +50,7 @@ const statsFetcher = async (
     includeMergedPullRequests,
     includeDiscussions,
     includeDiscussionsAnswers,
-    startTime,
+    commitsRange,
     ownerAffiliations,
     includeUserRepositories,
   }: {
@@ -54,7 +58,8 @@ const statsFetcher = async (
     includeMergedPullRequests: boolean;
     includeDiscussions: boolean;
     includeDiscussionsAnswers: boolean;
-    startTime: string | undefined;
+    /** The range the commit count covers; the last year, as GitHub reckons it, when absent. */
+    commitsRange: GitHubDateRange | undefined;
     ownerAffiliations: UserInfoQueryVariables['ownerAffiliations'];
     includeUserRepositories: boolean;
   },
@@ -69,7 +74,9 @@ const statsFetcher = async (
       includeMergedPullRequests,
       includeDiscussions,
       includeDiscussionsAnswers,
-      startTime,
+      // both ends together: an open `to` would run the range into the next 1st of January
+      startTime: commitsRange && toGitHubDateTime(commitsRange.from),
+      endTime: commitsRange && toGitHubDateTime(commitsRange.to),
       ownerAffiliations,
       includeUserRepositories,
     },
@@ -123,6 +130,16 @@ const statsFetcher = async (
   return stats;
 };
 
+/** One REST search: which index, the qualifiers scoping it, and the ones naming what to count. */
+interface SearchVariables {
+  /** `commits` or `issues`, the latter covering pull requests too. */
+  type: string;
+  /** Qualifiers appended after the scope, already `+`-joined. */
+  filter: string;
+  repo: Array<string>;
+  owner: Array<string>;
+}
+
 /**
  * Fetch total items count using the REST search API.
  *
@@ -131,15 +148,11 @@ const statsFetcher = async (
  * @returns The search response, carrying `total_count`.
  */
 const fetchTotalItems = (
-  variables: Record<string, unknown>,
+  { type, filter, repo, owner }: SearchVariables,
   token: string,
   { fetch }: FetcherContext,
-): Promise<FetcherResponse<{ total_count?: number }>> => {
-  const type = String(variables['type']);
-  const filter = String(variables['filter']);
-  const repo = variables['repo'] as Array<string> | string;
-  const owner = variables['owner'] as Array<string> | string;
-  return httpRequest(
+): Promise<FetcherResponse<{ total_count?: number }>> =>
+  httpRequest(
     fetch,
     `https://api.github.com/search/${type}?per_page=1&q=${buildSearchFilter(repo, owner).replaceAll(
       ' ',
@@ -154,7 +167,6 @@ const fetchTotalItems = (
       },
     },
   );
-};
 
 /**
  * Fetch a total count for a given username via the REST search API.
@@ -166,19 +178,7 @@ const fetchTotalItems = (
  * @returns Total count.
  */
 const totalItemsFetcher = async (
-  {
-    username,
-    repo,
-    owner,
-    type,
-    filter,
-  }: {
-    username: string;
-    repo: Array<string>;
-    owner: Array<string>;
-    type: string;
-    filter: string;
-  },
+  { username, ...search }: SearchVariables & { username: string },
   config: CardConfig,
 ): Promise<number> => {
   if (!GITHUB_USERNAME_PATTERN.test(username)) {
@@ -191,11 +191,7 @@ const totalItemsFetcher = async (
 
   let res: FetcherResponse<{ total_count?: number }>;
   try {
-    res = await retryer<{ total_count?: number }>(
-      fetchTotalItems,
-      { login: username, repo, owner, type, filter },
-      config,
-    );
+    res = await retryer(fetchTotalItems, search, config);
   } catch (error) {
     logger.log(error);
     throw error;
@@ -211,6 +207,38 @@ const totalItemsFetcher = async (
   return totalCount;
 };
 
+/** The flags that ask for a per-repository count, as the query names them. */
+interface RepoUserStatsFlags {
+  include_prs_authored?: boolean | undefined;
+  include_prs_commented?: boolean | undefined;
+  include_prs_reviewed?: boolean | undefined;
+  include_issues_authored?: boolean | undefined;
+  include_issues_commented?: boolean | undefined;
+}
+
+/** Each count the REST search API answers: the flag asking for it, and the qualifiers that find it. */
+const REPO_USER_SEARCHES: ReadonlyArray<
+  [flag: keyof RepoUserStatsFlags, stat: keyof RepoUserStats, filter: (username: string) => string]
+> = [
+  ['include_prs_authored', 'totalPRsAuthored', (username) => `author:${username}+type:pr`],
+  [
+    'include_prs_commented',
+    'totalPRsCommented',
+    (username) => `commenter:${username}+-author:${username}+type:pr`,
+  ],
+  [
+    'include_prs_reviewed',
+    'totalPRsReviewed',
+    (username) => `reviewed-by:${username}+-author:${username}+type:pr`,
+  ],
+  ['include_issues_authored', 'totalIssuesAuthored', (username) => `author:${username}+type:issue`],
+  [
+    'include_issues_commented',
+    'totalIssuesCommented',
+    (username) => `commenter:${username}+-author:${username}+type:issue`,
+  ],
+];
+
 /**
  * Fetch the per-repository counts the REST search API answers, one request each.
  *
@@ -221,122 +249,46 @@ const fetchRepoUserStats = async (
     username,
     repo = [],
     owner = [],
-    include_prs_authored = false,
-    include_prs_commented = false,
-    include_prs_reviewed = false,
-    include_issues_authored = false,
-    include_issues_commented = false,
-  }: {
+    ...flags
+  }: RepoUserStatsFlags & {
     username: string;
     repo?: Array<string>;
     owner?: Array<string>;
-    include_prs_authored?: boolean | undefined;
-    include_prs_commented?: boolean | undefined;
-    include_prs_reviewed?: boolean | undefined;
-    include_issues_authored?: boolean | undefined;
-    include_issues_commented?: boolean | undefined;
   },
   config: CardConfig,
 ): Promise<RepoUserStats> => {
   const stats: RepoUserStats = {};
-  if (include_prs_authored) {
-    stats.totalPRsAuthored = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_prs_commented) {
-    stats.totalPRsCommented = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `commenter:${username}+-author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_prs_reviewed) {
-    stats.totalPRsReviewed = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `reviewed-by:${username}+-author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_issues_authored) {
-    stats.totalIssuesAuthored = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `author:${username}+type:issue`,
-      },
-      config,
-    );
-  }
-  if (include_issues_commented) {
-    stats.totalIssuesCommented = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `commenter:${username}+-author:${username}+type:issue`,
-      },
-      config,
-    );
+  for (const [flag, stat, filter] of REPO_USER_SEARCHES) {
+    if (flags[flag]) {
+      stats[stat] = await totalItemsFetcher(
+        { username, repo, owner, type: 'issues', filter: filter(username) },
+        config,
+      );
+    }
   }
   return stats;
 };
 
 /**
- * Turn a GraphQL `errors` payload into the error to throw.
- */
-const graphqlError = (
-  errors: NonNullable<GraphQLResponse<unknown>['data']['errors']>,
-  statusText: string,
-  fallback: string,
-): CardError => {
-  logger.error(errors);
-  const message = errors[0]?.message;
-  return message
-    ? new CardError(wrapTextMultiline(message, 525, 12)[0] ?? '', {
-        code: 'upstream',
-        secondaryMessage: statusText,
-      })
-    : new CardError(fallback, { code: 'upstream' });
-};
-
-/**
- * Fetch all-time contributions by building a single GraphQL query
- * for all the given years.
+ * Sum one figure over a set of ranges, fetched as aliased fields of a single query.
  *
  * Whether private contributions are included depends on the user's profile settings:
  * https://docs.github.com/en/account-and-profile/how-tos/contribution-settings/manage-visibility-settings-for-private-contributions-and-achievements#changing-the-visibility-of-your-private-contributions
+ *
+ * @returns The total over every range, and 0 when there are none.
  */
-const fetchTotalContributions = async (
+const sumOverRanges = async (
   username: string,
-  years: Array<number>,
+  ranges: Array<GitHubDateRange>,
+  /** What one range contributes to the total. */
+  pick: (block: RangeContributionsFragment) => number,
   config: CardConfig,
 ): Promise<number> => {
-  if (years.length === 0) {
+  if (ranges.length === 0) {
     return 0;
   }
 
-  const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(years), 'bearer');
+  const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(ranges), 'bearer');
 
   const contribRes = await retryer(contributionsFetcher, { login: username }, config);
 
@@ -354,126 +306,12 @@ const fetchTotalContributions = async (
   }
 
   let total = 0;
-  for (const year of years) {
-    const yearBlock = user[`year_${year}`];
-    if (yearBlock?.contributionCalendar.totalContributions) {
-      total += yearBlock.contributionCalendar.totalContributions;
-    }
+  for (const block of Object.values(user)) {
+    total += pick(block);
   }
   return total;
 };
 
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-
-/**
- * Ranges per request.
- * Each costs roughly `4 * MAX_REPOSITORIES_LIMIT` nodes,
- * so an unchunked round of a heavily split account would breach GitHub's 500k node ceiling
- * and lose the ranges that had already resolved along with it.
- */
-const MAX_RANGES_PER_REQUEST = 100;
-
-const REPOS_CONTRIBUTED_TO_ERROR =
-  'Something went wrong while trying to retrieve the repository contributions data using the GraphQL API.';
-
-/**
- * Count the repositories a user contributed to across every contribution year.
- *
- * `repositoriesContributedTo` spans at most one year,
- * so every year is fetched as an aliased `contributionsCollection(from, to)` in one request and the repos de-duplicated.
- * A range returning `MAX_REPOSITORIES_LIMIT` results may have more,
- * so it is halved and requeried in the next round.
- *
- * Whether private contributions are included depends on the used PAT.
- *
- * @returns Count of repositories.
- */
-const fetchAllTimeReposContributedTo = async (
-  /** `nameWithOwner` uses GitHub's casing, which the query-string username need not match */
-  canonicalUsername: string,
-  years: Array<number>,
-  includeOwnRepos: boolean,
-  config: CardConfig,
-): Promise<number> => {
-  const repos = new Set<string>();
-  let pending = years.map((year) => getGitHubYearRange(year));
-
-  while (pending.length > 0) {
-    const nextPending: Array<GitHubDateRange> = [];
-
-    for (const chunk of chunkArray(pending, MAX_RANGES_PER_REQUEST)) {
-      const chunkFetcher = createGraphQLFetcher(
-        buildReposContributedToDocument(chunk, includeOwnRepos),
-        'bearer',
-      );
-      const res = await retryer(
-        chunkFetcher,
-        { login: canonicalUsername, maxRepositories: MAX_REPOSITORIES_LIMIT },
-        config,
-      );
-      if (res.data.errors) {
-        throw graphqlError(res.data.errors, res.statusText, REPOS_CONTRIBUTED_TO_ERROR);
-      }
-      const { user } = res.data.data;
-      if (!user) {
-        throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, { code: 'upstream' });
-      }
-
-      for (const [index, range] of chunk.entries()) {
-        const rangeResponse = user[`range_${index}`];
-        if (!rangeResponse) {
-          throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, {
-            code: 'upstream',
-          });
-        }
-
-        const lists = [
-          rangeResponse.commitContributionsByRepository,
-          rangeResponse.issueContributionsByRepository,
-          rangeResponse.pullRequestContributionsByRepository,
-          (rangeResponse.repositoryContributions?.nodes ?? []).filter((node) => node !== null),
-        ];
-        const isSaturated = lists.some((list) => list.length >= MAX_REPOSITORIES_LIMIT);
-
-        const rangeDays = Math.round((range.to.getTime() - range.from.getTime()) / MS_PER_DAY);
-        // a range of 1 day or less can't be split any further
-        if (isSaturated && rangeDays >= 2) {
-          // every `from` sits on UTC midnight, so the split lands on a day boundary too
-          const mid = new Date(range.from.getTime() + Math.floor(rangeDays / 2) * MS_PER_DAY);
-          // GitHub only reads the date portion,
-          // so the first half ends 1 second before `mid` to keep the halves from sharing a day
-          nextPending.push(
-            { from: range.from, to: new Date(mid.getTime() - 1000) },
-            { from: mid, to: range.to },
-          );
-          continue;
-        }
-        if (isSaturated) {
-          logger.log(
-            `Range ${range.from.toISOString()} - ${range.to.toISOString()} is saturated but cannot be split further.`,
-          );
-        }
-
-        for (const { repository } of lists.flat()) {
-          const name = repository.nameWithOwner;
-          if (includeOwnRepos || !name.startsWith(`${canonicalUsername}/`)) {
-            repos.add(name);
-          }
-        }
-      }
-    }
-
-    // each saturated range pushes both of its halves
-    const saturatedCount = nextPending.length / 2;
-    if (saturatedCount > 0) {
-      logger.log(`found ${saturatedCount} saturated ranges, splitting and retrying...`);
-    }
-    pending = nextPending;
-  }
-
-  return repos.size;
-};
-
 /**
  * Fetch stats for a given username.
  *
@@ -487,7 +325,8 @@ const fetchStats = async (
     include_merged_pull_requests = false,
     include_discussions = false,
     include_discussions_answers = false,
-    commits_year,
+    from,
+    to,
     repo = [],
     owner = [],
     include_prs_authored = false,
@@ -506,7 +345,10 @@ const fetchStats = async (
     include_merged_pull_requests?: boolean;
     include_discussions?: boolean;
     include_discussions_answers?: boolean;
-    commits_year?: number | undefined;
+    /** Start of the range the commit count covers; GitHub's own last year when neither end is given. */
+    from?: Date | undefined;
+    /** End of that range. */
+    to?: Date | undefined;
     repo?: Array<string>;
     owner?: Array<string>;
     include_prs_authored?: boolean;
@@ -532,6 +374,7 @@ const fetchStats = async (
     mergedPRsPercentage: 0,
     totalReviews: 0,
     totalCommits: 0,
+    commitsRange: undefined,
     totalIssues: 0,
     totalStars: 0,
     totalDiscussionsStarted: 0,
@@ -548,41 +391,30 @@ const fetchStats = async (
   };
   const affiliations = parseOwnerAffiliations(ownerAffiliations);
 
+  // neither end given leaves GitHub's trailing year in place, which `userInfo` already carries
+  const commitsRange = from === undefined && to === undefined ? undefined : toRange(from, to);
+  const commitsYearRanges = commitsRange ? toYearRanges(commitsRange) : [];
+  // one calendar year is a range `userInfo` can ask for itself; anything else is summed separately
+  const inlineRange = commitsYearRanges.length === 1 ? commitsYearRanges[0] : undefined;
+
   const res = await statsFetcher(
     {
       username,
       includeMergedPullRequests: include_merged_pull_requests,
       includeDiscussions: include_discussions,
       includeDiscussionsAnswers: include_discussions_answers,
-      startTime:
-        commits_year === undefined
-          ? undefined
-          : toGitHubDateTime(getGitHubYearRange(commits_year).from),
+      commitsRange: inlineRange,
       ownerAffiliations: affiliations,
       includeUserRepositories: contribs_include_own_repos,
     },
     config,
   );
 
-  // Catch GraphQL errors.
   if (res.data.errors) {
-    logger.error(res.data.errors);
-    const [firstError] = res.data.errors;
-    if (firstError?.type === 'NOT_FOUND') {
-      throw new CardError(firstError.message || 'Could not fetch user.', {
-        code: 'not_found',
-        secondaryMessage: USER_NOT_FOUND,
-      });
-    }
-    if (firstError?.message) {
-      throw new CardError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? '', {
-        code: 'upstream',
-        secondaryMessage: res.statusText,
-      });
-    }
-    throw new CardError(
+    throw graphqlError(
+      res.data.errors,
+      res.statusText,
       'Something went wrong while trying to retrieve the stats data using the GraphQL API.',
-      { code: 'upstream' },
     );
   }
 
@@ -609,7 +441,17 @@ const fetchStats = async (
       config,
     );
   } else {
-    stats.totalCommits = user.commits.totalCommitContributions;
+    stats.commitsRange = commitsRange;
+    // an inverted range sums no years, which is no commits rather than GitHub's default year
+    stats.totalCommits =
+      commitsRange && !inlineRange
+        ? await sumOverRanges(
+            username,
+            commitsYearRanges,
+            (block) => block.totalCommitContributions,
+            config,
+          )
+        : user.commits.totalCommitContributions;
   }
   const repoUserStats = await fetchRepoUserStats(
     {
@@ -642,21 +484,28 @@ const fetchStats = async (
   }
   stats.contributedTo = user.repositoriesContributedTo.totalCount;
 
+  const contributionRanges = toContributionRanges(
+    user.contributionsCollection.contributionYears,
+    getWidestRange(),
+  );
+
   if (include_contributions) {
-    stats.totalContributions = await fetchTotalContributions(
+    stats.totalContributions = await sumOverRanges(
       username,
-      user.contributionsCollection.contributionYears,
+      contributionRanges,
+      (block) => block.contributionCalendar.totalContributions,
       config,
     );
   }
 
   if (include_all_time_contribs) {
-    stats.allTimeContributedTo = await fetchAllTimeReposContributedTo(
+    const reposContributedTo = await fetchReposContributedTo(
       user.login,
-      user.contributionsCollection.contributionYears,
+      contributionRanges,
       contribs_include_own_repos,
       config,
     );
+    stats.allTimeContributedTo = reposContributedTo.size;
   }
 
   // Retrieve stars while filtering out repositories to be hidden.

package/src/fetchers/top-languages.ts

@@ -1,9 +1,7 @@
 import type { CardConfig } from '../common/config.ts';
-import { CardError, USER_NOT_FOUND } from '../common/error.ts';
+import { CardError } from '../common/error.ts';
 import { createGraphQLFetcher } from '../common/http.ts';
-import { logger } from '../common/log.ts';
 import { parseOwnerAffiliations } from '../common/ops.ts';
-import { wrapTextMultiline } from '../common/render.ts';
 import { retryer } from '../common/retryer.ts';
 import { TopLanguagesDocument } from '../graphql/generated/top-languages.ts';
 import type {
@@ -11,6 +9,7 @@ import type {
   TopLanguagesRepositoryFragment,
 } from '../graphql/generated/top-languages.ts';
 
+import { graphqlError } from './graphql-error.ts';
 import type { Lang, TopLangData } from './types.ts';
 
 const fetcher = createGraphQLFetcher(TopLanguagesDocument, 'token');
@@ -51,23 +50,10 @@ const fetchTopLanguages = async (
   );
 
   if (res.data.errors) {
-    logger.error(res.data.errors);
-    const [firstError] = res.data.errors;
-    if (firstError?.type === 'NOT_FOUND') {
-      throw new CardError(firstError.message || 'Could not fetch user.', {
-        code: 'not_found',
-        secondaryMessage: USER_NOT_FOUND,
-      });
-    }
-    if (firstError?.message) {
-      throw new CardError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? '', {
-        code: 'upstream',
-        secondaryMessage: res.statusText,
-      });
-    }
-    throw new CardError(
+    throw graphqlError(
+      res.data.errors,
+      res.statusText,
       'Something went wrong while trying to retrieve the language data using the GraphQL API.',
-      { code: 'upstream' },
     );
   }
 

package/src/fetchers/types.ts

@@ -1,3 +1,4 @@
+import type { GitHubDateRange } from '../common/date.ts';
 import type { RepoInfoFragment } from '../graphql/generated/repo.ts';
 
 export interface GistData {
@@ -39,6 +40,8 @@ export interface StatsData {
   mergedPRsPercentage: number;
   totalReviews: number;
   totalCommits: number;
+  /** The range `totalCommits` covers; `undefined` when it is GitHub's own last year, or all time. */
+  commitsRange: GitHubDateRange | undefined;
   totalIssues: number;
   totalStars: number;
   totalDiscussionsStarted: number;
@@ -54,6 +57,29 @@ export interface StatsData {
   rank: { level: string; percentile: number };
 }
 
+/** One repository a user contributed to, as the card ranks it. */
+export interface ContributedRepo {
+  nameWithOwner: string;
+  /**
+   * Commit-days plus issues and pull requests opened, summed over every year.
+   * Not a commit count: GitHub groups commit contributions by day, not by commit.
+   */
+  contributions: number;
+  /** Every year the user contributed to it, ascending. */
+  years: Array<number>;
+}
+
+export interface ContributedToData {
+  /** GitHub's own casing of the login, which the query param need not match. */
+  login: string;
+  /** The ranked slice, most contributions first. */
+  repos: Array<ContributedRepo>;
+  /** Every repository the walk found, which `repos` is a slice of. */
+  totalRepos: number;
+  /** The account's contribution years, ascending — the range the year marks cover. */
+  years: Array<number>;
+}
+
 export interface Lang {
   name: string;
   // GitHub's GraphQL `Language.color` is nullable — the card falls back to a default.

package/src/graphql/contributionsCollection.ts

@@ -0,0 +1,18 @@
+import type { GitHubDateRange } from '../common/date.ts';
+import { toGitHubDateTime } from '../common/date.ts';
+
+/** Naming `to` is not optional: GitHub defaults an omitted one to a year after `from`. */
+const contributionsCollectionOf = ({ from, to }: GitHubDateRange): string =>
+  `contributionsCollection(from: "${toGitHubDateTime(from)}", to: "${toGitHubDateTime(to)}")`;
+
+/**
+ * One `contributionsCollection` field per range, aliased by position.
+ *
+ * @returns The fields, for a query that selects `fragment`.
+ */
+const aliasedRanges = (ranges: Array<GitHubDateRange>, fragment: string): string =>
+  ranges
+    .map((range, index) => `range_${index}: ${contributionsCollectionOf(range)} { ...${fragment} }`)
+    .join('\n');
+
+export { aliasedRanges };