@markuplint/parser-utils 4.4.0 → 4.5.0

package/lib/attr-tokenizer.d.ts

@@ -1,11 +1,11 @@
-import type { QuoteSet } from './types.js';
+import type { QuoteSet, ValueType } from './types.js';
 import { AttrState } from './enums.js';
 /**
  * @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 attrTokenizer(raw: string, quoteSet?: readonly QuoteSet[], startState?: AttrState, quoteInValueChars?: ReadonlyArray<QuoteSet>, endOfUnquotedValueChars?: ReadonlyArray<string>): {
+export declare function attrTokenizer(raw: string, quoteSet?: readonly QuoteSet[], startState?: AttrState, noQuoteValueType?: ValueType, endOfUnquotedValueChars?: ReadonlyArray<string>): {
     spacesBeforeAttrName: string;
     attrName: string;
     spacesBeforeEqual: string;

package/lib/attr-tokenizer.js

@@ -1,10 +1,10 @@
 import { defaultSpaces } from './const.js';
 import { AttrState } from './enums.js';
+import { safeScriptParser } from './script-parser.js';
 const defaultQuoteSet = [
-    { start: '"', end: '"' },
-    { start: "'", end: "'" },
+    { start: '"', end: '"', type: 'string' },
+    { start: "'", end: "'", type: 'string' },
 ];
-const defaultQuoteInValueChars = [];
 const spaces = defaultSpaces;
 const EQUAL = '=';
 /**
@@ -12,7 +12,7 @@ const EQUAL = '=';
  * @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 attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = AttrState.BeforeName, quoteInValueChars = defaultQuoteInValueChars, endOfUnquotedValueChars = [...defaultSpaces, '/', '>']) {
+export function attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = AttrState.BeforeName, noQuoteValueType = 'string', endOfUnquotedValueChars = [...defaultSpaces, '/', '>']) {
     let state = startState;
     let spacesBeforeAttrName = '';
     let attrName = '';
@@ -22,9 +22,9 @@ export function attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = Attr
     let quoteTypeIndex = -1;
     let quoteStart = '';
     let attrValue = '';
+    let valueType = noQuoteValueType;
     let quoteEnd = '';
     const isBeforeValueStarted = startState === AttrState.BeforeValue;
-    const quoteModeStack = [];
     const chars = [...raw];
     while (chars.length > 0) {
         if (state === AttrState.AfterValue) {
@@ -104,15 +104,7 @@ export function attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = Attr
                 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);
+                    valueType = quote.type;
                     state = AttrState.Value;
                     break;
                 }
@@ -126,24 +118,16 @@ export function attrTokenizer(raw, quoteSet = defaultQuoteSet, startState = Attr
                     state = AttrState.AfterValue;
                     break;
                 }
-                if (quoteModeStack.length === 0 && char === quoteSet[quoteTypeIndex]?.end) {
+                if (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);
+                if (valueType === 'script') {
+                    const raw = char + chars.join('');
+                    const { validScript } = safeScriptParser(raw);
+                    attrValue += validScript;
+                    chars.splice(0, validScript.length - 1);
                     break;
                 }
                 attrValue += char;

package/lib/parser.d.ts

@@ -1,4 +1,4 @@
-import type { Token, ChildToken, QuoteSet, ParseOptions, ParserOptions, Tokenized } from './types.js';
+import type { Token, ChildToken, QuoteSet, ParseOptions, ParserOptions, Tokenized, ValueType } from './types.js';
 import type { EndTagType, MLASTDocument, MLASTParentNode, MLParser, ParserAuthoredElementNameDistinguishing, MLASTElement, MLASTElementCloseTag, MLASTToken, MLASTNodeTreeItem, MLASTTag, MLASTText, MLASTAttr, MLASTChildNode, MLASTSpreadAttr, ElementType, Walker, MLASTHTMLAttr } from '@markuplint/ml-ast';
 import { AttrState } from './enums.js';
 import { ParserError } from './parser-error.js';
@@ -76,7 +76,7 @@ export declare abstract class Parser<Node extends {} = {}, State extends unknown
     visitSpreadAttr(token: Token): MLASTSpreadAttr | null;
     visitAttr(token: Token, options?: {
         readonly quoteSet?: readonly QuoteSet[];
-        readonly quoteInValueChars?: readonly QuoteSet[];
+        readonly noQuoteValueType?: ValueType;
         readonly endOfUnquotedValueChars?: readonly string[];
         readonly startState?: AttrState;
     }): MLASTAttr & {

package/lib/parser.js

@@ -355,14 +355,14 @@ export class Parser {
         const raw = token.raw;
         const quoteSet = options?.quoteSet;
         const startState = options?.startState ?? AttrState.BeforeName;
-        const quoteInValueChars = options?.quoteInValueChars;
+        const noQuoteValueType = options?.noQuoteValueType;
         const endOfUnquotedValueChars = options?.endOfUnquotedValueChars;
         let startOffset = token.startOffset;
         let startLine = token.startLine;
         let startCol = token.startCol;
         let tokens;
         try {
-            tokens = attrTokenizer(raw, quoteSet, startState, quoteInValueChars, endOfUnquotedValueChars);
+            tokens = attrTokenizer(raw, quoteSet, startState, noQuoteValueType, endOfUnquotedValueChars);
         }
         catch (error) {
             if (error instanceof SyntaxError) {
@@ -781,7 +781,7 @@ _Parser_booleanish = new WeakMap(), _Parser_defaultState = new WeakMap(), _Parse
     for (let node of nodeList) {
         if (node.type === 'endtag') {
             const endTagUUID = node.uuid;
-            const openTag = newNodeList.findLast((n) => n.type === 'starttag' ? n.pairNode?.uuid === endTagUUID : false);
+            const openTag = newNodeList.findLast((n) => n.type === 'starttag' && !n.isGhost ? n.pairNode?.uuid === endTagUUID : false);
             if (!openTag) {
                 node = __classPrivateFieldGet(this, _Parser_instances, "m", _Parser_convertIntoInvalidNode).call(this, node);
             }

package/lib/script-parser.d.ts

@@ -1,4 +1,8 @@
 export declare function scriptParser(script: string): ScriptTokenType[];
+export declare function safeScriptParser(script: string): {
+    validScript: string;
+    leftover: string;
+};
 export type ScriptTokenType = {
     type: 'Identifier' | 'Boolean' | 'Numeric' | 'String' | 'Template' | 'Punctuator';
     value: string;

package/lib/script-parser.js

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { tokenize } from 'espree';
+import { tokenize, parse } from 'espree';
 export function scriptParser(script) {
     const tokens = tokenize(script, {
         ecmaVersion: 'latest',
@@ -10,3 +10,60 @@ export function scriptParser(script) {
         value: token.value,
     }));
 }
+export function safeScriptParser(script) {
+    let { validScript, leftover } = safeParse(script);
+    // Support for object literal
+    if (leftover.trim()) {
+        const assignment = '$=';
+        ({ validScript } = safeParse(`${assignment}${script}`));
+        validScript = validScript.length > assignment.length ? validScript.slice(assignment.length) : '';
+    }
+    // Support for spread operator
+    if (validScript.trim() === '') {
+        const coverStart = '$={';
+        const coverEnd = '}';
+        ({ validScript } = safeParse(`${coverStart}${script}${coverEnd}`));
+        const coverEndLastIndex = validScript.lastIndexOf(coverEnd);
+        validScript =
+            validScript.length > coverStart.length + coverEnd.length
+                ? validScript.slice(coverStart.length, coverEndLastIndex)
+                : '';
+    }
+    leftover = script.slice(validScript.length);
+    return {
+        validScript,
+        leftover,
+    };
+}
+function safeParse(script) {
+    let validScript;
+    let leftover;
+    try {
+        parse(script, {
+            ecmaVersion: 'latest',
+            ecmaFeatures: {
+                jsx: true,
+            },
+        });
+        validScript = script;
+        leftover = '';
+    }
+    catch (error) {
+        if (error instanceof SyntaxError && 'index' in error && typeof error.index === 'number') {
+            let index = error.index;
+            const unexpectedToken = script.slice(index);
+            if (unexpectedToken.trim() === '') {
+                index = script.search(/\S\s*$/);
+            }
+            validScript = script.slice(0, index);
+            leftover = script.slice(index);
+        }
+        else {
+            throw error;
+        }
+    }
+    return {
+        validScript,
+        leftover,
+    };
+}

package/lib/types.d.ts

@@ -53,4 +53,6 @@ export type IgnoreBlock = {
 export type QuoteSet = {
     readonly start: string;
     readonly end: string;
+    readonly type: ValueType;
 };
+export type ValueType = 'string' | 'script';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "4.4.0",
+	"version": "4.5.0",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -28,13 +28,13 @@
 	},
 	"dependencies": {
 		"@markuplint/ml-ast": "4.2.0",
-		"@markuplint/ml-spec": "4.3.0",
-		"@markuplint/types": "4.2.0",
+		"@markuplint/ml-spec": "4.4.0",
+		"@markuplint/types": "4.3.0",
 		"@types/uuid": "9.0.8",
 		"debug": "4.3.4",
 		"espree": "10.0.1",
-		"type-fest": "4.14.0",
+		"type-fest": "4.15.0",
 		"uuid": "9.0.1"
 	},
-	"gitHead": "ad3db077e96bea0666c9105b250f895263907a87"
+	"gitHead": "d5c8786b0dbbd82cdd89018dd57941d62bbe8d06"
 }