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

package/lib/const.d.ts

@@ -5,3 +5,6 @@ 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;

package/lib/const.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.svgElementList = exports.MASK_CHAR = void 0;
-exports.MASK_CHAR = '\uE000';
+export const MASK_CHAR = '\uE000';
 /**
  * SVG Element list
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element
  */
-exports.svgElementList = [
+export const svgElementList = [
     'a',
     'animate',
     'animateMotion',
@@ -97,3 +94,7 @@ exports.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\u0020/>]*)/i;
+export const reSplitterTag = /<[^>]+>/g;

package/lib/create-token.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 || '';
-    const endLine = (0, get_location_1.getEndLine)(raw, startLine);
-    const endCol = (0, get_location_1.getEndCol)(raw, startCol);
+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(),
@@ -19,17 +16,14 @@ function tokenizer(raw, startLine, startCol, startOffset) {
         endCol,
     };
 }
-exports.tokenizer = tokenizer;
-function createTokenFromRawCode(raw, startOffset, rawCode) {
-    raw = raw || '';
-    const loc = (0, get_location_1.sliceFragment)(rawCode, startOffset, startOffset + raw.length);
+export function createTokenFromRawCode(raw, startOffset, rawCode) {
+    raw = raw ?? '';
+    const loc = sliceFragment(rawCode, startOffset, startOffset + raw.length);
     return {
         uuid: uuid(),
         ...loc,
     };
 }
-exports.createTokenFromRawCode = createTokenFromRawCode;
-function uuid() {
-    return (0, uuid_1.v4)();
+export function uuid() {
+    return uuid4();
 }
-exports.uuid = uuid;

package/lib/debugger.js

@@ -1,7 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attributesToDebugMaps = exports.nodeListToDebugMaps = void 0;
-function nodeListToDebugMaps(nodeList, withAttr = false) {
+export function nodeListToDebugMaps(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, withAttr = false) {
     return nodeList
         .map(n => {
         const r = [];
@@ -18,8 +17,9 @@ function nodeListToDebugMaps(nodeList, withAttr = false) {
     })
         .flat();
 }
-exports.nodeListToDebugMaps = nodeListToDebugMaps;
-function attributesToDebugMaps(attributes) {
+export function attributesToDebugMaps(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+attributes) {
     return attributes.map(n => {
         const r = [
             tokenDebug({
@@ -48,11 +48,10 @@ function attributesToDebugMaps(attributes) {
         return r;
     });
 }
-exports.attributesToDebugMaps = attributesToDebugMaps;
 function tokenDebug(n, type = '') {
     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)}`;
+    n.potentialName ?? n.nodeName ?? n.name ?? n.type ?? type}: ${visibleWhiteSpace(n.raw)}`;
 }
 function visibleWhiteSpace(chars) {
     return chars.replace(/\n/g, '⏎').replace(/\t/g, '→').replace(/\s/g, '␣');

package/lib/decision.js

@@ -1,20 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPotentialCustomElementName = exports.isSVGElement = void 0;
-const types_1 = require("@markuplint/types");
-const const_1 = require("./const");
+import { isCustomElementName } from '@markuplint/types';
+import { svgElementList } from './const.js';
 /**
  *
  *
  * @param nodeName
  * @returns
  */
-function isSVGElement(nodeName) {
-    return const_1.svgElementList.includes(nodeName);
+export function isSVGElement(nodeName) {
+    return svgElementList.includes(nodeName);
 }
-exports.isSVGElement = isSVGElement;
-const isCEN = (0, types_1.isCustomElementName)();
-function isPotentialCustomElementName(tagName) {
+const isCEN = isCustomElementName();
+export function isPotentialCustomElementName(tagName) {
     return isCEN(tagName);
 }
-exports.isPotentialCustomElementName = isPotentialCustomElementName;

package/lib/detect-element-type.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectElementType = void 0;
-const decision_1 = require("./decision");
-function detectElementType(name, option, defaultPattern) {
+import { isPotentialCustomElementName } from './decision.js';
+export function detectElementType(name, option, defaultPattern) {
     if (distinguishAuthoredName(name, option, defaultPattern)) {
         return 'authored';
     }
-    return (0, decision_1.isPotentialCustomElementName)(name) ? 'web-component' : 'html';
+    return isPotentialCustomElementName(name) ? 'web-component' : 'html';
 }
-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;
@@ -30,7 +26,7 @@ function _distinguishAuthoredName(name, patterns) {
 }
 function toRegexp(pattern) {
     const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
-    if (matched) {
+    if (matched && matched[1]) {
         return new RegExp(matched[1], matched[2]);
     }
     return new RegExp(pattern);

package/lib/flatten-nodes.d.ts

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

package/lib/flatten-nodes.js

@@ -0,0 +1,245 @@
+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;
+                nodeOrders.forEach((node, i) => {
+                    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 = [];
+    nodeOrders.forEach(node => {
+        const prevNode = result[result.length - 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;
+            }
+            return;
+        }
+        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') {
+                    if (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.slice();
+}

package/lib/get-location.js

@@ -1,27 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sliceFragment = exports.getEndCol = exports.getEndLine = exports.getCol = exports.getLine = void 0;
-function getLine(html, startOffset) {
+export function getLine(html, startOffset) {
     return html.slice(0, startOffset).split(/\n/g).length;
 }
-exports.getLine = getLine;
-function getCol(html, startOffset) {
+export function getCol(html, startOffset) {
     const lines = html.slice(0, startOffset).split(/\n/g);
-    return lines[lines.length - 1].length + 1;
+    return (lines[lines.length - 1] ?? '').length + 1;
 }
-exports.getCol = getCol;
-function getEndLine(html, line) {
+export function getEndLine(html, line) {
     return html.split(/\r?\n/).length - 1 + line;
 }
-exports.getEndLine = getEndLine;
-function getEndCol(html, col) {
+export function getEndCol(html, col) {
     const lines = html.split(/\r?\n/);
     const lineCount = lines.length;
     const lastLine = lines.pop();
     return lineCount > 1 ? lastLine.length + 1 : col + html.length;
 }
-exports.getEndCol = getEndCol;
-function sliceFragment(rawHtml, start, end) {
+export function sliceFragment(rawHtml, start, end) {
     const raw = rawHtml.slice(start, end);
     return {
         startOffset: start,
@@ -33,4 +26,3 @@ function sliceFragment(rawHtml, start, end) {
         raw,
     };
 }
-exports.sliceFragment = sliceFragment;

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

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

package/lib/get-space-before.js

@@ -0,0 +1,8 @@
+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/idl-attributes.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchIDLAttribute = void 0;
 /**
  * IDL attributes VS Content attributes
  *
@@ -108,6 +105,9 @@ const idlContentMap = {
     pattern: 'pattern',
     placeholder: 'placeholder',
     playsInline: 'playsinline',
+    popover: 'popover',
+    popoverTarget: 'popovertarget',
+    popoverTargetAction: 'popovertargetaction',
     poster: 'poster',
     preload: 'preload',
     profile: 'profile',
@@ -397,23 +397,38 @@ const idlContentMap = {
     yChannelSelector: 'yChannelSelector',
     z: 'z',
     zoomAndPan: 'zoomAndPan',
+    /**
+     * PerformanceElementTiming API
+     *
+     * @experimental
+     * @see https://wicg.github.io/element-timing/#sec-modifications-DOM
+     * @see https://wicg.github.io/element-timing/#sec-elements-exposed
+     */
+    elementTiming: 'elementtiming',
+    /**
+     * IFrame credentialless
+     *
+     * @experimental
+     * @warning No specification found
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/credentialless
+     */
+    credentialless: 'credentialless',
 };
 const list = Object.entries(idlContentMap);
-function searchIDLAttribute(name) {
+export function searchIDLAttribute(name) {
     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()]
+        : list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
             contentAttrName.toLowerCase() === name.toLowerCase() ||
-            hyphenize(idlPropName) === name.toLowerCase()) ||
-        [];
+            hyphenize(idlPropName) === name.toLowerCase()) ?? [];
     return {
         idlPropName,
         contentAttrName,
     };
 }
-exports.searchIDLAttribute = searchIDLAttribute;
 function camelize(str) {
-    return str.replace(/[:-][a-z]/g, $0 => $0[1].toUpperCase());
+    return str.replace(/[:-][a-z]/g, $0 => $0[1]?.toUpperCase() ?? '');
 }
 function hyphenize(str) {
     return str.replace(/[A-Z]/g, $0 => `-${$0.toLowerCase()}`);

package/lib/ignore-block.d.ts

@@ -1,4 +1,4 @@
-import type { IgnoreBlock, IgnoreTag } from './types';
+import type { IgnoreBlock, IgnoreTag } from './types.js';
 import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function ignoreBlock(source: string, tags: IgnoreTag[], maskChar?: string): IgnoreBlock;
+export declare function ignoreBlock(source: string, tags: readonly IgnoreTag[], maskChar?: string): IgnoreBlock;
 export declare function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock): MLASTNode[];