@unicode-utils/parser 0.12.0-beta.17

package/dist/datafile-B9Fta4dI.js

@@ -0,0 +1,877 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { _ as trimCommentLine, a as isBoundaryLine, c as isEOFMarker, f as isLineWithData, i as inferVersion, l as isEmptyLine, m as isPropertyLine, n as getPropertyValue, o as isCommentLine, r as inferFileName, t as getBoundaryLineStyle } from "./line-helpers-tsCF16UF.js";
+import { invariant } from "@luxass/utils";
+import defu from "defu";
+
+//#region src/datafile/ast.ts
+const NodeTypes = {
+	ROOT: "root",
+	COMMENT: "comment",
+	EMPTY_COMMENT: "empty-comment",
+	BOUNDARY: "boundary",
+	DATA: "data",
+	EMPTY: "empty",
+	EOF: "eof",
+	PROPERTY: "property",
+	UNKNOWN: "unknown"
+};
+
+//#endregion
+//#region src/datafile/typeguards.ts
+/**
+* Type guard function that checks if an unknown value is a Node.
+* A Node must be an object with 'type', 'value', 'raw', and 'line' properties of the correct types.
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is Node} True if the node is a valid Node, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# Comment\n0000..007F; Basic Latin');
+* const firstChild = parsedData.children[0];
+*
+* if (isNode(firstChild)) {
+*   console.log(`Node type: ${firstChild.type}`);
+*   console.log(`Raw content: ${firstChild.raw}`);
+*   console.log(`Line number: ${firstChild.line}`);
+* }
+* ```
+*/
+function isNode(node) {
+	return typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && "raw" in node && typeof node.raw === "string" && "line" in node && typeof node.line === "number" && "value" in node && typeof node.value === "string";
+}
+/**
+* Type guard function that checks if an unknown value is a CommentNode.
+* A CommentNode must be a valid Node with the type property set to "comment".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is CommentNode} True if the node is a valid CommentNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# This is a comment\n0000; NULL');
+* const commentNode = parsedData.children[0];
+*
+* if (isCommentNode(commentNode)) {
+*   console.log(`Comment content: ${commentNode.value}`); // "This is a comment"
+*   console.log(`Raw line: ${commentNode.raw}`); // "# This is a comment"
+* }
+* ```
+*/
+function isCommentNode(node) {
+	return isNode(node) && node.type === "comment";
+}
+/**
+* Type guard function that checks if an unknown value is an EmptyCommentNode.
+* An EmptyCommentNode must be a valid Node with the type property set to "empty-comment".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is EmptyCommentNode} True if the node is a valid EmptyCommentNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('#\n0000; NULL');
+* const emptyCommentNode = parsedData.children[0];
+*
+* if (isEmptyCommentNode(emptyCommentNode)) {
+*   console.log(`Empty comment raw: ${emptyCommentNode.raw}`); // "#"
+*   console.log(`Empty comment value: "${emptyCommentNode.value}"`); // ""
+* }
+* ```
+*/
+function isEmptyCommentNode(node) {
+	return isNode(node) && node.type === "empty-comment";
+}
+/**
+* Type guard function that checks if an unknown value is a BoundaryNode.
+* A BoundaryNode must be a valid Node with the type property set to "boundary".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is BoundaryNode} True if the node is a valid BoundaryNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# ================================================\n0000; NULL');
+* const boundaryNode = parsedData.children[0];
+*
+* if (isBoundaryNode(boundaryNode)) {
+*   console.log(`Boundary style: ${boundaryNode.style}`); // "equals"
+*   console.log(`Boundary raw: ${boundaryNode.raw}`); // "# ================================================"
+* }
+* ```
+*/
+function isBoundaryNode(node) {
+	return isNode(node) && node.type === "boundary";
+}
+/**
+* Type guard function that checks if an unknown value is a DataNode.
+* A DataNode must be a valid Node with the type property set to "data".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is DataNode} True if the node is a valid DataNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('0000..007F    ; Basic Latin  # [128] <control-0000>..<control-007F>');
+* const dataNode = parsedData.children[0];
+*
+* if (isDataNode(dataNode)) {
+*   console.log(`Data value: ${dataNode.value}`); // "0000..007F    ; Basic Latin  # [128] <control-0000>..<control-007F>"
+*   console.log(`Raw content: ${dataNode.raw}`); // Same as value for data nodes
+*   console.log(`Line number: ${dataNode.line}`); // 1
+* }
+* ```
+*/
+function isDataNode(node) {
+	return isNode(node) && node.type === "data";
+}
+/**
+* Type guard function that checks if an unknown value is an EmptyNode.
+* An EmptyNode must be a valid Node with the type property set to "empty".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is EmptyNode} True if the node is a valid EmptyNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# Comment\n\n0000; NULL');
+* const emptyNode = parsedData.children[1]; // The blank line
+*
+* if (isEmptyNode(emptyNode)) {
+*   console.log(`Empty node raw: "${emptyNode.raw}"`); // ""
+*   console.log(`Empty node value: "${emptyNode.value}"`); // ""
+*   console.log(`Line number: ${emptyNode.line}`); // 2
+* }
+* ```
+*/
+function isEmptyNode(node) {
+	return isNode(node) && node.type === "empty";
+}
+/**
+* Type guard function that checks if an unknown value is a RootNode.
+* A RootNode must be a valid Node with the type property set to "root".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is RootNode} True if the node is a valid RootNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# Unicode Block Data\n0000..007F; Basic Latin');
+*
+* if (isRootNode(parsedData)) {
+*   console.log(`Root has ${parsedData.children.length} children`); // 2
+*   console.log(`File name: ${parsedData.fileName}`); // May be undefined
+*   console.log(`Version: ${parsedData.version}`); // May be undefined
+* }
+* ```
+*/
+function isRootNode(node) {
+	return isNode(node) && node.type === "root";
+}
+/**
+* Type guard function that checks if an unknown value is an UnknownNode.
+* An UnknownNode must be a valid Node with the type property set to "unknown".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is UnknownNode} True if the node is a valid UnknownNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* // Assuming some unusual content that doesn't match known patterns
+* const parsedData = parseDataFile('@@UNUSUAL_SYNTAX@@\n0000; NULL');
+* const unknownNode = parsedData.children[0];
+*
+* if (isUnknownNode(unknownNode)) {
+*   console.log(`Unknown node raw: ${unknownNode.raw}`); // "@@UNUSUAL_SYNTAX@@"
+*   console.log(`Unknown node value: ${unknownNode.value}`); // "@@UNUSUAL_SYNTAX@@"
+*   console.log(`Line number: ${unknownNode.line}`); // 1
+* }
+* ```
+*/
+function isUnknownNode(node) {
+	return isNode(node) && node.type === "unknown";
+}
+/**
+* Type guard function that checks if an unknown value is an EOFNode.
+* An EOFNode must be a valid Node with the type property set to "eof".
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is EOFNode} True if the node is a valid EOFNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('0000; NULL');
+* const lastNode = parsedData.children[parsedData.children.length - 1];
+*
+* if (isEOFNode(lastNode)) {
+*   console.log(`EOF node detected at line: ${lastNode.line}`);
+*   console.log(`EOF raw value: ${lastNode.raw}`); // Empty string
+* }
+* ```
+*/
+function isEOFNode(node) {
+	return isNode(node) && node.type === "eof";
+}
+/**
+* Type guard function that checks if an unknown value is a PropertyNode.
+* A PropertyNode must be a valid Node with the type property set to "property" and have a defined propertyValue.
+*
+* @param {unknown} node - The unknown value to check
+* @returns {node is PropertyNode} True if the node is a valid PropertyNode, false otherwise
+*
+* @example
+* ```typescript
+* import { parseDataFile } from './parser';
+*
+* const parsedData = parseDataFile('# @key=value\n0000; NULL');
+* const propertyNode = parsedData.children[0];
+*
+* if (isPropertyNode(propertyNode)) {
+*   console.log(`Property key: ${propertyNode.propertyKey}`); // "key"
+*   console.log(`Property value: ${propertyNode.propertyValue}`); // "value"
+*   console.log(`Raw content: ${propertyNode.raw}`); // "# @key=value"
+* }
+* ```
+*/
+function isPropertyNode(node) {
+	return isNode(node) && node.type === "property" && node.propertyValue !== void 0;
+}
+
+//#endregion
+//#region src/datafile/ast-utils.ts
+var ast_utils_exports = /* @__PURE__ */ __export({
+	allNodesAreOfType: () => allNodesAreOfType,
+	endsWithSequence: () => endsWithSequence,
+	findNodePattern: () => findNodePattern,
+	hasBoundaryWithinRange: () => hasBoundaryWithinRange,
+	hasConsecutiveNodesOfType: () => hasConsecutiveNodesOfType,
+	hasMinNodesOfType: () => hasMinNodesOfType,
+	hasNextNComments: () => hasNextNComments,
+	hasNextNCommentsFrom: () => hasNextNCommentsFrom,
+	hasNodePattern: () => hasNodePattern,
+	hasPrevNCommentsFrom: () => hasPrevNCommentsFrom,
+	isCommentOnlyDocument: () => isCommentOnlyDocument,
+	startsWithSequence: () => startsWithSequence,
+	visit: () => visit
+});
+const NODE_TYPE_CHECKERS = {
+	"comment": isCommentNode,
+	"empty-comment": isEmptyCommentNode,
+	"boundary": isBoundaryNode,
+	"data": isDataNode,
+	"empty": isEmptyNode,
+	"unknown": isUnknownNode,
+	"eof": isEOFNode,
+	"property": isPropertyNode
+};
+/**
+* Checks if the next N nodes from a given index are all comment nodes
+* @param {RootNode} root - The root node containing children
+* @param {number} startIndex - The starting index to check from
+* @param {number} count - Number of nodes to check
+* @returns {boolean} true if the next N nodes are all comment nodes, false otherwise
+*/
+function hasNextNCommentsFrom(root, startIndex, count) {
+	if (startIndex < 0 || count <= 0) return false;
+	if (startIndex + count > root.children.length) return false;
+	for (let i = startIndex; i < startIndex + count; i++) if (!isCommentNode(root.children[i])) return false;
+	return true;
+}
+/**
+* Checks if the next N nodes from the current node are all comment nodes
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode} currentNode - The current node to find in the children array
+* @param {number} count - Number of nodes to check after the current node
+* @returns {boolean} true if the next N nodes are all comment nodes, false otherwise
+*/
+function hasNextNComments(root, currentNode, count) {
+	const currentIndex = root.children.indexOf(currentNode);
+	if (currentIndex === -1) return false;
+	return hasNextNCommentsFrom(root, currentIndex + 1, count);
+}
+/**
+* Checks if the previous N nodes from a given index are all comment nodes
+* @param {RootNode} root - The root node containing children
+* @param {number} startIndex - The starting index to check backwards from
+* @param {number} count - Number of nodes to check backwards
+* @returns {boolean} true if the previous N nodes are all comment nodes, false otherwise
+*/
+function hasPrevNCommentsFrom(root, startIndex, count) {
+	if (startIndex >= root.children.length || count <= 0) return false;
+	if (startIndex - count + 1 < 0) return false;
+	for (let i = startIndex - count + 1; i <= startIndex; i++) if (!isCommentNode(root.children[i])) return false;
+	return true;
+}
+/**
+* Checks if there are N consecutive nodes of a specific type starting from an index
+* @param {RootNode} root - The root node containing children
+* @param {number} startIndex - The starting index to check from
+* @param {number} count - Number of consecutive nodes to check
+* @param {ChildNode["type"]} nodeType - The type of node to check for ('comment', 'data', 'boundary', 'empty', 'unknown')
+* @returns {boolean} true if there are N consecutive nodes of the specified type, false otherwise
+*/
+function hasConsecutiveNodesOfType(root, startIndex, count, nodeType) {
+	if (startIndex < 0 || count <= 0) return false;
+	if (startIndex + count > root.children.length) return false;
+	const checker = NODE_TYPE_CHECKERS[nodeType];
+	if (!checker) return false;
+	for (let i = startIndex; i < startIndex + count; i++) if (!checker(root.children[i])) return false;
+	return true;
+}
+/**
+* Checks if the root contains a specific pattern of node types
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"][]} pattern - Array of node types that should appear consecutively
+* @param {number} [startIndex] - Optional starting index to check from
+* @returns {boolean} true if the pattern is found, false otherwise
+*/
+function hasNodePattern(root, pattern, startIndex = 0) {
+	if (pattern.length === 0) return true;
+	if (startIndex < 0 || startIndex + pattern.length > root.children.length) return false;
+	for (let i = 0; i < pattern.length; i++) {
+		const nodeIndex = startIndex + i;
+		const expectedType = pattern[i];
+		if (expectedType == null) throw new Error(`Invalid node type at index ${i} in pattern: ${JSON.stringify(pattern)}`);
+		const checker = NODE_TYPE_CHECKERS[expectedType];
+		if (!checker || !checker(root.children[nodeIndex])) return false;
+	}
+	return true;
+}
+/**
+* Finds the first occurrence of a node pattern in the root's children
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"][]} pattern - Array of node types to search for
+* @returns {number} The index of the first occurrence, or -1 if not found
+*/
+function findNodePattern(root, pattern) {
+	if (pattern.length === 0) return 0;
+	for (let i = 0; i <= root.children.length - pattern.length; i++) if (hasNodePattern(root, pattern, i)) return i;
+	return -1;
+}
+/**
+* Checks if the root starts with a specific sequence of node types
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"][]} sequence - Array of node types that should appear at the beginning
+* @returns {boolean} true if the root starts with the sequence, false otherwise
+*/
+function startsWithSequence(root, sequence) {
+	return hasNodePattern(root, sequence, 0);
+}
+/**
+* Checks if the root ends with a specific sequence of node types
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"][]} sequence - Array of node types that should appear at the end
+* @returns {boolean} true if the root ends with the sequence, false otherwise
+*/
+function endsWithSequence(root, sequence) {
+	if (sequence.length === 0) return true;
+	if (sequence.length > root.children.length) return false;
+	return hasNodePattern(root, sequence, root.children.length - sequence.length);
+}
+/**
+* Checks if there are at least N nodes of a specific type in the root
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"]} nodeType - The type of node to count
+* @param {number} minCount - Minimum number of nodes required
+* @returns {boolean} true if there are at least minCount nodes of the specified type
+*/
+function hasMinNodesOfType(root, nodeType, minCount) {
+	const checker = NODE_TYPE_CHECKERS[nodeType];
+	if (!checker) return false;
+	let count = 0;
+	for (const child of root.children) if (checker(child)) {
+		count++;
+		if (count >= minCount) return true;
+	}
+	return false;
+}
+/**
+* Checks if all nodes in the root are of a specific type
+* @param {RootNode} root - The root node containing children
+* @param {ChildNode["type"]} nodeType - The type of node to check for
+* @returns {boolean} true if all nodes are of the specified type, false otherwise
+*/
+function allNodesAreOfType(root, nodeType) {
+	if (root.children.length === 0) return false;
+	const checker = NODE_TYPE_CHECKERS[nodeType];
+	if (!checker) return false;
+	return root.children.every((child) => checker(child));
+}
+/**
+* Checks if the root contains only comment and empty nodes
+* @param {RootNode} root - The root node containing children
+* @returns {boolean} true if the root contains only comments and empty nodes
+*/
+function isCommentOnlyDocument(root) {
+	return root.children.every((child) => isCommentNode(child) || isEmptyNode(child));
+}
+/**
+* Checks if there's a boundary node within the next N nodes
+* @param {RootNode} root - The root node containing children
+* @param {number} startIndex - The starting index to check from
+* @param {number} lookAhead - Number of nodes to look ahead
+* @returns {boolean} true if a boundary node is found within the range
+*/
+function hasBoundaryWithinRange(root, startIndex, lookAhead) {
+	if (startIndex < 0 || lookAhead <= 0) return false;
+	const endIndex = Math.min(startIndex + lookAhead, root.children.length);
+	for (let i = startIndex; i < endIndex; i++) if (isBoundaryNode(root.children[i])) return true;
+	return false;
+}
+function visit(root, callback) {
+	if (!root || !root.children) return;
+	for (let i = 0; i < root.children.length; i++) {
+		const currentNode = root.children[i];
+		const nextNode = root.children[i + 1];
+		const prevNode = root.children[i - 1];
+		if (currentNode == null) throw new Error(`Node at index ${i} is null or undefined`);
+		callback({
+			settings: null,
+			currentNode,
+			nextNode,
+			prevNode
+		});
+	}
+}
+
+//#endregion
+//#region src/inference/heading-settings.ts
+const HEADING_SETTINGS_CONFIG = [];
+function getHeadingSettings(fileName, version) {
+	if (!fileName || !version) return null;
+	const entry = HEADING_SETTINGS_CONFIG.find((config) => config.fileName === fileName && config.version === version);
+	if (!entry) return null;
+	return entry.settings;
+}
+
+//#endregion
+//#region src/inference/heading.ts
+/**
+* Helper function to check if a node is a comment node or empty comment node
+*/
+function isAnyCommentNode(node) {
+	return isCommentNode(node) || isEmptyCommentNode(node) || isBoundaryNode(node);
+}
+function inferHeadingFromAST(root, settings) {
+	if (!root || !root.children || root.children.length === 0) return null;
+	let heading = null;
+	let isInHeading = false;
+	let headingEndNodeIndex = -1;
+	let shouldStop = false;
+	const nodes = root.children;
+	const { allowEmptyLines, allowMultipleBoundaries } = defu(settings ?? {}, getHeadingSettings(root.fileName, root.version) ?? {}, {
+		allowEmptyLines: true,
+		allowMultipleBoundaries: true
+	});
+	visit(root, (ctx) => {
+		const { currentNode, nextNode, prevNode } = ctx;
+		if (shouldStop) return;
+		const currentIndex = nodes.indexOf(currentNode);
+		const value = currentNode.value.trim();
+		if (isEOFMarker(currentNode.raw) || nextNode && isEOFMarker(nextNode.raw)) {
+			invariant(heading == null, "heading should be null");
+			shouldStop = true;
+		}
+		if (isEOFNode(currentNode)) {
+			invariant(heading == null, "heading should be null");
+			shouldStop = true;
+		}
+		if (shouldStop) return;
+		if (value.startsWith("@")) {
+			if (!(prevNode && isAnyCommentNode(prevNode)) || !nextNode || !isAnyCommentNode(nextNode)) {
+				headingEndNodeIndex = currentIndex;
+				shouldStop = true;
+			}
+		} else if (isAnyCommentNode(currentNode)) {
+			isInHeading = true;
+			if (heading == null) heading = "";
+			if (!heading && value === "#") {} else if (value.startsWith("# Property:")) {
+				headingEndNodeIndex = currentIndex;
+				shouldStop = true;
+			} else {
+				if (isBoundaryNode(currentNode)) {
+					if (!allowMultipleBoundaries) {
+						let hasPreviousBoundary = false;
+						for (let k = 0; k < currentIndex; k++) if (isBoundaryNode(nodes[k])) {
+							hasPreviousBoundary = true;
+							break;
+						}
+						if (hasPreviousBoundary) {
+							headingEndNodeIndex = currentIndex;
+							shouldStop = true;
+						}
+					}
+					if (!shouldStop) {
+						let j = currentIndex + 1;
+						let foundDataLine = false;
+						while (j < nodes.length && j < currentIndex + 5) {
+							const lookAheadNode = nodes[j];
+							if (!lookAheadNode || lookAheadNode.value.trim() === "#") {
+								j++;
+								continue;
+							}
+							const nextIsBoundary = isBoundaryNode(lookAheadNode);
+							const nextIsExample = isAnyCommentNode(lookAheadNode) && nodes[j + 1]?.value.trim().startsWith("@") && nodes[j + 2] && isAnyCommentNode(nodes[j + 2]);
+							const nextIsProperty = lookAheadNode.value.trim().startsWith("# Property:");
+							if (!nextIsBoundary && !nextIsExample && !nextIsProperty) foundDataLine = true;
+							break;
+						}
+						if (foundDataLine) {
+							headingEndNodeIndex = currentIndex + 2;
+							shouldStop = true;
+						}
+					}
+				}
+				if (!shouldStop) heading = `${heading}${currentNode.raw}\n`;
+			}
+		} else if (isEmptyNode(currentNode)) {
+			if (heading && nextNode && isAnyCommentNode(nextNode)) if (allowEmptyLines) heading = `${heading}${currentNode.raw}\n`;
+			else {
+				headingEndNodeIndex = currentIndex;
+				shouldStop = true;
+			}
+			else if (isInHeading) if (!allowEmptyLines) {
+				headingEndNodeIndex = currentIndex;
+				shouldStop = true;
+			} else {
+				let hasMoreComments = false;
+				for (let j = currentIndex + 1; j < nodes.length && j < currentIndex + 5; j++) {
+					const lookAheadNode = nodes[j];
+					const nextValue = lookAheadNode?.value.trim();
+					if (nextValue !== "" && !isAnyCommentNode(lookAheadNode)) {
+						headingEndNodeIndex = currentIndex;
+						shouldStop = true;
+						break;
+					}
+					if (isAnyCommentNode(lookAheadNode) && nextValue !== "#") {
+						if (nextValue?.startsWith("# Property:")) break;
+						hasMoreComments = true;
+						break;
+					}
+				}
+				if (!shouldStop) if (hasMoreComments) heading = `${heading}${currentNode.raw}\n`;
+				else {
+					headingEndNodeIndex = currentIndex;
+					shouldStop = true;
+				}
+			}
+		} else if (isInHeading) {
+			headingEndNodeIndex = currentIndex;
+			shouldStop = true;
+		}
+	});
+	if (headingEndNodeIndex !== -1) {
+		let endNodesWithoutEmpty = headingEndNodeIndex;
+		if (allowMultipleBoundaries) {
+			let lastBoundaryNodeIndex = -1;
+			for (let i = 0; i <= endNodesWithoutEmpty; i++) if (isBoundaryNode(nodes[i])) lastBoundaryNodeIndex = i;
+			if (lastBoundaryNodeIndex !== -1) endNodesWithoutEmpty = lastBoundaryNodeIndex + 1;
+		}
+		if (allowEmptyLines) while (endNodesWithoutEmpty > 0) {
+			const prevNode = nodes[endNodesWithoutEmpty - 1];
+			const prevValue = prevNode?.value.trim();
+			if (prevValue !== "" && prevValue !== "#" && !isEmptyCommentNode(prevNode)) break;
+			endNodesWithoutEmpty--;
+		}
+		else while (endNodesWithoutEmpty > 0) {
+			const prevNode = nodes[endNodesWithoutEmpty - 1];
+			if (!isEmptyCommentNode(prevNode)) break;
+			endNodesWithoutEmpty--;
+		}
+		heading = `${nodes.slice(0, endNodesWithoutEmpty).map((node) => node.raw).join("\n")}\n`;
+	}
+	return heading;
+}
+
+//#endregion
+//#region src/datafile/parser.ts
+/**
+* Creates a node object from a single line of a data file.
+*
+* This function analyzes the given line and converts it to the appropriate
+* DataFileChildNode type (Empty, Boundary, Comment, Data, or Unknown)
+* based on the line's content and structure.
+*
+* @param {string} line - The text line to parse into a node
+* @param {number} lineNumber - The line number in the original file (0-based index)
+* @returns {ChildNode} A node object representing the parsed line
+*/
+function createNode(line, lineNumber) {
+	const trimmedLine = line.trim();
+	if (isEmptyLine(line)) return {
+		type: NodeTypes.EMPTY,
+		value: "",
+		raw: line,
+		line: lineNumber
+	};
+	if (isBoundaryLine(line)) {
+		let style;
+		try {
+			style = getBoundaryLineStyle(line);
+		} catch {
+			return {
+				type: NodeTypes.UNKNOWN,
+				value: trimmedLine,
+				raw: line,
+				line: lineNumber
+			};
+		}
+		return {
+			type: NodeTypes.BOUNDARY,
+			value: trimmedLine,
+			raw: line,
+			line: lineNumber,
+			style
+		};
+	}
+	if (isEOFMarker(line)) return {
+		type: NodeTypes.EOF,
+		value: trimmedLine,
+		raw: line,
+		line: lineNumber
+	};
+	if (isPropertyLine(line)) return {
+		type: NodeTypes.PROPERTY,
+		value: trimmedLine,
+		raw: line,
+		line: lineNumber,
+		propertyValue: getPropertyValue(trimmedLine)
+	};
+	if (isCommentLine(line)) {
+		const trimmedComment = trimCommentLine(line);
+		return {
+			type: trimmedComment === "" ? NodeTypes.EMPTY_COMMENT : NodeTypes.COMMENT,
+			value: trimmedComment,
+			raw: line,
+			line: lineNumber
+		};
+	}
+	if (isLineWithData(line)) return {
+		type: NodeTypes.DATA,
+		value: trimmedLine,
+		raw: line,
+		line: lineNumber
+	};
+	/* v8 ignore next 7 */
+	return {
+		type: NodeTypes.UNKNOWN,
+		value: trimmedLine,
+		raw: line,
+		line: lineNumber
+	};
+}
+/**
+* Parses a data file content string into a structured DataFileRootNode object.
+*
+* This function splits the content by line breaks, processes each line into
+* appropriate node types (Empty, Boundary, Comment, Data, or Unknown), and
+* assembles them into a root node with metadata.
+*
+* @param {string} content - The full content of the data file to parse
+* @param {string} [fileName] - Optional explicit file name. If not provided, will be inferred from content
+* @returns {RootNode} A structured representation of the data file
+*/
+function parseDataFileIntoAst(content, fileName) {
+	const children = content.split(/\r?\n/).map((line, index) => createNode(line, index));
+	return {
+		type: NodeTypes.ROOT,
+		value: "",
+		raw: content,
+		line: 0,
+		children,
+		fileName: fileName ?? inferFileName(content),
+		version: inferVersion(content)
+	};
+}
+
+//#endregion
+//#region src/datafile/sections.ts
+/**
+* Determines whether the given Unicode data file content contains sections.
+*
+* Sections in Unicode data files are typically delimited by special comment
+* patterns and contain related data grouped together.
+*
+* @param {string} content - The Unicode data file content to check
+* @returns {boolean} True if the content contains sections, false otherwise
+*
+* @example
+* ```ts
+* const fileContent = "# Section 1\ndata1\n\n# Section 2\ndata2";
+* const hasFileSections = hasSections(fileContent); // true
+* ```
+*/
+function hasSections(content) {
+	if (!content) return false;
+	return parseSections(content).size > 0;
+}
+/**
+* Parses Unicode data file content into sections.
+*
+* This function divides the file content into logical sections based on comment blocks
+* followed by data lines. Each section consists of a name (the first comment line),
+* a description (subsequent comment lines), and associated data lines.
+*
+* The function handles various formatting patterns found in Unicode data files,
+* including handling of empty lines, consecutive comments, and section boundaries.
+*
+* @param {string} content - The Unicode data file content to parse
+* @returns {Map<string, UCDSectionWithLines>} A map where keys are section names and
+*                                            values are objects containing the
+*                                            section description and associated data lines
+*
+* @example
+* ```ts
+* const content = `# Section 1
+* # Description of section 1
+* data1
+* data2
+*
+* # Section 2
+* # Description of section 2
+* data3
+* data4`;
+*
+* const sections = parseSections(content);
+* // sections will contain two entries:
+* // "Section 1" -> { description: "Description of section 1", lines: ["data1", "data2"] }
+* // "Section 2" -> { description: "Description of section 2", lines: ["data3", "data4"] }
+* ```
+*/
+function parseSections(content) {
+	const sections = /* @__PURE__ */ new Map();
+	if (!content) return sections;
+	const lines = content.split("\n");
+	let currentSection = null;
+	let currentDescription = "";
+	let currentLines = [];
+	let pendingComments = [];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line == null) continue;
+		if (isEmptyLine(line)) {
+			let nextNonEmptyIsData = false;
+			for (let j = i + 1; j < lines.length; j++) {
+				const lineJ = lines[j];
+				if (lineJ == null) continue;
+				if (!isEmptyLine(lineJ)) {
+					nextNonEmptyIsData = !isCommentLine(lineJ);
+					break;
+				}
+			}
+			if (!nextNonEmptyIsData) pendingComments = [];
+			continue;
+		}
+		if (isCommentLine(line)) {
+			if (isBoundaryLine(line)) continue;
+			pendingComments.push(line.replace(/^#\s*/, ""));
+		} else if (pendingComments.length > 0) {
+			if (currentSection !== null) sections.set(currentSection, {
+				description: currentDescription,
+				lines: currentLines
+			});
+			currentSection = pendingComments[0];
+			currentDescription = pendingComments.slice(1).join("\n");
+			currentLines = [line];
+			pendingComments = [];
+		} else if (currentSection !== null) currentLines.push(line);
+	}
+	if (currentSection !== null) sections.set(currentSection, {
+		description: currentDescription,
+		lines: currentLines
+	});
+	return sections;
+}
+
+//#endregion
+//#region src/datafile/model.ts
+/**
+* Represents a raw Unicode data file with methods to access its content.
+*
+* This class parses and provides access to various components of Unicode data files,
+* including the raw content, individual lines, file metadata (like heading, version),
+* and determines if the file has an EOF marker.
+*
+* @example
+* ```ts
+* // Create a RawDataFile from a string content
+* const content = "# UnicodeData-14.0.0.txt\n# Some Unicode data\n\nU+0020;SPACE\n# EOF";
+* const dataFile = new RawDataFile(content);
+*
+* // Access file properties
+* console.log(dataFile.fileName); // "UnicodeData"
+* console.log(dataFile.version);  // "14.0.0"
+* console.log(dataFile.hasEOF);   // true
+* console.log(dataFile.heading);  // "# UnicodeData-14.0.0.txt\n# Some Unicode data"
+* ```
+*/
+var RawDataFile = class {
+	/** The content includes everything */
+	rawContent = "";
+	/**
+	* The content without the heading section.
+	*
+	* NOTE:
+	* If we couldn't find a heading, this will be the same as `rawContent`.
+	*/
+	content = "";
+	/** The lines of the content, will not include the heading */
+	lines = [];
+	heading = null;
+	/**
+	* The AST representation of the data file.
+	* This is typically used for further processing or analysis of the file structure.
+	* If the file is not parsed into an AST, this will be undefined.
+	*/
+	ast = void 0;
+	sections = /* @__PURE__ */ new Map();
+	/**
+	* The name of the file, if available.
+	* This is typically extracted from the first line of the file.
+	* It may not always be present, especially if the file is empty or malformed.
+	*/
+	fileName = void 0;
+	/**
+	* The version of the file, if available.
+	* This is typically extracted from the first line of the file.
+	*/
+	version = void 0;
+	/**
+	* Indicates if the file has an EOF marker.
+	* This is typically used to indicate the end of the file in Unicode data files.
+	*/
+	hasEOF = false;
+	constructor(content, fileName) {
+		if (content == null || content.trim() === "") throw new Error("content is empty");
+		this.ast = parseDataFileIntoAst(content, fileName);
+		this.rawContent = this.content = content;
+		this.heading = inferHeadingFromAST(this.ast);
+		if (this.heading != null) this.content = content.replace(this.heading, "").trim();
+		this.lines = this.content.split("\n");
+		this.fileName = fileName ?? this.ast.fileName;
+		this.version = this.ast.version;
+		this.hasEOF = isEOFMarker(this.lines.at(-1));
+		this.sections = parseSections(this.content);
+	}
+};
+
+//#endregion
+export { isUnknownNode as _, HEADING_SETTINGS_CONFIG as a, isBoundaryNode as c, isEOFNode as d, isEmptyCommentNode as f, isRootNode as g, isPropertyNode as h, inferHeadingFromAST as i, isCommentNode as l, isNode as m, hasSections as n, getHeadingSettings as o, isEmptyNode as p, parseSections as r, ast_utils_exports as s, RawDataFile as t, isDataNode as u, NodeTypes as v };