@markuplint/parser-utils 3.0.0-dev.24 → 3.0.0-dev.290

package/lib/ignore-block.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreNode = exports.ignoreBlock = void 0;
-const const_1 = require("./const");
-const create_token_1 = require("./create-token");
-const get_location_1 = require("./get-location");
-const siblings_correction_1 = require("./siblings-correction");
-function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
+import { MASK_CHAR } from './const.js';
+import { uuid } from './create-token.js';
+import { sliceFragment } from './get-location.js';
+import { siblingsCorrection } from './siblings-correction.js';
+export function ignoreBlock(source, tags, maskChar = MASK_CHAR) {
     let replaced = source;
     const stack = [];
     for (const tag of tags) {
@@ -13,7 +10,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 ?? '').length);
             return mask;
         });
         replaced = attr.replaced;
@@ -22,7 +19,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 ?? '').length);
             const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;
             return taggedMask;
         });
@@ -37,7 +34,6 @@ function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
         maskChar,
     };
 }
-exports.ignoreBlock = ignoreBlock;
 function maskText(start, end, replaced, masking) {
     const stack = [];
     start = removeGlobalOption(start);
@@ -52,20 +48,21 @@ function maskText(start, end, replaced, masking) {
             index,
             startTag,
             taggedCode,
-            endTag: endTag || null,
+            endTag: 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 ?? '');
     }
     return {
         replaced,
         stack,
     };
 }
-function restoreNode(nodeList, ignoreBlock) {
-    var _a, _b, _c, _d;
+export function restoreNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, ignoreBlock) {
     nodeList = nodeList.slice();
     const { source, stack, maskChar } = ignoreBlock;
     for (const node of nodeList) {
@@ -81,15 +78,15 @@ function restoreNode(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 + (tag.endTag ?? '');
                     const above = node.raw.slice(pointer, start);
                     const below = text.slice(above.length + body.length);
                     if (above) {
                         const offset = node.startOffset + pointer;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + above.length);
+                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + above.length);
                         const textNode = {
                             ...node,
-                            uuid: (0, create_token_1.uuid)(),
+                            uuid: uuid(),
                             type: 'text',
                             raw,
                             startOffset,
@@ -99,19 +96,19 @@ function restoreNode(nodeList, ignoreBlock) {
                             startCol,
                             endCol,
                         };
-                        if ((_a = node.prevNode) === null || _a === void 0 ? void 0 : _a.nextNode) {
+                        if (node.prevNode?.nextNode) {
                             node.prevNode.nextNode = textNode;
                         }
-                        if ((_b = node.nextNode) === null || _b === void 0 ? void 0 : _b.prevNode) {
+                        if (node.nextNode?.prevNode) {
                             node.nextNode.prevNode = textNode;
                         }
                         insertList.push(textNode);
                     }
                     if (body) {
                         const offset = node.startOffset + pointer + above.length;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + body.length);
+                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + body.length);
                         const bodyNode = {
-                            uuid: (0, create_token_1.uuid)(),
+                            uuid: uuid(),
                             type: 'psblock',
                             nodeName: `#ps:${tag.type}`,
                             raw,
@@ -127,10 +124,10 @@ function restoreNode(nodeList, ignoreBlock) {
                             startCol,
                             endCol,
                         };
-                        if ((_c = node.prevNode) === null || _c === void 0 ? void 0 : _c.nextNode) {
+                        if (node.prevNode?.nextNode) {
                             node.prevNode.nextNode = bodyNode;
                         }
-                        if ((_d = node.nextNode) === null || _d === void 0 ? void 0 : _d.prevNode) {
+                        if (node.nextNode?.prevNode) {
                             node.nextNode.prevNode = bodyNode;
                         }
                         insertList.push(bodyNode);
@@ -141,10 +138,10 @@ function restoreNode(nodeList, ignoreBlock) {
             }
             if (text) {
                 const offset = node.endOffset - text.length;
-                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + text.length);
+                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(source, offset, offset + text.length);
                 const textNode = {
                     ...node,
-                    uuid: (0, create_token_1.uuid)(),
+                    uuid: uuid(),
                     type: 'text',
                     raw,
                     startOffset,
@@ -156,7 +153,7 @@ function restoreNode(nodeList, ignoreBlock) {
                 };
                 insertList.push(textNode);
             }
-            (0, siblings_correction_1.siblingsCorrection)(insertList);
+            siblingsCorrection(insertList);
             if (parentNode) {
                 parentNode.childNodes = insertList;
             }
@@ -183,7 +180,6 @@ function restoreNode(nodeList, ignoreBlock) {
     }
     return nodeList;
 }
-exports.restoreNode = restoreNode;
 function snap(str, reg) {
     const matched = reg.exec(str);
     if (!matched) {

package/lib/ignore-front-matter.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ignoreFrontMatter = void 0;
-function ignoreFrontMatter(code) {
+export function ignoreFrontMatter(code) {
     const reStart = /^(?:\s*\r?\n)?---\r?\n/.exec(code);
     if (!reStart) {
         return code;
@@ -18,4 +15,3 @@ function ignoreFrontMatter(code) {
     const masked = frontMatter.replace(/[^\r\n]/g, ' ');
     return masked + afterCode;
 }
-exports.ignoreFrontMatter = ignoreFrontMatter;

package/lib/index.d.ts

@@ -1,10 +1,16 @@
-export * from './decision';
-export * from './get-location';
-export * from './create-token';
-export * from './idl-attributes';
-export * from './walker';
-export * from './ignore-block';
-export * from './ignore-front-matter';
-export * from './debugger';
-export * from './parser-error';
-export * from './detect-element-type';
+export * from './const.js';
+export * from './create-token.js';
+export * from './debugger.js';
+export * from './decision.js';
+export * from './detect-element-type.js';
+export * from './flatten-nodes.js';
+export * from './get-location.js';
+export * from './get-space-before.js';
+export * from './idl-attributes.js';
+export * from './ignore-block.js';
+export * from './ignore-front-matter.js';
+export * from './parse-attr.js';
+export * from './parser-error.js';
+export * from './remove-deprecated-node.js';
+export * from './tag-splitter.js';
+export * from './walker.js';

package/lib/index.js

@@ -1,13 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./decision"), exports);
-tslib_1.__exportStar(require("./get-location"), exports);
-tslib_1.__exportStar(require("./create-token"), exports);
-tslib_1.__exportStar(require("./idl-attributes"), exports);
-tslib_1.__exportStar(require("./walker"), exports);
-tslib_1.__exportStar(require("./ignore-block"), exports);
-tslib_1.__exportStar(require("./ignore-front-matter"), exports);
-tslib_1.__exportStar(require("./debugger"), exports);
-tslib_1.__exportStar(require("./parser-error"), exports);
-tslib_1.__exportStar(require("./detect-element-type"), exports);
+export * from './const.js';
+export * from './create-token.js';
+export * from './debugger.js';
+export * from './decision.js';
+export * from './detect-element-type.js';
+export * from './flatten-nodes.js';
+export * from './get-location.js';
+export * from './get-space-before.js';
+export * from './idl-attributes.js';
+export * from './ignore-block.js';
+export * from './ignore-front-matter.js';
+export * from './parse-attr.js';
+export * from './parser-error.js';
+export * from './remove-deprecated-node.js';
+export * from './tag-splitter.js';
+export * from './walker.js';

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,144 @@
+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.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 = 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/parser-error.d.ts

@@ -1,13 +1,26 @@
+export type ParserErrorInfo = {
+    readonly line?: number;
+    readonly col?: number;
+    readonly raw?: string;
+};
 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, }: {
-        line?: number;
-        col?: number;
-        raw?: string;
-        nodeName?: string | null;
+    constructor(message: string, info: ParserErrorInfo);
+}
+export declare class TargetParserError extends ParserError {
+    name: string;
+    readonly nodeName: string | null;
+    constructor(message: string, info: ParserErrorInfo & {
+        readonly nodeName?: string | null;
+    });
+}
+export declare class ConfigParserError extends ParserError {
+    readonly filePath: string;
+    name: string;
+    constructor(message: string, info: ParserErrorInfo & {
+        readonly filePath: string;
     });
 }

package/lib/parser-error.js

@@ -1,14 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserError = void 0;
-class ParserError extends Error {
-    constructor(message, { line = 1, col = 0, raw = '', nodeName = null, }) {
-        super(nodeName ? `The ${nodeName} is invalid element (${line}:${col}): ${message}` : message);
+export class ParserError extends Error {
+    constructor(message, info) {
+        super(message);
         this.name = 'ParserError';
-        this.line = line;
-        this.col = col;
-        this.raw = raw;
-        this.nodeName = nodeName;
+        this.line = info.line ?? 1;
+        this.col = info.col ?? 0;
+        this.raw = info.raw ?? '';
+    }
+}
+export class TargetParserError extends ParserError {
+    constructor(message, info) {
+        const errMsg = info.nodeName
+            ? `The ${info.nodeName} is invalid element (${info.line}:${info.col}): ${message}`
+            : message;
+        super(errMsg, info);
+        this.name = 'TargetParserError';
+        this.nodeName = info.nodeName ?? null;
+    }
+}
+export class ConfigParserError extends ParserError {
+    constructor(message, info) {
+        const pos = info.line != null && info.line != null ? `(${info.line}:${info.col})` : '';
+        const file = ` in ${info.filePath}${pos}`;
+        const errMsg = `${message}${file}`;
+        super(errMsg, info);
+        this.name = 'ConfigParserError';
+        this.filePath = info.filePath;
     }
 }
-exports.ParserError = ParserError;

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

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

@@ -0,0 +1,39 @@
+/**
+ *
+ * @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 = [];
+    nodeOrders.forEach((node, i) => {
+        if (node.isGhost) {
+            return;
+        }
+        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.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.siblingsCorrection = void 0;
 /**
  * Correct the references to prevNode and nextNode in the order listed.
  *
@@ -8,13 +5,17 @@ exports.siblingsCorrection = void 0;
  * @affects nodeList[].prevNode
  * @affects nodeList[].nextNode
  */
-function siblingsCorrection(nodeList) {
+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 prevNode = nodeList[i - 1] ?? null;
         const node = nodeList[i];
-        const nextNode = nodeList[i + 1] || null;
+        if (!node) {
+            continue;
+        }
+        const nextNode = nodeList[i + 1] ?? null;
         node.prevNode = prevNode;
         node.nextNode = nextNode;
     }
 }
-exports.siblingsCorrection = siblingsCorrection;

package/lib/tag-splitter.d.ts

@@ -0,0 +1,7 @@
+export interface N {
+    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/tag-splitter.js

@@ -0,0 +1,89 @@
+import { reSplitterTag, reTagName } from './const.js';
+import { getEndCol, getEndLine } from '@markuplint/parser-utils';
+export default 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 = Array.from(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] !== '<') {
+            result.push({
+                type: 'text',
+                raw: node,
+                line,
+                col,
+            });
+        }
+        else {
+            const label = node.slice(1).slice(0, -1);
+            if (reTagName.test(label)) {
+                result.push({
+                    type: 'starttag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '/') {
+                result.push({
+                    type: 'endtag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '!') {
+                result.push({
+                    type: 'comment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '?') {
+                result.push({
+                    type: 'boguscomment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else {
+                result.push({
+                    type: 'text',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+        }
+        line = getEndLine(node, line);
+        col = getEndCol(node, col);
+    }
+    return result;
+}