@stati/core 1.29.2 → 2.0.0

package/dist/core/template-render.js

@@ -0,0 +1,444 @@
+/**
+ * Template composition: `stati.include()`, `stati.layout()` and `stati.body`, rendered on demand
+ * inside a per-page render scope that records every template and name lookup for the ISG cache.
+ * @module core/template-render
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { readFileSync } from 'node:fs';
+import { join, posix, relative } from 'node:path';
+import { EtaParseError } from 'eta';
+import { lookupFolders, parseTemplateName, templateFolderOf, } from './template-index.js';
+import { createValidatingContextProxy, parseEtaError, TemplateError, TemplateUsageError, } from './utils/index.js';
+/**
+ * Templates nested deeper than this are an error. It stops a component that includes itself
+ * with props from recursing forever; real component trees are far shallower.
+ */
+export const MAX_TEMPLATE_DEPTH = 100;
+/** Marks a render whose context has no `body` key: the page's layout and the Open Graph template */
+const NO_BODY = Symbol('no body');
+/**
+ * The template that failed while rendering, per error, for production log messages: Eta adds
+ * the template path to messages only in its debug mode.
+ */
+const failingTemplates = new WeakMap();
+/** Errors for `await` in a template that renders synchronously; such an include renders empty */
+const awaitErrors = new WeakSet();
+/**
+ * Everything one page's render shares: the templates and lookups it records, the stack of
+ * templates being rendered (for cycles), and the cache of includes rendered without props.
+ */
+export class RenderScope {
+    page;
+    eta;
+    index;
+    logger;
+    development;
+    /** The page's Markdown file, relative to the source directory */
+    pageFile;
+    /** The page's folder, relative to the source directory, where looked-up names start */
+    pageFolder;
+    /** Template files the page rendered, relative to the source directory, in order of first use */
+    templates = new Set();
+    /** Name lookups the page made, by folder and name */
+    lookups = new Map();
+    /** Templates rendered, counting a template each time it renders */
+    renders = 0;
+    /** Includes served from the page's cache instead of rendering again */
+    includeCacheHits = 0;
+    stack = [];
+    includeCache = new Map();
+    constructor(options) {
+        this.page = options.page;
+        this.eta = options.eta;
+        this.index = options.index;
+        this.logger = options.logger;
+        this.development = options.development;
+        this.pageFile = relative(options.index.srcDir, options.page.sourcePath).replace(/\\/g, '/');
+        this.pageFolder = templateFolderOf(this.pageFile);
+    }
+    /** Records a lookup for the page's cache entry. */
+    record(lookup) {
+        this.lookups.set(`${lookup.from ?? ''}\0${lookup.name}`, lookup);
+    }
+    /**
+     * The rendered template files as absolute POSIX paths, the given layout first.
+     *
+     * @param layout - The page's layout, relative to the source directory
+     */
+    templateFiles(layout) {
+        const files = [...this.templates];
+        if (layout !== null && this.templates.has(layout)) {
+            files.splice(files.indexOf(layout), 1);
+            files.unshift(layout);
+        }
+        const srcDir = this.index.srcDir.replace(/\\/g, '/');
+        return files.map((file) => posix.join(srcDir, file));
+    }
+    /** A template file for messages: its path from the project directory */
+    display(file) {
+        if (file === null) {
+            return 'the built-in Open Graph template';
+        }
+        return this.displayPath(join(this.index.srcDir, file)) || file;
+    }
+    /** An absolute path for messages: its path from the project directory */
+    displayPath(absolutePath) {
+        return relative(process.cwd(), absolutePath).replace(/\\/g, '/');
+    }
+    /**
+     * Renders a template and the parents it names with `stati.layout()`, asynchronously: the
+     * page's layout and the Open Graph template, which may use `await`.
+     *
+     * @param base - The values of the render
+     * @param template - The template file, relative to the source directory, or the source of a
+     *   template without a file
+     */
+    async renderAsync(base, template) {
+        const chain = [];
+        let frame = 'file' in template
+            ? { file: template.file, props: undefined, body: NO_BODY }
+            : { file: null, source: template.source, props: undefined, body: NO_BODY };
+        let output = '';
+        try {
+            while (frame) {
+                this.enter(frame.file, chain);
+                const slot = { target: null, calls: 0, closed: false };
+                const context = this.createContext(base, frame, slot);
+                try {
+                    const result = frame.file !== null
+                        ? await this.eta.renderAsync(frame.file, context)
+                        : await this.eta.renderStringAsync(frame.source, context);
+                    output = toOutput(result);
+                }
+                catch (error) {
+                    throw this.describeFailure(error, frame, false);
+                }
+                finally {
+                    slot.closed = true;
+                }
+                frame = slot.target
+                    ? { file: slot.target.file, props: slot.target.props, body: output }
+                    : null;
+            }
+        }
+        finally {
+            this.leave(chain);
+        }
+        return output;
+    }
+    /**
+     * Renders a template and the parents it names with `stati.layout()`, synchronously, for
+     * `stati.include()`.
+     */
+    renderSync(base, first) {
+        const chain = [];
+        let frame = first;
+        let output = '';
+        try {
+            while (frame) {
+                this.enter(frame.file, chain);
+                const slot = { target: null, calls: 0, closed: false };
+                const context = this.createContext(base, frame, slot);
+                try {
+                    output = toOutput(this.eta.render(frame.file, context));
+                }
+                catch (error) {
+                    throw this.describeFailure(error, frame, true);
+                }
+                finally {
+                    slot.closed = true;
+                }
+                frame = slot.target
+                    ? { file: slot.target.file, props: slot.target.props, body: output }
+                    : null;
+            }
+        }
+        finally {
+            this.leave(chain);
+        }
+        return output;
+    }
+    enter(file, chain) {
+        this.renders++;
+        if (file === null) {
+            return;
+        }
+        this.templates.add(file);
+        this.stack.push(file);
+        chain.push(file);
+    }
+    leave(chain) {
+        this.stack.splice(this.stack.length - chain.length, chain.length);
+    }
+    createContext(base, frame, slot) {
+        const context = {
+            ...base.values,
+            props: frame.props,
+            include: this.createInclude(base, frame.file),
+            layout: this.createLayout(slot, frame.file),
+        };
+        if (frame.body !== NO_BODY) {
+            context.body = frame.body;
+        }
+        return createValidatingContextProxy(context);
+    }
+    createInclude(base, callerFile) {
+        const include = ((name, props, body) => this.include(base, callerFile, name, props, body));
+        include.has = (name) => this.has(callerFile, name);
+        return include;
+    }
+    createLayout(slot, callerFile) {
+        const layout = ((name, props) => {
+            this.setLayout(slot, callerFile, name, props);
+            return '';
+        });
+        layout.has = (name) => this.has(callerFile, name);
+        return layout;
+    }
+    /** `stati.include.has()` and `stati.layout.has()` */
+    has(callerFile, name) {
+        const parsed = parseTemplateName(name, callerFile);
+        if (parsed.kind === 'invalid') {
+            return false;
+        }
+        const { file, lookup } = this.index.resolve(parsed, this.pageFolder);
+        this.record(lookup);
+        return file !== null;
+    }
+    /**
+     * Resolves a name for a call, recording the lookup. Reports invalid and unknown names.
+     *
+     * @returns The template file, or null after reporting the problem
+     */
+    resolveForCall(call, callerFile, name) {
+        const parsed = parseTemplateName(name, callerFile);
+        if (parsed.kind === 'invalid') {
+            this.fail('error', `${call}(${describeName(name)}): the name ${parsed.reason}.`, []);
+            return null;
+        }
+        const { file, lookup } = this.index.resolve(parsed, this.pageFolder);
+        this.record(lookup);
+        if (file === null) {
+            this.reportUnknown(call, name, parsed, callerFile);
+        }
+        return file;
+    }
+    reportUnknown(call, name, parsed, callerFile) {
+        const suggestions = this.index.suggest(parsed, this.pageFolder, callerFile);
+        const tried = parsed.kind === 'lookup'
+            ? lookupFolders(this.pageFolder).map((folder) => this.display(folder === '' ? `${parsed.name}.eta` : `${folder}/${parsed.name}.eta`))
+            : [this.display(`${parsed.path.slice(1)}.eta`)];
+        const didYouMean = suggestions.length > 0
+            ? ` Did you mean ${suggestions.map((suggestion) => `"${suggestion}"`).join(', ')}?`
+            : '';
+        this.fail('error', `${call}(${describeName(name)}): no template at ${tried.join(' or ')}.${didYouMean}`, suggestions.map((suggestion) => `Did you mean "${suggestion}"?`));
+    }
+    /** `stati.include(name, props?, body?)` */
+    include(base, callerFile, name, props, body) {
+        const file = this.resolveForCall('stati.include', callerFile, name);
+        if (file === null) {
+            return '';
+        }
+        const checkedProps = this.checkProps('stati.include', name, props);
+        const checkedBody = this.checkBody(name, body);
+        const cacheable = checkedProps === undefined && checkedBody === undefined;
+        const cacheKey = `${base.id}\0${file}`;
+        if (cacheable) {
+            const cached = this.includeCache.get(cacheKey);
+            if (cached !== undefined) {
+                this.includeCacheHits++;
+                return cached;
+            }
+        }
+        // A template that reaches itself without props renders the same way each time, forever.
+        // With props it may be a recursive component, which only the depth limit stops.
+        if ((cacheable && this.stack.includes(file)) || this.stack.length >= MAX_TEMPLATE_DEPTH) {
+            this.reportCycle('stati.include', file);
+            return '';
+        }
+        let html;
+        try {
+            html = this.renderSync(base, { file, props: checkedProps, body: checkedBody });
+        }
+        catch (error) {
+            if (this.development) {
+                throw error;
+            }
+            return this.logIncludeFailure(file, error);
+        }
+        if (cacheable) {
+            this.includeCache.set(cacheKey, html);
+        }
+        return html;
+    }
+    /** `stati.layout(name, props?)` */
+    setLayout(slot, callerFile, name, props) {
+        const caller = this.display(callerFile);
+        if (slot.closed) {
+            this.fail('warning', `stati.layout(${describeName(name)}) was called after ${caller} finished rendering, so it cannot wrap it. Call stati.layout() while the template renders.`, []);
+            return;
+        }
+        slot.calls++;
+        if (slot.calls > 1) {
+            this.fail('warning', `stati.layout(${describeName(name)}): ${caller} already called stati.layout(), and a template can name one layout. The last call is used.`, ['Call stati.layout() once per template; choose the name with a condition instead']);
+        }
+        const file = this.resolveForCall('stati.layout', callerFile, name);
+        if (file === null) {
+            slot.target = null;
+            return;
+        }
+        if (this.stack.includes(file)) {
+            this.reportCycle('stati.layout', file);
+            slot.target = null;
+            return;
+        }
+        slot.target = { file, props: this.checkProps('stati.layout', name, props) };
+    }
+    checkProps(call, name, props) {
+        if (props === undefined || props === null) {
+            return undefined;
+        }
+        if (typeof props !== 'object' || Array.isArray(props)) {
+            this.fail('warning', `${call}(${describeName(name)}, props): props must be an object, not ${describeType(props)}. The template renders without them.`, [`Pass the values as an object, such as ${call}(${describeName(name)}, { value })`]);
+            return undefined;
+        }
+        return props;
+    }
+    checkBody(name, body) {
+        if (body === undefined || body === null) {
+            return undefined;
+        }
+        if (typeof body !== 'string') {
+            this.fail('warning', `stati.include(${describeName(name)}, props, body): body must be a string of HTML, not ${describeType(body)}. The template renders without it.`, ['Pass HTML as a string, such as the output of another stati.include()']);
+            return undefined;
+        }
+        return body;
+    }
+    reportCycle(call, file) {
+        const chain = [...this.stack, file].map((template) => this.display(template)).join(' → ');
+        const reason = this.stack.length >= MAX_TEMPLATE_DEPTH
+            ? `templates are nested more than ${MAX_TEMPLATE_DEPTH} deep`
+            : `${this.display(file)} is already rendering`;
+        this.fail('error', `${call}(): ${reason}, so the call would never finish: ${chain}. The repeated template is skipped.`, ['Remove the call that leads back to a template that is already rendering']);
+    }
+    /**
+     * Reports a mistake at a call: in development as an error for the overlay (Eta adds the
+     * calling template and line), in production as a log message.
+     */
+    fail(level, message, suggestions) {
+        if (this.development) {
+            throw new TemplateUsageError(message, suggestions);
+        }
+        const text = `${message} (page ${this.page.url})`;
+        if (level === 'error') {
+            this.logger.error(text);
+        }
+        else {
+            this.logger.warning(text);
+        }
+    }
+    /**
+     * Turns a failure while rendering `frame` into the error to throw: compile errors become a
+     * {@link TemplateError} at the template that failed to compile, with a hint for `await` in
+     * a synchronous render, and every error remembers its template for production messages.
+     */
+    describeFailure(error, frame, sync) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        // Eta throws EtaParseError when the template itself fails to compile. Errors from templates
+        // it renders reach here wrapped (EtaRuntimeError) or already described.
+        if (failure instanceof EtaParseError) {
+            const described = this.describeCompileError(failure, frame, sync);
+            if (frame.file !== null)
+                failingTemplates.set(described, frame.file);
+            return described;
+        }
+        if (frame.file !== null && !failingTemplates.has(failure)) {
+            failingTemplates.set(failure, frame.file);
+        }
+        return failure;
+    }
+    describeCompileError(failure, frame, sync) {
+        const filePath = frame.file !== null ? join(this.index.srcDir, frame.file) : undefined;
+        // Eta appends the whole compiled function to syntax errors; the first part is the reason
+        const [reason] = failure.message.split(/\n=+\n/);
+        // An include renders synchronously: a template that compiles as an async function uses await
+        const source = sync && filePath !== undefined ? readTemplate(filePath) : null;
+        if (filePath !== undefined && source !== null && this.compilesAsync(source, filePath)) {
+            const awaitError = new TemplateError(`${this.display(frame.file)} uses await, but templates rendered by stati.include() render synchronously. Move the awaited work into a build hook or into data a helper prepares.`, filePath, lineOf(source, /\bawait\b/), undefined, undefined, ['Templates rendered by stati.include() cannot use await']);
+            awaitErrors.add(awaitError);
+            return awaitError;
+        }
+        const parsed = parseEtaError(new Error(reason ?? failure.message), filePath);
+        return new TemplateError(frame.file !== null ? `${this.display(frame.file)}: ${parsed.message}` : parsed.message, filePath, parsed.line, parsed.column, undefined, parsed.suggestions);
+    }
+    /** Whether a template that failed to compile synchronously compiles as an async function */
+    compilesAsync(source, filePath) {
+        try {
+            this.eta.compile(source, { async: true, filepath: filePath });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    logIncludeFailure(file, error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        const failed = failingTemplates.get(failure) ?? file;
+        const message = failure.message;
+        this.logger.error(`Error rendering ${this.display(failed)} for ${this.page.url}: ${message}`);
+        if (awaitErrors.has(failure)) {
+            return '';
+        }
+        // A comment cannot contain "--", which would let the message end it early
+        return `<!-- Error rendering ${this.display(failed)}: ${message.replace(/-(?=-)/g, '- ')} -->`;
+    }
+}
+/**
+ * The template that was rendering when an error was thrown, relative to the source directory.
+ * Set for errors that left {@link RenderScope.renderAsync}.
+ */
+export function failingTemplateOf(error) {
+    return failingTemplates.get(error);
+}
+/** The render scope of the page being rendered, for code that the template engine calls back. */
+const renderScopeStorage = new AsyncLocalStorage();
+/**
+ * Runs a page's render inside its scope.
+ */
+export function runInRenderScope(scope, render) {
+    return renderScopeStorage.run(scope, render);
+}
+/**
+ * The render scope of the page being rendered, or undefined outside a render.
+ */
+export function getRenderScope() {
+    return renderScopeStorage.getStore();
+}
+function toOutput(result) {
+    if (typeof result === 'string')
+        return result;
+    return result === undefined || result === null ? '' : String(result);
+}
+function describeName(name) {
+    return typeof name === 'string' ? `'${name}'` : describeType(name);
+}
+function describeType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'an array';
+    return typeof value === 'object' ? 'an object' : `a ${typeof value}`;
+}
+function readTemplate(filePath) {
+    try {
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/** The 1-based line of the first match, or undefined */
+function lineOf(source, pattern) {
+    const match = pattern.exec(source);
+    return match ? source.slice(0, match.index).split('\n').length : undefined;
+}

package/dist/core/templates.d.ts

@@ -1,20 +1,33 @@
 import { Eta } from 'eta';
-import type { StatiConfig, PageModel, NavNode, TocEntry, Logger } from '../types/index.js';
+import type { StatiConfig, PageModel, NavNode, TocEntry, Logger, TemplateLookup } from '../types/index.js';
 import type { PageReads } from './collections.js';
 import type { PageImages } from '../images/runtime.js';
 import type { GeneratedOgImage } from '../types/index.js';
+import { TemplateIndex } from './template-index.js';
 /**
  * Result of rendering a page template.
  */
 export interface RenderResult {
     /** The rendered HTML content */
     html: string;
-    /** Number of templates loaded (layout + partials) */
+    /** Number of distinct template files the page rendered */
     templatesLoaded: number;
+    /** Templates rendered, counting a template each time it renders */
+    templateRenders: number;
+    /** Includes served from the page's cache instead of rendering again */
+    includeCacheHits: number;
     /** Open Graph image generated for the page, if any */
     ogImage?: GeneratedOgImage | undefined;
     /** Shared data the render read, which the cache entry records */
     reads: PageReads;
+    /**
+     * Every template file the render used, as absolute POSIX paths, the page's layout first:
+     * the layout, its parents, the templates it included and the Open Graph template. A failed
+     * render lists the templates up to the one that failed.
+     */
+    templates: string[];
+    /** Template names the render looked up, with what each resolved to */
+    templateLookups: TemplateLookup[];
 }
 /**
  * Page-specific state for {@link renderPage}.
@@ -22,21 +35,26 @@ export interface RenderResult {
 export interface RenderPageExtras {
     /** Image state of the page; without it `stati.image()` emits a plain `<img>` */
     images?: PageImages | undefined;
+    /** The build's template index; without it the source directory is read for this page */
+    templateIndex?: TemplateIndex | undefined;
 }
-/**
- * Discovers partials in the hierarchy for a given page path.
- * Scans all parent directories for folders starting with underscore.
- *
- * @param pagePath - The path to the page (relative to srcDir), with `/` or `\` separators
- * @param config - Stati configuration
- * @returns Object mapping partial names to their file paths
- */
-export declare function discoverPartials(pagePath: string, config: StatiConfig): Promise<Record<string, string>>;
 /**
  * Clear the cached template engine. Call this when templates change in dev mode
  * so the next build recompiles them, or when shutting down a dev session.
  */
 export declare function clearTemplateEngineCache(): void;
+/**
+ * Creates the template engine: Eta with `stati` as its data variable and Stati's plugin,
+ * which replaces Eta's own `include()`, `layout()` and `block()` in templates.
+ *
+ * @throws {Error} When the installed Eta generates code the plugin does not recognize
+ */
 export declare function createTemplateEngine(config: StatiConfig): Eta;
+/**
+ * Renders a page: its layout (chosen by front matter `layout:` or discovery), the parents the
+ * layout names with `stati.layout()`, and every template they include, plus the page's Open
+ * Graph template when it gets a generated image. Records every template and name lookup for
+ * the ISG cache.
+ */
 export declare function renderPage(page: PageModel, body: string, config: StatiConfig, eta: Eta, navigation?: NavNode[], allPages?: PageModel[], assets?: import('../types/index.js').StatiAssets, toc?: TocEntry[], logger?: Logger, extras?: RenderPageExtras): Promise<RenderResult>;
 //# sourceMappingURL=templates.d.ts.map

package/dist/core/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAG1B,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,OAAO,EAEP,QAAQ,EACR,MAAM,EACP,MAAM,mBAAmB,CAAC;AAuB3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,sBAAsB,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACvC,iEAAiE;IACjE,KAAK,EAAE,SAAS,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACjC;AA2CD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAoDjC;AAcD;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CA2B7D;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,EACtB,MAAM,CAAC,EAAE,OAAO,mBAAmB,EAAE,WAAW,EAChD,GAAG,CAAC,EAAE,QAAQ,EAAE,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CA8RvB"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/core/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,OAAO,EAEP,QAAQ,EACR,MAAM,EACN,cAAc,EACf,MAAM,mBAAmB,CAAC;AAkB3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,EAAsB,UAAU,EAAqB,MAAM,sBAAsB,CAAC;AAC9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAA6B,MAAM,qBAAqB,CAAC;AAS/E;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,eAAe,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,gBAAgB,EAAE,MAAM,CAAC;IACzB,sDAAsD;IACtD,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACvC,iEAAiE;IACjE,KAAK,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sEAAsE;IACtE,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAChC,wFAAwF;IACxF,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAC3C;AAuDD;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CA6B7D;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,GAAG,EACR,UAAU,CAAC,EAAE,OAAO,EAAE,EACtB,QAAQ,CAAC,EAAE,SAAS,EAAE,EACtB,MAAM,CAAC,EAAE,OAAO,mBAAmB,EAAE,WAAW,EAChD,GAAG,CAAC,EAAE,QAAQ,EAAE,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CAOvB"}