@worktile/theia 3.0.9 → 3.1.0-next.2

package/esm2020/plugins/autoformat/autoformat.plugin.mjs

@@ -0,0 +1,109 @@
+import { Editor } from 'slate';
+import * as TheQueries from '../../queries';
+import { castArray } from '../../utils/cast-array';
+import { autoFormatBlock } from './transforms/auto-format-block';
+import { autoFormatInline } from './transforms/auto-format-inline';
+import { defaultAutoFormatRules } from '../../constants/auto-format-rules';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import { PluginKeys } from '../../interfaces';
+const mergAutoFormateRules = (rules) => {
+    const dataInfo = {};
+    rules.forEach(item => {
+        if (!dataInfo[item.type + item.key]) {
+            dataInfo[item.type + item.key] = {
+                ...item
+            };
+        }
+        dataInfo[item.type + item.key] = { ...dataInfo[item.type + item.key], ...item };
+    });
+    return dataInfo;
+};
+export const withAutoFormat = (editor) => {
+    const { insertText } = editor;
+    editor.insertText = text => {
+        let autoFormatRules = getPluginOptions(editor, PluginKeys.autoFormat)?.autoFormatRules;
+        const extraRules = mergAutoFormateRules(autoFormatRules);
+        autoFormatRules = Object.values(extraRules);
+        if (!TheQueries.isCollapsed(editor.selection)) {
+            return insertText(text);
+        }
+        for (const { query, ...rule } of autoFormatRules) {
+            const { trigger = ' ', mode = 'block', type, markup, preFormat, format, match, between, ignoreTrim, insertTrigger, allowSameTypeAbove = false, triggerAtBlockStart = true } = rule;
+            if (query && !query(editor, rule))
+                continue;
+            const triggers = castArray(trigger);
+            // Check trigger
+            if (!triggers.includes(text))
+                continue;
+            const valid = () => insertTrigger && insertText(text);
+            if (mode === 'block') {
+                let markups = castArray(markup);
+                let markupRange;
+                if (triggerAtBlockStart) {
+                    markupRange = TheQueries.getRangeFromBlockStart(editor);
+                    // Don't autoformat if there is void nodes.
+                    const hasVoidNode = TheQueries.someNode(editor, {
+                        at: markupRange,
+                        match: n => Editor.isVoid(editor, n)
+                    });
+                    if (hasVoidNode)
+                        continue;
+                    const textFromBlockStart = TheQueries.getText(editor, markupRange);
+                    if (match) {
+                        markups = match(editor, textFromBlockStart);
+                    }
+                    if (!markups.includes(textFromBlockStart))
+                        continue;
+                }
+                else {
+                    markupRange = TheQueries.getRangeBefore(editor, editor.selection, {
+                        matchString: markup,
+                        skipInvalid: true
+                    });
+                    if (!markupRange)
+                        continue;
+                    const blockAbovePath = TheQueries.getBlockAbove(editor)?.[1];
+                    if (!blockAbovePath)
+                        continue;
+                    // If the markup is not at the start, insert break before autoformatting.
+                    if (!Editor.isStart(editor, markupRange.anchor, blockAbovePath)) {
+                        editor.insertBreak();
+                    }
+                }
+                if (!allowSameTypeAbove) {
+                    // Don't autoformat if already in a block of the same type.
+                    const isBelowSameBlockType = TheQueries.someNode(editor, { match: { type } });
+                    if (isBelowSameBlockType)
+                        continue;
+                }
+                // Start of the block
+                autoFormatBlock(editor, type, markupRange, {
+                    preFormat,
+                    format
+                }, markups);
+                return valid();
+            }
+            if (mode === 'inline') {
+                if (autoFormatInline(editor, {
+                    type,
+                    between,
+                    ignoreTrim,
+                    format,
+                    markup: Array.isArray(markup) ? markup[0] : markup
+                })) {
+                    return valid();
+                }
+            }
+        }
+        insertText(text);
+    };
+    return editor;
+};
+export const createAutoFormatPlugin = createPluginFactory({
+    key: PluginKeys.autoFormat,
+    withOverrides: withAutoFormat,
+    options: {
+        autoFormatRules: defaultAutoFormatRules
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autoformat.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/autoformat/autoformat.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Range } from 'slate';\nimport * as TheQueries from '../../queries';\nimport { castArray } from '../../utils/cast-array';\nimport { AutoFormatRule } from '../../interfaces/auto-format';\nimport { autoFormatBlock } from './transforms/auto-format-block';\nimport { autoFormatInline } from './transforms/auto-format-inline';\nimport { defaultAutoFormatRules } from '../../constants/auto-format-rules';\nimport { createPluginFactory, getPluginOptions } from '../../core';\nimport { PluginKeys } from '../../interfaces';\n\nconst mergAutoFormateRules = (rules: AutoFormatRule[]) => {\n    const dataInfo = {};\n    rules.forEach(item => {\n        if (!dataInfo[item.type + item.key]) {\n            dataInfo[item.type + item.key] = {\n                ...item\n            };\n        }\n        dataInfo[item.type + item.key] = { ...dataInfo[item.type + item.key], ...item };\n    });\n    return dataInfo;\n};\n\nexport interface AutoFormatOptions {\n    autoFormatRules?: AutoFormatRule[];\n}\n\nexport const withAutoFormat = <T extends Editor>(editor: T) => {\n    const { insertText } = editor;\n    editor.insertText = text => {\n        let autoFormatRules = getPluginOptions<AutoFormatOptions>(editor, PluginKeys.autoFormat)?.autoFormatRules;\n        const extraRules = mergAutoFormateRules(autoFormatRules);\n        autoFormatRules = Object.values(extraRules);\n        if (!TheQueries.isCollapsed(editor.selection)) {\n            return insertText(text);\n        }\n\n        for (const { query, ...rule } of autoFormatRules) {\n            const {\n                trigger = ' ',\n                mode = 'block',\n                type,\n                markup,\n                preFormat,\n                format,\n                match,\n                between,\n                ignoreTrim,\n                insertTrigger,\n                allowSameTypeAbove = false,\n                triggerAtBlockStart = true\n            } = rule;\n\n            if (query && !query(editor, rule)) continue;\n\n            const triggers: string[] = castArray(trigger);\n\n            // Check trigger\n            if (!triggers.includes(text)) continue;\n\n            const valid = () => insertTrigger && insertText(text);\n\n            if (mode === 'block') {\n                let markups: string[] = castArray(markup);\n                let markupRange: Range | undefined;\n\n                if (triggerAtBlockStart) {\n                    markupRange = TheQueries.getRangeFromBlockStart(editor) as Range;\n\n                    // Don't autoformat if there is void nodes.\n                    const hasVoidNode = TheQueries.someNode(editor, {\n                        at: markupRange,\n                        match: n => Editor.isVoid(editor, n)\n                    });\n                    if (hasVoidNode) continue;\n\n                    const textFromBlockStart = TheQueries.getText(editor, markupRange);\n                    if (match) {\n                        markups = match(editor, textFromBlockStart);\n                    }\n                    if (!markups.includes(textFromBlockStart)) continue;\n                } else {\n                    markupRange = TheQueries.getRangeBefore(editor, editor.selection as Range, {\n                        matchString: markup,\n                        skipInvalid: true\n                    });\n                    if (!markupRange) continue;\n\n                    const blockAbovePath = TheQueries.getBlockAbove(editor)?.[1];\n                    if (!blockAbovePath) continue;\n\n                    // If the markup is not at the start, insert break before autoformatting.\n                    if (!Editor.isStart(editor, markupRange.anchor, blockAbovePath)) {\n                        editor.insertBreak();\n                    }\n                }\n\n                if (!allowSameTypeAbove) {\n                    // Don't autoformat if already in a block of the same type.\n                    const isBelowSameBlockType = TheQueries.someNode(editor, { match: { type } });\n                    if (isBelowSameBlockType) continue;\n                }\n\n                // Start of the block\n                autoFormatBlock(\n                    editor,\n                    type,\n                    markupRange,\n                    {\n                        preFormat,\n                        format\n                    },\n                    markups\n                );\n                return valid();\n            }\n\n            if (mode === 'inline') {\n                if (\n                    autoFormatInline(editor, {\n                        type,\n                        between,\n                        ignoreTrim,\n                        format,\n                        markup: Array.isArray(markup) ? markup[0] : markup\n                    })\n                ) {\n                    return valid();\n                }\n            }\n        }\n\n        insertText(text);\n    };\n\n    return editor;\n};\n\nexport const createAutoFormatPlugin = createPluginFactory<AutoFormatOptions>({\n    key: PluginKeys.autoFormat,\n    withOverrides: withAutoFormat,\n    options: {\n        autoFormatRules: defaultAutoFormatRules\n    }\n});\n"]}

package/{esm2015/plugins/autoformat/transforms/auto-format-block.js → esm2020/plugins/autoformat/transforms/auto-format-block.mjs}

@@ -1,14 +1,14 @@
-import { Editor, Transforms } from 'slate';
-export const autoFormatBlock = (editor, type, at, { preFormat, format }, markups) => {
-    Transforms.delete(editor, { at });
-    if (preFormat) {
-        preFormat(editor);
-    }
-    if (!format) {
-        Transforms.setNodes(editor, { type }, { match: n => Editor.isBlock(editor, n) });
-    }
-    else {
-        format(editor, markups);
-    }
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1mb3JtYXQtYmxvY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9hdXRvZm9ybWF0L3RyYW5zZm9ybXMvYXV0by1mb3JtYXQtYmxvY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBWSxVQUFVLEVBQVEsTUFBTSxPQUFPLENBQUM7QUFFM0QsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQzNCLE1BQWMsRUFDZCxJQUFZLEVBQ1osRUFBWSxFQUNaLEVBQ0ksU0FBUyxFQUNULE1BQU0sRUFJVCxFQUNELE9BQWtCLEVBQ3BCLEVBQUU7SUFDQSxVQUFVLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFFbEMsSUFBSSxTQUFTLEVBQUU7UUFDWCxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDckI7SUFFRCxJQUFJLENBQUMsTUFBTSxFQUFFO1FBQ1QsVUFBVSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsRUFBRSxJQUFJLEVBQVUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztLQUM1RjtTQUFNO1FBQ0gsTUFBTSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztLQUMzQjtBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciwgTG9jYXRpb24sIFRyYW5zZm9ybXMsIE5vZGUgfSBmcm9tICdzbGF0ZSc7XHJcblxyXG5leHBvcnQgY29uc3QgYXV0b0Zvcm1hdEJsb2NrID0gKFxyXG4gICAgZWRpdG9yOiBFZGl0b3IsXHJcbiAgICB0eXBlOiBzdHJpbmcsXHJcbiAgICBhdDogTG9jYXRpb24sXHJcbiAgICB7XHJcbiAgICAgICAgcHJlRm9ybWF0LFxyXG4gICAgICAgIGZvcm1hdFxyXG4gICAgfToge1xyXG4gICAgICAgIHByZUZvcm1hdD86IChlZGl0b3I6IEVkaXRvcikgPT4gdm9pZDtcclxuICAgICAgICBmb3JtYXQ/OiAoZWRpdG9yOiBFZGl0b3IsIG1hcmt1cHM/OiBzdHJpbmdbXSkgPT4gdm9pZDtcclxuICAgIH0sXHJcbiAgICBtYXJrdXBzPzogc3RyaW5nW11cclxuKSA9PiB7XHJcbiAgICBUcmFuc2Zvcm1zLmRlbGV0ZShlZGl0b3IsIHsgYXQgfSk7XHJcblxyXG4gICAgaWYgKHByZUZvcm1hdCkge1xyXG4gICAgICAgIHByZUZvcm1hdChlZGl0b3IpO1xyXG4gICAgfVxyXG5cclxuICAgIGlmICghZm9ybWF0KSB7XHJcbiAgICAgICAgVHJhbnNmb3Jtcy5zZXROb2RlcyhlZGl0b3IsIHsgdHlwZSB9IGFzIE5vZGUsIHsgbWF0Y2g6IG4gPT4gRWRpdG9yLmlzQmxvY2soZWRpdG9yLCBuKSB9KTtcclxuICAgIH0gZWxzZSB7XHJcbiAgICAgICAgZm9ybWF0KGVkaXRvciwgbWFya3Vwcyk7XHJcbiAgICB9XHJcbn07XHJcbiJdfQ==
+import { Editor, Transforms } from 'slate';
+export const autoFormatBlock = (editor, type, at, { preFormat, format }, markups) => {
+    Transforms.delete(editor, { at });
+    if (preFormat) {
+        preFormat(editor);
+    }
+    if (!format) {
+        Transforms.setNodes(editor, { type }, { match: n => Editor.isBlock(editor, n) });
+    }
+    else {
+        format(editor, markups);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1mb3JtYXQtYmxvY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9hdXRvZm9ybWF0L3RyYW5zZm9ybXMvYXV0by1mb3JtYXQtYmxvY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBWSxVQUFVLEVBQVEsTUFBTSxPQUFPLENBQUM7QUFFM0QsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLENBQzNCLE1BQWMsRUFDZCxJQUFZLEVBQ1osRUFBWSxFQUNaLEVBQ0ksU0FBUyxFQUNULE1BQU0sRUFJVCxFQUNELE9BQWtCLEVBQ3BCLEVBQUU7SUFDQSxVQUFVLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFFbEMsSUFBSSxTQUFTLEVBQUU7UUFDWCxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDckI7SUFFRCxJQUFJLENBQUMsTUFBTSxFQUFFO1FBQ1QsVUFBVSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsRUFBRSxJQUFJLEVBQVUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztLQUM1RjtTQUFNO1FBQ0gsTUFBTSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztLQUMzQjtBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciwgTG9jYXRpb24sIFRyYW5zZm9ybXMsIE5vZGUgfSBmcm9tICdzbGF0ZSc7XG5cbmV4cG9ydCBjb25zdCBhdXRvRm9ybWF0QmxvY2sgPSAoXG4gICAgZWRpdG9yOiBFZGl0b3IsXG4gICAgdHlwZTogc3RyaW5nLFxuICAgIGF0OiBMb2NhdGlvbixcbiAgICB7XG4gICAgICAgIHByZUZvcm1hdCxcbiAgICAgICAgZm9ybWF0XG4gICAgfToge1xuICAgICAgICBwcmVGb3JtYXQ/OiAoZWRpdG9yOiBFZGl0b3IpID0+IHZvaWQ7XG4gICAgICAgIGZvcm1hdD86IChlZGl0b3I6IEVkaXRvciwgbWFya3Vwcz86IHN0cmluZ1tdKSA9PiB2b2lkO1xuICAgIH0sXG4gICAgbWFya3Vwcz86IHN0cmluZ1tdXG4pID0+IHtcbiAgICBUcmFuc2Zvcm1zLmRlbGV0ZShlZGl0b3IsIHsgYXQgfSk7XG5cbiAgICBpZiAocHJlRm9ybWF0KSB7XG4gICAgICAgIHByZUZvcm1hdChlZGl0b3IpO1xuICAgIH1cblxuICAgIGlmICghZm9ybWF0KSB7XG4gICAgICAgIFRyYW5zZm9ybXMuc2V0Tm9kZXMoZWRpdG9yLCB7IHR5cGUgfSBhcyBOb2RlLCB7IG1hdGNoOiBuID0+IEVkaXRvci5pc0Jsb2NrKGVkaXRvciwgbikgfSk7XG4gICAgfSBlbHNlIHtcbiAgICAgICAgZm9ybWF0KGVkaXRvciwgbWFya3Vwcyk7XG4gICAgfVxufTtcbiJdfQ==

package/{esm2015/plugins/autoformat/transforms/auto-format-inline.js → esm2020/plugins/autoformat/transforms/auto-format-inline.mjs}

@@ -1,78 +1,78 @@
-import { Transforms } from 'slate';
-import * as TheQueries from '../../../queries';
-export const autoFormatInline = (editor, { type, between, markup, ignoreTrim, format }) => {
-    const selection = editor.selection;
-    const startMarkup = between ? between[0] : markup;
-    const endMarkup = between ? between[1] : '';
-    let endMarkupPointBefore = selection.anchor;
-    if (endMarkup) {
-        endMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
-            matchString: endMarkup
-        });
-        if (!endMarkupPointBefore) {
-            return false;
-        }
-    }
-    const startMarkupPointAfter = TheQueries.getPointBefore(editor, endMarkupPointBefore, {
-        matchString: startMarkup,
-        skipInvalid: true,
-        afterMatch: true
-    });
-    if (!startMarkupPointAfter) {
-        return false;
-    }
-    // found
-    const markupRange = {
-        anchor: startMarkupPointAfter,
-        focus: endMarkupPointBefore
-    };
-    if (!ignoreTrim) {
-        const markupText = TheQueries.getText(editor, markupRange);
-        if (markupText.trim() !== markupText) {
-            return false;
-        }
-    }
-    // delete end markup
-    if (endMarkup) {
-        endMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
-            matchString: endMarkup
-        });
-        Transforms.delete(editor, {
-            at: {
-                anchor: endMarkupPointBefore,
-                focus: selection.anchor
-            }
-        });
-    }
-    const startMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
-        matchString: startMarkup,
-        skipInvalid: true
-    });
-    if (format) {
-        const markupText = TheQueries.getText(editor, markupRange);
-        format(editor, markupText);
-        // delete start to end selection
-        Transforms.delete(editor, {
-            at: {
-                anchor: startMarkupPointBefore,
-                focus: selection.anchor
-            }
-        });
-    }
-    else {
-        // add mark to the text between the markups
-        Transforms.select(editor, markupRange);
-        editor.addMark(type, true);
-        Transforms.collapse(editor, { edge: 'end' });
-        editor.removeMark(type, false);
-        // delete start markup
-        Transforms.delete(editor, {
-            at: {
-                anchor: startMarkupPointBefore,
-                focus: startMarkupPointAfter
-            }
-        });
-    }
-    return true;
-};
+import { Transforms } from 'slate';
+import * as TheQueries from '../../../queries';
+export const autoFormatInline = (editor, { type, between, markup, ignoreTrim, format }) => {
+    const selection = editor.selection;
+    const startMarkup = between ? between[0] : markup;
+    const endMarkup = between ? between[1] : '';
+    let endMarkupPointBefore = selection.anchor;
+    if (endMarkup) {
+        endMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
+            matchString: endMarkup
+        });
+        if (!endMarkupPointBefore) {
+            return false;
+        }
+    }
+    const startMarkupPointAfter = TheQueries.getPointBefore(editor, endMarkupPointBefore, {
+        matchString: startMarkup,
+        skipInvalid: true,
+        afterMatch: true
+    });
+    if (!startMarkupPointAfter) {
+        return false;
+    }
+    // found
+    const markupRange = {
+        anchor: startMarkupPointAfter,
+        focus: endMarkupPointBefore
+    };
+    if (!ignoreTrim) {
+        const markupText = TheQueries.getText(editor, markupRange);
+        if (markupText.trim() !== markupText) {
+            return false;
+        }
+    }
+    // delete end markup
+    if (endMarkup) {
+        endMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
+            matchString: endMarkup
+        });
+        Transforms.delete(editor, {
+            at: {
+                anchor: endMarkupPointBefore,
+                focus: selection.anchor
+            }
+        });
+    }
+    const startMarkupPointBefore = TheQueries.getPointBefore(editor, selection, {
+        matchString: startMarkup,
+        skipInvalid: true
+    });
+    if (format) {
+        const markupText = TheQueries.getText(editor, markupRange);
+        format(editor, markupText);
+        // delete start to end selection
+        Transforms.delete(editor, {
+            at: {
+                anchor: startMarkupPointBefore,
+                focus: selection.anchor
+            }
+        });
+    }
+    else {
+        // add mark to the text between the markups
+        Transforms.select(editor, markupRange);
+        editor.addMark(type, true);
+        Transforms.collapse(editor, { edge: 'end' });
+        editor.removeMark(type, false);
+        // delete start markup
+        Transforms.delete(editor, {
+            at: {
+                anchor: startMarkupPointBefore,
+                focus: startMarkupPointAfter
+            }
+        });
+    }
+    return true;
+};
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2015/plugins/blockquote/blockquote.component.js → esm2020/plugins/blockquote/blockquote.component.mjs}

@@ -1,21 +1,21 @@
-import { Component } from '@angular/core';
-import { TheBaseElementComponent } from '../../interfaces';
-import * as i0 from "@angular/core";
-import * as i1 from "slate-angular";
-export class TheBlockquoteComponent extends TheBaseElementComponent {
-    constructor(elementRef, cdr) {
-        super(elementRef, cdr);
-        this.elementRef = elementRef;
-        this.cdr = cdr;
-    }
-}
-TheBlockquoteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TheBlockquoteComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-TheBlockquoteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: TheBlockquoteComponent, selector: "blockquote[theBlockquote]", usesInheritance: true, ngImport: i0, template: `<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children>`, isInline: true, components: [{ type: i1.SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TheBlockquoteComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'blockquote[theBlockquote]',
-                    template: `<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children>`
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2txdW90ZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9ibG9ja3F1b3RlL2Jsb2NrcXVvdGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWlDLE1BQU0sZUFBZSxDQUFDO0FBRXpFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDOzs7QUFNM0QsTUFBTSxPQUFPLHNCQUF1QixTQUFRLHVCQUF3QztJQUNoRixZQUFtQixVQUFzQixFQUFTLEdBQXNCO1FBQ3BFLEtBQUssQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFEUixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQVMsUUFBRyxHQUFILEdBQUcsQ0FBbUI7SUFFeEUsQ0FBQzs7b0hBSFEsc0JBQXNCO3dHQUF0QixzQkFBc0Isd0ZBRnJCLGlIQUFpSDs0RkFFbEgsc0JBQXNCO2tCQUpsQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSwyQkFBMkI7b0JBQ3JDLFFBQVEsRUFBRSxpSEFBaUg7aUJBQzlIIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBFbGVtZW50UmVmLCBDaGFuZ2VEZXRlY3RvclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBFZGl0b3IsIEVsZW1lbnQgfSBmcm9tICdzbGF0ZSc7XHJcbmltcG9ydCB7IFRoZUJhc2VFbGVtZW50Q29tcG9uZW50IH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcyc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICAgIHNlbGVjdG9yOiAnYmxvY2txdW90ZVt0aGVCbG9ja3F1b3RlXScsXHJcbiAgICB0ZW1wbGF0ZTogYDxzbGF0ZS1jaGlsZHJlbiBbY2hpbGRyZW5dPVwiY2hpbGRyZW5cIiBbY29udGV4dF09XCJjaGlsZHJlbkNvbnRleHRcIiBbdmlld0NvbnRleHRdPVwidmlld0NvbnRleHRcIj48L3NsYXRlLWNoaWxkcmVuPmBcclxufSlcclxuZXhwb3J0IGNsYXNzIFRoZUJsb2NrcXVvdGVDb21wb25lbnQgZXh0ZW5kcyBUaGVCYXNlRWxlbWVudENvbXBvbmVudDxFbGVtZW50LCBFZGl0b3I+IHtcclxuICAgIGNvbnN0cnVjdG9yKHB1YmxpYyBlbGVtZW50UmVmOiBFbGVtZW50UmVmLCBwdWJsaWMgY2RyOiBDaGFuZ2VEZXRlY3RvclJlZikge1xyXG4gICAgICAgIHN1cGVyKGVsZW1lbnRSZWYsIGNkcik7XHJcbiAgICB9XHJcbn1cclxuIl19
+import { Component } from '@angular/core';
+import { TheBaseElementComponent } from '../../interfaces';
+import * as i0 from "@angular/core";
+import * as i1 from "slate-angular";
+export class TheBlockquoteComponent extends TheBaseElementComponent {
+    constructor(elementRef, cdr) {
+        super(elementRef, cdr);
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+    }
+}
+TheBlockquoteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheBlockquoteComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TheBlockquoteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: TheBlockquoteComponent, selector: "blockquote[theBlockquote]", usesInheritance: true, ngImport: i0, template: `<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children>`, isInline: true, components: [{ type: i1.SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheBlockquoteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'blockquote[theBlockquote]',
+                    template: `<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children>`
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2txdW90ZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9ibG9ja3F1b3RlL2Jsb2NrcXVvdGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWlDLE1BQU0sZUFBZSxDQUFDO0FBRXpFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDOzs7QUFNM0QsTUFBTSxPQUFPLHNCQUF1QixTQUFRLHVCQUF3QztJQUNoRixZQUFtQixVQUFzQixFQUFTLEdBQXNCO1FBQ3BFLEtBQUssQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFEUixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQVMsUUFBRyxHQUFILEdBQUcsQ0FBbUI7SUFFeEUsQ0FBQzs7bUhBSFEsc0JBQXNCO3VHQUF0QixzQkFBc0Isd0ZBRnJCLGlIQUFpSDsyRkFFbEgsc0JBQXNCO2tCQUpsQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSwyQkFBMkI7b0JBQ3JDLFFBQVEsRUFBRSxpSEFBaUg7aUJBQzlIIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBFbGVtZW50UmVmLCBDaGFuZ2VEZXRlY3RvclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRWRpdG9yLCBFbGVtZW50IH0gZnJvbSAnc2xhdGUnO1xuaW1wb3J0IHsgVGhlQmFzZUVsZW1lbnRDb21wb25lbnQgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdibG9ja3F1b3RlW3RoZUJsb2NrcXVvdGVdJyxcbiAgICB0ZW1wbGF0ZTogYDxzbGF0ZS1jaGlsZHJlbiBbY2hpbGRyZW5dPVwiY2hpbGRyZW5cIiBbY29udGV4dF09XCJjaGlsZHJlbkNvbnRleHRcIiBbdmlld0NvbnRleHRdPVwidmlld0NvbnRleHRcIj48L3NsYXRlLWNoaWxkcmVuPmBcbn0pXG5leHBvcnQgY2xhc3MgVGhlQmxvY2txdW90ZUNvbXBvbmVudCBleHRlbmRzIFRoZUJhc2VFbGVtZW50Q29tcG9uZW50PEVsZW1lbnQsIEVkaXRvcj4ge1xuICAgIGNvbnN0cnVjdG9yKHB1YmxpYyBlbGVtZW50UmVmOiBFbGVtZW50UmVmLCBwdWJsaWMgY2RyOiBDaGFuZ2VEZXRlY3RvclJlZikge1xuICAgICAgICBzdXBlcihlbGVtZW50UmVmLCBjZHIpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/plugins/blockquote/blockquote.editor.mjs

@@ -0,0 +1,20 @@
+import { Transforms, Element } from 'slate';
+import { ElementKinds } from '../../constants';
+import { PluginKeys } from '../../interfaces';
+import { getPluginOptions } from '../../core/utils/get-plugin-options';
+import * as TheQueries from '../../queries';
+export const BlockquoteEditor = {
+    toggleBlockquote(editor) {
+        const isActive = TheQueries.isBlockActive(editor, ElementKinds.blockquote);
+        const allowParentTypes = getPluginOptions(editor, PluginKeys.blockquote)?.allowParentTypes || [];
+        if (!isActive) {
+            Transforms.wrapNodes(editor, { type: ElementKinds.blockquote, children: [] }, {
+                mode: 'lowest'
+            });
+        }
+        else {
+            Transforms.unwrapNodes(editor, { match: n => Element.isElement(n) && n.type === ElementKinds.blockquote });
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/plugins/blockquote/blockquote.plugin.js → esm2020/plugins/blockquote/blockquote.plugin.mjs}

@@ -1,71 +1,71 @@
-import { Editor, Transforms } from 'slate';
-import { ElementKinds } from '../../constants';
-import { PluginKeys } from '../../interfaces';
-import { createEmptyParagraph } from '../../utils';
-import { createPluginFactory } from '../../core';
-import { TheBlockquoteComponent } from './blockquote.component';
-import { BlockquoteEditor } from './blockquote.editor';
-import * as TheQueries from '../../queries';
-import * as TheTransforms from '../../transforms';
-export const withBlockquote = (editor) => {
-    const { renderElement, deleteBackward, insertBreak, isContainer } = editor;
-    editor.renderElement = (element) => {
-        if (element.type === ElementKinds.blockquote) {
-            return TheBlockquoteComponent;
-        }
-        return renderElement(element);
-    };
-    editor.deleteBackward = unit => {
-        const aboveResult = Editor.above(editor, {
-            match: n => Editor.isBlock(editor, n) && n.type === ElementKinds.blockquote
-        });
-        if (!aboveResult) {
-            return deleteBackward(unit);
-        }
-        const hasHandled = TheTransforms.handleContinualDeleteBackward(editor, aboveResult, ElementKinds.blockquote);
-        if (hasHandled) {
-            return;
-        }
-        return deleteBackward(unit);
-    };
-    editor.insertBreak = () => {
-        const lowestBlock = TheQueries.anchorBlock(editor);
-        if (!lowestBlock) {
-            insertBreak();
-            return;
-        }
-        const hasHandled = TheTransforms.handleContinualInsertBreak(editor, lowestBlock, ElementKinds.blockquote);
-        if (hasHandled) {
-            return;
-        }
-        const voidEntry = Editor.above(editor, {
-            match: n => Editor.isBlock(editor, n) && Editor.isVoid(editor, n)
-        });
-        if (voidEntry && voidEntry[0]) {
-            Transforms.insertNodes(editor, createEmptyParagraph());
-            return;
-        }
-        return insertBreak();
-    };
-    editor.isContainer = (element) => {
-        return element.type === ElementKinds.blockquote ? true : isContainer(element);
-    };
-    return editor;
-};
-export const createBlockquotePlugin = createPluginFactory({
-    key: PluginKeys.blockquote,
-    withOverrides: withBlockquote,
-    toolbarItems: [
-        {
-            key: ElementKinds.blockquote,
-            icon: 'blockquote',
-            name: '引用',
-            active: editor => TheQueries.isBlockActive(editor, ElementKinds.blockquote),
-            execute: editor => BlockquoteEditor.toggleBlockquote(editor)
-        }
-    ],
-    options: {
-        allowParentTypes: [ElementKinds.tableCell]
-    }
-});
+import { Editor, Transforms } from 'slate';
+import { ElementKinds } from '../../constants';
+import { PluginKeys } from '../../interfaces';
+import { createEmptyParagraph } from '../../utils';
+import { createPluginFactory } from '../../core';
+import { TheBlockquoteComponent } from './blockquote.component';
+import { BlockquoteEditor } from './blockquote.editor';
+import * as TheQueries from '../../queries';
+import * as TheTransforms from '../../transforms';
+export const withBlockquote = (editor) => {
+    const { renderElement, deleteBackward, insertBreak, isContainer } = editor;
+    editor.renderElement = (element) => {
+        if (element.type === ElementKinds.blockquote) {
+            return TheBlockquoteComponent;
+        }
+        return renderElement(element);
+    };
+    editor.deleteBackward = unit => {
+        const aboveResult = Editor.above(editor, {
+            match: n => Editor.isBlock(editor, n) && n.type === ElementKinds.blockquote
+        });
+        if (!aboveResult) {
+            return deleteBackward(unit);
+        }
+        const hasHandled = TheTransforms.handleContinualDeleteBackward(editor, aboveResult, ElementKinds.blockquote);
+        if (hasHandled) {
+            return;
+        }
+        return deleteBackward(unit);
+    };
+    editor.insertBreak = () => {
+        const lowestBlock = TheQueries.anchorBlock(editor);
+        if (!lowestBlock) {
+            insertBreak();
+            return;
+        }
+        const hasHandled = TheTransforms.handleContinualInsertBreak(editor, lowestBlock, ElementKinds.blockquote);
+        if (hasHandled) {
+            return;
+        }
+        const voidEntry = Editor.above(editor, {
+            match: n => Editor.isBlock(editor, n) && Editor.isVoid(editor, n)
+        });
+        if (voidEntry && voidEntry[0]) {
+            Transforms.insertNodes(editor, createEmptyParagraph());
+            return;
+        }
+        return insertBreak();
+    };
+    editor.isContainer = (element) => {
+        return element.type === ElementKinds.blockquote ? true : isContainer(element);
+    };
+    return editor;
+};
+export const createBlockquotePlugin = createPluginFactory({
+    key: PluginKeys.blockquote,
+    withOverrides: withBlockquote,
+    toolbarItems: [
+        {
+            key: ElementKinds.blockquote,
+            icon: 'blockquote',
+            name: '引用',
+            active: editor => TheQueries.isBlockActive(editor, ElementKinds.blockquote),
+            execute: editor => BlockquoteEditor.toggleBlockquote(editor)
+        }
+    ],
+    options: {
+        allowParentTypes: [ElementKinds.tableCell]
+    }
+});
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2txdW90ZS5wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zcmMvcGx1Z2lucy9ibG9ja3F1b3RlL2Jsb2NrcXVvdGUucGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQVcsVUFBVSxFQUFFLE1BQU0sT0FBTyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUNqRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssVUFBVSxNQUFNLGVBQWUsQ0FBQztBQUM1QyxPQUFPLEtBQUssYUFBYSxNQUFNLGtCQUFrQixDQUFDO0FBRWxELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFtQixNQUFTLEVBQUssRUFBRTtJQUM3RCxNQUFNLEVBQUUsYUFBYSxFQUFFLGNBQWMsRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLEdBQUcsTUFBTSxDQUFDO0lBRTNFLE1BQU0sQ0FBQyxhQUFhLEdBQUcsQ0FBQyxPQUFnQixFQUFFLEVBQUU7UUFDeEMsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLFlBQVksQ0FBQyxVQUFVLEVBQUU7WUFDMUMsT0FBTyxzQkFBc0IsQ0FBQztTQUNqQztRQUNELE9BQU8sYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2xDLENBQUMsQ0FBQztJQUVGLE1BQU0sQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLEVBQUU7UUFDM0IsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBVSxNQUFNLEVBQUU7WUFDOUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksS0FBSyxZQUFZLENBQUMsVUFBVTtTQUM5RSxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsV0FBVyxFQUFFO1lBQ2QsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDL0I7UUFDRCxNQUFNLFVBQVUsR0FBRyxhQUFhLENBQUMsNkJBQTZCLENBQUMsTUFBTSxFQUFFLFdBQVcsRUFBRSxZQUFZLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDN0csSUFBSSxVQUFVLEVBQUU7WUFDWixPQUFPO1NBQ1Y7UUFDRCxPQUFPLGNBQWMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoQyxDQUFDLENBQUM7SUFFRixNQUFNLENBQUMsV0FBVyxHQUFHLEdBQUcsRUFBRTtRQUN0QixNQUFNLFdBQVcsR0FBRyxVQUFVLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBRW5ELElBQUksQ0FBQyxXQUFXLEVBQUU7WUFDZCxXQUFXLEVBQUUsQ0FBQztZQUNkLE9BQU87U0FDVjtRQUNELE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQywwQkFBMEIsQ0FBQyxNQUFNLEVBQUUsV0FBVyxFQUFFLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUMxRyxJQUFJLFVBQVUsRUFBRTtZQUNaLE9BQU87U0FDVjtRQUNELE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQVUsTUFBTSxFQUFFO1lBQzVDLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztTQUNwRSxDQUFDLENBQUM7UUFDSCxJQUFJLFNBQVMsSUFBSSxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDM0IsVUFBVSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLEVBQUUsQ0FBQyxDQUFDO1lBQ3ZELE9BQU87U0FDVjtRQUNELE9BQU8sV0FBVyxFQUFFLENBQUM7SUFDekIsQ0FBQyxDQUFDO0lBRUYsTUFBTSxDQUFDLFdBQVcsR0FBRyxDQUFDLE9BQWdCLEVBQUUsRUFBRTtRQUN0QyxPQUFPLE9BQU8sQ0FBQyxJQUFJLEtBQUssWUFBWSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbEYsQ0FBQyxDQUFDO0lBRUYsT0FBTyxNQUFNLENBQUM7QUFDbEIsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsbUJBQW1CLENBQUM7SUFDdEQsR0FBRyxFQUFFLFVBQVUsQ0FBQyxVQUFVO0lBQzFCLGFBQWEsRUFBRSxjQUFjO0lBQzdCLFlBQVksRUFBRTtRQUNWO1lBQ0ksR0FBRyxFQUFFLFlBQVksQ0FBQyxVQUFVO1lBQzVCLElBQUksRUFBRSxZQUFZO1lBQ2xCLElBQUksRUFBRSxJQUFJO1lBQ1YsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEVBQUUsWUFBWSxDQUFDLFVBQVUsQ0FBQztZQUMzRSxPQUFPLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0IsQ0FBQyxNQUFNLENBQUM7U0FDL0Q7S0FDSjtJQUNELE9BQU8sRUFBRTtRQUNMLGdCQUFnQixFQUFFLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQztLQUM3QztDQUNKLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciwgRWxlbWVudCwgVHJhbnNmb3JtcyB9IGZyb20gJ3NsYXRlJztcbmltcG9ydCB7IEVsZW1lbnRLaW5kcyB9IGZyb20gJy4uLy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgeyBQbHVnaW5LZXlzIH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQgeyBjcmVhdGVFbXB0eVBhcmFncmFwaCB9IGZyb20gJy4uLy4uL3V0aWxzJztcbmltcG9ydCB7IGNyZWF0ZVBsdWdpbkZhY3RvcnkgfSBmcm9tICcuLi8uLi9jb3JlJztcbmltcG9ydCB7IFRoZUJsb2NrcXVvdGVDb21wb25lbnQgfSBmcm9tICcuL2Jsb2NrcXVvdGUuY29tcG9uZW50JztcbmltcG9ydCB7IEJsb2NrcXVvdGVFZGl0b3IgfSBmcm9tICcuL2Jsb2NrcXVvdGUuZWRpdG9yJztcbmltcG9ydCAqIGFzIFRoZVF1ZXJpZXMgZnJvbSAnLi4vLi4vcXVlcmllcyc7XG5pbXBvcnQgKiBhcyBUaGVUcmFuc2Zvcm1zIGZyb20gJy4uLy4uL3RyYW5zZm9ybXMnO1xuXG5leHBvcnQgY29uc3Qgd2l0aEJsb2NrcXVvdGUgPSA8VCBleHRlbmRzIEVkaXRvcj4oZWRpdG9yOiBUKTogVCA9PiB7XG4gICAgY29uc3QgeyByZW5kZXJFbGVtZW50LCBkZWxldGVCYWNrd2FyZCwgaW5zZXJ0QnJlYWssIGlzQ29udGFpbmVyIH0gPSBlZGl0b3I7XG5cbiAgICBlZGl0b3IucmVuZGVyRWxlbWVudCA9IChlbGVtZW50OiBFbGVtZW50KSA9PiB7XG4gICAgICAgIGlmIChlbGVtZW50LnR5cGUgPT09IEVsZW1lbnRLaW5kcy5ibG9ja3F1b3RlKSB7XG4gICAgICAgICAgICByZXR1cm4gVGhlQmxvY2txdW90ZUNvbXBvbmVudDtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gcmVuZGVyRWxlbWVudChlbGVtZW50KTtcbiAgICB9O1xuXG4gICAgZWRpdG9yLmRlbGV0ZUJhY2t3YXJkID0gdW5pdCA9PiB7XG4gICAgICAgIGNvbnN0IGFib3ZlUmVzdWx0ID0gRWRpdG9yLmFib3ZlPEVsZW1lbnQ+KGVkaXRvciwge1xuICAgICAgICAgICAgbWF0Y2g6IG4gPT4gRWRpdG9yLmlzQmxvY2soZWRpdG9yLCBuKSAmJiBuLnR5cGUgPT09IEVsZW1lbnRLaW5kcy5ibG9ja3F1b3RlXG4gICAgICAgIH0pO1xuICAgICAgICBpZiAoIWFib3ZlUmVzdWx0KSB7XG4gICAgICAgICAgICByZXR1cm4gZGVsZXRlQmFja3dhcmQodW5pdCk7XG4gICAgICAgIH1cbiAgICAgICAgY29uc3QgaGFzSGFuZGxlZCA9IFRoZVRyYW5zZm9ybXMuaGFuZGxlQ29udGludWFsRGVsZXRlQmFja3dhcmQoZWRpdG9yLCBhYm92ZVJlc3VsdCwgRWxlbWVudEtpbmRzLmJsb2NrcXVvdGUpO1xuICAgICAgICBpZiAoaGFzSGFuZGxlZCkge1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBkZWxldGVCYWNrd2FyZCh1bml0KTtcbiAgICB9O1xuXG4gICAgZWRpdG9yLmluc2VydEJyZWFrID0gKCkgPT4ge1xuICAgICAgICBjb25zdCBsb3dlc3RCbG9jayA9IFRoZVF1ZXJpZXMuYW5jaG9yQmxvY2soZWRpdG9yKTtcblxuICAgICAgICBpZiAoIWxvd2VzdEJsb2NrKSB7XG4gICAgICAgICAgICBpbnNlcnRCcmVhaygpO1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IGhhc0hhbmRsZWQgPSBUaGVUcmFuc2Zvcm1zLmhhbmRsZUNvbnRpbnVhbEluc2VydEJyZWFrKGVkaXRvciwgbG93ZXN0QmxvY2ssIEVsZW1lbnRLaW5kcy5ibG9ja3F1b3RlKTtcbiAgICAgICAgaWYgKGhhc0hhbmRsZWQpIHtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuICAgICAgICBjb25zdCB2b2lkRW50cnkgPSBFZGl0b3IuYWJvdmU8RWxlbWVudD4oZWRpdG9yLCB7XG4gICAgICAgICAgICBtYXRjaDogbiA9PiBFZGl0b3IuaXNCbG9jayhlZGl0b3IsIG4pICYmIEVkaXRvci5pc1ZvaWQoZWRpdG9yLCBuKVxuICAgICAgICB9KTtcbiAgICAgICAgaWYgKHZvaWRFbnRyeSAmJiB2b2lkRW50cnlbMF0pIHtcbiAgICAgICAgICAgIFRyYW5zZm9ybXMuaW5zZXJ0Tm9kZXMoZWRpdG9yLCBjcmVhdGVFbXB0eVBhcmFncmFwaCgpKTtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gaW5zZXJ0QnJlYWsoKTtcbiAgICB9O1xuXG4gICAgZWRpdG9yLmlzQ29udGFpbmVyID0gKGVsZW1lbnQ6IEVsZW1lbnQpID0+IHtcbiAgICAgICAgcmV0dXJuIGVsZW1lbnQudHlwZSA9PT0gRWxlbWVudEtpbmRzLmJsb2NrcXVvdGUgPyB0cnVlIDogaXNDb250YWluZXIoZWxlbWVudCk7XG4gICAgfTtcblxuICAgIHJldHVybiBlZGl0b3I7XG59O1xuXG5leHBvcnQgY29uc3QgY3JlYXRlQmxvY2txdW90ZVBsdWdpbiA9IGNyZWF0ZVBsdWdpbkZhY3Rvcnkoe1xuICAgIGtleTogUGx1Z2luS2V5cy5ibG9ja3F1b3RlLFxuICAgIHdpdGhPdmVycmlkZXM6IHdpdGhCbG9ja3F1b3RlLFxuICAgIHRvb2xiYXJJdGVtczogW1xuICAgICAgICB7XG4gICAgICAgICAgICBrZXk6IEVsZW1lbnRLaW5kcy5ibG9ja3F1b3RlLFxuICAgICAgICAgICAgaWNvbjogJ2Jsb2NrcXVvdGUnLFxuICAgICAgICAgICAgbmFtZTogJ+W8leeUqCcsXG4gICAgICAgICAgICBhY3RpdmU6IGVkaXRvciA9PiBUaGVRdWVyaWVzLmlzQmxvY2tBY3RpdmUoZWRpdG9yLCBFbGVtZW50S2luZHMuYmxvY2txdW90ZSksXG4gICAgICAgICAgICBleGVjdXRlOiBlZGl0b3IgPT4gQmxvY2txdW90ZUVkaXRvci50b2dnbGVCbG9ja3F1b3RlKGVkaXRvcilcbiAgICAgICAgfVxuICAgIF0sXG4gICAgb3B0aW9uczoge1xuICAgICAgICBhbGxvd1BhcmVudFR5cGVzOiBbRWxlbWVudEtpbmRzLnRhYmxlQ2VsbF1cbiAgICB9XG59KTtcbiJdfQ==