@markuplint/parser-utils 4.0.0-dev.0 → 4.0.0-dev.12

package/lib/script-parser.d.ts

@@ -1,4 +1,4 @@
-export declare function scriptParser(script: string): any;
+export declare function scriptParser(script: string): ScriptTokenType[];
 export declare function removeQuote(str: string): string;
 export type ScriptTokenType = {
     type: 'Identifier' | 'Boolean' | 'Numeric' | 'String' | 'Template' | 'Punctuator';

package/lib/script-parser.js

@@ -12,7 +12,7 @@ export function scriptParser(script) {
 }
 export function removeQuote(str) {
     const quote = str[0];
-    if (quote !== '"' && quote !== "'") {
+    if (quote !== '"' && quote !== "'" && quote !== '`') {
         return str;
     }
     if (str.at(-1) !== quote) {

package/lib/sort-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { MLASTNodeTreeItem } from '@markuplint/ml-ast';
+export declare function sortNodes(a: MLASTNodeTreeItem, b: MLASTNodeTreeItem): 0 | 1 | -1;

package/lib/sort-nodes.js

@@ -0,0 +1,18 @@
+export function sortNodes(a, b) {
+    if (a.startOffset === b.startOffset) {
+        return sort(a, b, 'endOffset');
+    }
+    return sort(a, b, 'startOffset');
+}
+function sort(a, b, key) {
+    if (Number.isNaN(a[key]) || Number.isNaN(b[key])) {
+        return 0;
+    }
+    if (a[key] < b[key]) {
+        return -1;
+    }
+    if (a[key] > b[key]) {
+        return 1;
+    }
+    return 0;
+}

package/lib/types.d.ts

@@ -1,9 +1,43 @@
+import type { EndTagType, MLASTParentNode, ParserOptions as ConfigParserOptions } from '@markuplint/ml-ast';
+export type ParserOptions = {
+    readonly booleanish?: boolean;
+    readonly endTagType?: EndTagType;
+    readonly ignoreTags?: readonly IgnoreTag[];
+    readonly maskChar?: string;
+    readonly tagNameCaseSensitive?: boolean;
+    readonly selfCloseType?: SelfCloseType;
+    readonly spaceChars?: readonly string[];
+    readonly rawTextElements?: readonly string[];
+};
+export type ParseOptions = ConfigParserOptions & {
+    readonly offsetOffset?: number;
+    readonly offsetLine?: number;
+    readonly offsetColumn?: number;
+    readonly depth?: number;
+};
+export type Tokenized<N extends {} = {}, State extends unknown = null> = {
+    readonly ast: N[];
+    readonly isFragment: boolean;
+    readonly state?: State;
+};
+export type Token = {
+    readonly raw: string;
+    readonly startOffset: number;
+    readonly startLine: number;
+    readonly startCol: number;
+};
+export type ChildToken = Token & {
+    readonly depth: number;
+    readonly parentNode: MLASTParentNode | null;
+};
+export type SelfCloseType = 'html' | 'xml' | 'html+xml';
 export type Code = {
     readonly type: string;
     readonly index: number;
     readonly startTag: string;
     readonly taggedCode: string;
     readonly endTag: string | null;
+    resolved: boolean;
 };
 export type IgnoreTag = {
     readonly type: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "4.0.0-dev.0+7c596917",
+	"version": "4.0.0-dev.12+2275fbeb0",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -10,6 +10,9 @@
 	"exports": {
 		".": {
 			"import": "./lib/index.js"
+		},
+		"./location": {
+			"import": "./lib/get-location.js"
 		}
 	},
 	"types": "lib/index.d.ts",
@@ -24,12 +27,13 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "4.0.0-dev.0+7c596917",
-		"@markuplint/types": "4.0.0-dev.0+7c596917",
+		"@markuplint/ml-ast": "4.0.0-dev.12+2275fbeb0",
+		"@markuplint/ml-spec": "4.0.0-dev.12+2275fbeb0",
+		"@markuplint/types": "4.0.0-dev.12+2275fbeb0",
 		"@types/uuid": "^9.0.7",
 		"espree": "^9.6.1",
-		"type-fest": "^4.8.2",
+		"type-fest": "^4.9.0",
 		"uuid": "^9.0.1"
 	},
-	"gitHead": "7c59691701465a0fb3a4b69187318e8033c463d4"
+	"gitHead": "2275fbeb053605b636f080f4fafd7cd4fc57a9a3"
 }

package/lib/attr-parser.d.ts

@@ -1,25 +0,0 @@
-import type { QuoteSet } from './types.js';
-export declare enum AttrState {
-    BeforeName = 0,
-    Name = 1,
-    Equal = 2,
-    BeforeValue = 3,
-    Value = 4,
-    AfterValue = 5
-}
-/**
- * @see https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
- * @see https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state
- * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state
- */
-export declare function attrParser(raw: string, quoteSet?: readonly QuoteSet[], startState?: AttrState, quoteInValueChars?: ReadonlyArray<QuoteSet>, spaces?: ReadonlyArray<string>): {
-    spacesBeforeAttrName: string;
-    attrName: string;
-    spacesBeforeEqual: string;
-    equal: string;
-    spacesAfterEqual: string;
-    quoteStart: string;
-    attrValue: string;
-    quoteEnd: string;
-    leftover: string;
-};

package/lib/attr-parser.js

@@ -1,188 +0,0 @@
-import { defaultSpaces } from './const.js';
-const defaultQuoteSet = [
-    { start: '"', end: '"' },
-    { start: "'", end: "'" },
-];
-const defaultQuoteInValueChars = [];
-const EQUAL = '=';
-export var AttrState;
-(function (AttrState) {
-    AttrState[AttrState["BeforeName"] = 0] = "BeforeName";
-    AttrState[AttrState["Name"] = 1] = "Name";
-    AttrState[AttrState["Equal"] = 2] = "Equal";
-    AttrState[AttrState["BeforeValue"] = 3] = "BeforeValue";
-    AttrState[AttrState["Value"] = 4] = "Value";
-    AttrState[AttrState["AfterValue"] = 5] = "AfterValue";
-})(AttrState || (AttrState = {}));
-/**
- * @see https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
- * @see https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state
- * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state
- */
-export function attrParser(raw, quoteSet = defaultQuoteSet, startState = AttrState.BeforeName, quoteInValueChars = defaultQuoteInValueChars, spaces = defaultSpaces) {
-    let state = startState;
-    let spacesBeforeAttrName = '';
-    let attrName = '';
-    let spacesBeforeEqual = '';
-    let equal = '';
-    let spacesAfterEqual = '';
-    let quoteTypeIndex = -1;
-    let quoteStart = '';
-    let attrValue = '';
-    let quoteEnd = '';
-    const quoteModeStack = [];
-    const chars = [...raw];
-    while (chars.length > 0) {
-        if (state === AttrState.AfterValue) {
-            break;
-        }
-        const char = chars.shift();
-        switch (state) {
-            case AttrState.BeforeName: {
-                if (char === '>') {
-                    chars.unshift(char);
-                    state = AttrState.AfterValue;
-                    break;
-                }
-                if (char === '/') {
-                    chars.unshift(char);
-                    state = AttrState.AfterValue;
-                    break;
-                }
-                if (spaces.includes(char)) {
-                    spacesBeforeAttrName += char;
-                    break;
-                }
-                attrName += char;
-                state = AttrState.Name;
-                break;
-            }
-            case AttrState.Name: {
-                if (char === '>') {
-                    chars.unshift(char);
-                    state = AttrState.AfterValue;
-                    break;
-                }
-                if (char === '/') {
-                    chars.unshift(char);
-                    state = AttrState.AfterValue;
-                    break;
-                }
-                if (spaces.includes(char)) {
-                    spacesBeforeEqual += char;
-                    state = AttrState.Equal;
-                    break;
-                }
-                if (char === EQUAL) {
-                    equal += char;
-                    state = AttrState.BeforeValue;
-                    break;
-                }
-                attrName += char;
-                break;
-            }
-            case AttrState.Equal: {
-                if (spaces.includes(char)) {
-                    spacesBeforeEqual += char;
-                    break;
-                }
-                if (char === EQUAL) {
-                    equal += char;
-                    state = AttrState.BeforeValue;
-                    break;
-                }
-                // End of attribute
-                chars.unshift(spacesBeforeEqual, char);
-                spacesBeforeEqual = '';
-                state = AttrState.AfterValue;
-                break;
-            }
-            case AttrState.BeforeValue: {
-                if (spaces.includes(char)) {
-                    spacesAfterEqual += char;
-                    break;
-                }
-                quoteTypeIndex = quoteSet.findIndex(quote => quote.start === char);
-                const quote = quoteSet[quoteTypeIndex];
-                if (quote) {
-                    quoteStart = quote.start;
-                    state = AttrState.Value;
-                    break;
-                }
-                const raw = char + chars.join('');
-                const inQuote = quoteInValueChars.find(quote => raw.startsWith(quote.start));
-                if (inQuote) {
-                    quoteModeStack.push(inQuote);
-                    attrValue += inQuote.start;
-                    chars.splice(0, inQuote.start.length - 1);
-                    state = AttrState.Value;
-                    break;
-                }
-                chars.unshift(char);
-                state = AttrState.Value;
-                break;
-            }
-            case AttrState.Value: {
-                // console.log(
-                // 	char,
-                // 	quoteSet[quoteTypeIndex]?.end,
-                // 	quoteModeStack.map(q => `${q.start}${q.end}`),
-                // );
-                if (!quoteSet[quoteTypeIndex]) {
-                    if (spaces.includes(char)) {
-                        chars.unshift(char);
-                        state = AttrState.AfterValue;
-                        break;
-                    }
-                    if (char === '/') {
-                        chars.unshift(char);
-                        state = AttrState.AfterValue;
-                        break;
-                    }
-                    if (char === '>') {
-                        chars.unshift(char);
-                        state = AttrState.AfterValue;
-                        break;
-                    }
-                }
-                if (quoteModeStack.length === 0 && char === quoteSet[quoteTypeIndex]?.end) {
-                    quoteEnd = char;
-                    state = AttrState.AfterValue;
-                    break;
-                }
-                const raw = char + chars.join('');
-                const inQuoteEnd = quoteModeStack.at(-1);
-                if (inQuoteEnd && raw.startsWith(inQuoteEnd.end)) {
-                    quoteModeStack.pop();
-                    attrValue += inQuoteEnd.end;
-                    chars.splice(0, inQuoteEnd.end.length - 1);
-                    break;
-                }
-                const inQuoteStart = quoteInValueChars.find(quote => raw.startsWith(quote.start));
-                if (inQuoteStart) {
-                    quoteModeStack.push(inQuoteStart);
-                    attrValue += inQuoteStart.start;
-                    chars.splice(0, inQuoteStart.start.length - 1);
-                    break;
-                }
-                attrValue += char;
-                break;
-            }
-        }
-    }
-    if (state === AttrState.Value && quoteTypeIndex !== -1) {
-        throw new SyntaxError(`Unclosed attribute value: ${raw}`);
-    }
-    const leftover = chars.join('');
-    return {
-        spacesBeforeAttrName,
-        attrName,
-        spacesBeforeEqual,
-        equal,
-        spacesAfterEqual,
-        quoteStart,
-        attrValue,
-        quoteEnd,
-        leftover,
-    };
-}

package/lib/create-token.d.ts

@@ -1,4 +0,0 @@
-import type { MLToken } from '@markuplint/ml-ast';
-export declare function tokenizer(raw: string | null, startLine: number, startCol: number, startOffset: number): MLToken;
-export declare function createTokenFromRawCode(raw: string | null, startOffset: number, rawCode: string): MLToken;
-export declare function uuid(): string;

package/lib/create-token.js

@@ -1,29 +0,0 @@
-import { v4 as uuid4 } from 'uuid';
-import { getEndCol, getEndLine, sliceFragment } from './get-location.js';
-export function tokenizer(raw, startLine, startCol, startOffset) {
-    raw = raw ?? '';
-    const endLine = getEndLine(raw, startLine);
-    const endCol = getEndCol(raw, startCol);
-    const endOffset = startOffset + raw.length;
-    return {
-        uuid: uuid(),
-        raw,
-        startOffset,
-        endOffset,
-        startLine,
-        endLine,
-        startCol,
-        endCol,
-    };
-}
-export function createTokenFromRawCode(raw, startOffset, rawCode) {
-    raw = raw ?? '';
-    const loc = sliceFragment(rawCode, startOffset, startOffset + raw.length);
-    return {
-        uuid: uuid(),
-        ...loc,
-    };
-}
-export function uuid() {
-    return uuid4();
-}

package/lib/flatten-nodes.d.ts

@@ -1,2 +0,0 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function flattenNodes(nodeTree: MLASTNode[], rawHtml: string, createLastText?: boolean): MLASTNode[];

package/lib/flatten-nodes.js

@@ -1,247 +0,0 @@
-import { uuid } from './create-token.js';
-import { getEndCol, getEndLine } from './get-location.js';
-import { removeDeprecatedNode } from './remove-deprecated-node.js';
-import { tagSplitter } from './tag-splitter.js';
-import { walk } from './walker.js';
-export function flattenNodes(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeTree, rawHtml, createLastText = true) {
-    const nodeOrders = arrayize(nodeTree, rawHtml);
-    {
-        /**
-         * Correction prev/next/parent
-         */
-        let prevToken = null;
-        for (const node of nodeOrders) {
-            if (!prevToken) {
-                prevToken = node;
-                continue;
-            }
-            if (node.type !== 'endtag') {
-                prevToken = node;
-                continue;
-            }
-            const endTag = node;
-            if (endTag.nodeName.toLowerCase() === 'body' && prevToken.type === 'text') {
-                const prevWreckagesText = prevToken;
-                const wreckages = tagSplitter(prevWreckagesText.raw, prevWreckagesText.startLine, prevWreckagesText.startCol);
-                if (wreckages.length > 0 && wreckages[0]) {
-                    // console.log('wreckages\n', wreckages);
-                    const lastText = wreckages[0];
-                    const raw = lastText.raw;
-                    const startLine = lastText.line;
-                    const startCol = lastText.col;
-                    prevWreckagesText.raw = raw;
-                    prevWreckagesText.endOffset = prevWreckagesText.startOffset + raw.length;
-                    prevWreckagesText.startLine = startLine;
-                    prevWreckagesText.endLine = getEndLine(raw, startLine);
-                    prevWreckagesText.startCol = startCol;
-                    prevWreckagesText.endCol = getEndCol(raw, startCol);
-                }
-            }
-        }
-    }
-    removeDeprecatedNode(nodeOrders);
-    {
-        /**
-         * getting last node
-         */
-        let lastNode = null;
-        for (const node of nodeOrders) {
-            if (node.isGhost) {
-                continue;
-            }
-            lastNode = node;
-        }
-        if (lastNode) {
-            if (lastNode.type === 'text') {
-                // Correction for Parse5 AST
-                // prev node: ? -> html
-                lastNode.prevNode = lastNode.parentNode?.parentNode ?? lastNode.parentNode;
-                if (lastNode.prevNode) {
-                    lastNode.prevNode.nextNode = lastNode;
-                }
-                // parent node: body -> null
-                lastNode.parentNode = null;
-                // next node: ? -> null
-                lastNode.nextNode = null;
-            }
-            else if (createLastText) {
-                /**
-                 * create Last spaces
-                 */
-                let lastOffset = 0;
-                for (const node of nodeOrders) {
-                    lastOffset = Math.max(node.endOffset, lastOffset);
-                }
-                // console.log(lastOffset);
-                const lastTextContent = rawHtml.slice(lastOffset);
-                // console.log(`"${lastTextContent}"`);
-                if (lastTextContent) {
-                    const line = lastNode?.endLine ?? 0;
-                    const col = lastNode?.endCol ?? 0;
-                    const lastTextNode = {
-                        uuid: uuid(),
-                        raw: lastTextContent,
-                        startOffset: lastOffset,
-                        endOffset: lastOffset + lastTextContent.length,
-                        startLine: line,
-                        endLine: getEndLine(lastTextContent, line),
-                        startCol: col,
-                        endCol: getEndCol(lastTextContent, col),
-                        nodeName: '#text',
-                        type: 'text',
-                        parentNode: null,
-                        prevNode: lastNode,
-                        nextNode: null,
-                        isFragment: false,
-                        isGhost: false,
-                    };
-                    lastNode.nextNode = lastTextNode;
-                    if ((lastNode.type === 'starttag' || lastNode.type === 'endtag') && lastNode.pearNode) {
-                        lastNode.pearNode.nextNode = lastTextNode;
-                    }
-                    nodeOrders.push(lastTextNode);
-                }
-            }
-        }
-    }
-    /**
-     * concat text nodes
-     */
-    const result = [];
-    for (const node of nodeOrders) {
-        const prevNode = result.at(-1) ?? null;
-        if (node.type === 'text' && prevNode?.type === 'text') {
-            prevNode.raw = prevNode.raw + node.raw;
-            prevNode.endOffset = node.endOffset;
-            prevNode.endLine = node.endLine;
-            prevNode.endCol = node.endCol;
-            prevNode.nextNode = node.nextNode;
-            if (prevNode.parentNode) {
-                if (prevNode.parentNode.childNodes) {
-                    if (prevNode.parentNode.childNodes.findIndex(currentChild => currentChild.uuid === prevNode.uuid) === -1) {
-                        prevNode.parentNode.childNodes.unshift(prevNode);
-                    }
-                    else {
-                        prevNode.parentNode.childNodes = [prevNode];
-                    }
-                }
-                prevNode.parentNode.childNodes = prevNode.parentNode.childNodes?.filter(n => n.uuid !== node.uuid);
-            }
-            if (node.nextNode) {
-                node.nextNode.prevNode = prevNode;
-            }
-            continue;
-        }
-        result.push(node);
-    }
-    {
-        /**
-         * Correction prev/next/parent
-         */
-        let prevToken = null;
-        for (const node of result) {
-            if (!prevToken) {
-                prevToken = node;
-                continue;
-            }
-            if (((prevToken.type === 'endtag' && prevToken.nodeName.toLowerCase() === 'body') ||
-                prevToken.type === 'doctype') &&
-                node.type === 'text') {
-                const nextNode = prevToken.nextNode;
-                prevToken.nextNode = node;
-                if (prevToken.type === 'endtag' && prevToken.pearNode) {
-                    prevToken.pearNode.nextNode = node;
-                }
-                node.prevNode = prevToken;
-                node.nextNode = nextNode;
-                node.parentNode = prevToken.parentNode;
-            }
-            // EndTag
-            if (node.type === 'starttag' && node.pearNode) {
-                const endTag = node.pearNode;
-                endTag.pearNode = node;
-                endTag.prevNode = node.prevNode;
-                endTag.nextNode = node.nextNode;
-            }
-            // Children
-            if (node.type === 'text') {
-                const parent = node.parentNode;
-                if (parent &&
-                    parent.type === 'starttag' &&
-                    parent.nodeName.toLowerCase() === 'html' &&
-                    parent.childNodes &&
-                    !parent.childNodes.some(n => n.uuid === node.uuid)) {
-                    parent.childNodes.push(node);
-                }
-            }
-            prevToken = node;
-        }
-    }
-    // console.log(nodeOrders.map((n, i) => `${i}: ${n.raw.trim()}`));
-    return result;
-}
-function arrayize(
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeTree, rawHtml) {
-    const nodeOrders = [];
-    let prevLine = 1;
-    let prevCol = 1;
-    let currentEndOffset = 0;
-    /**
-     * pushing list
-     */
-    walk(nodeTree, node => {
-        const diff = node.startOffset - currentEndOffset;
-        if (diff > 0) {
-            const html = rawHtml.slice(currentEndOffset, node.startOffset);
-            /**
-             * first white spaces
-             */
-            if (/^\s+$/.test(html)) {
-                const spaces = html;
-                const textNode = {
-                    uuid: uuid(),
-                    raw: spaces,
-                    startOffset: currentEndOffset,
-                    endOffset: currentEndOffset + spaces.length,
-                    startLine: prevLine,
-                    endLine: getEndLine(spaces, prevLine),
-                    startCol: prevCol,
-                    endCol: getEndCol(spaces, prevCol),
-                    nodeName: '#text',
-                    type: 'text',
-                    parentNode: node.parentNode,
-                    prevNode: node.prevNode,
-                    nextNode: node,
-                    isFragment: false,
-                    isGhost: false,
-                };
-                node.prevNode = textNode;
-                if (node.parentNode && node.parentNode.childNodes) {
-                    const newChildNodes = [...node.parentNode.childNodes];
-                    if (newChildNodes.some(child => {
-                        return (
-                        // Out of start offset
-                        textNode.endOffset < child.startOffset ||
-                            // Out of end offset
-                            child.endOffset < textNode.startOffset);
-                    })) {
-                        newChildNodes.push(textNode);
-                    }
-                    newChildNodes.sort((a, b) => a.startOffset - b.startOffset);
-                    node.parentNode.childNodes = newChildNodes;
-                }
-                nodeOrders.push(textNode);
-            }
-        }
-        currentEndOffset = node.startOffset + node.raw.length;
-        prevLine = node.endLine;
-        prevCol = node.endCol;
-        // for ghost nodes
-        node.endOffset = node.endOffset ?? currentEndOffset;
-        nodeOrders.push(node);
-    });
-    return [...nodeOrders];
-}

package/lib/get-space-before.d.ts

@@ -1 +0,0 @@
-export declare function getSpaceBefore(offset: number, rawCode: string): import("packages/@markuplint/ml-ast/lib/types.js").MLToken;

package/lib/get-space-before.js

@@ -1,8 +0,0 @@
-import { createTokenFromRawCode } from './create-token.js';
-export function getSpaceBefore(offset, rawCode) {
-    const aboveCode = rawCode.slice(0, offset);
-    const aboveAttrMatched = aboveCode.match(/\s+$/m);
-    const aboveAttrChar = aboveAttrMatched?.[0] ?? '';
-    const spacesBefore = createTokenFromRawCode(aboveAttrChar, offset - aboveAttrChar.length, rawCode);
-    return spacesBefore;
-}

package/lib/parse-attr.d.ts

@@ -1,24 +0,0 @@
-import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
-type ParseAttrOptions = {
-    readonly booleanish?: boolean;
-    readonly valueDelimiters?: readonly ValueDelimiter[];
-    readonly equal?: string;
-};
-type ValueDelimiter = {
-    readonly start: string;
-    readonly end: string;
-};
-export declare const defaultValueDelimiters: readonly ValueDelimiter[];
-export declare function parseAttr(raw: string, offset: number, html: string, options?: ParseAttrOptions): MLASTHTMLAttr;
-export declare function tokenize(raw: string, options?: ParseAttrOptions): {
-    beforeName: string;
-    name: string;
-    afterName: string;
-    equal: string;
-    beforeValue: string;
-    startQuote: string;
-    value: string;
-    endQuote: string;
-    afterAttr: string;
-};
-export {};