@deenruv/admin-ui 1.0.0

package/esm2022/core/shared/components/rich-text-editor/prosemirror/custom-nodes.mjs

@@ -0,0 +1,97 @@
+import { DOMSerializer } from 'prosemirror-model';
+export const iframeNode = {
+    group: 'block',
+    attrs: {
+        allow: {},
+        allowfullscreeen: {},
+        frameborder: {},
+        height: { default: undefined },
+        name: { default: '' },
+        referrerpolicy: {},
+        sandbox: { default: undefined },
+        src: {},
+        srcdoc: { default: undefined },
+        title: { default: undefined },
+        width: { default: undefined },
+    },
+    parseDOM: [
+        {
+            tag: 'iframe',
+            getAttrs: node => {
+                if (node instanceof HTMLIFrameElement) {
+                    const attrs = {
+                        allow: node.allow,
+                        allowfullscreeen: node.allowFullscreen ?? true,
+                        frameborder: node.getAttribute('frameborder'),
+                        height: node.height,
+                        name: node.name,
+                        referrerpolicy: node.referrerPolicy,
+                        src: node.src,
+                        title: node.title ?? '',
+                        width: node.width,
+                        // Note: we do not allow the `srcdoc` attribute to be
+                        // set as it presents an XSS attack vector
+                    };
+                    if (node.sandbox.length) {
+                        attrs.sandbox = node.sandbox;
+                    }
+                    return attrs;
+                }
+                return null;
+            },
+        },
+    ],
+    toDOM(node) {
+        return ['iframe', { ...node.attrs, sandbox: 'allow-scripts allow-same-origin' }];
+    },
+};
+export const iframeNodeView = (node, view, getPos, decorations) => {
+    const domSerializer = DOMSerializer.fromSchema(view.state.schema);
+    const wrapper = document.createElement('div');
+    wrapper.classList.add('iframe-wrapper');
+    const iframe = domSerializer.serializeNode(node);
+    wrapper.appendChild(iframe);
+    return {
+        dom: wrapper,
+    };
+};
+export const linkMark = {
+    attrs: {
+        href: {},
+        title: { default: null },
+        target: { default: null },
+        rel: { default: null },
+        download: { default: null },
+        type: { default: null },
+    },
+    inclusive: false,
+    parseDOM: [
+        {
+            tag: 'a[href]',
+            getAttrs(dom) {
+                if (typeof dom !== 'string') {
+                    return {
+                        href: dom.getAttribute('href'),
+                        title: dom.getAttribute('title'),
+                        target: dom.getAttribute('target'),
+                        rel: dom.getAttribute('rel'),
+                        download: dom.getAttribute('download'),
+                        type: dom.getAttribute('type'),
+                    };
+                }
+                else {
+                    return null;
+                }
+            },
+        },
+    ],
+    toDOM(node) {
+        const { href, title, target, rel, download, type } = node.attrs;
+        const attrs = { href, title, rel, download, type };
+        if (target) {
+            attrs['target'] = target;
+        }
+        return ['a', attrs, 0];
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-nodes.js","sourceRoot":"","sources":["../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/custom-nodes.ts"],"names":[],"mappings":"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","sourcesContent":["import { Attrs, DOMParser, DOMSerializer, Node, NodeSpec, Mark, MarkSpec } from 'prosemirror-model';\nimport { NodeViewConstructor } from 'prosemirror-view';\n\nexport const iframeNode: NodeSpec = {\n    group: 'block',\n    attrs: {\n        allow: {},\n        allowfullscreeen: {},\n        frameborder: {},\n        height: { default: undefined },\n        name: { default: '' },\n        referrerpolicy: {},\n        sandbox: { default: undefined },\n        src: {},\n        srcdoc: { default: undefined },\n        title: { default: undefined },\n        width: { default: undefined },\n    },\n    parseDOM: [\n        {\n            tag: 'iframe',\n            getAttrs: node => {\n                if (node instanceof HTMLIFrameElement) {\n                    const attrs: Record<string, any> = {\n                        allow: node.allow,\n                        allowfullscreeen: node.allowFullscreen ?? true,\n                        frameborder: node.getAttribute('frameborder'),\n                        height: node.height,\n                        name: node.name,\n                        referrerpolicy: node.referrerPolicy,\n                        src: node.src,\n                        title: node.title ?? '',\n                        width: node.width,\n                        // Note: we do not allow the `srcdoc` attribute to be\n                        // set as it presents an XSS attack vector\n                    };\n                    if (node.sandbox.length) {\n                        attrs.sandbox = node.sandbox;\n                    }\n                    return attrs;\n                }\n                return null;\n            },\n        },\n    ],\n    toDOM(node) {\n        return ['iframe', { ...node.attrs, sandbox: 'allow-scripts allow-same-origin' }];\n    },\n};\n\nexport const iframeNodeView: NodeViewConstructor = (node, view, getPos, decorations) => {\n    const domSerializer = DOMSerializer.fromSchema(view.state.schema);\n    const wrapper = document.createElement('div');\n    wrapper.classList.add('iframe-wrapper');\n    const iframe = domSerializer.serializeNode(node);\n    wrapper.appendChild(iframe);\n    return {\n        dom: wrapper,\n    };\n};\n\nexport const linkMark: MarkSpec = {\n    attrs: {\n        href: {},\n        title: { default: null },\n        target: { default: null },\n        rel: { default: null },\n        download: { default: null },\n        type: { default: null },\n    },\n    inclusive: false,\n    parseDOM: [\n        {\n            tag: 'a[href]',\n            getAttrs(dom: HTMLElement | string) {\n                if (typeof dom !== 'string') {\n                    return {\n                        href: dom.getAttribute('href'),\n                        title: dom.getAttribute('title'),\n                        target: dom.getAttribute('target'),\n                        rel: dom.getAttribute('rel'),\n                        download: dom.getAttribute('download'),\n                        type: dom.getAttribute('type'),\n                    };\n                } else {\n                    return null;\n                }\n            },\n        },\n    ],\n    toDOM(node) {\n        const { href, title, target, rel, download, type } = node.attrs;\n        const attrs = { href, title, rel, download, type };\n        if (target) {\n            attrs['target'] = target;\n        }\n        return ['a', attrs, 0];\n    },\n};\n"]}

package/esm2022/core/shared/components/rich-text-editor/prosemirror/inputrules.mjs

@@ -0,0 +1,61 @@
+import { ellipsis, emDash, inputRules, smartQuotes, textblockTypeInputRule, wrappingInputRule, } from 'prosemirror-inputrules';
+// : (NodeType) → InputRule
+// Given a blockquote node type, returns an input rule that turns `"> "`
+// at the start of a textblock into a blockquote.
+export function blockQuoteRule(nodeType) {
+    return wrappingInputRule(/^\s*>\s$/, nodeType);
+}
+// : (NodeType) → InputRule
+// Given a list node type, returns an input rule that turns a number
+// followed by a dot at the start of a textblock into an ordered list.
+export function orderedListRule(nodeType) {
+    return wrappingInputRule(/^(\d+)\.\s$/, nodeType, match => ({ order: +match[1] }), (match, node) => node.childCount + node.attrs.order === +match[1]);
+}
+// : (NodeType) → InputRule
+// Given a list node type, returns an input rule that turns a bullet
+// (dash, plush, or asterisk) at the start of a textblock into a
+// bullet list.
+export function bulletListRule(nodeType) {
+    return wrappingInputRule(/^\s*([-+*])\s$/, nodeType);
+}
+// : (NodeType) → InputRule
+// Given a code block node type, returns an input rule that turns a
+// textblock starting with three backticks into a code block.
+export function codeBlockRule(nodeType) {
+    return textblockTypeInputRule(/^```$/, nodeType);
+}
+// : (NodeType, number) → InputRule
+// Given a node type and a maximum level, creates an input rule that
+// turns up to that number of `#` characters followed by a space at
+// the start of a textblock into a heading whose level corresponds to
+// the number of `#` signs.
+export function headingRule(nodeType, maxLevel) {
+    return textblockTypeInputRule(new RegExp('^(#{1,' + maxLevel + '})\\s$'), nodeType, match => ({
+        level: match[1].length,
+    }));
+}
+// : (Schema) → Plugin
+// A set of input rules for creating the basic block quotes, lists,
+// code blocks, and heading.
+export function buildInputRules(schema) {
+    const rules = smartQuotes.concat(ellipsis, emDash);
+    let type;
+    /* eslint-disable no-cond-assign */
+    if ((type = schema.nodes.blockquote)) {
+        rules.push(blockQuoteRule(type));
+    }
+    if ((type = schema.nodes.ordered_list)) {
+        rules.push(orderedListRule(type));
+    }
+    if ((type = schema.nodes.bullet_list)) {
+        rules.push(bulletListRule(type));
+    }
+    if ((type = schema.nodes.code_block)) {
+        rules.push(codeBlockRule(type));
+    }
+    if ((type = schema.nodes.heading)) {
+        rules.push(headingRule(type, 6));
+    }
+    return inputRules({ rules });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/components/rich-text-editor/prosemirror/keymap.mjs

@@ -0,0 +1,118 @@
+import { chainCommands, exitCode, joinDown, joinUp, lift, selectParentNode, setBlockType, toggleMark, wrapIn, } from 'prosemirror-commands';
+import { redo, undo } from 'prosemirror-history';
+import { undoInputRule } from 'prosemirror-inputrules';
+import { liftListItem, sinkListItem, splitListItem, wrapInList } from 'prosemirror-schema-list';
+const mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
+// :: (Schema, ?Object) → Object
+// Inspect the given schema looking for marks and nodes from the
+// basic schema, and if found, add key bindings related to them.
+// This will add:
+//
+// * **Mod-b** for toggling [strong](#schema-basic.StrongMark)
+// * **Mod-i** for toggling [emphasis](#schema-basic.EmMark)
+// * **Mod-`** for toggling [code font](#schema-basic.CodeMark)
+// * **Ctrl-Shift-0** for making the current textblock a paragraph
+// * **Ctrl-Shift-1** to **Ctrl-Shift-Digit6** for making the current
+//   textblock a heading of the corresponding level
+// * **Ctrl-Shift-Backslash** to make the current textblock a code block
+// * **Ctrl-Shift-8** to wrap the selection in an ordered list
+// * **Ctrl-Shift-9** to wrap the selection in a bullet list
+// * **Ctrl->** to wrap the selection in a block quote
+// * **Enter** to split a non-empty textblock in a list item while at
+//   the same time splitting the list item
+// * **Mod-Enter** to insert a hard break
+// * **Mod-_** to insert a horizontal rule
+// * **Backspace** to undo an input rule
+// * **Alt-ArrowUp** to `joinUp`
+// * **Alt-ArrowDown** to `joinDown`
+// * **Mod-BracketLeft** to `lift`
+// * **Escape** to `selectParentNode`
+//
+// You can suppress or map these bindings by passing a `mapKeys`
+// argument, which maps key names (say `"Mod-B"` to either `false`, to
+// remove the binding, or a new key name string.
+export function buildKeymap(schema, mapKeys) {
+    const keys = {};
+    let type;
+    function bind(key, cmd) {
+        if (mapKeys) {
+            const mapped = mapKeys[key];
+            if (mapped === false) {
+                return;
+            }
+            if (mapped) {
+                key = mapped;
+            }
+        }
+        keys[key] = cmd;
+    }
+    bind('Mod-z', undo);
+    bind('Shift-Mod-z', redo);
+    bind('Backspace', undoInputRule);
+    if (!mac) {
+        bind('Mod-y', redo);
+    }
+    bind('Alt-ArrowUp', joinUp);
+    bind('Alt-ArrowDown', joinDown);
+    bind('Mod-BracketLeft', lift);
+    bind('Escape', selectParentNode);
+    /* eslint-disable no-cond-assign */
+    if ((type = schema.marks.strong)) {
+        bind('Mod-b', toggleMark(type));
+        bind('Mod-B', toggleMark(type));
+    }
+    if ((type = schema.marks.em)) {
+        bind('Mod-i', toggleMark(type));
+        bind('Mod-I', toggleMark(type));
+    }
+    if ((type = schema.marks.code)) {
+        bind('Mod-`', toggleMark(type));
+    }
+    if ((type = schema.nodes.bullet_list)) {
+        bind('Shift-Ctrl-8', wrapInList(type));
+    }
+    if ((type = schema.nodes.ordered_list)) {
+        bind('Shift-Ctrl-9', wrapInList(type));
+    }
+    if ((type = schema.nodes.blockquote)) {
+        bind('Ctrl->', wrapIn(type));
+    }
+    if ((type = schema.nodes.hard_break)) {
+        const br = type;
+        const cmd = chainCommands(exitCode, (state, dispatch) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+            return true;
+        });
+        bind('Mod-Enter', cmd);
+        bind('Shift-Enter', cmd);
+        if (mac) {
+            bind('Ctrl-Enter', cmd);
+        }
+    }
+    if ((type = schema.nodes.list_item)) {
+        bind('Enter', splitListItem(type));
+        bind('Mod-[', liftListItem(type));
+        bind('Mod-]', sinkListItem(type));
+    }
+    if ((type = schema.nodes.paragraph)) {
+        bind('Shift-Ctrl-0', setBlockType(type));
+    }
+    if ((type = schema.nodes.code_block)) {
+        bind('Shift-Ctrl-\\', setBlockType(type));
+    }
+    if ((type = schema.nodes.heading)) {
+        for (let i = 1; i <= 6; i++) {
+            bind('Shift-Ctrl-' + i, setBlockType(type, { level: i }));
+        }
+    }
+    if ((type = schema.nodes.horizontal_rule)) {
+        const hr = type;
+        bind('Mod-_', (state, dispatch) => {
+            dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());
+            return true;
+        });
+    }
+    return keys;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keymap.js","sourceRoot":"","sources":["../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/keymap.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    chainCommands,\n    exitCode,\n    joinDown,\n    joinUp,\n    lift,\n    selectParentNode,\n    setBlockType,\n    toggleMark,\n    wrapIn,\n} from 'prosemirror-commands';\nimport { redo, undo } from 'prosemirror-history';\nimport { undoInputRule } from 'prosemirror-inputrules';\nimport { MarkType, NodeType, Schema } from 'prosemirror-model';\nimport { liftListItem, sinkListItem, splitListItem, wrapInList } from 'prosemirror-schema-list';\n\nimport { Keymap } from './types';\n\nconst mac = typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;\n\n// :: (Schema, ?Object) → Object\n// Inspect the given schema looking for marks and nodes from the\n// basic schema, and if found, add key bindings related to them.\n// This will add:\n//\n// * **Mod-b** for toggling [strong](#schema-basic.StrongMark)\n// * **Mod-i** for toggling [emphasis](#schema-basic.EmMark)\n// * **Mod-`** for toggling [code font](#schema-basic.CodeMark)\n// * **Ctrl-Shift-0** for making the current textblock a paragraph\n// * **Ctrl-Shift-1** to **Ctrl-Shift-Digit6** for making the current\n//   textblock a heading of the corresponding level\n// * **Ctrl-Shift-Backslash** to make the current textblock a code block\n// * **Ctrl-Shift-8** to wrap the selection in an ordered list\n// * **Ctrl-Shift-9** to wrap the selection in a bullet list\n// * **Ctrl->** to wrap the selection in a block quote\n// * **Enter** to split a non-empty textblock in a list item while at\n//   the same time splitting the list item\n// * **Mod-Enter** to insert a hard break\n// * **Mod-_** to insert a horizontal rule\n// * **Backspace** to undo an input rule\n// * **Alt-ArrowUp** to `joinUp`\n// * **Alt-ArrowDown** to `joinDown`\n// * **Mod-BracketLeft** to `lift`\n// * **Escape** to `selectParentNode`\n//\n// You can suppress or map these bindings by passing a `mapKeys`\n// argument, which maps key names (say `\"Mod-B\"` to either `false`, to\n// remove the binding, or a new key name string.\nexport function buildKeymap(schema: Schema, mapKeys?: Keymap) {\n    const keys = {};\n    let type: MarkType | NodeType;\n    function bind(key: string, cmd: (...args: any[]) => boolean) {\n        if (mapKeys) {\n            const mapped = mapKeys[key];\n            if (mapped === false) {\n                return;\n            }\n            if (mapped) {\n                key = mapped;\n            }\n        }\n        keys[key] = cmd;\n    }\n\n    bind('Mod-z', undo);\n    bind('Shift-Mod-z', redo);\n    bind('Backspace', undoInputRule);\n    if (!mac) {\n        bind('Mod-y', redo);\n    }\n\n    bind('Alt-ArrowUp', joinUp);\n    bind('Alt-ArrowDown', joinDown);\n    bind('Mod-BracketLeft', lift);\n    bind('Escape', selectParentNode);\n\n    /* eslint-disable no-cond-assign */\n    if ((type = schema.marks.strong)) {\n        bind('Mod-b', toggleMark(type));\n        bind('Mod-B', toggleMark(type));\n    }\n    if ((type = schema.marks.em)) {\n        bind('Mod-i', toggleMark(type));\n        bind('Mod-I', toggleMark(type));\n    }\n    if ((type = schema.marks.code)) {\n        bind('Mod-`', toggleMark(type));\n    }\n\n    if ((type = schema.nodes.bullet_list)) {\n        bind('Shift-Ctrl-8', wrapInList(type));\n    }\n    if ((type = schema.nodes.ordered_list)) {\n        bind('Shift-Ctrl-9', wrapInList(type));\n    }\n    if ((type = schema.nodes.blockquote)) {\n        bind('Ctrl->', wrapIn(type));\n    }\n    if ((type = schema.nodes.hard_break)) {\n        const br = type;\n        const cmd = chainCommands(exitCode, (state, dispatch) => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            dispatch!(state.tr.replaceSelectionWith(br.create()).scrollIntoView());\n            return true;\n        });\n        bind('Mod-Enter', cmd);\n        bind('Shift-Enter', cmd);\n        if (mac) {\n            bind('Ctrl-Enter', cmd);\n        }\n    }\n    if ((type = schema.nodes.list_item)) {\n        bind('Enter', splitListItem(type));\n        bind('Mod-[', liftListItem(type));\n        bind('Mod-]', sinkListItem(type));\n    }\n    if ((type = schema.nodes.paragraph)) {\n        bind('Shift-Ctrl-0', setBlockType(type));\n    }\n    if ((type = schema.nodes.code_block)) {\n        bind('Shift-Ctrl-\\\\', setBlockType(type));\n    }\n    if ((type = schema.nodes.heading)) {\n        for (let i = 1; i <= 6; i++) {\n            bind('Shift-Ctrl-' + i, setBlockType(type, { level: i }));\n        }\n    }\n    if ((type = schema.nodes.horizontal_rule)) {\n        const hr = type;\n        bind('Mod-_', (state, dispatch) => {\n            dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());\n            return true;\n        });\n    }\n\n    return keys;\n}\n"]}

package/esm2022/core/shared/components/rich-text-editor/prosemirror/menu/links.mjs

@@ -0,0 +1,69 @@
+import { MenuItem } from 'prosemirror-menu';
+import { TextSelection } from 'prosemirror-state';
+import { LinkDialogComponent } from '../../link-dialog/link-dialog.component';
+import { markActive, renderClarityIcon } from './menu-common';
+function selectionIsWithinLink(state, anchor, head) {
+    const { doc } = state;
+    const headLink = doc
+        .resolve(head)
+        .marks()
+        .find(m => m.type.name === 'link');
+    const anchorLink = doc
+        .resolve(anchor)
+        .marks()
+        .find(m => m.type.name === 'link');
+    if (headLink && anchorLink && headLink.eq(anchorLink)) {
+        return true;
+    }
+    return false;
+}
+export function linkItem(linkMark, modalService) {
+    return new MenuItem({
+        title: 'Add or remove link',
+        render: renderClarityIcon({ shape: 'link', size: 22 }),
+        class: '',
+        css: '',
+        active(state) {
+            return markActive(state, linkMark);
+        },
+        enable(state) {
+            const { selection } = state;
+            return !selection.empty || selectionIsWithinLink(state, selection.anchor, selection.head);
+        },
+        run(state, dispatch, view) {
+            let attrs;
+            const { selection, doc } = state;
+            if (selection instanceof TextSelection &&
+                selectionIsWithinLink(state, selection.anchor + 1, selection.head - 1)) {
+                const mark = doc
+                    .resolve(selection.anchor + 1)
+                    .marks()
+                    .find(m => m.type.name === 'link');
+                if (mark) {
+                    attrs = mark.attrs;
+                }
+            }
+            modalService
+                .fromComponent(LinkDialogComponent, {
+                closable: true,
+                locals: {
+                    existing: attrs,
+                },
+            })
+                .subscribe(result => {
+                let tr = state.tr;
+                if (result) {
+                    const { $from, $to } = selection.ranges[0];
+                    tr = tr.removeMark($from.pos, $to.pos, linkMark);
+                    if (result.href !== '') {
+                        tr = tr.addMark($from.pos, $to.pos, linkMark.create(result));
+                    }
+                }
+                dispatch(tr.scrollIntoView());
+                view.focus();
+            });
+            return true;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/components/rich-text-editor/prosemirror/menu/menu-common.mjs

@@ -0,0 +1,41 @@
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+export function markActive(state, type) {
+    const { from, $from, to, empty } = state.selection;
+    if (empty) {
+        return type.isInSet(state.storedMarks || $from.marks());
+    }
+    else {
+        return state.doc.rangeHasMark(from, to, type);
+    }
+}
+export function canInsert(state, nodeType) {
+    const $from = state.selection.$from;
+    for (let d = $from.depth; d >= 0; d--) {
+        const index = $from.index(d);
+        if ($from.node(d).canReplaceWith(index, index, nodeType)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function renderClarityIcon(options) {
+    return (view) => {
+        const icon = document.createElement('clr-icon');
+        icon.setAttribute('shape', options.shape);
+        icon.setAttribute('size', (options.size ?? IconSize.Small).toString());
+        const labelEl = document.createElement('span');
+        labelEl.textContent = options.label ?? '';
+        return wrapInMenuItemWithIcon(icon, options.label ? labelEl : undefined);
+    };
+}
+export function wrapInMenuItemWithIcon(...elements) {
+    const wrapperEl = document.createElement('span');
+    wrapperEl.classList.add('menu-item-with-icon');
+    wrapperEl.append(...elements.filter(notNullOrUndefined));
+    return wrapperEl;
+}
+export const IconSize = {
+    Large: 22,
+    Small: 16,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/components/rich-text-editor/prosemirror/menu/menu-plugin.mjs

@@ -0,0 +1,12 @@
+import { menuBar } from 'prosemirror-menu';
+import { ModalService } from '../../../../../providers/modal/modal.service';
+import { buildMenuItems } from './menu';
+export function customMenuPlugin(options) {
+    const modalService = options.injector.get(ModalService);
+    const pmMenuBarPlugin = menuBar({
+        floating: options.floatingMenu !== false,
+        content: buildMenuItems(options.schema, modalService).fullMenu,
+    });
+    return pmMenuBarPlugin;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvbWVudS9tZW51LXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJM0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBRTVFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFReEMsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQWdDO0lBQzdELE1BQU0sWUFBWSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3hELE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQztRQUM1QixRQUFRLEVBQUUsT0FBTyxDQUFDLFlBQVksS0FBSyxLQUFLO1FBQ3hDLE9BQU8sRUFBRSxjQUFjLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQyxRQUFRO0tBQ2pFLENBQUMsQ0FBQztJQUNILE9BQU8sZUFBZSxDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgbWVudUJhciB9IGZyb20gJ3Byb3NlbWlycm9yLW1lbnUnO1xuaW1wb3J0IHsgU2NoZW1hIH0gZnJvbSAncHJvc2VtaXJyb3ItbW9kZWwnO1xuaW1wb3J0IHsgRWRpdG9yU3RhdGUsIFBsdWdpbiB9IGZyb20gJ3Byb3NlbWlycm9yLXN0YXRlJztcblxuaW1wb3J0IHsgTW9kYWxTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vcHJvdmlkZXJzL21vZGFsL21vZGFsLnNlcnZpY2UnO1xuXG5pbXBvcnQgeyBidWlsZE1lbnVJdGVtcyB9IGZyb20gJy4vbWVudSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3VzdG9tTWVudVBsdWdpbk9wdGlvbnMge1xuICAgIGZsb2F0aW5nTWVudT86IGJvb2xlYW47XG4gICAgc2NoZW1hOiBTY2hlbWE7XG4gICAgaW5qZWN0b3I6IEluamVjdG9yO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gY3VzdG9tTWVudVBsdWdpbihvcHRpb25zOiBDdXN0b21NZW51UGx1Z2luT3B0aW9ucykge1xuICAgIGNvbnN0IG1vZGFsU2VydmljZSA9IG9wdGlvbnMuaW5qZWN0b3IuZ2V0KE1vZGFsU2VydmljZSk7XG4gICAgY29uc3QgcG1NZW51QmFyUGx1Z2luID0gbWVudUJhcih7XG4gICAgICAgIGZsb2F0aW5nOiBvcHRpb25zLmZsb2F0aW5nTWVudSAhPT0gZmFsc2UsXG4gICAgICAgIGNvbnRlbnQ6IGJ1aWxkTWVudUl0ZW1zKG9wdGlvbnMuc2NoZW1hLCBtb2RhbFNlcnZpY2UpLmZ1bGxNZW51LFxuICAgIH0pO1xuICAgIHJldHVybiBwbU1lbnVCYXJQbHVnaW47XG59XG4iXX0=