@moderneinc/design-system-logos 7.0.0-next.df34ef

package/README.md

@@ -0,0 +1,183 @@
+# @moderneinc/design-system-logos
+
+212 ecosystem logo marks for Moderne applications — one JS module per mark,
+each a percent-encoded `data:image/svg+xml` URI, reached through a manifest of
+per-slug dynamic imports so a consumer's bundler code-splits every mark into
+its own chunk.
+
+---
+
+## Install
+
+```sh
+npm install @moderneinc/design-system-logos
+```
+
+## Usage
+
+Three ways to reach a mark.
+
+**Static** — one mark, no runtime API. The bundler pulls in exactly this file.
+
+```js
+import kafka from '@moderneinc/design-system-logos/marks/kafka'
+// kafka: a `data:image/svg+xml` string — use it directly as an <img src>
+```
+
+**React** — `<Logo>` resolves light/dark from `[data-theme="dark"]` on the
+document root and swaps artwork when the attribute changes.
+
+```jsx
+import { Logo } from '@moderneinc/design-system-logos/react'
+
+<Logo slug="kafka" alt="Kafka" size="1.5rem" />
+```
+
+Pass `dark` to override the resolved theme. Note this does not server-render
+the mark: loading happens in an effect, so a server-rendered page emits the
+placeholder either way. What it avoids is the light-then-dark swap on the
+client's first effect.
+
+```jsx
+<Logo slug="kafka" alt="Kafka" dark={false} />
+```
+
+**Dynamic** — for code that does not know its slug until runtime.
+
+```js
+import { loadLogo, slugs, hasDark, isLogoSlug } from '@moderneinc/design-system-logos'
+
+const uri = await loadLogo('kafka', { dark: true }) // data URI string
+```
+
+- `slugs` — every light-mark slug, e.g. `'kafka'`
+- `hasDark(slug)` — whether a `.dark.svg` sibling exists
+- `isLogoSlug(slug)` — type guard narrowing `string` to `LogoSlug`
+
+### TypeScript
+
+Subpath types (`/react`, `/marks/*`) need `moduleResolution` set to `bundler`,
+`node16`, or `nodenext`. Under legacy `node10` only the root import resolves —
+verified against a real consumer.
+
+---
+
+## Maintainer docs
+
+Everything below documents `src/marks` and the tooling that keeps its 212
+marks visually coherent. It is not part of the package's public API —
+consumers of the API above can stop here.
+
+Counterpart to `tools/` in [moderneinc/public-assets], which does the same job
+for tenant branding. Same conventions, so a mark can move between the two.
+
+[moderneinc/public-assets]: https://github.com/moderneinc/public-assets
+
+## Conventions
+
+- **A square `viewBox`, framed to the keyline grid.** Each asset carries its own
+  margin; nothing downstream adds any. Assets without a `viewBox` cannot scale;
+  they paint at their authored size anchored top-left in any box that does not
+  match.
+- **No `width`/`height`.** Intrinsic dimensions fight the frame.
+- **True vector.** A base64 PNG in an SVG wrapper cannot scale or be recolored,
+  and costs 10–100× the bytes.
+- **Bare marks on transparency.** No backing rect that is not part of the logo.
+- **`<slug>.dark.svg` for marks that do not read on a dark surface**, sharing
+  its light sibling's `viewBox` exactly. Prefer the vendor's own reverse
+  artwork; otherwise lift the near-black ink and leave brand accents alone.
+  A mark that already reads on dark gets no dark variant.
+
+## The keyline grid
+
+These are logos, but they are used as icons — a 20px slot in the builder tree,
+a 48px tile on a card — and a set of logos dropped into equal boxes does not
+read as a set. A solid square fills its box and shouts; a thin outline of the
+same size whispers; a 5:1 wordmark shrinks to a smear. The grid is what makes
+them look like siblings.
+
+So each mark is centred in a square frame and sized to a keyline: **how much of
+that frame its long axis gets**. `keylineSpan` in `lib.mjs` sets it from two
+measurements, and nothing about it is per-asset or hand-tuned:
+
+- **Coverage** — the alpha-weighted share of the artwork's own bounding box
+  that is actually painted, from 0.13 (Micronaut's hairline) to 1.0 (a solid
+  npm block). Span falls as coverage rises, so ink drawn heavy and ink drawn
+  light land at the same weight. The falloff is deliberately gentle: a bounded
+  silhouette reads as its whole box, so normalizing on ink area outright throws
+  outline marks off the grid.
+- **Elongation** — a 4:1 wordmark is thin by construction, so its long axis
+  gets a little more room than a compact mark needs.
+
+Span lands between 0.58 and 0.88, against a base of 0.70 at half coverage —
+about what the hand-built set rendered at, once its 250-of-400 canvas and the
+tile's old `scale(1.15)` are multiplied out.
+
+`logos:check` recomputes the keyline and fails any mark more than 6% off it,
+which is what catches an asset dropped in without `logos:prepare`.
+
+## Commands
+
+```sh
+npm run logos:prepare -w @moderneinc/design-system-logos -- src/marks/foo.svg   # viewBox, svgo, keyline frame
+npm run logos:prepare -w @moderneinc/design-system-logos -- --all               # re-run over the whole set
+npm run logos:check                                                             # verify; exits non-zero on failure
+npm run logos:sheet                                                             # logo-contact-sheet.png
+```
+
+`logos:prepare` is idempotent, so `--all` is safe. Passing a light asset also
+prepares its dark sibling, and always frames the dark one against the light.
+
+Storybook's **Icons/Logos** page is the richer view: every mark light beside
+dark, at 20px and 96px, drawn by the real component.
+
+## Adding a logo
+
+1. Source the vendor's **current** artwork — their live site or brand page, not
+   a logo aggregator's 2019 cache. Brands refresh marks, often specifically to
+   work in dark mode.
+2. Save it as `src/marks/<slug>.svg`, lowercase.
+3. `npm run logos:prepare -w @moderneinc/design-system-logos -- src/marks/<slug>.svg`
+4. Look at it on both plates. If it dies on dark, add `<slug>.dark.svg` and
+   re-run `logos:prepare` on the light file.
+5. `npm run logos:check`
+
+## Prerequisites
+
+Structural checks are pure Node. Keyline, clipping and contrast checks render
+the marks and need `brew install librsvg imagemagick`; they are skipped with a
+notice when those are missing, so `logos:check` still runs anywhere.
+
+## Traps
+
+- **Never put `@media (prefers-color-scheme)` inside an SVG.** It follows the OS,
+  not the app's theme toggle, so a dark-mode OS renders the mark white-on-white
+  on a light page. `logos:check` rejects it. Use a `.dark.svg` sibling.
+- **`logos:prepare` must keep using this directory's svgo config.** The
+  default preset drops `viewBox` when `width`/`height` are present and agree —
+  exactly the shape a freshly downloaded logo has.
+- **The contrast check is deliberately loose.** WCAG 3:1 is a text standard; a
+  logo is a large shape, and brand colors legitimately sit near 2:1 without being
+  hard to recognize. It only flags marks that nearly vanish, so it will not catch
+  a merely weak one. That is what looking at the Storybook page is for.
+- **Nothing downstream may add padding to a mark.** The keyline is the padding,
+  and a slot that insets it again reintroduces exactly the imbalance the grid
+  exists to remove — the mark that was already given the least room loses the
+  most.
+
+## Why `tools/` is not linted
+
+`biome.json` never includes `packages/*/tools/**`, so these files keep their
+source repo's house style (semicolons, against this repo's `semicolons:
+"asNeeded"`). That is deliberate: they are shared with [moderneinc/public-assets]
+so a mark can move between the two, and reformatting would fork them. Adding
+`tools/` to Biome's includes would rewrite all five files.
+
+## Provenance
+
+These are third-party marks, reproduced to identify the projects they belong to.
+Each is the vendor's own current artwork, reframed to the keyline grid and
+optimized — never redrawn or recolored, apart from lifting near-black ink for a
+`.dark.svg` sibling. They are published here so Moderne's own applications render
+them consistently. Nothing about packaging them grants any trademark right, and
+downstream use outside that purpose is the user's responsibility.

package/dist/index.cjs

@@ -0,0 +1,453 @@
+'use strict';
+
+const slugs = [
+  "akka",
+  "android",
+  "angular",
+  "anthropic",
+  "apache",
+  "archunit",
+  "arquillian",
+  "artifactory",
+  "assertj",
+  "astgrep",
+  "aws",
+  "aws-s3",
+  "axonframework",
+  "axoniq",
+  "azul",
+  "azure",
+  "biome",
+  "byteman",
+  "camel",
+  "circleci",
+  "cloudsuitability",
+  "cobol",
+  "codehaus",
+  "compose",
+  "concourse",
+  "controlflow",
+  "core",
+  "csharp",
+  "cucumber",
+  "customrecipe",
+  "datafaker",
+  "dbrider",
+  "diffblue",
+  "docker",
+  "dotnet",
+  "dropwizard",
+  "easymock",
+  "elastic",
+  "fasterxml",
+  "featureflags",
+  "ff4j",
+  "flyway",
+  "gcp",
+  "gemini",
+  "github",
+  "gitlab",
+  "go",
+  "google",
+  "gradle",
+  "groovy",
+  "hcl",
+  "hibernate",
+  "httpcomponents",
+  "jacoco",
+  "jakarta",
+  "jasperreports",
+  "java",
+  "javascript",
+  "jboss",
+  "jenkins",
+  "jest",
+  "jetty",
+  "jhipster",
+  "jmockit",
+  "joda",
+  "json",
+  "jspecify",
+  "junit",
+  "kafka",
+  "keyfactor",
+  "kotlin",
+  "kubernetes",
+  "langchain",
+  "launchdarkly",
+  "liberty",
+  "lodash",
+  "log4j",
+  "lombok",
+  "maven",
+  "micrometer",
+  "micronaut",
+  "minio",
+  "mistral",
+  "mockito",
+  "moderne",
+  "mui",
+  "netty",
+  "nextjs",
+  "nexus",
+  "nodejs",
+  "npm",
+  "nuget",
+  "okhttp",
+  "open-ai",
+  "openapi",
+  "openfeature",
+  "openrewrite",
+  "opentelemetry",
+  "operaton",
+  "oracle",
+  "picnic",
+  "play",
+  "plexus",
+  "poolside",
+  "properties",
+  "pydantic",
+  "pypi",
+  "python",
+  "quarkus",
+  "react",
+  "reactive",
+  "reactor",
+  "recommendations",
+  "refaster",
+  "richfaces",
+  "scala",
+  "search",
+  "spring",
+  "springamqp",
+  "springbatch",
+  "springboot",
+  "springcloud",
+  "springdata",
+  "springframework",
+  "springkafka",
+  "springsecurity",
+  "sql",
+  "storybook",
+  "struts",
+  "svelte",
+  "tapestry",
+  "terraform",
+  "testcontainers",
+  "testng",
+  "text",
+  "timefold",
+  "toml",
+  "ubc",
+  "ui5",
+  "unleash",
+  "vue",
+  "vulncheck",
+  "wicket",
+  "wiremock",
+  "xml",
+  "xunit",
+  "yaml"
+];
+const darkSlugs = [
+  "akka",
+  "anthropic",
+  "assertj",
+  "astgrep",
+  "aws",
+  "axoniq",
+  "azul",
+  "circleci",
+  "cloudsuitability",
+  "codehaus",
+  "controlflow",
+  "core",
+  "datafaker",
+  "diffblue",
+  "docker",
+  "easymock",
+  "fasterxml",
+  "featureflags",
+  "github",
+  "hcl",
+  "hibernate",
+  "httpcomponents",
+  "jacoco",
+  "jakarta",
+  "jboss",
+  "jmockit",
+  "joda",
+  "json",
+  "jspecify",
+  "junit",
+  "kafka",
+  "keyfactor",
+  "langchain",
+  "launchdarkly",
+  "lodash",
+  "micronaut",
+  "mockito",
+  "moderne",
+  "nextjs",
+  "nexus",
+  "nuget",
+  "open-ai",
+  "openapi",
+  "openfeature",
+  "openrewrite",
+  "operaton",
+  "poolside",
+  "properties",
+  "quarkus",
+  "react",
+  "reactive",
+  "recommendations",
+  "richfaces",
+  "search",
+  "terraform",
+  "testng",
+  "text",
+  "timefold",
+  "toml",
+  "ubc",
+  "unleash",
+  "vulncheck",
+  "xml",
+  "xunit",
+  "yaml"
+];
+
+const thunks = {
+  "akka": () => import('./marks/akka.js'),
+  "android": () => import('./marks/android.js'),
+  "angular": () => import('./marks/angular.js'),
+  "anthropic": () => import('./marks/anthropic.js'),
+  "apache": () => import('./marks/apache.js'),
+  "archunit": () => import('./marks/archunit.js'),
+  "arquillian": () => import('./marks/arquillian.js'),
+  "artifactory": () => import('./marks/artifactory.js'),
+  "assertj": () => import('./marks/assertj.js'),
+  "astgrep": () => import('./marks/astgrep.js'),
+  "aws": () => import('./marks/aws.js'),
+  "aws-s3": () => import('./marks/aws-s3.js'),
+  "axonframework": () => import('./marks/axonframework.js'),
+  "axoniq": () => import('./marks/axoniq.js'),
+  "azul": () => import('./marks/azul.js'),
+  "azure": () => import('./marks/azure.js'),
+  "biome": () => import('./marks/biome.js'),
+  "byteman": () => import('./marks/byteman.js'),
+  "camel": () => import('./marks/camel.js'),
+  "circleci": () => import('./marks/circleci.js'),
+  "cloudsuitability": () => import('./marks/cloudsuitability.js'),
+  "cobol": () => import('./marks/cobol.js'),
+  "codehaus": () => import('./marks/codehaus.js'),
+  "compose": () => import('./marks/compose.js'),
+  "concourse": () => import('./marks/concourse.js'),
+  "controlflow": () => import('./marks/controlflow.js'),
+  "core": () => import('./marks/core.js'),
+  "csharp": () => import('./marks/csharp.js'),
+  "cucumber": () => import('./marks/cucumber.js'),
+  "customrecipe": () => import('./marks/customrecipe.js'),
+  "datafaker": () => import('./marks/datafaker.js'),
+  "dbrider": () => import('./marks/dbrider.js'),
+  "diffblue": () => import('./marks/diffblue.js'),
+  "docker": () => import('./marks/docker.js'),
+  "dotnet": () => import('./marks/dotnet.js'),
+  "dropwizard": () => import('./marks/dropwizard.js'),
+  "easymock": () => import('./marks/easymock.js'),
+  "elastic": () => import('./marks/elastic.js'),
+  "fasterxml": () => import('./marks/fasterxml.js'),
+  "featureflags": () => import('./marks/featureflags.js'),
+  "ff4j": () => import('./marks/ff4j.js'),
+  "flyway": () => import('./marks/flyway.js'),
+  "gcp": () => import('./marks/gcp.js'),
+  "gemini": () => import('./marks/gemini.js'),
+  "github": () => import('./marks/github.js'),
+  "gitlab": () => import('./marks/gitlab.js'),
+  "go": () => import('./marks/go.js'),
+  "google": () => import('./marks/google.js'),
+  "gradle": () => import('./marks/gradle.js'),
+  "groovy": () => import('./marks/groovy.js'),
+  "hcl": () => import('./marks/hcl.js'),
+  "hibernate": () => import('./marks/hibernate.js'),
+  "httpcomponents": () => import('./marks/httpcomponents.js'),
+  "jacoco": () => import('./marks/jacoco.js'),
+  "jakarta": () => import('./marks/jakarta.js'),
+  "jasperreports": () => import('./marks/jasperreports.js'),
+  "java": () => import('./marks/java.js'),
+  "javascript": () => import('./marks/javascript.js'),
+  "jboss": () => import('./marks/jboss.js'),
+  "jenkins": () => import('./marks/jenkins.js'),
+  "jest": () => import('./marks/jest.js'),
+  "jetty": () => import('./marks/jetty.js'),
+  "jhipster": () => import('./marks/jhipster.js'),
+  "jmockit": () => import('./marks/jmockit.js'),
+  "joda": () => import('./marks/joda.js'),
+  "json": () => import('./marks/json.js'),
+  "jspecify": () => import('./marks/jspecify.js'),
+  "junit": () => import('./marks/junit.js'),
+  "kafka": () => import('./marks/kafka.js'),
+  "keyfactor": () => import('./marks/keyfactor.js'),
+  "kotlin": () => import('./marks/kotlin.js'),
+  "kubernetes": () => import('./marks/kubernetes.js'),
+  "langchain": () => import('./marks/langchain.js'),
+  "launchdarkly": () => import('./marks/launchdarkly.js'),
+  "liberty": () => import('./marks/liberty.js'),
+  "lodash": () => import('./marks/lodash.js'),
+  "log4j": () => import('./marks/log4j.js'),
+  "lombok": () => import('./marks/lombok.js'),
+  "maven": () => import('./marks/maven.js'),
+  "micrometer": () => import('./marks/micrometer.js'),
+  "micronaut": () => import('./marks/micronaut.js'),
+  "minio": () => import('./marks/minio.js'),
+  "mistral": () => import('./marks/mistral.js'),
+  "mockito": () => import('./marks/mockito.js'),
+  "moderne": () => import('./marks/moderne.js'),
+  "mui": () => import('./marks/mui.js'),
+  "netty": () => import('./marks/netty.js'),
+  "nextjs": () => import('./marks/nextjs.js'),
+  "nexus": () => import('./marks/nexus.js'),
+  "nodejs": () => import('./marks/nodejs.js'),
+  "npm": () => import('./marks/npm.js'),
+  "nuget": () => import('./marks/nuget.js'),
+  "okhttp": () => import('./marks/okhttp.js'),
+  "open-ai": () => import('./marks/open-ai.js'),
+  "openapi": () => import('./marks/openapi.js'),
+  "openfeature": () => import('./marks/openfeature.js'),
+  "openrewrite": () => import('./marks/openrewrite.js'),
+  "opentelemetry": () => import('./marks/opentelemetry.js'),
+  "operaton": () => import('./marks/operaton.js'),
+  "oracle": () => import('./marks/oracle.js'),
+  "picnic": () => import('./marks/picnic.js'),
+  "play": () => import('./marks/play.js'),
+  "plexus": () => import('./marks/plexus.js'),
+  "poolside": () => import('./marks/poolside.js'),
+  "properties": () => import('./marks/properties.js'),
+  "pydantic": () => import('./marks/pydantic.js'),
+  "pypi": () => import('./marks/pypi.js'),
+  "python": () => import('./marks/python.js'),
+  "quarkus": () => import('./marks/quarkus.js'),
+  "react": () => import('./marks/react.js'),
+  "reactive": () => import('./marks/reactive.js'),
+  "reactor": () => import('./marks/reactor.js'),
+  "recommendations": () => import('./marks/recommendations.js'),
+  "refaster": () => import('./marks/refaster.js'),
+  "richfaces": () => import('./marks/richfaces.js'),
+  "scala": () => import('./marks/scala.js'),
+  "search": () => import('./marks/search.js'),
+  "spring": () => import('./marks/spring.js'),
+  "springamqp": () => import('./marks/springamqp.js'),
+  "springbatch": () => import('./marks/springbatch.js'),
+  "springboot": () => import('./marks/springboot.js'),
+  "springcloud": () => import('./marks/springcloud.js'),
+  "springdata": () => import('./marks/springdata.js'),
+  "springframework": () => import('./marks/springframework.js'),
+  "springkafka": () => import('./marks/springkafka.js'),
+  "springsecurity": () => import('./marks/springsecurity.js'),
+  "sql": () => import('./marks/sql.js'),
+  "storybook": () => import('./marks/storybook.js'),
+  "struts": () => import('./marks/struts.js'),
+  "svelte": () => import('./marks/svelte.js'),
+  "tapestry": () => import('./marks/tapestry.js'),
+  "terraform": () => import('./marks/terraform.js'),
+  "testcontainers": () => import('./marks/testcontainers.js'),
+  "testng": () => import('./marks/testng.js'),
+  "text": () => import('./marks/text.js'),
+  "timefold": () => import('./marks/timefold.js'),
+  "toml": () => import('./marks/toml.js'),
+  "ubc": () => import('./marks/ubc.js'),
+  "ui5": () => import('./marks/ui5.js'),
+  "unleash": () => import('./marks/unleash.js'),
+  "vue": () => import('./marks/vue.js'),
+  "vulncheck": () => import('./marks/vulncheck.js'),
+  "wicket": () => import('./marks/wicket.js'),
+  "wiremock": () => import('./marks/wiremock.js'),
+  "xml": () => import('./marks/xml.js'),
+  "xunit": () => import('./marks/xunit.js'),
+  "yaml": () => import('./marks/yaml.js')
+};
+const darkThunks = {
+  "akka": () => import('./marks/akka.dark.js'),
+  "anthropic": () => import('./marks/anthropic.dark.js'),
+  "assertj": () => import('./marks/assertj.dark.js'),
+  "astgrep": () => import('./marks/astgrep.dark.js'),
+  "aws": () => import('./marks/aws.dark.js'),
+  "axoniq": () => import('./marks/axoniq.dark.js'),
+  "azul": () => import('./marks/azul.dark.js'),
+  "circleci": () => import('./marks/circleci.dark.js'),
+  "cloudsuitability": () => import('./marks/cloudsuitability.dark.js'),
+  "codehaus": () => import('./marks/codehaus.dark.js'),
+  "controlflow": () => import('./marks/controlflow.dark.js'),
+  "core": () => import('./marks/core.dark.js'),
+  "datafaker": () => import('./marks/datafaker.dark.js'),
+  "diffblue": () => import('./marks/diffblue.dark.js'),
+  "docker": () => import('./marks/docker.dark.js'),
+  "easymock": () => import('./marks/easymock.dark.js'),
+  "fasterxml": () => import('./marks/fasterxml.dark.js'),
+  "featureflags": () => import('./marks/featureflags.dark.js'),
+  "github": () => import('./marks/github.dark.js'),
+  "hcl": () => import('./marks/hcl.dark.js'),
+  "hibernate": () => import('./marks/hibernate.dark.js'),
+  "httpcomponents": () => import('./marks/httpcomponents.dark.js'),
+  "jacoco": () => import('./marks/jacoco.dark.js'),
+  "jakarta": () => import('./marks/jakarta.dark.js'),
+  "jboss": () => import('./marks/jboss.dark.js'),
+  "jmockit": () => import('./marks/jmockit.dark.js'),
+  "joda": () => import('./marks/joda.dark.js'),
+  "json": () => import('./marks/json.dark.js'),
+  "jspecify": () => import('./marks/jspecify.dark.js'),
+  "junit": () => import('./marks/junit.dark.js'),
+  "kafka": () => import('./marks/kafka.dark.js'),
+  "keyfactor": () => import('./marks/keyfactor.dark.js'),
+  "langchain": () => import('./marks/langchain.dark.js'),
+  "launchdarkly": () => import('./marks/launchdarkly.dark.js'),
+  "lodash": () => import('./marks/lodash.dark.js'),
+  "micronaut": () => import('./marks/micronaut.dark.js'),
+  "mockito": () => import('./marks/mockito.dark.js'),
+  "moderne": () => import('./marks/moderne.dark.js'),
+  "nextjs": () => import('./marks/nextjs.dark.js'),
+  "nexus": () => import('./marks/nexus.dark.js'),
+  "nuget": () => import('./marks/nuget.dark.js'),
+  "open-ai": () => import('./marks/open-ai.dark.js'),
+  "openapi": () => import('./marks/openapi.dark.js'),
+  "openfeature": () => import('./marks/openfeature.dark.js'),
+  "openrewrite": () => import('./marks/openrewrite.dark.js'),
+  "operaton": () => import('./marks/operaton.dark.js'),
+  "poolside": () => import('./marks/poolside.dark.js'),
+  "properties": () => import('./marks/properties.dark.js'),
+  "quarkus": () => import('./marks/quarkus.dark.js'),
+  "react": () => import('./marks/react.dark.js'),
+  "reactive": () => import('./marks/reactive.dark.js'),
+  "recommendations": () => import('./marks/recommendations.dark.js'),
+  "richfaces": () => import('./marks/richfaces.dark.js'),
+  "search": () => import('./marks/search.dark.js'),
+  "terraform": () => import('./marks/terraform.dark.js'),
+  "testng": () => import('./marks/testng.dark.js'),
+  "text": () => import('./marks/text.dark.js'),
+  "timefold": () => import('./marks/timefold.dark.js'),
+  "toml": () => import('./marks/toml.dark.js'),
+  "ubc": () => import('./marks/ubc.dark.js'),
+  "unleash": () => import('./marks/unleash.dark.js'),
+  "vulncheck": () => import('./marks/vulncheck.dark.js'),
+  "xml": () => import('./marks/xml.dark.js'),
+  "xunit": () => import('./marks/xunit.dark.js'),
+  "yaml": () => import('./marks/yaml.dark.js')
+};
+
+const darkSet = new Set(darkSlugs);
+const hasDark = (slug) => darkSet.has(slug);
+const slugSet = new Set(slugs);
+const isLogoSlug = (slug) => slugSet.has(slug);
+const loadLogo = async (slug, { dark = false } = {}) => {
+  const thunk = dark && darkSet.has(slug) ? darkThunks[slug] : thunks[slug];
+  if (!thunk) {
+    throw new Error(`unknown logo slug: ${slug}`);
+  }
+  return (await thunk()).default;
+};
+
+exports.hasDark = hasDark;
+exports.isLogoSlug = isLogoSlug;
+exports.loadLogo = loadLogo;
+exports.slugs = slugs;
+//# sourceMappingURL=index.cjs.map