@koobiq/components 18.7.1 → 18.9.0

package/esm2022/code-block/code-block-content.mjs

@@ -0,0 +1,382 @@
+import { booleanAttribute, Directive, ElementRef, inject, Input, numberAttribute, Renderer2, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import hljs from 'highlight.js';
+import * as i0 from "@angular/core";
+const KBQ_CODE_BLOCK_FALLBACK_LANGUAGE = 'plaintext';
+export class KbqCodeBlockContent {
+    /** The code file. */
+    set file({ language, content }) {
+        if (!hljs.getLanguage(language)) {
+            console.warn(`[KBQ] Unknown language: "${language}". Setting to "${KBQ_CODE_BLOCK_FALLBACK_LANGUAGE}".`);
+            language = KBQ_CODE_BLOCK_FALLBACK_LANGUAGE;
+        }
+        const { value: highlightedHTML, language: highlightedLanguage } = hljs.highlight(content, { language });
+        const safeHTML = this.domSanitizer.sanitize(SecurityContext.HTML, highlightedHTML);
+        const highlightedHTMLWithLineNumbers = window['hljs'].lineNumbersValue(safeHTML, {
+            startFrom: this.startFrom,
+            singleLine: this.singleLine
+        });
+        this.renderer.setAttribute(this.elementRef.nativeElement, 'data-language', highlightedLanguage);
+        this.renderer.setProperty(this.elementRef.nativeElement, 'innerHTML', highlightedHTMLWithLineNumbers);
+    }
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        this.renderer = inject(Renderer2);
+        this.domSanitizer = inject(DomSanitizer);
+        /** The starting line number. */
+        this.startFrom = 1;
+        /** Whether to display line numbers for single line code block. */
+        this.singleLine = false;
+        this.initLineNumbersPlugin();
+    }
+    /**
+     * @TODO Add SSR support (#DS-3173)
+     */
+    initLineNumbersPlugin() {
+        window['hljs'] = hljs;
+        this.highlightJSLineNumbersPlugin();
+    }
+    /**
+     * This method is not intended for editing.
+     * Changes may lead to unpredictable behavior.
+     * Source code: https://github.com/wcoder/highlightjs-line-numbers.js/blob/v2.9.0/src/highlightjs-line-numbers.js
+     */
+    highlightJSLineNumbersPlugin() {
+        'use strict';
+        const w = window;
+        const d = document;
+        const TABLE_NAME = 'hljs-ln', LINE_NAME = 'hljs-ln-line', CODE_BLOCK_NAME = 'hljs-ln-code', NUMBERS_BLOCK_NAME = 'hljs-ln-numbers', NUMBER_LINE_NAME = 'hljs-ln-n', DATA_ATTR_NAME = 'data-line-number', BREAK_LINE_REGEXP = /\r\n|\r|\n/g;
+        if (w['hljs']) {
+            w['hljs'].initLineNumbersOnLoad = initLineNumbersOnLoad;
+            w['hljs'].lineNumbersBlock = lineNumbersBlock;
+            w['hljs'].lineNumbersBlockSync = lineNumbersBlockSync;
+            w['hljs'].lineNumbersValue = lineNumbersValue;
+            addStyles();
+        }
+        else {
+            w.console.error('highlight.js not detected!');
+        }
+        function isHljsLnCodeDescendant(domElt) {
+            let curElt = domElt;
+            while (curElt) {
+                if (curElt.className && curElt.className.indexOf('hljs-ln-code') !== -1) {
+                    return true;
+                }
+                curElt = curElt.parentNode;
+            }
+            return false;
+        }
+        function getHljsLnTable(hljsLnDomElt) {
+            let curElt = hljsLnDomElt;
+            while (curElt.nodeName !== 'TABLE') {
+                curElt = curElt.parentNode;
+            }
+            return curElt;
+        }
+        // Function to workaround a copy issue with Microsoft Edge.
+        // Due to hljs-ln wrapping the lines of code inside a <table> element,
+        // itself wrapped inside a <pre> element, window.getSelection().toString()
+        // does not contain any line breaks. So we need to get them back using the
+        // rendered code in the DOM as reference.
+        function edgeGetSelectedCodeLines(selection) {
+            // current selected text without line breaks
+            const selectionText = selection.toString();
+            // get the <td> element wrapping the first line of selected code
+            let tdAnchor = selection.anchorNode;
+            while (tdAnchor.nodeName !== 'TD') {
+                tdAnchor = tdAnchor.parentNode;
+            }
+            // get the <td> element wrapping the last line of selected code
+            let tdFocus = selection.focusNode;
+            while (tdFocus.nodeName !== 'TD') {
+                tdFocus = tdFocus.parentNode;
+            }
+            // extract line numbers
+            let firstLineNumber = parseInt(tdAnchor.dataset.lineNumber);
+            let lastLineNumber = parseInt(tdFocus.dataset.lineNumber);
+            // multi-lines copied case
+            if (firstLineNumber != lastLineNumber) {
+                let firstLineText = tdAnchor.textContent;
+                let lastLineText = tdFocus.textContent;
+                // if the selection was made backward, swap values
+                if (firstLineNumber > lastLineNumber) {
+                    let tmp = firstLineNumber;
+                    firstLineNumber = lastLineNumber;
+                    lastLineNumber = tmp;
+                    tmp = firstLineText;
+                    firstLineText = lastLineText;
+                    lastLineText = tmp;
+                }
+                // discard not copied characters in first line
+                while (selectionText.indexOf(firstLineText) !== 0) {
+                    firstLineText = firstLineText.slice(1);
+                }
+                // discard not copied characters in last line
+                while (selectionText.lastIndexOf(lastLineText) === -1) {
+                    lastLineText = lastLineText.slice(0, -1);
+                }
+                // reconstruct and return the real copied text
+                let selectedText = firstLineText;
+                const hljsLnTable = getHljsLnTable(tdAnchor);
+                for (let i = firstLineNumber + 1; i < lastLineNumber; ++i) {
+                    const codeLineSel = format('.{0}[{1}="{2}"]', [CODE_BLOCK_NAME, DATA_ATTR_NAME, i]);
+                    const codeLineElt = hljsLnTable.querySelector(codeLineSel);
+                    selectedText += '\n' + codeLineElt.textContent;
+                }
+                selectedText += '\n' + lastLineText;
+                return selectedText;
+                // single copied line case
+            }
+            else {
+                return selectionText;
+            }
+        }
+        // ensure consistent code copy/paste behavior across all browsers
+        // (see https://github.com/wcoder/highlightjs-line-numbers.js/issues/51)
+        d.addEventListener('copy', function (e) {
+            // get current selection
+            const selection = w.getSelection();
+            // override behavior when one wants to copy line of codes
+            if (isHljsLnCodeDescendant(selection.anchorNode)) {
+                let selectionText;
+                // workaround an issue with Microsoft Edge as copied line breaks
+                // are removed otherwise from the selection string
+                if (w.navigator.userAgent.indexOf('Edge') !== -1) {
+                    selectionText = edgeGetSelectedCodeLines(selection);
+                }
+                else {
+                    // other browsers can directly use the selection string
+                    selectionText = selection.toString();
+                }
+                e.clipboardData.setData('text/plain', selectionText);
+                e.preventDefault();
+            }
+        });
+        function addStyles() {
+            const css = d.createElement('style');
+            css.type = 'text/css';
+            css.innerHTML = format('.{0}{border-collapse:collapse}' + '.{0} td{padding:0}' + '.{1}:before{content:attr({2})}', [
+                TABLE_NAME,
+                NUMBER_LINE_NAME,
+                DATA_ATTR_NAME
+            ]);
+            d.getElementsByTagName('head')[0].appendChild(css);
+        }
+        function initLineNumbersOnLoad(options) {
+            if (d.readyState === 'interactive' || d.readyState === 'complete') {
+                documentReady(options);
+            }
+            else {
+                w.addEventListener('DOMContentLoaded', function () {
+                    documentReady(options);
+                });
+            }
+        }
+        function documentReady(options) {
+            try {
+                const blocks = d.querySelectorAll('code.hljs,code.nohighlight');
+                for (const i in blocks) {
+                    if (blocks.hasOwnProperty(i)) {
+                        if (!isPluginDisabledForBlock(blocks[i])) {
+                            lineNumbersBlock(blocks[i], options);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                w.console.error('LineNumbers error: ', e);
+            }
+        }
+        function isPluginDisabledForBlock(element) {
+            return element.classList.contains('nohljsln');
+        }
+        function lineNumbersBlock(element, options) {
+            if (typeof element !== 'object')
+                return;
+            async(function () {
+                element.innerHTML = lineNumbersInternal(element, options);
+            });
+        }
+        function lineNumbersBlockSync(element, options) {
+            if (typeof element !== 'object')
+                return;
+            element.innerHTML = lineNumbersInternal(element, options);
+        }
+        function lineNumbersValue(value, options) {
+            if (typeof value !== 'string')
+                return;
+            const element = d.createElement('code');
+            element.innerHTML = value;
+            return lineNumbersInternal(element, options);
+        }
+        function lineNumbersInternal(element, options) {
+            const internalOptions = mapOptions(element, options);
+            duplicateMultilineNodes(element);
+            return addLineNumbersBlockFor(element.innerHTML, internalOptions);
+        }
+        function addLineNumbersBlockFor(inputHtml, options) {
+            const lines = getLines(inputHtml);
+            // if last line contains only carriage return remove it
+            if (lines[lines.length - 1].trim() === '') {
+                lines.pop();
+            }
+            if (lines.length > 1 || options.singleLine) {
+                let html = '';
+                for (let i = 0, l = lines.length; i < l; i++) {
+                    html += format('<tr>' +
+                        '<td class="{0} {1}" {3}="{5}">' +
+                        '<div class="{2}" {3}="{5}"></div>' +
+                        '</td>' +
+                        '<td class="{0} {4}" {3}="{5}">' +
+                        '{6}' +
+                        '</td>' +
+                        '</tr>', [
+                        LINE_NAME,
+                        NUMBERS_BLOCK_NAME,
+                        NUMBER_LINE_NAME,
+                        DATA_ATTR_NAME,
+                        CODE_BLOCK_NAME,
+                        i + options.startFrom,
+                        lines[i].length > 0 ? lines[i] : ' '
+                    ]);
+                }
+                return format('<table class="{0}">{1}</table>', [TABLE_NAME, html]);
+            }
+            return inputHtml;
+        }
+        /**
+         * @param {HTMLElement} element Code block.
+         * @param {Object} options External API options.
+         * @returns {Object} Internal API options.
+         */
+        function mapOptions(element, options) {
+            options = options || {};
+            return {
+                singleLine: getSingleLineOption(options),
+                startFrom: getStartFromOption(element, options)
+            };
+        }
+        function getSingleLineOption(options) {
+            const defaultValue = false;
+            if (options.singleLine) {
+                return options.singleLine;
+            }
+            return defaultValue;
+        }
+        function getStartFromOption(element, options) {
+            const defaultValue = 1;
+            let startFrom = defaultValue;
+            if (isFinite(options.startFrom)) {
+                startFrom = options.startFrom;
+            }
+            // can be overridden because local option is priority
+            const value = getAttribute(element, 'data-ln-start-from');
+            if (value !== null) {
+                startFrom = toNumber(value, defaultValue);
+            }
+            return startFrom;
+        }
+        /**
+         * Recursive method for fix multi-line elements implementation in highlight.js
+         * Doing deep passage on child nodes.
+         * @param {HTMLElement} element
+         */
+        function duplicateMultilineNodes(element) {
+            const nodes = element.childNodes;
+            for (const node in nodes) {
+                if (nodes.hasOwnProperty(node)) {
+                    const child = nodes[node];
+                    if (getLinesCount(child.textContent) > 0) {
+                        if (child.childNodes.length > 0) {
+                            duplicateMultilineNodes(child);
+                        }
+                        else {
+                            duplicateMultilineNode(child.parentNode);
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Method for fix multi-line elements implementation in highlight.js
+         * @param {HTMLElement} element
+         */
+        function duplicateMultilineNode(element) {
+            const className = element.className;
+            if (!/hljs-/.test(className))
+                return;
+            const lines = getLines(element.innerHTML);
+            let result = '';
+            for (let i = 0; i < lines.length; i++) {
+                const lineText = lines[i].length > 0 ? lines[i] : ' ';
+                result += format('<span class="{0}">{1}</span>\n', [className, lineText]);
+            }
+            element.innerHTML = result.trim();
+        }
+        function getLines(text) {
+            if (text.length === 0)
+                return [];
+            return text.split(BREAK_LINE_REGEXP);
+        }
+        function getLinesCount(text) {
+            return (text.trim().match(BREAK_LINE_REGEXP) || []).length;
+        }
+        ///
+        /// HELPERS
+        ///
+        function async(func) {
+            w.setTimeout(func, 0);
+        }
+        /**
+         * {@link https://wcoder.github.io/notes/string-format-for-string-formating-in-javascript}
+         * @param {string} format
+         * @param {array} args
+         */
+        function format(format, args) {
+            return format.replace(/\{(\d+)\}/g, function (m, n) {
+                return args[n] !== undefined ? args[n] : m;
+            });
+        }
+        /**
+         * @param {HTMLElement} element Code block.
+         * @param {String} attrName Attribute name.
+         * @returns {String} Attribute value or empty.
+         */
+        function getAttribute(element, attrName) {
+            return element.hasAttribute(attrName) ? element.getAttribute(attrName) : null;
+        }
+        /**
+         * @param {String} str Source string.
+         * @param {Number} fallback Fallback value.
+         * @returns Parsed number or fallback value.
+         */
+        function toNumber(str, fallback) {
+            if (!str)
+                return fallback;
+            const number = Number(str);
+            return isFinite(number) ? number : fallback;
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: KbqCodeBlockContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.6", type: KbqCodeBlockContent, isStandalone: true, selector: "[kbqCodeBlockContent]", inputs: { file: "file", startFrom: ["startFrom", "startFrom", numberAttribute], singleLine: ["singleLine", "singleLine", booleanAttribute] }, host: { classAttribute: "hljs" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: KbqCodeBlockContent, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[kbqCodeBlockContent]',
+                    host: {
+                        class: 'hljs'
+                    }
+                }]
+        }], ctorParameters: () => [], propDecorators: { file: [{
+                type: Input,
+                args: [{ required: true }]
+            }], startFrom: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], singleLine: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-block-content.js","sourceRoot":"","sources":["../../../../packages/components/code-block/code-block-content.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,MAAM,EACN,KAAK,EACL,eAAe,EACf,SAAS,EACT,eAAe,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,IAAI,MAAM,cAAc,CAAC;;AAGhC,MAAM,gCAAgC,GAAG,WAAW,CAAC;AASrD,MAAM,OAAO,mBAAmB;IAK5B,qBAAqB;IACrB,IAA+B,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAoB;QACvE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,IAAI,CAAC,4BAA4B,QAAQ,kBAAkB,gCAAgC,IAAI,CAAC,CAAC;YACzG,QAAQ,GAAG,gCAAgC,CAAC;QAChD,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxG,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QACnF,MAAM,8BAA8B,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,QAAQ,EAAE;YAC7E,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC9B,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,eAAe,EAAE,mBAAoB,CAAC,CAAC;QACjG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,WAAW,EAAE,8BAA8B,CAAC,CAAC;IAC1G,CAAC;IAQD;QA3BiB,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAChC,aAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;QAC7B,iBAAY,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAmBrD,gCAAgC;QACO,cAAS,GAAW,CAAC,CAAC;QAE7D,kEAAkE;QAC1B,eAAU,GAAY,KAAK,CAAC;QAGhE,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACK,qBAAqB;QACzB,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,4BAA4B,EAAE,CAAC;IACxC,CAAC;IAED;;;;OAIG;IACK,4BAA4B;QAChC,YAAY,CAAC;QAEb,MAAM,CAAC,GAAG,MAAM,CAAC;QACjB,MAAM,CAAC,GAAG,QAAQ,CAAC;QAEnB,MAAM,UAAU,GAAG,SAAS,EACxB,SAAS,GAAG,cAAc,EAC1B,eAAe,GAAG,cAAc,EAChC,kBAAkB,GAAG,iBAAiB,EACtC,gBAAgB,GAAG,WAAW,EAC9B,cAAc,GAAG,kBAAkB,EACnC,iBAAiB,GAAG,aAAa,CAAC;QAEtC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;YACZ,CAAC,CAAC,MAAM,CAAC,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;YACxD,CAAC,CAAC,MAAM,CAAC,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;YAC9C,CAAC,CAAC,MAAM,CAAC,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;YACtD,CAAC,CAAC,MAAM,CAAC,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;YAE9C,SAAS,EAAE,CAAC;QAChB,CAAC;aAAM,CAAC;YACJ,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAClD,CAAC;QAED,SAAS,sBAAsB,CAAC,MAAM;YAClC,IAAI,MAAM,GAAG,MAAM,CAAC;YACpB,OAAO,MAAM,EAAE,CAAC;gBACZ,IAAI,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;oBACtE,OAAO,IAAI,CAAC;gBAChB,CAAC;gBACD,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC;YAC/B,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,SAAS,cAAc,CAAC,YAAY;YAChC,IAAI,MAAM,GAAG,YAAY,CAAC;YAC1B,OAAO,MAAM,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;gBACjC,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC;YAC/B,CAAC;YACD,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,2DAA2D;QAC3D,sEAAsE;QACtE,0EAA0E;QAC1E,0EAA0E;QAC1E,yCAAyC;QACzC,SAAS,wBAAwB,CAAC,SAAS;YACvC,4CAA4C;YAC5C,MAAM,aAAa,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;YAE3C,gEAAgE;YAChE,IAAI,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC;YACpC,OAAO,QAAQ,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;gBAChC,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC;YACnC,CAAC;YAED,+DAA+D;YAC/D,IAAI,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC;YAClC,OAAO,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;gBAC/B,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;YACjC,CAAC;YAED,uBAAuB;YACvB,IAAI,eAAe,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC5D,IAAI,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAE1D,0BAA0B;YAC1B,IAAI,eAAe,IAAI,cAAc,EAAE,CAAC;gBACpC,IAAI,aAAa,GAAG,QAAQ,CAAC,WAAW,CAAC;gBACzC,IAAI,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;gBAEvC,kDAAkD;gBAClD,IAAI,eAAe,GAAG,cAAc,EAAE,CAAC;oBACnC,IAAI,GAAG,GAAG,eAAe,CAAC;oBAC1B,eAAe,GAAG,cAAc,CAAC;oBACjC,cAAc,GAAG,GAAG,CAAC;oBACrB,GAAG,GAAG,aAAa,CAAC;oBACpB,aAAa,GAAG,YAAY,CAAC;oBAC7B,YAAY,GAAG,GAAG,CAAC;gBACvB,CAAC;gBAED,8CAA8C;gBAC9C,OAAO,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;oBAChD,aAAa,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC3C,CAAC;gBAED,6CAA6C;gBAC7C,OAAO,aAAa,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;oBACpD,YAAY,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC7C,CAAC;gBAED,8CAA8C;gBAC9C,IAAI,YAAY,GAAG,aAAa,CAAC;gBACjC,MAAM,WAAW,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;gBAC7C,KAAK,IAAI,CAAC,GAAG,eAAe,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,EAAE,EAAE,CAAC,EAAE,CAAC;oBACxD,MAAM,WAAW,GAAG,MAAM,CAAC,iBAAiB,EAAE,CAAC,eAAe,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC;oBACpF,MAAM,WAAW,GAAG,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;oBAC3D,YAAY,IAAI,IAAI,GAAG,WAAW,CAAC,WAAW,CAAC;gBACnD,CAAC;gBACD,YAAY,IAAI,IAAI,GAAG,YAAY,CAAC;gBACpC,OAAO,YAAY,CAAC;gBACpB,0BAA0B;YAC9B,CAAC;iBAAM,CAAC;gBACJ,OAAO,aAAa,CAAC;YACzB,CAAC;QACL,CAAC;QAED,iEAAiE;QACjE,wEAAwE;QACxE,CAAC,CAAC,gBAAgB,CAAC,MAAM,EAAE,UAAU,CAAC;YAClC,wBAAwB;YACxB,MAAM,SAAS,GAAG,CAAC,CAAC,YAAY,EAAG,CAAC;YACpC,yDAAyD;YACzD,IAAI,sBAAsB,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC/C,IAAI,aAAa,CAAC;gBAClB,gEAAgE;gBAChE,kDAAkD;gBAClD,IAAI,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;oBAC/C,aAAa,GAAG,wBAAwB,CAAC,SAAS,CAAC,CAAC;gBACxD,CAAC;qBAAM,CAAC;oBACJ,uDAAuD;oBACvD,aAAa,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACzC,CAAC;gBACD,CAAC,CAAC,aAAc,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;gBACtD,CAAC,CAAC,cAAc,EAAE,CAAC;YACvB,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,SAAS,SAAS;YACd,MAAM,GAAG,GAAG,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YACrC,GAAG,CAAC,IAAI,GAAG,UAAU,CAAC;YACtB,GAAG,CAAC,SAAS,GAAG,MAAM,CAClB,gCAAgC,GAAG,oBAAoB,GAAG,gCAAgC,EAC1F;gBACI,UAAU;gBACV,gBAAgB;gBAChB,cAAc;aACjB,CACJ,CAAC;YACF,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACvD,CAAC;QAED,SAAS,qBAAqB,CAAC,OAAO;YAClC,IAAI,CAAC,CAAC,UAAU,KAAK,aAAa,IAAI,CAAC,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;gBAChE,aAAa,CAAC,OAAO,CAAC,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACJ,CAAC,CAAC,gBAAgB,CAAC,kBAAkB,EAAE;oBACnC,aAAa,CAAC,OAAO,CAAC,CAAC;gBAC3B,CAAC,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,SAAS,aAAa,CAAC,OAAO;YAC1B,IAAI,CAAC;gBACD,MAAM,MAAM,GAAG,CAAC,CAAC,gBAAgB,CAAC,4BAA4B,CAAC,CAAC;gBAEhE,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;oBACrB,IAAI,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;wBAC3B,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;4BACvC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;wBACzC,CAAC;oBACL,CAAC;gBACL,CAAC;YACL,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC;YAC9C,CAAC;QACL,CAAC;QAED,SAAS,wBAAwB,CAAC,OAAO;YACrC,OAAO,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAClD,CAAC;QAED,SAAS,gBAAgB,CAAC,OAAO,EAAE,OAAO;YACtC,IAAI,OAAO,OAAO,KAAK,QAAQ;gBAAE,OAAO;YAExC,KAAK,CAAC;gBACF,OAAO,CAAC,SAAS,GAAG,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC9D,CAAC,CAAC,CAAC;QACP,CAAC;QAED,SAAS,oBAAoB,CAAC,OAAO,EAAE,OAAO;YAC1C,IAAI,OAAO,OAAO,KAAK,QAAQ;gBAAE,OAAO;YAExC,OAAO,CAAC,SAAS,GAAG,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC9D,CAAC;QAED,SAAS,gBAAgB,CAAC,KAAK,EAAE,OAAO;YACpC,IAAI,OAAO,KAAK,KAAK,QAAQ;gBAAE,OAAO;YAEtC,MAAM,OAAO,GAAG,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YACxC,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC;YAE1B,OAAO,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,SAAS,mBAAmB,CAAC,OAAO,EAAE,OAAO;YACzC,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAErD,uBAAuB,CAAC,OAAO,CAAC,CAAC;YAEjC,OAAO,sBAAsB,CAAC,OAAO,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;QACtE,CAAC;QAED,SAAS,sBAAsB,CAAC,SAAS,EAAE,OAAO;YAC9C,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;YAElC,uDAAuD;YACvD,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;gBACxC,KAAK,CAAC,GAAG,EAAE,CAAC;YAChB,CAAC;YAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;gBACzC,IAAI,IAAI,GAAG,EAAE,CAAC;gBAEd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC3C,IAAI,IAAI,MAAM,CACV,MAAM;wBACF,gCAAgC;wBAChC,mCAAmC;wBACnC,OAAO;wBACP,gCAAgC;wBAChC,KAAK;wBACL,OAAO;wBACP,OAAO,EACX;wBACI,SAAS;wBACT,kBAAkB;wBAClB,gBAAgB;wBAChB,cAAc;wBACd,eAAe;wBACf,CAAC,GAAG,OAAO,CAAC,SAAS;wBACrB,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;qBACvC,CACJ,CAAC;gBACN,CAAC;gBAED,OAAO,MAAM,CAAC,gCAAgC,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;YACxE,CAAC;YAED,OAAO,SAAS,CAAC;QACrB,CAAC;QAED;;;;WAIG;QACH,SAAS,UAAU,CAAC,OAAO,EAAE,OAAO;YAChC,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;YACxB,OAAO;gBACH,UAAU,EAAE,mBAAmB,CAAC,OAAO,CAAC;gBACxC,SAAS,EAAE,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC;aAClD,CAAC;QACN,CAAC;QAED,SAAS,mBAAmB,CAAC,OAAO;YAChC,MAAM,YAAY,GAAG,KAAK,CAAC;YAC3B,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;gBACrB,OAAO,OAAO,CAAC,UAAU,CAAC;YAC9B,CAAC;YACD,OAAO,YAAY,CAAC;QACxB,CAAC;QAED,SAAS,kBAAkB,CAAC,OAAO,EAAE,OAAO;YACxC,MAAM,YAAY,GAAG,CAAC,CAAC;YACvB,IAAI,SAAS,GAAG,YAAY,CAAC;YAE7B,IAAI,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC9B,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;YAClC,CAAC;YAED,qDAAqD;YACrD,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;YAC1D,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACjB,SAAS,GAAG,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YAC9C,CAAC;YAED,OAAO,SAAS,CAAC;QACrB,CAAC;QAED;;;;WAIG;QACH,SAAS,uBAAuB,CAAC,OAAO;YACpC,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC;YACjC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACvB,IAAI,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;oBAC1B,IAAI,aAAa,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;wBACvC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;4BAC9B,uBAAuB,CAAC,KAAK,CAAC,CAAC;wBACnC,CAAC;6BAAM,CAAC;4BACJ,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;wBAC7C,CAAC;oBACL,CAAC;gBACL,CAAC;YACL,CAAC;QACL,CAAC;QAED;;;WAGG;QACH,SAAS,sBAAsB,CAAC,OAAO;YACnC,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;YAEpC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC;gBAAE,OAAO;YAErC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAE1C,IAAI,MAAM,GAAG,EAAE,CAAC;YAEhB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACpC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;gBACtD,MAAM,IAAI,MAAM,CAAC,gCAAgC,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC9E,CAAC;YAED,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;QACtC,CAAC;QAED,SAAS,QAAQ,CAAC,IAAI;YAClB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACzC,CAAC;QAED,SAAS,aAAa,CAAC,IAAI;YACvB,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;QAC/D,CAAC;QAED,GAAG;QACH,WAAW;QACX,GAAG;QAEH,SAAS,KAAK,CAAC,IAAI;YACf,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAC1B,CAAC;QAED;;;;WAIG;QACH,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI;YACxB,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,UAAU,CAAC,EAAE,CAAC;gBAC9C,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/C,CAAC,CAAC,CAAC;QACP,CAAC;QAED;;;;WAIG;QACH,SAAS,YAAY,CAAC,OAAO,EAAE,QAAQ;YACnC,OAAO,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAClF,CAAC;QAED;;;;WAIG;QACH,SAAS,QAAQ,CAAC,GAAG,EAAE,QAAQ;YAC3B,IAAI,CAAC,GAAG;gBAAE,OAAO,QAAQ,CAAC;YAC1B,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC3B,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;QAChD,CAAC;IACL,CAAC;iIAjaQ,mBAAmB;qHAAnB,mBAAmB,uHAuBR,eAAe,4CAGf,gBAAgB;;2FA1B3B,mBAAmB;kBAP/B,SAAS;mBAAC;oBACP,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,uBAAuB;oBACjC,IAAI,EAAE;wBACF,KAAK,EAAE,MAAM;qBAChB;iBACJ;wDAOkC,IAAI;sBAAlC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAiBc,SAAS;sBAA/C,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAGG,UAAU;sBAAjD,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE","sourcesContent":["import {\n    booleanAttribute,\n    Directive,\n    ElementRef,\n    inject,\n    Input,\n    numberAttribute,\n    Renderer2,\n    SecurityContext\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport hljs from 'highlight.js';\nimport { KbqCodeBlockFile } from './code-block.types';\n\nconst KBQ_CODE_BLOCK_FALLBACK_LANGUAGE = 'plaintext';\n\n@Directive({\n    standalone: true,\n    selector: '[kbqCodeBlockContent]',\n    host: {\n        class: 'hljs'\n    }\n})\nexport class KbqCodeBlockContent {\n    private readonly elementRef = inject(ElementRef);\n    private readonly renderer = inject(Renderer2);\n    private readonly domSanitizer = inject(DomSanitizer);\n\n    /** The code file. */\n    @Input({ required: true }) set file({ language, content }: KbqCodeBlockFile) {\n        if (!hljs.getLanguage(language)) {\n            console.warn(`[KBQ] Unknown language: \"${language}\". Setting to \"${KBQ_CODE_BLOCK_FALLBACK_LANGUAGE}\".`);\n            language = KBQ_CODE_BLOCK_FALLBACK_LANGUAGE;\n        }\n        const { value: highlightedHTML, language: highlightedLanguage } = hljs.highlight(content, { language });\n        const safeHTML = this.domSanitizer.sanitize(SecurityContext.HTML, highlightedHTML);\n        const highlightedHTMLWithLineNumbers = window['hljs'].lineNumbersValue(safeHTML, {\n            startFrom: this.startFrom,\n            singleLine: this.singleLine\n        });\n\n        this.renderer.setAttribute(this.elementRef.nativeElement, 'data-language', highlightedLanguage!);\n        this.renderer.setProperty(this.elementRef.nativeElement, 'innerHTML', highlightedHTMLWithLineNumbers);\n    }\n\n    /** The starting line number. */\n    @Input({ transform: numberAttribute }) startFrom: number = 1;\n\n    /** Whether to display line numbers for single line code block. */\n    @Input({ transform: booleanAttribute }) singleLine: boolean = false;\n\n    constructor() {\n        this.initLineNumbersPlugin();\n    }\n\n    /**\n     * @TODO Add SSR support (#DS-3173)\n     */\n    private initLineNumbersPlugin(): void {\n        window['hljs'] = hljs;\n        this.highlightJSLineNumbersPlugin();\n    }\n\n    /**\n     * This method is not intended for editing.\n     * Changes may lead to unpredictable behavior.\n     * Source code: https://github.com/wcoder/highlightjs-line-numbers.js/blob/v2.9.0/src/highlightjs-line-numbers.js\n     */\n    private highlightJSLineNumbersPlugin(): void {\n        'use strict';\n\n        const w = window;\n        const d = document;\n\n        const TABLE_NAME = 'hljs-ln',\n            LINE_NAME = 'hljs-ln-line',\n            CODE_BLOCK_NAME = 'hljs-ln-code',\n            NUMBERS_BLOCK_NAME = 'hljs-ln-numbers',\n            NUMBER_LINE_NAME = 'hljs-ln-n',\n            DATA_ATTR_NAME = 'data-line-number',\n            BREAK_LINE_REGEXP = /\\r\\n|\\r|\\n/g;\n\n        if (w['hljs']) {\n            w['hljs'].initLineNumbersOnLoad = initLineNumbersOnLoad;\n            w['hljs'].lineNumbersBlock = lineNumbersBlock;\n            w['hljs'].lineNumbersBlockSync = lineNumbersBlockSync;\n            w['hljs'].lineNumbersValue = lineNumbersValue;\n\n            addStyles();\n        } else {\n            w.console.error('highlight.js not detected!');\n        }\n\n        function isHljsLnCodeDescendant(domElt) {\n            let curElt = domElt;\n            while (curElt) {\n                if (curElt.className && curElt.className.indexOf('hljs-ln-code') !== -1) {\n                    return true;\n                }\n                curElt = curElt.parentNode;\n            }\n            return false;\n        }\n\n        function getHljsLnTable(hljsLnDomElt) {\n            let curElt = hljsLnDomElt;\n            while (curElt.nodeName !== 'TABLE') {\n                curElt = curElt.parentNode;\n            }\n            return curElt;\n        }\n\n        // Function to workaround a copy issue with Microsoft Edge.\n        // Due to hljs-ln wrapping the lines of code inside a <table> element,\n        // itself wrapped inside a <pre> element, window.getSelection().toString()\n        // does not contain any line breaks. So we need to get them back using the\n        // rendered code in the DOM as reference.\n        function edgeGetSelectedCodeLines(selection) {\n            // current selected text without line breaks\n            const selectionText = selection.toString();\n\n            // get the <td> element wrapping the first line of selected code\n            let tdAnchor = selection.anchorNode;\n            while (tdAnchor.nodeName !== 'TD') {\n                tdAnchor = tdAnchor.parentNode;\n            }\n\n            // get the <td> element wrapping the last line of selected code\n            let tdFocus = selection.focusNode;\n            while (tdFocus.nodeName !== 'TD') {\n                tdFocus = tdFocus.parentNode;\n            }\n\n            // extract line numbers\n            let firstLineNumber = parseInt(tdAnchor.dataset.lineNumber);\n            let lastLineNumber = parseInt(tdFocus.dataset.lineNumber);\n\n            // multi-lines copied case\n            if (firstLineNumber != lastLineNumber) {\n                let firstLineText = tdAnchor.textContent;\n                let lastLineText = tdFocus.textContent;\n\n                // if the selection was made backward, swap values\n                if (firstLineNumber > lastLineNumber) {\n                    let tmp = firstLineNumber;\n                    firstLineNumber = lastLineNumber;\n                    lastLineNumber = tmp;\n                    tmp = firstLineText;\n                    firstLineText = lastLineText;\n                    lastLineText = tmp;\n                }\n\n                // discard not copied characters in first line\n                while (selectionText.indexOf(firstLineText) !== 0) {\n                    firstLineText = firstLineText.slice(1);\n                }\n\n                // discard not copied characters in last line\n                while (selectionText.lastIndexOf(lastLineText) === -1) {\n                    lastLineText = lastLineText.slice(0, -1);\n                }\n\n                // reconstruct and return the real copied text\n                let selectedText = firstLineText;\n                const hljsLnTable = getHljsLnTable(tdAnchor);\n                for (let i = firstLineNumber + 1; i < lastLineNumber; ++i) {\n                    const codeLineSel = format('.{0}[{1}=\"{2}\"]', [CODE_BLOCK_NAME, DATA_ATTR_NAME, i]);\n                    const codeLineElt = hljsLnTable.querySelector(codeLineSel);\n                    selectedText += '\\n' + codeLineElt.textContent;\n                }\n                selectedText += '\\n' + lastLineText;\n                return selectedText;\n                // single copied line case\n            } else {\n                return selectionText;\n            }\n        }\n\n        // ensure consistent code copy/paste behavior across all browsers\n        // (see https://github.com/wcoder/highlightjs-line-numbers.js/issues/51)\n        d.addEventListener('copy', function (e) {\n            // get current selection\n            const selection = w.getSelection()!;\n            // override behavior when one wants to copy line of codes\n            if (isHljsLnCodeDescendant(selection.anchorNode)) {\n                let selectionText;\n                // workaround an issue with Microsoft Edge as copied line breaks\n                // are removed otherwise from the selection string\n                if (w.navigator.userAgent.indexOf('Edge') !== -1) {\n                    selectionText = edgeGetSelectedCodeLines(selection);\n                } else {\n                    // other browsers can directly use the selection string\n                    selectionText = selection.toString();\n                }\n                e.clipboardData!.setData('text/plain', selectionText);\n                e.preventDefault();\n            }\n        });\n\n        function addStyles() {\n            const css = d.createElement('style');\n            css.type = 'text/css';\n            css.innerHTML = format(\n                '.{0}{border-collapse:collapse}' + '.{0} td{padding:0}' + '.{1}:before{content:attr({2})}',\n                [\n                    TABLE_NAME,\n                    NUMBER_LINE_NAME,\n                    DATA_ATTR_NAME\n                ]\n            );\n            d.getElementsByTagName('head')[0].appendChild(css);\n        }\n\n        function initLineNumbersOnLoad(options) {\n            if (d.readyState === 'interactive' || d.readyState === 'complete') {\n                documentReady(options);\n            } else {\n                w.addEventListener('DOMContentLoaded', function () {\n                    documentReady(options);\n                });\n            }\n        }\n\n        function documentReady(options) {\n            try {\n                const blocks = d.querySelectorAll('code.hljs,code.nohighlight');\n\n                for (const i in blocks) {\n                    if (blocks.hasOwnProperty(i)) {\n                        if (!isPluginDisabledForBlock(blocks[i])) {\n                            lineNumbersBlock(blocks[i], options);\n                        }\n                    }\n                }\n            } catch (e) {\n                w.console.error('LineNumbers error: ', e);\n            }\n        }\n\n        function isPluginDisabledForBlock(element) {\n            return element.classList.contains('nohljsln');\n        }\n\n        function lineNumbersBlock(element, options) {\n            if (typeof element !== 'object') return;\n\n            async(function () {\n                element.innerHTML = lineNumbersInternal(element, options);\n            });\n        }\n\n        function lineNumbersBlockSync(element, options) {\n            if (typeof element !== 'object') return;\n\n            element.innerHTML = lineNumbersInternal(element, options);\n        }\n\n        function lineNumbersValue(value, options) {\n            if (typeof value !== 'string') return;\n\n            const element = d.createElement('code');\n            element.innerHTML = value;\n\n            return lineNumbersInternal(element, options);\n        }\n\n        function lineNumbersInternal(element, options) {\n            const internalOptions = mapOptions(element, options);\n\n            duplicateMultilineNodes(element);\n\n            return addLineNumbersBlockFor(element.innerHTML, internalOptions);\n        }\n\n        function addLineNumbersBlockFor(inputHtml, options) {\n            const lines = getLines(inputHtml);\n\n            // if last line contains only carriage return remove it\n            if (lines[lines.length - 1].trim() === '') {\n                lines.pop();\n            }\n\n            if (lines.length > 1 || options.singleLine) {\n                let html = '';\n\n                for (let i = 0, l = lines.length; i < l; i++) {\n                    html += format(\n                        '<tr>' +\n                            '<td class=\"{0} {1}\" {3}=\"{5}\">' +\n                            '<div class=\"{2}\" {3}=\"{5}\"></div>' +\n                            '</td>' +\n                            '<td class=\"{0} {4}\" {3}=\"{5}\">' +\n                            '{6}' +\n                            '</td>' +\n                            '</tr>',\n                        [\n                            LINE_NAME,\n                            NUMBERS_BLOCK_NAME,\n                            NUMBER_LINE_NAME,\n                            DATA_ATTR_NAME,\n                            CODE_BLOCK_NAME,\n                            i + options.startFrom,\n                            lines[i].length > 0 ? lines[i] : ' '\n                        ]\n                    );\n                }\n\n                return format('<table class=\"{0}\">{1}</table>', [TABLE_NAME, html]);\n            }\n\n            return inputHtml;\n        }\n\n        /**\n         * @param {HTMLElement} element Code block.\n         * @param {Object} options External API options.\n         * @returns {Object} Internal API options.\n         */\n        function mapOptions(element, options) {\n            options = options || {};\n            return {\n                singleLine: getSingleLineOption(options),\n                startFrom: getStartFromOption(element, options)\n            };\n        }\n\n        function getSingleLineOption(options) {\n            const defaultValue = false;\n            if (options.singleLine) {\n                return options.singleLine;\n            }\n            return defaultValue;\n        }\n\n        function getStartFromOption(element, options) {\n            const defaultValue = 1;\n            let startFrom = defaultValue;\n\n            if (isFinite(options.startFrom)) {\n                startFrom = options.startFrom;\n            }\n\n            // can be overridden because local option is priority\n            const value = getAttribute(element, 'data-ln-start-from');\n            if (value !== null) {\n                startFrom = toNumber(value, defaultValue);\n            }\n\n            return startFrom;\n        }\n\n        /**\n         * Recursive method for fix multi-line elements implementation in highlight.js\n         * Doing deep passage on child nodes.\n         * @param {HTMLElement} element\n         */\n        function duplicateMultilineNodes(element) {\n            const nodes = element.childNodes;\n            for (const node in nodes) {\n                if (nodes.hasOwnProperty(node)) {\n                    const child = nodes[node];\n                    if (getLinesCount(child.textContent) > 0) {\n                        if (child.childNodes.length > 0) {\n                            duplicateMultilineNodes(child);\n                        } else {\n                            duplicateMultilineNode(child.parentNode);\n                        }\n                    }\n                }\n            }\n        }\n\n        /**\n         * Method for fix multi-line elements implementation in highlight.js\n         * @param {HTMLElement} element\n         */\n        function duplicateMultilineNode(element) {\n            const className = element.className;\n\n            if (!/hljs-/.test(className)) return;\n\n            const lines = getLines(element.innerHTML);\n\n            let result = '';\n\n            for (let i = 0; i < lines.length; i++) {\n                const lineText = lines[i].length > 0 ? lines[i] : ' ';\n                result += format('<span class=\"{0}\">{1}</span>\\n', [className, lineText]);\n            }\n\n            element.innerHTML = result.trim();\n        }\n\n        function getLines(text) {\n            if (text.length === 0) return [];\n            return text.split(BREAK_LINE_REGEXP);\n        }\n\n        function getLinesCount(text) {\n            return (text.trim().match(BREAK_LINE_REGEXP) || []).length;\n        }\n\n        ///\n        /// HELPERS\n        ///\n\n        function async(func) {\n            w.setTimeout(func, 0);\n        }\n\n        /**\n         * {@link https://wcoder.github.io/notes/string-format-for-string-formating-in-javascript}\n         * @param {string} format\n         * @param {array} args\n         */\n        function format(format, args) {\n            return format.replace(/\\{(\\d+)\\}/g, function (m, n) {\n                return args[n] !== undefined ? args[n] : m;\n            });\n        }\n\n        /**\n         * @param {HTMLElement} element Code block.\n         * @param {String} attrName Attribute name.\n         * @returns {String} Attribute value or empty.\n         */\n        function getAttribute(element, attrName) {\n            return element.hasAttribute(attrName) ? element.getAttribute(attrName) : null;\n        }\n\n        /**\n         * @param {String} str Source string.\n         * @param {Number} fallback Fallback value.\n         * @returns Parsed number or fallback value.\n         */\n        function toNumber(str, fallback) {\n            if (!str) return fallback;\n            const number = Number(str);\n            return isFinite(number) ? number : fallback;\n        }\n    }\n}\n"]}