bestax-migrate 2.25.5 → 2.25.6

package/dist/sources/_shared/html/emit.js

@@ -0,0 +1,355 @@
+/**
+ * A parsed HTML tree → JSX source, laid out the way the HTML was.
+ *
+ * Each element keeps its tag (SVG's with the casing parse5 restores, so
+ * `foreignObject`), its attributes become props (`attributes.ts`), and its
+ * children follow the source's own lines: a run of whitespace with a line
+ * break in it is a line break in the JSX, at two spaces an indent. JSX drops
+ * such a run, so where the run renders (`whitespace.ts`) and a line break
+ * would lose it, the space is written out as `{" "}`; between two texts JSX
+ * joins the lines with a space already. Preformatted content is written on
+ * the lines it has, with a template literal for text that spans several, and
+ * a script's or stylesheet's text is always one.
+ *
+ * Void elements close themselves, and so does an element with nothing left
+ * in it. A comment becomes a JSX comment, except Internet Explorer's
+ * conditional ones, which no supported browser reads. What can't be written
+ * as it was is reported, with the HTML line it is on, for the caller to turn
+ * into TODOs: `HtmlIssue` lists the kinds, and which of them are emitted.
+ */
+import { convertAttributes, isCustomElement, printProp, } from './attributes.js';
+import { isComment, } from './parse.js';
+import { isConditionalComment, jsxComment, jsxText, templateLiteral, } from './text.js';
+import { defaultDisplayOf, layoutWhitespace, } from './whitespace.js';
+const HTML = 'http://www.w3.org/1999/xhtml';
+const VOID = new Set([
+    'area',
+    'base',
+    'basefont',
+    'bgsound',
+    'br',
+    'col',
+    'embed',
+    'frame',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+/** Elements whose text is code, never markup. */
+const RAW_TEXT = new Set(['script', 'style']);
+/** The current elements of the HTML standard. */
+const KNOWN = new Set(('a abbr address area article aside audio b base bdi bdo blockquote body ' +
+    'br button canvas caption cite code col colgroup data datalist dd del ' +
+    'details dfn dialog div dl dt em embed fieldset figcaption figure footer ' +
+    'form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ' +
+    'ins kbd label legend li link main map mark menu meta meter nav noscript ' +
+    'object ol optgroup option output p picture pre progress q rp rt ruby s ' +
+    'samp script search section select selectedcontent slot small source ' +
+    'span strong style sub summary sup table tbody td template textarea ' +
+    'tfoot th thead time title tr track u ul var video wbr').split(' '));
+/** Its obsolete ones, which still parse. */
+const OBSOLETE = new Set(('acronym applet basefont bgsound big blink center dir font frame ' +
+    'frameset isindex keygen listing marquee menuitem multicol nextid nobr ' +
+    'noembed noframes param plaintext rb rtc spacer strike tt xmp').split(' '));
+/** A tag JSX reads as an intrinsic element: lowercase first, no `.` or `:`. */
+const JSX_TAG = /^[a-z][\w$-]*$/;
+const INDENT = '  ';
+/** Lines of output, each write going on the end of the open one. */
+class Writer {
+    lines = [];
+    open = null;
+    /**
+     * Write on the open line, or open one at `depth`. A line break in `text`
+     * (a template literal's) is kept as it is, with no indent after it.
+     */
+    write(text, depth, html) {
+        const [first, ...rest] = text.split('\n');
+        if (!this.open) {
+            this.open = { depth, text: '', html };
+            this.lines.push(this.open);
+        }
+        this.open.text += first;
+        this.open.html ??= html;
+        rest.forEach((part, index) => {
+            this.open = {
+                depth: null,
+                text: part,
+                html: html === null ? null : html + index + 1,
+            };
+            this.lines.push(this.open);
+        });
+    }
+    /** End the line; the next write starts a new one. */
+    break() {
+        this.open = null;
+    }
+    blank() {
+        this.break();
+        this.lines.push({ depth: 0, text: '', html: null });
+    }
+}
+/**
+ * Pieces as items: words and the spaces between them on one line joined
+ * into texts, a run with a line break in it as a break, and a run that
+ * renders nothing on one line dropped.
+ *
+ * Two runs meet only where a dropped comment was between them, and then a
+ * space that renders can end up beside a line break, where JSX would trim
+ * it. Such a space is the break's to write, so a text never starts or ends
+ * with a space next to a break.
+ */
+function itemsOf(pieces) {
+    const items = [];
+    for (const piece of pieces) {
+        let last = items[items.length - 1];
+        if (piece.kind === 'node') {
+            items.push({ kind: 'node', node: piece.node });
+        }
+        else if (piece.kind === 'space' && piece.newlines > 0) {
+            let kept = piece.kept;
+            if (last?.kind === 'text' && last.text.endsWith(' ')) {
+                kept = true;
+                last.text = last.text.slice(0, -1);
+                if (last.text === '')
+                    items.pop();
+                last = items[items.length - 1];
+            }
+            const blank = piece.newlines > 1;
+            if (last?.kind === 'break') {
+                last.kept ||= kept;
+                last.blank ||= blank;
+            }
+            else {
+                items.push({ kind: 'break', kept, blank });
+            }
+        }
+        else if (piece.kind === 'space' && piece.kept && last?.kind === 'break') {
+            last.kept = true;
+        }
+        else if (piece.kind !== 'space' || piece.kept) {
+            const text = piece.kind === 'space' ? ' ' : piece.text;
+            if (last?.kind === 'text')
+                last.text += text;
+            else
+                items.push({ kind: 'text', text, line: piece.line });
+        }
+    }
+    return items;
+}
+/**
+ * Items that run over several lines, given a line break at each end too, so
+ * the tags sit on lines of their own. JSX drops a line break beside a tag,
+ * so that changes nothing, except that a space a text starts or ends with
+ * would go with it: that space becomes the break's.
+ */
+function framed(items) {
+    if (!items.some(item => item.kind === 'break'))
+        return items;
+    const out = [...items];
+    const edge = (at) => {
+        const index = at === 'start' ? 0 : out.length - 1;
+        const item = out[index];
+        if (item.kind === 'break')
+            return;
+        let kept = false;
+        if (item.kind === 'text') {
+            const space = at === 'start' ? /^ / : / $/;
+            kept = space.test(item.text);
+            const text = item.text.replace(space, '');
+            if (text === '')
+                out.splice(index, 1);
+            else
+                out[index] = { ...item, text };
+        }
+        const added = { kind: 'break', kept, blank: false };
+        if (at === 'start')
+            out.unshift(added);
+        else
+            out.push(added);
+    };
+    edge('start');
+    edge('end');
+    return out;
+}
+export function emitJsx(root, options = {}) {
+    const layout = layoutWhitespace(root, options.displayOf ?? defaultDisplayOf);
+    const out = new Writer();
+    const reported = [];
+    const report = (issue, line) => {
+        reported.push({ ...issue, line });
+    };
+    /**
+     * A parent's pieces as they are written, reporting what changes: a
+     * comment no browser reads goes, and an element JSX can't name gives way
+     * to its children, which join the text around them.
+     */
+    const piecesOf = (parent) => (layout.get(parent) ?? []).flatMap(piece => {
+        if (piece.kind !== 'node')
+            return [piece];
+        const node = piece.node;
+        const line = node.sourceCodeLocation?.startLine ?? null;
+        if (isComment(node)) {
+            if (!isConditionalComment(node.data))
+                return [piece];
+            report({ kind: 'conditional-comment', token: 'comment' }, line);
+            return [];
+        }
+        if (JSX_TAG.test(node.tagName))
+            return [piece];
+        report({ kind: 'element-name', token: node.tagName }, line);
+        return piecesOf(node);
+    });
+    const comment = (node, depth) => {
+        const line = node.sourceCodeLocation?.startLine ?? null;
+        jsxComment(node.data).forEach((text, index) => {
+            if (index > 0)
+                out.break();
+            out.write(text, depth, line);
+        });
+    };
+    /** Preformatted children: every character, on the lines it has. */
+    const exact = (parent, pieces, depth) => {
+        for (const piece of pieces) {
+            if (piece.kind === 'node') {
+                if (isComment(piece.node))
+                    comment(piece.node, depth);
+                else
+                    element(piece.node, depth);
+            }
+            else if (piece.kind === 'exact' && piece.text !== '') {
+                const literal = RAW_TEXT.has(parent.tagName) || piece.text.includes('\n');
+                out.write(literal ? `{${templateLiteral(piece.text)}}` : jsxText(piece.text), depth, piece.line);
+            }
+        }
+    };
+    /** Children laid out on the source's lines, one indent in from `depth`. */
+    const flow = (items, depth) => {
+        items.forEach((item, index) => {
+            if (item.kind === 'break') {
+                const before = items[index - 1];
+                const after = items[index + 1];
+                const betweenTexts = before?.kind === 'text' && after?.kind === 'text';
+                // JSX joins two texts across a line break with a space, so a run
+                // that renders nothing between them stays on one line.
+                if (betweenTexts && !item.kept)
+                    return;
+                if (item.kept && !betweenTexts)
+                    out.write('{" "}', depth + 1, null);
+                if (item.blank && before && after)
+                    out.blank();
+                out.break();
+            }
+            else if (item.kind === 'text') {
+                out.write(jsxText(item.text), depth + 1, item.line);
+            }
+            else if (isComment(item.node)) {
+                comment(item.node, depth + 1);
+            }
+            else {
+                element(item.node, depth + 1);
+            }
+        });
+    };
+    /** Report an element that is written as it was but isn't plain HTML. */
+    const reportElement = (node, line) => {
+        if (node.namespaceURI !== HTML)
+            return;
+        const tag = node.tagName;
+        if (tag === 'template') {
+            report({ kind: 'template', token: tag }, line);
+        }
+        else if (isCustomElement(node)) {
+            report({ kind: 'custom-element', token: tag }, line);
+        }
+        else if (OBSOLETE.has(tag)) {
+            report({ kind: 'obsolete-element', token: tag }, line);
+        }
+        else if (!KNOWN.has(tag)) {
+            report({ kind: 'unknown-element', token: tag }, line);
+        }
+    };
+    const element = (node, depth) => {
+        const tag = node.tagName;
+        const location = node.sourceCodeLocation;
+        const line = location?.startLine ?? null;
+        reportElement(node, line);
+        const { props, issues } = convertAttributes(node);
+        for (const issue of issues) {
+            const at = issue.attribute && location?.attrs?.[issue.attribute];
+            report(issue, at ? at.startLine : line);
+        }
+        const pieces = piecesOf(node);
+        const preformatted = pieces.some(piece => piece.kind === 'exact');
+        const items = preformatted ? [] : framed(itemsOf(pieces));
+        const empty = VOID.has(tag) ||
+            tag === 'textarea' ||
+            pieces.every(piece => (piece.kind === 'space' && !piece.kept) ||
+                (piece.kind === 'exact' && piece.text === ''));
+        const startTag = location?.startTag;
+        const tall = props.length > 1 &&
+            startTag !== undefined &&
+            startTag.endLine > startTag.startLine;
+        out.write(`<${tag}`, depth, line);
+        for (const prop of props) {
+            const at = location?.attrs?.[prop.attribute]?.startLine ?? line;
+            if (tall) {
+                out.break();
+                out.write(printProp(prop), depth + 1, at);
+            }
+            else {
+                out.write(` ${printProp(prop)}`, depth, at);
+            }
+        }
+        if (tall)
+            out.break();
+        const close = tall ? '' : ' ';
+        out.write(empty ? `${close}/>` : '>', depth, startTag?.endLine ?? line);
+        if (empty)
+            return;
+        if (preformatted)
+            exact(node, pieces, depth);
+        else
+            flow(items, depth);
+        const end = location?.endTag?.startLine ?? location?.endLine ?? null;
+        out.write(`</${tag}>`, depth, end);
+    };
+    const items = itemsOf(piecesOf(root));
+    const content = items.filter(item => item.kind !== 'break');
+    const only = content.length === 1 ? content[0] : undefined;
+    if (only?.kind === 'node' && !isComment(only.node)) {
+        element(only.node, 0);
+    }
+    else {
+        // A block holds the content, so whitespace at either end renders
+        // nothing, and the fragment's tags can sit on lines of their own.
+        while (items[0]?.kind === 'break')
+            items.shift();
+        while (items[items.length - 1]?.kind === 'break')
+            items.pop();
+        out.write('<>', 0, null);
+        if (items.length > 0) {
+            out.break();
+            flow(items, 0);
+            out.break();
+        }
+        out.write('</>', 0, null);
+    }
+    const base = options.indent ?? 0;
+    const code = out.lines
+        .map(entry => entry.depth === null || entry.text === ''
+        ? entry.text
+        : INDENT.repeat(base + entry.depth) + entry.text)
+        .join('\n');
+    return {
+        code,
+        htmlLineOf: line => out.lines[line - 1]?.html ?? null,
+        reported,
+    };
+}

package/dist/sources/_shared/html/parse.d.ts

@@ -0,0 +1,54 @@
+/**
+ * HTML source → the DOM a browser builds from it, by parse5.
+ *
+ * A page is parsed as a document and a partial as a fragment, so a partial
+ * gains no `<html>`/`<head>`/`<body>` and a document keeps what the parser
+ * moves into its head. Either way the caller gets the content of the body,
+ * which is what becomes JSX, and the rest separately: the head's children,
+ * the `<html>` and `<body>` attributes, and the comments outside both.
+ *
+ * Scripting is off, as it is for a page with JavaScript disabled: a
+ * `<noscript>` holds markup rather than text, which is what it means to
+ * someone reading the page.
+ */
+import { type DefaultTreeAdapterMap, type Token } from 'parse5';
+export type Node = DefaultTreeAdapterMap['node'];
+export type ParentNode = DefaultTreeAdapterMap['parentNode'];
+export type ChildNode = DefaultTreeAdapterMap['childNode'];
+export type Element = DefaultTreeAdapterMap['element'];
+export type Template = DefaultTreeAdapterMap['template'];
+export type TextNode = DefaultTreeAdapterMap['textNode'];
+export type CommentNode = DefaultTreeAdapterMap['commentNode'];
+export type Attribute = Token.Attribute;
+export interface HtmlParseError {
+    /** parse5's code for it, from the HTML spec (`missing-end-tag-name`). */
+    code: string;
+    line: number;
+    col: number;
+}
+export interface ParsedHtml {
+    kind: 'document' | 'fragment';
+    /**
+     * What holds the content: the `<body>` of a document, or the fragment.
+     * Its children are the content; its attributes are the body's.
+     */
+    root: Element | DefaultTreeAdapterMap['documentFragment'];
+    head: ChildNode[];
+    htmlAttributes: Attribute[];
+    bodyAttributes: Attribute[];
+    /**
+     * Comments a document has outside its head and body, before `<html>` or
+     * after `</body>`, where a credit or licence notice often sits.
+     */
+    outsideComments: CommentNode[];
+    errors: HtmlParseError[];
+}
+/** Whether parse5 should read this source as a whole document. */
+export declare function isDocument(source: string): boolean;
+export declare function isElement(node: Node): node is Element;
+export declare function isText(node: Node): node is TextNode;
+export declare function isComment(node: Node): node is CommentNode;
+/** An element's children, or a `<template>`'s content, which holds them. */
+export declare function childrenOf(node: ParentNode): ChildNode[];
+export declare function parseHtml(source: string): ParsedHtml;
+//# sourceMappingURL=parse.d.ts.map

package/dist/sources/_shared/html/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/sources/_shared/html/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAGL,KAAK,qBAAqB,EAE1B,KAAK,KAAK,EACX,MAAM,QAAQ,CAAC;AAEhB,MAAM,MAAM,IAAI,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACjD,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,qBAAqB,CAAC,WAAW,CAAC,CAAC;AAC3D,MAAM,MAAM,OAAO,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;AACvD,MAAM,MAAM,QAAQ,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;AACzD,MAAM,MAAM,QAAQ,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;AACzD,MAAM,MAAM,WAAW,GAAG,qBAAqB,CAAC,aAAa,CAAC,CAAC;AAC/D,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAC9B;;;OAGG;IACH,IAAI,EAAE,OAAO,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IAC1D,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B;;;OAGG;IACH,eAAe,EAAE,WAAW,EAAE,CAAC;IAC/B,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAQD,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,OAAO,CAErD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,QAAQ,CAEnD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,WAAW,CAEzD;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,CAIxD;AAQD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CA6CpD"}

package/dist/sources/_shared/html/parse.js

@@ -0,0 +1,85 @@
+/**
+ * HTML source → the DOM a browser builds from it, by parse5.
+ *
+ * A page is parsed as a document and a partial as a fragment, so a partial
+ * gains no `<html>`/`<head>`/`<body>` and a document keeps what the parser
+ * moves into its head. Either way the caller gets the content of the body,
+ * which is what becomes JSX, and the rest separately: the head's children,
+ * the `<html>` and `<body>` attributes, and the comments outside both.
+ *
+ * Scripting is off, as it is for a page with JavaScript disabled: a
+ * `<noscript>` holds markup rather than text, which is what it means to
+ * someone reading the page.
+ */
+import { parse, parseFragment, } from 'parse5';
+/**
+ * The tags that make HTML a document rather than a partial, wherever they
+ * sit outside a comment. `<head` is not `<header`.
+ */
+const DOCUMENT_MARKER = /<(?:!doctype|html|head|body)(?=[\s/>])/i;
+/** Whether parse5 should read this source as a whole document. */
+export function isDocument(source) {
+    return DOCUMENT_MARKER.test(source.replace(/<!--[\s\S]*?(?:-->|$)/g, ''));
+}
+export function isElement(node) {
+    return 'tagName' in node;
+}
+export function isText(node) {
+    return node.nodeName === '#text';
+}
+export function isComment(node) {
+    return node.nodeName === '#comment';
+}
+/** An element's children, or a `<template>`'s content, which holds them. */
+export function childrenOf(node) {
+    return node.nodeName === 'template'
+        ? node.content.childNodes
+        : node.childNodes;
+}
+function find(nodes, tag) {
+    return nodes.find((node) => isElement(node) && node.tagName === tag);
+}
+export function parseHtml(source) {
+    const errors = [];
+    const options = {
+        sourceCodeLocationInfo: true,
+        scriptingEnabled: false,
+        onParseError: (error) => {
+            errors.push({
+                code: error.code,
+                line: error.startLine,
+                col: error.startCol,
+            });
+        },
+    };
+    if (!isDocument(source)) {
+        return {
+            kind: 'fragment',
+            root: parseFragment(source, options),
+            head: [],
+            htmlAttributes: [],
+            bodyAttributes: [],
+            outsideComments: [],
+            errors,
+        };
+    }
+    const document = parse(source, options);
+    // The parser always builds `<html>`, and inside it `<head>` and `<body>`
+    // (a `<frameset>` page has no body, and gets an empty one here).
+    const html = find(document.childNodes, 'html');
+    const head = find(html.childNodes, 'head');
+    const body = find(html.childNodes, 'body');
+    const outsideComments = [...document.childNodes, ...html.childNodes].filter(isComment);
+    return {
+        kind: 'document',
+        root: body ?? {
+            nodeName: '#document-fragment',
+            childNodes: [],
+        },
+        head: head?.childNodes ?? [],
+        htmlAttributes: html.attrs,
+        bodyAttributes: body?.attrs ?? [],
+        outsideComments,
+        errors,
+    };
+}

package/dist/sources/_shared/html/style.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A `style="…"` attribute as the object literal React takes.
+ *
+ * The declarations are split by hand, since a style attribute is a flat list
+ * and the only syntax that matters is what can hide a `;` or a `:`: quoted
+ * strings, parentheses (`url(a;b)`), and comments. Property names are camel
+ * cased the way React hyphenates them back: `-ms-` becomes `ms`, any other
+ * vendor prefix a capital (`WebkitTransition`), and a custom property keeps
+ * its name, quoted. Which declaration of a property applies is CSS's choice:
+ * an `!important` one over the rest, else the last.
+ *
+ * As in CSS, a declaration that can't be read (an IE hack like `*zoom: 1`,
+ * an empty value, a string or parenthesis left open) is skipped and the rest
+ * apply; it is handed back for the caller to report. So is an `!important`
+ * one, which is written without its priority, since React sets every value
+ * without one.
+ */
+export type StyleIssue = 
+/** A declaration that can't be read, left out. */
+{
+    kind: 'style';
+    detail: string;
+}
+/** A declaration written without the `!important` React can't set. */
+ | {
+    kind: 'style-important';
+    token: string;
+    detail: string;
+};
+export interface StyleObject {
+    /** The object literal's source, or null when there is nothing to write. */
+    code: string | null;
+    issues: StyleIssue[];
+}
+/** The key React reads for a CSS property name. */
+export declare function styleKey(property: string): string;
+export interface Declaration {
+    /** As written, but for its case: lowercase unless a custom property. */
+    property: string;
+    value: string;
+    important: boolean;
+    /** The declaration's own text, for a report to quote. */
+    text: string;
+}
+export interface Style {
+    /** The declarations it could read, in order. */
+    declarations: Declaration[];
+    /** The text of each one it couldn't, which CSS skips too. */
+    skipped: string[];
+}
+/** A style attribute's declarations, read one at a time. */
+export declare function readStyle(text: string): Style;
+/**
+ * The declaration that applies for each property, as the cascade picks it
+ * inside one attribute: an `!important` one over any other, else the last.
+ * In the order of the declarations that apply.
+ */
+export declare function applied(declarations: Declaration[]): Map<string, Declaration>;
+/** A style attribute's text as a React style object. */
+export declare function styleObject(text: string): StyleObject;
+//# sourceMappingURL=style.d.ts.map

package/dist/sources/_shared/html/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../../../src/sources/_shared/html/style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,MAAM,UAAU;AACpB,kDAAkD;AAChD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACnC,sEAAsE;GACpE;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAqFD,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWjD;AAMD,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,KAAK;IACpB,gDAAgD;IAChD,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,6DAA6D;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,4DAA4D;AAC5D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAoB7C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAS7E;AAED,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAuBrD"}