@morphemecms/cms 0.0.0-stage → 0.1.0

package/site/site.ts

@@ -0,0 +1,76 @@
+// Name, title, phone, email, address and CVR number: contact.json; the texts of "Book en tid": booking.json (the calendar
+// is the app Calendly's, src/apps/calendly/); the menus: menu.json and mobile-menu.json; the shared texts of the other blocks: their shared.ts, with those saved in
+// blocks.json over them (`blockTexts`).
+// The site's owner edits them in the editor (/editor/); what the editor does not edit is the site's config
+// (src/site/config.ts).
+import contact from '@data/contact.json';
+import booking from '@data/booking.json';
+import menu from '@data/menu.json';
+import mobileMenu from '@data/mobile-menu.json';
+import blocks from '@data/blocks.json';
+import standardPages from '@data/standard-pages.json';
+import { config } from '@site/config';
+import { sharedTexts, type SharedTexts } from '@morphemecms/cms/src/shared';
+import { standardShared } from '@morphemecms/cms/src/standard/sharedTexts';
+
+// The number with its country code: +45 when it has none (a number in Denmark, saved without it), else
+// its own ("+46 70 12 34 56", picked in the editor).
+const phoneIntl = `${contact.phone.trim().startsWith('+') ? '+' : '+45'}${contact.phone.replace(/\D/g, '')}`;
+// The CVR number, when it is filled in ("Virksomheden" › "Kontakt").
+const { cvr = '' } = contact as typeof contact & { cvr?: string };
+
+export const site = {
+  name: contact.name,
+  role: contact.role,
+  /** The site's own address, https://<domain> (config.ts). */
+  url: `https://${config.domain}`,
+  /** The site's language (config.ts, BCP 47: "da-DK"). */
+  locale: config.locale,
+  description: config.siteDescription,
+  phone: contact.phone,
+  phoneHref: `tel:${phoneIntl}`,
+  /** For structured data: the country code and the digits. */
+  phoneIntl,
+  email: contact.email,
+  address: { street: contact.street, city: contact.city },
+  /** The CVR number, or empty: at the bottom of every page (the theme's Footer.astro) and in the structured data. */
+  cvr,
+  mapsUrl: `https://www.google.com/maps/search/?api=1&query=${`${contact.street}, ${contact.city}`.replace(/ /g, '+')}`,
+  bookingPath: config.booking.path,
+  /** The pages a booking or an order ends on (config.ts): no action bar there. */
+  thanks: config.booking.thanks,
+  /** The page about the owner, or '' (config.ts). */
+  aboutPath: config.aboutPath,
+  /** The block after every blog post, by its type, or '' (config.ts). */
+  postEnd: config.postEnd,
+  /** The page chosen as the contact page ("Indstillinger" › "Udseende" › "Standardsider", standard-pages.json). */
+  contactPath: standardPages.contact,
+  /** The shared texts of "Book en tid" (an app's booking block). */
+  booking: { heading: booking.heading, text: booking.text },
+  /** The labels of the buttons "Book en tid" and "Ring" (the number comes after). */
+  labels: { book: booking.book, call: booking.call },
+  /** The owner's picture (config.ts), or '' when the site has none. */
+  portrait: config.picture?.src ?? '',
+  portraitAlt: config.picture?.alt ?? '',
+};
+
+// Primary navigation (menu.json, "Hovedmenu"). Labels, URLs and sub-items started out as the old site's menu.
+export type NavItem = { label: string; href: string; children?: { label: string; href: string }[] };
+export const nav: NavItem[] = menu.items;
+/** Whether the header has the menu and its button ("Aktiveret" under "Hovedmenu"). */
+export const navShown = menu.enabled !== false;
+/** The links in the bar under the header on a phone (mobile-menu.json, "Mobilmenu"); none when it is turned off. */
+export const mobileNav: { label: string; href: string }[] = mobileMenu.enabled ? mobileMenu.items : [];
+// Sub-items in alphabetical order (Danish: æ, ø, å last), in both the desktop and the mobile menu.
+for (const item of nav) item.children?.sort((a, b) => a.label.localeCompare(b.label, 'da'));
+
+/** The texts every copy of a block has ("Blokke" in the editor), with {…} for what differs, by
+ * the block's type: those written in its shared.ts, with the saved ones (blocks.json) over them. The
+ * standard blocks' first, so an app's block (src/apps/<app>/blocks/) by the same name has its own. */
+export const blockTexts = sharedTexts(
+  {
+    ...standardShared,
+    ...import.meta.glob<SharedTexts>('/src/apps/*/blocks/*/shared.ts', { eager: true, import: 'default' }),
+  },
+  blocks,
+);

package/site/siteConfig.d.mts

@@ -0,0 +1 @@
+export const config: import("./defineSite.mjs").SiteConfig;

package/site/siteConfig.mjs

@@ -0,0 +1,8 @@
+// The site's settings (src/site/config.ts, `@site/config`) for this package's modules that also run outside Vite, where
+// @site is no alias (astro.mjs and the scripts): loaded from the site's root, the working directory, as Node loads
+// TypeScript. Its imports must be ones Node can follow (defineSite.mjs, not @site).
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/** @type {{ config: import('./defineSite.mjs').SiteConfig }} */
+export const { config } = await import(/* @vite-ignore */ pathToFileURL(join(process.cwd(), 'src/site/config.ts')).href);

package/site/siteCsp.d.mts

@@ -0,0 +1,10 @@
+/** What the site's installed apps load from elsewhere, and the addresses allowed in the editor.
+ * @returns {import('../lib/csp.mjs').Sources[]} */
+export function siteSources(): import("../lib/csp.mjs").Sources[];
+/** What is wrong with the addresses allowed in the editor (src/data/csp.json): not JSON, or not written as an app's
+ * csp.json must be (npm run check:content). */
+export function allowedCspProblems(): string[];
+/** What is wrong with what the apps (all of them, installed or not) say they load from elsewhere: a csp.json not
+ * written as it must be, or an address the app's code on the site loads from that its csp.json does not have (npm run
+ * check:content). */
+export function appCspProblems(): string[];

package/site/siteCsp.mjs

@@ -0,0 +1,75 @@
+// What this site's pages may load from elsewhere, besides what the editor's package allows on every site (the
+// videos, packages/editor/lib/csp.mjs, which writes the policy into the pages): what each installed app needs
+// (src/apps/<app>/csp.json, src/data/apps.json), Google Analytics, Google Ads and Google Tag Manager too, which load
+// Google's tag once the visitor has said yes (src/scripts/tracking.ts), and the addresses allowed in the editor after
+// the policy stopped them (src/data/csp.json, config.csp: the app "Cookiescanner"'s "Blokeret adresse").
+// Read by the build (packages/editor/astro.mjs) and by npm run check:content (appCspProblems), so no TypeScript here.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { allows, sourcesProblems } from '../lib/csp.mjs';
+
+// The site's src/, from its root (the working directory).
+const SRC = pathToFileURL(`${process.cwd()}/src/`);
+
+const json = (file) => JSON.parse(readFileSync(new URL(file, SRC), 'utf8'));
+
+const appSources = (app) => {
+  const file = new URL(`apps/${app}/csp.json`, SRC);
+  return existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
+};
+
+// The addresses allowed in the editor (config.csp), as an app's csp.json.
+const ALLOWED = new URL('data/csp.json', SRC);
+const allowedSources = () => (existsSync(ALLOWED) ? JSON.parse(readFileSync(ALLOWED, 'utf8')) : {});
+
+/** What the site's installed apps load from elsewhere, and the addresses allowed in the editor.
+ * @returns {import('../lib/csp.mjs').Sources[]} */
+export function siteSources() {
+  return [...(json('data/apps.json').installed ?? []).map(appSources), allowedSources()];
+}
+
+/** What is wrong with the addresses allowed in the editor (src/data/csp.json): not JSON, or not written as an app's
+ * csp.json must be (npm run check:content). */
+export function allowedCspProblems() {
+  try {
+    return sourcesProblems(allowedSources(), 'src/data/csp.json');
+  } catch {
+    return ['src/data/csp.json: er ikke JSON.'];
+  }
+}
+
+// A line of code that loads from an address (not a link to it): a script's or a frame's src, fetch, import …
+const LOADS = /\bsrc\b|\bsrcset\b|\bfetch\(|\bimport\(|\bsendBeacon\(|\bEventSource\(|\bWebSocket\(|\bXMLHttpRequest\b/;
+const ADDRESS = /https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)+/gi;
+// An app's files that do not run in a browser on the site: its part of the Worker and its step after the build
+// (packages/editor/lib/apps.mjs).
+const OFF_SITE = new Set(['worker.js', 'build.mjs']);
+
+/** What is wrong with what the apps (all of them, installed or not) say they load from elsewhere: a csp.json not
+ * written as it must be, or an address the app's code on the site loads from that its csp.json does not have (npm run
+ * check:content). */
+export function appCspProblems() {
+  const apps = new URL('apps/', SRC);
+  if (!existsSync(apps)) return [];
+  return readdirSync(apps, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .flatMap(({ name: app }) => {
+      const dir = `src/apps/${app}`;
+      let sources;
+      try {
+        sources = appSources(app);
+      } catch {
+        return [`${dir}/csp.json: er ikke JSON.`];
+      }
+      const problems = sourcesProblems(sources, `${dir}/csp.json`);
+      if (problems.length) return problems;
+      const missing = new Set();
+      for (const file of readdirSync(new URL(`${app}/`, apps), { recursive: true, encoding: 'utf8' }))
+        if (/\.(tsx?|mjs|js|astro)$/.test(file) && !OFF_SITE.has(file))
+          for (const line of readFileSync(new URL(`${app}/${file}`, apps), 'utf8').split('\n'))
+            if (LOADS.test(line)) for (const [url] of line.matchAll(ADDRESS)) if (!allows(sources, url)) missing.add(new URL(url).origin);
+      return [...missing].map(
+        (origin) => `${dir}: henter fra ${origin}, men csp.json har det ikke, så sidernes Content-Security-Policy stopper det.`,
+      );
+    });
+}

package/site/siteModules.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Runs `use` with a loader of the site's modules (`@site/collections`, `/src/apps/<id>/index.ts`), then closes it.
+ * @template T
+ * @param {(load: (path: string) => Promise<any>) => Promise<T>} use
+ * @returns {Promise<T>}
+ */
+export function withSiteModules<T>(use: (load: (path: string) => Promise<any>) => Promise<T>): Promise<T>;

package/site/siteModules.mjs

@@ -0,0 +1,27 @@
+// The site's TypeScript loaded with Vite, as the build has it (its @site, @theme and apps), for the scripts that run
+// outside the build: Node itself loads no TypeScript from a package in node_modules, and follows no @site.
+import { createServer } from 'vite';
+import { appFoldersPlugin } from '../lib/apps.mjs';
+import { aliases, themePlugin } from './theme.mjs';
+
+/**
+ * Runs `use` with a loader of the site's modules (`@site/collections`, `/src/apps/<id>/index.ts`), then closes it.
+ * @template T
+ * @param {(load: (path: string) => Promise<any>) => Promise<T>} use
+ * @returns {Promise<T>}
+ */
+export async function withSiteModules(use) {
+  const server = await createServer({
+    configFile: false,
+    logLevel: 'error',
+    appType: 'custom',
+    plugins: [themePlugin(), appFoldersPlugin(`${process.cwd()}/`)],
+    resolve: { alias: aliases() },
+    server: { middlewareMode: true, hmr: false, ws: false },
+  });
+  try {
+    return await use((path) => server.ssrLoadModule(path));
+  } finally {
+    await server.close();
+  }
+}

package/site/standardPages.ts

@@ -0,0 +1,59 @@
+// The blog page, the 404 page and the cookie policy: the pages chosen under "Indstillinger" › "Udseende" › "Standardsider"
+// (src/data/standard-pages.json, packages/editor/defaults/standardPages.ts), read for the theme's templates/Blog.astro (at /blog/) and
+// templates/NotFound.astro (the page for an address that does not exist): the page, its heading (the H1 at the top of
+// its text, else its title), its introduction (the first paragraph of the text before its first heading or block) and the
+// rest, shown, as sections: text ("text": a heading and Markdown) and each block by its type, with its fields; and where
+// the cookie banner's "Læs mere" goes (cookiesHref).
+import { slug } from 'github-slugger';
+import paths from '@data/standard-pages.json';
+import { getPages, type Page } from './content';
+import { pageH1, partsOfMarkdown, sectionsFromParts } from '@morphemecms/cms/src/sections.mjs';
+
+/** The addresses of the pages that are the front page, the blog page, the 404 page, the contact page, the privacy policy
+ * and the cookie policy (their own addresses: the front page is shown at /, the blog page at /blog/, the 404 page at none,
+ * the others at their own). */
+export const standardPaths: {
+  front: string;
+  blog: string;
+  notFound: string;
+  contact: string;
+  privacy: string;
+  cookies: string;
+} = paths;
+
+export type PageSection = { type: string; hidden?: boolean; heading?: string; body?: string } & Record<string, any>;
+export type StandardPageView = { page: Page; heading: string; intro?: string; sections: PageSection[] };
+
+async function read(key: 'blog' | 'notFound'): Promise<StandardPageView> {
+  const page = (await getPages({ previews: false })).find((p) => p.data.path === standardPaths[key]);
+  if (!page) throw new Error(`src/data/standard-pages.json: siden ${standardPaths[key]} findes ikke, eller den er en kladde.`);
+  const sections = (sectionsFromParts(partsOfMarkdown(page.body ?? '')) as PageSection[]).filter((s) => !s.hidden);
+  // The introduction: the first paragraph of a text without a heading at the top; the rest of that text stays a section.
+  let intro: string | undefined;
+  const first = sections[0];
+  if (first?.type === 'text' && !first.heading && first.body) {
+    const [paragraph, ...rest] = first.body.trim().split(/\n\s*\n/);
+    intro = paragraph.trim();
+    if (rest.length) first.body = rest.join('\n\n');
+    else sections.shift();
+  }
+  return { page, heading: pageH1(page.body).heading || page.data.title, intro, sections };
+}
+
+/** The blog page, shown at /blog/. */
+export const blogPage = () => read('blog');
+/** The 404 page, shown for an address that does not exist. */
+export const notFoundPage = () => read('notFound');
+
+/** The addresses the standard pages are shown at, by their own: the front page's at /, the blog page's at /blog/. */
+export const shownAt = (path: string) => (path === standardPaths.front ? '/' : path === standardPaths.blog ? '/blog/' : path);
+
+/** Where the cookie banner's "Læs mere" goes: the cookie policy, and when it is the privacy policy, its first heading about
+ * cookies (its id, as Astro gives it: github-slugger), if it has one. */
+export async function cookiesHref(): Promise<string> {
+  const path = standardPaths.cookies;
+  if (path !== standardPaths.privacy) return path;
+  const page = (await getPages({ previews: false })).find((p) => p.data.path === path);
+  const heading = (page?.body ?? '').match(/^#{2,6}\s+(.*cookie.*?)\s*#*\s*$/im)?.[1];
+  return heading ? `${path}#${slug(heading)}` : path;
+}

package/site/testimonials.ts

@@ -0,0 +1,48 @@
+// The site's client testimonials: one JSON file per testimonial in src/data/testimonials/, edited in the
+// editor (/editor/, "Udtalelser"). Each has its picture (optional), its tags (`categories`, the same tags as the blog posts,
+// src/data/categories/) and whether it is shown on the front page. `order` is the order on the
+// testimonials page and the front page (set with the arrows in the editor).
+type TestimonialData = {
+  name: string;
+  image?: string;
+  context?: string;
+  /** Paragraphs separated by a blank line. */
+  quote: string;
+  categories?: string[];
+  frontPage: boolean;
+  order: number;
+};
+
+export type Testimonial = {
+  /** The file name, e.g. "marie-louise-eriksen" (a "Hero" picks its quote by it). */
+  slug: string;
+  name: string;
+  /** Its picture (optional), by the name. */
+  image?: string;
+  context?: string;
+  /** One string per paragraph. */
+  quote: string[];
+  /** Its tags (slugs in src/data/categories/), e.g. ["stress"]. */
+  categories: string[];
+  frontPage: boolean;
+};
+
+const files = import.meta.glob<TestimonialData>('@data/testimonials/*.json', { eager: true, import: 'default' });
+
+export const testimonials: Testimonial[] = Object.entries(files)
+  .map(([file, t]) => ({ file, t }))
+  .sort((a, b) => a.t.order - b.t.order || a.file.localeCompare(b.file))
+  .map(({ file, t }) => ({
+    slug: file.replace(/^.*\/|\.json$/g, ''),
+    name: t.name,
+    image: t.image || undefined,
+    context: t.context || undefined,
+    quote: t.quote
+      .split(/\n\s*\n/)
+      .map((p) => p.trim())
+      .filter(Boolean),
+    categories: t.categories ?? [],
+    frontPage: t.frontPage,
+  }));
+
+export const testimonialsPath = '/udtalelser/';

package/site/text.ts

@@ -0,0 +1,43 @@
+// Text from the pages, shared by the site (content.ts) and the editor's previews of the blocks
+// (a theme's editor/previews.tsx), which has no content collections. A word in colour (<span class="color-accent">,
+// @morphemecms/cms/lib/text-colors.mjs) is its text.
+import { withoutColors } from '@morphemecms/cms/lib/text-colors.mjs';
+import { config } from '@site/config';
+
+// A title can end in a word for search engines after a dash (`titleEnd` in the site's config, " – København"): kept
+// in <title>, left out of the heading.
+const escaped = config.titleEnd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const END = config.titleEnd ? new RegExp(`\\s+[–-]\\s+${escaped}$`) : null;
+export const displayTitle = (title: string) => (END ? title.replace(END, '') : title);
+
+// A page's own opening words: the first sentences of the body as plain text.
+export function openingText(markdown: string | undefined, max = 240) {
+  const text = (markdown ?? '')
+    .split(/\n{2,}/)
+    .filter((p) => !/^\s*(#|!\[|<|\||-|\*\*?[^*]+:\*\*?\s*$)/.test(p))
+    .map((p) =>
+      withoutColors(p)
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, '')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/[*_`>]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim(),
+    )
+    .filter((p) => p.length > 40)
+    .join(' ');
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max);
+  const end = Math.max(cut.lastIndexOf('. '), cut.lastIndexOf('? '), cut.lastIndexOf('! '));
+  return end > 80 ? cut.slice(0, end + 1) : cut.replace(/\s+\S*$/, '') + '...';
+}
+
+// A short text written as Markdown (an introduction: bold, italic, links; packages/editor/lib/inline.ts) as plain
+// text, for a meta description.
+export const plainText = (markdown: string) =>
+  withoutColors(markdown)
+    .replace(/!\[[^\]]*\]\([^)]*\)/g, '')
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+    .replace(/\*\*|__|[*`]|\b_|_\b/g, '')
+    .replace(/\\([!-/:-@[-`{-~])/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim();

package/site/theme.d.mts

@@ -0,0 +1,83 @@
+/** The choice of icon pack made under "Indstillinger" › "Udseende" › "Ikonpakker" (src/data/icons.json, `{ "pack": "<id>"
+ * }`), or undefined while none is made (then the theme's is used). */
+export function chosenPack(): any;
+/** The icon pack the site and the editor draw their icons with, by its id (packInUse in packages/editor/site/iconPacks.mjs): the one
+ * chosen, else the theme's ("icons" in its theme.json), else the standard theme's (Material Symbols). Stops with what is
+ * wrong when it is not installed. */
+export function iconPack(theme?: string): any;
+/** The icon packs there are with their licences, from their manifests, for "Licenser" under "Indstillinger" (IconPack
+ * in @morphemecms/cms/lib/licenses.mjs, licensesIntegration in packages/editor/astro.mjs): each pack's id, name, version, who made it,
+ * its licence's name and file (LICENSE in its folder), the theme it came with, whether the site draws with it, and each
+ * set it takes icons from besides its own (`includes`, with its `licenseFile`). packProblems checks the manifests. */
+export function iconPackLicenses(): {
+    inUse: boolean;
+    includes: any;
+    theme?: any;
+    name: any;
+    version: any;
+    author: any;
+    license: any;
+    file: string;
+    id: string;
+}[];
+/** An icon of a theme (the one in use, if none is given) as its file's text: its own (icons/<name>.svg), else its icon
+ * pack's; null when it is Phosphor's own, or neither has it (then it is Phosphor's). For what is drawn outside Vite: the
+ * play button of a video in the text (rehypeVideo, packages/editor/astro.mjs). In Vite, themePlugin puts them in Phosphor's place. */
+export function themeIcon(name: any, theme?: string): string | null;
+/** What is wrong with the choice of motion scheme made under "Udseende" › "Bevægelse" (src/data/motion.json): one that
+ * is not a scheme (lib/motion.ts). */
+export function motionProblems(): string[];
+/** What is wrong with the system's icon packs (packProblems; a theme's own are its themeProblems) and the choice of one:
+ * src/data/icons.json naming one that is not there. */
+export function iconPackProblems(): string[];
+/** What a theme is missing (the standard theme: of THEME_FILES and the look of every standard block, another: of
+ * OWN_FILES), what is wrong in its theme.json (name, version, author, icon), a block of its own (a folder in its
+ * blocks/ that is not the look of a standard block, or with a block's contract in it), a part nothing uses (in a
+ * folder without its View.tsx, a file the standard theme does not have there), and what is wrong with its own icons
+ * (iconProblems). */
+export function themeProblems(theme: any): string[];
+/** The file `@site/<file>` is: the site's src/site/<file>, else the package's defaults/<file>, with or without its
+ * extension (`@site/editor`, as TypeScript writes it), or null. */
+export function siteFile(file: any): string | null;
+/** The folder of the theme in use, under src/themes/. */
+export function activeTheme(): string;
+/** @theme and @site as a Vite plugin: `@site/<file>` is the site's own part, else the package's standard one
+ * (siteFile), and `@theme/<file>` is the theme in use's file, else the standard theme's. A glob
+ * (`import.meta.glob('@theme/blocks/*\/View.tsx')`) is the theme in use's; whoever globs puts the standard
+ * theme's under it (packages/editor/src/standard/siteLooks.ts, packages/editor/src/standard/themeBlocks.ts).
+ * And the theme's icons (themeIcons: its own, else the icon pack in use's, iconPack) in Phosphor's place, on the site
+ * and in the editor alike: an import of `@phosphor-icons/react` is Phosphor's with the theme's icons in place of its own
+ * (reactIcons), and an SVG file of Phosphor's as text (`?raw`) the theme's, when it has one. An icon neither has is
+ * Phosphor's (check:content stops at a pack without one the site or the editor draws: packProblems). With Phosphor's
+ * pack and no icons of its own nothing is changed. The pack is read when the site is built, so a new choice
+ * (src/data/icons.json) or theme is in the site and the editor after the next build. */
+export function themePlugin(): {
+    name: string;
+    enforce: string;
+    config: () => {
+        optimizeDeps: {
+            include: string[];
+        };
+    } | {
+        optimizeDeps?: undefined;
+    };
+    resolveId(source: any, importer: any): string | null;
+    load(id: any): string | null;
+};
+/** What a block is missing to be drawn from its view (packages/editor/src/standard/view.tsx): a standard block's
+ * contract its view.ts and load.ts, an app's block (src/apps/<app>/blocks/<type>/) those and its View.tsx; and the
+ * files of how a block looked before (Site.astro, draw.tsx), which nothing uses now. */
+export function blockProblems(): string[];
+/** The theme every theme builds on, Material (this package's theme/, id 'saturn'): it has all of THEME_FILES and the look of every
+ * standard block. */
+export const STANDARD_THEME: "saturn";
+export function themeFolder(theme: any): string;
+export const THEME_FILES: string[];
+export function installedThemes(): string[];
+/** What every theme has itself. */
+export const OWN_FILES: string[];
+export function aliases(): {
+    '@data': string;
+    '@saturn': string;
+    '@icons': string;
+};