@lotte-innovate/ui-component-test 0.0.89 → 0.0.96

package/dist/public/tinymce/plugins/advlist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/advlist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "advlist" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/advlist')
+//   ES2015:
+//     import 'tinymce/plugins/advlist'
+require('./plugin.js');

package/dist/public/tinymce/plugins/advlist/plugin.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * TinyMCE version 6.8.5 (TBD)
+ */
+(function () {
+    'use strict';
+    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var applyListFormat = function (editor, listName, styleValue) {
+        var cmd = listName === 'UL' ? 'InsertUnorderedList' : 'InsertOrderedList';
+        editor.execCommand(cmd, false, styleValue === false ? null : { 'list-style-type': styleValue });
+    };
+    var register$2 = function (editor) {
+        editor.addCommand('ApplyUnorderedListStyle', function (ui, value) {
+            applyListFormat(editor, 'UL', value['list-style-type']);
+        });
+        editor.addCommand('ApplyOrderedListStyle', function (ui, value) {
+            applyListFormat(editor, 'OL', value['list-style-type']);
+        });
+    };
+    var option = function (name) { return function (editor) { return editor.options.get(name); }; };
+    var register$1 = function (editor) {
+        var registerOption = editor.options.register;
+        registerOption('advlist_number_styles', {
+            processor: 'string[]',
+            default: 'default,lower-alpha,lower-greek,lower-roman,upper-alpha,upper-roman'.split(',')
+        });
+        registerOption('advlist_bullet_styles', {
+            processor: 'string[]',
+            default: 'default,circle,square'.split(',')
+        });
+    };
+    var getNumberStyles = option('advlist_number_styles');
+    var getBulletStyles = option('advlist_bullet_styles');
+    var isNullable = function (a) { return a === null || a === undefined; };
+    var isNonNullable = function (a) { return !isNullable(a); };
+    var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
+    var Optional = /** @class */ (function () {
+        function Optional(tag, value) {
+            this.tag = tag;
+            this.value = value;
+        }
+        Optional.some = function (value) {
+            return new Optional(true, value);
+        };
+        Optional.none = function () {
+            return Optional.singletonNone;
+        };
+        Optional.prototype.fold = function (onNone, onSome) {
+            if (this.tag) {
+                return onSome(this.value);
+            }
+            else {
+                return onNone();
+            }
+        };
+        Optional.prototype.isSome = function () {
+            return this.tag;
+        };
+        Optional.prototype.isNone = function () {
+            return !this.tag;
+        };
+        Optional.prototype.map = function (mapper) {
+            if (this.tag) {
+                return Optional.some(mapper(this.value));
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.bind = function (binder) {
+            if (this.tag) {
+                return binder(this.value);
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.exists = function (predicate) {
+            return this.tag && predicate(this.value);
+        };
+        Optional.prototype.forall = function (predicate) {
+            return !this.tag || predicate(this.value);
+        };
+        Optional.prototype.filter = function (predicate) {
+            if (!this.tag || predicate(this.value)) {
+                return this;
+            }
+            else {
+                return Optional.none();
+            }
+        };
+        Optional.prototype.getOr = function (replacement) {
+            return this.tag ? this.value : replacement;
+        };
+        Optional.prototype.or = function (replacement) {
+            return this.tag ? this : replacement;
+        };
+        Optional.prototype.getOrThunk = function (thunk) {
+            return this.tag ? this.value : thunk();
+        };
+        Optional.prototype.orThunk = function (thunk) {
+            return this.tag ? this : thunk();
+        };
+        Optional.prototype.getOrDie = function (message) {
+            if (!this.tag) {
+                throw new Error(message !== null && message !== void 0 ? message : 'Called getOrDie on None');
+            }
+            else {
+                return this.value;
+            }
+        };
+        Optional.from = function (value) {
+            return isNonNullable(value) ? Optional.some(value) : Optional.none();
+        };
+        Optional.prototype.getOrNull = function () {
+            return this.tag ? this.value : null;
+        };
+        Optional.prototype.getOrUndefined = function () {
+            return this.value;
+        };
+        Optional.prototype.each = function (worker) {
+            if (this.tag) {
+                worker(this.value);
+            }
+        };
+        Optional.prototype.toArray = function () {
+            return this.tag ? [this.value] : [];
+        };
+        Optional.prototype.toString = function () {
+            return this.tag ? "some(".concat(this.value, ")") : 'none()';
+        };
+        return Optional;
+    }());
+    Optional.singletonNone = new Optional(false);
+    var findUntil = function (xs, pred, until) {
+        for (var i = 0, len = xs.length; i < len; i++) {
+            var x = xs[i];
+            if (pred(x, i)) {
+                return Optional.some(x);
+            }
+            else if (until(x, i)) {
+                break;
+            }
+        }
+        return Optional.none();
+    };
+    var isCustomList = function (list) { return /\btox\-/.test(list.className); };
+    var isChildOfBody = function (editor, elm) {
+        return editor.dom.isChildOf(elm, editor.getBody());
+    };
+    var matchNodeNames = function (regex) { return function (node) { return isNonNullable(node) && regex.test(node.nodeName); }; };
+    var isListNode = matchNodeNames(/^(OL|UL|DL)$/);
+    var isTableCellNode = matchNodeNames(/^(TH|TD)$/);
+    var inList = function (editor, parents, nodeName) { return findUntil(parents, function (parent) { return isListNode(parent) && !isCustomList(parent); }, isTableCellNode).exists(function (list) { return list.nodeName === nodeName && isChildOfBody(editor, list); }); };
+    var getSelectedStyleType = function (editor) {
+        var listElm = editor.dom.getParent(editor.selection.getNode(), 'ol,ul');
+        var style = editor.dom.getStyle(listElm, 'listStyleType');
+        return Optional.from(style);
+    };
+    var isWithinNonEditable = function (editor, element) { return element !== null && !editor.dom.isEditable(element); };
+    var isWithinNonEditableList = function (editor, element) {
+        var parentList = editor.dom.getParent(element, 'ol,ul,dl');
+        return isWithinNonEditable(editor, parentList) && editor.selection.isEditable();
+    };
+    var setNodeChangeHandler = function (editor, nodeChangeHandler) {
+        var initialNode = editor.selection.getNode();
+        nodeChangeHandler({
+            parents: editor.dom.getParents(initialNode),
+            element: initialNode
+        });
+        editor.on('NodeChange', nodeChangeHandler);
+        return function () { return editor.off('NodeChange', nodeChangeHandler); };
+    };
+    var styleValueToText = function (styleValue) {
+        return styleValue.replace(/\-/g, ' ').replace(/\b\w/g, function (chr) {
+            return chr.toUpperCase();
+        });
+    };
+    var normalizeStyleValue = function (styleValue) { return isNullable(styleValue) || styleValue === 'default' ? '' : styleValue; };
+    var makeSetupHandler = function (editor, nodeName) { return function (api) {
+        var updateButtonState = function (editor, parents) {
+            var element = editor.selection.getStart(true);
+            api.setActive(inList(editor, parents, nodeName));
+            api.setEnabled(!isWithinNonEditableList(editor, element) && editor.selection.isEditable());
+        };
+        var nodeChangeHandler = function (e) { return updateButtonState(editor, e.parents); };
+        return setNodeChangeHandler(editor, nodeChangeHandler);
+    }; };
+    var addSplitButton = function (editor, id, tooltip, cmd, nodeName, styles) {
+        editor.ui.registry.addSplitButton(id, {
+            tooltip: tooltip,
+            icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
+            presets: 'listpreview',
+            columns: 3,
+            fetch: function (callback) {
+                var items = global.map(styles, function (styleValue) {
+                    var iconStyle = nodeName === 'OL' ? 'num' : 'bull';
+                    var iconName = styleValue === 'disc' || styleValue === 'decimal' ? 'default' : styleValue;
+                    var itemValue = normalizeStyleValue(styleValue);
+                    var displayText = styleValueToText(styleValue);
+                    return {
+                        type: 'choiceitem',
+                        value: itemValue,
+                        icon: 'list-' + iconStyle + '-' + iconName,
+                        text: displayText
+                    };
+                });
+                callback(items);
+            },
+            onAction: function () { return editor.execCommand(cmd); },
+            onItemAction: function (_splitButtonApi, value) {
+                applyListFormat(editor, nodeName, value);
+            },
+            select: function (value) {
+                var listStyleType = getSelectedStyleType(editor);
+                return listStyleType.map(function (listStyle) { return value === listStyle; }).getOr(false);
+            },
+            onSetup: makeSetupHandler(editor, nodeName)
+        });
+    };
+    var addButton = function (editor, id, tooltip, cmd, nodeName, styleValue) {
+        editor.ui.registry.addToggleButton(id, {
+            active: false,
+            tooltip: tooltip,
+            icon: nodeName === 'OL' ? 'ordered-list' : 'unordered-list',
+            onSetup: makeSetupHandler(editor, nodeName),
+            onAction: function () { return editor.queryCommandState(cmd) || styleValue === '' ? editor.execCommand(cmd) : applyListFormat(editor, nodeName, styleValue); }
+        });
+    };
+    var addControl = function (editor, id, tooltip, cmd, nodeName, styles) {
+        if (styles.length > 1) {
+            addSplitButton(editor, id, tooltip, cmd, nodeName, styles);
+        }
+        else {
+            addButton(editor, id, tooltip, cmd, nodeName, normalizeStyleValue(styles[0]));
+        }
+    };
+    var register = function (editor) {
+        addControl(editor, 'numlist', 'Numbered list', 'InsertOrderedList', 'OL', getNumberStyles(editor));
+        addControl(editor, 'bullist', 'Bullet list', 'InsertUnorderedList', 'UL', getBulletStyles(editor));
+    };
+    var Plugin = function () {
+        global$1.add('advlist', function (editor) {
+            if (editor.hasPlugin('lists')) {
+                register$1(editor);
+                register(editor);
+                register$2(editor);
+            }
+            else {
+                console.error('Please use the Lists plugin together with the Advanced List plugin.');
+            }
+        });
+    };
+    Plugin();
+})();

package/dist/public/tinymce/plugins/autolink/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/autolink/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "autolink" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/autolink')
+//   ES2015:
+//     import 'tinymce/plugins/autolink'
+require('./plugin.js');

package/dist/public/tinymce/plugins/autolink/plugin.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * TinyMCE version 6.8.5 (TBD)
+ */
+(function () {
+    'use strict';
+    var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var link = function () { return /(?:[A-Za-z][A-Za-z\d.+-]{0,14}:\/\/(?:[-.~*+=!&;:'%@?^${}(),\w]+@)?|www\.|[-;:&=+$,.\w]+@)[A-Za-z\d-]+(?:\.[A-Za-z\d-]+)*(?::\d+)?(?:\/(?:[-.~*+=!;:'%@$(),\/\w]*[-~*+=%@$()\/\w])?)?(?:\?(?:[-.~*+=!&;:'%@?^${}(),\/\w]+))?(?:#(?:[-.~*+=!&;:'%@?^${}(),\/\w]+))?/g; };
+    var option = function (name) { return function (editor) { return editor.options.get(name); }; };
+    var register = function (editor) {
+        var registerOption = editor.options.register;
+        registerOption('autolink_pattern', {
+            processor: 'regexp',
+            default: new RegExp('^' + link().source + '$', 'i')
+        });
+        registerOption('link_default_target', { processor: 'string' });
+        registerOption('link_default_protocol', {
+            processor: 'string',
+            default: 'https'
+        });
+    };
+    var getAutoLinkPattern = option('autolink_pattern');
+    var getDefaultLinkTarget = option('link_default_target');
+    var getDefaultLinkProtocol = option('link_default_protocol');
+    var allowUnsafeLinkTarget = option('allow_unsafe_link_target');
+    var hasProto = function (v, constructor, predicate) {
+        var _a;
+        if (predicate(v, constructor.prototype)) {
+            return true;
+        }
+        else {
+            return ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) === constructor.name;
+        }
+    };
+    var typeOf = function (x) {
+        var t = typeof x;
+        if (x === null) {
+            return 'null';
+        }
+        else if (t === 'object' && Array.isArray(x)) {
+            return 'array';
+        }
+        else if (t === 'object' && hasProto(x, String, function (o, proto) { return proto.isPrototypeOf(o); })) {
+            return 'string';
+        }
+        else {
+            return t;
+        }
+    };
+    var isType = function (type) { return function (value) { return typeOf(value) === type; }; };
+    var eq = function (t) { return function (a) { return t === a; }; };
+    var isString = isType('string');
+    var isUndefined = eq(undefined);
+    var isNullable = function (a) { return a === null || a === undefined; };
+    var isNonNullable = function (a) { return !isNullable(a); };
+    var not = function (f) { return function (t) { return !f(t); }; };
+    var hasOwnProperty = Object.hasOwnProperty;
+    var has = function (obj, key) { return hasOwnProperty.call(obj, key); };
+    var checkRange = function (str, substr, start) { return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr; };
+    var contains = function (str, substr, start, end) {
+        if (start === void 0) { start = 0; }
+        var idx = str.indexOf(substr, start);
+        if (idx !== -1) {
+            return isUndefined(end) ? true : idx + substr.length <= end;
+        }
+        else {
+            return false;
+        }
+    };
+    var startsWith = function (str, prefix) {
+        return checkRange(str, prefix, 0);
+    };
+    var zeroWidth = '\uFEFF';
+    var isZwsp = function (char) { return char === zeroWidth; };
+    var removeZwsp = function (s) { return s.replace(/\uFEFF/g, ''); };
+    var global = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker');
+    var isTextNode = function (node) { return node.nodeType === 3; };
+    var isElement = function (node) { return node.nodeType === 1; };
+    var isBracketOrSpace = function (char) { return /^[(\[{ \u00a0]$/.test(char); };
+    var hasProtocol = function (url) { return /^([A-Za-z][A-Za-z\d.+-]*:\/\/)|mailto:/.test(url); };
+    var isPunctuation = function (char) { return /[?!,.;:]/.test(char); };
+    var findChar = function (text, index, predicate) {
+        for (var i = index - 1; i >= 0; i--) {
+            var char = text.charAt(i);
+            if (!isZwsp(char) && predicate(char)) {
+                return i;
+            }
+        }
+        return -1;
+    };
+    var freefallRtl = function (container, offset) {
+        var tempNode = container;
+        var tempOffset = offset;
+        while (isElement(tempNode) && tempNode.childNodes[tempOffset]) {
+            tempNode = tempNode.childNodes[tempOffset];
+            tempOffset = isTextNode(tempNode) ? tempNode.data.length : tempNode.childNodes.length;
+        }
+        return {
+            container: tempNode,
+            offset: tempOffset
+        };
+    };
+    var parseCurrentLine = function (editor, offset) {
+        var _a;
+        var voidElements = editor.schema.getVoidElements();
+        var autoLinkPattern = getAutoLinkPattern(editor);
+        var dom = editor.dom, selection = editor.selection;
+        if (dom.getParent(selection.getNode(), 'a[href]') !== null) {
+            return null;
+        }
+        var rng = selection.getRng();
+        var textSeeker = global(dom, function (node) {
+            return dom.isBlock(node) || has(voidElements, node.nodeName.toLowerCase()) || dom.getContentEditable(node) === 'false';
+        });
+        var _b = freefallRtl(rng.endContainer, rng.endOffset), endContainer = _b.container, endOffset = _b.offset;
+        var root = (_a = dom.getParent(endContainer, dom.isBlock)) !== null && _a !== void 0 ? _a : dom.getRoot();
+        var endSpot = textSeeker.backwards(endContainer, endOffset + offset, function (node, offset) {
+            var text = node.data;
+            var idx = findChar(text, offset, not(isBracketOrSpace));
+            return idx === -1 || isPunctuation(text[idx]) ? idx : idx + 1;
+        }, root);
+        if (!endSpot) {
+            return null;
+        }
+        var lastTextNode = endSpot.container;
+        var startSpot = textSeeker.backwards(endSpot.container, endSpot.offset, function (node, offset) {
+            lastTextNode = node;
+            var idx = findChar(node.data, offset, isBracketOrSpace);
+            return idx === -1 ? idx : idx + 1;
+        }, root);
+        var newRng = dom.createRng();
+        if (!startSpot) {
+            newRng.setStart(lastTextNode, 0);
+        }
+        else {
+            newRng.setStart(startSpot.container, startSpot.offset);
+        }
+        newRng.setEnd(endSpot.container, endSpot.offset);
+        var rngText = removeZwsp(newRng.toString());
+        var matches = rngText.match(autoLinkPattern);
+        if (matches) {
+            var url = matches[0];
+            if (startsWith(url, 'www.')) {
+                var protocol = getDefaultLinkProtocol(editor);
+                url = protocol + '://' + url;
+            }
+            else if (contains(url, '@') && !hasProtocol(url)) {
+                url = 'mailto:' + url;
+            }
+            return {
+                rng: newRng,
+                url: url
+            };
+        }
+        else {
+            return null;
+        }
+    };
+    var convertToLink = function (editor, result) {
+        var dom = editor.dom, selection = editor.selection;
+        var rng = result.rng, url = result.url;
+        var bookmark = selection.getBookmark();
+        selection.setRng(rng);
+        var command = 'createlink';
+        var args = {
+            command: command,
+            ui: false,
+            value: url
+        };
+        var beforeExecEvent = editor.dispatch('BeforeExecCommand', args);
+        if (!beforeExecEvent.isDefaultPrevented()) {
+            editor.getDoc().execCommand(command, false, url);
+            editor.dispatch('ExecCommand', args);
+            var defaultLinkTarget = getDefaultLinkTarget(editor);
+            if (isString(defaultLinkTarget)) {
+                var anchor = selection.getNode();
+                dom.setAttrib(anchor, 'target', defaultLinkTarget);
+                if (defaultLinkTarget === '_blank' && !allowUnsafeLinkTarget(editor)) {
+                    dom.setAttrib(anchor, 'rel', 'noopener');
+                }
+            }
+        }
+        selection.moveToBookmark(bookmark);
+        editor.nodeChanged();
+    };
+    var handleSpacebar = function (editor) {
+        var result = parseCurrentLine(editor, -1);
+        if (isNonNullable(result)) {
+            convertToLink(editor, result);
+        }
+    };
+    var handleBracket = handleSpacebar;
+    var handleEnter = function (editor) {
+        var result = parseCurrentLine(editor, 0);
+        if (isNonNullable(result)) {
+            convertToLink(editor, result);
+        }
+    };
+    var setup = function (editor) {
+        editor.on('keydown', function (e) {
+            if (e.keyCode === 13 && !e.isDefaultPrevented()) {
+                handleEnter(editor);
+            }
+        });
+        editor.on('keyup', function (e) {
+            if (e.keyCode === 32) {
+                handleSpacebar(editor);
+            }
+            else if (e.keyCode === 48 && e.shiftKey || e.keyCode === 221) {
+                handleBracket(editor);
+            }
+        });
+    };
+    var Plugin = function () {
+        global$1.add('autolink', function (editor) {
+            register(editor);
+            setup(editor);
+        });
+    };
+    Plugin();
+})();

package/dist/public/tinymce/plugins/code/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/code/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "code" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/code')
+//   ES2015:
+//     import 'tinymce/plugins/code'
+require('./plugin.js');

package/dist/public/tinymce/plugins/code/plugin.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * TinyMCE version 6.8.5 (TBD)
+ */
+(function () {
+    'use strict';
+    var global = tinymce.util.Tools.resolve('tinymce.PluginManager');
+    var setContent = function (editor, html) {
+        editor.focus();
+        editor.undoManager.transact(function () {
+            editor.setContent(html);
+        });
+        editor.selection.setCursorLocation();
+        editor.nodeChanged();
+    };
+    var getContent = function (editor) {
+        return editor.getContent({ source_view: true });
+    };
+    var open = function (editor) {
+        var editorContent = getContent(editor);
+        editor.windowManager.open({
+            title: 'Source Code',
+            size: 'large',
+            body: {
+                type: 'panel',
+                items: [{
+                        type: 'textarea',
+                        name: 'code'
+                    }]
+            },
+            buttons: [
+                {
+                    type: 'cancel',
+                    name: 'cancel',
+                    text: 'Cancel'
+                },
+                {
+                    type: 'submit',
+                    name: 'save',
+                    text: 'Save',
+                    primary: true
+                }
+            ],
+            initialData: { code: editorContent },
+            onSubmit: function (api) {
+                setContent(editor, api.getData().code);
+                api.close();
+            }
+        });
+    };
+    var register$1 = function (editor) {
+        editor.addCommand('mceCodeEditor', function () {
+            open(editor);
+        });
+    };
+    var register = function (editor) {
+        var onAction = function () { return editor.execCommand('mceCodeEditor'); };
+        editor.ui.registry.addButton('code', {
+            icon: 'sourcecode',
+            tooltip: 'Source code',
+            onAction: onAction
+        });
+        editor.ui.registry.addMenuItem('code', {
+            icon: 'sourcecode',
+            text: 'Source code',
+            onAction: onAction
+        });
+    };
+    var Plugin = function () {
+        global.add('code', function (editor) {
+            register$1(editor);
+            register(editor);
+            return {};
+        });
+    };
+    Plugin();
+})();

package/dist/public/tinymce/plugins/codesample/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/public/tinymce/plugins/codesample/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Exports the "codesample" plugin for usage with module loaders
+// Usage:
+//   CommonJS:
+//     require('tinymce/plugins/codesample')
+//   ES2015:
+//     import 'tinymce/plugins/codesample'
+require('./plugin.js');

package/dist/public/tinymce/plugins/codesample/plugin.d.ts

@@ -0,0 +1,45 @@
+declare var plainTextGrammar: {};
+export function Token(type: any, content: any, alias: any, matchedStr: any): void;
+export namespace Token {
+    function stringify(o: any, language: any): any;
+}
+export class Token {
+    constructor(type: any, content: any, alias: any, matchedStr: any);
+    type: any;
+    content: any;
+    alias: any;
+    length: number;
+}
+export declare let manual: any;
+export declare let disableWorkerMessageHandler: any;
+export declare namespace util {
+    function encode(tokens: any): any;
+    function type(o: any): string;
+    function objId(obj: any): any;
+    function clone(o: any, visited: any): any;
+    function getLanguage(element: any): string;
+    function setLanguage(element: any, language: any): void;
+    function currentScript(): HTMLOrSVGScriptElement | null;
+    function isActive(element: any, className: any, defaultActivation: any): boolean;
+}
+export declare namespace languages {
+    export { plainTextGrammar as plain };
+    export { plainTextGrammar as plaintext };
+    export { plainTextGrammar as text };
+    export { plainTextGrammar as txt };
+    export function extend(id: any, redef: any): any;
+    export function insertBefore(inside: any, before: any, insert: any, root: any): {};
+    export function DFS(o: any, callback: any, type: any, visited: any): void;
+}
+export declare let plugins: {};
+export declare function highlightAll(async: any, callback: any): void;
+export declare function highlightAllUnder(container: any, async: any, callback: any): void;
+export declare function highlightElement(element: any, async: any, callback: any): void;
+export declare function highlight(text: any, grammar: any, language: any): any;
+export declare function tokenize(text: any, grammar: any): any[];
+export declare namespace hooks {
+    let all: {};
+    function add(name: any, callback: any): void;
+    function run(name: any, env: any): void;
+}
+export {};