@blue-patterns/richtext 0.0.0-stage → 0.7.18

package/dist/linkForm.js

@@ -0,0 +1,137 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file linkForm.tsx
+ * @input The address being entered, a refused-address message, and the
+ *   caller's apply, remove, and cancel handlers
+ * @output Exports LinkForm, the link URL form, and REMOVE_LINK_GLYPH
+ * @position Internal to RichText. RichTextEditorToolbar's link popover
+ *   renders this form, so adding and editing a link share one form.
+ */
+import { useRef } from 'react';
+import { IconButton } from '@blue-patterns/core/IconButton';
+import { TextInput } from '@blue-patterns/core/TextInput';
+import { HStack, StackItem } from '@blue-patterns/core/Layout';
+import { Icon } from '@blue-patterns/core/Icon';
+import { isImeKeyEvent } from '@blue-patterns/core/utils';
+import { useTranslator } from '@blue-patterns/core/i18n';
+
+/**
+ * Remove's glyph. No shared icon name means "unlink", so it is fixed
+ * component artwork until component icon slots exist.
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const REMOVE_LINK_GLYPH = /*#__PURE__*/_jsx("svg", {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 24 24",
+  fill: "none",
+  "aria-hidden": "true",
+  children: /*#__PURE__*/_jsx("path", {
+    d: "M18 13l2-2a5 5 0 0 0-7-7l-2 2M6 11l-2 2a5 5 0 0 0 7 7l2-2M8 2v3M2 8h3M16 22v-3M22 16h-3",
+    stroke: "currentColor",
+    strokeWidth: "2",
+    strokeLinecap: "round",
+    strokeLinejoin: "round"
+  })
+});
+/**
+ * The link form: one URL field, then Apply, Remove (only when editing a
+ * link), and Cancel as icon buttons. Enter in the field
+ * applies, and Escape anywhere in the form cancels. A refused address shows
+ * the field's error status and keeps focus in the field.
+ */
+export function LinkForm({
+  url,
+  error,
+  isEditing,
+  size,
+  onUrlChange,
+  onApply,
+  onRemove,
+  onCancel
+}) {
+  const t = useTranslator();
+  const inputRef = useRef(null);
+  const apply = () => {
+    if (!onApply()) {
+      inputRef.current?.focus();
+    }
+  };
+  const applyLabel = isEditing ? t('@astryx.richTextEditor.link.update') : t('@astryx.richTextEditor.link.add');
+  const removeLabel = t('@astryx.richTextEditor.link.remove');
+  const cancelLabel = t('@astryx.richTextEditor.link.cancel');
+  return /*#__PURE__*/_jsxs(HStack, {
+    gap: 1,
+    vAlign: "start",
+    onKeyDown: event => {
+      // Escape that ends an IME composition is the input method's.
+      if (event.key === 'Escape' && !isImeKeyEvent(event.nativeEvent)) {
+        // Claimed here, so a surrounding layer's Escape handling leaves it
+        // to Cancel, which also gives the editor back its selection.
+        event.preventDefault();
+        onCancel();
+      }
+    },
+    children: [/*#__PURE__*/_jsx(StackItem, {
+      size: "fill",
+      children: /*#__PURE__*/_jsx(TextInput, {
+        ref: inputRef,
+        label: t('@astryx.richTextEditor.link.url'),
+        isLabelHidden: true,
+        value: url,
+        size: size,
+        width: "100%",
+        autoComplete: "url"
+        // A URL keyboard on touch screens and no spelling marks under an
+        // address. The field stays plain text, so a bare domain reaches
+        // the link rules (sanitizeUrl), which make it an https link.
+        ,
+        inputMode: "url",
+        hasSpellCheck: false,
+        placeholder: t('@astryx.richTextEditor.link.urlPlaceholder'),
+        status: error ? {
+          type: 'error',
+          message: error
+        } : undefined,
+        statusVariant: "detached",
+        onChange: onUrlChange,
+        onEnter: apply,
+        onKeyDown: event => {
+          // Applying hands focus to the editor, which must not receive the
+          // rest of this Enter as a new line over the linked words.
+          if (event.key === 'Enter' && !isImeKeyEvent(event.nativeEvent)) {
+            event.preventDefault();
+          }
+        }
+      })
+    }), /*#__PURE__*/_jsx(IconButton, {
+      label: applyLabel,
+      icon: /*#__PURE__*/_jsx(Icon, {
+        icon: "check"
+      }),
+      variant: "ghost",
+      size: size,
+      tooltip: applyLabel,
+      onClick: apply
+    }), isEditing && /*#__PURE__*/_jsx(IconButton, {
+      label: removeLabel,
+      icon: REMOVE_LINK_GLYPH,
+      variant: "ghost",
+      size: size,
+      tooltip: removeLabel,
+      onClick: onRemove
+    }), /*#__PURE__*/_jsx(IconButton, {
+      label: cancelLabel,
+      icon: /*#__PURE__*/_jsx(Icon, {
+        icon: "close"
+      }),
+      variant: "ghost",
+      size: size,
+      tooltip: cancelLabel,
+      onClick: onCancel
+    })]
+  });
+}

package/dist/linkUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Matches a bare URL for AutoLink. Adapted from the Lexical playground.
+ * Intentionally permissive on path/query so real-world URLs linkify.
+ */
+export declare const URL_MATCHER: RegExp;
+/**
+ * Matches a bare email address for AutoLink (rendered as a `mailto:` link).
+ * An unquoted local part starts only at the text start, after whitespace, or
+ * after one of `<>()[]\,;:@"`. A quoted local part ends at the next quote or
+ * line break. Each run is read once, so matching time stays linear.
+ */
+export declare const EMAIL_MATCHER: RegExp;
+/**
+ * Return a safe href for `url`, or `'about:blank'` if it can't be parsed or uses
+ * a disallowed scheme. A scheme-less input like `example.com` is treated as
+ * `https://example.com`. Use this before writing any user-supplied string into
+ * a link's href.
+ */
+export declare function sanitizeUrl(url: string): string;
+/**
+ * Whether `url` is a well-formed, safe (http/https/mailto/tel) URL. Used to
+ * decide whether an entered link value is acceptable before dispatching the
+ * toggle-link command. Shares the {@link SAFE_PROTOCOLS} allowlist with
+ * {@link sanitizeUrl} so the two never disagree.
+ */
+export declare function validateUrl(url: string): boolean;
+//# sourceMappingURL=linkUtils.d.ts.map

package/dist/linkUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkUtils.d.ts","sourceRoot":"","sources":["../src/linkUtils.ts"],"names":[],"mappings":"AAoCA;;;GAGG;AACH,eAAO,MAAM,WAAW,QAC0F,CAAC;AAEnH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QACyJ,CAAC;AAgBpL;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAc/C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAWhD"}

package/dist/linkUtils.js

@@ -0,0 +1,101 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file linkUtils.ts
+ * @input Uses only the DOM URL constructor (guarded via try/catch for SSR/edge).
+ * @output Exports `sanitizeUrl`, `validateUrl`, and the URL/email matcher regexes
+ *   used by the AutoLink wiring.
+ * @position @blue-patterns/richtext helper shared by RichTextEditorToolbar (link
+ *   button) and the AutoLink matchers in RichTextEditor. Kept dependency-free so
+ *   both can import it without pulling in extra `@lexical/*` surface.
+ *
+ * SYNC: When modified, update:
+ * - /packages/richtext/src/RichTextEditorToolbar.tsx (link button)
+ * - /packages/richtext/src/RichTextEditor.tsx (AutoLink matchers)
+ * - /packages/richtext/src/RichTextEditor.test.tsx (tests)
+ * - /packages/richtext/src/RichTextEditor.doc.mjs (link docs)
+ * - /packages/richtext/src/index.ts (exports / barrel)
+ *
+ * NOTE: Mirrors the Lexical playground's url.ts (`sanitizeUrl` / `validateUrl`
+ * / `URL_REGEX` / `EMAIL_REGEX`). Sanitization is the security-critical part:
+ * it blocks `javascript:`, `data:`, and other non-http(s)/mailto/tel schemes
+ * from being written into a LinkNode's href, so an inserted link can never
+ * smuggle in an executable URL.
+ */
+
+/**
+ * Schemes a link is allowed to carry. Anything else (notably `javascript:`,
+ * `data:`, `vbscript:`) is rejected by {@link validateUrl} and coerced to
+ * `about:blank` by {@link sanitizeUrl}, so a malicious paste can't produce a
+ * clickable code-execution link.
+ */
+const SAFE_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'tel:']);
+
+/** Matches a scheme prefix like `https:` / `mailto:` at the start of a string. */
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+
+/**
+ * Matches a bare URL for AutoLink. Adapted from the Lexical playground.
+ * Intentionally permissive on path/query so real-world URLs linkify.
+ */
+export const URL_MATCHER = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)/;
+
+/**
+ * Matches a bare email address for AutoLink (rendered as a `mailto:` link).
+ * An unquoted local part starts only at the text start, after whitespace, or
+ * after one of `<>()[]\,;:@"`. A quoted local part ends at the next quote or
+ * line break. Each run is read once, so matching time stays linear.
+ */
+export const EMAIL_MATCHER = /((?<![^<>()[\]\\,;:\s@"])[^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*|("[^"\r\n]+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
+
+/**
+ * A host with a port also looks like a scheme (`example.com:`).
+ * The host needs a dot or is `localhost`, so `tel:911` keeps its scheme.
+ */
+const HOST_WITH_PORT = /^(?:localhost|[a-z0-9-]+(?:\.[a-z0-9-]+)+):\d{1,5}(?:[/?#]|$)/i;
+
+/** Prepend a default `https://` scheme to a bare host so it parses as absolute. */
+function withDefaultScheme(url) {
+  return HAS_SCHEME.test(url) && !HOST_WITH_PORT.test(url) ? url : `https://${url}`;
+}
+
+/**
+ * Return a safe href for `url`, or `'about:blank'` if it can't be parsed or uses
+ * a disallowed scheme. A scheme-less input like `example.com` is treated as
+ * `https://example.com`. Use this before writing any user-supplied string into
+ * a link's href.
+ */
+export function sanitizeUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed === '') {
+    return 'about:blank';
+  }
+  try {
+    const parsed = new URL(withDefaultScheme(trimmed));
+    if (!SAFE_PROTOCOLS.has(parsed.protocol.toLowerCase())) {
+      return 'about:blank';
+    }
+    return parsed.href;
+  } catch {
+    return 'about:blank';
+  }
+}
+
+/**
+ * Whether `url` is a well-formed, safe (http/https/mailto/tel) URL. Used to
+ * decide whether an entered link value is acceptable before dispatching the
+ * toggle-link command. Shares the {@link SAFE_PROTOCOLS} allowlist with
+ * {@link sanitizeUrl} so the two never disagree.
+ */
+export function validateUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed === '') {
+    return false;
+  }
+  try {
+    const parsed = new URL(withDefaultScheme(trimmed));
+    return SAFE_PROTOCOLS.has(parsed.protocol.toLowerCase());
+  } catch {
+    return false;
+  }
+}

package/dist/markdown.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file markdown.ts
+ * @output Server-safe entry `@blue-patterns/richtext/markdown`: the Markdown
+ *   serializers, createRichTextExtension, RichTextExtensionError, and their
+ *   types.
+ * @position Imports no React, DOM, or client-only module, so server and Node
+ *   code converts Markdown and adopts plugins here (spec:AST-064 FR3, FR12).
+ *   The package's main entry is a client module and re-exports all of this
+ *   for client code. An extension holds its plugin's functions, so it is not
+ *   serializable: create the extensions a page passes to the surfaces in a
+ *   client module, and create your own for headless use.
+ */
+export { markdownToEditorStateJSON, editorStateJSONToMarkdown, } from './markdownSerializers.js';
+export type { MarkdownSerializerOptions } from './markdownSerializers.js';
+export { createRichTextExtension, RichTextExtensionError, } from './markdownExtensions.js';
+export type { RichTextMarkdownExtension } from './markdownExtensions.js';
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAC,yBAAyB,EAAC,MAAM,uBAAuB,CAAC;AACrE,OAAO,EACL,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAC,yBAAyB,EAAC,MAAM,sBAAsB,CAAC"}

package/dist/markdown.js

@@ -0,0 +1,17 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file markdown.ts
+ * @output Server-safe entry `@blue-patterns/richtext/markdown`: the Markdown
+ *   serializers, createRichTextExtension, RichTextExtensionError, and their
+ *   types.
+ * @position Imports no React, DOM, or client-only module, so server and Node
+ *   code converts Markdown and adopts plugins here (spec:AST-064 FR3, FR12).
+ *   The package's main entry is a client module and re-exports all of this
+ *   for client code. An extension holds its plugin's functions, so it is not
+ *   serializable: create the extensions a page passes to the surfaces in a
+ *   client module, and create your own for headless use.
+ */
+
+export { markdownToEditorStateJSON, editorStateJSONToMarkdown } from "./markdownSerializers.js";
+export { createRichTextExtension, RichTextExtensionError } from "./markdownExtensions.js";

package/dist/markdownCharacterReferences.d.ts

@@ -0,0 +1,135 @@
+import { type ElementNode, type LexicalNode } from 'lexical';
+/**
+ * What a stand-in replaced: a reference as written, an escaped `&`, or a
+ * backslash-escaped character.
+ */
+type StandIn = {
+    readonly kind: 'reference';
+    readonly source: string;
+} | {
+    readonly kind: 'ampersand';
+} | {
+    readonly kind: 'escape';
+    readonly character: string;
+} | {
+    readonly kind: 'backslash';
+} | {
+    readonly kind: 'literal';
+    readonly text: string;
+};
+export interface ProtectedMarkdown {
+    /** The source with stand-ins in place of references. */
+    readonly markdown: string;
+    /** What each stand-in replaced. */
+    readonly standIns: ReadonlyMap<string, StandIn>;
+}
+/** Private-use characters that do not occur in `text`, in order. */
+export declare function absentCharacters(text: string): Generator<string>;
+/**
+ * Returns `markdown` with every backslash escape outside code — a backslash
+ * before ASCII punctuation — replaced by a private-use stand-in for the
+ * escaped character, and every backslash in code by a stand-in for itself,
+ * which Lexical would otherwise drop from a code span — except before `|`,
+ * which a table reads before its code. A backslash before anything else
+ * outside code stays as written. One pass over the source.
+ */
+export declare function protectBackslashEscapes(markdown: string): ProtectedMarkdown;
+/**
+ * Whether core Markdown refuses a link to `url`, a destination already
+ * decoded: the probe writes it back with every special character escaped.
+ * A URL that cannot be written back is refused.
+ */
+export declare function coreRefusesUrl(url: string): boolean;
+/**
+ * Returns `markdown` with each inline link whose destination core Markdown
+ * refuses — `javascript:` and the like — kept from becoming a link
+ * (spec:AST-061 FR7). Where core shows the link as its source text, exactly
+ * as written, the whole source becomes one stand-in that comes back as that
+ * text. Where core reads no link there at all (its link text holds brackets
+ * of its own), only the `(` that opens the destination becomes a stand-in,
+ * so the text around it reads as core reads it, marks included. Brackets and
+ * parentheses pair by nesting, so link text holding brackets is found whole.
+ * Linear in the source: pairs come from one pass, and a destination inside a
+ * found link is not probed again. Run first, on the source as written;
+ * `$unwrapRefusedLinks` catches any link the editor still makes.
+ */
+export declare function protectRefusedLinks(markdown: string): ProtectedMarkdown;
+/** Whether `node` is text that holds an image's Markdown source. */
+export declare function $isImageSource(node: LexicalNode): boolean;
+/**
+ * Returns `markdown` with every image outside code replaced by a private-use
+ * stand-in, and the source each stand-in replaced. An image starts with a `!`
+ * that is not escaped and the paired brackets of its text. An inline image
+ * (`![a](b)`) ends with the destination and title that close it, read whole
+ * by core's inline parser. A reference image (`![a][b]`, `![a][]`, `![a]`)
+ * ends with its label; its definition can sit in another block, so it is kept
+ * whether or not one exists. A link around an image keeps its own brackets,
+ * so the image stays inside the link's text.
+ */
+export declare function protectImages(markdown: string): {
+    readonly markdown: string;
+    readonly images: ReadonlyMap<string, string>;
+};
+/**
+ * Puts each image's source back where its stand-in sits under `node`, as
+ * text marked as an image's source. The text is a token: a person deletes it
+ * whole, and autolinking leaves its URL alone. ImageSourceCaretPlugin keeps
+ * the caret out of it, so typing never replaces it.
+ */
+export declare function $restoreImages(node: ElementNode, images: ReadonlyMap<string, string>): void;
+/**
+ * Takes every link under `node` whose URL core Markdown refuses out of its
+ * link, leaving its text in place, so no form of link text or destination
+ * the source pass did not find can store or draw an unsafe URL.
+ */
+export declare function $unwrapRefusedLinks(node: ElementNode): void;
+/**
+ * Returns `markdown` with every parenthesis inside an inline link
+ * destination — between the destination's own parentheses, balanced, as core
+ * Markdown and CommonMark read them — replaced by a private-use stand-in for
+ * itself, outside code. Run after protectBackslashEscapes, so an escaped
+ * parenthesis is already a stand-in and never counts toward the balance.
+ */
+export declare function protectLinkDestinationParentheses(markdown: string): ProtectedMarkdown;
+/** The code spans a stand-in pass replaced: each stand-in's code. */
+export interface ProtectedCodeSpans {
+    readonly markdown: string;
+    readonly spans: ReadonlyMap<string, string>;
+    /** Stand-ins for backticks in link destinations and titles. */
+    readonly standIns: ReadonlyMap<string, StandIn>;
+}
+/**
+ * Returns `markdown` with each code span outside fenced code replaced by a
+ * private-use stand-in, and the code each stands for, as core Markdown reads
+ * it. Code spans bind tighter than emphasis and links (CommonMark 0.31
+ * §6.1), but Lexical's import applies a code span before an earlier mark on
+ * the same line, which breaks every mark around code that follows another
+ * (`~~a~~ ~~`c`~~`); with the code out of the way, the marks pair first and
+ * the code comes back inside them. Backticks in a link's destination or
+ * title are the link's, never a code span: they become stand-ins too, put
+ * back into the link's address and title after import, so Lexical cannot
+ * pair them into code either. In a table row, a span holding an unescaped
+ * `|` is left alone, so the row still splits its cells there, as GFM does.
+ */
+export declare function protectCodeSpans(markdown: string): ProtectedCodeSpans;
+/**
+ * Puts each code span back where its stand-in sits under `node`: the code as
+ * text with the code format, inside whatever marks the stand-in took. In a
+ * table cell an escaped `\|` in code is a `|`, as GFM reads cells.
+ */
+export declare function $restoreCodeSpans(node: ElementNode, spans: ReadonlyMap<string, string>): void;
+/**
+ * Returns `markdown` with every character reference outside code replaced by
+ * a private-use stand-in that occurs nowhere else in it, and the escaped `&`
+ * of an escaped reference replaced by one too. One pass over the source.
+ */
+export declare function protectCharacterReferences(markdown: string): ProtectedMarkdown;
+/**
+ * Replaces the stand-ins under `node` with the characters their references
+ * name or their escapes stand for — or, in code Lexical read as code, with
+ * the references and escapes as written — in text, link destinations, and
+ * link titles. One pass over the text.
+ */
+export declare function $restoreCharacterReferences(node: ElementNode, standIns: ReadonlyMap<string, StandIn>): void;
+export {};
+//# sourceMappingURL=markdownCharacterReferences.d.ts.map

package/dist/markdownCharacterReferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownCharacterReferences.d.ts","sourceRoot":"","sources":["../src/markdownCharacterReferences.ts"],"names":[],"mappings":"AAiCA,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,SAAS,CAAC;AAMjB;;;GAGG;AACH,KAAK,OAAO,GACR;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAC,GACrD;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAC,GAC5B;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GACrD;IAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAC,GAC5B;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mCAAmC;IACnC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjD;AAYD,oEAAoE;AACpE,wBAAiB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAUjE;AAkID;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CA2D3E;AAkHD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAUnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CA8DvE;AAUD,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,CA+DA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,IAAI,CA8BN;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAS3D;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,GACf,iBAAiB,CA4EnB;AAED,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjD;AA2FD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAwErE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,IAAI,CAgCN;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,GACf,iBAAiB,CA+EnB;AAmDD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,IAAI,CAsCN"}