@mcp-b/chrome-devtools-mcp 1.1.2 → 1.1.3

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

@@ -1,240 +0,0 @@
-/**
- * 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

@@ -1,318 +0,0 @@
-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';