@cccsaurora/howler-ui 2.14.0-dev.269 → 2.14.0-dev.271

package/components/elements/addons/search/phrase/Phrase.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ClickAwayListener, InputAdornment, ListItemText, MenuItem, MenuList, Paper, Popper, TextField } from '@mui/material';
+import { parseEvent } from '@cccsaurora/howler-ui/commons/components/utils/keyboard';
+import { useEffect, useRef, useState } from 'react';
+import WordLexer from './word/WordLexer';
+import WordSuggestor from './word/WordSuggester';
+const Phrase = ({ value = '', variant = 'outlined', suggestions = [], lexer, suggester, debug, startAdornment, endAdornment, onChange, onKeyDown, ...props }) => {
+    const containerRef = useRef();
+    const inputRef = useRef();
+    const menuRef = useRef();
+    const lexerRef = useRef(lexer || new WordLexer());
+    const analysisRef = useRef();
+    const suggesterRef = useRef(suggester || new WordSuggestor(suggestions));
+    const [optionsOpen, setOptionsOpen] = useState(false);
+    const [options, setOptions] = useState(suggestions);
+    useEffect(() => {
+        suggesterRef.current = suggester || new WordSuggestor(suggestions);
+    }, [suggester, suggestions]);
+    const lex = (inputValue, offset = 0) => {
+        let cursor = inputRef.current.querySelector('input').selectionStart + offset;
+        cursor = cursor < 0 ? 0 : cursor > inputValue.length ? inputValue.length : cursor;
+        analysisRef.current = lexerRef.current.parse(inputValue, cursor);
+        return analysisRef.current;
+    };
+    const onWordClick = (word) => {
+        const { suggest } = analysisRef.current;
+        const inputEl = inputRef.current.querySelector('input');
+        // NOTE: this is the only thing that works well with UNDO/REDO
+        // NOTE: the 'deprecated' insertText has no proper replacement to support this yet.
+        inputEl.focus();
+        inputEl.setSelectionRange(suggest.token.startIndex, suggest.token.endIndex + 1);
+        document.execCommand('insertText', false, word);
+        // NOTE: setRangeText does not work with UNDO/REDO [CTRL+Z|CTRL+SHIFT+Z]
+        // inputEl.setRangeText(word, current.startIndex, current.endIndex + 1, 'end');
+        setOptionsOpen(false);
+    };
+    const _suggest = (inputValue, offset = 0) => {
+        const _suggestions = suggesterRef.current.suggest(lex(inputValue, offset));
+        setOptions(_suggestions?.length > 0 ? _suggestions : [...suggestions]);
+    };
+    const _onChange = (event) => {
+        onChange(event.target.value);
+    };
+    const _onInputKeyDown = (event) => {
+        const parsedEvent = parseEvent(event);
+        const { isEnter, isCtrl, isSpace, isEscape, isArrowDown } = parsedEvent;
+        if (isArrowDown) {
+            event.preventDefault(); // prevent native scroll.
+            menuRef.current.focus(); // ensure suggestion menu gets focus.
+        }
+        else if (isCtrl && isSpace) {
+            setOptionsOpen(true);
+            _suggest(value);
+        }
+        else if (isEscape) {
+            setOptionsOpen(!optionsOpen);
+        }
+        if (isEnter && optionsOpen && options.length === 1) {
+            onWordClick(options[0]);
+            event.preventDefault();
+        }
+        else if (onKeyDown) {
+            onKeyDown(parsedEvent);
+        }
+    };
+    const _onSelectCapture = event => {
+        if (optionsOpen) {
+            _suggest(event.target.value);
+        }
+    };
+    const _onMenuKeyDown = (event) => {
+        const { isEscape } = parseEvent(event);
+        if (isEscape) {
+            inputRef.current.focus();
+            setOptionsOpen(false);
+        }
+    };
+    return (_jsx(ClickAwayListener, { onClickAway: () => setOptionsOpen(false), children: _jsxs("div", { ref: containerRef, style: { position: 'relative' }, children: [_jsx(TextField, { ref: inputRef, ...props, fullWidth: true, autoComplete: "off", value: value, variant: variant, onChange: _onChange, onKeyDown: _onInputKeyDown, InputProps: {
+                        ...props.InputProps,
+                        onSelectCapture: _onSelectCapture,
+                        startAdornment: startAdornment && _jsx(InputAdornment, { position: "start", children: startAdornment }),
+                        endAdornment: endAdornment && _jsx(InputAdornment, { position: "end", children: endAdornment })
+                    } }), _jsx(Popper, { anchorEl: containerRef.current, style: { width: '100%', zIndex: 100 }, open: optionsOpen && (options.length > 0 || (debug && analysisRef.current?.tokens.length > 0)), disablePortal: true, children: _jsx(Paper, { elevation: 2, sx: { maxHeight: 200, overflow: 'auto', borderTopRightRadius: 0, borderTopLeftRadius: 0 }, children: _jsx(MenuList, { ref: menuRef, onKeyDown: _onMenuKeyDown, sx: {
+                                '&:focus': {
+                                    outline: 'none'
+                                }
+                            }, children: options?.map(o => (_jsx(MenuItem, { onClick: () => onWordClick(o), children: _jsx(ListItemText, { children: o }) }, o))) }) }) })] }) }));
+};
+export default Phrase;

package/components/elements/addons/search/phrase/PhraseConsumer.d.ts

@@ -0,0 +1,13 @@
+import type { PhraseToken } from '.';
+import type PhraseLexer from './PhraseLexer';
+export default abstract class PhraseConsumer<L extends PhraseLexer> {
+    protected _buffer: any[];
+    reset(): void;
+    init(buffer: string[], _lexer?: L): void;
+    append(next: string, _lexer?: L): void;
+    bufferValue(): string;
+    endsWithAny(...values: string[]): boolean;
+    test(regex: RegExp): boolean;
+    abstract lock(lexer: L): boolean;
+    abstract consume(lexer: L): PhraseToken;
+}

package/components/elements/addons/search/phrase/PhraseConsumer.js

@@ -0,0 +1,22 @@
+export default class PhraseConsumer {
+    _buffer = [];
+    reset() {
+        this._buffer = [];
+    }
+    init(buffer, _lexer) {
+        this._buffer = [...buffer];
+    }
+    append(next, _lexer) {
+        this._buffer.push(next);
+    }
+    bufferValue() {
+        return this._buffer.join('');
+    }
+    endsWithAny(...values) {
+        const _bufferValue = this.bufferValue();
+        return values.some(v => _bufferValue.endsWith(v));
+    }
+    test(regex) {
+        return regex.test(this.bufferValue());
+    }
+}

package/components/elements/addons/search/phrase/PhraseLexer.d.ts

@@ -0,0 +1,26 @@
+import type { PhraseAnalysis } from '.';
+import type PhraseConsumer from './PhraseConsumer';
+export default abstract class PhraseLexer {
+    private _phrase;
+    private _buffer;
+    private _tokens;
+    private _consumers;
+    private _consumer;
+    private _startIndex;
+    private _endIndex;
+    private find;
+    parse(phrase: string, cursor?: number): PhraseAnalysis;
+    lock(): PhraseConsumer<PhraseLexer>;
+    buffer(): string[];
+    bufferValue(): string;
+    start(): number;
+    end(): number;
+    ahead(inc?: number): string;
+    behind(inc?: number): string;
+    behindEndsWithAny(trim: boolean, ...values: string[]): boolean;
+    testBehind(regex: RegExp): boolean;
+    aheadStartsWithAny(trim: boolean, ...values: string[]): boolean;
+    aheadIsEmpty(trim?: boolean): boolean;
+    testAhead(regex: RegExp): boolean;
+    abstract consumers(): PhraseConsumer<PhraseLexer>[];
+}

package/components/elements/addons/search/phrase/PhraseLexer.js

@@ -0,0 +1,130 @@
+export default class PhraseLexer {
+    _phrase = null;
+    _buffer = null;
+    _tokens = null;
+    _consumers = null;
+    _consumer = null;
+    _startIndex = 0;
+    _endIndex = -1;
+    find(cursor, tokens) {
+        const index = tokens.findIndex(t => t.startIndex <= cursor && cursor <= t.endIndex);
+        const token = tokens.at(index);
+        return { index, token };
+    }
+    parse(phrase, cursor = 0) {
+        this._phrase = phrase;
+        this._buffer = [];
+        this._tokens = [];
+        this._consumers = this.consumers();
+        this._consumer = null;
+        this._startIndex = 0;
+        this._endIndex = -1;
+        for (let i = 0; i < this._phrase.length; i++) {
+            this._endIndex += 1;
+            const next = this._phrase[i];
+            this._buffer.push(next);
+            // console.log(this._buffer.join(''));
+            // Prevent duplication of next character
+            //  when aquiring new consumer lock.
+            let newLock = false;
+            // Try to find a consumer to lock on.
+            if (!this._consumer) {
+                this._consumer = this.lock();
+                if (this._consumer) {
+                    newLock = true;
+                    // console.log('new lock...');
+                    // console.log(this._consumer);
+                    this._consumer.init(this._buffer, this);
+                }
+            }
+            // If we have a consumer, write next character into it
+            //  and then see if it can consume the buffer.
+            if (this._consumer) {
+                if (newLock) {
+                    newLock = false;
+                }
+                else {
+                    this._consumer.append(next, this);
+                }
+                const token = this._consumer.consume(this);
+                if (token) {
+                    this._tokens.push(token);
+                    this._buffer = [];
+                    this._consumer = null;
+                    this._startIndex = this._endIndex + 1;
+                }
+            }
+        }
+        // Always add a EOP (end-of-phrase) token.
+        this._tokens.push({ type: 'eop', startIndex: phrase.length, endIndex: phrase.length, value: '' });
+        // Flatten token structure.
+        // By collapsing all children token, we can find the exact token for the current cursor position.
+        const flatTokens = this._tokens.flatMap(t => (t.children && t.children.length > 0 ? t.children : [t]));
+        // Find the index of the token within range or cursor.
+        const { token: parent, index: parentIndex } = this.find(cursor, this._tokens);
+        const { token: current, index: currentIndex } = this.find(cursor, flatTokens);
+        // Figure out which token to use to generate suggestions.
+        // When at the start of a token, use the previous one.
+        // console.log(currentIndex);
+        // console.log(flatTokens[currentIndex - 1]);
+        const filter = cursor === current.startIndex && flatTokens[currentIndex - 1] ? flatTokens[currentIndex - 1] : current;
+        return {
+            cursor,
+            parentIndex,
+            parent,
+            currentIndex,
+            current,
+            suggest: {
+                token: filter,
+                parent: this.find(filter.startIndex, this._tokens).token,
+                value: filter.value.substring(0, cursor - filter.startIndex)
+            },
+            tokens: this._tokens
+        };
+    }
+    lock() {
+        return this._consumers.find(c => c.lock(this));
+    }
+    buffer() {
+        return this._buffer;
+    }
+    bufferValue() {
+        return this._buffer.join('');
+    }
+    start() {
+        return this._startIndex;
+    }
+    end() {
+        return this._endIndex;
+    }
+    ahead(inc) {
+        const start = this._endIndex + 1;
+        if (inc) {
+            return this._phrase.slice(start, start + inc);
+        }
+        return this._phrase.substring(start);
+    }
+    behind(inc) {
+        if (inc) {
+            return this.bufferValue().slice(-inc);
+        }
+        return this.bufferValue();
+    }
+    behindEndsWithAny(trim, ...values) {
+        const behind = trim ? this.behind().trimEnd() : this.behind();
+        return values.some(v => behind.endsWith(v));
+    }
+    testBehind(regex) {
+        return regex.test(this.behind());
+    }
+    aheadStartsWithAny(trim, ...values) {
+        const ahead = trim ? this.ahead().trimStart() : this.ahead();
+        return values.some(v => ahead.startsWith(v));
+    }
+    aheadIsEmpty(trim = false) {
+        return trim ? this.ahead().trim().length === 0 : this.ahead().length === 0;
+    }
+    testAhead(regex) {
+        return regex.test(this.ahead());
+    }
+}

package/components/elements/addons/search/phrase/index.d.ts

@@ -0,0 +1,40 @@
+export type PhraseAnalysis = {
+    cursor: number;
+    parentIndex: number;
+    parent: PhraseToken;
+    currentIndex: number;
+    current: PhraseToken;
+    suggest: {
+        token: PhraseToken;
+        parent: PhraseToken;
+        value: string;
+    };
+    tokens?: PhraseToken[];
+};
+export type PhraseToken = {
+    value: string;
+    startIndex: number;
+    endIndex: number;
+    type?: string;
+    children?: PhraseToken[];
+};
+export type PhraseSuggester = {
+    suggest: (phrase: PhraseAnalysis) => string[];
+};
+export type PhraseSuggestorValue = {
+    field: string;
+    values: string[];
+};
+export declare class PhraseBuffer {
+    constructor(type?: string);
+    private type;
+    private startIndex;
+    private endIndex;
+    private buffer;
+    init(startIndex: number, buffer?: string[]): PhraseBuffer;
+    append(value: string): PhraseBuffer;
+    value(): string;
+    start(index?: number): number;
+    end(index?: number): number;
+    token(): PhraseToken;
+}

package/components/elements/addons/search/phrase/index.js

@@ -0,0 +1,45 @@
+export class PhraseBuffer {
+    constructor(type) {
+        this.type = type;
+    }
+    type;
+    startIndex = 0;
+    endIndex = -1;
+    buffer = [];
+    init(startIndex, buffer) {
+        this.buffer = buffer ? [...buffer] : [];
+        this.startIndex = startIndex;
+        this.endIndex = startIndex + (buffer ? buffer.length : 0);
+        return this;
+    }
+    append(value) {
+        this.buffer.push(value);
+        this.endIndex += value.length;
+        return this;
+    }
+    value() {
+        return this.buffer.join('');
+    }
+    start(index) {
+        if (index !== undefined) {
+            this.startIndex = index;
+        }
+        return this.startIndex;
+    }
+    end(index) {
+        if (index !== undefined) {
+            this.endIndex = index;
+        }
+        return this.endIndex;
+    }
+    token() {
+        return this.endIndex > 0
+            ? {
+                type: this.type,
+                value: this.value(),
+                startIndex: this.startIndex,
+                endIndex: this.endIndex - 1
+            }
+            : null;
+    }
+}

package/components/elements/addons/search/phrase/word/WordLexer.d.ts

@@ -0,0 +1,5 @@
+import type PhraseConsumer from '../PhraseConsumer';
+import PhraseLexer from '../PhraseLexer';
+export default class WordLexer extends PhraseLexer {
+    consumers(): PhraseConsumer<PhraseLexer>[];
+}

package/components/elements/addons/search/phrase/word/WordLexer.js

@@ -0,0 +1,8 @@
+import PhraseLexer from '../PhraseLexer';
+import WhitespaceConsumer from './consumers/WhitespaceConsumer';
+import WordConsumer from './consumers/WordConsumer';
+export default class WordLexer extends PhraseLexer {
+    consumers() {
+        return [new WordConsumer(), new WhitespaceConsumer()];
+    }
+}

package/components/elements/addons/search/phrase/word/WordSuggester.d.ts

@@ -0,0 +1,6 @@
+import type { PhraseAnalysis, PhraseSuggester } from '..';
+export default class WordSuggestor implements PhraseSuggester {
+    private suggestions;
+    constructor(suggestions: string[]);
+    suggest(phrase: PhraseAnalysis): string[];
+}

package/components/elements/addons/search/phrase/word/WordSuggester.js

@@ -0,0 +1,9 @@
+export default class WordSuggestor {
+    suggestions;
+    constructor(suggestions) {
+        this.suggestions = suggestions;
+    }
+    suggest(phrase) {
+        return this.suggestions.filter(s => s.indexOf(phrase.suggest.value) > -1);
+    }
+}

package/components/elements/addons/search/phrase/word/consumers/WhitespaceConsumer.d.ts

@@ -0,0 +1,7 @@
+import type { PhraseToken } from '../..';
+import PhraseConsumer from '../../PhraseConsumer';
+import type PhraseLexer from '../../PhraseLexer';
+export default class WhitespaceConsumer extends PhraseConsumer<PhraseLexer> {
+    lock(lexer: PhraseLexer): boolean;
+    consume(lexer: PhraseLexer): PhraseToken;
+}

package/components/elements/addons/search/phrase/word/consumers/WhitespaceConsumer.js

@@ -0,0 +1,17 @@
+import PhraseConsumer from '../../PhraseConsumer';
+export default class WhitespaceConsumer extends PhraseConsumer {
+    lock(lexer) {
+        return lexer.bufferValue().match(/\s/) && lexer.ahead(1) !== ' ';
+    }
+    consume(lexer) {
+        if (lexer.ahead(1) !== ' ') {
+            return {
+                type: 'whitespace',
+                startIndex: lexer.start(),
+                endIndex: lexer.end(),
+                value: this._buffer.join('')
+            };
+        }
+        return null;
+    }
+}

package/components/elements/addons/search/phrase/word/consumers/WordConsumer.d.ts

@@ -0,0 +1,7 @@
+import type { PhraseToken } from '../..';
+import PhraseConsumer from '../../PhraseConsumer';
+import type PhraseLexer from '../../PhraseLexer';
+export default class WordConsumer extends PhraseConsumer<PhraseLexer> {
+    lock(lexer: PhraseLexer): boolean;
+    consume(lexer: PhraseLexer): PhraseToken;
+}

package/components/elements/addons/search/phrase/word/consumers/WordConsumer.js

@@ -0,0 +1,17 @@
+import PhraseConsumer from '../../PhraseConsumer';
+export default class WordConsumer extends PhraseConsumer {
+    lock(lexer) {
+        return !lexer.bufferValue().match(/\s/) && (lexer.ahead(1) === ' ' || lexer.ahead(1) === '');
+    }
+    consume(lexer) {
+        if (lexer.ahead(1) === ' ' || lexer.aheadIsEmpty(true)) {
+            return {
+                type: 'word',
+                startIndex: lexer.start(),
+                endIndex: lexer.end(),
+                value: this._buffer.join('')
+            };
+        }
+        return null;
+    }
+}

package/components/elements/display/ActionButton.d.ts

@@ -0,0 +1,8 @@
+import { type ButtonProps } from '@mui/material';
+import { type FC } from 'react';
+declare const ActionButton: FC<{
+    actionId: string;
+    hitId: string;
+    label: string;
+} & ButtonProps>;
+export default ActionButton;

package/components/elements/display/ActionButton.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import useMyActionFunctions from '@cccsaurora/howler-ui/components/routes/action/useMyActionFunctions';
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const ActionButton = ({ actionId, hitId, label, ...otherProps }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { executeAction } = useMyActionFunctions();
+    const [action, setAction] = useState(null);
+    useEffect(() => {
+        dispatchApi(api.search.action.post({ query: `action_id:${actionId}`, rows: 1 })).then(result => setAction(result.items[0]));
+    }, [actionId, dispatchApi]);
+    return (_jsx(Button, { variant: otherProps.variant ?? 'outlined', disabled: !action, onClick: () => executeAction(actionId, `howler.id:${hitId}`), color: otherProps.color ?? 'primary', children: label ?? action?.name ?? t('loading') }));
+};
+export default ActionButton;

package/components/elements/display/Classification.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+declare const Classification: FC;
+export default Classification;

package/components/elements/display/Classification.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Chip, useMediaQuery, useTheme } from '@mui/material';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { useContext, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+const Classification = () => {
+    const { config } = useContext(ApiConfigContext);
+    const { t } = useTranslation();
+    const theme = useTheme();
+    const isSm = useMediaQuery(theme.breakpoints.down('md'));
+    const label = useMemo(() => {
+        if (isSm) {
+            return config.c12nDef?.UNRESTRICTED?.replace(/[a-z]/g, '').replace(/ /g, '') ?? '???';
+        }
+        else {
+            return config.c12nDef?.UNRESTRICTED ?? 'Unknown';
+        }
+    }, [config.c12nDef?.UNRESTRICTED, isSm]);
+    const color = useMemo(() => config.c12nDef?.levels_styles_map?.[label.replace(/\/\/.+/, '')]?.color ?? 'default', [config.c12nDef?.levels_styles_map, label]);
+    return _jsx(Chip, { label: t(label), color: color, sx: { mr: 1, fontSize: '.9rem', p: 2, textTransform: 'uppercase' } });
+};
+export default Classification;

package/components/elements/display/DocumentationButton.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+declare const DocumentationButton: FC;
+export default DocumentationButton;

package/components/elements/display/DocumentationButton.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Help } from '@mui/icons-material';
+import { IconButton, Tooltip } from '@mui/material';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link, useLocation } from 'react-router-dom';
+const DocumentationButton = () => {
+    const { t } = useTranslation();
+    const location = useLocation();
+    const [link, i18nKey] = useMemo(() => {
+        switch (location.pathname) {
+            case '/action': {
+                return ['/help/actions', 'documentation.open.actions'];
+            }
+            case '/search':
+            case '/advanced': {
+                return ['/help/search', 'documentation.open.search'];
+            }
+            case '/views':
+            case '/views/create': {
+                return ['/help/views', 'documentation.open.views'];
+            }
+            case '/templates':
+            case '/templates/view': {
+                return ['/help/templates', 'documentation.open.templates'];
+            }
+            default: {
+                return [null, null];
+            }
+        }
+    }, [location.pathname]);
+    return (link && (_jsx(Tooltip, { title: t(i18nKey), children: _jsx(IconButton, { size: "small", component: Link, to: link, sx: { ml: -2, color: 'text.secondary', opacity: 0.8 }, children: _jsx(Help, { sx: { fontSize: '16px' } }) }) })));
+};
+export default DocumentationButton;

package/components/elements/display/DynamicTabs.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+declare const DynamicTabs: React.FC<{
+    tabs: {
+        title: string;
+        children: React.ReactNode;
+    }[];
+}>;
+export default DynamicTabs;

package/components/elements/display/DynamicTabs.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Tab, Tabs } from '@mui/material';
+import * as React from 'react';
+const CustomTabPanel = (props) => {
+    const { children, value, index, ...other } = props;
+    return (_jsx("div", { role: "tabpanel", hidden: value !== index, id: `tabpanel-${index}`, "aria-labelledby": `tab-${index}`, ...other, children: value === index && _jsx(Box, { sx: { p: 1 }, children: children }) }));
+};
+const a11yProps = (index) => {
+    return {
+        id: `tab-${index}`,
+        'aria-controls': `tabpanel-${index}`
+    };
+};
+const DynamicTabs = ({ tabs }) => {
+    const [value, setValue] = React.useState(0);
+    const handleChange = (_event, newValue) => {
+        setValue(newValue);
+    };
+    return (_jsxs(Box, { sx: { width: '100%' }, children: [_jsx(Box, { sx: { borderBottom: 1, borderColor: 'divider' }, children: _jsx(Tabs, { value: value, onChange: handleChange, "aria-label": "dynamic tabs", children: tabs.map((t, index) => (_jsx(Tab, { label: t.title, ...a11yProps(index) }, t.title))) }) }), tabs.map((t, index) => (_jsx(CustomTabPanel, { value: value, index: index, children: t.children }, t.title)))] }));
+};
+export default DynamicTabs;

package/components/elements/display/HandlebarsMarkdown.d.ts

@@ -0,0 +1,9 @@
+import { type MarkdownProps } from '../display/Markdown';
+interface HandlebarsMarkdownProps extends MarkdownProps {
+    object?: {
+        [index: string]: any;
+    };
+    disableLinks?: boolean;
+}
+declare const _default: import("react").NamedExoticComponent<HandlebarsMarkdownProps>;
+export default _default;