@unicode-utils/parser 0.12.0-beta.17

package/dist/datafile-D70biLnW.d.ts

@@ -0,0 +1,495 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { t as BoundaryStyle } from "./line-helpers-upUikru9.js";
+
+//#region src/datafile/ast.d.ts
+declare const NodeTypes: {
+  readonly ROOT: "root";
+  readonly COMMENT: "comment";
+  readonly EMPTY_COMMENT: "empty-comment";
+  readonly BOUNDARY: "boundary";
+  readonly DATA: "data";
+  readonly EMPTY: "empty";
+  readonly EOF: "eof";
+  readonly PROPERTY: "property";
+  readonly UNKNOWN: "unknown";
+};
+type NodeType = typeof NodeTypes[keyof typeof NodeTypes];
+interface BaseNode {
+  type: NodeType;
+  value: string;
+  raw: string;
+  line: number;
+}
+interface RootNode extends BaseNode {
+  type: "root";
+  children: ChildNode[];
+  fileName?: string;
+  version?: string;
+}
+interface PropertyNode extends BaseNode {
+  type: "property";
+  propertyValue: string | undefined;
+}
+interface CommentNode extends BaseNode {
+  type: "comment";
+}
+interface EmptyCommentNode extends BaseNode {
+  type: "empty-comment";
+}
+interface BoundaryNode extends BaseNode {
+  type: "boundary";
+  style: BoundaryStyle;
+}
+interface DataNode extends BaseNode {
+  type: "data";
+}
+interface EmptyNode extends BaseNode {
+  type: "empty";
+}
+interface EOFNode extends BaseNode {
+  type: "eof";
+}
+interface UnknownNode extends BaseNode {
+  type: "unknown";
+  [key: Exclude<string, keyof BaseNode | "type">]: unknown;
+}
+type ChildNode = CommentNode | EmptyCommentNode | BoundaryNode | DataNode | EmptyNode | EOFNode | PropertyNode | UnknownNode;
+type Node = RootNode | ChildNode;
+declare namespace ast_utils_d_exports {
+  export { VisitCallback, VisitContext, allNodesAreOfType, endsWithSequence, findNodePattern, hasBoundaryWithinRange, hasConsecutiveNodesOfType, hasMinNodesOfType, hasNextNComments, hasNextNCommentsFrom, hasNodePattern, hasPrevNCommentsFrom, isCommentOnlyDocument, startsWithSequence, visit };
+}
+/**
+ * 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
+ */
+declare function hasNextNCommentsFrom(root: RootNode, startIndex: number, count: number): boolean;
+/**
+ * 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
+ */
+declare function hasNextNComments(root: RootNode, currentNode: ChildNode, count: number): boolean;
+/**
+ * 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
+ */
+declare function hasPrevNCommentsFrom(root: RootNode, startIndex: number, count: number): boolean;
+/**
+ * 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
+ */
+declare function hasConsecutiveNodesOfType(root: RootNode, startIndex: number, count: number, nodeType: ChildNode["type"]): boolean;
+/**
+ * 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
+ */
+declare function hasNodePattern(root: RootNode, pattern: ChildNode["type"][], startIndex?: number): boolean;
+/**
+ * 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
+ */
+declare function findNodePattern(root: RootNode, pattern: ChildNode["type"][]): number;
+/**
+ * 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
+ */
+declare function startsWithSequence(root: RootNode, sequence: ChildNode["type"][]): boolean;
+/**
+ * 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
+ */
+declare function endsWithSequence(root: RootNode, sequence: ChildNode["type"][]): boolean;
+/**
+ * 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
+ */
+declare function hasMinNodesOfType(root: RootNode, nodeType: ChildNode["type"], minCount: number): boolean;
+/**
+ * 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
+ */
+declare function allNodesAreOfType(root: RootNode, nodeType: ChildNode["type"]): boolean;
+/**
+ * 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
+ */
+declare function isCommentOnlyDocument(root: RootNode): boolean;
+/**
+ * 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
+ */
+declare function hasBoundaryWithinRange(root: RootNode, startIndex: number, lookAhead: number): boolean;
+interface VisitContext {
+  settings: any;
+  currentNode: ChildNode;
+  nextNode?: ChildNode;
+  prevNode?: ChildNode;
+}
+type VisitCallback = (ctx: VisitContext) => void;
+declare function visit(root: RootNode, callback: VisitCallback): void;
+//#endregion
+//#region src/datafile/sections.d.ts
+interface UCDSectionWithLines {
+  description: string;
+  lines: string[];
+}
+/**
+ * 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
+ * ```
+ */
+declare function hasSections(content: string): boolean;
+/**
+ * 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"] }
+ * ```
+ */
+declare function parseSections(content: string): Map<string, UCDSectionWithLines>;
+//#endregion
+//#region src/datafile/model.d.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"
+ * ```
+ */
+declare class RawDataFile {
+  /** The content includes everything */
+  readonly rawContent: string;
+  /**
+   * The content without the heading section.
+   *
+   * NOTE:
+   * If we couldn't find a heading, this will be the same as `rawContent`.
+   */
+  readonly content: string;
+  /** The lines of the content, will not include the heading */
+  readonly lines: string[];
+  readonly heading: string | 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.
+   */
+  readonly ast: RootNode | undefined;
+  readonly sections: Map<string, UCDSectionWithLines>;
+  /**
+   * 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.
+   */
+  readonly fileName: string | undefined;
+  /**
+   * The version of the file, if available.
+   * This is typically extracted from the first line of the file.
+   */
+  readonly version: string | undefined;
+  /**
+   * Indicates if the file has an EOF marker.
+   * This is typically used to indicate the end of the file in Unicode data files.
+   */
+  readonly hasEOF: boolean;
+  constructor(content: string, fileName?: string);
+}
+//#endregion
+//#region src/datafile/typeguards.d.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}`);
+ * }
+ * ```
+ */
+declare function isNode(node: unknown): node is Node;
+/**
+ * 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"
+ * }
+ * ```
+ */
+declare function isCommentNode(node: unknown): node is CommentNode;
+/**
+ * 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}"`); // ""
+ * }
+ * ```
+ */
+declare function isEmptyCommentNode(node: unknown): node is EmptyCommentNode;
+/**
+ * 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}`); // "# ================================================"
+ * }
+ * ```
+ */
+declare function isBoundaryNode(node: unknown): node is BoundaryNode;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isDataNode(node: unknown): node is DataNode;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isEmptyNode(node: unknown): node is EmptyNode;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isRootNode(node: unknown): node is RootNode;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isUnknownNode(node: unknown): node is UnknownNode;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isEOFNode(node: unknown): node is EOFNode;
+/**
+ * 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"
+ * }
+ * ```
+ */
+declare function isPropertyNode(node: unknown): node is PropertyNode;
+//#endregion
+export { EmptyNode as C, PropertyNode as D, NodeTypes as E, RootNode as O, EmptyCommentNode as S, NodeType as T, BoundaryNode as _, isEmptyCommentNode as a, DataNode as b, isPropertyNode as c, RawDataFile as d, UCDSectionWithLines as f, BaseNode as g, ast_utils_d_exports as h, isEOFNode as i, UnknownNode as k, isRootNode as l, parseSections as m, isCommentNode as n, isEmptyNode as o, hasSections as p, isDataNode as r, isNode as s, isBoundaryNode as t, isUnknownNode as u, ChildNode as v, Node as w, EOFNode as x, CommentNode as y };

package/dist/datafile.d.ts

@@ -0,0 +1,3 @@
+import "./line-helpers-upUikru9.js";
+import { C as EmptyNode, D as PropertyNode, E as NodeTypes, O as RootNode, S as EmptyCommentNode, T as NodeType, _ as BoundaryNode, a as isEmptyCommentNode, b as DataNode, c as isPropertyNode, d as RawDataFile, f as UCDSectionWithLines, g as BaseNode, h as ast_utils_d_exports, i as isEOFNode, k as UnknownNode, l as isRootNode, m as parseSections, n as isCommentNode, o as isEmptyNode, p as hasSections, r as isDataNode, s as isNode, t as isBoundaryNode, u as isUnknownNode, v as ChildNode, w as Node, x as EOFNode, y as CommentNode } from "./datafile-D70biLnW.js";
+export { BaseNode, BoundaryNode, ChildNode, CommentNode, DataNode, EOFNode, EmptyCommentNode, EmptyNode, Node, NodeType, NodeTypes, PropertyNode, RawDataFile, RootNode, UCDSectionWithLines, UnknownNode, ast_utils_d_exports as astUtils, hasSections, isBoundaryNode, isCommentNode, isDataNode, isEOFNode, isEmptyCommentNode, isEmptyNode, isNode, isPropertyNode, isRootNode, isUnknownNode, parseSections };

package/dist/datafile.js

@@ -0,0 +1,4 @@
+import { _ as isUnknownNode, c as isBoundaryNode, d as isEOFNode, f as isEmptyCommentNode, g as isRootNode, h as isPropertyNode, l as isCommentNode, m as isNode, n as hasSections, p as isEmptyNode, r as parseSections, s as ast_utils_exports, t as RawDataFile, u as isDataNode, v as NodeTypes } from "./datafile-B9Fta4dI.js";
+import "./line-helpers-tsCF16UF.js";
+
+export { NodeTypes, RawDataFile, ast_utils_exports as astUtils, hasSections, isBoundaryNode, isCommentNode, isDataNode, isEOFNode, isEmptyCommentNode, isEmptyNode, isNode, isPropertyNode, isRootNode, isUnknownNode, parseSections };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { _ as isMissingAnnotation, a as getBoundaryLineStyle, b as parseMissingAnnotation, c as inferVersion, d as isDashBoundary, f as isEOFMarker, g as isLineWithData, h as isHashBoundary, i as SpecialTag, l as isBoundaryLine, m as isEqualsBoundary, n as MissingAnnotation, o as getPropertyValue, p as isEmptyLine, r as ParsedFileName, s as inferFileName, t as BoundaryStyle, u as isCommentLine, v as isPropertyLine, x as trimCommentLine, y as parseFileNameLine } from "./line-helpers-upUikru9.js";
+import { C as EmptyNode, D as PropertyNode, E as NodeTypes, O as RootNode, S as EmptyCommentNode, T as NodeType, _ as BoundaryNode, a as isEmptyCommentNode, b as DataNode, c as isPropertyNode, d as RawDataFile, f as UCDSectionWithLines, g as BaseNode, h as ast_utils_d_exports, i as isEOFNode, k as UnknownNode, l as isRootNode, m as parseSections, n as isCommentNode, o as isEmptyNode, p as hasSections, r as isDataNode, s as isNode, t as isBoundaryNode, u as isUnknownNode, v as ChildNode, w as Node, x as EOFNode, y as CommentNode } from "./datafile-D70biLnW.js";
+
+//#region src/inference/heading.d.ts
+interface InferHeadingSettings {
+  /**
+   * Whether to allow empty lines between heading lines.
+   * When false, any empty line will mark the end of the heading.
+   * @default true
+   */
+  allowEmptyLines?: boolean;
+  /**
+   * Whether to allow multiple boundary lines in the heading.
+   * When false, only the last boundary line will be included.
+   * @default true
+   */
+  allowMultipleBoundaries?: boolean;
+}
+declare function inferHeadingFromAST(root: RootNode, settings?: InferHeadingSettings): string | null;
+//#endregion
+//#region src/inference/heading-settings.d.ts
+interface DataFileSettingsEntry {
+  /**
+   * The fileName this configuration applies to.
+   */
+  fileName: string;
+  /**
+   * The version of Unicode this configuration applies to.
+   */
+  version: string;
+  /**
+   * The settings to use for inferring headings in this file.
+   */
+  settings: InferHeadingSettings;
+}
+declare const HEADING_SETTINGS_CONFIG: DataFileSettingsEntry[];
+declare function getHeadingSettings(fileName?: string, version?: string): InferHeadingSettings | null;
+//#endregion
+export { BaseNode, BoundaryNode, BoundaryStyle, ChildNode, CommentNode, type DataFileSettingsEntry, DataNode, EOFNode, EmptyCommentNode, EmptyNode, HEADING_SETTINGS_CONFIG, type InferHeadingSettings, MissingAnnotation, Node, NodeType, NodeTypes, ParsedFileName, PropertyNode, RawDataFile, RootNode, SpecialTag, UCDSectionWithLines, UnknownNode, ast_utils_d_exports as astUtils, getBoundaryLineStyle, getHeadingSettings, getPropertyValue, hasSections, inferFileName, inferHeadingFromAST, inferVersion, isBoundaryLine, isBoundaryNode, isCommentLine, isCommentNode, isDashBoundary, isDataNode, isEOFMarker, isEOFNode, isEmptyCommentNode, isEmptyLine, isEmptyNode, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isNode, isPropertyLine, isPropertyNode, isRootNode, isUnknownNode, parseFileNameLine, parseMissingAnnotation, parseSections, trimCommentLine };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { _ as isUnknownNode, a as HEADING_SETTINGS_CONFIG, c as isBoundaryNode, d as isEOFNode, f as isEmptyCommentNode, g as isRootNode, h as isPropertyNode, i as inferHeadingFromAST, l as isCommentNode, m as isNode, n as hasSections, o as getHeadingSettings, p as isEmptyNode, r as parseSections, s as ast_utils_exports, t as RawDataFile, u as isDataNode, v as NodeTypes } from "./datafile-B9Fta4dI.js";
+import { _ as trimCommentLine, a as isBoundaryLine, c as isEOFMarker, d as isHashBoundary, f as isLineWithData, g as parseMissingAnnotation, h as parseFileNameLine, i as inferVersion, l as isEmptyLine, m as isPropertyLine, n as getPropertyValue, o as isCommentLine, p as isMissingAnnotation, r as inferFileName, s as isDashBoundary, t as getBoundaryLineStyle, u as isEqualsBoundary } from "./line-helpers-tsCF16UF.js";
+
+export { HEADING_SETTINGS_CONFIG, NodeTypes, RawDataFile, ast_utils_exports as astUtils, getBoundaryLineStyle, getHeadingSettings, getPropertyValue, hasSections, inferFileName, inferHeadingFromAST, inferVersion, isBoundaryLine, isBoundaryNode, isCommentLine, isCommentNode, isDashBoundary, isDataNode, isEOFMarker, isEOFNode, isEmptyCommentNode, isEmptyLine, isEmptyNode, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isNode, isPropertyLine, isPropertyNode, isRootNode, isUnknownNode, parseFileNameLine, parseMissingAnnotation, parseSections, trimCommentLine };