@markuplint/parser-utils 3.5.0 → 3.6.1

package/lib/const.d.ts

@@ -1,4 +1,4 @@
-export declare const MASK_CHAR = "\uE000";
+export declare const MASK_CHAR = '\uE000';
 /**
  * SVG Element list
  *

package/lib/create-token.d.ts

@@ -1,4 +1,9 @@
 import type { MLToken } from '@markuplint/ml-ast';
-export declare function tokenizer(raw: string | null, startLine: number, startCol: number, startOffset: number): MLToken;
+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

@@ -4,7 +4,7 @@ exports.uuid = exports.createTokenFromRawCode = exports.tokenizer = void 0;
 const uuid_1 = require("uuid");
 const get_location_1 = require("./get-location");
 function tokenizer(raw, startLine, startCol, startOffset) {
-    raw = raw || '';
+    raw = raw !== null && raw !== void 0 ? raw : '';
     const endLine = (0, get_location_1.getEndLine)(raw, startLine);
     const endCol = (0, get_location_1.getEndCol)(raw, startCol);
     const endOffset = startOffset + raw.length;
@@ -21,7 +21,7 @@ function tokenizer(raw, startLine, startCol, startOffset) {
 }
 exports.tokenizer = tokenizer;
 function createTokenFromRawCode(raw, startOffset, rawCode) {
-    raw = raw || '';
+    raw = raw !== null && raw !== void 0 ? raw : '';
     const loc = (0, get_location_1.sliceFragment)(rawCode, startOffset, startOffset + raw.length);
     return {
         uuid: uuid(),

package/lib/debugger.js

@@ -54,9 +54,10 @@ attributes) {
 }
 exports.attributesToDebugMaps = attributesToDebugMaps;
 function tokenDebug(n, type = '') {
+    var _a, _b, _c, _d;
     return `[${n.startLine}:${n.startCol}]>[${n.endLine}:${n.endCol}](${n.startOffset},${n.endOffset})${
     // @ts-ignore
-    n.potentialName || n.nodeName || n.name || n.type || type}: ${visibleWhiteSpace(n.raw)}`;
+    (_d = (_c = (_b = (_a = n.potentialName) !== null && _a !== void 0 ? _a : n.nodeName) !== null && _b !== void 0 ? _b : n.name) !== null && _c !== void 0 ? _c : n.type) !== null && _d !== void 0 ? _d : type}: ${visibleWhiteSpace(n.raw)}`;
 }
 function visibleWhiteSpace(chars) {
     return chars.replace(/\n/g, '⏎').replace(/\t/g, '→').replace(/\s/g, '␣');

package/lib/detect-element-type.d.ts

@@ -1,2 +1,6 @@
 import type { ElementType, ParserAuthoredElementNameDistinguishing } from '@markuplint/ml-ast';
-export declare function detectElementType(name: string, option?: ParserAuthoredElementNameDistinguishing, defaultPattern?: ParserAuthoredElementNameDistinguishing): ElementType;
+export declare function detectElementType(
+	name: string,
+	option?: ParserAuthoredElementNameDistinguishing,
+	defaultPattern?: ParserAuthoredElementNameDistinguishing,
+): ElementType;

package/lib/detect-element-type.js

@@ -10,10 +10,10 @@ function detectElementType(name, option, defaultPattern) {
 }
 exports.detectElementType = detectElementType;
 function distinguishAuthoredName(name, pattern, defaultPattern) {
-    if (pattern) {
+    if (pattern != null) {
         return _distinguishAuthoredName(name, pattern);
     }
-    if (defaultPattern) {
+    if (defaultPattern != null) {
         return _distinguishAuthoredName(name, defaultPattern);
     }
     return false;

package/lib/flatten-nodes.js

@@ -8,6 +8,7 @@ const parser_utils_1 = require("@markuplint/parser-utils");
 function flattenNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 nodeTree, rawHtml, createLastText = true) {
+    var _a, _b, _c, _d;
     const nodeOrders = arrayize(nodeTree, rawHtml);
     {
         /**
@@ -26,21 +27,19 @@ nodeTree, rawHtml, createLastText = true) {
             const endTag = node;
             if (endTag.nodeName.toLowerCase() === 'body' && prevToken.type === 'text') {
                 const prevWreckagesText = prevToken;
-                if (prevWreckagesText) {
-                    const wreckages = (0, tag_splitter_1.default)(prevWreckagesText.raw, prevWreckagesText.startLine, prevWreckagesText.startCol);
-                    if (wreckages.length && 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 = (0, parser_utils_1.getEndLine)(raw, startLine);
-                        prevWreckagesText.startCol = startCol;
-                        prevWreckagesText.endCol = (0, parser_utils_1.getEndCol)(raw, startCol);
-                    }
+                const wreckages = (0, tag_splitter_1.default)(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 = (0, parser_utils_1.getEndLine)(raw, startLine);
+                    prevWreckagesText.startCol = startCol;
+                    prevWreckagesText.endCol = (0, parser_utils_1.getEndCol)(raw, startCol);
                 }
             }
         }
@@ -61,7 +60,7 @@ nodeTree, rawHtml, createLastText = true) {
             if (lastNode.type === 'text') {
                 // Correction for Parse5 AST
                 // prev node: ? -> html
-                lastNode.prevNode = lastNode.parentNode && lastNode.parentNode.parentNode;
+                lastNode.prevNode = (_b = (_a = lastNode.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode) !== null && _b !== void 0 ? _b : lastNode.parentNode;
                 if (lastNode.prevNode) {
                     lastNode.prevNode.nextNode = lastNode;
                 }
@@ -82,8 +81,8 @@ nodeTree, rawHtml, createLastText = true) {
                 const lastTextContent = rawHtml.slice(lastOffset);
                 // console.log(`"${lastTextContent}"`);
                 if (lastTextContent) {
-                    const line = lastNode ? lastNode.endLine : 0;
-                    const col = lastNode ? lastNode.endCol : 0;
+                    const line = (_c = lastNode === null || lastNode === void 0 ? void 0 : lastNode.endLine) !== null && _c !== void 0 ? _c : 0;
+                    const col = (_d = lastNode === null || lastNode === void 0 ? void 0 : lastNode.endCol) !== null && _d !== void 0 ? _d : 0;
                     const lastTextNode = {
                         uuid: (0, parser_utils_1.uuid)(),
                         raw: lastTextContent,
@@ -101,11 +100,9 @@ nodeTree, rawHtml, createLastText = true) {
                         isFragment: false,
                         isGhost: false,
                     };
-                    if (lastNode) {
-                        lastNode.nextNode = lastTextNode;
-                        if ((lastNode.type === 'starttag' || lastNode.type === 'endtag') && lastNode.pearNode) {
-                            lastNode.pearNode.nextNode = lastTextNode;
-                        }
+                    lastNode.nextNode = lastTextNode;
+                    if ((lastNode.type === 'starttag' || lastNode.type === 'endtag') && lastNode.pearNode) {
+                        lastNode.pearNode.nextNode = lastTextNode;
                     }
                     nodeOrders.push(lastTextNode);
                 }
@@ -117,15 +114,24 @@ nodeTree, rawHtml, createLastText = true) {
      */
     const result = [];
     nodeOrders.forEach(node => {
-        const prevNode = result[result.length - 1] || null;
-        if (node.type === 'text' && prevNode && prevNode.type === 'text') {
+        var _a, _b;
+        const prevNode = (_a = result[result.length - 1]) !== null && _a !== void 0 ? _a : null;
+        if (node.type === 'text' && (prevNode === null || prevNode === void 0 ? void 0 : 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 && prevNode.parentNode.childNodes) {
-                prevNode.parentNode.childNodes = prevNode.parentNode.childNodes.filter(n => n.uuid !== node.uuid);
+            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 = (_b = prevNode.parentNode.childNodes) === null || _b === void 0 ? void 0 : _b.filter(n => n.uuid !== node.uuid);
             }
             if (node.nextNode) {
                 node.nextNode.prevNode = prevNode;
@@ -190,6 +196,7 @@ nodeTree, rawHtml) {
      * pushing list
      */
     (0, parser_utils_1.walk)(nodeTree, node => {
+        var _a;
         const diff = node.startOffset - currentEndOffset;
         if (diff > 0) {
             const html = rawHtml.slice(currentEndOffset, node.startOffset);
@@ -237,8 +244,7 @@ nodeTree, rawHtml) {
         prevLine = node.endLine;
         prevCol = node.endCol;
         // for ghost nodes
-        node.startOffset = node.startOffset || node.startOffset;
-        node.endOffset = node.endOffset || currentEndOffset;
+        node.endOffset = (_a = node.endOffset) !== null && _a !== void 0 ? _a : currentEndOffset;
         nodeOrders.push(node);
     });
     return nodeOrders.slice();

package/lib/get-location.d.ts

@@ -2,12 +2,16 @@ export declare function getLine(html: string, startOffset: number): number;
 export declare function getCol(html: string, startOffset: number): number;
 export declare function getEndLine(html: string, line: number): number;
 export declare function getEndCol(html: string, col: number): number;
-export declare function sliceFragment(rawHtml: string, start: number, end: number): {
-    startOffset: number;
-    endOffset: number;
-    startLine: number;
-    endLine: number;
-    startCol: number;
-    endCol: number;
-    raw: string;
+export declare function sliceFragment(
+	rawHtml: string,
+	start: number,
+	end: number,
+): {
+	startOffset: number;
+	endOffset: number;
+	startLine: number;
+	endLine: number;
+	startCol: number;
+	endCol: number;
+	raw: string;
 };

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

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

package/lib/get-space-before.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpaceBefore = void 0;
+const create_token_1 = require("./create-token");
+function getSpaceBefore(offset, rawCode) {
+    var _a;
+    const aboveCode = rawCode.slice(0, offset);
+    const aboveAttrMatched = aboveCode.match(/\s+$/m);
+    const aboveAttrChar = (_a = aboveAttrMatched === null || aboveAttrMatched === void 0 ? void 0 : aboveAttrMatched[0]) !== null && _a !== void 0 ? _a : '';
+    const spacesBefore = (0, create_token_1.createTokenFromRawCode)(aboveAttrChar, offset - aboveAttrChar.length, rawCode);
+    return spacesBefore;
+}
+exports.getSpaceBefore = getSpaceBefore;

package/lib/idl-attributes.d.ts

@@ -1,4 +1,4 @@
 export declare function searchIDLAttribute(name: string): {
-    idlPropName: string | undefined;
-    contentAttrName: string | undefined;
+	idlPropName: string | undefined;
+	contentAttrName: string | undefined;
 };

package/lib/idl-attributes.js

@@ -419,12 +419,13 @@ const idlContentMap = {
 };
 const list = Object.entries(idlContentMap);
 function searchIDLAttribute(name) {
+    var _a;
     const camelizedName = camelize(name);
-    const [idlPropName, contentAttrName] = (/^on[a-z]/.test(name) && [name.toLowerCase(), name.toLowerCase()]) ||
-        list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
+    const [idlPropName, contentAttrName] = /^on[a-z]/.test(name)
+        ? [name.toLowerCase(), name.toLowerCase()]
+        : (_a = list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
             contentAttrName.toLowerCase() === name.toLowerCase() ||
-            hyphenize(idlPropName) === name.toLowerCase()) ||
-        [];
+            hyphenize(idlPropName) === name.toLowerCase())) !== null && _a !== void 0 ? _a : [];
     return {
         idlPropName,
         contentAttrName,

package/lib/ignore-block.js

@@ -13,7 +13,7 @@ function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
         const attr = maskText(prepend(tag.start, '(?<=(?:"|\'))'), append(tag.end, '(?=(?:"|\'))'), replaced, (startTag, taggedCode, endTag) => {
             const mask = maskChar.repeat(startTag.length) +
                 taggedCode.replace(/[^\n]/g, maskChar) +
-                maskChar.repeat((endTag || '').length);
+                maskChar.repeat((endTag !== null && endTag !== void 0 ? endTag : '').length);
             return mask;
         });
         replaced = attr.replaced;
@@ -22,7 +22,7 @@ function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
         const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {
             const mask = maskChar.repeat(startTag.length) +
                 taggedCode.replace(/[^\n]/g, maskChar) +
-                maskChar.repeat((endTag || '').length);
+                maskChar.repeat((endTag !== null && endTag !== void 0 ? endTag : '').length);
             const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;
             return taggedMask;
         });
@@ -52,12 +52,12 @@ function maskText(start, end, replaced, masking) {
             index,
             startTag,
             taggedCode,
-            endTag: endTag || null,
+            endTag: endTag !== null && endTag !== void 0 ? endTag : null,
         });
         /**
          * It will not replace line breaks because detects line number.
          */
-        replaced = above + masking(startTag, taggedCode, endTag) + (below || '');
+        replaced = above + masking(startTag, taggedCode, endTag) + (below !== null && below !== void 0 ? below : '');
     }
     return {
         replaced,
@@ -67,7 +67,7 @@ function maskText(start, end, replaced, masking) {
 function restoreNode(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 nodeList, ignoreBlock) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     nodeList = nodeList.slice();
     const { source, stack, maskChar } = ignoreBlock;
     for (const node of nodeList) {
@@ -83,7 +83,7 @@ nodeList, ignoreBlock) {
             for (const tag of stack) {
                 if (node.startOffset <= tag.index && tag.index < node.endOffset) {
                     const start = tag.index - node.startOffset;
-                    const body = tag.startTag + tag.taggedCode + (tag.endTag || '');
+                    const body = tag.startTag + tag.taggedCode + ((_a = tag.endTag) !== null && _a !== void 0 ? _a : '');
                     const above = node.raw.slice(pointer, start);
                     const below = text.slice(above.length + body.length);
                     if (above) {
@@ -101,10 +101,10 @@ nodeList, ignoreBlock) {
                             startCol,
                             endCol,
                         };
-                        if ((_a = node.prevNode) === null || _a === void 0 ? void 0 : _a.nextNode) {
+                        if ((_b = node.prevNode) === null || _b === void 0 ? void 0 : _b.nextNode) {
                             node.prevNode.nextNode = textNode;
                         }
-                        if ((_b = node.nextNode) === null || _b === void 0 ? void 0 : _b.prevNode) {
+                        if ((_c = node.nextNode) === null || _c === void 0 ? void 0 : _c.prevNode) {
                             node.nextNode.prevNode = textNode;
                         }
                         insertList.push(textNode);
@@ -129,10 +129,10 @@ nodeList, ignoreBlock) {
                             startCol,
                             endCol,
                         };
-                        if ((_c = node.prevNode) === null || _c === void 0 ? void 0 : _c.nextNode) {
+                        if ((_d = node.prevNode) === null || _d === void 0 ? void 0 : _d.nextNode) {
                             node.prevNode.nextNode = bodyNode;
                         }
-                        if ((_d = node.nextNode) === null || _d === void 0 ? void 0 : _d.prevNode) {
+                        if ((_e = node.nextNode) === null || _e === void 0 ? void 0 : _e.prevNode) {
                             node.nextNode.prevNode = bodyNode;
                         }
                         insertList.push(bodyNode);

package/lib/index.d.ts

@@ -5,9 +5,11 @@ export * from './decision';
 export * from './detect-element-type';
 export * from './flatten-nodes';
 export * from './get-location';
+export * from './get-space-before';
 export * from './idl-attributes';
 export * from './ignore-block';
 export * from './ignore-front-matter';
+export * from './parse-attr';
 export * from './parser-error';
 export * from './remove-deprecated-node';
 export * from './tag-splitter';

package/lib/index.js

@@ -8,9 +8,11 @@ tslib_1.__exportStar(require("./decision"), exports);
 tslib_1.__exportStar(require("./detect-element-type"), exports);
 tslib_1.__exportStar(require("./flatten-nodes"), exports);
 tslib_1.__exportStar(require("./get-location"), exports);
+tslib_1.__exportStar(require("./get-space-before"), exports);
 tslib_1.__exportStar(require("./idl-attributes"), exports);
 tslib_1.__exportStar(require("./ignore-block"), exports);
 tslib_1.__exportStar(require("./ignore-front-matter"), exports);
+tslib_1.__exportStar(require("./parse-attr"), exports);
 tslib_1.__exportStar(require("./parser-error"), exports);
 tslib_1.__exportStar(require("./remove-deprecated-node"), exports);
 tslib_1.__exportStar(require("./tag-splitter"), exports);

package/lib/parse-attr.d.ts

@@ -0,0 +1,24 @@
+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 {};

package/lib/parse-attr.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = exports.parseAttr = exports.defaultValueDelimiters = void 0;
+const create_token_1 = require("./create-token");
+exports.defaultValueDelimiters = [
+    {
+        start: "'",
+        end: "'",
+    },
+    {
+        start: '"',
+        end: '"',
+    },
+];
+const defaultEqual = '=';
+const spaceRegex = /^\s$/;
+function parseAttr(raw, offset, html, options) {
+    const tokens = tokenize(raw, options);
+    tokens.beforeName;
+    const attrToken = (0, create_token_1.createTokenFromRawCode)(raw, offset, html);
+    const spacesBeforeName = (0, create_token_1.tokenizer)(tokens.beforeName, attrToken.startLine, attrToken.startCol, attrToken.startOffset);
+    const name = (0, create_token_1.tokenizer)(tokens.name, spacesBeforeName.endLine, spacesBeforeName.endCol, spacesBeforeName.endOffset);
+    const spacesBeforeEqual = (0, create_token_1.tokenizer)(tokens.afterName, name.endLine, name.endCol, name.endOffset);
+    const equal = (0, create_token_1.tokenizer)(tokens.equal, spacesBeforeEqual.endLine, spacesBeforeEqual.endCol, spacesBeforeEqual.endOffset);
+    const spacesAfterEqual = (0, create_token_1.tokenizer)(tokens.beforeValue, equal.endLine, equal.endCol, equal.endOffset);
+    const startQuote = (0, create_token_1.tokenizer)(tokens.startQuote, spacesAfterEqual.endLine, spacesAfterEqual.endCol, spacesAfterEqual.endOffset);
+    const value = (0, create_token_1.tokenizer)(tokens.value, startQuote.endLine, startQuote.endCol, startQuote.endOffset);
+    const endQuote = (0, create_token_1.tokenizer)(tokens.endQuote, value.endLine, value.endCol, value.endOffset);
+    const attr = {
+        type: 'html-attr',
+        uuid: (0, create_token_1.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;
+}
+exports.parseAttr = parseAttr;
+function tokenize(raw, options) {
+    var _a, _b, _c;
+    const valueDelimiters = (_a = options === null || options === void 0 ? void 0 : options.valueDelimiters) !== null && _a !== void 0 ? _a : exports.defaultValueDelimiters;
+    const equalDelimiter = (_b = options === null || options === void 0 ? void 0 : options.equal) !== null && _b !== void 0 ? _b : defaultEqual;
+    let state = 'b-name';
+    const charactors = raw.split('');
+    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 = (_c = valueDelimiters.find(d => d.start === charactor)) !== null && _c !== void 0 ? _c : 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,
+    };
+}
+exports.tokenize = tokenize;

package/lib/parser-error.d.ts

@@ -1,13 +1,21 @@
 export declare class ParserError extends Error {
-    readonly col: number;
-    readonly line: number;
-    name: string;
-    readonly nodeName: string | null;
-    readonly raw: string;
-    constructor(message: string, { line, col, raw, nodeName, }: {
-        readonly line?: number;
-        readonly col?: number;
-        readonly raw?: string;
-        readonly nodeName?: string | null;
-    });
+	readonly col: number;
+	readonly line: number;
+	name: string;
+	readonly nodeName: string | null;
+	readonly raw: string;
+	constructor(
+		message: string,
+		{
+			line,
+			col,
+			raw,
+			nodeName,
+		}: {
+			readonly line?: number;
+			readonly col?: number;
+			readonly raw?: string;
+			readonly nodeName?: string | null;
+		},
+	);
 }

package/lib/remove-deprecated-node.js

@@ -34,7 +34,7 @@ nodeOrders) {
         stack[id] = i;
     });
     let r = nodeOrders.length;
-    while (r--) {
+    while (r-- > 0) {
         if (removeIndexes.includes(r)) {
             nodeOrders.splice(r, 1);
         }

package/lib/siblings-correction.js

@@ -11,13 +11,14 @@ exports.siblingsCorrection = void 0;
 function siblingsCorrection(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 nodeList) {
+    var _a, _b;
     for (let i = 0; i < nodeList.length; i++) {
-        const prevNode = nodeList[i - 1] || null;
+        const prevNode = (_a = nodeList[i - 1]) !== null && _a !== void 0 ? _a : null;
         const node = nodeList[i];
         if (!node) {
             continue;
         }
-        const nextNode = nodeList[i + 1] || null;
+        const nextNode = (_b = nodeList[i + 1]) !== null && _b !== void 0 ? _b : null;
         node.prevNode = prevNode;
         node.nextNode = nextNode;
     }

package/lib/tag-splitter.d.ts

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

package/lib/types.d.ts

@@ -1,18 +1,18 @@
 export type Code = {
-    readonly type: string;
-    readonly index: number;
-    readonly startTag: string;
-    readonly taggedCode: string;
-    readonly endTag: string | null;
+	readonly type: string;
+	readonly index: number;
+	readonly startTag: string;
+	readonly taggedCode: string;
+	readonly endTag: string | null;
 };
 export type IgnoreTag = {
-    readonly type: string;
-    readonly start: Readonly<RegExp>;
-    readonly end: Readonly<RegExp>;
+	readonly type: string;
+	readonly start: Readonly<RegExp>;
+	readonly end: Readonly<RegExp>;
 };
 export type IgnoreBlock = {
-    readonly source: string;
-    readonly replaced: string;
-    readonly stack: readonly Code[];
-    readonly maskChar: string;
+	readonly source: string;
+	readonly replaced: string;
+	readonly stack: readonly Code[];
+	readonly maskChar: string;
 };

package/lib/walker.js

@@ -10,7 +10,7 @@ nodeList, walker, depth = 0) {
             if (node.type === 'endtag') {
                 continue;
             }
-            if (node.childNodes && node.childNodes.length) {
+            if (node.childNodes && node.childNodes.length > 0) {
                 walk(node.childNodes, walker, depth + 1);
             }
             if ('pearNode' in node && node.pearNode) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "3.5.0",
+	"version": "3.6.1",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -24,12 +24,12 @@
 	},
 	"dependencies": {
 		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/types": "3.4.0",
+		"@markuplint/types": "3.5.1",
 		"tslib": "^2.4.1",
 		"uuid": "^9.0.0"
 	},
 	"peerDependencies": {
 		"@markuplint/ml-core": "3.x"
 	},
-	"gitHead": "0c47b2c2722f6823a17f36edbab98486275f8ab4"
+	"gitHead": "3cdf5a088b2da03773d5d4461d0e65ec32290a00"
 }