@unicode-utils/core 0.12.0-beta.15

package/dist/index.js

@@ -0,0 +1,216 @@
+import { n as UNICODE_STABLE_VERSION, r as UNICODE_VERSION_METADATA, t as UNICODE_DRAFT_VERSION } from "./constants-DygWVxzp.js";
+import { t as RawDataFile } from "./datafile-CWbGVIAa.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-CYDQ0FnQ.js";
+
+//#region src/draft.ts
+/**
+* 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" } }
+* });
+* ```
+*/
+async function getCurrentDraftVersion(options = {}) {
+	const { url = "https://unicode-proxy.ucdjs.dev/draft/ReadMe.txt", fetchOptions = {}, patterns = [
+		/Version (\d+\.\d+(?:\.\d+)?) of the Unicode Standard/,
+		/Unicode(\d+\.\d+(?:\.\d+)?)/,
+		/Version (\d+\.\d+)(?!\.\d)/
+	] } = options;
+	try {
+		const res = await fetch(url, fetchOptions);
+		if (!res.ok) throw new Error("failed to fetch draft ReadMe");
+		const text = await res.text();
+		for (const pattern of patterns) {
+			const match = text.match(pattern);
+			if (match == null || match[1] == null) continue;
+			return match[1];
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/hexcodes.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]
+* ```
+*/
+function fromHexToCodepoint(hex, joiner, strict = false) {
+	if (strict) {
+		if (typeof hex !== "string" || typeof joiner !== "string") throw new TypeError("Both hex and joiner must be strings");
+		if (hex.trim() === "") throw new Error("Hex string cannot be empty");
+	}
+	const hexParts = hex.split(joiner);
+	const codepoints = [];
+	for (const part of hexParts) {
+		const trimmedPart = part.trim();
+		if (strict && trimmedPart === "") throw new Error("Empty hex part found");
+		if (strict && !/^[0-9a-f]+$/i.test(trimmedPart)) throw new Error(`Invalid hex format: "${trimmedPart}"`);
+		const codepoint = Number.parseInt(trimmedPart, 16);
+		if (strict && Number.isNaN(codepoint)) throw new Error(`Failed to parse hex value: "${trimmedPart}"`);
+		if (strict && codepoint > 1114111) throw new Error(`Invalid Unicode codepoint: ${codepoint.toString(16).toUpperCase()} (exceeds U+10FFFF)`);
+		codepoints.push(codepoint);
+	}
+	return codepoints;
+}
+/**
+* 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"]
+* ```
+*/
+function expandHexRange(hex) {
+	if (hex.includes("..")) {
+		const [start, end] = fromHexToCodepoint(hex, "..");
+		if (start == null || Number.isNaN(start) || end == null || Number.isNaN(end)) return [];
+		const points = [];
+		for (let codepoint = start; codepoint <= end; codepoint++) points.push(codepoint.toString(16).padStart(4, "0").toUpperCase());
+		return points;
+	}
+	return [hex];
+}
+/**
+* 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
+*/
+function stripHex(hex) {
+	return hex.replace(/[-\s]?(?:200D|FE0E|FE0F)/g, "");
+}
+
+//#endregion
+//#region src/mappings.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.
+*/
+const UNICODE_TO_UCD_VERSION_MAPPINGS = {
+	"1.0.0": "1.1-Update",
+	"1.0.1": "1.1-Update",
+	"1.1.0": "1.1-Update",
+	"1.1.5": "1.1-Update",
+	"2.0.0": "2.0-Update",
+	"2.1.0": "2.1-Update4",
+	"2.1.1": "2.1-Update",
+	"2.1.2": "2.1-Update",
+	"2.1.5": "2.1-Update2",
+	"2.1.8": "2.1-Update3",
+	"2.1.9": "2.1-Update4",
+	"3.0.0": "3.0-Update",
+	"3.0.1": "3.0-Update1",
+	"3.1.0": "3.1-Update",
+	"3.1.1": "3.1-Update1",
+	"3.2.0": "3.2-Update",
+	"4.0.0": "4.0-Update",
+	"4.0.1": "4.0-Update1"
+};
+/**
+* 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
+*/
+function resolveUCDVersion(unicodeVersion) {
+	const ucdVersion = UNICODE_TO_UCD_VERSION_MAPPINGS[unicodeVersion];
+	if (ucdVersion) return ucdVersion;
+	return unicodeVersion;
+}
+
+//#endregion
+//#region src/path.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
+*/
+function buildUCDPath(version, path) {
+	return new URL(`${version}/${hasUCDFolderPath(version) ? "ucd/" : ""}${path}`, "https://www.unicode.org/").pathname;
+}
+/**
+* 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')
+*/
+function hasUCDFolderPath(version) {
+	if (version.includes("Update")) return false;
+	return !Object.keys(UNICODE_TO_UCD_VERSION_MAPPINGS).includes(version);
+}
+
+//#endregion
+export { RawDataFile, UNICODE_DRAFT_VERSION, UNICODE_STABLE_VERSION, UNICODE_TO_UCD_VERSION_MAPPINGS, UNICODE_VERSION_METADATA, buildUCDPath, expandHexRange, fromHexToCodepoint, getBoundaryLineStyle, getCurrentDraftVersion, getPropertyValue, hasUCDFolderPath, inferFileName, inferVersion, isBoundaryLine, isCommentLine, isDashBoundary, isEOFMarker, isEmptyLine, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isPropertyLine, parseFileNameLine, parseMissingAnnotation, resolveUCDVersion, stripHex, trimCommentLine };

package/dist/line-helpers-CYDQ0FnQ.js

@@ -0,0 +1,373 @@
+//#region src/line-helpers.ts
+const HASH_BOUNDARY_REGEX = /^\s*#\s*#{2,}\s*$/;
+const EQUALS_BOUNDARY_REGEX = /^\s*#\s*={2,}\s*$/;
+const DASH_BOUNDARY_REGEX = /^\s*#\s*-{2,}\s*$/;
+/**
+* Determines if a line is an End-of-File (EOF) marker.
+*
+* In Unicode data files, the EOF marker is typically represented
+* as a line containing only "# EOF".
+*
+* @param {string} [line] - The line to check
+* @returns {boolean} True if the line is an EOF marker, false otherwise
+*
+* @example
+* ```ts
+* isEOFMarker("# EOF"); // true
+* isEOFMarker("Some text"); // false
+* isEOFMarker(); // false
+* ```
+*/
+function isEOFMarker(line) {
+	if (!line) return false;
+	return line.trim() === "# EOF";
+}
+/**
+* Determines if a line contains a hash boundary pattern.
+*
+* A hash boundary is a line containing a pattern like "# ###" (# followed by multiple #).
+* These patterns are used in Unicode data files to separate different sections of content.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line contains a hash boundary pattern, false otherwise
+*
+* @example
+* ```ts
+* isHashBoundary("# #####"); // true
+* isHashBoundary("# Some text"); // false
+* isHashBoundary(""); // false
+* ```
+*/
+function isHashBoundary(line) {
+	if (!line) return false;
+	return HASH_BOUNDARY_REGEX.test(line);
+}
+/**
+* Determines if a line contains an equals boundary pattern.
+*
+* An equals boundary is a line containing a pattern like "# ===" (# followed by multiple =).
+* These patterns are used in Unicode data files to separate different sections of content.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line contains an equals boundary pattern, false otherwise
+*
+* @example
+* ```ts
+* isEqualsBoundary("# ====="); // true
+* isEqualsBoundary("# Some text"); // false
+* isEqualsBoundary(""); // false
+* ```
+*/
+function isEqualsBoundary(line) {
+	if (!line) return false;
+	return EQUALS_BOUNDARY_REGEX.test(line);
+}
+/**
+* Determines if a line contains a dash boundary pattern.
+*
+* A dash boundary is a line containing a pattern like "# ---" (# followed by multiple -).
+* These patterns are used in Unicode data files to separate different sections of content.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line contains a dash boundary pattern, false otherwise
+*
+* @example
+* ```ts
+* isDashBoundary("# -----"); // true
+* isDashBoundary("# Some text"); // false
+* isDashBoundary(""); // false
+* ```
+*/
+function isDashBoundary(line) {
+	if (!line) return false;
+	return DASH_BOUNDARY_REGEX.test(line);
+}
+/**
+* Determines if a line is any type of boundary line.
+*
+* A boundary line is any line that matches one of the boundary patterns:
+* hash boundary, equals boundary, or dash boundary. These patterns are used
+* in Unicode data files to separate different sections of content.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line is a boundary line, false otherwise
+*
+* @example
+* ```ts
+* isBoundaryLine("# #####"); // true (hash boundary)
+* isBoundaryLine("# ====="); // true (equals boundary)
+* isBoundaryLine("# -----"); // true (dash boundary)
+* isBoundaryLine("# Some text"); // false
+* isBoundaryLine(""); // false
+* ```
+*/
+function isBoundaryLine(line) {
+	if (!line) return false;
+	return isHashBoundary(line) || isEqualsBoundary(line) || isDashBoundary(line);
+}
+/**
+* Extracts the style character from a boundary line.
+*
+* This function determines which type of boundary character is used in the line:
+* '#', '=', or '-'. It checks the line against each boundary pattern and returns
+* the corresponding character.
+*
+* @param {string} line - The boundary line to analyze
+* @returns {BoundaryStyle} The boundary style character ('#', '=', or '-')
+* @throws {Error} If the line is not a valid boundary line
+*
+* @example
+* ```ts
+* getBoundaryLineStyle("# #####"); // returns "#"
+* getBoundaryLineStyle("# ====="); // returns "="
+* getBoundaryLineStyle("# -----"); // returns "-"
+* ```
+*/
+function getBoundaryLineStyle(line) {
+	if (isHashBoundary(line)) return "#";
+	if (isEqualsBoundary(line)) return "=";
+	if (isDashBoundary(line)) return "-";
+	throw new Error(`invalid boundary style for line: ${line}`);
+}
+/**
+* Determines if a line is a comment line.
+*
+* A comment line is either a line that starts with "# " or
+* a line that only contains "#" (possibly with whitespace).
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line is a comment line, false otherwise
+*/
+function isCommentLine(line) {
+	if (!line) return false;
+	return line.startsWith("# ") || line.startsWith("#		") || line.trim() === "#";
+}
+/**
+* Removes the comment marker ('#') and any following whitespace from a line.
+*
+* This function is designed to extract the actual content from comment lines
+* in Unicode data files by removing the leading '#' character and any whitespace
+* that follows it.
+*
+* @param {string} line - The comment line to trim
+* @returns {string} The content of the comment line without the comment marker
+*
+* @example
+* ```ts
+* trimCommentLine("# Some comment"); // returns "Some comment"
+* trimCommentLine("#\tTabbed comment"); // returns "Tabbed comment"
+* trimCommentLine(""); // returns ""
+* ```
+*/
+function trimCommentLine(line) {
+	if (!line) return "";
+	return line.trim().replace(/^#\s*/, "");
+}
+/**
+* Checks if a string line is empty after trimming whitespace.
+*
+* @param {string} line - The string to check for emptiness
+* @returns {boolean} A boolean indicating whether the trimmed line is empty
+*/
+function isEmptyLine(line) {
+	if (!line) return true;
+	return line.trim() === "";
+}
+/**
+* Determines if a line contains data in a Unicode data file.
+*
+* A line is considered to contain data if it is neither a comment line
+* (starting with '#') nor an empty line.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line contains data, false otherwise
+*
+* @example
+* ```ts
+* isLineWithData("U+0020;SPACE"); // true
+* isLineWithData("# Comment line"); // false
+* isLineWithData(""); // false
+* ```
+*/
+function isLineWithData(line) {
+	return !isCommentLine(line) && !isEmptyLine(line);
+}
+/**
+* Check if a given line from a Unicode data file is a 'missing' annotation.
+*
+* In Unicode data files, lines starting with '# @missing:' indicate
+* a range of code points that are not assigned.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line is a missing annotation, false otherwise
+*/
+function isMissingAnnotation(line) {
+	return line.startsWith("# @missing:");
+}
+const MISSING_ANNOTATION_SPECIAL_TAGS = {
+	"<none>": "none",
+	"<script>": "script",
+	"<code-point>": "code-point"
+};
+/**
+* Parses a line into a MissingAnnotation object.
+*
+* This function attempts to extract information from a line that follows the
+* format of a missing annotation in Unicode data files.
+*
+* The format being parsed is:
+* `# @missing: START..END; DEFAULT_PROP_VALUE_OR_PROPERTY_NAME[; DEFAULT_PROPERTY_VALUE]`
+*
+* @param {string} line - The line to parse
+* @returns {MissingAnnotation | null} A MissingAnnotation object if the line is a valid missing annotation, null otherwise
+*
+* @example
+* ```ts
+* parseMissingAnnotation("# @missing: 0000..007F; NA")
+* // -> { start: "0000", end: "007F", defaultPropertyValue: "NA" }
+*
+* parseMissingAnnotation("# @missing: 0000..007F; Script; Unknown")
+* // -> { start: "0000", end: "007F", propertyName: "Script", defaultPropertyValue: "Unknown" }
+* ```
+*/
+function parseMissingAnnotation(line) {
+	if (!isMissingAnnotation(line)) return null;
+	const match = line.match(/^# @missing: ([0-9A-F]+)\.\.([0-9A-F]+); ([^;\n]+)(?:; ([^\n]+))?$/m);
+	if (match == null) return null;
+	const [_, start, end, defaultPropValueOrPropertyName, defaultPropertyValue] = match;
+	const defaultProperty = defaultPropertyValue == null ? defaultPropValueOrPropertyName : defaultPropertyValue;
+	const specialTag = defaultProperty && defaultProperty in MISSING_ANNOTATION_SPECIAL_TAGS ? MISSING_ANNOTATION_SPECIAL_TAGS[defaultProperty] : void 0;
+	if (start == null || end == null || defaultPropValueOrPropertyName == null) return null;
+	return {
+		start,
+		end,
+		propertyName: defaultPropertyValue == null ? void 0 : defaultPropValueOrPropertyName,
+		defaultPropertyValue: defaultProperty || "",
+		specialTag
+	};
+}
+/**
+* Attempts to infer the file name from the first line of a Unicode data file.
+*
+* This function extracts the file name from the first line of the content,
+* assuming it's a comment line. It removes any leading '#' characters and whitespace.
+*
+* For example:
+* - From a file with first line "# ArabicShaping-5.0.0.txt", it returns "ArabicShaping"
+* - From a file with first line "# UnicodeData-5.0.0.txt", it returns "UnicodeData"
+*
+* @param {string} line - The first line of the file
+* @returns {string | undefined} The inferred file name, or undefined if it can't be determined
+*/
+function inferFileName(line) {
+	return parseFileNameLine(line)?.fileName;
+}
+/**
+* Attempts to infer the version from the first line of a Unicode data file.
+*
+* This function extracts the version number from the first line of the content,
+* assuming it's a comment line. It looks for a pattern like "Name-X.Y.Z.txt"
+* and extracts the X.Y.Z part as the version.
+*
+* For example:
+* - From a file with first line "# ArabicShaping-5.0.0.txt", it returns "5.0.0"
+* - From a file with first line "# UnicodeData-14.0.0.txt", it returns "14.0.0"
+*
+* @param {string} line - The first line of the file
+* @returns {string | undefined} The inferred version number, or undefined if it can't be determined
+*/
+function inferVersion(line) {
+	return parseFileNameLine(line)?.version;
+}
+/**
+* Parses a line from a Unicode data file to extract the file name and version information.
+*
+* This function tries to extract file name and version information from a line that
+* typically appears at the beginning of Unicode data files. It handles various formats:
+* - "FileName-1.2.3.txt"
+* - "FileName-1.2.3"
+* - "FileName.txt"
+*
+* The function also properly handles comment markers at the beginning of the line.
+*
+* @param {string} line - The line to parse, typically the first line of a Unicode data file
+* @returns {ParsedFileName | undefined} An object containing the file name and version if
+*                                      successfully parsed, or undefined if parsing fails
+*
+* @example
+* ```ts
+* parseFileNameLine("# UnicodeData-14.0.0.txt");
+* // Returns { fileName: "UnicodeData", version: "14.0.0" }
+*
+* parseFileNameLine("# ArabicShaping.txt");
+* // Returns { fileName: "ArabicShaping", version: undefined }
+* ```
+*/
+function parseFileNameLine(line) {
+	if (!line) return;
+	line = line.split("\n")[0].trim();
+	if (!isCommentLine(line)) return;
+	line = line.trim().replace(/^#\s*/, "");
+	if (line === "") return;
+	let match = line.match(/^(.*?)(?:-([0-9.]+))?\.txt$/);
+	if (match == null) {
+		match = line.match(/^(.*?)(?:-([0-9.]+))?$/);
+		/* v8 ignore next 3 */
+		if (match == null) return;
+	}
+	const [_, fileName, version] = match;
+	if (!fileName || fileName.trim() === "") return;
+	return {
+		fileName,
+		version
+	};
+}
+/**
+* Determines if a line represents a property definition in Unicode data files.
+*
+* In Unicode data files, properties are typically defined in comment lines that
+* start with "# Property:" followed by the property name.
+*
+* @param {string} line - The line to check
+* @returns {boolean} True if the line is a property definition, false otherwise
+*
+* @example
+* ```ts
+* isPropertyLine("# Property: Age"); // true
+* isPropertyLine("# Some other comment"); // false
+* isPropertyLine(""); // false
+* ```
+*/
+function isPropertyLine(line) {
+	if (!line) return false;
+	if (!isCommentLine(line)) return false;
+	const val = getPropertyValue(line);
+	return val !== void 0 && val.trim() !== "";
+}
+/**
+* Extracts the property value from a property definition line in Unicode data files.
+*
+* This function parses a line that follows the format '# Property: [PropertyValue]'
+* and returns the PropertyValue part. It is used internally by isPropertyLine
+* to parse property definitions in Unicode data files.
+*
+* @param {string} line - The line to extract the property value from
+* @returns {string | undefined} The extracted property value, or undefined if
+*                              the line is not a valid property definition
+*
+* @example
+* ```ts
+* getPropertyValue("# Property: Age"); // returns "Age"
+* getPropertyValue("# Property: "); // returns undefined
+* getPropertyValue("# Not a property line"); // returns undefined
+* ```
+*/
+function getPropertyValue(line) {
+	const trimmedComment = trimCommentLine(line).trim();
+	if (trimmedComment === "") return;
+	if (!trimmedComment.startsWith("Property:")) return;
+	return trimmedComment.slice(9).trim();
+}
+
+//#endregion
+export { trimCommentLine as _, isBoundaryLine as a, isEOFMarker as c, isHashBoundary as d, isLineWithData as f, parseMissingAnnotation as g, parseFileNameLine as h, inferVersion as i, isEmptyLine as l, isPropertyLine as m, getPropertyValue as n, isCommentLine as o, isMissingAnnotation as p, inferFileName as r, isDashBoundary as s, getBoundaryLineStyle as t, isEqualsBoundary as u };