@ecodev/natural-editor 41.3.0 → 42.2.0

package/esm2020/lib/utils/image.mjs

@@ -0,0 +1,81 @@
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { Plugin } from 'prosemirror-state';
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+export class ImagePlugin {
+    constructor(document) {
+        this.document = document;
+        this.plugin = new Plugin({
+            state: {
+                init() {
+                    return DecorationSet.empty;
+                },
+                apply(tr, set) {
+                    // Adjust decoration positions to changes made by the transaction
+                    set = set.map(tr.mapping, tr.doc);
+                    // See if the transaction adds or removes any placeholders
+                    const action = tr.getMeta(this);
+                    if (action && action.add) {
+                        const widget = document.createElement('placeholder');
+                        const deco = Decoration.widget(action.add.pos, widget, { id: action.add.id });
+                        set = set.add(tr.doc, [deco]);
+                    }
+                    else if (action && action.remove) {
+                        set = set.remove(set.find(undefined, undefined, spec => spec.id === action.remove.id));
+                    }
+                    return set;
+                },
+            },
+            props: {
+                decorations(state) {
+                    return this.getState(state);
+                },
+            },
+        });
+    }
+    findPlaceholder(state, id) {
+        const decorators = this.plugin.getState(state);
+        const found = decorators.find(undefined, undefined, spec => spec.id === id);
+        return found.length ? found[0].from : null;
+    }
+    startImageUpload(view, file, uploader, schema) {
+        // A fresh object to act as the ID for this upload
+        const id = {};
+        // Replace the selection with a placeholder
+        const tr = view.state.tr;
+        if (!tr.selection.empty) {
+            tr.deleteSelection();
+        }
+        tr.setMeta(this.plugin, { add: { id, pos: tr.selection.from } });
+        view.dispatch(tr);
+        uploader(file).subscribe({
+            next: url => {
+                const pos = this.findPlaceholder(view.state, id);
+                // If the content around the placeholder has been deleted, drop
+                // the image
+                if (pos === null) {
+                    return;
+                }
+                // Otherwise, insert it at the placeholder's position, and remove
+                // the placeholder
+                view.dispatch(view.state.tr
+                    .replaceWith(pos, pos, schema.nodes.image.create({ src: url }))
+                    .setMeta(this.plugin, { remove: { id } }));
+            },
+            error: () => {
+                // On failure, just clean up the placeholder
+                view?.dispatch(tr.setMeta(this.plugin, { remove: { id } }));
+            },
+        });
+    }
+}
+ImagePlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImagePlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+ImagePlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImagePlugin });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImagePlugin, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.js","sourceRoot":"","sources":["../../../../../projects/natural-editor/src/lib/utils/image.ts"],"names":[],"mappings":"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","sourcesContent":["import {Decoration, DecorationSet, EditorView} from 'prosemirror-view';\nimport {EditorState, Plugin} from 'prosemirror-state';\nimport {Observable} from 'rxjs';\nimport {Schema} from 'prosemirror-model';\nimport {Inject, Injectable} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\n\nexport type ImageUploader = (file: File) => Observable<string>;\n\n@Injectable()\nexport class ImagePlugin {\n    public readonly plugin: Plugin<DecorationSet>;\n\n    public constructor(@Inject(DOCUMENT) private readonly document: Document) {\n        this.plugin = new Plugin<DecorationSet>({\n            state: {\n                init(): DecorationSet {\n                    return DecorationSet.empty;\n                },\n                apply(tr, set): DecorationSet {\n                    // Adjust decoration positions to changes made by the transaction\n                    set = set.map(tr.mapping, tr.doc);\n\n                    // See if the transaction adds or removes any placeholders\n                    const action = tr.getMeta(this);\n                    if (action && action.add) {\n                        const widget = document.createElement('placeholder');\n                        const deco = Decoration.widget(action.add.pos, widget, {id: action.add.id});\n                        set = set.add(tr.doc, [deco]);\n                    } else if (action && action.remove) {\n                        set = set.remove(set.find(undefined, undefined, spec => spec.id === action.remove.id));\n                    }\n\n                    return set;\n                },\n            },\n            props: {\n                decorations(state): DecorationSet {\n                    return this.getState(state);\n                },\n            },\n        });\n    }\n\n    private findPlaceholder(state: EditorState, id: Record<string, never>): number | null {\n        const decorators = this.plugin.getState(state);\n        const found = decorators.find(undefined, undefined, spec => spec.id === id);\n        return found.length ? found[0].from : null;\n    }\n\n    public startImageUpload(view: EditorView, file: File, uploader: ImageUploader, schema: Schema): void {\n        // A fresh object to act as the ID for this upload\n        const id = {};\n\n        // Replace the selection with a placeholder\n        const tr = view.state.tr;\n        if (!tr.selection.empty) {\n            tr.deleteSelection();\n        }\n\n        tr.setMeta(this.plugin, {add: {id, pos: tr.selection.from}});\n        view.dispatch(tr);\n\n        uploader(file).subscribe({\n            next: url => {\n                const pos = this.findPlaceholder(view.state, id);\n                // If the content around the placeholder has been deleted, drop\n                // the image\n                if (pos === null) {\n                    return;\n                }\n\n                // Otherwise, insert it at the placeholder's position, and remove\n                // the placeholder\n                view.dispatch(\n                    view.state.tr\n                        .replaceWith(pos, pos, schema.nodes.image.create({src: url}))\n                        .setMeta(this.plugin, {remove: {id}}),\n                );\n            },\n            error: () => {\n                // On failure, just clean up the placeholder\n                view?.dispatch(tr.setMeta(this.plugin, {remove: {id}}));\n            },\n        });\n    }\n}\n"]}

package/esm2020/lib/utils/items/cell-background-color-item.mjs

@@ -0,0 +1,55 @@
+import { CellSelection, isInTable, selectionCell, setCellAttr } from 'prosemirror-tables';
+import { Item } from './item';
+import { ColorDialogComponent } from '../../color-dialog/color-dialog.component';
+const setCellBackgroundColor = setCellAttr.bind(null, 'background');
+function findFirstClassInSelection(state) {
+    if (!isInTable(state)) {
+        return '';
+    }
+    // For single cell selection
+    const $cell = selectionCell(state);
+    let foundColor = $cell?.nodeAfter?.attrs.background ?? '';
+    if (foundColor) {
+        return foundColor;
+    }
+    // For multiple cells selection
+    let keepLooking = true;
+    if (state.selection instanceof CellSelection) {
+        state.selection.forEachCell(node => {
+            const color = node.attrs.background;
+            if (keepLooking && color) {
+                keepLooking = false;
+                foundColor = color;
+            }
+        });
+    }
+    return foundColor;
+}
+export class CellBackgroundColorItem extends Item {
+    constructor(dialog) {
+        super({
+            enable(state) {
+                // Pretend to set a unique color that is not already set, to test if we can any color at all
+                const cmd = setCellBackgroundColor('#000001');
+                return cmd(state);
+            },
+            run(state, dispatch, view) {
+                dialog
+                    .open(ColorDialogComponent, {
+                    data: {
+                        color: findFirstClassInSelection(state),
+                    },
+                })
+                    .afterClosed()
+                    .subscribe(result => {
+                    if (dispatch && result) {
+                        const cmd = setCellBackgroundColor(result.color);
+                        cmd(state, dispatch);
+                    }
+                    view.focus();
+                });
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/class-item.mjs

@@ -0,0 +1,86 @@
+import { AllSelection, TextSelection } from 'prosemirror-state';
+import { Item } from './item';
+import { ClassDialogComponent } from '../../class-dialog/class-dialog.component';
+function setClass(tr, classValue, allowedNodeType) {
+    const { selection, doc } = tr;
+    if (!selection || !doc) {
+        return tr;
+    }
+    const { from, to } = selection;
+    const tasks = [];
+    doc.nodesBetween(from, to, (node, pos) => {
+        const nodeType = node.type;
+        const currentClass = node.attrs.class || null;
+        if (currentClass !== classValue && allowedNodeType === nodeType) {
+            tasks.push({
+                node,
+                pos,
+                nodeType,
+            });
+        }
+        return true;
+    });
+    if (!tasks.length) {
+        return tr;
+    }
+    tasks.forEach(job => {
+        const { node, pos, nodeType } = job;
+        const newAttrs = {
+            ...node.attrs,
+            class: classValue ? classValue : null,
+        };
+        tr = tr.setNodeMarkup(pos, nodeType, newAttrs, node.marks);
+    });
+    return tr;
+}
+/**
+ * Returns the first `class` attribute that is non-empty in the selection.
+ * If not found, return empty string.
+ */
+function findFirstClassInSelection(state, allowedNodeType) {
+    const { selection, doc } = state;
+    const { from, to } = selection;
+    let keepLooking = true;
+    let foundClass = '';
+    doc.nodesBetween(from, to, node => {
+        if (keepLooking && node.type === allowedNodeType && node.attrs.class) {
+            keepLooking = false;
+            foundClass = node.attrs.class;
+        }
+        return keepLooking;
+    });
+    return foundClass;
+}
+export class ClassItem extends Item {
+    constructor(dialog, nodeType) {
+        super({
+            active: state => {
+                return !!findFirstClassInSelection(state, nodeType);
+            },
+            enable: state => {
+                const { selection } = state;
+                return selection instanceof TextSelection || selection instanceof AllSelection;
+            },
+            run: (state, dispatch, view) => {
+                dialog
+                    .open(ClassDialogComponent, {
+                    data: {
+                        class: findFirstClassInSelection(state, nodeType),
+                    },
+                })
+                    .afterClosed()
+                    .subscribe(result => {
+                    if (dispatch && result) {
+                        const { selection } = state;
+                        const tr = setClass(state.tr.setSelection(selection), result.class, nodeType);
+                        if (tr.docChanged) {
+                            dispatch?.(tr);
+                        }
+                    }
+                    view.focus();
+                });
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-item.js","sourceRoot":"","sources":["../../../../../../projects/natural-editor/src/lib/utils/items/class-item.ts"],"names":[],"mappings":"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","sourcesContent":["import {Node, NodeType} from 'prosemirror-model';\nimport {AllSelection, EditorState, TextSelection, Transaction} from 'prosemirror-state';\nimport {Item} from './item';\nimport {MatDialog} from '@angular/material/dialog';\nimport {ClassDialogComponent, ClassDialogData} from '../../class-dialog/class-dialog.component';\n\nfunction setClass(tr: Transaction, classValue: string, allowedNodeType: NodeType): Transaction {\n    const {selection, doc} = tr;\n    if (!selection || !doc) {\n        return tr;\n    }\n    const {from, to} = selection;\n\n    const tasks: {\n        node: Node;\n        pos: number;\n        nodeType: NodeType;\n    }[] = [];\n\n    doc.nodesBetween(from, to, (node, pos) => {\n        const nodeType = node.type;\n        const currentClass = node.attrs.class || null;\n        if (currentClass !== classValue && allowedNodeType === nodeType) {\n            tasks.push({\n                node,\n                pos,\n                nodeType,\n            });\n        }\n        return true;\n    });\n\n    if (!tasks.length) {\n        return tr;\n    }\n\n    tasks.forEach(job => {\n        const {node, pos, nodeType} = job;\n        const newAttrs = {\n            ...node.attrs,\n            class: classValue ? classValue : null,\n        };\n\n        tr = tr.setNodeMarkup(pos, nodeType, newAttrs, node.marks);\n    });\n\n    return tr;\n}\n\n/**\n * Returns the first `class` attribute that is non-empty in the selection.\n * If not found, return empty string.\n */\nfunction findFirstClassInSelection(state: EditorState, allowedNodeType: NodeType): string {\n    const {selection, doc} = state;\n    const {from, to} = selection;\n    let keepLooking = true;\n    let foundClass: string = '';\n\n    doc.nodesBetween(from, to, node => {\n        if (keepLooking && node.type === allowedNodeType && node.attrs.class) {\n            keepLooking = false;\n            foundClass = node.attrs.class;\n        }\n\n        return keepLooking;\n    });\n\n    return foundClass;\n}\n\nexport class ClassItem extends Item {\n    public constructor(dialog: MatDialog, nodeType: NodeType) {\n        super({\n            active: state => {\n                return !!findFirstClassInSelection(state, nodeType);\n            },\n\n            enable: state => {\n                const {selection} = state;\n                return selection instanceof TextSelection || selection instanceof AllSelection;\n            },\n\n            run: (state, dispatch, view): void => {\n                dialog\n                    .open<ClassDialogComponent, ClassDialogData, ClassDialogData>(ClassDialogComponent, {\n                        data: {\n                            class: findFirstClassInSelection(state, nodeType),\n                        },\n                    })\n                    .afterClosed()\n                    .subscribe(result => {\n                        if (dispatch && result) {\n                            const {selection} = state;\n\n                            const tr = setClass(state.tr.setSelection(selection), result.class, nodeType);\n                            if (tr.docChanged) {\n                                dispatch?.(tr);\n                            }\n                        }\n\n                        view.focus();\n                    });\n            },\n        });\n    }\n}\n"]}

package/esm2020/lib/utils/items/horizontal-rule-item.mjs

@@ -0,0 +1,24 @@
+import { Item } from './item';
+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 class HorizontalRuleItem extends Item {
+    constructor(hr) {
+        super({
+            enable(state) {
+                return canInsert(state, hr);
+            },
+            run(state, dispatch) {
+                dispatch(state.tr.replaceSelectionWith(hr.create()));
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/item.mjs

@@ -0,0 +1,39 @@
+/**
+ * One item of the menu.
+ *
+ * This is the equivalent of `MenuItem` but without all the rendering logic since we use Angular
+ * templates for rendering. Also it caches the state of the item everytime the editor state changes,
+ * so Angular can query the state as often as needed without performance hit.
+ */
+export class Item {
+    constructor(spec) {
+        this.spec = spec;
+        /**
+         * Whether the item is 'active' (for example, the item for toggling the strong mark might be active when the cursor is in strong text).
+         */
+        this.active = false;
+        /**
+         * Button is shown but disabled, because the item cannot be (un-)applied
+         */
+        this.disabled = false;
+        /**
+         * Whether the item is shown at the moment
+         */
+        this.show = true;
+    }
+    /**
+     * Update the item state according to the editor state
+     */
+    update(view, state) {
+        if (this.spec.active) {
+            this.active = this.spec.active(state);
+        }
+        if (this.spec.enable) {
+            this.disabled = !this.spec.enable(state);
+        }
+        if (this.spec.select) {
+            this.show = this.spec.select(state);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/link-item.mjs

@@ -0,0 +1,40 @@
+import { Item } from './item';
+import { toggleMark } from 'prosemirror-commands';
+import { LinkDialogComponent } from '../../link-dialog/link-dialog.component';
+import { markActive } from './utils';
+export class LinkItem extends Item {
+    constructor(markType, dialog) {
+        super({
+            active(state) {
+                return markActive(state, markType);
+            },
+            enable(state) {
+                return !state.selection.empty;
+            },
+            run(state, dispatch, view) {
+                if (markActive(state, markType)) {
+                    toggleMark(markType)(state, dispatch);
+                    return;
+                }
+                dialog
+                    .open(LinkDialogComponent, {
+                    data: {
+                        href: '',
+                        title: '',
+                    },
+                })
+                    .afterClosed()
+                    .subscribe(result => {
+                    if (result) {
+                        if (!result.title) {
+                            delete result.title;
+                        }
+                        toggleMark(markType, result)(view.state, view.dispatch);
+                    }
+                    view.focus();
+                });
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/table-item.mjs

@@ -0,0 +1,43 @@
+import { TextSelection } from 'prosemirror-state';
+import { tableNodeTypes } from 'prosemirror-tables';
+import { Item } from './item';
+function createCell(cellType, cellContent) {
+    return cellContent ? cellType.createChecked(null, cellContent) : cellType.createAndFill();
+}
+function createTable(state, rowsCount, colsCount, withHeaderRow, cellContent) {
+    const types = tableNodeTypes(state.schema);
+    const headerCells = [];
+    const cells = [];
+    for (let index = 0; index < colsCount; index += 1) {
+        const cell = createCell(types.cell, cellContent);
+        if (cell) {
+            cells.push(cell);
+        }
+        if (withHeaderRow) {
+            const headerCell = createCell(types.header_cell, cellContent);
+            if (headerCell) {
+                headerCells.push(headerCell);
+            }
+        }
+    }
+    const rows = [];
+    for (let index = 0; index < rowsCount; index += 1) {
+        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+    }
+    return types.table.createChecked(null, rows);
+}
+function addTable(state, dispatch, { rowsCount = 3, colsCount = 3, withHeaderRow = true, cellContent, } = {}) {
+    const offset = state.tr.selection.anchor + 1;
+    const nodes = createTable(state, rowsCount, colsCount, withHeaderRow, cellContent);
+    const tr = state.tr.replaceSelectionWith(nodes).scrollIntoView();
+    const resolvedPos = tr.doc.resolve(offset);
+    // move cursor into table
+    tr.setSelection(TextSelection.near(resolvedPos));
+    dispatch?.(tr);
+}
+export class AddTableItem extends Item {
+    constructor() {
+        super({ run: (editor, tr) => addTable(editor, tr) });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/text-align-item.mjs

@@ -0,0 +1,78 @@
+import { AllSelection, TextSelection } from 'prosemirror-state';
+import { Item } from './item';
+function setTextAlign(tr, schema, alignment) {
+    const { selection, doc } = tr;
+    if (!selection || !doc) {
+        return tr;
+    }
+    const { from, to } = selection;
+    const { nodes } = schema;
+    const tasks = [];
+    alignment = alignment || null;
+    const allowedNodeTypes = new Set([
+        nodes.paragraph,
+        // nodes['blockquote'],
+        // nodes['listItem'],
+        // nodes['heading'],
+    ]);
+    doc.nodesBetween(from, to, (node, pos) => {
+        const nodeType = node.type;
+        const align = node.attrs.align || null;
+        if (align !== alignment && allowedNodeTypes.has(nodeType)) {
+            tasks.push({
+                node,
+                pos,
+                nodeType,
+            });
+        }
+        return true;
+    });
+    if (!tasks.length) {
+        return tr;
+    }
+    tasks.forEach(job => {
+        const { node, pos, nodeType } = job;
+        const newAttrs = {
+            ...node.attrs,
+            align: alignment ? alignment : null,
+        };
+        tr = tr.setNodeMarkup(pos, nodeType, newAttrs, node.marks);
+    });
+    return tr;
+}
+export class TextAlignItem extends Item {
+    constructor(alignment) {
+        super({
+            active: state => {
+                const { selection, doc } = state;
+                const { from, to } = selection;
+                let keepLooking = true;
+                let active = false;
+                doc.nodesBetween(from, to, node => {
+                    if (keepLooking && node.attrs.align === alignment) {
+                        keepLooking = false;
+                        active = true;
+                    }
+                    return keepLooking;
+                });
+                return active;
+            },
+            enable: state => {
+                const { selection } = state;
+                return selection instanceof TextSelection || selection instanceof AllSelection;
+            },
+            run: (state, dispatch) => {
+                const { schema, selection } = state;
+                const tr = setTextAlign(state.tr.setSelection(selection), schema, this.active ? null : alignment);
+                if (tr.docChanged) {
+                    dispatch?.(tr);
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/utils.mjs

@@ -0,0 +1,41 @@
+import { Item } from './item';
+import { toggleMark } from 'prosemirror-commands';
+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);
+    }
+}
+/**
+ * Convert built-in `MenuItem` into our Angular specific `Item`
+ */
+export function menuItemToItem(item) {
+    return new Item(item.spec);
+}
+/**
+ * From a `Command`, creates a new `Item` that will have an automatic `enable` spec
+ */
+export function cmdToItem(cmd, options = {}) {
+    const passedOptions = {
+        run: cmd,
+        ...options,
+    };
+    if (!options.enable && !options.select) {
+        passedOptions.enable = state => cmd(state);
+    }
+    return new Item(passedOptions);
+}
+/**
+ * From a `MarkType`, creates a new `Item` that will have an automatic `active` and `enable` spec
+ */
+export function markTypeToItem(markType) {
+    return cmdToItem(toggleMark(markType), {
+        active(state) {
+            return markActive(state, markType);
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/items/wrap-list-item.mjs

@@ -0,0 +1,6 @@
+import { wrapInList } from 'prosemirror-schema-list';
+import { cmdToItem } from './utils';
+export function wrapListItem(nodeType) {
+    return cmdToItem(wrapInList(nodeType));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JhcC1saXN0LWl0ZW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uYXR1cmFsLWVkaXRvci9zcmMvbGliL3V0aWxzL2l0ZW1zL3dyYXAtbGlzdC1pdGVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSx5QkFBeUIsQ0FBQztBQUNuRCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0sU0FBUyxDQUFDO0FBRWxDLE1BQU0sVUFBVSxZQUFZLENBQUMsUUFBa0I7SUFDM0MsT0FBTyxTQUFTLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7QUFDM0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Tm9kZVR5cGV9IGZyb20gJ3Byb3NlbWlycm9yLW1vZGVsJztcbmltcG9ydCB7SXRlbX0gZnJvbSAnLi9pdGVtJztcbmltcG9ydCB7d3JhcEluTGlzdH0gZnJvbSAncHJvc2VtaXJyb3Itc2NoZW1hLWxpc3QnO1xuaW1wb3J0IHtjbWRUb0l0ZW19IGZyb20gJy4vdXRpbHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gd3JhcExpc3RJdGVtKG5vZGVUeXBlOiBOb2RlVHlwZSk6IEl0ZW0ge1xuICAgIHJldHVybiBjbWRUb0l0ZW0od3JhcEluTGlzdChub2RlVHlwZSkpO1xufVxuIl19