@stati/core 1.29.2 → 2.0.1

package/dist/core/template-index.js

@@ -0,0 +1,484 @@
+/**
+ * The template index: every `.eta` file under the source directory, and the name lookup that
+ * `stati.include()`, `stati.layout()`, front matter `layout:`, layout discovery and the Open
+ * Graph template share, so rendering and the ISG cache resolve every name the same way.
+ * @module core/template-index
+ */
+import { posix, resolve } from 'node:path';
+import { glob } from 'tinyglobby';
+import { TEMPLATE_EXTENSION } from '../constants.js';
+import { editDistance, findSimilarNames } from './utils/similarity.utils.js';
+/**
+ * Normalizes `/`-separated segments, dropping `.` and empty ones.
+ *
+ * @returns The normalized path, or null when `..` climbs above its start
+ */
+function normalizeSegments(path) {
+    const segments = [];
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..') {
+            if (segments.length === 0)
+                return null;
+            segments.pop();
+            continue;
+        }
+        segments.push(segment);
+    }
+    return segments.join('/');
+}
+/**
+ * Parses a name passed to `stati.include()`, `stati.layout()`, `.has()` or front matter `layout:`.
+ * Backslashes count as `/`, and an `.eta` suffix is dropped.
+ *
+ * @param raw - The name as written
+ * @param callerFile - The calling template, relative to the source directory, or null for a
+ *   template without a file (the built-in Open Graph template)
+ */
+export function parseTemplateName(raw, callerFile) {
+    if (typeof raw !== 'string') {
+        return { kind: 'invalid', reason: `must be a string, not ${describeValue(raw)}` };
+    }
+    let name = raw.replace(/\\/g, '/');
+    if (name.endsWith(TEMPLATE_EXTENSION)) {
+        name = name.slice(0, -TEMPLATE_EXTENSION.length);
+    }
+    if (name === '') {
+        return { kind: 'invalid', reason: 'is empty' };
+    }
+    if (/^[a-zA-Z]:/.test(name)) {
+        return {
+            kind: 'invalid',
+            reason: 'is a file system path; use a path inside the source directory',
+        };
+    }
+    if (name.endsWith('/')) {
+        return { kind: 'invalid', reason: 'ends with "/"; name a template file' };
+    }
+    if (name.startsWith('/')) {
+        const path = normalizeSegments(name);
+        if (path === null) {
+            return { kind: 'invalid', reason: 'resolves outside the source directory' };
+        }
+        if (path === '') {
+            return { kind: 'invalid', reason: 'names the source directory, not a template' };
+        }
+        return { kind: 'path', path: `/${path}`, relative: false };
+    }
+    if (name === '.' || name === '..' || name.startsWith('./') || name.startsWith('../')) {
+        if (callerFile === null) {
+            return {
+                kind: 'invalid',
+                reason: 'is relative, and the built-in Open Graph template has no file to resolve it from; use a path such as "partials/card" instead',
+            };
+        }
+        const path = normalizeSegments(`${posix.dirname(callerFile.replace(/\\/g, '/'))}/${name}`);
+        if (path === null) {
+            return { kind: 'invalid', reason: 'resolves outside the source directory' };
+        }
+        if (path === '') {
+            return { kind: 'invalid', reason: 'names a folder, not a template' };
+        }
+        return { kind: 'path', path: `/${path}`, relative: true };
+    }
+    const normalized = normalizeSegments(name);
+    if (normalized === null) {
+        return { kind: 'invalid', reason: 'resolves outside the source directory' };
+    }
+    if (normalized === '') {
+        return { kind: 'invalid', reason: 'names a folder, not a template' };
+    }
+    return { kind: 'lookup', name: normalized };
+}
+function describeValue(value) {
+    if (value === null || value === undefined)
+        return String(value);
+    if (Array.isArray(value))
+        return 'an array';
+    return typeof value === 'object' ? 'an object' : `${typeof value} ${String(value)}`;
+}
+/**
+ * The folder of a file relative to the source directory, `''` for the source directory itself.
+ * Paths outside the source directory count as the source directory.
+ *
+ * @param relativeFile - A path relative to the source directory, with `/` or `\` separators
+ */
+export function templateFolderOf(relativeFile) {
+    const file = relativeFile.replace(/\\/g, '/');
+    if (file.startsWith('../') ||
+        file === '..' ||
+        posix.isAbsolute(file) ||
+        /^[a-zA-Z]:/.test(file)) {
+        return '';
+    }
+    const dir = posix.dirname(file);
+    return dir === '.' ? '' : posix.normalize(dir);
+}
+/**
+ * The folders a looked-up name is searched in, nearest first: the folder itself, each parent,
+ * then the source directory (`''`).
+ */
+export function lookupFolders(from) {
+    const folders = [];
+    let dir = from;
+    while (dir !== '') {
+        folders.push(dir);
+        const parent = posix.dirname(dir);
+        dir = parent === '.' ? '' : parent;
+    }
+    folders.push('');
+    return folders;
+}
+/**
+ * A `./` or `../` name that reaches `target` from `fromFolder`, both relative to the source
+ * directory. Pure string work, unlike `path.relative`, which resolves against the process's
+ * working directory.
+ *
+ * @example
+ * ```typescript
+ * relativeTemplateName('partials', 'partials/icon'); // './icon'
+ * relativeTemplateName('blog/2024', 'blog/post');     // '../post'
+ * relativeTemplateName('', 'layout');                 // './layout'
+ * ```
+ */
+export function relativeTemplateName(fromFolder, target) {
+    const from = fromFolder === '' ? [] : fromFolder.split('/');
+    const to = target.split('/');
+    let common = 0;
+    while (common < from.length && common < to.length - 1 && from[common] === to[common]) {
+        common++;
+    }
+    const rest = to.slice(common).join('/');
+    const ups = from.length - common;
+    return ups === 0 ? `./${rest}` : `${'../'.repeat(ups)}${rest}`;
+}
+/** The template file for a name in a folder. */
+function candidateFile(folder, name) {
+    return folder === '' ? `${name}${TEMPLATE_EXTENSION}` : `${folder}/${name}${TEMPLATE_EXTENSION}`;
+}
+/**
+ * Converts an absolute path to the index's form: relative to the source directory, `/`
+ * separators. Returns null for files outside it and for files that are not templates.
+ *
+ * @param srcDir - Absolute source directory
+ * @param absolutePath - Absolute path of a file, with either separator
+ */
+export function toTemplateFile(srcDir, absolutePath) {
+    const base = srcDir.replace(/\\/g, '/').replace(/\/+$/, '');
+    const path = absolutePath.replace(/\\/g, '/');
+    const caseInsensitive = /^[a-zA-Z]:/.test(base);
+    const comparablePath = caseInsensitive ? path.toLowerCase() : path;
+    const comparableBase = caseInsensitive ? base.toLowerCase() : base;
+    if (!comparablePath.startsWith(`${comparableBase}/`)) {
+        return null;
+    }
+    const relative = posix.normalize(path.slice(base.length + 1));
+    if (relative.startsWith('../') || !relative.endsWith(TEMPLATE_EXTENSION)) {
+        return null;
+    }
+    return relative;
+}
+/**
+ * Whether a value read from the cache manifest is a list of template lookups.
+ */
+export function isTemplateLookupList(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => {
+            if (typeof item !== 'object' || item === null)
+                return false;
+            const { name, from, file } = item;
+            return (typeof name === 'string' &&
+                (from === undefined || typeof from === 'string') &&
+                (file === null || typeof file === 'string'));
+        }));
+}
+/**
+ * Every `.eta` file under a source directory, with memoised name lookups.
+ * Paths are relative to the source directory, with `/` separators and the `.eta` extension.
+ */
+export class TemplateIndex {
+    srcDir;
+    templates;
+    lookupCache = new Map();
+    sorted = null;
+    /**
+     * @param srcDir - Absolute source directory
+     * @param files - Template files relative to it
+     */
+    constructor(srcDir, files) {
+        this.srcDir = srcDir;
+        this.templates = new Set();
+        for (const file of files) {
+            this.templates.add(file.replace(/\\/g, '/'));
+        }
+    }
+    /**
+     * Globs the source directory once for its templates.
+     *
+     * @param srcDir - Absolute source directory
+     */
+    static async load(srcDir) {
+        const files = await glob(`**/*${TEMPLATE_EXTENSION}`, {
+            cwd: srcDir,
+            onlyFiles: true,
+            ignore: ['**/node_modules/**'],
+            expandDirectories: false,
+        });
+        return new TemplateIndex(srcDir, files);
+    }
+    /** Number of templates */
+    get size() {
+        return this.templates.size;
+    }
+    /** Whether a template file exists, given relative to the source directory */
+    has(file) {
+        return this.templates.has(file);
+    }
+    /** Every template file, sorted */
+    files() {
+        this.sorted ??= [...this.templates].sort();
+        return this.sorted;
+    }
+    /**
+     * Adds a template, for a file created during a dev session.
+     *
+     * @returns Whether the index changed
+     */
+    add(file) {
+        if (!file.endsWith(TEMPLATE_EXTENSION) || this.templates.has(file)) {
+            return false;
+        }
+        this.templates.add(file);
+        this.invalidate();
+        return true;
+    }
+    /**
+     * Removes a template, for a file deleted during a dev session.
+     *
+     * @returns Whether the index changed
+     */
+    remove(file) {
+        if (!this.templates.delete(file)) {
+            return false;
+        }
+        this.invalidate();
+        return true;
+    }
+    invalidate() {
+        this.lookupCache.clear();
+        this.sorted = null;
+    }
+    /**
+     * Finds the nearest template for a looked-up name, searching `from` and then each parent
+     * folder up to the source directory.
+     *
+     * @param name - A normalized looked-up name, such as `partials/header`
+     * @param from - The folder to start in, relative to the source directory
+     * @returns The template file, or null when no folder has one
+     */
+    lookup(name, from) {
+        const key = `${from}\0${name}`;
+        const cached = this.lookupCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        let found = null;
+        for (const folder of lookupFolders(from)) {
+            const file = candidateFile(folder, name);
+            if (this.templates.has(file)) {
+                found = file;
+                break;
+            }
+        }
+        this.lookupCache.set(key, found);
+        return found;
+    }
+    /**
+     * Resolves a parsed name for a page.
+     *
+     * @param name - A parsed, valid name
+     * @param pageFolder - The page's folder, where looked-up names start
+     * @returns The file (or null) and the lookup to record
+     */
+    resolve(name, pageFolder) {
+        if (name.kind === 'path') {
+            const candidate = `${name.path.slice(1)}${TEMPLATE_EXTENSION}`;
+            const file = this.templates.has(candidate) ? candidate : null;
+            return { file, lookup: { name: name.path, file } };
+        }
+        const file = this.lookup(name.name, pageFolder);
+        return { file, lookup: { name: name.name, from: pageFolder, file } };
+    }
+    /**
+     * Resolves a recorded lookup again, for the cache. Lookups with a `from` folder are searched
+     * like looked-up names; the others are a single path.
+     *
+     * @returns The file the lookup would resolve to now, or null
+     */
+    resolveRecorded(lookup) {
+        if (lookup.from === undefined) {
+            const candidate = `${lookup.name.replace(/^\/+/, '')}${TEMPLATE_EXTENSION}`;
+            return this.templates.has(candidate) ? candidate : null;
+        }
+        return this.lookup(lookup.name, lookup.from);
+    }
+    /**
+     * Whether any recorded lookup would now resolve to a different file than it did.
+     */
+    lookupsChanged(lookups) {
+        return (lookups ?? []).some((lookup) => this.resolveRecorded(lookup) !== lookup.file);
+    }
+    /**
+     * Names a template could have meant, for an unknown name: templates with the same base name
+     * first, then similar names, written the way the name was written.
+     *
+     * @param name - The unknown name, parsed
+     * @param pageFolder - The page's folder
+     * @param callerFile - The calling template, relative to the source directory
+     * @param limit - Maximum number of suggestions
+     */
+    suggest(name, pageFolder, callerFile, limit = 3) {
+        const withoutExtension = (file) => file.slice(0, -TEMPLATE_EXTENSION.length);
+        const candidates = new Map();
+        if (name.kind === 'lookup') {
+            // The names this page can reach: each file, relative to each folder it could be found from
+            const folders = lookupFolders(pageFolder);
+            for (const file of this.files()) {
+                for (const folder of folders) {
+                    if (folder === '' || file.startsWith(`${folder}/`)) {
+                        const reachable = withoutExtension(folder === '' ? file : file.slice(folder.length + 1));
+                        if (!candidates.has(reachable))
+                            candidates.set(reachable, reachable);
+                    }
+                }
+            }
+        }
+        else {
+            const callerFolder = callerFile === null ? '' : templateFolderOf(callerFile);
+            for (const file of this.files()) {
+                const path = `/${withoutExtension(file)}`;
+                const written = name.relative
+                    ? relativeTemplateName(callerFolder, withoutExtension(file))
+                    : path;
+                candidates.set(path, written);
+            }
+        }
+        // A template with the same file name in another folder (a moved file, or a name without
+        // its folder), then a misspelt file name in the same folder; nearest first
+        const target = name.kind === 'lookup' ? name.name : name.path;
+        const targetBase = posix.basename(target);
+        const targetFolder = posix.dirname(target);
+        const others = [...candidates.keys()].filter((candidate) => candidate !== target);
+        const byDistance = (a, b) => editDistance(target, a) - editDistance(target, b) || a.localeCompare(b);
+        const sameBase = others
+            .filter((candidate) => posix.basename(candidate) === targetBase)
+            .sort(byDistance);
+        const sameFolder = others.filter((candidate) => posix.dirname(candidate) === targetFolder);
+        const similarBases = new Set(findSimilarNames(targetBase, sameFolder.map((candidate) => posix.basename(candidate)), limit));
+        const misspelt = sameFolder
+            .filter((candidate) => similarBases.has(posix.basename(candidate)))
+            .sort(byDistance);
+        return [...new Set([...sameBase, ...misspelt])]
+            .slice(0, limit)
+            .map((candidate) => candidates.get(candidate));
+    }
+    /**
+     * Picks a page's layout: its front matter `layout:` when that names a template, otherwise the
+     * nearest `layout.eta`, or for index pages the nearest `index.eta` or `layout.eta`, whichever
+     * is in a nearer folder (`index.eta` first within a folder).
+     *
+     * @param pageFile - The page's Markdown file, relative to the source directory
+     * @param frontMatterLayout - The page's front matter `layout:` value
+     * @param isIndexPage - Whether the page lists a collection, which enables `index.eta`
+     */
+    resolvePageLayout(pageFile, frontMatterLayout, isIndexPage) {
+        const pageFolder = templateFolderOf(pageFile);
+        const lookups = [];
+        let unresolvedFrontMatter;
+        // YAML reads `layout: 404` as a number
+        const layoutName = typeof frontMatterLayout === 'number' ? String(frontMatterLayout) : frontMatterLayout;
+        const callerFile = pageFile.replace(/\\/g, '/');
+        if (layoutName !== undefined && layoutName !== null && layoutName !== '') {
+            const parsed = parseTemplateName(layoutName, callerFile);
+            if (parsed.kind === 'invalid') {
+                unresolvedFrontMatter = { value: layoutName, problem: parsed.reason, suggestions: [] };
+            }
+            else {
+                const resolved = this.resolve(parsed, pageFolder);
+                lookups.push(resolved.lookup);
+                if (resolved.file !== null) {
+                    return { file: resolved.file, lookups };
+                }
+                unresolvedFrontMatter = {
+                    value: layoutName,
+                    problem: 'names no template',
+                    suggestions: this.suggest(parsed, pageFolder, callerFile),
+                };
+            }
+        }
+        const discovered = this.discoverLayout(pageFolder, isIndexPage, lookups);
+        return { file: discovered, lookups, ...(unresolvedFrontMatter && { unresolvedFrontMatter }) };
+    }
+    discoverLayout(pageFolder, isIndexPage, lookups) {
+        const layout = this.lookup('layout', pageFolder);
+        lookups.push({ name: 'layout', from: pageFolder, file: layout });
+        if (!isIndexPage) {
+            return layout;
+        }
+        const index = this.lookup('index', pageFolder);
+        lookups.push({ name: 'index', from: pageFolder, file: index });
+        if (index === null || layout === null) {
+            return index ?? layout;
+        }
+        // The nearer folder wins; within one folder index.eta comes first
+        const depth = (file) => {
+            const folder = templateFolderOf(file);
+            return folder === '' ? 0 : folder.split('/').length;
+        };
+        return depth(index) >= depth(layout) ? index : layout;
+    }
+}
+/**
+ * The index of a dev server session, which its file watcher keeps current as templates are
+ * added and deleted, so rebuilds reuse it. It lives outside the cached Eta engine, which every
+ * template change drops. Other builds read the source directory each time.
+ */
+let session = null;
+/**
+ * Starts a dev server session for a source directory: builds reuse one index, and the dev
+ * server updates it on file events.
+ */
+export function startTemplateIndexSession(srcDir) {
+    session = { srcDir: resolve(srcDir), index: null };
+}
+/**
+ * Ends the dev server session for a source directory; later builds read it again. A session
+ * another dev server started for a different directory is left alone.
+ */
+export function endTemplateIndexSession(srcDir) {
+    if (session && session.srcDir === resolve(srcDir)) {
+        session = null;
+    }
+}
+/**
+ * Returns the template index for a build: the session's while a dev server watches the
+ * source directory, otherwise a new one.
+ *
+ * @param srcDir - Absolute source directory
+ */
+export async function loadTemplateIndex(srcDir) {
+    // The session can end while the glob runs, when the dev server stops mid-build
+    const current = session;
+    if (current && current.srcDir === resolve(srcDir)) {
+        current.index ??= await TemplateIndex.load(srcDir);
+        return current.index;
+    }
+    return TemplateIndex.load(srcDir);
+}
+/**
+ * The dev server session's index for a source directory, or null when there is none yet.
+ */
+export function getCachedTemplateIndex(srcDir) {
+    return session && session.srcDir === resolve(srcDir) ? session.index : null;
+}

package/dist/core/template-render.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 { type Eta } from 'eta';
+import type { Logger, PageModel, TemplateLookup } from '../types/index.js';
+import { type TemplateIndex } from './template-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 declare const MAX_TEMPLATE_DEPTH = 100;
+/**
+ * The values every template of one render shares, such as `site`, `page` and `helpers`, and an
+ * id: the page's layout and its Open Graph template render with different values, so includes
+ * cached for one must not be reused by the other.
+ */
+export interface BaseContext {
+    readonly id: string;
+    readonly values: Record<string, unknown>;
+}
+/** What a render scope needs from the page being rendered. */
+export interface RenderScopeOptions {
+    page: PageModel;
+    eta: Eta;
+    index: TemplateIndex;
+    logger: Logger;
+    /** Development renders throw errors to the error overlay; production renders log them */
+    development: boolean;
+}
+/**
+ * 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 declare class RenderScope {
+    readonly page: PageModel;
+    readonly eta: Eta;
+    readonly index: TemplateIndex;
+    readonly logger: Logger;
+    readonly development: boolean;
+    /** The page's Markdown file, relative to the source directory */
+    readonly pageFile: string;
+    /** The page's folder, relative to the source directory, where looked-up names start */
+    readonly pageFolder: string;
+    /** Template files the page rendered, relative to the source directory, in order of first use */
+    readonly templates: Set<string>;
+    /** Name lookups the page made, by folder and name */
+    readonly lookups: Map<string, TemplateLookup>;
+    /** Templates rendered, counting a template each time it renders */
+    renders: number;
+    /** Includes served from the page's cache instead of rendering again */
+    includeCacheHits: number;
+    private readonly stack;
+    private readonly includeCache;
+    constructor(options: RenderScopeOptions);
+    /** Records a lookup for the page's cache entry. */
+    record(lookup: TemplateLookup): void;
+    /**
+     * 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: string | null): string[];
+    /** A template file for messages: its path from the project directory */
+    display(file: string | null): string;
+    /** An absolute path for messages: its path from the project directory */
+    displayPath(absolutePath: string): string;
+    /**
+     * 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
+     */
+    renderAsync(base: BaseContext, template: {
+        file: string;
+    } | {
+        source: string;
+    }): Promise<string>;
+    /**
+     * Renders a template and the parents it names with `stati.layout()`, synchronously, for
+     * `stati.include()`.
+     */
+    private renderSync;
+    private enter;
+    private leave;
+    private createContext;
+    private createInclude;
+    private createLayout;
+    /** `stati.include.has()` and `stati.layout.has()` */
+    private has;
+    /**
+     * Resolves a name for a call, recording the lookup. Reports invalid and unknown names.
+     *
+     * @returns The template file, or null after reporting the problem
+     */
+    private resolveForCall;
+    private reportUnknown;
+    /** `stati.include(name, props?, body?)` */
+    private include;
+    /** `stati.layout(name, props?)` */
+    private setLayout;
+    private checkProps;
+    private checkBody;
+    private reportCycle;
+    /**
+     * 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.
+     */
+    private fail;
+    /**
+     * 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.
+     */
+    private describeFailure;
+    private describeCompileError;
+    /** Whether a template that failed to compile synchronously compiles as an async function */
+    private compilesAsync;
+    private logIncludeFailure;
+}
+/**
+ * The template that was rendering when an error was thrown, relative to the source directory.
+ * Set for errors that left {@link RenderScope.renderAsync}.
+ */
+export declare function failingTemplateOf(error: Error): string | undefined;
+/**
+ * Runs a page's render inside its scope.
+ */
+export declare function runInRenderScope<T>(scope: RenderScope, render: () => Promise<T>): Promise<T>;
+/**
+ * The render scope of the page being rendered, or undefined outside a render.
+ */
+export declare function getRenderScope(): RenderScope | undefined;
+//# sourceMappingURL=template-render.d.ts.map

package/dist/core/template-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-render.d.ts","sourceRoot":"","sources":["../../src/core/template-render.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AAC9C,OAAO,KAAK,EACV,MAAM,EACN,SAAS,EAGT,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAQ7B;;;GAGG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAuBD,8DAA8D;AAC9D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,GAAG,CAAC;IACT,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,WAAW,EAAE,OAAO,CAAC;CACtB;AAWD;;;GAGG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,cAAqB;IACvC,qDAAqD;IACrD,QAAQ,CAAC,OAAO,8BAAqC;IACrD,mEAAmE;IACnE,OAAO,SAAK;IACZ,uEAAuE;IACvE,gBAAgB,SAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;gBAE9C,OAAO,EAAE,kBAAkB;IAUvC,mDAAmD;IACnD,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIpC;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE;IAU9C,wEAAwE;IACxE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM;IAOpC,yEAAyE;IACzE,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAIzC;;;;;;;OAOG;IACG,WAAW,CACf,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC;IAiClB;;;OAGG;IACH,OAAO,CAAC,UAAU;IA0BlB,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,YAAY;IASpB,qDAAqD;IACrD,OAAO,CAAC,GAAG;IAUX;;;;OAIG;IACH,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,aAAa;IAwBrB,2CAA2C;IAC3C,OAAO,CAAC,OAAO;IA6Cf,mCAAmC;IACnC,OAAO,CAAC,SAAS;IAoCjB,OAAO,CAAC,UAAU;IAmBlB,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,WAAW;IAanB;;;OAGG;IACH,OAAO,CAAC,IAAI;IAYZ;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,oBAAoB;IA6B5B,4FAA4F;IAC5F,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,iBAAiB;CAW1B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAElE;AAKD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE5F;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,WAAW,GAAG,SAAS,CAExD"}