chrome-devtools-mcp 0.10.1 → 0.10.2

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/marked/package/src/helpers.js

@@ -0,0 +1,240 @@
+/**
+ * Helpers
+ */
+const escapeTest = /[&<>"']/;
+const escapeReplace = /[&<>"']/g;
+const escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+const escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+const escapeReplacements = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+};
+const getEscapeReplacement = (ch) => escapeReplacements[ch];
+export function escape(html, encode) {
+    if (encode) {
+        if (escapeTest.test(html)) {
+            return html.replace(escapeReplace, getEscapeReplacement);
+        }
+    }
+    else {
+        if (escapeTestNoEncode.test(html)) {
+            return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+        }
+    }
+    return html;
+}
+const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+export function unescape(html) {
+    // explicitly match decimal, hex, and named HTML entities
+    return html.replace(unescapeTest, (_, n) => {
+        n = n.toLowerCase();
+        if (n === 'colon')
+            return ':';
+        if (n.charAt(0) === '#') {
+            return n.charAt(1) === 'x'
+                ? String.fromCharCode(parseInt(n.substring(2), 16))
+                : String.fromCharCode(+n.substring(1));
+        }
+        return '';
+    });
+}
+const caret = /(^|[^\[])\^/g;
+export function edit(regex, opt) {
+    regex = regex.source || regex;
+    opt = opt || '';
+    const obj = {
+        replace: (name, val) => {
+            val = val.source || val;
+            val = val.replace(caret, '$1');
+            regex = regex.replace(name, val);
+            return obj;
+        },
+        getRegex: () => {
+            return new RegExp(regex, opt);
+        }
+    };
+    return obj;
+}
+const nonWordAndColonTest = /[^\w:]/g;
+const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+export function cleanUrl(sanitize, base, href) {
+    if (sanitize) {
+        let prot;
+        try {
+            prot = decodeURIComponent(unescape(href))
+                .replace(nonWordAndColonTest, '')
+                .toLowerCase();
+        }
+        catch (e) {
+            return null;
+        }
+        if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+            return null;
+        }
+    }
+    if (base && !originIndependentUrl.test(href)) {
+        href = resolveUrl(base, href);
+    }
+    try {
+        href = encodeURI(href).replace(/%25/g, '%');
+    }
+    catch (e) {
+        return null;
+    }
+    return href;
+}
+const baseUrls = {};
+const justDomain = /^[^:]+:\/*[^/]*$/;
+const protocol = /^([^:]+:)[\s\S]*$/;
+const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+export function resolveUrl(base, href) {
+    if (!baseUrls[' ' + base]) {
+        // we can ignore everything in base after the last slash of its path component,
+        // but we might need to add _that_
+        // https://tools.ietf.org/html/rfc3986#section-3
+        if (justDomain.test(base)) {
+            baseUrls[' ' + base] = base + '/';
+        }
+        else {
+            baseUrls[' ' + base] = rtrim(base, '/', true);
+        }
+    }
+    base = baseUrls[' ' + base];
+    const relativeBase = base.indexOf(':') === -1;
+    if (href.substring(0, 2) === '//') {
+        if (relativeBase) {
+            return href;
+        }
+        return base.replace(protocol, '$1') + href;
+    }
+    else if (href.charAt(0) === '/') {
+        if (relativeBase) {
+            return href;
+        }
+        return base.replace(domain, '$1') + href;
+    }
+    else {
+        return base + href;
+    }
+}
+export const noopTest = { exec: function noopTest() { } };
+export function merge(obj) {
+    let i = 1, target, key;
+    for (; i < arguments.length; i++) {
+        target = arguments[i];
+        for (key in target) {
+            if (Object.prototype.hasOwnProperty.call(target, key)) {
+                obj[key] = target[key];
+            }
+        }
+    }
+    return obj;
+}
+export function splitCells(tableRow, count) {
+    // ensure that every cell-delimiting pipe has a space
+    // before it to distinguish it from an escaped pipe
+    const row = tableRow.replace(/\|/g, (match, offset, str) => {
+        let escaped = false, curr = offset;
+        while (--curr >= 0 && str[curr] === '\\')
+            escaped = !escaped;
+        if (escaped) {
+            // odd number of slashes means | is escaped
+            // so we leave it alone
+            return '|';
+        }
+        else {
+            // add space before unescaped |
+            return ' |';
+        }
+    }), cells = row.split(/ \|/);
+    let i = 0;
+    // First/last cell in a row cannot be empty if it has no leading/trailing pipe
+    if (!cells[0].trim()) {
+        cells.shift();
+    }
+    if (!cells[cells.length - 1].trim()) {
+        cells.pop();
+    }
+    if (cells.length > count) {
+        cells.splice(count);
+    }
+    else {
+        while (cells.length < count)
+            cells.push('');
+    }
+    for (; i < cells.length; i++) {
+        // leading or trailing whitespace is ignored per the gfm spec
+        cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+    }
+    return cells;
+}
+// Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+// /c*$/ is vulnerable to REDOS.
+// invert: Remove suffix of non-c chars instead. Default falsey.
+export function rtrim(str, c, invert) {
+    const l = str.length;
+    if (l === 0) {
+        return '';
+    }
+    // Length of suffix matching the invert condition.
+    let suffLen = 0;
+    // Step left until we fail to match the invert condition.
+    while (suffLen < l) {
+        const currChar = str.charAt(l - suffLen - 1);
+        if (currChar === c && !invert) {
+            suffLen++;
+        }
+        else if (currChar !== c && invert) {
+            suffLen++;
+        }
+        else {
+            break;
+        }
+    }
+    return str.substr(0, l - suffLen);
+}
+export function findClosingBracket(str, b) {
+    if (str.indexOf(b[1]) === -1) {
+        return -1;
+    }
+    const l = str.length;
+    let level = 0, i = 0;
+    for (; i < l; i++) {
+        if (str[i] === '\\') {
+            i++;
+        }
+        else if (str[i] === b[0]) {
+            level++;
+        }
+        else if (str[i] === b[1]) {
+            level--;
+            if (level < 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export function checkSanitizeDeprecation(opt) {
+    if (opt && opt.sanitize && !opt.silent) {
+        console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
+    }
+}
+// copied from https://stackoverflow.com/a/5450113/806777
+export function repeatString(pattern, count) {
+    if (count < 1) {
+        return '';
+    }
+    let result = '';
+    while (count > 1) {
+        if (count & 1) {
+            result += pattern;
+        }
+        count >>= 1;
+        pattern += pattern;
+    }
+    return result + pattern;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/marked/package/src/marked.js

@@ -0,0 +1,318 @@
+import { changeDefaults, defaults, getDefaults } from './defaults.js';
+import { checkSanitizeDeprecation, escape, merge } from './helpers.js';
+import { Lexer } from './Lexer.js';
+import { Parser } from './Parser.js';
+import { Renderer } from './Renderer.js';
+import { Slugger } from './Slugger.js';
+import { TextRenderer } from './TextRenderer.js';
+import { Tokenizer } from './Tokenizer.js';
+/**
+ * Marked
+ */
+export function marked(src, opt, callback) {
+    // throw error in case of non string input
+    if (typeof src === 'undefined' || src === null) {
+        throw new Error('marked(): input parameter is undefined or null');
+    }
+    if (typeof src !== 'string') {
+        throw new Error('marked(): input parameter is of type '
+            + Object.prototype.toString.call(src) + ', string expected');
+    }
+    if (typeof opt === 'function') {
+        callback = opt;
+        opt = null;
+    }
+    opt = merge({}, marked.defaults, opt || {});
+    checkSanitizeDeprecation(opt);
+    if (callback) {
+        const highlight = opt.highlight;
+        let tokens;
+        try {
+            tokens = Lexer.lex(src, opt);
+        }
+        catch (e) {
+            return callback(e);
+        }
+        const done = function (err) {
+            let out;
+            if (!err) {
+                try {
+                    if (opt.walkTokens) {
+                        marked.walkTokens(tokens, opt.walkTokens);
+                    }
+                    out = Parser.parse(tokens, opt);
+                }
+                catch (e) {
+                    err = e;
+                }
+            }
+            opt.highlight = highlight;
+            return err
+                ? callback(err)
+                : callback(null, out);
+        };
+        if (!highlight || highlight.length < 3) {
+            return done();
+        }
+        delete opt.highlight;
+        if (!tokens.length)
+            return done();
+        let pending = 0;
+        marked.walkTokens(tokens, function (token) {
+            if (token.type === 'code') {
+                pending++;
+                setTimeout(() => {
+                    highlight(token.text, token.lang, function (err, code) {
+                        if (err) {
+                            return done(err);
+                        }
+                        if (code != null && code !== token.text) {
+                            token.text = code;
+                            token.escaped = true;
+                        }
+                        pending--;
+                        if (pending === 0) {
+                            done();
+                        }
+                    });
+                }, 0);
+            }
+        });
+        if (pending === 0) {
+            done();
+        }
+        return;
+    }
+    try {
+        const tokens = Lexer.lex(src, opt);
+        if (opt.walkTokens) {
+            marked.walkTokens(tokens, opt.walkTokens);
+        }
+        return Parser.parse(tokens, opt);
+    }
+    catch (e) {
+        e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+        if (opt.silent) {
+            return '<p>An error occurred:</p><pre>'
+                + escape(e.message + '', true)
+                + '</pre>';
+        }
+        throw e;
+    }
+}
+/**
+ * Options
+ */
+marked.options =
+    marked.setOptions = function (opt) {
+        merge(marked.defaults, opt);
+        changeDefaults(marked.defaults);
+        return marked;
+    };
+marked.getDefaults = getDefaults;
+marked.defaults = defaults;
+/**
+ * Use Extension
+ */
+marked.use = function (...args) {
+    const opts = merge({}, ...args);
+    const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} };
+    let hasExtensions;
+    args.forEach((pack) => {
+        // ==-- Parse "addon" extensions --== //
+        if (pack.extensions) {
+            hasExtensions = true;
+            pack.extensions.forEach((ext) => {
+                if (!ext.name) {
+                    throw new Error('extension name required');
+                }
+                if (ext.renderer) { // Renderer extensions
+                    const prevRenderer = extensions.renderers ? extensions.renderers[ext.name] : null;
+                    if (prevRenderer) {
+                        // Replace extension with func to run new extension but fall back if false
+                        extensions.renderers[ext.name] = function (...args) {
+                            let ret = ext.renderer.apply(this, args);
+                            if (ret === false) {
+                                ret = prevRenderer.apply(this, args);
+                            }
+                            return ret;
+                        };
+                    }
+                    else {
+                        extensions.renderers[ext.name] = ext.renderer;
+                    }
+                }
+                if (ext.tokenizer) { // Tokenizer Extensions
+                    if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
+                        throw new Error("extension level must be 'block' or 'inline'");
+                    }
+                    if (extensions[ext.level]) {
+                        extensions[ext.level].unshift(ext.tokenizer);
+                    }
+                    else {
+                        extensions[ext.level] = [ext.tokenizer];
+                    }
+                    if (ext.start) { // Function to check for start of token
+                        if (ext.level === 'block') {
+                            if (extensions.startBlock) {
+                                extensions.startBlock.push(ext.start);
+                            }
+                            else {
+                                extensions.startBlock = [ext.start];
+                            }
+                        }
+                        else if (ext.level === 'inline') {
+                            if (extensions.startInline) {
+                                extensions.startInline.push(ext.start);
+                            }
+                            else {
+                                extensions.startInline = [ext.start];
+                            }
+                        }
+                    }
+                }
+                if (ext.childTokens) { // Child tokens to be visited by walkTokens
+                    extensions.childTokens[ext.name] = ext.childTokens;
+                }
+            });
+        }
+        // ==-- Parse "overwrite" extensions --== //
+        if (pack.renderer) {
+            const renderer = marked.defaults.renderer || new Renderer();
+            for (const prop in pack.renderer) {
+                const prevRenderer = renderer[prop];
+                // Replace renderer with func to run extension, but fall back if false
+                renderer[prop] = (...args) => {
+                    let ret = pack.renderer[prop].apply(renderer, args);
+                    if (ret === false) {
+                        ret = prevRenderer.apply(renderer, args);
+                    }
+                    return ret;
+                };
+            }
+            opts.renderer = renderer;
+        }
+        if (pack.tokenizer) {
+            const tokenizer = marked.defaults.tokenizer || new Tokenizer();
+            for (const prop in pack.tokenizer) {
+                const prevTokenizer = tokenizer[prop];
+                // Replace tokenizer with func to run extension, but fall back if false
+                tokenizer[prop] = (...args) => {
+                    let ret = pack.tokenizer[prop].apply(tokenizer, args);
+                    if (ret === false) {
+                        ret = prevTokenizer.apply(tokenizer, args);
+                    }
+                    return ret;
+                };
+            }
+            opts.tokenizer = tokenizer;
+        }
+        // ==-- Parse WalkTokens extensions --== //
+        if (pack.walkTokens) {
+            const walkTokens = marked.defaults.walkTokens;
+            opts.walkTokens = function (token) {
+                pack.walkTokens.call(this, token);
+                if (walkTokens) {
+                    walkTokens.call(this, token);
+                }
+            };
+        }
+        if (hasExtensions) {
+            opts.extensions = extensions;
+        }
+        marked.setOptions(opts);
+    });
+};
+/**
+ * Run callback for every token
+ */
+marked.walkTokens = function (tokens, callback) {
+    for (const token of tokens) {
+        callback.call(marked, token);
+        switch (token.type) {
+            case 'table': {
+                for (const cell of token.header) {
+                    marked.walkTokens(cell.tokens, callback);
+                }
+                for (const row of token.rows) {
+                    for (const cell of row) {
+                        marked.walkTokens(cell.tokens, callback);
+                    }
+                }
+                break;
+            }
+            case 'list': {
+                marked.walkTokens(token.items, callback);
+                break;
+            }
+            default: {
+                if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { // Walk any extensions
+                    marked.defaults.extensions.childTokens[token.type].forEach(function (childTokens) {
+                        marked.walkTokens(token[childTokens], callback);
+                    });
+                }
+                else if (token.tokens) {
+                    marked.walkTokens(token.tokens, callback);
+                }
+            }
+        }
+    }
+};
+/**
+ * Parse Inline
+ */
+marked.parseInline = function (src, opt) {
+    // throw error in case of non string input
+    if (typeof src === 'undefined' || src === null) {
+        throw new Error('marked.parseInline(): input parameter is undefined or null');
+    }
+    if (typeof src !== 'string') {
+        throw new Error('marked.parseInline(): input parameter is of type '
+            + Object.prototype.toString.call(src) + ', string expected');
+    }
+    opt = merge({}, marked.defaults, opt || {});
+    checkSanitizeDeprecation(opt);
+    try {
+        const tokens = Lexer.lexInline(src, opt);
+        if (opt.walkTokens) {
+            marked.walkTokens(tokens, opt.walkTokens);
+        }
+        return Parser.parseInline(tokens, opt);
+    }
+    catch (e) {
+        e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+        if (opt.silent) {
+            return '<p>An error occurred:</p><pre>'
+                + escape(e.message + '', true)
+                + '</pre>';
+        }
+        throw e;
+    }
+};
+/**
+ * Expose
+ */
+marked.Parser = Parser;
+marked.parser = Parser.parse;
+marked.Renderer = Renderer;
+marked.TextRenderer = TextRenderer;
+marked.Lexer = Lexer;
+marked.lexer = Lexer.lex;
+marked.Tokenizer = Tokenizer;
+marked.Slugger = Slugger;
+marked.parse = marked;
+export const options = marked.options;
+export const setOptions = marked.setOptions;
+export const use = marked.use;
+export const walkTokens = marked.walkTokens;
+export const parseInline = marked.parseInline;
+export const parse = marked;
+export const parser = Parser.parse;
+export const lexer = Lexer.lex;
+export { defaults, getDefaults } from './defaults.js';
+export { Lexer } from './Lexer.js';
+export { Parser } from './Parser.js';
+export { Tokenizer } from './Tokenizer.js';
+export { Renderer } from './Renderer.js';
+export { TextRenderer } from './TextRenderer.js';
+export { Slugger } from './Slugger.js';