It appears you have a well-structured Git repository with various files, including SVG icons and HTML documents. Here's a brief overview:

backend/node_modules/postcss-load-config/src/index.d.ts

@@ -0,0 +1,65 @@
+// based on @types/postcss-load-config@2.0.1
+// Type definitions for postcss-load-config 2.1
+import Processor from 'postcss/lib/processor'
+import { Plugin, ProcessOptions, Transformer } from 'postcss'
+import { Options as ConfigOptions } from 'lilconfig'
+
+declare function postcssrc(
+  ctx?: postcssrc.ConfigContext,
+  path?: string,
+  options?: ConfigOptions
+): Promise<postcssrc.Result>
+
+declare namespace postcssrc {
+  // In the ConfigContext, these three options can be instances of the
+  // appropriate class, or strings. If they are strings, postcss-load-config will
+  // require() them and pass the instances along.
+  export interface ProcessOptionsPreload {
+    parser?: string | ProcessOptions['parser']
+    stringifier?: string | ProcessOptions['stringifier']
+    syntax?: string | ProcessOptions['syntax']
+  }
+
+  // The remaining ProcessOptions, sans the three above.
+  export type RemainingProcessOptions = Pick<
+    ProcessOptions,
+    Exclude<keyof ProcessOptions, keyof ProcessOptionsPreload>
+  >
+
+  // Additional context options that postcss-load-config understands.
+  export interface Context {
+    cwd?: string
+    env?: string
+  }
+
+  // The full shape of the ConfigContext.
+  export type ConfigContext = Context &
+    ProcessOptionsPreload &
+    RemainingProcessOptions
+
+  // Result of postcssrc is a Promise containing the filename plus the options
+  // and plugins that are ready to pass on to postcss.
+  export type ResultPlugin = Plugin | Transformer | Processor
+
+  export interface Result {
+    file: string
+    options: ProcessOptions
+    plugins: ResultPlugin[]
+  }
+
+  export type ConfigPlugin = Transformer | Plugin | Processor
+
+  export interface Config {
+    parser?: string | ProcessOptions['parser'] | false
+    stringifier?: string | ProcessOptions['stringifier'] | false
+    syntax?: string | ProcessOptions['syntax'] | false
+    map?: string | false
+    from?: string
+    to?: string
+    plugins?: Array<ConfigPlugin | false> | Record<string, object | false>
+  }
+
+  export type ConfigFn = (ctx: ConfigContext) => Config | Promise<Config>
+}
+
+export = postcssrc

backend/node_modules/postcss-load-config/src/index.js

@@ -0,0 +1,164 @@
+// @ts-check
+const { resolve } = require('node:path')
+
+const config = require('lilconfig')
+const yaml = require('yaml')
+
+const loadOptions = require('./options.js')
+const loadPlugins = require('./plugins.js')
+const req = require('./req.js')
+
+const interopRequireDefault = obj =>
+  obj && obj.__esModule ? obj : { default: obj }
+
+/**
+ * Process the result from cosmiconfig
+ *
+ * @param  {Object} ctx Config Context
+ * @param  {Object} result Cosmiconfig result
+ *
+ * @return {Promise<Object>} PostCSS Config
+ */
+async function processResult(ctx, result) {
+  let file = result.filepath || ''
+  let projectConfig = interopRequireDefault(result.config).default || {}
+
+  if (typeof projectConfig === 'function') {
+    projectConfig = projectConfig(ctx)
+  } else {
+    projectConfig = Object.assign({}, projectConfig, ctx)
+  }
+
+  if (!projectConfig.plugins) {
+    projectConfig.plugins = []
+  }
+
+  let res = {
+    file,
+    options: await loadOptions(projectConfig, file),
+    plugins: await loadPlugins(projectConfig, file)
+  }
+  delete projectConfig.plugins
+  return res
+}
+
+/**
+ * Builds the Config Context
+ *
+ * @param  {Object} ctx Config Context
+ *
+ * @return {Object} Config Context
+ */
+function createContext(ctx) {
+  /**
+   * @type {Object}
+   *
+   * @prop {String} cwd=process.cwd() Config search start location
+   * @prop {String} env=process.env.NODE_ENV Config Enviroment, will be set to `development` by `postcss-load-config` if `process.env.NODE_ENV` is `undefined`
+   */
+  ctx = Object.assign(
+    {
+      cwd: process.cwd(),
+      env: process.env.NODE_ENV
+    },
+    ctx
+  )
+
+  if (!ctx.env) {
+    process.env.NODE_ENV = 'development'
+  }
+
+  return ctx
+}
+
+async function loader(filepath) {
+  return req(filepath)
+}
+
+/** @return {import('lilconfig').Options} */
+const withLoaders = (options = {}) => {
+  let moduleName = 'postcss'
+
+  return {
+    ...options,
+    loaders: {
+      ...options.loaders,
+      '.cjs': loader,
+      '.cts': loader,
+      '.js': loader,
+      '.mjs': loader,
+      '.mts': loader,
+      '.ts': loader,
+      '.yaml': (_, content) => yaml.parse(content),
+      '.yml': (_, content) => yaml.parse(content)
+    },
+    searchPlaces: [
+      ...(options.searchPlaces || []),
+      'package.json',
+      `.${moduleName}rc`,
+      `.${moduleName}rc.json`,
+      `.${moduleName}rc.yaml`,
+      `.${moduleName}rc.yml`,
+      `.${moduleName}rc.ts`,
+      `.${moduleName}rc.cts`,
+      `.${moduleName}rc.mts`,
+      `.${moduleName}rc.js`,
+      `.${moduleName}rc.cjs`,
+      `.${moduleName}rc.mjs`,
+      `${moduleName}.config.ts`,
+      `${moduleName}.config.cts`,
+      `${moduleName}.config.mts`,
+      `${moduleName}.config.js`,
+      `${moduleName}.config.cjs`,
+      `${moduleName}.config.mjs`
+    ]
+  }
+}
+
+/**
+ * Load Config
+ *
+ * @method rc
+ *
+ * @param  {Object} ctx Config Context
+ * @param  {String} path Config Path
+ * @param  {Object} options Config Options
+ *
+ * @return {Promise} config PostCSS Config
+ */
+function rc(ctx, path, options) {
+  /**
+   * @type {Object} The full Config Context
+   */
+  ctx = createContext(ctx)
+
+  /**
+   * @type {String} `process.cwd()`
+   */
+  path = path ? resolve(path) : process.cwd()
+
+  return config
+    .lilconfig('postcss', withLoaders(options))
+    .search(path)
+    .then(result => {
+      if (!result) {
+        throw new Error(`No PostCSS Config found in: ${path}`)
+      }
+      return processResult(ctx, result)
+    })
+}
+
+/**
+ * Autoload Config for PostCSS
+ *
+ * @author Michael Ciniawsky @michael-ciniawsky <michael.ciniawsky@gmail.com>
+ * @license MIT
+ *
+ * @module postcss-load-config
+ * @version 2.1.0
+ *
+ * @requires comsiconfig
+ * @requires ./options
+ * @requires ./plugins
+ */
+module.exports = rc

backend/node_modules/postcss-load-config/src/options.js

@@ -0,0 +1,48 @@
+// @ts-check
+const req = require('./req.js')
+
+/**
+ * Load Options
+ *
+ * @private
+ * @method options
+ *
+ * @param  {Object} config  PostCSS Config
+ *
+ * @return {Promise<Object>} options PostCSS Options
+ */
+async function options(config, file) {
+  if (config.parser && typeof config.parser === 'string') {
+    try {
+      config.parser = await req(config.parser, file)
+    } catch (err) {
+      throw new Error(
+        `Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`
+      )
+    }
+  }
+
+  if (config.syntax && typeof config.syntax === 'string') {
+    try {
+      config.syntax = await req(config.syntax, file)
+    } catch (err) {
+      throw new Error(
+        `Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`
+      )
+    }
+  }
+
+  if (config.stringifier && typeof config.stringifier === 'string') {
+    try {
+      config.stringifier = await req(config.stringifier, file)
+    } catch (err) {
+      throw new Error(
+        `Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`
+      )
+    }
+  }
+
+  return config
+}
+
+module.exports = options

backend/node_modules/postcss-load-config/src/plugins.js

@@ -0,0 +1,90 @@
+// @ts-check
+const req = require('./req.js')
+
+/**
+ * Plugin Loader
+ *
+ * @private
+ * @method load
+ *
+ * @param  {String} plugin PostCSS Plugin Name
+ * @param  {Object} options PostCSS Plugin Options
+ *
+ * @return {Promise<Function>} PostCSS Plugin
+ */
+async function load(plugin, options, file) {
+  try {
+    if (
+      options === null ||
+      options === undefined ||
+      Object.keys(options).length === 0
+    ) {
+      return await req(plugin, file)
+    } else {
+      return (await req(plugin, file))(options)
+      /* c8 ignore next */
+    }
+  } catch (err) {
+    throw new Error(
+      `Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`
+    )
+  }
+}
+
+/**
+ * Load Plugins
+ *
+ * @private
+ * @method plugins
+ *
+ * @param {Object} config PostCSS Config Plugins
+ *
+ * @return {Promise<Array>} plugins PostCSS Plugins
+ */
+async function plugins(config, file) {
+  let list = []
+
+  if (Array.isArray(config.plugins)) {
+    list = config.plugins.filter(Boolean)
+  } else {
+    list = Object.entries(config.plugins)
+      .filter(([, options]) => {
+        return options !== false
+      })
+      .map(([plugin, options]) => {
+        return load(plugin, options, file)
+      })
+    list = await Promise.all(list)
+  }
+
+  if (list.length && list.length > 0) {
+    list.forEach((plugin, i) => {
+      if (plugin.default) {
+        plugin = plugin.default
+      }
+
+      if (plugin.postcss === true) {
+        plugin = plugin()
+      } else if (plugin.postcss) {
+        plugin = plugin.postcss
+      }
+
+      if (
+        // eslint-disable-next-line
+        !(
+          (typeof plugin === 'object' && Array.isArray(plugin.plugins)) ||
+          (typeof plugin === 'object' && plugin.postcssPlugin) ||
+          typeof plugin === 'function'
+        )
+      ) {
+        throw new TypeError(
+          `Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`
+        )
+      }
+    })
+  }
+
+  return list
+}
+
+module.exports = plugins

backend/node_modules/postcss-load-config/src/req.js

@@ -0,0 +1,59 @@
+// @ts-check
+const { createRequire } = require('node:module')
+const { pathToFileURL } = require('node:url')
+
+const TS_EXT_RE = /\.[mc]?ts$/
+
+let tsx
+
+let jiti
+
+let importError
+
+/**
+ * @param {string} name
+ * @param {string} rootFile
+ * @returns {Promise<any>}
+ */
+async function req(name, rootFile = __filename) {
+  let url = createRequire(rootFile).resolve(name)
+
+  try {
+    return (await import(`${pathToFileURL(url)}?t=${Date.now()}`)).default
+  } catch (err) {
+    if (!TS_EXT_RE.test(url)) {
+      /* c8 ignore start */
+      throw err
+    }
+  }
+
+  if (tsx === undefined) {
+    tsx = await import('tsx/cjs/api').catch(error => {
+      importError = error
+    })
+  }
+
+  if (tsx) {
+    let loaded = tsx.require(name, rootFile)
+    return loaded && '__esModule' in loaded ? loaded.default : loaded
+  }
+
+  if (jiti === undefined) {
+    jiti = await import('jiti').then(
+      m => m.default,
+      error => {
+        importError = importError ?? error
+      }
+    )
+  }
+
+  if (jiti) {
+    return jiti(rootFile, { interopDefault: true })(name)
+  }
+
+  throw new Error(
+    `'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed\nError: ${importError.message}`
+  )
+}
+
+module.exports = req