@markuplint/parser-utils 4.0.0-dev.20 → 4.0.0-dev.23

package/lib/parse-attr.js

@@ -1,144 +0,0 @@
-import { createTokenFromRawCode, tokenizer, uuid } from './create-token.js';
-export const defaultValueDelimiters = [
-    {
-        start: "'",
-        end: "'",
-    },
-    {
-        start: '"',
-        end: '"',
-    },
-];
-const defaultEqual = '=';
-const spaceRegex = /^\s$/;
-export function parseAttr(raw, offset, html, options) {
-    const tokens = tokenize(raw, options);
-    tokens.beforeName;
-    const attrToken = createTokenFromRawCode(raw, offset, html);
-    const spacesBeforeName = tokenizer(tokens.beforeName, attrToken.startLine, attrToken.startCol, attrToken.startOffset);
-    const name = tokenizer(tokens.name, spacesBeforeName.endLine, spacesBeforeName.endCol, spacesBeforeName.endOffset);
-    const spacesBeforeEqual = tokenizer(tokens.afterName, name.endLine, name.endCol, name.endOffset);
-    const equal = tokenizer(tokens.equal, spacesBeforeEqual.endLine, spacesBeforeEqual.endCol, spacesBeforeEqual.endOffset);
-    const spacesAfterEqual = tokenizer(tokens.beforeValue, equal.endLine, equal.endCol, equal.endOffset);
-    const startQuote = tokenizer(tokens.startQuote, spacesAfterEqual.endLine, spacesAfterEqual.endCol, spacesAfterEqual.endOffset);
-    const value = tokenizer(tokens.value, startQuote.endLine, startQuote.endCol, startQuote.endOffset);
-    const endQuote = tokenizer(tokens.endQuote, value.endLine, value.endCol, value.endOffset);
-    const attr = {
-        type: 'html-attr',
-        uuid: uuid(),
-        raw: attrToken.raw,
-        startOffset: attrToken.startOffset,
-        endOffset: attrToken.endOffset,
-        startLine: attrToken.startLine,
-        endLine: attrToken.endLine,
-        startCol: attrToken.startCol,
-        endCol: attrToken.endCol,
-        spacesBeforeName,
-        name,
-        spacesBeforeEqual,
-        equal,
-        spacesAfterEqual,
-        startQuote,
-        value,
-        endQuote,
-        isDuplicatable: false,
-        nodeName: name.raw,
-        parentNode: null,
-        nextNode: null,
-        prevNode: null,
-        isFragment: false,
-        isGhost: false,
-    };
-    return attr;
-}
-export function tokenize(raw, options) {
-    const valueDelimiters = options?.valueDelimiters ?? defaultValueDelimiters;
-    const equalDelimiter = options?.equal ?? defaultEqual;
-    let state = 'b-name';
-    const charactors = [...raw];
-    let beforeName = '';
-    let name = '';
-    let afterName = '';
-    let equal = '';
-    let valueDelimiter = null;
-    let beforeValue = '';
-    let startQuote = '';
-    let value = '';
-    let endQuote = '';
-    let afterAttr = '';
-    while (charactors.length > 0) {
-        const charactor = charactors.shift();
-        if (state === 'b-name') {
-            if (spaceRegex.test(charactor)) {
-                beforeName += charactor;
-                continue;
-            }
-            name += charactor;
-            state = 'name';
-            continue;
-        }
-        if (state === 'name') {
-            if (equalDelimiter === charactor) {
-                equal = equalDelimiter;
-                state = 'value-start';
-                continue;
-            }
-            if (spaceRegex.test(charactor)) {
-                afterName += charactor;
-                state = 'a-name';
-                continue;
-            }
-            name += charactor;
-            continue;
-        }
-        if (state === 'a-name') {
-            if (equalDelimiter === charactor) {
-                equal = equalDelimiter;
-                state = 'value-start';
-                continue;
-            }
-            if (spaceRegex.test(charactor)) {
-                afterName += charactor;
-                continue;
-            }
-            break;
-        }
-        if (state === 'value-start') {
-            if (spaceRegex.test(charactor)) {
-                beforeValue += charactor;
-                continue;
-            }
-            valueDelimiter = valueDelimiters.find(d => d.start === charactor) ?? null;
-            if (valueDelimiter) {
-                startQuote += valueDelimiter.start;
-            }
-            else {
-                value += beforeValue + charactor;
-                beforeValue = '';
-            }
-            state = 'value';
-            continue;
-        }
-        if (state !== 'value') {
-            throw new Error('ParseError: unknown parse state in the attribute');
-        }
-        value += charactor;
-    }
-    if (valueDelimiter) {
-        const endQuoteIndex = value.lastIndexOf(valueDelimiter.end);
-        endQuote = value.slice(endQuoteIndex, endQuoteIndex + 1);
-        afterAttr = value.slice(endQuoteIndex + 1);
-        value = value.slice(0, endQuoteIndex);
-    }
-    return {
-        beforeName,
-        name,
-        afterName,
-        equal,
-        beforeValue,
-        startQuote,
-        value,
-        endQuote,
-        afterAttr,
-    };
-}

package/lib/remove-deprecated-node.d.ts

@@ -1,7 +0,0 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-/**
- *
- * @disruptive
- * @param nodeOrders [Disruptive change]
- */
-export declare function removeDeprecatedNode(nodeOrders: MLASTNode[]): void;

package/lib/remove-deprecated-node.js

@@ -1,39 +0,0 @@
-/**
- *
- * @disruptive
- * @param nodeOrders [Disruptive change]
- */
-export function removeDeprecatedNode(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeOrders) {
-    /**
-     * sorting
-     */
-    nodeOrders.sort((a, b) => {
-        if (a.isGhost || b.isGhost) {
-            return 0;
-        }
-        return a.startOffset - b.startOffset;
-    });
-    /**
-     * remove duplicated node
-     */
-    const stack = {};
-    const removeIndexes = [];
-    for (const [i, node] of nodeOrders.entries()) {
-        if (node.isGhost) {
-            continue;
-        }
-        const id = `${node.startLine}:${node.startCol}:${node.endLine}:${node.endCol}`;
-        if (stack[id] != null) {
-            removeIndexes.push(i);
-        }
-        stack[id] = i;
-    }
-    let r = nodeOrders.length;
-    while (r-- > 0) {
-        if (removeIndexes.includes(r)) {
-            nodeOrders.splice(r, 1);
-        }
-    }
-}

package/lib/siblings-correction.d.ts

@@ -1,9 +0,0 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-/**
- * Correct the references to prevNode and nextNode in the order listed.
- *
- * @param nodeList
- * @affects nodeList[].prevNode
- * @affects nodeList[].nextNode
- */
-export declare function siblingsCorrection(nodeList: MLASTNode[]): void;

package/lib/siblings-correction.js

@@ -1,21 +0,0 @@
-/**
- * Correct the references to prevNode and nextNode in the order listed.
- *
- * @param nodeList
- * @affects nodeList[].prevNode
- * @affects nodeList[].nextNode
- */
-export function siblingsCorrection(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList) {
-    for (let i = 0; i < nodeList.length; i++) {
-        const prevNode = nodeList[i - 1] ?? null;
-        const node = nodeList[i];
-        if (!node) {
-            continue;
-        }
-        const nextNode = nodeList[i + 1] ?? null;
-        node.prevNode = prevNode;
-        node.nextNode = nextNode;
-    }
-}

package/lib/tag-parser.d.ts

@@ -1,10 +0,0 @@
-import type { MLASTAttr } from '@markuplint/ml-ast';
-export declare function tagParser(raw: string, startLine: number, startCol: number, startOffset: number, offsetOffset?: number, offsetLine?: number, offsetColumn?: number, spaces?: ReadonlyArray<string>): {
-    beforeOpenTag: string;
-    tagName: string;
-    attrs: MLASTAttr[];
-    afterAttrSpaces: import("@markuplint/ml-ast").MLToken;
-    selfClosingSolidus: import("@markuplint/ml-ast").MLToken;
-    isOpenTag: boolean;
-    leftover: string;
-};

package/lib/tag-parser.js

@@ -1,152 +0,0 @@
-import { attrTokenizer } from './attr-tokenizer.js';
-import { defaultSpaces } from './const.js';
-import { tokenizer } from './create-token.js';
-var TagState;
-(function (TagState) {
-    TagState[TagState["BeforeOpenTag"] = 0] = "BeforeOpenTag";
-    TagState[TagState["FirstCharOfTagName"] = 1] = "FirstCharOfTagName";
-    TagState[TagState["TagName"] = 2] = "TagName";
-    TagState[TagState["Attrs"] = 3] = "Attrs";
-    TagState[TagState["AfterAttrs"] = 4] = "AfterAttrs";
-    TagState[TagState["AfterOpenTag"] = 5] = "AfterOpenTag";
-})(TagState || (TagState = {}));
-export function tagParser(raw, startLine, startCol, startOffset, offsetOffset = 0, offsetLine = 0, offsetColumn = 0, spaces = defaultSpaces) {
-    let offset = startOffset + offsetOffset;
-    let line = startLine + offsetLine;
-    let col = startCol + (startLine === 1 ? offsetColumn : 0);
-    let state = TagState.BeforeOpenTag;
-    let beforeOpenTagChars = '';
-    let tagName = '';
-    let afterAttrsSpaceChars = '';
-    let selfClosingSolidusChar = '';
-    let isOpenTag = true;
-    const attrs = [];
-    const chars = [...raw];
-    while (chars.length > 0) {
-        if (state === TagState.AfterOpenTag) {
-            break;
-        }
-        const char = chars.shift();
-        stateSwitch: switch (state) {
-            case TagState.BeforeOpenTag: {
-                if (char === '<') {
-                    const beforeOpenTag = tokenizer(beforeOpenTagChars, line, col, offset);
-                    line = beforeOpenTag.endLine;
-                    col = beforeOpenTag.endCol;
-                    offset = beforeOpenTag.endOffset;
-                    // Add `<` length
-                    col += 1;
-                    offset += 1;
-                    state = TagState.FirstCharOfTagName;
-                    break;
-                }
-                beforeOpenTagChars += char;
-                break;
-            }
-            case TagState.FirstCharOfTagName: {
-                if (/[a-z]/i.test(char)) {
-                    tagName += char;
-                    state = TagState.TagName;
-                    break;
-                }
-                if (char === '/') {
-                    isOpenTag = false;
-                    break;
-                }
-                chars.unshift(char);
-                state = TagState.AfterOpenTag;
-                break;
-            }
-            case TagState.TagName: {
-                if (spaces.includes(char)) {
-                    chars.unshift(char);
-                    if (!isOpenTag) {
-                        // Add `/` of `</`(close tag) length
-                        offset += 1;
-                        col += 1;
-                    }
-                    offset += tagName.length;
-                    col += tagName.length;
-                    state = TagState.Attrs;
-                    break;
-                }
-                if (char === '/') {
-                    chars.unshift(char);
-                    state = TagState.AfterAttrs;
-                    break;
-                }
-                if (char === '>') {
-                    state = TagState.AfterOpenTag;
-                    break;
-                }
-                tagName += char;
-                break;
-            }
-            case TagState.Attrs: {
-                let leftover = char + chars.join('');
-                while (leftover.trim()) {
-                    if (leftover.trim().startsWith('/') || leftover.trim().startsWith('>')) {
-                        chars.length = 0;
-                        chars.push(...leftover);
-                        state = TagState.AfterAttrs;
-                        break stateSwitch;
-                    }
-                    const attr = attrTokenizer(leftover, line, col, offset);
-                    line = attr.endLine;
-                    col = attr.endCol;
-                    offset = attr.endOffset;
-                    if (leftover === attr.__leftover) {
-                        throw new SyntaxError(`Invalid attribute syntax: ${leftover}`);
-                    }
-                    leftover = attr.__leftover ?? '';
-                    delete attr.__leftover;
-                    attrs.push(attr);
-                }
-                break;
-            }
-            case TagState.AfterAttrs: {
-                if (char === '>') {
-                    state = TagState.AfterOpenTag;
-                    break;
-                }
-                if (spaces.includes(char)) {
-                    afterAttrsSpaceChars += char;
-                    break;
-                }
-                if (char === '/') {
-                    selfClosingSolidusChar = char;
-                    break;
-                }
-                throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
-            }
-        }
-    }
-    const leftover = chars.join('');
-    if ((!leftover && state === TagState.TagName) || tagName === '') {
-        throw new SyntaxError(`Invalid tag syntax: "${raw}"`);
-    }
-    // console.log({
-    // 	state,
-    // 	leftover,
-    // 	afterAttrsSpaceChars,
-    // 	selfClosingSolidusChar,
-    // 	attrs: attrs.map(a => a.raw),
-    // });
-    const afterAttrSpaces = tokenizer(afterAttrsSpaceChars, line, col, offset);
-    line = afterAttrSpaces.endLine;
-    col = afterAttrSpaces.endCol;
-    offset = afterAttrSpaces.endOffset;
-    const selfClosingSolidus = tokenizer(selfClosingSolidusChar, line, col, offset);
-    line = selfClosingSolidus.endLine;
-    col = selfClosingSolidus.endCol;
-    offset = selfClosingSolidus.endOffset;
-    return {
-        beforeOpenTag: beforeOpenTagChars,
-        tagName,
-        attrs,
-        afterAttrSpaces,
-        selfClosingSolidus,
-        isOpenTag,
-        leftover,
-    };
-}

package/lib/tag-splitter.d.ts

@@ -1,7 +0,0 @@
-export interface N {
-    type: 'text' | 'starttag' | 'endtag' | 'comment' | 'boguscomment';
-    raw: string;
-    line: number;
-    col: number;
-}
-export declare function tagSplitter(raw: string, line: number, col: number): N[];

package/lib/tag-splitter.js

@@ -1,96 +0,0 @@
-import { reSplitterTag, reTagName } from './const.js';
-import { getEndCol, getEndLine } from '@markuplint/parser-utils';
-export function tagSplitter(raw, line, col) {
-    return withLocation(tagSplitterAsString(raw), line, col);
-}
-function tagSplitterAsString(raw) {
-    const tagMatches = raw.match(reSplitterTag);
-    if (!tagMatches) {
-        return [raw];
-    }
-    const tokens = [...tagMatches];
-    tokens.unshift(); // remove all match
-    const nodes = [];
-    let rest = raw;
-    for (const token of tokens) {
-        const index = rest.indexOf(token);
-        let length = token.length;
-        if (index > 0) {
-            const text = rest.slice(0, index);
-            nodes.push(text);
-            length += text.length;
-        }
-        nodes.push(token);
-        rest = rest.slice(length);
-    }
-    if (rest) {
-        nodes.push(rest);
-    }
-    return nodes;
-}
-function withLocation(nodes, line, col) {
-    const result = [];
-    for (const node of nodes) {
-        if (node[0] === '<') {
-            const label = node.slice(1).slice(0, -1);
-            if (reTagName.test(label)) {
-                result.push({
-                    type: 'starttag',
-                    raw: node,
-                    line,
-                    col,
-                });
-            }
-            else {
-                switch (label[0]) {
-                    case '/': {
-                        result.push({
-                            type: 'endtag',
-                            raw: node,
-                            line,
-                            col,
-                        });
-                        break;
-                    }
-                    case '!': {
-                        result.push({
-                            type: 'comment',
-                            raw: node,
-                            line,
-                            col,
-                        });
-                        break;
-                    }
-                    case '?': {
-                        result.push({
-                            type: 'boguscomment',
-                            raw: node,
-                            line,
-                            col,
-                        });
-                        break;
-                    }
-                    default: {
-                        result.push({
-                            type: 'text',
-                            raw: node,
-                            line,
-                            col,
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            result.push({
-                type: 'text',
-                raw: node,
-                line,
-                col,
-            });
-        }
-        line = getEndLine(node, line);
-        col = getEndCol(node, col);
-    }
-    return result;
-}

package/lib/walker.d.ts

@@ -1,2 +0,0 @@
-import type { MLASTNode, Walker } from '@markuplint/ml-ast';
-export declare function walk(nodeList: readonly MLASTNode[], walker: Walker, depth?: number): void;

package/lib/walker.js

@@ -1,18 +0,0 @@
-export function walk(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, walker, depth = 0) {
-    for (const node of nodeList) {
-        walker(node, depth);
-        if ('childNodes' in node) {
-            if (node.type === 'endtag') {
-                continue;
-            }
-            if (node.childNodes && node.childNodes.length > 0) {
-                walk(node.childNodes, walker, depth + 1);
-            }
-            if ('pearNode' in node && node.pearNode) {
-                walker(node.pearNode, depth);
-            }
-        }
-    }
-}