@unicode-utils/core 0.12.0-beta.15

package/dist/datafile-UqVC4xXw.d.ts

@@ -0,0 +1,495 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { t as BoundaryStyle } from "./line-helpers-DGsVuiW2.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: string]: 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-DGsVuiW2.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-UqVC4xXw.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 { a as isBoundaryNode, c as isEOFNode, d as isNode, f as isPropertyNode, h as NodeTypes, i as ast_utils_exports, l as isEmptyCommentNode, m as isUnknownNode, n as hasSections, o as isCommentNode, p as isRootNode, r as parseSections, s as isDataNode, t as RawDataFile, u as isEmptyNode } from "./datafile-CWbGVIAa.js";
+import "./line-helpers-CYDQ0FnQ.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,153 @@
+import { i as UnicodeVersionMetadata, n as UNICODE_STABLE_VERSION, r as UNICODE_VERSION_METADATA, t as UNICODE_DRAFT_VERSION } from "./constants-BclbCHPC.js";
+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-DGsVuiW2.js";
+import { d as RawDataFile } from "./datafile-UqVC4xXw.js";
+
+//#region src/draft.d.ts
+interface GetCurrentDraftVersionOptions {
+  /**
+   * Custom URL to fetch the Unicode draft ReadMe from
+   * @default "https://unicode-proxy.ucdjs.dev/draft/ReadMe.txt"
+   */
+  url?: string;
+  /**
+   * Custom fetch options to use when fetching the ReadMe
+   */
+  fetchOptions?: RequestInit;
+  /**
+   * Custom regex patterns to use for extracting the version
+   * Each pattern must include exactly one capturing group that matches the version
+   */
+  patterns?: RegExp[];
+}
+/**
+ * Retrieves the current Unicode Standard draft version by fetching and parsing
+ * the Unicode draft ReadMe file.
+ *
+ * The function tries to extract the version number using several regex patterns,
+ * starting with the most explicit match and falling back to less specific patterns.
+ *
+ * @param {GetCurrentDraftVersionOptions} options - Configuration options for the function
+ * @returns {Promise<string | null>} A promise that resolves to:
+ * - The Unicode draft version as a string (e.g., "15.1.0" or "15.1")
+ * - `null` if the version couldn't be determined or if an error occurred during fetching
+ *
+ * @example
+ * ```ts
+ * // Using default options
+ * const version = await getCurrentDraftVersion();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using custom options
+ * const version = await getCurrentDraftVersion({
+ *   url: "https://luxass.dev/readme",
+ *   patterns: [/MyCustomPattern-(\d+\.\d+)/],
+ *   fetchOptions: { headers: { "Authorization": "token" } }
+ * });
+ * ```
+ */
+declare function getCurrentDraftVersion(options?: GetCurrentDraftVersionOptions): Promise<string | null>;
+//#endregion
+//#region src/hexcodes.d.ts
+/**
+ * Converts a hex string to an array of unicode codepoints.
+ *
+ * @param {string} hex - The hexadecimal string to convert
+ * @param {string} joiner - The string that separates the hex values
+ * @param {boolean} strict - If true, throws errors for invalid input. If false, returns NaN for invalid parts.
+ * @returns {number[]} An array of numbers representing unicode codepoints
+ *
+ * @example
+ * ```ts
+ * fromHexToCodepoint('1F600-1F64F', '-') // [128512, 128591]
+ * fromHexToCodepoint('1F600,1F64F', ',') // [128512, 128591]
+ * fromHexToCodepoint('1F600-', '-', true) // throws Error
+ * fromHexToCodepoint('1F600-', '-', false) // [128512, NaN]
+ * ```
+ */
+declare function fromHexToCodepoint(hex: string, joiner: string, strict?: boolean): number[];
+/**
+ * Expands a hexadecimal range into an array of individual hexadecimal values.
+ * If the input contains ".." it treats it as a range and expands it,
+ * otherwise returns the input hex as a single-element array.
+ *
+ * @param {string} hex - The hexadecimal string, optionally containing ".." to denote a range
+ * @returns {string[]} An array of hexadecimal strings. If given a range (e.g. "0000..0010"),
+ *          returns all values in that range. If given a single hex value,
+ *          returns an array containing just that value.
+ *
+ * @example
+ * ```ts
+ * expandHexRange("0000..0002") // Returns ["0000", "0001", "0002"]
+ * expandHexRange("0000") // Returns ["0000"]
+ * ```
+ */
+declare function expandHexRange(hex: string): string[];
+/**
+ * Removes specific unicode variation selectors from a hex string.
+ * Specifically removes:
+ * - 200D (Zero Width Joiner)
+ * - FE0E (Variation Selector-15, text style)
+ * - FE0F (Variation Selector-16, emoji style)
+ *
+ * @param {string} hex - The hex string to strip variation selectors from
+ * @returns {string} The hex string with variation selectors removed
+ */
+declare function stripHex(hex: string): string;
+//#endregion
+//#region src/mappings.d.ts
+/**
+ * Maps Unicode standard version numbers to their corresponding UCD (Unicode Character Database) version identifiers.
+ *
+ * The Unicode Character Database (UCD) files are available at https://unicode.org/Public/{version}
+ * where {version} is not always the same as the Unicode standard version.
+ *
+ * For example:
+ * - Unicode 4.0.1 corresponds to UCD version "4.0-Update1"
+ * - Unicode 2.1.9 corresponds to UCD version "2.1-Update4"
+ *
+ * Note: Only versions with special UCD paths are included here.
+ * Versions 4.1.0 and later use their version number directly as the UCD path.
+ */
+declare const UNICODE_TO_UCD_VERSION_MAPPINGS: Record<string, string>;
+/**
+ * Resolves a Unicode version to its corresponding UCD (Unicode Character Database) version identifier.
+ *
+ * Some Unicode versions don't have directly corresponding UCD version identifiers. For example,
+ * Unicode 4.0.1's files are found using UCD version '4.0-Update1'
+ * rather than '4.0.1'.
+ *
+ * If the version is not found in the mappings, returns the original version.
+ * This is useful for handling newer Unicode versions that use the version number directly.
+ *
+ * @param {string} unicodeVersion - The Unicode version to resolve to a UCD version identifier
+ * @returns {string} The corresponding UCD version identifier or the original version if not mapped
+ */
+declare function resolveUCDVersion(unicodeVersion: string): string;
+//#endregion
+//#region src/path.d.ts
+/**
+ * Builds file paths for Unicode Character Database (UCD) files
+ *
+ * @param {string} version - The Unicode version (e.g., "15.1.0")
+ * @param {string} path - The filename to access (e.g., "PropList.txt", "DerivedLineBreak.txt")
+ * @returns {string} The complete file path for the UCD file
+ */
+declare function buildUCDPath(version: string, path: string): string;
+/**
+ * Determines whether a Unicode version has the UCD folder structure.
+ *
+ * Newer Unicode versions typically use a UCD subfolder structure, while older versions
+ * use special version formats (like '4.0-Update1' instead of '4.0.1') without UCD folders.
+ * This function checks if a version:
+ * 1. Contains "Update" in its name (indicating no UCD folder structure)
+ * 2. Exists in our UNICODE_TO_UCD_VERSION_MAPPINGS (meaning it doesn't use UCD folders)
+ *
+ * @param {string} version - The Unicode version string to check
+ * @returns {boolean} - Returns true if the version uses UCD folder structure (e.g., '15.0.0'),
+ *                      false if it doesn't use UCD folders (e.g., '4.0.1' uses '4.0-Update1')
+ */
+declare function hasUCDFolderPath(version: string): boolean;
+//#endregion
+export { BoundaryStyle, type GetCurrentDraftVersionOptions, MissingAnnotation, ParsedFileName, RawDataFile, SpecialTag, UNICODE_DRAFT_VERSION, UNICODE_STABLE_VERSION, UNICODE_TO_UCD_VERSION_MAPPINGS, UNICODE_VERSION_METADATA, type UnicodeVersionMetadata, buildUCDPath, expandHexRange, fromHexToCodepoint, getBoundaryLineStyle, getCurrentDraftVersion, getPropertyValue, hasUCDFolderPath, inferFileName, inferVersion, isBoundaryLine, isCommentLine, isDashBoundary, isEOFMarker, isEmptyLine, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isPropertyLine, parseFileNameLine, parseMissingAnnotation, resolveUCDVersion, stripHex, trimCommentLine };