@markuplint/parser-utils 4.0.0-alpha.4 → 4.0.0-alpha.6

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 Yusuke Hirao
+Copyright (c) 2017-2023 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/attr-parser.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,188 @@
+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/attr-tokenizer.d.ts

@@ -0,0 +1,6 @@
+import type { QuoteSet } from './types.js';
+import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
+import { AttrState } from './attr-parser.js';
+export declare function attrTokenizer(raw: string, line: number, col: number, startOffset: number, quoteSet?: ReadonlyArray<QuoteSet>, startState?: AttrState, quoteInValueChars?: ReadonlyArray<QuoteSet>, spaces?: ReadonlyArray<string>): MLASTHTMLAttr & {
+    __leftover?: string;
+};

package/lib/attr-tokenizer.js

@@ -0,0 +1,75 @@
+import { AttrState, attrParser } from './attr-parser.js';
+import { tokenizer, uuid } from './create-token.js';
+export function attrTokenizer(raw, line, col, startOffset, quoteSet, startState = AttrState.BeforeName, quoteInValueChars, spaces) {
+    const parsed = attrParser(raw, quoteSet, startState, quoteInValueChars, spaces);
+    let offset = startOffset;
+    const spacesBeforeName = tokenizer(parsed.spacesBeforeAttrName, line, col, offset);
+    line = spacesBeforeName.endLine;
+    col = spacesBeforeName.endCol;
+    offset = spacesBeforeName.endOffset;
+    const name = tokenizer(parsed.attrName, line, col, offset);
+    line = name.endLine;
+    col = name.endCol;
+    offset = name.endOffset;
+    const spacesBeforeEqual = tokenizer(parsed.spacesBeforeEqual, line, col, offset);
+    line = spacesBeforeEqual.endLine;
+    col = spacesBeforeEqual.endCol;
+    offset = spacesBeforeEqual.endOffset;
+    const equal = tokenizer(parsed.equal, line, col, offset);
+    line = equal.endLine;
+    col = equal.endCol;
+    offset = equal.endOffset;
+    const spacesAfterEqual = tokenizer(parsed.spacesAfterEqual, line, col, offset);
+    line = spacesAfterEqual.endLine;
+    col = spacesAfterEqual.endCol;
+    offset = spacesAfterEqual.endOffset;
+    const startQuote = tokenizer(parsed.quoteStart, line, col, offset);
+    line = startQuote.endLine;
+    col = startQuote.endCol;
+    offset = startQuote.endOffset;
+    const value = tokenizer(parsed.attrValue, line, col, offset);
+    line = value.endLine;
+    col = value.endCol;
+    offset = value.endOffset;
+    const endQuote = tokenizer(parsed.quoteEnd, line, col, offset);
+    const attrToken = tokenizer(parsed.attrName +
+        parsed.spacesBeforeEqual +
+        parsed.equal +
+        parsed.spacesAfterEqual +
+        parsed.quoteStart +
+        parsed.attrValue +
+        parsed.quoteEnd, name.startLine, name.startCol, name.startOffset);
+    const result = {
+        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,
+        prevNode: null,
+        nextNode: null,
+        isFragment: false,
+        isGhost: false,
+    };
+    if (parsed.leftover) {
+        return {
+            ...result,
+            __leftover: parsed.leftover,
+        };
+    }
+    return result;
+}

package/lib/const.d.ts

@@ -5,6 +5,12 @@ export declare const MASK_CHAR = "\uE000";
  * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element
  */
 export declare const svgElementList: string[];
-export declare const reTag: RegExp;
 export declare const reTagName: RegExp;
 export declare const reSplitterTag: RegExp;
+/**
+ * - U+0009 CHARACTER TABULATION (tab) => `\t`
+ * - U+000A LINE FEED (LF) => `\n`
+ * - U+000C FORM FEED (FF) => `\f`
+ * - U+0020 SPACE => ` `
+ */
+export declare const defaultSpaces: readonly ["\t", "\n", "\f", " "];

package/lib/const.js

@@ -94,7 +94,12 @@ export const svgElementList = [
     'tref',
     'vkern',
 ];
-export const reTag = /^<((?:.|\s|\n)+)>\s*$/;
-// eslint-disable-next-line no-control-regex
-export const reTagName = /^[a-z][^\u0000\u0009\u000A\u000C />]*/i;
+export const reTagName = /^[a-z][^\0\t\n\f />]*/i;
 export const reSplitterTag = /<[^>]+>/g;
+/**
+ * - U+0009 CHARACTER TABULATION (tab) => `\t`
+ * - U+000A LINE FEED (LF) => `\n`
+ * - U+000C FORM FEED (FF) => `\f`
+ * - U+0020 SPACE => ` `
+ */
+export const defaultSpaces = ['\t', '\n', '\f', ' '];

package/lib/flatten-nodes.js

@@ -1,7 +1,7 @@
 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 { tagSplitter } from './tag-splitter.js';
 import { walk } from './walker.js';
 export function flattenNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types

package/lib/get-location.js

@@ -1,8 +1,8 @@
 export function getLine(html, startOffset) {
-    return html.slice(0, startOffset).split(/\n/g).length;
+    return html.slice(0, startOffset).split(/\n/).length;
 }
 export function getCol(html, startOffset) {
-    const lines = html.slice(0, startOffset).split(/\n/g);
+    const lines = html.slice(0, startOffset).split(/\n/);
     return (lines.at(-1) ?? '').length + 1;
 }
 export function getEndLine(html, line) {

package/lib/ignore-block.js

@@ -192,14 +192,26 @@ function snap(str, reg) {
     return [index, above, snapPoint, below];
 }
 function removeGlobalOption(reg) {
+    if (typeof reg === 'string') {
+        return new RegExp(escapeRegExpForStr(reg));
+    }
     return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');
 }
 function prepend(reg, str) {
+    if (typeof reg === 'string') {
+        return new RegExp(str + escapeRegExpForStr(reg));
+    }
     return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');
 }
 function append(reg, str) {
+    if (typeof reg === 'string') {
+        return new RegExp(escapeRegExpForStr(reg) + str);
+    }
     return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');
 }
 function hasIgnoreBlock(textContent, maskChar) {
     return textContent.includes(maskChar);
 }
+function escapeRegExpForStr(str) {
+    return str.replaceAll(/[!$()*+./:=?[\\\]^{|}]/g, '\\$&');
+}

package/lib/ignore-front-matter.js

@@ -1,5 +1,5 @@
 export function ignoreFrontMatter(code) {
-    const reStart = /^(?:\s*\r?\n)?---\r?\n/.exec(code);
+    const reStart = /^(?:\s*\n)?---\r?\n/.exec(code);
     if (!reStart) {
         return code;
     }

package/lib/index.d.ts

@@ -1,3 +1,5 @@
+export * from './attr-parser.js';
+export * from './attr-tokenizer.js';
 export * from './const.js';
 export * from './create-token.js';
 export * from './debugger.js';
@@ -12,5 +14,7 @@ export * from './ignore-front-matter.js';
 export * from './parse-attr.js';
 export * from './parser-error.js';
 export * from './remove-deprecated-node.js';
+export * from './script-parser.js';
+export * from './tag-parser.js';
 export * from './tag-splitter.js';
 export * from './walker.js';

package/lib/index.js

@@ -1,3 +1,5 @@
+export * from './attr-parser.js';
+export * from './attr-tokenizer.js';
 export * from './const.js';
 export * from './create-token.js';
 export * from './debugger.js';
@@ -12,5 +14,7 @@ export * from './ignore-front-matter.js';
 export * from './parse-attr.js';
 export * from './parser-error.js';
 export * from './remove-deprecated-node.js';
+export * from './script-parser.js';
+export * from './tag-parser.js';
 export * from './tag-splitter.js';
 export * from './walker.js';

package/lib/script-parser.d.ts

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

package/lib/script-parser.js

@@ -0,0 +1,22 @@
+// @ts-ignore
+import { tokenize } from 'espree';
+export function scriptParser(script) {
+    const tokens = tokenize(script, {
+        ecmaVersion: 'latest',
+        loc: false,
+    });
+    return tokens.map((token) => ({
+        type: token.type,
+        value: token.value,
+    }));
+}
+export function removeQuote(str) {
+    const quote = str[0];
+    if (quote !== '"' && quote !== "'") {
+        return str;
+    }
+    if (str.at(-1) !== quote) {
+        return str;
+    }
+    return str.slice(1, -1);
+}

package/lib/tag-parser.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -4,4 +4,4 @@ export interface N {
     line: number;
     col: number;
 }
-export default function tagSplitter(raw: string, line: number, col: number): N[];
+export declare function tagSplitter(raw: string, line: number, col: number): N[];

package/lib/tag-splitter.js

@@ -1,6 +1,6 @@
 import { reSplitterTag, reTagName } from './const.js';
 import { getEndCol, getEndLine } from '@markuplint/parser-utils';
-export default function tagSplitter(raw, line, col) {
+export function tagSplitter(raw, line, col) {
     return withLocation(tagSplitterAsString(raw), line, col);
 }
 function tagSplitterAsString(raw) {

package/lib/types.d.ts

@@ -7,8 +7,8 @@ export type Code = {
 };
 export type IgnoreTag = {
     readonly type: string;
-    readonly start: Readonly<RegExp>;
-    readonly end: Readonly<RegExp>;
+    readonly start: Readonly<RegExp> | string;
+    readonly end: Readonly<RegExp> | string;
 };
 export type IgnoreBlock = {
     readonly source: string;
@@ -16,3 +16,7 @@ export type IgnoreBlock = {
     readonly stack: readonly Code[];
     readonly maskChar: string;
 };
+export type QuoteSet = {
+    readonly start: string;
+    readonly end: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "4.0.0-alpha.4",
+	"version": "4.0.0-alpha.6",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -24,11 +24,12 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "4.0.0-alpha.4",
-		"@markuplint/types": "4.0.0-alpha.4",
-		"@types/uuid": "^9.0.6",
-		"type-fest": "^4.5.0",
+		"@markuplint/ml-ast": "4.0.0-alpha.6",
+		"@markuplint/types": "4.0.0-alpha.6",
+		"@types/uuid": "^9.0.7",
+		"espree": "^9.6.1",
+		"type-fest": "^4.8.2",
 		"uuid": "^9.0.1"
 	},
-	"gitHead": "991b3aef77fde42c79343ee8c807257a35c589d7"
+	"gitHead": "06e1242d274c72cf08a10a572b06ac35d1b924a4"
 }