mdeck 2.3.0 → 3.1.0

package/src/extensions/packages.js

@@ -0,0 +1,318 @@
+// Packages: every theme and every palette can be installed on its own, from
+// mdeck itself (the built-in ones) or from the theme repository
+// (https://gh.tschieber.de/mdeck-themes/). A package is one extension folder;
+// it travels as one JSON file of its text files, so installing it is checking
+// it and writing those files. Only extension.toml and, for a theme,
+// styles.css are allowed: a package never carries code.
+// What a package needs follows from its manifest: a theme needs its default
+// palette, and a palette that belongs to one theme needs that theme. Those
+// are installed along with it.
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { resolve, relative, basename } from 'node:path'
+import { ID_RE, ManifestError, RANGE_RE, parseManifestText, validateManifest } from './manifest.js'
+import { builtinExtensionsRoot } from '../paths.js'
+
+export const CATALOGUE_URL = 'https://gh.tschieber.de/mdeck-themes/catalogue.json'
+export const MARKER = '.mdeck-package.json'
+const PACKAGE_KINDS = ['theme', 'palette']
+const FILES = { theme: ['extension.toml', 'styles.css'], palette: ['extension.toml'] }
+// Where theme fonts may come from: stylesheet services that only serve fonts.
+export const FONT_HOSTS = ['https://fonts.googleapis.com/', 'https://fonts.bunny.net/']
+
+export class PackageError extends Error {}
+const fail = message => { throw new PackageError(message) }
+
+export const sha256 = text => createHash('sha256').update(text, 'utf8').digest('hex')
+export const keyOf = (kind, id) => `${kind}:${id}`
+
+export function catalogueUrl() {
+  return process.env.MDECK_THEMES_URL || CATALOGUE_URL
+}
+
+const parts = version => version.split('.').map(Number)
+export function compareVersions(a, b) {
+  const [x, y] = [parts(a), parts(b)]
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] - y[i]
+  return 0
+}
+
+// Ranges are only of the form ">=1.2.3"; no range means any version.
+export function satisfies(range, version) {
+  if (!range) return true
+  const match = RANGE_RE.exec(range)
+  return Boolean(match) && compareVersions(version, match[1]) >= 0
+}
+
+function checkCss(text, where) {
+  if (/@import/i.test(text)) fail(`${where}: @import is not allowed; list font stylesheets under fonts in extension.toml`)
+  for (const match of text.matchAll(/url\(\s*(['"]?)([^'")]*)\1\s*\)/gi)) {
+    if (!match[2].trim().startsWith('data:')) fail(`${where}: url(${match[2]}) is not allowed; only data: URLs`)
+  }
+}
+
+// Checks one package's files: what it may hold, its manifest, its fonts and
+// stylesheet. `published` also requires version, author and license, as the
+// theme repository does. Returns the validated record.
+export function checkPackage({ kind, id, files }, { published = false } = {}) {
+  if (!PACKAGE_KINDS.includes(kind)) fail(`${kind} is not a kind of package; only themes and palettes are`)
+  if (typeof id !== 'string' || !ID_RE.test(id)) fail(`"${id}" is not an id: lowercase letters, digits and hyphens, starting with a letter`)
+  if (!files || typeof files !== 'object') fail(`The ${kind} ${id} has no files`)
+  for (const [name, text] of Object.entries(files)) {
+    if (!FILES[kind].includes(name)) fail(`The ${kind} ${id}: "${name}" is not allowed; a ${kind} holds only ${FILES[kind].join(' and ')}`)
+    if (typeof text !== 'string') fail(`The ${kind} ${id}: ${name} is not text`)
+  }
+  if (!files['extension.toml']) fail(`The ${kind} ${id}: extension.toml is missing`)
+  const dir = `/package/${id}`
+  const file = `${dir}/extension.toml`
+  let record
+  try {
+    record = validateManifest(parseManifestText(files['extension.toml'], file), { file, dir, folderName: id, fileExists: path => Object.hasOwn(files, relative(dir, path)) })
+  } catch (error) {
+    if (error instanceof ManifestError) fail(`The ${kind} ${id}: ${error.message.replace(`${file}: `, '')}`)
+    throw error
+  }
+  if (record.kind !== kind) fail(`${id}/extension.toml says kind = "${record.kind}", but it is in the ${kind}s`)
+  if (published) for (const key of ['version', 'author', 'license']) if (!record.package?.[key]) fail(`The ${kind} ${id}: ${key} is required in the theme repository`)
+  if (kind === 'theme') {
+    for (const url of record.manifest.fonts) if (!FONT_HOSTS.some(host => url.startsWith(host))) fail(`The theme ${id} loads fonts from ${url}; allowed are ${FONT_HOSTS.join(', ')}`)
+    checkCss(files['styles.css'] ?? '', `The theme ${id}: styles.css`)
+  }
+  return record
+}
+
+// What a package needs installed with it: a theme its default palette, a
+// palette of one theme that theme.
+export function dependencies(kind, manifest) {
+  if (kind === 'theme') return [{ kind: 'palette', id: manifest.palette }]
+  return manifest.theme ? [{ kind: 'theme', id: manifest.theme }] : []
+}
+
+// A package folder's files and record; `kind` comes from the manifest.
+export function readPackageDir(dir, { published = false } = {}) {
+  const id = basename(dir)
+  const files = {}
+  for (const name of readdirSync(dir).sort()) {
+    if (name.startsWith('.') || name === 'README.md') continue
+    if (!statSync(resolve(dir, name)).isFile()) fail(`${resolve(dir, name)}: a package holds only files`)
+    files[name] = readFileSync(resolve(dir, name), 'utf8')
+  }
+  const kind = /^kind\s*=\s*"([a-z]+)"/m.exec(files['extension.toml'] ?? '')?.[1]
+  const record = checkPackage({ kind, id, files }, { published })
+  return { kind, id, files, record }
+}
+
+// The published form of a package folder: one JSON text and its checksum.
+export function bundlePackage(dir, options) {
+  const { kind, id, files, record } = readPackageDir(dir, options)
+  const bundle = { schema: 2, kind, id, version: record.package?.version ?? '0.0.0', ...(record.package?.mdeck ? { mdeck: record.package.mdeck } : {}), files }
+  const text = JSON.stringify(bundle, null, 1) + '\n'
+  return { bundle, text, sha256: sha256(text), record }
+}
+
+// ─── Installed packages ───────────────────────────────────────────────────
+
+const readJson = file => { try { return JSON.parse(readFileSync(file, 'utf8')) } catch { return null } }
+const packageDir = (root, kind, id) => resolve(root, `${kind}s`, id)
+
+// Files changed since the package was installed, by name.
+function changedFiles(dir, marker) {
+  return Object.entries(marker.files ?? {}).filter(([name, hash]) => {
+    const file = resolve(dir, name)
+    return !existsSync(file) || sha256(readFileSync(file, 'utf8')) !== hash
+  }).map(([name]) => name)
+}
+
+const refuseChanged = (dir, marker) => {
+  const changed = changedFiles(dir, marker)
+  if (changed.length) fail(`${dir} was changed since it was installed (${changed.join(', ')}); add --force to replace or remove it anyway`)
+}
+
+// The packages installed in an extensions folder (in its themes/ and
+// palettes/), by "kind:id".
+export function installedPackages(root) {
+  const found = {}
+  for (const kind of PACKAGE_KINDS) {
+    const dir = resolve(root, `${kind}s`)
+    if (!existsSync(dir)) continue
+    for (const id of readdirSync(dir).sort()) {
+      const marker = readJson(resolve(dir, id, MARKER))
+      if (marker?.kind === kind) found[keyOf(kind, id)] = { kind, id, version: marker.version ?? null, url: marker.url ?? null, dir: resolve(dir, id), marker }
+    }
+  }
+  return found
+}
+
+// Writes a checked package into an extensions folder (a deck's, or the
+// user's), as <kind>s/<id>. A folder of the deck's own is never touched; one
+// installed before is replaced unless it was changed by hand.
+export function installPackage(bundle, { root, url = null, digest = null, force = false } = {}) {
+  const { kind, id } = bundle
+  const record = checkPackage(bundle)
+  const dir = packageDir(root, kind, id)
+  const before = installedPackages(root)[keyOf(kind, id)]
+  if (existsSync(dir) && !readJson(resolve(dir, MARKER))) fail(`${dir} already exists and was not installed by mdeck; rename or remove it first`)
+  if (before && !force) refuseChanged(before.dir, before.marker)
+  // Files are overwritten in place, not deleted and written again, so a
+  // running editor sees a change instead of a file that disappears.
+  mkdirSync(dir, { recursive: true })
+  const hashes = {}
+  for (const [name, content] of Object.entries(bundle.files)) {
+    writeFileSync(resolve(dir, name), content, 'utf8')
+    hashes[name] = sha256(content)
+  }
+  for (const name of readdirSync(dir)) if (name !== MARKER && !Object.hasOwn(hashes, name)) rmSync(resolve(dir, name), { recursive: true, force: true })
+  writeFileSync(resolve(dir, MARKER), JSON.stringify({ kind, id, version: bundle.version, url, sha256: digest, files: hashes }, null, 2) + '\n')
+  return { record, dir, replaced: before?.version ?? null }
+}
+
+export function removePackage(kind, id, { root, force = false } = {}) {
+  const installed = installedPackages(root)[keyOf(kind, id)]
+  if (!installed) fail(`The ${kind} ${id} is not installed in ${root}`)
+  if (!force) refuseChanged(installed.dir, installed.marker)
+  rmSync(installed.dir, { recursive: true, force: true })
+  return installed
+}
+
+// ─── The catalogue: built-in packages and the repository ──────────────────
+
+async function get(url, as) {
+  let response
+  try { response = await fetch(url) } catch (error) { fail(`Could not reach ${url}: ${error.cause?.message ?? error.message}`) }
+  if (!response.ok) fail(`${url} answered ${response.status}`)
+  return as === 'json' ? response.json() : response.text()
+}
+
+export async function fetchCatalogue(url = catalogueUrl()) {
+  const data = await get(url, 'json')
+  if (data?.schema !== 2 || !Array.isArray(data.themes) || !Array.isArray(data.palettes)) fail(`${url} is not a theme repository catalogue`)
+  return data
+}
+
+// One entry of the catalogue, from a package's record.
+function entryOf(kind, record) {
+  return {
+    kind, id: record.id, title: record.title, description: record.description ?? '',
+    version: record.package?.version ?? '0.0.0', ...(record.package?.author ? { author: record.package.author } : {}), ...(record.package?.license ? { license: record.package.license } : {}),
+    ...(record.package?.homepage ? { homepage: record.package.homepage } : {}), ...(record.package?.mdeck ? { mdeck: record.package.mdeck } : {}),
+    ...(kind === 'theme' ? { palette: record.manifest.palette, ...(record.manifest.palettes?.length ? { palettes: record.manifest.palettes } : {}), appearance: record.manifest.appearance ?? 'light' } : {}),
+    ...(kind === 'palette' && record.manifest.theme ? { theme: record.manifest.theme } : {}),
+  }
+}
+
+// The themes and palettes that come with mdeck, as catalogue entries.
+export function builtInEntries(root = builtinExtensionsRoot) {
+  const entries = []
+  for (const kind of PACKAGE_KINDS) {
+    const dir = resolve(root, `${kind}s`)
+    if (!existsSync(dir)) continue
+    for (const id of readdirSync(dir).sort()) {
+      if (id.startsWith('.')) continue
+      const { record } = readPackageDir(resolve(dir, id))
+      entries.push({ ...entryOf(kind, record), builtIn: true, dir: resolve(dir, id) })
+    }
+  }
+  return entries
+}
+
+// Every theme and palette mdeck can install: the built-in ones, and the
+// repository's when it answers. Of two versions the newer is offered; the
+// built-in one on a tie, since it needs no download. `offline` says why the
+// repository is missing.
+export async function loadCatalogue({ url = catalogueUrl(), online = true } = {}) {
+  const entries = new Map(builtInEntries().map(entry => [keyOf(entry.kind, entry.id), entry]))
+  let offline = null
+  let remote = { themes: [], palettes: [] }
+  if (online) { try { remote = await fetchCatalogue(url) } catch (error) { offline = error.message } }
+  for (const entry of [...remote.themes.map(e => ({ ...e, kind: 'theme' })), ...remote.palettes.map(e => ({ ...e, kind: 'palette' }))]) {
+    const key = keyOf(entry.kind, entry.id)
+    const have = entries.get(key)
+    if (entry.builtIn) { if (have) have.preview = entry.preview; continue }
+    if (!have || compareVersions(entry.version, have.version) > 0) entries.set(key, { ...entry, builtIn: false, builtInVersion: have?.version })
+  }
+  const sorted = [...entries.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id, 'en'))
+  return { url, offline, entries: sorted, get: (kind, id) => entries.get(keyOf(kind, id)) }
+}
+
+export function findEntry(catalogue, kind, id) {
+  return catalogue.get(kind, id) ?? fail(`There is no ${kind} "${id}"${catalogue.offline ? ` among those that come with mdeck, and the theme repository could not be reached (${catalogue.offline})` : `; mdeck ${kind}s search lists them`}`)
+}
+
+// A package's files: read from mdeck's folder, or downloaded and checked
+// against the repository's checksum.
+export async function obtainPackage(catalogue, entry) {
+  if (entry.builtIn) { const { bundle, sha256: digest } = bundlePackage(entry.dir); return { bundle, url: null, digest } }
+  const url = new URL(entry.url, catalogue.url).href
+  const text = await get(url, 'text')
+  if (sha256(text) !== entry.sha256) fail(`${url} does not match its checksum in the catalogue; not installed`)
+  let bundle
+  try { bundle = JSON.parse(text) } catch { fail(`${url} is not a package`) }
+  if (bundle.kind !== entry.kind || bundle.id !== entry.id || bundle.version !== entry.version) fail(`${url} holds the ${bundle.kind} ${bundle.id} ${bundle.version}, not the ${entry.kind} ${entry.id} ${entry.version}`)
+  return { bundle, url, digest: entry.sha256 }
+}
+
+// A package and what it needs, in the order to install them: what is needed
+// first, the package itself last. A theme and its own palette need each
+// other; each is installed once.
+export function withDependencies(catalogue, kind, id, seen = new Set()) {
+  const key = keyOf(kind, id)
+  if (seen.has(key)) return []
+  seen.add(key)
+  const entry = findEntry(catalogue, kind, id)
+  const needs = kind === 'theme' ? [{ kind: 'palette', id: entry.palette }] : entry.theme ? [{ kind: 'theme', id: entry.theme }] : []
+  const order = []
+  for (const need of needs) for (const item of withDependencies(catalogue, need.kind, need.id, seen)) if (!order.includes(item)) order.push(item)
+  return [...order, entry]
+}
+
+// ─── The repository itself ────────────────────────────────────────────────
+
+// The theme repository as served: catalogue.json, and <kind>s/<id>-<version>.json
+// for each package, from a folder with themes/ and palettes/. mdeck's
+// built-in packages are listed too (marked builtIn), so the repository's
+// themes may use built-in palettes. Every package is checked, no id appears
+// twice in a kind, and what each needs is in the catalogue. Previews are added
+// by the caller.
+export function buildRepository(repoDir, outDir) {
+  const builtIn = builtInEntries()
+  const records = {}
+  const add = (kind, id, value) => {
+    if (records[keyOf(kind, id)]) fail(`There are two ${kind}s "${id}"${value.builtIn || records[keyOf(kind, id)].builtIn ? '; one comes with mdeck, change it there' : ''}`)
+    records[keyOf(kind, id)] = value
+  }
+  for (const entry of builtIn) add(entry.kind, entry.id, { entry, builtIn: true, ...bundlePackage(entry.dir) })
+  for (const kind of PACKAGE_KINDS) {
+    const dir = resolve(repoDir, `${kind}s`)
+    if (!existsSync(dir)) continue
+    for (const id of readdirSync(dir).sort()) {
+      if (id.startsWith('.') || !statSync(resolve(dir, id)).isDirectory()) continue
+      const read = bundlePackage(resolve(dir, id), { published: true })
+      if (read.bundle.kind !== kind) fail(`${kind}s/${id} holds a ${read.bundle.kind}`)
+      add(kind, id, { entry: entryOf(kind, read.record), builtIn: false, dir: resolve(dir, id), ...read })
+    }
+  }
+  // What each needs must be there, and a theme may offer only palettes that
+  // are open to it.
+  for (const { record, bundle } of Object.values(records)) {
+    for (const need of dependencies(bundle.kind, record.manifest)) {
+      if (!records[keyOf(need.kind, need.id)]) fail(`The ${bundle.kind} ${bundle.id} needs the ${need.kind} "${need.id}", which is neither in the repository nor built into mdeck`)
+    }
+    if (bundle.kind === 'theme') for (const id of [record.manifest.palette, ...(record.manifest.palettes ?? [])]) {
+      const palette = records[keyOf('palette', id)]
+      if (!palette) fail(`The theme ${bundle.id} offers the palette "${id}", which is neither in the repository nor built into mdeck`)
+      const owner = palette.record.manifest.theme
+      if (owner && owner !== bundle.id) fail(`The theme ${bundle.id} offers the palette ${id}, which belongs to the theme ${owner}`)
+    }
+  }
+  const catalogue = { schema: 2, themes: [], palettes: [] }
+  for (const key of Object.keys(records).sort()) {
+    const { entry, text, sha256: digest, bundle, builtIn: isBuiltIn } = records[key]
+    const file = `${bundle.kind}s/${bundle.id}-${bundle.version}.json`
+    mkdirSync(resolve(outDir, `${bundle.kind}s`), { recursive: true })
+    writeFileSync(resolve(outDir, file), text)
+    const { dir, ...listed } = entry
+    catalogue[`${bundle.kind}s`].push({ ...listed, ...(isBuiltIn ? { builtIn: true } : {}), url: file, sha256: digest })
+  }
+  writeFileSync(resolve(outDir, 'catalogue.json'), JSON.stringify(catalogue, null, 2) + '\n')
+  return { catalogue, dirs: Object.fromEntries(Object.entries(records).map(([key, value]) => [key, value.dir ?? value.entry.dir])) }
+}

package/src/home/Home.jsx

@@ -66,24 +66,29 @@ async function openService(action, page = '') {
   const tab = window.open('about:blank', '_blank')
   try {
     const { url } = await api('/action', { action })
-    const target = new URL(page, url).href
-    if (tab) tab.location = target
-    else window.open(target, '_blank')
+    const target = new URL(page, url)
+    // The editors link back here.
+    if (action === 'editor') target.searchParams.set('home', location.href.split('#')[0])
+    if (tab) tab.location = target.href
+    else window.open(target.href, '_blank')
   } catch (error) {
     tab?.close()
     throw error
   }
 }
 
-function ServiceTile({ icon, title, text, action, url, onError, onStarted }) {
+// `page` opens another page of the same service, such as the editor's
+// design page.
+function ServiceTile({ icon, title, text, action, page = '', url, onError, onStarted }) {
   const [starting, setStarting] = useState(false)
   const launch = async () => {
     setStarting(true)
-    try { await openService(action); onStarted() } catch (error) { onError(error.message) } finally { setStarting(false) }
+    try { await openService(action, page); onStarted() } catch (error) { onError(error.message) } finally { setStarting(false) }
   }
+  const shown = url && new URL(page, url).href
   return <button class="home-tile" onClick={launch} disabled={starting}>
     <span class="home-tile-icon"><HomeIcon name={icon} size={22} /></span>
-    <span class="home-tile-body"><strong>{title}</strong><span>{starting ? 'Starting…' : url ? url.replace(/^https?:\/\//, '') : text}</span></span>
+    <span class="home-tile-body"><strong>{title}</strong><span>{starting ? 'Starting…' : shown ? shown.replace(/^https?:\/\//, '') : text}</span></span>
     <HomeIcon name="external" size={16} />
   </button>
 }
@@ -335,6 +340,7 @@ export function Home() {
         <h2>Write and learn</h2>
         <div class="home-tiles">
           <ServiceTile icon="editor" title="Visual editor" text="Forms and a live preview; saves into the file and keeps a backup." action="editor" url={info.services.editor} onError={setError} onStarted={load} />
+          <ServiceTile icon="look" title="Theme editor" text="Try and fine-tune themes and palettes on a sample deck; install more." action="editor" page="design.html" url={info.services.editor} onError={setError} onStarted={load} />
           <ServiceTile icon="guides" title="Guides" text="How to write slides, layouts, presenting, sharing and more." action="docs" url={info.services.docs} onError={setError} onStarted={load} />
         </div>
       </section>

package/src/layouts/layoutApi.jsx

@@ -62,8 +62,16 @@ export function extractContent(markdown, { headingLevels = [], paragraph = false
 
 // An SVG picture that uses the theme's colour variables is drawn inline, so it
 // follows the theme, palette and light or dark. The build lists them by the
-// path the deck uses.
-export const themedSvg = src => themedSvgs[src] ?? themedSvgs[String(src ?? '').split(/[?#]/)[0]]
+// path the deck uses; an SVG data URL carries its drawing itself.
+export const themedSvg = src => themedSvgs[src] ?? themedSvgs[String(src ?? '').split(/[?#]/)[0]] ?? themedDataSvg(src)
+
+function themedDataSvg(src) {
+  const match = /^data:image\/svg\+xml(;base64)?,(.*)$/s.exec(String(src ?? ''))
+  if (!match) return null
+  let markup
+  try { markup = match[1] ? atob(match[2]) : decodeURIComponent(match[2]) } catch { return null }
+  return /var\(--/.test(markup) && /^\s*<svg\b/.test(markup) ? markup : null
+}
 
 const attribute = (tag, name) => tag.match(new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, 'i'))?.slice(1).find(v => v != null)
 

package/src/runtime/themeLoader.js

@@ -1,6 +1,7 @@
 import baseCSS from '../../assets/base.css?inline'
 import { themes, palettes } from 'virtual:mdeck-extensions'
 import { buildAppearance } from '../extensions/appearance.js'
+import { movedHint } from '../extensions/moved.js'
 
 const SELF_CONTAINED = typeof __MDECK_SELF_CONTAINED__ !== 'undefined'
   && __MDECK_SELF_CONTAINED__
@@ -48,8 +49,10 @@ function syncThemeFonts(urls) {
 }
 
 export async function loadTheme({ theme = 'neue', palette, appearance, params = {}, meta = {} } = {}) {
-  const entry = themeEntry(theme)
-  if (!entry) throw new Error(`Unknown theme: "${theme}". Available: ${THEME_NAMES.join(', ')}`)
+  // A deck without a theme gets neue, or the first installed theme when neue
+  // was removed.
+  const entry = themeEntry(theme) ?? (theme === 'neue' && THEME_NAMES.length ? themeEntry(THEME_NAMES[0]) : null)
+  if (!entry) throw new Error(movedHint('theme', theme) ?? `Unknown theme: "${theme}". Available: ${THEME_NAMES.join(', ') || 'none; install one with mdeck themes install'}`)
 
   const styles = await entry.load()
   const look = buildAppearance({

package/assets/extensions/palettes/brand/extension.toml

@@ -1,29 +0,0 @@
-schema = 1
-kind = "palette"
-id = "brand"
-title = "FHNW"
-description = "The FHNW corporate colours: black, white and FHNW yellow."
-# Only for the fhnw theme: its corporate colours.
-theme = "fhnw"
-
-[light]
-"--bg" = "#ffffff"
-"--surface" = "#f1f1ee"
-"--ink" = "#000000"
-"--ink-soft" = "#262626"
-"--muted" = "#6e6e6e"
-"--rule" = "#deded9"
-"--accent" = "#fde70e"
-"--accent-2" = "#000000"
-"--on-accent" = "#000000"
-
-[dark]
-"--bg" = "#000000"
-"--surface" = "#1c1c1c"
-"--ink" = "#ffffff"
-"--ink-soft" = "#dcdcdc"
-"--muted" = "#9a9a9a"
-"--rule" = "#333333"
-"--accent" = "#fde70e"
-"--accent-2" = "#ffffff"
-"--on-accent" = "#000000"

package/assets/extensions/palettes/cobalt/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "cobalt"
-title = "Cobalt"
-description = "Strong ultramarine on white, with vivid orange; bold and clear."
-
-[light]
-"--bg" = "#ffffff"
-"--surface" = "#eef1fb"
-"--ink" = "#0c1033"
-"--ink-soft" = "#2a2f55"
-"--muted" = "#5b6080"
-"--rule" = "#d5dbf0"
-"--accent" = "#1f3fd1"
-"--accent-2" = "#e8590c"
-"--on-accent" = "#ffffff"
-
-[dark]
-"--bg" = "#0a1030"
-"--surface" = "#121a44"
-"--ink" = "#eef1ff"
-"--ink-soft" = "#c9cff0"
-"--muted" = "#8e97c4"
-"--rule" = "#212b5e"
-"--accent" = "#6f8cff"
-"--accent-2" = "#ff922b"
-"--on-accent" = "#0a1030"

package/assets/extensions/palettes/ember/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "ember"
-title = "Ember"
-description = "Sand and espresso with a glowing orange."
-
-[light]
-"--bg" = "#fbf6ef"
-"--surface" = "#f1e7da"
-"--ink" = "#2a1a10"
-"--ink-soft" = "#4a3324"
-"--muted" = "#7a6656"
-"--rule" = "#e6d6c3"
-"--accent" = "#c2410c"
-"--accent-2" = "#8f5a3c"
-"--on-accent" = "#ffffff"
-
-[dark]
-"--bg" = "#121005"
-"--surface" = "#1f1e19"
-"--ink" = "#eae0d5"
-"--ink-soft" = "#c6ac8f"
-"--muted" = "#9a8a77"
-"--rule" = "#2b2a29"
-"--accent" = "#eb5e28"
-"--accent-2" = "#c98b6b"
-"--on-accent" = "#0d0a05"

package/assets/extensions/palettes/forest/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "forest"
-title = "Forest"
-description = "Deep green with moss and ochre; calm, with contrast."
-
-[light]
-"--bg" = "#f6f5ef"
-"--surface" = "#e9eadf"
-"--ink" = "#12261c"
-"--ink-soft" = "#2c4436"
-"--muted" = "#5a6c60"
-"--rule" = "#d3d8c8"
-"--accent" = "#2e7d32"
-"--accent-2" = "#9a6b00"
-"--on-accent" = "#ffffff"
-
-[dark]
-"--bg" = "#0e1a14"
-"--surface" = "#16261d"
-"--ink" = "#e9f1e6"
-"--ink-soft" = "#c4d3c0"
-"--muted" = "#8ea493"
-"--rule" = "#24382c"
-"--accent" = "#7bd389"
-"--accent-2" = "#e6c35c"
-"--on-accent" = "#0e1a14"

package/assets/extensions/palettes/graphite/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "graphite"
-title = "Graphite"
-description = "Black and white with a steel-blue accent."
-
-[light]
-"--bg" = "#fbfaf8"
-"--surface" = "#efeeeb"
-"--ink" = "#141414"
-"--ink-soft" = "#3a3a3a"
-"--muted" = "#6a6a6a"
-"--rule" = "#d9d8d4"
-"--accent" = "#3d5a73"
-"--accent-2" = "#8a6d3b"
-"--on-accent" = "#ffffff"
-
-[dark]
-"--bg" = "#141414"
-"--surface" = "#1f1f1f"
-"--ink" = "#f2f2f0"
-"--ink-soft" = "#cfcfcc"
-"--muted" = "#8e8e8b"
-"--rule" = "#2f2f2f"
-"--accent" = "#9fc2e0"
-"--accent-2" = "#d9b878"
-"--on-accent" = "#141414"

package/assets/extensions/palettes/pastel/extension.toml

@@ -1,30 +0,0 @@
-schema = 1
-kind = "palette"
-id = "pastel"
-title = "Pastel"
-description = "Soft pastels in the Catppuccin style: Latte by day, Mocha by night, mauve and peach."
-
-# Catppuccin Latte; the peach and the muted grey are a shade darker so they
-# can be read on the base.
-[light]
-"--bg" = "#eff1f5"
-"--surface" = "#e6e9ef"
-"--ink" = "#4c4f69"
-"--ink-soft" = "#5c5f77"
-"--muted" = "#676a80"
-"--rule" = "#ccd0da"
-"--accent" = "#8839ef"
-"--accent-2" = "#dc5c0c"
-"--on-accent" = "#eff1f5"
-
-# Catppuccin Mocha.
-[dark]
-"--bg" = "#1e1e2e"
-"--surface" = "#313244"
-"--ink" = "#cdd6f4"
-"--ink-soft" = "#bac2de"
-"--muted" = "#a6adc8"
-"--rule" = "#45475a"
-"--accent" = "#cba6f7"
-"--accent-2" = "#fab387"
-"--on-accent" = "#1e1e2e"

package/assets/extensions/palettes/phosphor/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "phosphor"
-title = "Phosphor"
-description = "A terminal screen: near-black with phosphor green and amber; in light, a printout on paper."
-
-[light]
-"--bg" = "#fbfbf7"
-"--surface" = "#eeefe8"
-"--ink" = "#141714"
-"--ink-soft" = "#2f362f"
-"--muted" = "#5c665c"
-"--rule" = "#d6dad0"
-"--accent" = "#16803a"
-"--accent-2" = "#a05a00"
-"--on-accent" = "#ffffff"
-
-[dark]
-"--bg" = "#050805"
-"--surface" = "#0e160f"
-"--ink" = "#b6ffc4"
-"--ink-soft" = "#86e29a"
-"--muted" = "#5c9e6a"
-"--rule" = "#1a2e1d"
-"--accent" = "#39ff6e"
-"--accent-2" = "#ffb000"
-"--on-accent" = "#050805"

package/assets/extensions/palettes/terra/extension.toml

@@ -1,27 +0,0 @@
-schema = 1
-kind = "palette"
-id = "terra"
-title = "Terra"
-description = "Cream, deep navy and brick red; warm and grounded."
-
-[light]
-"--bg" = "#fdf0d5"
-"--surface" = "#f1e3c3"
-"--ink" = "#002b42"
-"--ink-soft" = "#12425c"
-"--muted" = "#5a6870"
-"--rule" = "#e3cfa3"
-"--accent" = "#b3121d"
-"--accent-2" = "#c25e00"
-"--on-accent" = "#fff7e6"
-
-[dark]
-"--bg" = "#001f30"
-"--surface" = "#062c42"
-"--ink" = "#fdf0d5"
-"--ink-soft" = "#e8d9b8"
-"--muted" = "#9fb0b8"
-"--rule" = "#10405a"
-"--accent" = "#ff6b5b"
-"--accent-2" = "#ffb347"
-"--on-accent" = "#001f30"