@markuplint/html-parser 4.0.0-dev.0 → 4.0.0-dev.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 Yusuke Hirao
+Copyright (c) 2017-2024 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/index.d.ts

@@ -1,4 +1,2 @@
-export { isDocumentFragment } from './is-document-fragment.js';
 export { getNamespace } from './get-namespace.js';
-export { parse } from './parse.js';
-export { createTree } from './create-tree.js';
+export { parser, HtmlParser } from './parser.js';

package/lib/index.js

@@ -1,4 +1,2 @@
-export { isDocumentFragment } from './is-document-fragment.js';
 export { getNamespace } from './get-namespace.js';
-export { parse } from './parse.js';
-export { createTree } from './create-tree.js';
+export { parser, HtmlParser } from './parser.js';

package/lib/optimize-starts-head-or-body.d.ts

@@ -1,8 +1,10 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function isStartsHeadTagOrBodyTag(rawCode: string): boolean;
-export declare function optimizeStartsHeadTagOrBodyTagSetup(rawCode: string): {
-    code: string;
-    heads: string[];
-    bodies: string[];
+import type { HtmlParser } from './parser.js';
+import type { MLASTNodeTreeItem } from '@markuplint/ml-ast';
+export type Replacements = {
+    readonly code: string;
+    readonly heads: readonly string[];
+    readonly bodies: readonly string[];
 };
-export declare function optimizeStartsHeadTagOrBodyTagResume(nodeList: MLASTNode[], replacements: ReturnType<typeof optimizeStartsHeadTagOrBodyTagSetup>): void;
+export declare function isStartsHeadTagOrBodyTag(rawCode: string): boolean;
+export declare function optimizeStartsHeadTagOrBodyTagSetup(rawCode: string): Replacements;
+export declare function optimizeStartsHeadTagOrBodyTagResume(parser: HtmlParser, nodeList: readonly MLASTNodeTreeItem[], replacements: Replacements): readonly MLASTNodeTreeItem[];

package/lib/optimize-starts-head-or-body.js

@@ -1,8 +1,15 @@
 const UNDUPLICATED_CHAR = '\uFFFD';
 export function isStartsHeadTagOrBodyTag(rawCode) {
-    return /^\s*<(?:head|body)>/i.test(rawCode);
+    return /^\s*<(?:head|body)[\s>]/i.test(rawCode);
 }
 export function optimizeStartsHeadTagOrBodyTagSetup(rawCode) {
+    if (!isStartsHeadTagOrBodyTag(rawCode)) {
+        return {
+            code: rawCode,
+            heads: [],
+            bodies: [],
+        };
+    }
     const heads = [];
     const bodies = [];
     const code = rawCode.replaceAll(/(?<=<\/?)(?:head|body)(?=[\0\t\n\f />])/gi, tag => {
@@ -29,21 +36,32 @@ export function optimizeStartsHeadTagOrBodyTagSetup(rawCode) {
 }
 export function optimizeStartsHeadTagOrBodyTagResume(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-replacements) {
+parser, nodeList, replacements) {
+    const heads = [...replacements.heads];
+    const bodies = [...replacements.bodies];
     for (const node of nodeList) {
         if (!node.nodeName.startsWith(`x-${UNDUPLICATED_CHAR}`)) {
             continue;
         }
-        const realName = node.nodeName === `x-${UNDUPLICATED_CHAR}h` ? replacements.heads.shift() : replacements.bodies.shift();
+        const realName = node.nodeName === `x-${UNDUPLICATED_CHAR}h` ? heads.shift() : bodies.shift();
         if (!realName) {
             continue;
         }
-        node.raw = node.raw.replace(node.nodeName, realName);
-        node.nodeName = realName;
+        if (node.type !== 'starttag' && node.type !== 'endtag') {
+            continue;
+        }
+        parser.updateRaw(node, node.raw.replace(node.nodeName, realName));
         if (node.type === 'starttag') {
-            node.elementType = 'html';
+            parser.updateElement(node, {
+                nodeName: realName,
+                elementType: 'html',
+            });
+            continue;
         }
+        parser.updateElement(node, {
+            nodeName: realName,
+        });
+        continue;
     }
+    return nodeList;
 }

package/lib/parser.d.ts

@@ -0,0 +1,33 @@
+import type { Replacements } from './optimize-starts-head-or-body.js';
+import type { Node } from './types.js';
+import type { MLASTNodeTreeItem, MLASTParentNode } from '@markuplint/ml-ast';
+import type { ChildToken, ParseOptions, ParserOptions } from '@markuplint/parser-utils';
+import { Parser } from '@markuplint/parser-utils';
+type State = {
+    startsHeadTagOrBodyTag: Replacements | null;
+    afterPosition: {
+        endOffset: number;
+        endLine: number;
+        endCol: number;
+        depth: number;
+    };
+};
+type ExtendsOptions = Pick<ParserOptions, 'ignoreTags' | 'maskChar'>;
+export declare class HtmlParser extends Parser<Node, State> {
+    constructor(options?: ExtendsOptions);
+    tokenize(): {
+        ast: import("node_modules/parse5/dist/tree-adapters/default.js").ChildNode[];
+        isFragment: boolean;
+    };
+    beforeParse(rawCode: string, options?: ParseOptions): string;
+    afterParse(nodeList: readonly MLASTNodeTreeItem[], options?: ParseOptions): readonly MLASTNodeTreeItem[];
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterNodeize(siblings: readonly MLASTNodeTreeItem[], parentNode: MLASTParentNode | null, depth: number): {
+        siblings: import("@markuplint/ml-ast").MLASTChildNode[];
+        ancestors: MLASTNodeTreeItem[];
+    };
+    visitText(token: ChildToken): readonly MLASTNodeTreeItem[];
+    visitSpreadAttr(): null;
+}
+export declare const parser: HtmlParser;
+export {};

package/lib/parser.js

@@ -0,0 +1,162 @@
+import { Parser } from '@markuplint/parser-utils';
+import { parse, parseFragment } from 'parse5';
+import { isDocumentFragment } from './is-document-fragment.js';
+import { optimizeStartsHeadTagOrBodyTagResume, optimizeStartsHeadTagOrBodyTagSetup, } from './optimize-starts-head-or-body.js';
+export class HtmlParser extends Parser {
+    constructor(options) {
+        super(options, {
+            startsHeadTagOrBodyTag: null,
+            afterPosition: {
+                endOffset: 0,
+                endLine: 1,
+                endCol: 1,
+                depth: 0,
+            },
+        });
+    }
+    tokenize() {
+        const isFragment = isDocumentFragment(this.rawCode);
+        const parseFn = isFragment ? parseFragment : parse;
+        const doc = parseFn(this.rawCode, {
+            scriptingEnabled: false,
+            sourceCodeLocationInfo: true,
+        });
+        const childNodes = doc.childNodes;
+        return {
+            ast: childNodes,
+            isFragment,
+        };
+    }
+    beforeParse(rawCode, options) {
+        rawCode = super.beforeParse(rawCode, options);
+        const replacements = optimizeStartsHeadTagOrBodyTagSetup(rawCode);
+        if (replacements?.code) {
+            this.state.startsHeadTagOrBodyTag = replacements;
+            return replacements.code;
+        }
+        this.state.afterPosition = {
+            endOffset: (options?.offsetOffset ?? 0) + this.state.afterPosition.endOffset,
+            endLine: (options?.offsetLine ?? 0) + this.state.afterPosition.endLine,
+            endCol: (options?.offsetColumn ?? 0) + this.state.afterPosition.endCol,
+            depth: this.state.afterPosition.depth,
+        };
+        return rawCode;
+    }
+    afterParse(nodeList, options) {
+        nodeList = super.afterParse(nodeList, options);
+        if (this.state.startsHeadTagOrBodyTag) {
+            return optimizeStartsHeadTagOrBodyTagResume(this, nodeList, this.state.startsHeadTagOrBodyTag);
+        }
+        return nodeList;
+    }
+    nodeize(
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    originNode, parentNode, depth) {
+        const namespace = 'namespaceURI' in originNode ? originNode.namespaceURI : '';
+        const location = originNode.sourceCodeLocation;
+        if (!location) {
+            // Ghost element
+            const afterNode = this.state.afterPosition.depth === depth ? this.state.afterPosition : parentNode;
+            const startOffset = afterNode?.endOffset ?? 0;
+            const startLine = afterNode?.endLine ?? 0;
+            const startCol = afterNode?.endCol ?? 0;
+            const childNodes = 'childNodes' in originNode ? originNode.childNodes : [];
+            return this.visitElement({
+                raw: '',
+                startOffset,
+                startLine,
+                startCol,
+                depth,
+                parentNode,
+                nodeName: originNode.nodeName,
+                namespace,
+            }, childNodes);
+        }
+        const { startOffset, endOffset } = location;
+        const token = this.sliceFragment(startOffset, endOffset ?? startOffset);
+        switch (originNode.nodeName) {
+            case '#documentType': {
+                if (!('name' in originNode)) {
+                    throw new TypeError("DocumentType doesn't have name");
+                }
+                return this.visitDoctype({
+                    ...token,
+                    depth,
+                    name: originNode.name ?? '',
+                    publicId: originNode.publicId ?? '',
+                    systemId: originNode.systemId ?? '',
+                    parentNode,
+                });
+            }
+            case '#text': {
+                return this.visitText({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            case '#comment': {
+                return this.visitComment({
+                    ...token,
+                    depth,
+                    parentNode,
+                });
+            }
+            default: {
+                const tagLoc = 'startTag' in location ? location.startTag : null;
+                const offset = tagLoc?.startOffset ?? startOffset;
+                const endOffset = tagLoc?.endOffset ?? offset;
+                const startTagToken = this.sliceFragment(offset, endOffset);
+                const childNodes = 'childNodes' in originNode
+                    ? originNode.nodeName === 'template' && 'content' in originNode
+                        ? originNode.content.childNodes
+                        : originNode.childNodes
+                    : [];
+                return this.visitElement({
+                    ...startTagToken,
+                    depth,
+                    parentNode,
+                    nodeName: originNode.nodeName,
+                    namespace,
+                }, childNodes, {
+                    createEndTagToken: () => {
+                        const endTagLoc = 'endTag' in location ? location.endTag : null;
+                        if (!endTagLoc) {
+                            return null;
+                        }
+                        const { startOffset, endOffset } = endTagLoc;
+                        const endTagToken = this.sliceFragment(startOffset, endOffset);
+                        return {
+                            ...endTagToken,
+                            depth,
+                            parentNode,
+                        };
+                    },
+                });
+            }
+        }
+    }
+    afterNodeize(siblings, parentNode, depth) {
+        const after = super.afterNodeize(siblings, parentNode, depth);
+        const prevNode = after.siblings.at(-1) ?? after.ancestors.findLast(n => n.depth === depth);
+        if (prevNode) {
+            this.state.afterPosition = {
+                endOffset: prevNode.endOffset,
+                endLine: prevNode.endLine,
+                endCol: prevNode.endCol,
+                depth,
+            };
+        }
+        return after;
+    }
+    visitText(token) {
+        return super.visitText(token, {
+            researchTags: true,
+            invalidTagAsText: true,
+        });
+    }
+    visitSpreadAttr() {
+        return null;
+    }
+}
+export const parser = new HtmlParser();

package/lib/types.d.ts

@@ -0,0 +1,9 @@
+export type { ParserOptions, DefaultTreeAdapterMap } from 'parse5';
+import type { DefaultTreeAdapterMap } from 'parse5';
+export type Node = DefaultTreeAdapterMap['node'];
+export type TextNode = DefaultTreeAdapterMap['textNode'];
+export type Element = DefaultTreeAdapterMap['element'];
+export type CommentNode = DefaultTreeAdapterMap['commentNode'];
+export type Document = DefaultTreeAdapterMap['document'];
+export type DocumentFragment = DefaultTreeAdapterMap['documentFragment'];
+export type ChildNode = DefaultTreeAdapterMap['childNode'];

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/html-parser",
-	"version": "4.0.0-dev.0+7c596917",
+	"version": "4.0.0-dev.12+2275fbeb0",
 	"description": "HTML parser for markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -25,10 +25,10 @@
 		"clean": "tsc --build --clean"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "4.0.0-dev.0+7c596917",
-		"@markuplint/parser-utils": "4.0.0-dev.0+7c596917",
+		"@markuplint/ml-ast": "4.0.0-dev.12+2275fbeb0",
+		"@markuplint/parser-utils": "4.0.0-dev.12+2275fbeb0",
 		"parse5": "7.1.2",
-		"type-fest": "^4.8.2"
+		"type-fest": "^4.9.0"
 	},
-	"gitHead": "7c59691701465a0fb3a4b69187318e8033c463d4"
+	"gitHead": "2275fbeb053605b636f080f4fafd7cd4fc57a9a3"
 }

package/lib/create-tree.d.ts

@@ -1,2 +0,0 @@
-import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function createTree(rawCode: string, isFragment: boolean, offsetOffset: number, offsetLine: number, offsetColumn: number): MLASTNode[];

package/lib/create-tree.js

@@ -1,254 +0,0 @@
-// @ts-nocheck TODO: Parse5(https://github.com/inikulin/parse5) supports to expose type definitions as submodules.
-import { detectElementType, getEndCol, getEndLine, sliceFragment, tagParser, uuid } from '@markuplint/parser-utils';
-import { parse, parseFragment } from 'parse5';
-const P5_OPTIONS = {
-    scriptingEnabled: false,
-    sourceCodeLocationInfo: true,
-};
-export function createTree(rawCode, isFragment, offsetOffset, offsetLine, offsetColumn) {
-    const doc = isFragment ? parseFragment(rawCode, P5_OPTIONS) : parse(rawCode, P5_OPTIONS);
-    return createTreeRecursive(doc, null, rawCode, offsetOffset, offsetLine, offsetColumn);
-}
-function createTreeRecursive(rootNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-parentNode, rawHtml, offsetOffset, offsetLine, offsetColumn) {
-    const nodeList = [];
-    const childNodes = getChildNodes(rootNode);
-    let prevNode = null;
-    for (const p5node of childNodes) {
-        const node = nodeize(p5node, prevNode, parentNode, rawHtml, offsetOffset, offsetLine, offsetColumn);
-        if (!node) {
-            continue;
-        }
-        if (prevNode) {
-            if (node.type !== 'endtag') {
-                prevNode.nextNode = node;
-            }
-            node.prevNode = prevNode;
-        }
-        prevNode = node;
-        nodeList.push(node);
-    }
-    return nodeList;
-}
-function nodeize(originNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-prevNode, 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-parentNode, rawHtml, offsetOffset, offsetLine, offsetColumn) {
-    const nextNode = null;
-    const location = getLocation(originNode);
-    if (!location) {
-        const prevToken = prevNode ?? parentNode;
-        const startOffset = prevToken ? prevToken.endOffset : 0;
-        const endOffset = prevToken ? prevToken.endOffset : 0;
-        const startLine = prevToken ? prevToken.endLine : 0;
-        const endLine = prevToken ? prevToken.endLine : 0;
-        const startCol = prevToken ? prevToken.endCol : 0;
-        const endCol = prevToken ? prevToken.endCol : 0;
-        const node = {
-            uuid: uuid(),
-            raw: '',
-            startOffset: startOffset + offsetOffset,
-            endOffset: endOffset + offsetOffset,
-            startLine: startLine + offsetLine,
-            endLine: endLine + offsetLine,
-            startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-            endCol: endCol + (endLine === 1 ? offsetColumn : 0),
-            nodeName: originNode.nodeName,
-            type: 'starttag',
-            namespace: getNamespace(originNode),
-            elementType: 'html',
-            attributes: [],
-            hasSpreadAttr: false,
-            pearNode: null,
-            tagCloseChar: '',
-            tagOpenChar: '',
-            parentNode,
-            prevNode,
-            nextNode,
-            isFragment: false,
-            isGhost: true,
-        };
-        node.childNodes = createTreeRecursive(originNode, node, rawHtml, offsetOffset, offsetLine, offsetColumn);
-        return node;
-    }
-    const { startOffset, endOffset, startLine, endLine, startCol, endCol } = location;
-    const raw = rawHtml.slice(startOffset, endOffset ?? startOffset);
-    switch (originNode.nodeName) {
-        case '#documentType': {
-            return {
-                uuid: uuid(),
-                raw,
-                // @ts-ignore
-                name: originNode.name ?? '',
-                // @ts-ignore
-                publicId: originNode.publicId ?? '',
-                // @ts-ignore
-                systemId: originNode.systemId ?? '',
-                startOffset: startOffset + offsetOffset,
-                endOffset: endOffset + offsetOffset,
-                startLine: startLine + offsetLine,
-                endLine: endLine + offsetLine,
-                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
-                nodeName: '#doctype',
-                type: 'doctype',
-                parentNode,
-                prevNode,
-                _addPrevNode: 102,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-        }
-        case '#text': {
-            const node = {
-                uuid: uuid(),
-                raw,
-                startOffset: startOffset + offsetOffset,
-                endOffset: endOffset + offsetOffset,
-                startLine: startLine + offsetLine,
-                endLine: endLine + offsetLine,
-                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
-                nodeName: '#text',
-                type: 'text',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-            return node;
-        }
-        case '#comment': {
-            return {
-                uuid: uuid(),
-                raw,
-                startOffset: startOffset + offsetOffset,
-                endOffset: endOffset + offsetOffset,
-                startLine: startLine + offsetLine,
-                endLine: endLine + offsetLine,
-                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-                endCol: endCol + (endLine === 1 ? offsetColumn : 0),
-                nodeName: '#comment',
-                type: 'comment',
-                parentNode,
-                prevNode,
-                nextNode,
-                isFragment: false,
-                isGhost: false,
-            };
-        }
-        default: {
-            const tagLoc = 'startTag' in location ? location.startTag : null;
-            const startTagRaw = tagLoc
-                ? rawHtml.slice(tagLoc.startOffset, tagLoc.endOffset)
-                : rawHtml.slice(startOffset, endOffset ?? startOffset);
-            const tagTokens = tagParser(startTagRaw, startLine, startCol, startOffset, offsetOffset, offsetLine, offsetColumn);
-            const tagName = tagTokens.tagName;
-            let endTag = null;
-            let endTagLoc = 'endTag' in location ? location.endTag : null;
-            /**
-             * Patch: Create endTag for SVG Element
-             * @see https://github.com/inikulin/parse5/issues/352
-             */
-            if (!endTagLoc &&
-                'namespaceURI' in originNode &&
-                originNode.namespaceURI === 'http://www.w3.org/2000/svg') {
-                const belowRawHTMLFromStartTagEnd = rawHtml.slice(location.endOffset);
-                const endTagMatched = belowRawHTMLFromStartTagEnd.match(new RegExp(`^</\\s*${tagName}[^>]*>`, 'm'));
-                const endTag = endTagMatched && endTagMatched[0];
-                if (endTag) {
-                    endTagLoc = sliceFragment(rawHtml, location.endOffset, location.endOffset + endTag.length);
-                }
-            }
-            if (endTagLoc) {
-                const { startOffset, endOffset, startLine, endLine, startCol, endCol } = endTagLoc;
-                const endTagRaw = rawHtml.slice(startOffset, endOffset);
-                const endTagTokens = tagParser(endTagRaw, startLine, startCol, startOffset, offsetOffset, offsetLine, offsetColumn);
-                const endTagName = endTagTokens.tagName;
-                endTag = {
-                    uuid: uuid(),
-                    raw: endTagRaw,
-                    startOffset: startOffset + offsetOffset,
-                    endOffset: endOffset + offsetOffset,
-                    startLine: startLine + offsetLine,
-                    endLine: endLine + offsetLine,
-                    startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-                    endCol: endCol + (endLine === 1 ? offsetColumn : 0),
-                    nodeName: endTagName,
-                    type: 'endtag',
-                    namespace: getNamespace(originNode),
-                    attributes: endTagTokens.attrs,
-                    parentNode,
-                    prevNode,
-                    nextNode,
-                    pearNode: null,
-                    isFragment: false,
-                    isGhost: false,
-                    tagOpenChar: '</',
-                    tagCloseChar: '>',
-                };
-            }
-            const _endOffset = startOffset + startTagRaw.length;
-            const _endLine = getEndLine(startTagRaw, startLine);
-            const _endCol = getEndCol(startTagRaw, startCol);
-            const startTag = {
-                uuid: uuid(),
-                raw: startTagRaw,
-                startOffset: startOffset + offsetOffset,
-                endOffset: _endOffset + offsetOffset,
-                startLine: startLine + offsetLine,
-                endLine: _endLine + offsetLine,
-                startCol: startCol + (startLine === 1 ? offsetColumn : 0),
-                endCol: _endCol + (startLine === _endLine ? offsetColumn : 0),
-                nodeName: tagName,
-                type: 'starttag',
-                namespace: getNamespace(originNode),
-                elementType: detectElementType(tagName),
-                attributes: tagTokens.attrs,
-                hasSpreadAttr: false,
-                parentNode,
-                prevNode,
-                nextNode,
-                pearNode: endTag,
-                selfClosingSolidus: tagTokens.selfClosingSolidus,
-                endSpace: tagTokens.endSpace,
-                isFragment: false,
-                isGhost: false,
-                tagOpenChar: '<',
-                tagCloseChar: '>',
-            };
-            if (endTag) {
-                endTag.pearNode = startTag;
-            }
-            startTag.childNodes = createTreeRecursive(originNode, startTag, rawHtml, offsetOffset, offsetLine, offsetColumn);
-            return startTag;
-        }
-    }
-}
-/**
- * getChildNodes
- *
- * - If node has "content" property then parse as document fragment.
- */
-function getChildNodes(rootNode) {
-    return rootNode.content ? rootNode.content.childNodes : rootNode.childNodes ?? [];
-}
-function hasLocation(node) {
-    return 'sourceCodeLocation' in node;
-}
-function getLocation(node) {
-    if (hasLocation(node) && node.sourceCodeLocation) {
-        return node.sourceCodeLocation;
-    }
-    return null;
-}
-function getNamespace(node) {
-    if ('namespaceURI' in node) {
-        return node.namespaceURI;
-    }
-    return '';
-}

package/lib/parse.d.ts

@@ -1,2 +0,0 @@
-import type { Parse } from '@markuplint/ml-ast';
-export declare const parse: Parse;

package/lib/parse.js

@@ -1,23 +0,0 @@
-import { ignoreFrontMatter, flattenNodes } from '@markuplint/parser-utils';
-import { createTree } from './create-tree.js';
-import { isDocumentFragment } from './is-document-fragment.js';
-import { isStartsHeadTagOrBodyTag, optimizeStartsHeadTagOrBodyTagResume, optimizeStartsHeadTagOrBodyTagSetup, } from './optimize-starts-head-or-body.js';
-export const parse = (rawCode, options) => {
-    if (options?.ignoreFrontMatter) {
-        rawCode = ignoreFrontMatter(rawCode);
-    }
-    const isFragment = isDocumentFragment(rawCode);
-    const data = isStartsHeadTagOrBodyTag(rawCode) ? optimizeStartsHeadTagOrBodyTagSetup(rawCode) : null;
-    if (data?.code) {
-        rawCode = data.code;
-    }
-    const nodeTree = createTree(rawCode, isFragment, options?.offsetOffset ?? 0, options?.offsetLine ?? 0, options?.offsetColumn ?? 0);
-    const nodeList = flattenNodes(nodeTree, rawCode);
-    if (data) {
-        optimizeStartsHeadTagOrBodyTagResume(nodeList, data);
-    }
-    return {
-        nodeList,
-        isFragment,
-    };
-};