@akinon/ui-editor 1.0.0

package/dist/cjs/tiptap/components/menu-bar/__tests__/youtube-popover.test.tsx

@@ -0,0 +1,538 @@
+import '@tiptap/extension-youtube';
+import '@testing-library/jest-dom';
+
+import { render, screen } from '@testing-library/react';
+import { userEvent } from '@testing-library/user-event';
+import { Editor } from '@tiptap/core';
+import Document from '@tiptap/extension-document';
+import Paragraph from '@tiptap/extension-paragraph';
+import Text from '@tiptap/extension-text';
+import Youtube from '@tiptap/extension-youtube';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { EditorState } from '../../../types';
+import { YouTubePopover } from '../youtube-popover';
+
+vi.mock('@akinon/ui-popover', () => ({
+  Popover: ({
+    children,
+    content,
+    open,
+    onOpenChange
+  }: {
+    children: React.ReactNode;
+    content: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+  }) => {
+    const [isOpen, setIsOpen] = React.useState(false);
+
+    React.useEffect(() => {
+      if (open !== undefined) {
+        setIsOpen(open);
+      }
+    }, [open]);
+
+    const handleClick = () => {
+      setIsOpen(!isOpen);
+      if (onOpenChange) {
+        onOpenChange(!isOpen);
+      }
+    };
+
+    return (
+      <div>
+        <div onClick={handleClick}>{children}</div>
+        {(open !== undefined ? open : isOpen) && (
+          <div data-testid="popover-content">{content}</div>
+        )}
+      </div>
+    );
+  }
+}));
+
+vi.mock('@akinon/ui-button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+    tooltip,
+    icon,
+    type
+  }: {
+    children?: React.ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    tooltip?: string;
+    icon?: string;
+    type?: string;
+  }) => (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      aria-label={tooltip}
+      data-icon={icon}
+      data-type={type}
+    >
+      {children}
+    </button>
+  )
+}));
+
+vi.mock('@akinon/ui-input', () => ({
+  Input: ({
+    value,
+    onChange,
+    placeholder,
+    onKeyDown,
+    status
+  }: {
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    placeholder: string;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    status?: string;
+  }) => (
+    <input
+      value={value}
+      onChange={onChange}
+      placeholder={placeholder}
+      onKeyDown={onKeyDown}
+      data-status={status}
+    />
+  )
+}));
+
+vi.mock('@akinon/ui-theme', () => ({
+  useToken: () => ({
+    token: {},
+    hashId: 'test-hash'
+  }),
+  getSafeCustomTokens: () => ({
+    layout: {
+      displayFlex: 'flex',
+      flexCenter: 'center'
+    }
+  })
+}));
+
+vi.mock('@ant-design/cssinjs', () => ({
+  useStyleRegister: (_config: unknown, callback: () => unknown) => {
+    callback();
+    return (component: React.ReactNode) => component;
+  }
+}));
+
+vi.mock('antd', () => ({
+  ConfigProvider: {
+    ConfigContext: React.createContext({
+      getPrefixCls: (name: string) => `ant-${name}`,
+      theme: {}
+    })
+  }
+}));
+
+vi.mock('../../../../i18n', () => ({
+  i18n: {
+    t: (key: string) => {
+      const translations: Record<string, string> = {
+        'editor.youtube.placeholder': 'YouTube URL',
+        'editor.youtube.tooltip': 'Insert YouTube Video',
+        'editor.youtube.cancel': 'Cancel',
+        'editor.youtube.insert': 'Insert'
+      };
+      return translations[key] || key;
+    }
+  }
+}));
+
+describe('YouTubePopover', () => {
+  const createEditor = () => {
+    return new Editor({
+      extensions: [Document, Paragraph, Text, Youtube]
+    });
+  };
+
+  const createEditorState = (
+    overrides: Partial<EditorState> = {}
+  ): EditorState => ({
+    isBold: false,
+    isItalic: false,
+    isUnderline: false,
+    isStrike: false,
+    isCode: false,
+    isHighlight: false,
+    isParagraph: false,
+    isHeading1: false,
+    isHeading2: false,
+    isHeading3: false,
+    isHeading4: false,
+    isCodeBlock: false,
+    isBlockquote: false,
+    isBulletList: false,
+    isOrderedList: false,
+    isTaskList: false,
+    isLink: false,
+    isTable: false,
+    isLeftAlign: false,
+    isCenterAlign: false,
+    isRightAlign: false,
+    isJustifyAlign: false,
+    canUndo: false,
+    canRedo: false,
+    canBold: false,
+    canItalic: false,
+    canUnderline: false,
+    canStrike: false,
+    canCode: false,
+    canClearMarks: false,
+    ...overrides
+  });
+
+  it('should render youtube popover button', () => {
+    const editor = createEditor();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    expect(screen.getByLabelText('Insert YouTube Video')).toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should have correct icon', () => {
+    const editor = createEditor();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    expect(button).toHaveAttribute('data-icon', 'youtube');
+
+    editor.destroy();
+  });
+
+  it('should be disabled when disabled prop is true', () => {
+    const editor = createEditor();
+
+    render(
+      <YouTubePopover
+        editor={editor}
+        editorState={createEditorState()}
+        disabled={true}
+      />
+    );
+
+    expect(screen.getByLabelText('Insert YouTube Video')).toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should be enabled when disabled prop is false', () => {
+    const editor = createEditor();
+
+    render(
+      <YouTubePopover
+        editor={editor}
+        editorState={createEditorState()}
+        disabled={false}
+      />
+    );
+
+    expect(screen.getByLabelText('Insert YouTube Video')).not.toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should show popover content when button is clicked', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    expect(screen.getByTestId('popover-content')).toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should contain URL input field in popover', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    expect(screen.getByPlaceholderText('YouTube URL')).toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should contain cancel button in popover', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    expect(screen.getByText('Cancel')).toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should contain insert button in popover', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    expect(screen.getByText('Insert')).toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should allow entering URL in input', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    expect(urlInput).toHaveValue('https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    editor.destroy();
+  });
+
+  it('should disable insert button when URL is empty', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const insertButton = screen.getByText('Insert');
+    expect(insertButton).toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should disable insert button when URL is invalid', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://invalid-url.com');
+
+    const insertButton = screen.getByText('Insert');
+    expect(insertButton).toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should show error status when URL is invalid', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://invalid-url.com');
+
+    expect(urlInput).toHaveAttribute('data-status', 'error');
+
+    editor.destroy();
+  });
+
+  it('should enable insert button when URL is valid youtube.com URL', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    const insertButton = screen.getByText('Insert');
+    expect(insertButton).not.toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should enable insert button when URL is valid youtu.be URL', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://youtu.be/dQw4w9WgXcQ');
+
+    const insertButton = screen.getByText('Insert');
+    expect(insertButton).not.toBeDisabled();
+
+    editor.destroy();
+  });
+
+  it('should insert video when insert button is clicked', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    const insertButton = screen.getByText('Insert');
+    await user.click(insertButton);
+
+    const html = editor.getHTML();
+    expect(html).toContain('youtube');
+
+    editor.destroy();
+  });
+
+  it('should clear input and close popover after inserting video', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    const insertButton = screen.getByText('Insert');
+    await user.click(insertButton);
+
+    expect(screen.queryByTestId('popover-content')).not.toBeInTheDocument();
+
+    editor.destroy();
+  });
+
+  it('should insert video when Enter key is pressed with valid URL', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(
+      urlInput,
+      'https://www.youtube.com/watch?v=dQw4w9WgXcQ{Enter}'
+    );
+
+    const html = editor.getHTML();
+    expect(html).toContain('youtube');
+
+    editor.destroy();
+  });
+
+  it('should not insert video when Enter key is pressed with invalid URL', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://invalid-url.com{Enter}');
+
+    const html = editor.getHTML();
+    expect(html).not.toContain('youtube');
+
+    editor.destroy();
+  });
+
+  it('should clear input and close popover when cancel button is clicked', async () => {
+    const editor = createEditor();
+    const user = userEvent.setup();
+
+    render(
+      <YouTubePopover editor={editor} editorState={createEditorState()} />
+    );
+
+    const button = screen.getByLabelText('Insert YouTube Video');
+    await user.click(button);
+
+    const urlInput = screen.getByPlaceholderText('YouTube URL');
+    await user.type(urlInput, 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+
+    const cancelButton = screen.getByText('Cancel');
+    await user.click(cancelButton);
+
+    expect(screen.queryByTestId('popover-content')).not.toBeInTheDocument();
+
+    editor.destroy();
+  });
+});

package/dist/cjs/tiptap/components/menu-bar/action-toolbar.d.ts

@@ -0,0 +1,15 @@
+import '@tiptap/extension-history';
+import type { Editor } from '@tiptap/react';
+import React from 'react';
+import type { EditorState, ToolbarButtonId } from '../../types';
+interface ActionToolbarProps {
+    editor: Editor;
+    editorState: EditorState;
+    isSourceMode: boolean;
+    toggleSource: () => void;
+    disabled?: boolean;
+    hiddenButtons?: Array<ToolbarButtonId>;
+}
+export declare const ActionToolbar: ({ editor, editorState, isSourceMode, toggleSource, disabled, hiddenButtons }: ActionToolbarProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=action-toolbar.d.ts.map

package/dist/cjs/tiptap/components/menu-bar/action-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-toolbar.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/components/menu-bar/action-toolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEhE,UAAU,kBAAkB;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;CACxC;AAYD,eAAO,MAAM,aAAa,GAAI,8EAO3B,kBAAkB,sBAmDpB,CAAC"}

package/dist/cjs/tiptap/components/menu-bar/action-toolbar.js

@@ -0,0 +1,40 @@
+import '@tiptap/extension-history';
+import { Button } from '@akinon/ui-button';
+import React from 'react';
+import { i18n } from '../../../i18n';
+import { TOOLBAR_BUTTON_IDS } from '../../constants';
+export const ActionToolbar = ({ editor, editorState, isSourceMode, toggleSource, disabled = false, hiddenButtons = [] }) => {
+    const activeCls = 'active';
+    const actionButtons = [
+        {
+            id: TOOLBAR_BUTTON_IDS.UNDO,
+            key: 1,
+            icon: 'format-undo',
+            tooltip: i18n.t('editor.toolbar.undo'),
+            onClick: () => editor.chain().focus().undo().run(),
+            disabled: disabled || isSourceMode || !editorState.canUndo
+        },
+        {
+            id: TOOLBAR_BUTTON_IDS.REDO,
+            key: 2,
+            icon: 'format-redo',
+            tooltip: i18n.t('editor.toolbar.redo'),
+            onClick: () => editor.chain().focus().redo().run(),
+            disabled: disabled || isSourceMode || !editorState.canRedo
+        },
+        {
+            id: TOOLBAR_BUTTON_IDS.SOURCE_MODE,
+            key: 3,
+            icon: isSourceMode ? 'eye-close' : 'eye-open',
+            tooltip: isSourceMode
+                ? i18n.t('editor.toolbar.normal_mode')
+                : i18n.t('editor.toolbar.source_mode'),
+            onClick: toggleSource,
+            disabled: false,
+            active: isSourceMode
+        }
+    ];
+    return (React.createElement(React.Fragment, null, actionButtons
+        .filter(button => !hiddenButtons.includes(button.id))
+        .map(button => (React.createElement(Button, { key: button.key, type: "icon", size: "small", onClick: button.onClick, disabled: button.disabled, tooltip: button.tooltip, icon: button.icon, className: button.active ? activeCls : '' })))));
+};

package/dist/cjs/tiptap/components/menu-bar/alignment-toolbar.d.ts

@@ -0,0 +1,12 @@
+import '@tiptap/extension-text-align';
+import type { Editor } from '@tiptap/react';
+import React from 'react';
+import type { EditorState } from '../../types';
+interface AlignmentToolbarProps {
+    editor: Editor;
+    editorState: EditorState;
+    disabled?: boolean;
+}
+export declare const AlignmentToolbar: ({ editor, editorState, disabled }: AlignmentToolbarProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=alignment-toolbar.d.ts.map

package/dist/cjs/tiptap/components/menu-bar/alignment-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignment-toolbar.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/components/menu-bar/alignment-toolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAC;AAGtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,UAAU,qBAAqB;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAUD,eAAO,MAAM,gBAAgB,GAAI,mCAI9B,qBAAqB,sBAoDvB,CAAC"}

package/dist/cjs/tiptap/components/menu-bar/alignment-toolbar.js

@@ -0,0 +1,39 @@
+import '@tiptap/extension-text-align';
+import { Button } from '@akinon/ui-button';
+import React from 'react';
+import { i18n } from '../../../i18n';
+import { ALIGNMENT_OPTIONS } from '../../constants';
+export const AlignmentToolbar = ({ editor, editorState, disabled = false }) => {
+    const activeCls = 'active';
+    const buttonGroup = [
+        {
+            key: 1,
+            icon: 'format-left-align',
+            tooltip: i18n.t('editor.toolbar.align_left'),
+            onClick: () => editor.chain().focus().setTextAlign(ALIGNMENT_OPTIONS.LEFT).run(),
+            className: editorState.isLeftAlign ? activeCls : ''
+        },
+        {
+            key: 2,
+            icon: 'format-center-align',
+            tooltip: i18n.t('editor.toolbar.align_center'),
+            onClick: () => editor.chain().focus().setTextAlign(ALIGNMENT_OPTIONS.CENTER).run(),
+            className: editorState.isCenterAlign ? activeCls : ''
+        },
+        {
+            key: 3,
+            icon: 'format-right-align',
+            tooltip: i18n.t('editor.toolbar.align_right'),
+            onClick: () => editor.chain().focus().setTextAlign(ALIGNMENT_OPTIONS.RIGHT).run(),
+            className: editorState.isRightAlign ? activeCls : ''
+        },
+        {
+            key: 4,
+            icon: 'format-justification',
+            tooltip: i18n.t('editor.toolbar.justify'),
+            onClick: () => editor.chain().focus().setTextAlign(ALIGNMENT_OPTIONS.JUSTIFY).run(),
+            className: editorState.isJustifyAlign ? activeCls : ''
+        }
+    ];
+    return (React.createElement(React.Fragment, null, buttonGroup.map(button => (React.createElement(Button, { key: button.key, type: "icon", size: "small", onClick: button.onClick, disabled: disabled, tooltip: button.tooltip, icon: button.icon, className: button.className })))));
+};

package/dist/cjs/tiptap/components/menu-bar/heading-selector.d.ts

@@ -0,0 +1,16 @@
+import '@tiptap/extension-heading';
+import '@tiptap/extension-paragraph';
+import type { Editor } from '@tiptap/react';
+import React from 'react';
+import type { EditorState, ToolbarButtonId } from '../../types';
+interface HeadingSelectorProps {
+    editor: Editor;
+    editorState: EditorState;
+    disabled?: boolean;
+    baseCls: string;
+    hashId: string;
+    hiddenButtons?: ToolbarButtonId[];
+}
+export declare const HeadingSelector: ({ editor, editorState, disabled, baseCls, hashId, hiddenButtons }: HeadingSelectorProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=heading-selector.d.ts.map

package/dist/cjs/tiptap/components/menu-bar/heading-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-selector.d.ts","sourceRoot":"","sources":["../../../../../src/tiptap/components/menu-bar/heading-selector.tsx"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC;AACnC,OAAO,6BAA6B,CAAC;AAIrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,MAAM,OAAO,CAAC;AAQ1B,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEhE,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,eAAe,EAAE,CAAC;CACnC;AAED,eAAO,MAAM,eAAe,GAAI,mEAO7B,oBAAoB,sBAsFtB,CAAC"}