@formatjs/icu-messageformat-parser 3.2.1 → 3.4.0

package/parser.js

@@ -1,918 +1,857 @@
-import { __assign } from "tslib";
-import { ErrorKind } from './error.js';
-import { SKELETON_TYPE, TYPE, } from './types.js';
-import { SPACE_SEPARATOR_REGEX } from './regex.generated.js';
-import { parseNumberSkeleton, parseNumberSkeletonFromString, parseDateTimeSkeleton, } from '@formatjs/icu-skeleton-parser';
-import { getBestPattern } from './date-time-pattern-generator.js';
-var SPACE_SEPARATOR_START_REGEX = new RegExp("^".concat(SPACE_SEPARATOR_REGEX.source, "*"));
-var SPACE_SEPARATOR_END_REGEX = new RegExp("".concat(SPACE_SEPARATOR_REGEX.source, "*$"));
+import { ErrorKind } from "./error.js";
+import { SKELETON_TYPE, TYPE } from "./types.js";
+import { SPACE_SEPARATOR_REGEX } from "./regex.generated.js";
+import { parseNumberSkeleton, parseNumberSkeletonFromString, parseDateTimeSkeleton } from "@formatjs/icu-skeleton-parser";
+import { getBestPattern } from "./date-time-pattern-generator.js";
+const SPACE_SEPARATOR_START_REGEX = new RegExp(`^${SPACE_SEPARATOR_REGEX.source}*`);
+const SPACE_SEPARATOR_END_REGEX = new RegExp(`${SPACE_SEPARATOR_REGEX.source}*$`);
 function createLocation(start, end) {
-    return { start: start, end: end };
+	return {
+		start,
+		end
+	};
 }
 // #region Ponyfills
 // Consolidate these variables up top for easier toggling during debugging
-var hasNativeFromEntries = !!Object.fromEntries;
-var hasTrimStart = !!String.prototype.trimStart;
-var hasTrimEnd = !!String.prototype.trimEnd;
-var fromEntries = 
-// native
-hasNativeFromEntries
-    ? Object.fromEntries
-    : // Ponyfill
-        function fromEntries(entries) {
-            var obj = {};
-            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-                var _a = entries_1[_i], k = _a[0], v = _a[1];
-                obj[k] = v;
-            }
-            return obj;
-        };
-var trimStart = hasTrimStart
-    ? // Native
-        function trimStart(s) {
-            return s.trimStart();
-        }
-    : // Ponyfill
-        function trimStart(s) {
-            return s.replace(SPACE_SEPARATOR_START_REGEX, '');
-        };
-var trimEnd = hasTrimEnd
-    ? // Native
-        function trimEnd(s) {
-            return s.trimEnd();
-        }
-    : // Ponyfill
-        function trimEnd(s) {
-            return s.replace(SPACE_SEPARATOR_END_REGEX, '');
-        };
+const hasNativeFromEntries = !!Object.fromEntries;
+const hasTrimStart = !!String.prototype.trimStart;
+const hasTrimEnd = !!String.prototype.trimEnd;
+const fromEntries = hasNativeFromEntries ? Object.fromEntries : function fromEntries(entries) {
+	const obj = {};
+	for (const [k, v] of entries) {
+		obj[k] = v;
+	}
+	return obj;
+};
+const trimStart = hasTrimStart ? function trimStart(s) {
+	return s.trimStart();
+} : function trimStart(s) {
+	return s.replace(SPACE_SEPARATOR_START_REGEX, "");
+};
+const trimEnd = hasTrimEnd ? function trimEnd(s) {
+	return s.trimEnd();
+} : function trimEnd(s) {
+	return s.replace(SPACE_SEPARATOR_END_REGEX, "");
+};
 // #endregion
-var IDENTIFIER_PREFIX_RE = new RegExp('([^\\p{White_Space}\\p{Pattern_Syntax}]*)', 'yu');
+const IDENTIFIER_PREFIX_RE = new RegExp("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
 function matchIdentifierAtIndex(s, index) {
-    var _a;
-    IDENTIFIER_PREFIX_RE.lastIndex = index;
-    var match = IDENTIFIER_PREFIX_RE.exec(s);
-    return (_a = match[1]) !== null && _a !== void 0 ? _a : '';
+	IDENTIFIER_PREFIX_RE.lastIndex = index;
+	const match = IDENTIFIER_PREFIX_RE.exec(s);
+	return match[1] ?? "";
+}
+export class Parser {
+	message;
+	position;
+	locale;
+	ignoreTag;
+	requiresOtherClause;
+	shouldParseSkeletons;
+	constructor(message, options = {}) {
+		this.message = message;
+		this.position = {
+			offset: 0,
+			line: 1,
+			column: 1
+		};
+		this.ignoreTag = !!options.ignoreTag;
+		this.locale = options.locale;
+		this.requiresOtherClause = !!options.requiresOtherClause;
+		this.shouldParseSkeletons = !!options.shouldParseSkeletons;
+	}
+	parse() {
+		if (this.offset() !== 0) {
+			throw Error("parser can only be used once");
+		}
+		return this.parseMessage(0, "", false);
+	}
+	parseMessage(nestingLevel, parentArgType, expectingCloseTag) {
+		let elements = [];
+		while (!this.isEOF()) {
+			const char = this.char();
+			if (char === 123) {
+				const result = this.parseArgument(nestingLevel, expectingCloseTag);
+				if (result.err) {
+					return result;
+				}
+				elements.push(result.val);
+			} else if (char === 125 && nestingLevel > 0) {
+				break;
+			} else if (char === 35 && (parentArgType === "plural" || parentArgType === "selectordinal")) {
+				const position = this.clonePosition();
+				this.bump();
+				elements.push({
+					type: TYPE.pound,
+					location: createLocation(position, this.clonePosition())
+				});
+			} else if (char === 60 && !this.ignoreTag && this.peek() === 47) {
+				if (expectingCloseTag) {
+					break;
+				} else {
+					return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));
+				}
+			} else if (char === 60 && !this.ignoreTag && _isAlpha(this.peek() || 0)) {
+				const result = this.parseTag(nestingLevel, parentArgType);
+				if (result.err) {
+					return result;
+				}
+				elements.push(result.val);
+			} else {
+				const result = this.parseLiteral(nestingLevel, parentArgType);
+				if (result.err) {
+					return result;
+				}
+				elements.push(result.val);
+			}
+		}
+		return {
+			val: elements,
+			err: null
+		};
+	}
+	/**
+	* A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
+	* [custom element name][] except that a dash is NOT always mandatory and uppercase letters
+	* are accepted:
+	*
+	* ```
+	* tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
+	* tagName ::= [a-z] (PENChar)*
+	* PENChar ::=
+	*     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+	*     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
+	*     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+	* ```
+	*
+	* [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+	* NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
+	* since other tag-based engines like React allow it
+	*/
+	parseTag(nestingLevel, parentArgType) {
+		const startPosition = this.clonePosition();
+		this.bump();
+		const tagName = this.parseTagName();
+		this.bumpSpace();
+		if (this.bumpIf("/>")) {
+			// Self closing tag
+			return {
+				val: {
+					type: TYPE.literal,
+					value: `<${tagName}/>`,
+					location: createLocation(startPosition, this.clonePosition())
+				},
+				err: null
+			};
+		} else if (this.bumpIf(">")) {
+			const childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
+			if (childrenResult.err) {
+				return childrenResult;
+			}
+			const children = childrenResult.val;
+			// Expecting a close tag
+			const endTagStartPosition = this.clonePosition();
+			if (this.bumpIf("</")) {
+				if (this.isEOF() || !_isAlpha(this.char())) {
+					return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+				}
+				const closingTagNameStartPosition = this.clonePosition();
+				const closingTagName = this.parseTagName();
+				if (tagName !== closingTagName) {
+					return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));
+				}
+				this.bumpSpace();
+				if (!this.bumpIf(">")) {
+					return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
+				}
+				return {
+					val: {
+						type: TYPE.tag,
+						value: tagName,
+						children,
+						location: createLocation(startPosition, this.clonePosition())
+					},
+					err: null
+				};
+			} else {
+				return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));
+			}
+		} else {
+			return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));
+		}
+	}
+	/**
+	* This method assumes that the caller has peeked ahead for the first tag character.
+	*/
+	parseTagName() {
+		const startOffset = this.offset();
+		this.bump();
+		while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {
+			this.bump();
+		}
+		return this.message.slice(startOffset, this.offset());
+	}
+	parseLiteral(nestingLevel, parentArgType) {
+		const start = this.clonePosition();
+		let value = "";
+		while (true) {
+			const parseQuoteResult = this.tryParseQuote(parentArgType);
+			if (parseQuoteResult) {
+				value += parseQuoteResult;
+				continue;
+			}
+			const parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
+			if (parseUnquotedResult) {
+				value += parseUnquotedResult;
+				continue;
+			}
+			const parseLeftAngleResult = this.tryParseLeftAngleBracket();
+			if (parseLeftAngleResult) {
+				value += parseLeftAngleResult;
+				continue;
+			}
+			break;
+		}
+		const location = createLocation(start, this.clonePosition());
+		return {
+			val: {
+				type: TYPE.literal,
+				value,
+				location
+			},
+			err: null
+		};
+	}
+	tryParseLeftAngleBracket() {
+		if (!this.isEOF() && this.char() === 60 && (this.ignoreTag || !_isAlphaOrSlash(this.peek() || 0))) {
+			this.bump();
+			return "<";
+		}
+		return null;
+	}
+	/**
+	* Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
+	* a character that requires quoting (that is, "only where needed"), and works the same in
+	* nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
+	*/
+	tryParseQuote(parentArgType) {
+		if (this.isEOF() || this.char() !== 39) {
+			return null;
+		}
+		// Parse escaped char following the apostrophe, or early return if there is no escaped char.
+		// Check if is valid escaped character
+		switch (this.peek()) {
+			case 39:
+				// double quote, should return as a single quote.
+				this.bump();
+				this.bump();
+				return "'";
+			case 123:
+			case 60:
+			case 62:
+			case 125: break;
+			case 35:
+				if (parentArgType === "plural" || parentArgType === "selectordinal") {
+					break;
+				}
+				return null;
+			default: return null;
+		}
+		this.bump();
+		const codePoints = [this.char()];
+		this.bump();
+		// read chars until the optional closing apostrophe is found
+		while (!this.isEOF()) {
+			const ch = this.char();
+			if (ch === 39) {
+				if (this.peek() === 39) {
+					codePoints.push(39);
+					// Bump one more time because we need to skip 2 characters.
+					this.bump();
+				} else {
+					// Optional closing apostrophe.
+					this.bump();
+					break;
+				}
+			} else {
+				codePoints.push(ch);
+			}
+			this.bump();
+		}
+		return String.fromCodePoint(...codePoints);
+	}
+	tryParseUnquoted(nestingLevel, parentArgType) {
+		if (this.isEOF()) {
+			return null;
+		}
+		const ch = this.char();
+		if (ch === 60 || ch === 123 || ch === 35 && (parentArgType === "plural" || parentArgType === "selectordinal") || ch === 125 && nestingLevel > 0) {
+			return null;
+		} else {
+			this.bump();
+			return String.fromCodePoint(ch);
+		}
+	}
+	parseArgument(nestingLevel, expectingCloseTag) {
+		const openingBracePosition = this.clonePosition();
+		this.bump();
+		this.bumpSpace();
+		if (this.isEOF()) {
+			return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		if (this.char() === 125) {
+			this.bump();
+			return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		// argument name
+		let value = this.parseIdentifierIfPossible().value;
+		if (!value) {
+			return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		this.bumpSpace();
+		if (this.isEOF()) {
+			return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		switch (this.char()) {
+			case 125: {
+				this.bump();
+				return {
+					val: {
+						type: TYPE.argument,
+						value,
+						location: createLocation(openingBracePosition, this.clonePosition())
+					},
+					err: null
+				};
+			}
+			case 44: {
+				this.bump();
+				this.bumpSpace();
+				if (this.isEOF()) {
+					return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+				}
+				return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
+			}
+			default: return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
+		}
+	}
+	/**
+	* Advance the parser until the end of the identifier, if it is currently on
+	* an identifier character. Return an empty string otherwise.
+	*/
+	parseIdentifierIfPossible() {
+		const startingPosition = this.clonePosition();
+		const startOffset = this.offset();
+		const value = matchIdentifierAtIndex(this.message, startOffset);
+		const endOffset = startOffset + value.length;
+		this.bumpTo(endOffset);
+		const endPosition = this.clonePosition();
+		const location = createLocation(startingPosition, endPosition);
+		return {
+			value,
+			location
+		};
+	}
+	parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition) {
+		// Parse this range:
+		// {name, type, style}
+		//        ^---^
+		let typeStartPosition = this.clonePosition();
+		let argType = this.parseIdentifierIfPossible().value;
+		let typeEndPosition = this.clonePosition();
+		switch (argType) {
+			case "":
+ // Expecting a style string number, date, time, plural, selectordinal, or select.
+			return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+			case "number":
+			case "date":
+			case "time": {
+				// Parse this range:
+				// {name, number, style}
+				//              ^-------^
+				this.bumpSpace();
+				let styleAndLocation = null;
+				if (this.bumpIf(",")) {
+					this.bumpSpace();
+					const styleStartPosition = this.clonePosition();
+					const result = this.parseSimpleArgStyleIfPossible();
+					if (result.err) {
+						return result;
+					}
+					const style = trimEnd(result.val);
+					if (style.length === 0) {
+						return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));
+					}
+					const styleLocation = createLocation(styleStartPosition, this.clonePosition());
+					styleAndLocation = {
+						style,
+						styleLocation
+					};
+				}
+				const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+				if (argCloseResult.err) {
+					return argCloseResult;
+				}
+				const location = createLocation(openingBracePosition, this.clonePosition());
+				// Extract style or skeleton
+				if (styleAndLocation && styleAndLocation.style.startsWith("::")) {
+					// Skeleton starts with `::`.
+					let skeleton = trimStart(styleAndLocation.style.slice(2));
+					if (argType === "number") {
+						const result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
+						if (result.err) {
+							return result;
+						}
+						return {
+							val: {
+								type: TYPE.number,
+								value,
+								location,
+								style: result.val
+							},
+							err: null
+						};
+					} else {
+						if (skeleton.length === 0) {
+							return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location);
+						}
+						let dateTimePattern = skeleton;
+						// Get "best match" pattern only if locale is passed, if not, let it
+						// pass as-is where `parseDateTimeSkeleton()` will throw an error
+						// for unsupported patterns.
+						if (this.locale) {
+							dateTimePattern = getBestPattern(skeleton, this.locale);
+						}
+						const style = {
+							type: SKELETON_TYPE.dateTime,
+							pattern: dateTimePattern,
+							location: styleAndLocation.styleLocation,
+							parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(dateTimePattern) : {}
+						};
+						const type = argType === "date" ? TYPE.date : TYPE.time;
+						return {
+							val: {
+								type,
+								value,
+								location,
+								style
+							},
+							err: null
+						};
+					}
+				}
+				// Regular style or no style.
+				return {
+					val: {
+						type: argType === "number" ? TYPE.number : argType === "date" ? TYPE.date : TYPE.time,
+						value,
+						location,
+						style: styleAndLocation?.style ?? null
+					},
+					err: null
+				};
+			}
+			case "plural":
+			case "selectordinal":
+			case "select": {
+				// Parse this range:
+				// {name, plural, options}
+				//              ^---------^
+				const typeEndPosition = this.clonePosition();
+				this.bumpSpace();
+				if (!this.bumpIf(",")) {
+					return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition, { ...typeEndPosition }));
+				}
+				this.bumpSpace();
+				// Parse offset:
+				// {name, plural, offset:1, options}
+				//                ^-----^
+				//
+				// or the first option:
+				//
+				// {name, plural, one {...} other {...}}
+				//                ^--^
+				let identifierAndLocation = this.parseIdentifierIfPossible();
+				let pluralOffset = 0;
+				if (argType !== "select" && identifierAndLocation.value === "offset") {
+					if (!this.bumpIf(":")) {
+						return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));
+					}
+					this.bumpSpace();
+					const result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
+					if (result.err) {
+						return result;
+					}
+					// Parse another identifier for option parsing
+					this.bumpSpace();
+					identifierAndLocation = this.parseIdentifierIfPossible();
+					pluralOffset = result.val;
+				}
+				const optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
+				if (optionsResult.err) {
+					return optionsResult;
+				}
+				const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+				if (argCloseResult.err) {
+					return argCloseResult;
+				}
+				const location = createLocation(openingBracePosition, this.clonePosition());
+				if (argType === "select") {
+					return {
+						val: {
+							type: TYPE.select,
+							value,
+							options: fromEntries(optionsResult.val),
+							location
+						},
+						err: null
+					};
+				} else {
+					return {
+						val: {
+							type: TYPE.plural,
+							value,
+							options: fromEntries(optionsResult.val),
+							offset: pluralOffset,
+							pluralType: argType === "plural" ? "cardinal" : "ordinal",
+							location
+						},
+						err: null
+					};
+				}
+			}
+			default: return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
+		}
+	}
+	tryParseArgumentClose(openingBracePosition) {
+		// Parse: {value, number, ::currency/GBP }
+		//
+		if (this.isEOF() || this.char() !== 125) {
+			return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
+		}
+		this.bump();
+		return {
+			val: true,
+			err: null
+		};
+	}
+	/**
+	* See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
+	*/
+	parseSimpleArgStyleIfPossible() {
+		let nestedBraces = 0;
+		const startPosition = this.clonePosition();
+		while (!this.isEOF()) {
+			const ch = this.char();
+			switch (ch) {
+				case 39: {
+					// Treat apostrophe as quoting but include it in the style part.
+					// Find the end of the quoted literal text.
+					this.bump();
+					let apostrophePosition = this.clonePosition();
+					if (!this.bumpUntil("'")) {
+						return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));
+					}
+					this.bump();
+					break;
+				}
+				case 123: {
+					nestedBraces += 1;
+					this.bump();
+					break;
+				}
+				case 125: {
+					if (nestedBraces > 0) {
+						nestedBraces -= 1;
+					} else {
+						return {
+							val: this.message.slice(startPosition.offset, this.offset()),
+							err: null
+						};
+					}
+					break;
+				}
+				default:
+					this.bump();
+					break;
+			}
+		}
+		return {
+			val: this.message.slice(startPosition.offset, this.offset()),
+			err: null
+		};
+	}
+	parseNumberSkeletonFromString(skeleton, location) {
+		let tokens = [];
+		try {
+			tokens = parseNumberSkeletonFromString(skeleton);
+		} catch {
+			return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);
+		}
+		return {
+			val: {
+				type: SKELETON_TYPE.number,
+				tokens,
+				location,
+				parsedOptions: this.shouldParseSkeletons ? parseNumberSkeleton(tokens) : {}
+			},
+			err: null
+		};
+	}
+	/**
+	* @param nesting_level The current nesting level of messages.
+	*     This can be positive when parsing message fragment in select or plural argument options.
+	* @param parent_arg_type The parent argument's type.
+	* @param parsed_first_identifier If provided, this is the first identifier-like selector of
+	*     the argument. It is a by-product of a previous parsing attempt.
+	* @param expecting_close_tag If true, this message is directly or indirectly nested inside
+	*     between a pair of opening and closing tags. The nested message will not parse beyond
+	*     the closing tag boundary.
+	*/
+	tryParsePluralOrSelectOptions(nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
+		let hasOtherClause = false;
+		const options = [];
+		const parsedSelectors = new Set();
+		let { value: selector, location: selectorLocation } = parsedFirstIdentifier;
+		// Parse:
+		// one {one apple}
+		// ^--^
+		while (true) {
+			if (selector.length === 0) {
+				const startPosition = this.clonePosition();
+				if (parentArgType !== "select" && this.bumpIf("=")) {
+					// Try parse `={number}` selector
+					const result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);
+					if (result.err) {
+						return result;
+					}
+					selectorLocation = createLocation(startPosition, this.clonePosition());
+					selector = this.message.slice(startPosition.offset, this.offset());
+				} else {
+					break;
+				}
+			}
+			// Duplicate selector clauses
+			if (parsedSelectors.has(selector)) {
+				return this.error(parentArgType === "select" ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);
+			}
+			if (selector === "other") {
+				hasOtherClause = true;
+			}
+			// Parse:
+			// one {one apple}
+			//     ^----------^
+			this.bumpSpace();
+			const openingBracePosition = this.clonePosition();
+			if (!this.bumpIf("{")) {
+				return this.error(parentArgType === "select" ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));
+			}
+			const fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
+			if (fragmentResult.err) {
+				return fragmentResult;
+			}
+			const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+			if (argCloseResult.err) {
+				return argCloseResult;
+			}
+			options.push([selector, {
+				value: fragmentResult.val,
+				location: createLocation(openingBracePosition, this.clonePosition())
+			}]);
+			// Keep track of the existing selectors
+			parsedSelectors.add(selector);
+			// Prep next selector clause.
+			this.bumpSpace();
+			({value: selector, location: selectorLocation} = this.parseIdentifierIfPossible());
+		}
+		if (options.length === 0) {
+			return this.error(parentArgType === "select" ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));
+		}
+		if (this.requiresOtherClause && !hasOtherClause) {
+			return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));
+		}
+		return {
+			val: options,
+			err: null
+		};
+	}
+	tryParseDecimalInteger(expectNumberError, invalidNumberError) {
+		let sign = 1;
+		const startingPosition = this.clonePosition();
+		if (this.bumpIf("+")) {} else if (this.bumpIf("-")) {
+			sign = -1;
+		}
+		let hasDigits = false;
+		let decimal = 0;
+		while (!this.isEOF()) {
+			const ch = this.char();
+			if (ch >= 48 && ch <= 57) {
+				hasDigits = true;
+				decimal = decimal * 10 + (ch - 48);
+				this.bump();
+			} else {
+				break;
+			}
+		}
+		const location = createLocation(startingPosition, this.clonePosition());
+		if (!hasDigits) {
+			return this.error(expectNumberError, location);
+		}
+		decimal *= sign;
+		if (!Number.isSafeInteger(decimal)) {
+			return this.error(invalidNumberError, location);
+		}
+		return {
+			val: decimal,
+			err: null
+		};
+	}
+	offset() {
+		return this.position.offset;
+	}
+	isEOF() {
+		return this.offset() === this.message.length;
+	}
+	clonePosition() {
+		// This is much faster than `Object.assign` or spread.
+		return {
+			offset: this.position.offset,
+			line: this.position.line,
+			column: this.position.column
+		};
+	}
+	/**
+	* Return the code point at the current position of the parser.
+	* Throws if the index is out of bound.
+	*/
+	char() {
+		const offset = this.position.offset;
+		if (offset >= this.message.length) {
+			throw Error("out of bound");
+		}
+		const code = this.message.codePointAt(offset);
+		if (code === undefined) {
+			throw Error(`Offset ${offset} is at invalid UTF-16 code unit boundary`);
+		}
+		return code;
+	}
+	error(kind, location) {
+		return {
+			val: null,
+			err: {
+				kind,
+				message: this.message,
+				location
+			}
+		};
+	}
+	/** Bump the parser to the next UTF-16 code unit. */
+	bump() {
+		if (this.isEOF()) {
+			return;
+		}
+		const code = this.char();
+		if (code === 10) {
+			this.position.line += 1;
+			this.position.column = 1;
+			this.position.offset += 1;
+		} else {
+			this.position.column += 1;
+			// 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.
+			this.position.offset += code < 65536 ? 1 : 2;
+		}
+	}
+	/**
+	* If the substring starting at the current position of the parser has
+	* the given prefix, then bump the parser to the character immediately
+	* following the prefix and return true. Otherwise, don't bump the parser
+	* and return false.
+	*/
+	bumpIf(prefix) {
+		if (this.message.startsWith(prefix, this.offset())) {
+			for (let i = 0; i < prefix.length; i++) {
+				this.bump();
+			}
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Bump the parser until the pattern character is found and return `true`.
+	* Otherwise bump to the end of the file and return `false`.
+	*/
+	bumpUntil(pattern) {
+		const currentOffset = this.offset();
+		const index = this.message.indexOf(pattern, currentOffset);
+		if (index >= 0) {
+			this.bumpTo(index);
+			return true;
+		} else {
+			this.bumpTo(this.message.length);
+			return false;
+		}
+	}
+	/**
+	* Bump the parser to the target offset.
+	* If target offset is beyond the end of the input, bump the parser to the end of the input.
+	*/
+	bumpTo(targetOffset) {
+		if (this.offset() > targetOffset) {
+			throw Error(`targetOffset ${targetOffset} must be greater than or equal to the current offset ${this.offset()}`);
+		}
+		targetOffset = Math.min(targetOffset, this.message.length);
+		while (true) {
+			const offset = this.offset();
+			if (offset === targetOffset) {
+				break;
+			}
+			if (offset > targetOffset) {
+				throw Error(`targetOffset ${targetOffset} is at invalid UTF-16 code unit boundary`);
+			}
+			this.bump();
+			if (this.isEOF()) {
+				break;
+			}
+		}
+	}
+	/** advance the parser through all whitespace to the next non-whitespace code unit. */
+	bumpSpace() {
+		while (!this.isEOF() && _isWhiteSpace(this.char())) {
+			this.bump();
+		}
+	}
+	/**
+	* Peek at the *next* Unicode codepoint in the input without advancing the parser.
+	* If the input has been exhausted, then this returns null.
+	*/
+	peek() {
+		if (this.isEOF()) {
+			return null;
+		}
+		const code = this.char();
+		const offset = this.offset();
+		const nextCode = this.message.charCodeAt(offset + (code >= 65536 ? 2 : 1));
+		return nextCode ?? null;
+	}
 }
-var Parser = /** @class */ (function () {
-    function Parser(message, options) {
-        if (options === void 0) { options = {}; }
-        this.message = message;
-        this.position = { offset: 0, line: 1, column: 1 };
-        this.ignoreTag = !!options.ignoreTag;
-        this.locale = options.locale;
-        this.requiresOtherClause = !!options.requiresOtherClause;
-        this.shouldParseSkeletons = !!options.shouldParseSkeletons;
-    }
-    Parser.prototype.parse = function () {
-        if (this.offset() !== 0) {
-            throw Error('parser can only be used once');
-        }
-        return this.parseMessage(0, '', false);
-    };
-    Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {
-        var elements = [];
-        while (!this.isEOF()) {
-            var char = this.char();
-            if (char === 123 /* `{` */) {
-                var result = this.parseArgument(nestingLevel, expectingCloseTag);
-                if (result.err) {
-                    return result;
-                }
-                elements.push(result.val);
-            }
-            else if (char === 125 /* `}` */ && nestingLevel > 0) {
-                break;
-            }
-            else if (char === 35 /* `#` */ &&
-                (parentArgType === 'plural' || parentArgType === 'selectordinal')) {
-                var position = this.clonePosition();
-                this.bump();
-                elements.push({
-                    type: TYPE.pound,
-                    location: createLocation(position, this.clonePosition()),
-                });
-            }
-            else if (char === 60 /* `<` */ &&
-                !this.ignoreTag &&
-                this.peek() === 47 // char code for '/'
-            ) {
-                if (expectingCloseTag) {
-                    break;
-                }
-                else {
-                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));
-                }
-            }
-            else if (char === 60 /* `<` */ &&
-                !this.ignoreTag &&
-                _isAlpha(this.peek() || 0)) {
-                var result = this.parseTag(nestingLevel, parentArgType);
-                if (result.err) {
-                    return result;
-                }
-                elements.push(result.val);
-            }
-            else {
-                var result = this.parseLiteral(nestingLevel, parentArgType);
-                if (result.err) {
-                    return result;
-                }
-                elements.push(result.val);
-            }
-        }
-        return { val: elements, err: null };
-    };
-    /**
-     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
-     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters
-     * are accepted:
-     *
-     * ```
-     * tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
-     * tagName ::= [a-z] (PENChar)*
-     * PENChar ::=
-     *     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
-     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
-     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-     * ```
-     *
-     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
-     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
-     * since other tag-based engines like React allow it
-     */
-    Parser.prototype.parseTag = function (nestingLevel, parentArgType) {
-        var startPosition = this.clonePosition();
-        this.bump(); // `<`
-        var tagName = this.parseTagName();
-        this.bumpSpace();
-        if (this.bumpIf('/>')) {
-            // Self closing tag
-            return {
-                val: {
-                    type: TYPE.literal,
-                    value: "<".concat(tagName, "/>"),
-                    location: createLocation(startPosition, this.clonePosition()),
-                },
-                err: null,
-            };
-        }
-        else if (this.bumpIf('>')) {
-            var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
-            if (childrenResult.err) {
-                return childrenResult;
-            }
-            var children = childrenResult.val;
-            // Expecting a close tag
-            var endTagStartPosition = this.clonePosition();
-            if (this.bumpIf('</')) {
-                if (this.isEOF() || !_isAlpha(this.char())) {
-                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
-                }
-                var closingTagNameStartPosition = this.clonePosition();
-                var closingTagName = this.parseTagName();
-                if (tagName !== closingTagName) {
-                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));
-                }
-                this.bumpSpace();
-                if (!this.bumpIf('>')) {
-                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));
-                }
-                return {
-                    val: {
-                        type: TYPE.tag,
-                        value: tagName,
-                        children: children,
-                        location: createLocation(startPosition, this.clonePosition()),
-                    },
-                    err: null,
-                };
-            }
-            else {
-                return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));
-            }
-        }
-        else {
-            return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));
-        }
-    };
-    /**
-     * This method assumes that the caller has peeked ahead for the first tag character.
-     */
-    Parser.prototype.parseTagName = function () {
-        var startOffset = this.offset();
-        this.bump(); // the first tag name character
-        while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {
-            this.bump();
-        }
-        return this.message.slice(startOffset, this.offset());
-    };
-    Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {
-        var start = this.clonePosition();
-        var value = '';
-        while (true) {
-            var parseQuoteResult = this.tryParseQuote(parentArgType);
-            if (parseQuoteResult) {
-                value += parseQuoteResult;
-                continue;
-            }
-            var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
-            if (parseUnquotedResult) {
-                value += parseUnquotedResult;
-                continue;
-            }
-            var parseLeftAngleResult = this.tryParseLeftAngleBracket();
-            if (parseLeftAngleResult) {
-                value += parseLeftAngleResult;
-                continue;
-            }
-            break;
-        }
-        var location = createLocation(start, this.clonePosition());
-        return {
-            val: { type: TYPE.literal, value: value, location: location },
-            err: null,
-        };
-    };
-    Parser.prototype.tryParseLeftAngleBracket = function () {
-        if (!this.isEOF() &&
-            this.char() === 60 /* `<` */ &&
-            (this.ignoreTag ||
-                // If at the opening tag or closing tag position, bail.
-                !_isAlphaOrSlash(this.peek() || 0))) {
-            this.bump(); // `<`
-            return '<';
-        }
-        return null;
-    };
-    /**
-     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
-     * a character that requires quoting (that is, "only where needed"), and works the same in
-     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
-     */
-    Parser.prototype.tryParseQuote = function (parentArgType) {
-        if (this.isEOF() || this.char() !== 39 /* `'` */) {
-            return null;
-        }
-        // Parse escaped char following the apostrophe, or early return if there is no escaped char.
-        // Check if is valid escaped character
-        switch (this.peek()) {
-            case 39 /* `'` */:
-                // double quote, should return as a single quote.
-                this.bump();
-                this.bump();
-                return "'";
-            // '{', '<', '>', '}'
-            case 123:
-            case 60:
-            case 62:
-            case 125:
-                break;
-            case 35: // '#'
-                if (parentArgType === 'plural' || parentArgType === 'selectordinal') {
-                    break;
-                }
-                return null;
-            default:
-                return null;
-        }
-        this.bump(); // apostrophe
-        var codePoints = [this.char()]; // escaped char
-        this.bump();
-        // read chars until the optional closing apostrophe is found
-        while (!this.isEOF()) {
-            var ch = this.char();
-            if (ch === 39 /* `'` */) {
-                if (this.peek() === 39 /* `'` */) {
-                    codePoints.push(39);
-                    // Bump one more time because we need to skip 2 characters.
-                    this.bump();
-                }
-                else {
-                    // Optional closing apostrophe.
-                    this.bump();
-                    break;
-                }
-            }
-            else {
-                codePoints.push(ch);
-            }
-            this.bump();
-        }
-        return String.fromCodePoint.apply(String, codePoints);
-    };
-    Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {
-        if (this.isEOF()) {
-            return null;
-        }
-        var ch = this.char();
-        if (ch === 60 /* `<` */ ||
-            ch === 123 /* `{` */ ||
-            (ch === 35 /* `#` */ &&
-                (parentArgType === 'plural' || parentArgType === 'selectordinal')) ||
-            (ch === 125 /* `}` */ && nestingLevel > 0)) {
-            return null;
-        }
-        else {
-            this.bump();
-            return String.fromCodePoint(ch);
-        }
-    };
-    Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {
-        var openingBracePosition = this.clonePosition();
-        this.bump(); // `{`
-        this.bumpSpace();
-        if (this.isEOF()) {
-            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
-        }
-        if (this.char() === 125 /* `}` */) {
-            this.bump();
-            return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
-        }
-        // argument name
-        var value = this.parseIdentifierIfPossible().value;
-        if (!value) {
-            return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
-        }
-        this.bumpSpace();
-        if (this.isEOF()) {
-            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
-        }
-        switch (this.char()) {
-            // Simple argument: `{name}`
-            case 125 /* `}` */: {
-                this.bump(); // `}`
-                return {
-                    val: {
-                        type: TYPE.argument,
-                        // value does not include the opening and closing braces.
-                        value: value,
-                        location: createLocation(openingBracePosition, this.clonePosition()),
-                    },
-                    err: null,
-                };
-            }
-            // Argument with options: `{name, format, ...}`
-            case 44 /* `,` */: {
-                this.bump(); // `,`
-                this.bumpSpace();
-                if (this.isEOF()) {
-                    return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
-                }
-                return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
-            }
-            default:
-                return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));
-        }
-    };
-    /**
-     * Advance the parser until the end of the identifier, if it is currently on
-     * an identifier character. Return an empty string otherwise.
-     */
-    Parser.prototype.parseIdentifierIfPossible = function () {
-        var startingPosition = this.clonePosition();
-        var startOffset = this.offset();
-        var value = matchIdentifierAtIndex(this.message, startOffset);
-        var endOffset = startOffset + value.length;
-        this.bumpTo(endOffset);
-        var endPosition = this.clonePosition();
-        var location = createLocation(startingPosition, endPosition);
-        return { value: value, location: location };
-    };
-    Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {
-        var _a;
-        // Parse this range:
-        // {name, type, style}
-        //        ^---^
-        var typeStartPosition = this.clonePosition();
-        var argType = this.parseIdentifierIfPossible().value;
-        var typeEndPosition = this.clonePosition();
-        switch (argType) {
-            case '':
-                // Expecting a style string number, date, time, plural, selectordinal, or select.
-                return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
-            case 'number':
-            case 'date':
-            case 'time': {
-                // Parse this range:
-                // {name, number, style}
-                //              ^-------^
-                this.bumpSpace();
-                var styleAndLocation = null;
-                if (this.bumpIf(',')) {
-                    this.bumpSpace();
-                    var styleStartPosition = this.clonePosition();
-                    var result = this.parseSimpleArgStyleIfPossible();
-                    if (result.err) {
-                        return result;
-                    }
-                    var style = trimEnd(result.val);
-                    if (style.length === 0) {
-                        return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));
-                    }
-                    var styleLocation = createLocation(styleStartPosition, this.clonePosition());
-                    styleAndLocation = { style: style, styleLocation: styleLocation };
-                }
-                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
-                if (argCloseResult.err) {
-                    return argCloseResult;
-                }
-                var location_1 = createLocation(openingBracePosition, this.clonePosition());
-                // Extract style or skeleton
-                if (styleAndLocation && styleAndLocation.style.startsWith('::')) {
-                    // Skeleton starts with `::`.
-                    var skeleton = trimStart(styleAndLocation.style.slice(2));
-                    if (argType === 'number') {
-                        var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
-                        if (result.err) {
-                            return result;
-                        }
-                        return {
-                            val: { type: TYPE.number, value: value, location: location_1, style: result.val },
-                            err: null,
-                        };
-                    }
-                    else {
-                        if (skeleton.length === 0) {
-                            return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);
-                        }
-                        var dateTimePattern = skeleton;
-                        // Get "best match" pattern only if locale is passed, if not, let it
-                        // pass as-is where `parseDateTimeSkeleton()` will throw an error
-                        // for unsupported patterns.
-                        if (this.locale) {
-                            dateTimePattern = getBestPattern(skeleton, this.locale);
-                        }
-                        var style = {
-                            type: SKELETON_TYPE.dateTime,
-                            pattern: dateTimePattern,
-                            location: styleAndLocation.styleLocation,
-                            parsedOptions: this.shouldParseSkeletons
-                                ? parseDateTimeSkeleton(dateTimePattern)
-                                : {},
-                        };
-                        var type = argType === 'date' ? TYPE.date : TYPE.time;
-                        return {
-                            val: { type: type, value: value, location: location_1, style: style },
-                            err: null,
-                        };
-                    }
-                }
-                // Regular style or no style.
-                return {
-                    val: {
-                        type: argType === 'number'
-                            ? TYPE.number
-                            : argType === 'date'
-                                ? TYPE.date
-                                : TYPE.time,
-                        value: value,
-                        location: location_1,
-                        style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,
-                    },
-                    err: null,
-                };
-            }
-            case 'plural':
-            case 'selectordinal':
-            case 'select': {
-                // Parse this range:
-                // {name, plural, options}
-                //              ^---------^
-                var typeEndPosition_1 = this.clonePosition();
-                this.bumpSpace();
-                if (!this.bumpIf(',')) {
-                    return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));
-                }
-                this.bumpSpace();
-                // Parse offset:
-                // {name, plural, offset:1, options}
-                //                ^-----^
-                //
-                // or the first option:
-                //
-                // {name, plural, one {...} other {...}}
-                //                ^--^
-                var identifierAndLocation = this.parseIdentifierIfPossible();
-                var pluralOffset = 0;
-                if (argType !== 'select' && identifierAndLocation.value === 'offset') {
-                    if (!this.bumpIf(':')) {
-                        return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));
-                    }
-                    this.bumpSpace();
-                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);
-                    if (result.err) {
-                        return result;
-                    }
-                    // Parse another identifier for option parsing
-                    this.bumpSpace();
-                    identifierAndLocation = this.parseIdentifierIfPossible();
-                    pluralOffset = result.val;
-                }
-                var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
-                if (optionsResult.err) {
-                    return optionsResult;
-                }
-                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
-                if (argCloseResult.err) {
-                    return argCloseResult;
-                }
-                var location_2 = createLocation(openingBracePosition, this.clonePosition());
-                if (argType === 'select') {
-                    return {
-                        val: {
-                            type: TYPE.select,
-                            value: value,
-                            options: fromEntries(optionsResult.val),
-                            location: location_2,
-                        },
-                        err: null,
-                    };
-                }
-                else {
-                    return {
-                        val: {
-                            type: TYPE.plural,
-                            value: value,
-                            options: fromEntries(optionsResult.val),
-                            offset: pluralOffset,
-                            pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',
-                            location: location_2,
-                        },
-                        err: null,
-                    };
-                }
-            }
-            default:
-                return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));
-        }
-    };
-    Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {
-        // Parse: {value, number, ::currency/GBP }
-        //
-        if (this.isEOF() || this.char() !== 125 /* `}` */) {
-            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));
-        }
-        this.bump(); // `}`
-        return { val: true, err: null };
-    };
-    /**
-     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
-     */
-    Parser.prototype.parseSimpleArgStyleIfPossible = function () {
-        var nestedBraces = 0;
-        var startPosition = this.clonePosition();
-        while (!this.isEOF()) {
-            var ch = this.char();
-            switch (ch) {
-                case 39 /* `'` */: {
-                    // Treat apostrophe as quoting but include it in the style part.
-                    // Find the end of the quoted literal text.
-                    this.bump();
-                    var apostrophePosition = this.clonePosition();
-                    if (!this.bumpUntil("'")) {
-                        return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));
-                    }
-                    this.bump();
-                    break;
-                }
-                case 123 /* `{` */: {
-                    nestedBraces += 1;
-                    this.bump();
-                    break;
-                }
-                case 125 /* `}` */: {
-                    if (nestedBraces > 0) {
-                        nestedBraces -= 1;
-                    }
-                    else {
-                        return {
-                            val: this.message.slice(startPosition.offset, this.offset()),
-                            err: null,
-                        };
-                    }
-                    break;
-                }
-                default:
-                    this.bump();
-                    break;
-            }
-        }
-        return {
-            val: this.message.slice(startPosition.offset, this.offset()),
-            err: null,
-        };
-    };
-    Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {
-        var tokens = [];
-        try {
-            tokens = parseNumberSkeletonFromString(skeleton);
-        }
-        catch (_a) {
-            return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);
-        }
-        return {
-            val: {
-                type: SKELETON_TYPE.number,
-                tokens: tokens,
-                location: location,
-                parsedOptions: this.shouldParseSkeletons
-                    ? parseNumberSkeleton(tokens)
-                    : {},
-            },
-            err: null,
-        };
-    };
-    /**
-     * @param nesting_level The current nesting level of messages.
-     *     This can be positive when parsing message fragment in select or plural argument options.
-     * @param parent_arg_type The parent argument's type.
-     * @param parsed_first_identifier If provided, this is the first identifier-like selector of
-     *     the argument. It is a by-product of a previous parsing attempt.
-     * @param expecting_close_tag If true, this message is directly or indirectly nested inside
-     *     between a pair of opening and closing tags. The nested message will not parse beyond
-     *     the closing tag boundary.
-     */
-    Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
-        var _a;
-        var hasOtherClause = false;
-        var options = [];
-        var parsedSelectors = new Set();
-        var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;
-        // Parse:
-        // one {one apple}
-        // ^--^
-        while (true) {
-            if (selector.length === 0) {
-                var startPosition = this.clonePosition();
-                if (parentArgType !== 'select' && this.bumpIf('=')) {
-                    // Try parse `={number}` selector
-                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);
-                    if (result.err) {
-                        return result;
-                    }
-                    selectorLocation = createLocation(startPosition, this.clonePosition());
-                    selector = this.message.slice(startPosition.offset, this.offset());
-                }
-                else {
-                    break;
-                }
-            }
-            // Duplicate selector clauses
-            if (parsedSelectors.has(selector)) {
-                return this.error(parentArgType === 'select'
-                    ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR
-                    : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);
-            }
-            if (selector === 'other') {
-                hasOtherClause = true;
-            }
-            // Parse:
-            // one {one apple}
-            //     ^----------^
-            this.bumpSpace();
-            var openingBracePosition = this.clonePosition();
-            if (!this.bumpIf('{')) {
-                return this.error(parentArgType === 'select'
-                    ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT
-                    : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));
-            }
-            var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
-            if (fragmentResult.err) {
-                return fragmentResult;
-            }
-            var argCloseResult = this.tryParseArgumentClose(openingBracePosition);
-            if (argCloseResult.err) {
-                return argCloseResult;
-            }
-            options.push([
-                selector,
-                {
-                    value: fragmentResult.val,
-                    location: createLocation(openingBracePosition, this.clonePosition()),
-                },
-            ]);
-            // Keep track of the existing selectors
-            parsedSelectors.add(selector);
-            // Prep next selector clause.
-            this.bumpSpace();
-            (_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);
-        }
-        if (options.length === 0) {
-            return this.error(parentArgType === 'select'
-                ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR
-                : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));
-        }
-        if (this.requiresOtherClause && !hasOtherClause) {
-            return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));
-        }
-        return { val: options, err: null };
-    };
-    Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {
-        var sign = 1;
-        var startingPosition = this.clonePosition();
-        if (this.bumpIf('+')) {
-        }
-        else if (this.bumpIf('-')) {
-            sign = -1;
-        }
-        var hasDigits = false;
-        var decimal = 0;
-        while (!this.isEOF()) {
-            var ch = this.char();
-            if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {
-                hasDigits = true;
-                decimal = decimal * 10 + (ch - 48);
-                this.bump();
-            }
-            else {
-                break;
-            }
-        }
-        var location = createLocation(startingPosition, this.clonePosition());
-        if (!hasDigits) {
-            return this.error(expectNumberError, location);
-        }
-        decimal *= sign;
-        if (!Number.isSafeInteger(decimal)) {
-            return this.error(invalidNumberError, location);
-        }
-        return { val: decimal, err: null };
-    };
-    Parser.prototype.offset = function () {
-        return this.position.offset;
-    };
-    Parser.prototype.isEOF = function () {
-        return this.offset() === this.message.length;
-    };
-    Parser.prototype.clonePosition = function () {
-        // This is much faster than `Object.assign` or spread.
-        return {
-            offset: this.position.offset,
-            line: this.position.line,
-            column: this.position.column,
-        };
-    };
-    /**
-     * Return the code point at the current position of the parser.
-     * Throws if the index is out of bound.
-     */
-    Parser.prototype.char = function () {
-        var offset = this.position.offset;
-        if (offset >= this.message.length) {
-            throw Error('out of bound');
-        }
-        var code = this.message.codePointAt(offset);
-        if (code === undefined) {
-            throw Error("Offset ".concat(offset, " is at invalid UTF-16 code unit boundary"));
-        }
-        return code;
-    };
-    Parser.prototype.error = function (kind, location) {
-        return {
-            val: null,
-            err: {
-                kind: kind,
-                message: this.message,
-                location: location,
-            },
-        };
-    };
-    /** Bump the parser to the next UTF-16 code unit. */
-    Parser.prototype.bump = function () {
-        if (this.isEOF()) {
-            return;
-        }
-        var code = this.char();
-        if (code === 10 /* '\n' */) {
-            this.position.line += 1;
-            this.position.column = 1;
-            this.position.offset += 1;
-        }
-        else {
-            this.position.column += 1;
-            // 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.
-            this.position.offset += code < 0x10000 ? 1 : 2;
-        }
-    };
-    /**
-     * If the substring starting at the current position of the parser has
-     * the given prefix, then bump the parser to the character immediately
-     * following the prefix and return true. Otherwise, don't bump the parser
-     * and return false.
-     */
-    Parser.prototype.bumpIf = function (prefix) {
-        if (this.message.startsWith(prefix, this.offset())) {
-            for (var i = 0; i < prefix.length; i++) {
-                this.bump();
-            }
-            return true;
-        }
-        return false;
-    };
-    /**
-     * Bump the parser until the pattern character is found and return `true`.
-     * Otherwise bump to the end of the file and return `false`.
-     */
-    Parser.prototype.bumpUntil = function (pattern) {
-        var currentOffset = this.offset();
-        var index = this.message.indexOf(pattern, currentOffset);
-        if (index >= 0) {
-            this.bumpTo(index);
-            return true;
-        }
-        else {
-            this.bumpTo(this.message.length);
-            return false;
-        }
-    };
-    /**
-     * Bump the parser to the target offset.
-     * If target offset is beyond the end of the input, bump the parser to the end of the input.
-     */
-    Parser.prototype.bumpTo = function (targetOffset) {
-        if (this.offset() > targetOffset) {
-            throw Error("targetOffset ".concat(targetOffset, " must be greater than or equal to the current offset ").concat(this.offset()));
-        }
-        targetOffset = Math.min(targetOffset, this.message.length);
-        while (true) {
-            var offset = this.offset();
-            if (offset === targetOffset) {
-                break;
-            }
-            if (offset > targetOffset) {
-                throw Error("targetOffset ".concat(targetOffset, " is at invalid UTF-16 code unit boundary"));
-            }
-            this.bump();
-            if (this.isEOF()) {
-                break;
-            }
-        }
-    };
-    /** advance the parser through all whitespace to the next non-whitespace code unit. */
-    Parser.prototype.bumpSpace = function () {
-        while (!this.isEOF() && _isWhiteSpace(this.char())) {
-            this.bump();
-        }
-    };
-    /**
-     * Peek at the *next* Unicode codepoint in the input without advancing the parser.
-     * If the input has been exhausted, then this returns null.
-     */
-    Parser.prototype.peek = function () {
-        if (this.isEOF()) {
-            return null;
-        }
-        var code = this.char();
-        var offset = this.offset();
-        var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));
-        return nextCode !== null && nextCode !== void 0 ? nextCode : null;
-    };
-    return Parser;
-}());
-export { Parser };
 /**
- * This check if codepoint is alphabet (lower & uppercase)
- * @param codepoint
- * @returns
- */
+* This check if codepoint is alphabet (lower & uppercase)
+* @param codepoint
+* @returns
+*/
 function _isAlpha(codepoint) {
-    return ((codepoint >= 97 && codepoint <= 122) ||
-        (codepoint >= 65 && codepoint <= 90));
+	return codepoint >= 97 && codepoint <= 122 || codepoint >= 65 && codepoint <= 90;
 }
 function _isAlphaOrSlash(codepoint) {
-    return _isAlpha(codepoint) || codepoint === 47; /* '/' */
+	return _isAlpha(codepoint) || codepoint === 47;
 }
 /** See `parseTag` function docs. */
 function _isPotentialElementNameChar(c) {
-    return (c === 45 /* '-' */ ||
-        c === 46 /* '.' */ ||
-        (c >= 48 && c <= 57) /* 0..9 */ ||
-        c === 95 /* '_' */ ||
-        (c >= 97 && c <= 122) /** a..z */ ||
-        (c >= 65 && c <= 90) /* A..Z */ ||
-        c == 0xb7 ||
-        (c >= 0xc0 && c <= 0xd6) ||
-        (c >= 0xd8 && c <= 0xf6) ||
-        (c >= 0xf8 && c <= 0x37d) ||
-        (c >= 0x37f && c <= 0x1fff) ||
-        (c >= 0x200c && c <= 0x200d) ||
-        (c >= 0x203f && c <= 0x2040) ||
-        (c >= 0x2070 && c <= 0x218f) ||
-        (c >= 0x2c00 && c <= 0x2fef) ||
-        (c >= 0x3001 && c <= 0xd7ff) ||
-        (c >= 0xf900 && c <= 0xfdcf) ||
-        (c >= 0xfdf0 && c <= 0xfffd) ||
-        (c >= 0x10000 && c <= 0xeffff));
+	return c === 45 || c === 46 || c >= 48 && c <= 57 || c === 95 || c >= 97 && c <= 122 || c >= 65 && c <= 90 || c == 183 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8255 && c <= 8256 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
 }
 /**
- * Code point equivalent of regex `\p{White_Space}`.
- * From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
- */
+* Code point equivalent of regex `\p{White_Space}`.
+* From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
+*/
 function _isWhiteSpace(c) {
-    return ((c >= 0x0009 && c <= 0x000d) ||
-        c === 0x0020 ||
-        c === 0x0085 ||
-        (c >= 0x200e && c <= 0x200f) ||
-        c === 0x2028 ||
-        c === 0x2029);
+	return c >= 9 && c <= 13 || c === 32 || c === 133 || c >= 8206 && c <= 8207 || c === 8232 || c === 8233;
 }