/**
 * Instantiate the GitHub API Client
 */
const octokit = new Octokit({
  auth: token || process.env.GITHUB_TOKEN,
});

/**
 * Fetch the GitHub Repository
 */
const { data: repository } = await octokit.repos.get({
  owner,
  repo,
});

/**
 * Fetch the GitHub Repository Language Data
 */
const { data: languages } = await octokit.repos.listLanguages({
  owner,
  repo,
});

/**
 * Fetch the GitHub language colors source-of-truth
 */
const { data: linguistInitial } = await octokit.repos.getContents({
  owner: 'github',
  repo: 'linguist',
  path: 'lib/linguist/languages.yml',
  mediaType: {
    format: 'base64',
  },
});

/**
 * Create a Buffer for the linguistInitial content
 * Parse the YML file so we can extract the colors we need from it later
 */
const linguistContent = linguistInitial as { content: string };
const linguistBuffer = Buffer.from(linguistContent.content as string, 'base64');
const linguist = YAML.parse(linguistBuffer.toString('utf-8'));

/**
 * Initialize the random function with a custom seed so it's consistent
 * This accepts the query param and will otherwise fallback on the unique repository ID
 */
const random = seedrandom(seed || repository.id.toString());

I conditionally assign a template object some values depending on whether or not the user has requested a darkmode image be generated.

```js
/**
 * Remote Template Images
 */
const template = {
  base:
    displayParameter === 'light'
      ? await Jimp.read(fromAWS('/meta/base.png'))
      : await Jimp.read(fromAWS('/meta/base_dark.png')),
  dot:
    dotTypeParameter === 'circle'
      ? await Jimp.read(fromAWS('/meta/dot_black.png'))
      : await Jimp.read(fromAWS('/meta/square_black.png')),

  circle: await Jimp.read(fromAWS('/meta/dot_black.png')),
  square: await Jimp.read(fromAWS('/meta/square_black.png')),

  githubLogo:
    displayParameter === 'light'
      ? await Jimp.read(fromAWS('/meta/github_black.png'))
      : await Jimp.read(fromAWS('/meta/github_white.png')),
};

/**
 * Font family used for writing
 */
const font =
  displayParameter === 'light'
    ? await Jimp.loadFont(
        'https://unpkg.com/@jimp/plugin-print@0.10.3/fonts/open-sans/open-sans-64-black/open-sans-64-black.fnt'
      )
    : await Jimp.loadFont(
        'https://unpkg.com/@jimp/plugin-print@0.10.3/fonts/open-sans/open-sans-64-white/open-sans-64-white.fnt'
      );

/**
 * Required Image Dimensions
 */
const width = 1280;
const height = 640;

/**
 * Total Count of Squares (Dimensions)
 */
const horizontal = width / 20;
const vertical = height / 20;

/**
 * Spacing
 */
const spacing = 40;

/**
 * Base Image
 */
const dots = [...new Array(horizontal * vertical)];
const image = template.base.clone().resize(width, height);

/**
 * Protected Area Coordinates
 */
const protectedArea = {
  x: { min: 185, max: 1085 },
  y: { min: 185, max: 445 },
};

const getXPosition = (index: number): number => {
  return 5 + (index % horizontal) * 20;
};

const getYPosition = (index: number): number => {
  return 5 + 20 * Math.floor(index / horizontal);
};

const isProtectedArea = (index: number): boolean => {
  if (
    getXPosition(index) > protectedArea.x.min &&
    getXPosition(index) < protectedArea.x.max &&
    getYPosition(index) > protectedArea.y.min &&
    getYPosition(index) < protectedArea.y.max
  ) {
    return true;
  }

  return false;
};

const isInnerRing = (index: number, rows = 1): boolean => {
  if (
    getXPosition(index) > protectedArea.x.min - rows * 20 &&
    getXPosition(index) < protectedArea.x.max + rows * 20 &&
    getYPosition(index) > protectedArea.y.min - rows * 20 &&
    getYPosition(index) < protectedArea.y.max + rows * 20
  ) {
    return true;
  }

  return false;
};

const generateOpacity = (index: number, opacityStart: number): number => {
  const opacityBoost = 0.45;
  const opacity = opacityStart + opacityBoost > 1 ? 1 : opacityStart + opacityBoost;

  if (isInnerRing(index, 1)) return 0.4 * opacity;
  if (isInnerRing(index, 2)) return 0.4 * opacity;
  if (isInnerRing(index, 3)) return 0.5 * opacity;
  if (isInnerRing(index, 4)) return 0.5 * opacity;
  if (isInnerRing(index, 5)) return 0.6 * opacity;

  return opacity;
};

/**
 * Reducer Function for applying the dynamic generation logic to each dot
 */
const dotReducer = (_: unknown, __: unknown, index: number): void => {...}
dots.reduce(dotReducer, dots[0]);

/**
 * If the index is within a protected area we already know to stop.
 * Nothing will be added in the protected region.
 */
if (isProtectedArea(index)) return;

/**
 * If we randomly generate a number between 1 and 100 and it's 80 or greater, let's just skip.
 * This reduces needlessly large amounts of squares from being added in a somewhat controlled way.
 * This basically gives us a percentage of reduction.
 */
const reduction = 80;
// const reduction = 0;
if (Math.floor(random() * 100) + 1 >= 100 - reduction) return;

/**
 * If we haven't returned already, we're ready to proceed.
 */
const dot = template.dot.clone();

/**
 * Randomly select the language key we want to use to fetch our color.
 * Provide preference to the language-byte-counter provided by GitHub.
 */
const colorLanguageKey = weightedRandom(Object.entries(languages), random) as string;

/**
 * If it exists, pluck the Hexidecimal code we need for the language key randomly picked
 */
let { color: hexColor } = linguist[colorLanguageKey] as { color: string | undefined };

/**
 * Fix the hex color to a sensible default if it's undefined
 */
if (hexColor === undefined) {
  hexColor = 'cccccc';
}

/**
 * Convert the Hexidecimal value to a Jimp compatible RGB
 */
let color = hexToRgb(hexColor);

/**
 * Fix the color to a sensible default if it's null
 */
if (color === null) {
  color = hexToRgb('cccccc') as RGB;
}

const weightedRandom = (items: [string, number][], randomizer: () => number = Math.random) => {
  /**
   * First, we loop the main dataset to count up the total weight. We're starting the counter at one because the upper boundary of Math.random() is exclusive.
   */
  let total = 1;
  for (let i = 0; i < items.length; ++i) {
    total += items[i][1];
  }

  /**
   * Total in hand, we can now pick a random value akin to our random index from before.
   */
  const threshold = Math.floor(randomizer() * total);

  /**
   * Now we just need to loop through the main data one more time
   * until we discover which value would live within this
   * particular threshold. We need to keep a running count of
   * weights as we go, so let's just reuse the "total" variable
   * since it was already declared.
   */
  total = 0;
  for (let i = 0; i < items.length; ++i) {
    /**
     * Add the weight to our running total.
     */
    total += items[i][1];

    /**
     * If this value falls within the threshold, we're done!
     */
    if (total >= threshold) {
      return items[i][0];
    }
  }
};

/**
 * Destructure the color and apply it to the square
 */
const { red, green, blue } = color;
dot.color([
  { apply: 'red', params: [red] },
  { apply: 'green', params: [green] },
  { apply: 'blue', params: [blue] },
]);

/**
 * Randomly generate (and validate) the opacity of our square.
 * The generateOpacity function adds the fade out effect towards to the center
 */
const opacity = generateOpacity(index, random());
dot.opacity(opacity);

/**
 * Our Square is now ready let's finally apply it to our image
 */
image.composite(dot, getXPosition(index), getYPosition(index));