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

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

@@ -1,453 +0,0 @@
-import { defaults } from './defaults.js';
-import { Tokenizer } from './Tokenizer.js';
-import { block, inline } from './rules.js';
-import { repeatString } from './helpers.js';
-/**
- * smartypants text replacement
- */
-function smartypants(text) {
-    return text
-        // em-dashes
-        .replace(/---/g, '\u2014')
-        // en-dashes
-        .replace(/--/g, '\u2013')
-        // opening singles
-        .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
-        // closing singles & apostrophes
-        .replace(/'/g, '\u2019')
-        // opening doubles
-        .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
-        // closing doubles
-        .replace(/"/g, '\u201d')
-        // ellipses
-        .replace(/\.{3}/g, '\u2026');
-}
-/**
- * mangle email addresses
- */
-function mangle(text) {
-    let out = '', i, ch;
-    const l = text.length;
-    for (i = 0; i < l; i++) {
-        ch = text.charCodeAt(i);
-        if (Math.random() > 0.5) {
-            ch = 'x' + ch.toString(16);
-        }
-        out += '&#' + ch + ';';
-    }
-    return out;
-}
-/**
- * Block Lexer
- */
-export class Lexer {
-    constructor(options) {
-        this.tokens = [];
-        this.tokens.links = Object.create(null);
-        this.options = options || defaults;
-        this.options.tokenizer = this.options.tokenizer || new Tokenizer();
-        this.tokenizer = this.options.tokenizer;
-        this.tokenizer.options = this.options;
-        this.tokenizer.lexer = this;
-        this.inlineQueue = [];
-        this.state = {
-            inLink: false,
-            inRawBlock: false,
-            top: true
-        };
-        const rules = {
-            block: block.normal,
-            inline: inline.normal
-        };
-        if (this.options.pedantic) {
-            rules.block = block.pedantic;
-            rules.inline = inline.pedantic;
-        }
-        else if (this.options.gfm) {
-            rules.block = block.gfm;
-            if (this.options.breaks) {
-                rules.inline = inline.breaks;
-            }
-            else {
-                rules.inline = inline.gfm;
-            }
-        }
-        this.tokenizer.rules = rules;
-    }
-    /**
-     * Expose Rules
-     */
-    static get rules() {
-        return {
-            block,
-            inline
-        };
-    }
-    /**
-     * Static Lex Method
-     */
-    static lex(src, options) {
-        const lexer = new Lexer(options);
-        return lexer.lex(src);
-    }
-    /**
-     * Static Lex Inline Method
-     */
-    static lexInline(src, options) {
-        const lexer = new Lexer(options);
-        return lexer.inlineTokens(src);
-    }
-    /**
-     * Preprocessing
-     */
-    lex(src) {
-        src = src
-            .replace(/\r\n|\r/g, '\n')
-            .replace(/\t/g, '    ');
-        this.blockTokens(src, this.tokens);
-        let next;
-        while (next = this.inlineQueue.shift()) {
-            this.inlineTokens(next.src, next.tokens);
-        }
-        return this.tokens;
-    }
-    /**
-     * Lexing
-     */
-    blockTokens(src, tokens = []) {
-        if (this.options.pedantic) {
-            src = src.replace(/^ +$/gm, '');
-        }
-        let token, lastToken, cutSrc, lastParagraphClipped;
-        while (src) {
-            if (this.options.extensions
-                && this.options.extensions.block
-                && this.options.extensions.block.some((extTokenizer) => {
-                    if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
-                        src = src.substring(token.raw.length);
-                        tokens.push(token);
-                        return true;
-                    }
-                    return false;
-                })) {
-                continue;
-            }
-            // newline
-            if (token = this.tokenizer.space(src)) {
-                src = src.substring(token.raw.length);
-                if (token.type) {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            // code
-            if (token = this.tokenizer.code(src)) {
-                src = src.substring(token.raw.length);
-                lastToken = tokens[tokens.length - 1];
-                // An indented code block cannot interrupt a paragraph.
-                if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {
-                    lastToken.raw += '\n' + token.raw;
-                    lastToken.text += '\n' + token.text;
-                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            // fences
-            if (token = this.tokenizer.fences(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // heading
-            if (token = this.tokenizer.heading(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // hr
-            if (token = this.tokenizer.hr(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // blockquote
-            if (token = this.tokenizer.blockquote(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // list
-            if (token = this.tokenizer.list(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // html
-            if (token = this.tokenizer.html(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // def
-            if (token = this.tokenizer.def(src)) {
-                src = src.substring(token.raw.length);
-                lastToken = tokens[tokens.length - 1];
-                if (lastToken && (lastToken.type === 'paragraph' || lastToken.type === 'text')) {
-                    lastToken.raw += '\n' + token.raw;
-                    lastToken.text += '\n' + token.raw;
-                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
-                }
-                else if (!this.tokens.links[token.tag]) {
-                    this.tokens.links[token.tag] = {
-                        href: token.href,
-                        title: token.title
-                    };
-                }
-                continue;
-            }
-            // table (gfm)
-            if (token = this.tokenizer.table(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // lheading
-            if (token = this.tokenizer.lheading(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // top-level paragraph
-            // prevent paragraph consuming extensions by clipping 'src' to extension start
-            cutSrc = src;
-            if (this.options.extensions && this.options.extensions.startBlock) {
-                let startIndex = Infinity;
-                const tempSrc = src.slice(1);
-                let tempStart;
-                this.options.extensions.startBlock.forEach(function (getStartIndex) {
-                    tempStart = getStartIndex.call({ lexer: this }, tempSrc);
-                    if (typeof tempStart === 'number' && tempStart >= 0) {
-                        startIndex = Math.min(startIndex, tempStart);
-                    }
-                });
-                if (startIndex < Infinity && startIndex >= 0) {
-                    cutSrc = src.substring(0, startIndex + 1);
-                }
-            }
-            if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
-                lastToken = tokens[tokens.length - 1];
-                if (lastParagraphClipped && lastToken.type === 'paragraph') {
-                    lastToken.raw += '\n' + token.raw;
-                    lastToken.text += '\n' + token.text;
-                    this.inlineQueue.pop();
-                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                lastParagraphClipped = (cutSrc.length !== src.length);
-                src = src.substring(token.raw.length);
-                continue;
-            }
-            // text
-            if (token = this.tokenizer.text(src)) {
-                src = src.substring(token.raw.length);
-                lastToken = tokens[tokens.length - 1];
-                if (lastToken && lastToken.type === 'text') {
-                    lastToken.raw += '\n' + token.raw;
-                    lastToken.text += '\n' + token.text;
-                    this.inlineQueue.pop();
-                    this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            if (src) {
-                const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
-                if (this.options.silent) {
-                    console.error(errMsg);
-                    break;
-                }
-                else {
-                    throw new Error(errMsg);
-                }
-            }
-        }
-        this.state.top = true;
-        return tokens;
-    }
-    inline(src, tokens) {
-        this.inlineQueue.push({ src, tokens });
-    }
-    /**
-     * Lexing/Compiling
-     */
-    inlineTokens(src, tokens = []) {
-        let token, lastToken, cutSrc;
-        // String with links masked to avoid interference with em and strong
-        let maskedSrc = src;
-        let match;
-        let keepPrevChar, prevChar;
-        // Mask out reflinks
-        if (this.tokens.links) {
-            const links = Object.keys(this.tokens.links);
-            if (links.length > 0) {
-                while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
-                    if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
-                        maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
-                    }
-                }
-            }
-        }
-        // Mask out other blocks
-        while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
-            maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
-        }
-        // Mask out escaped em & strong delimiters
-        while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) {
-            maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex);
-        }
-        while (src) {
-            if (!keepPrevChar) {
-                prevChar = '';
-            }
-            keepPrevChar = false;
-            // extensions
-            if (this.options.extensions
-                && this.options.extensions.inline
-                && this.options.extensions.inline.some((extTokenizer) => {
-                    if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
-                        src = src.substring(token.raw.length);
-                        tokens.push(token);
-                        return true;
-                    }
-                    return false;
-                })) {
-                continue;
-            }
-            // escape
-            if (token = this.tokenizer.escape(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // tag
-            if (token = this.tokenizer.tag(src)) {
-                src = src.substring(token.raw.length);
-                lastToken = tokens[tokens.length - 1];
-                if (lastToken && token.type === 'text' && lastToken.type === 'text') {
-                    lastToken.raw += token.raw;
-                    lastToken.text += token.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            // link
-            if (token = this.tokenizer.link(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // reflink, nolink
-            if (token = this.tokenizer.reflink(src, this.tokens.links)) {
-                src = src.substring(token.raw.length);
-                lastToken = tokens[tokens.length - 1];
-                if (lastToken && token.type === 'text' && lastToken.type === 'text') {
-                    lastToken.raw += token.raw;
-                    lastToken.text += token.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            // em & strong
-            if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // code
-            if (token = this.tokenizer.codespan(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // br
-            if (token = this.tokenizer.br(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // del (gfm)
-            if (token = this.tokenizer.del(src)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // autolink
-            if (token = this.tokenizer.autolink(src, mangle)) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // url (gfm)
-            if (!this.state.inLink && (token = this.tokenizer.url(src, mangle))) {
-                src = src.substring(token.raw.length);
-                tokens.push(token);
-                continue;
-            }
-            // text
-            // prevent inlineText consuming extensions by clipping 'src' to extension start
-            cutSrc = src;
-            if (this.options.extensions && this.options.extensions.startInline) {
-                let startIndex = Infinity;
-                const tempSrc = src.slice(1);
-                let tempStart;
-                this.options.extensions.startInline.forEach(function (getStartIndex) {
-                    tempStart = getStartIndex.call({ lexer: this }, tempSrc);
-                    if (typeof tempStart === 'number' && tempStart >= 0) {
-                        startIndex = Math.min(startIndex, tempStart);
-                    }
-                });
-                if (startIndex < Infinity && startIndex >= 0) {
-                    cutSrc = src.substring(0, startIndex + 1);
-                }
-            }
-            if (token = this.tokenizer.inlineText(cutSrc, smartypants)) {
-                src = src.substring(token.raw.length);
-                if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started
-                    prevChar = token.raw.slice(-1);
-                }
-                keepPrevChar = true;
-                lastToken = tokens[tokens.length - 1];
-                if (lastToken && lastToken.type === 'text') {
-                    lastToken.raw += token.raw;
-                    lastToken.text += token.text;
-                }
-                else {
-                    tokens.push(token);
-                }
-                continue;
-            }
-            if (src) {
-                const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
-                if (this.options.silent) {
-                    console.error(errMsg);
-                    break;
-                }
-                else {
-                    throw new Error(errMsg);
-                }
-            }
-        }
-        return tokens;
-    }
-}

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

@@ -1,233 +0,0 @@
-import { defaults } from './defaults.js';
-import { unescape } from './helpers.js';
-import { Renderer } from './Renderer.js';
-import { Slugger } from './Slugger.js';
-import { TextRenderer } from './TextRenderer.js';
-/**
- * Parsing & Compiling
- */
-export class Parser {
-    constructor(options) {
-        this.options = options || defaults;
-        this.options.renderer = this.options.renderer || new Renderer();
-        this.renderer = this.options.renderer;
-        this.renderer.options = this.options;
-        this.textRenderer = new TextRenderer();
-        this.slugger = new Slugger();
-    }
-    /**
-     * Static Parse Method
-     */
-    static parse(tokens, options) {
-        const parser = new Parser(options);
-        return parser.parse(tokens);
-    }
-    /**
-     * Static Parse Inline Method
-     */
-    static parseInline(tokens, options) {
-        const parser = new Parser(options);
-        return parser.parseInline(tokens);
-    }
-    /**
-     * Parse Loop
-     */
-    parse(tokens, top = true) {
-        let out = '', i, j, k, l2, l3, row, cell, header, body, token, ordered, start, loose, itemBody, item, checked, task, checkbox, ret;
-        const l = tokens.length;
-        for (i = 0; i < l; i++) {
-            token = tokens[i];
-            // Run any renderer extensions
-            if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-                ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-                if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
-                    out += ret || '';
-                    continue;
-                }
-            }
-            switch (token.type) {
-                case 'space': {
-                    continue;
-                }
-                case 'hr': {
-                    out += this.renderer.hr();
-                    continue;
-                }
-                case 'heading': {
-                    out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);
-                    continue;
-                }
-                case 'code': {
-                    out += this.renderer.code(token.text, token.lang, token.escaped);
-                    continue;
-                }
-                case 'table': {
-                    header = '';
-                    // header
-                    cell = '';
-                    l2 = token.header.length;
-                    for (j = 0; j < l2; j++) {
-                        cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), { header: true, align: token.align[j] });
-                    }
-                    header += this.renderer.tablerow(cell);
-                    body = '';
-                    l2 = token.rows.length;
-                    for (j = 0; j < l2; j++) {
-                        row = token.rows[j];
-                        cell = '';
-                        l3 = row.length;
-                        for (k = 0; k < l3; k++) {
-                            cell += this.renderer.tablecell(this.parseInline(row[k].tokens), { header: false, align: token.align[k] });
-                        }
-                        body += this.renderer.tablerow(cell);
-                    }
-                    out += this.renderer.table(header, body);
-                    continue;
-                }
-                case 'blockquote': {
-                    body = this.parse(token.tokens);
-                    out += this.renderer.blockquote(body);
-                    continue;
-                }
-                case 'list': {
-                    ordered = token.ordered;
-                    start = token.start;
-                    loose = token.loose;
-                    l2 = token.items.length;
-                    body = '';
-                    for (j = 0; j < l2; j++) {
-                        item = token.items[j];
-                        checked = item.checked;
-                        task = item.task;
-                        itemBody = '';
-                        if (item.task) {
-                            checkbox = this.renderer.checkbox(checked);
-                            if (loose) {
-                                if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
-                                    item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
-                                    if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
-                                        item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
-                                    }
-                                }
-                                else {
-                                    item.tokens.unshift({
-                                        type: 'text',
-                                        text: checkbox
-                                    });
-                                }
-                            }
-                            else {
-                                itemBody += checkbox;
-                            }
-                        }
-                        itemBody += this.parse(item.tokens, loose);
-                        body += this.renderer.listitem(itemBody, task, checked);
-                    }
-                    out += this.renderer.list(body, ordered, start);
-                    continue;
-                }
-                case 'html': {
-                    // TODO parse inline content if parameter markdown=1
-                    out += this.renderer.html(token.text);
-                    continue;
-                }
-                case 'paragraph': {
-                    out += this.renderer.paragraph(this.parseInline(token.tokens));
-                    continue;
-                }
-                case 'text': {
-                    body = token.tokens ? this.parseInline(token.tokens) : token.text;
-                    while (i + 1 < l && tokens[i + 1].type === 'text') {
-                        token = tokens[++i];
-                        body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
-                    }
-                    out += top ? this.renderer.paragraph(body) : body;
-                    continue;
-                }
-                default: {
-                    const errMsg = 'Token with "' + token.type + '" type was not found.';
-                    if (this.options.silent) {
-                        console.error(errMsg);
-                        return;
-                    }
-                    else {
-                        throw new Error(errMsg);
-                    }
-                }
-            }
-        }
-        return out;
-    }
-    /**
-     * Parse Inline Tokens
-     */
-    parseInline(tokens, renderer) {
-        renderer = renderer || this.renderer;
-        let out = '', i, token, ret;
-        const l = tokens.length;
-        for (i = 0; i < l; i++) {
-            token = tokens[i];
-            // Run any renderer extensions
-            if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-                ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-                if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
-                    out += ret || '';
-                    continue;
-                }
-            }
-            switch (token.type) {
-                case 'escape': {
-                    out += renderer.text(token.text);
-                    break;
-                }
-                case 'html': {
-                    out += renderer.html(token.text);
-                    break;
-                }
-                case 'link': {
-                    out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
-                    break;
-                }
-                case 'image': {
-                    out += renderer.image(token.href, token.title, token.text);
-                    break;
-                }
-                case 'strong': {
-                    out += renderer.strong(this.parseInline(token.tokens, renderer));
-                    break;
-                }
-                case 'em': {
-                    out += renderer.em(this.parseInline(token.tokens, renderer));
-                    break;
-                }
-                case 'codespan': {
-                    out += renderer.codespan(token.text);
-                    break;
-                }
-                case 'br': {
-                    out += renderer.br();
-                    break;
-                }
-                case 'del': {
-                    out += renderer.del(this.parseInline(token.tokens, renderer));
-                    break;
-                }
-                case 'text': {
-                    out += renderer.text(token.text);
-                    break;
-                }
-                default: {
-                    const errMsg = 'Token with "' + token.type + '" type was not found.';
-                    if (this.options.silent) {
-                        console.error(errMsg);
-                        return;
-                    }
-                    else {
-                        throw new Error(errMsg);
-                    }
-                }
-            }
-        }
-        return out;
-    }
-}