{

public const ENCODING = 'UTF-8';

/** @var string[] */

private array $messageArray;

private string $message;

private int $messageLength;

private Type\LocationDetails $position;

private bool $ignoreTag;

private bool $requiresOtherClause;

private bool $shouldParseSkeletons;

private CodePointHelper $codePointHelper;

private DateTimeSkeletonParser $dateTimeSkeletonParser;

private NumberSkeletonParser $numberSkeletonParser;

public function __construct(string $message, ?Options $options = null)

{

$this->message = $message;

$this->messageLength = mb_strlen($message, self::ENCODING);

$this->messageArray = mb_str_split($message, 1, self::ENCODING);

$this->position = new Type\LocationDetails(0, 1, 1);

$this->ignoreTag = $options->ignoreTag ?? false;

$this->requiresOtherClause = $options->requiresOtherClause ?? false;

$this->shouldParseSkeletons = $options->shouldParseSkeletons ?? false;

$this->codePointHelper = new CodePointHelper();

$this->dateTimeSkeletonParser = new DateTimeSkeletonParser();

$this->numberSkeletonParser = new NumberSkeletonParser();

}

/**

public function parse(): Result

{

if ($this->offset() !== 0) {

throw new Exception\IllegalParserUsageException('The parser may only be used once');

}

return $this->parseMessage(0, '', false);

}

/**

private function parseMessage(int $nestingLevel, string $parentArgType, bool $expectingCloseTag): Result

{

$elements = new Type\ElementCollection();

while (!$this->isEof()) {

$char = $this->char();

if ($char === CodePoint::LEFT_CURLY_BRACE) {

$result = $this->parseArgument($nestingLevel, $expectingCloseTag);

if ($result->err instanceof Error) {

return $result;

}

assert($result->val !== null);

$elements = $elements->merge($result->val);

} elseif ($char === CodePoint::RIGHT_CURLY_BRACE && $nestingLevel > 0) {

break;

} elseif (

$char === CodePoint::NUMBER_SIGN

&& ($parentArgType === 'plural' || $parentArgType === 'selectordinal')

) {

$position = $this->clonePosition();

$this->bump();

$elements->add(new Type\PoundElement(new Type\Location($position, $this->clonePosition())));

} elseif (

$char === CodePoint::LEFT_ANGLE_BRACKET

&& !$this->ignoreTag

&& $this->peek() === CodePoint::FORWARD_SLASH

) {

if ($expectingCloseTag) {

break;

}

return $this->error(

Error::UNMATCHED_CLOSING_TAG,

new Type\Location($this->clonePosition(), $this->clonePosition()),

);

} elseif (

$char === CodePoint::LEFT_ANGLE_BRACKET

&& !$this->ignoreTag

&& $this->codePointHelper->isAlpha($this->peek() ?? 0)

) {

$result = $this->parseTag($nestingLevel, $parentArgType);

if ($result->err instanceof Error) {

return $result;

}

assert($result->val !== null);

$elements = $elements->merge($result->val);

} else {

$result = $this->parseLiteral($nestingLevel, $parentArgType);

assert($result->val !== null);

$elements = $elements->merge($result->val);

}

}

return new Result($elements);

}

/**

private function parseTag(int $nestingLevel, string $parentArgType): Result

{

$startPosition = $this->clonePosition();

$this->bump(); // '<'

$tagName = $this->parseTagName();

$this->bumpSpace();

if ($this->bumpIf('/>')) {

// Self-closing tag.

return new Result(new Type\ElementCollection([

new Type\LiteralElement("<$tagName/>", new Type\Location($startPosition, $this->clonePosition())),

]));

} elseif ($this->bumpIf('>')) {

$childrenResult = $this->parseMessage($nestingLevel + 1, $parentArgType, true);

if ($childrenResult->err !== null) {

return $childrenResult;

}

$endTagStartPosition = $this->clonePosition();

if ($this->bumpIf('</')) {

if ($this->isEof() || !$this->codePointHelper->isAlpha($this->char())) {

return $this->error(

Error::INVALID_TAG,

new Type\Location($endTagStartPosition, $this->clonePosition()),

);

}

$closingTagNameStartPosition = $this->clonePosition();

$closingTagName = $this->parseTagName();

if ($tagName !== $closingTagName) {

return $this->error(

Error::UNMATCHED_CLOSING_TAG,

new Type\Location($closingTagNameStartPosition, $this->clonePosition()),

);

}

$this->bumpSpace();

if (!$this->bumpIf('>')) {

return $this->error(

Error::INVALID_TAG,

new Type\Location($endTagStartPosition, $this->clonePosition()),

);

}

$children = $childrenResult->val;

assert($children !== null);

return new Result(new Type\ElementCollection([

new Type\TagElement($tagName, $children, new Type\Location($startPosition, $this->clonePosition())),

]));

}

return $this->error(

Error::UNCLOSED_TAG,

new Type\Location($startPosition, $this->clonePosition()),

);

}

return $this->error(

Error::INVALID_TAG,

new Type\Location($startPosition, $this->clonePosition()),

);

}

/**

private function parseTagName(): string

{

$startOffset = $this->offset();

$this->bump(); // the first tag name character

while (!$this->isEof() && $this->codePointHelper->isPotentialElementNameChar($this->char())) {

$this->bump();

}

$length = $this->offset() - $startOffset;

return mb_substr($this->message, $startOffset, $length, self::ENCODING);

}

/**

private function parseArgument(int $nestingLevel, bool $expectingCloseTag): Result

{

$openingBracePosition = $this->clonePosition();

$this->bump(); // '{'

$this->bumpSpace();

if ($this->isEof()) {

return $this->error(

Error::EXPECT_ARGUMENT_CLOSING_BRACE,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

if ($this->char() === CodePoint::RIGHT_CURLY_BRACE) {

$this->bump();

return $this->error(

Error::EMPTY_ARGUMENT,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

// Argument name.

$value = $this->parseIdentifierIfPossible()['value'];

if ($value === '') {

return $this->error(

Error::MALFORMED_ARGUMENT,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

$this->bumpSpace();

if ($this->isEof()) {

return $this->error(

Error::EXPECT_ARGUMENT_CLOSING_BRACE,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

switch ($this->char()) {

// Simple argument: `{name}`

case CodePoint::RIGHT_CURLY_BRACE:

$this->bump();

return new Result(new Type\ElementCollection([

new Type\ArgumentElement($value, new Type\Location($openingBracePosition, $this->clonePosition())),

]));

// Argument with options: `{name, format, ...}`

case CodePoint::COMMA:

$this->bump();

$this->bumpSpace();

if ($this->isEof()) {

return $this->error(

Error::EXPECT_ARGUMENT_CLOSING_BRACE,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

return $this->parseArgumentOptions($nestingLevel, $expectingCloseTag, $value, $openingBracePosition);

}

return $this->error(

Error::MALFORMED_ARGUMENT,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

/**

private function parseLiteral(int $nestingLevel, string $parentArgType): Result

{

$start = $this->clonePosition();

$value = '';

while (true) {

$quoted = $this->tryParseQuote($parentArgType);

if ($quoted !== null) {

$value .= $quoted;

continue;

}

$unquoted = $this->tryParseUnquoted($nestingLevel, $parentArgType);

if ($unquoted !== null) {

$value .= $unquoted;

continue;

}

$leftAngle = $this->tryParseLeftAngleBracket();

if ($leftAngle !== null) {

$value .= $leftAngle;

continue;

}

break;

}

$location = new Type\Location($start, $this->clonePosition());

return new Result(new Type\ElementCollection([new Type\LiteralElement($value, $location)]));

}

/**

private function tryParseQuote(string $parentArgType): ?string

{

if ($this->isEof() || $this->char() !== CodePoint::STRAIGHT_APOSTROPHE) {

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 CodePoint::STRAIGHT_APOSTROPHE:

// Two apostrophes in a row; should return as a single one.

$this->bump();

$this->bump();

return "'";

case CodePoint::LEFT_CURLY_BRACE:

case CodePoint::LEFT_ANGLE_BRACKET:

case CodePoint::RIGHT_ANGLE_BRACKET:

case CodePoint::RIGHT_CURLY_BRACE:

break;

case CodePoint::NUMBER_SIGN:

if ($parentArgType === 'plural' || $parentArgType === 'selectordinal') {

break;

}

return null;

default:

return null;

}

$this->bump(); // apostrophe

$codePoints = [$this->char()]; // escaped char

$this->bump();

// Read chars until the optional closing apostrophe is found.

while (!$this->isEof()) {

$char = $this->char();

if ($char === CodePoint::STRAIGHT_APOSTROPHE) {

if ($this->peek() === CodePoint::STRAIGHT_APOSTROPHE) {

$codePoints[] = CodePoint::STRAIGHT_APOSTROPHE;

// Bump one more time because we need to skip 2 characters.

$this->bump();

} else {

// Optional closing apostrophe.

$this->bump();

break;

}

} else {

$codePoints[] = $char;

}

$this->bump();

}

return $this->codePointHelper->fromCodePoint(...$codePoints);

}

/**

private function tryParseUnquoted(int $nestingLevel, string $parentArgType): ?string

{

if ($this->isEof()) {

return null;

}

$char = $this->char();

if (

$char === CodePoint::LEFT_ANGLE_BRACKET

|| $char === CodePoint::LEFT_CURLY_BRACE

|| (

$char === CodePoint::NUMBER_SIGN

&& ($parentArgType === 'plural' || $parentArgType === 'selectordinal')

)

|| ($char === CodePoint::RIGHT_CURLY_BRACE && $nestingLevel > 0)

) {

return null;

}

$this->bump();

return $this->codePointHelper->fromCodePoint($char);

}

/**

private function tryParseLeftAngleBracket(): ?string

{

if (

!$this->isEof()

&& $this->char() === CodePoint::LEFT_ANGLE_BRACKET

&& (

$this->ignoreTag

// If at the opening tag or closing tag position, bail.

|| !$this->codePointHelper->isAlphaOrSlash($this->peek() ?? 0)

)

) {

$this->bump(); // '<'

return '<';

}

return null;

}

/**

private function parseIdentifierIfPossible(): array

{

$startingPosition = $this->clonePosition();

$startOffset = $this->offset();

$value = $this->matchIdentifierAtIndex($startOffset);

$endOffset = $startOffset + mb_strlen($value, self::ENCODING);

$this->bumpTo($endOffset);

$endPosition = $this->clonePosition();

$location = new Type\Location($startingPosition, $endPosition);

return [

'value' => $value,

'location' => $location,

];

}

/**

private function parseArgumentOptions(

int $nestingLevel,

bool $expectingCloseTag,

string $value,

Type\LocationDetails $openingBracePosition

): Result {

// Parse this range:

// {name, type, style}

// ^---^

$typeStartPosition = $this->clonePosition();

/** @var ArgType $argType */

$argType = $this->parseIdentifierIfPossible()['value'];

$typeEndPosition = $this->clonePosition();

switch ($argType) {

case '':

// Expecting a style string number, date, time, plural, selectordinal, or select.

return $this->error(

Error::EXPECT_ARGUMENT_TYPE,

new Type\Location($typeStartPosition, $typeEndPosition),

);

case 'number':

case 'date':

case 'time':

// Parse this range:

// {name, number, style}

// ^-------^

$this->bumpSpace();

/** @var array{style: string, styleLocation: Type\Location} | null $styleAndLocation */

$styleAndLocation = null;

if ($this->bumpIf(',')) {

$this->bumpSpace();

$startStylePosition = $this->clonePosition();

$result = $this->parseSimpleArgStyleIfPossible();

if ($result['error'] !== null) {

return new Result(null, $result['error']);

}

$style = rtrim((string) $result['value'], CodePointHelper::WHITE_SPACE_TOKENS);

if (mb_strlen($style) === 0) {

return $this->error(

Error::EXPECT_ARGUMENT_STYLE,

new Type\Location($this->clonePosition(), $this->clonePosition()),

);

}

$styleLocation = new Type\Location($startStylePosition, $this->clonePosition());

$styleAndLocation = [

'style' => $style,

'styleLocation' => $styleLocation,

];

}

$argCloseResult = $this->tryParseArgumentClose($openingBracePosition);

if ($argCloseResult !== null) {

return new Result(null, $argCloseResult);

}

$location = new Type\Location($openingBracePosition, $this->clonePosition());

// Extract style or skeleton.

if (

$styleAndLocation !== null

&& mb_strpos($styleAndLocation['style'], '::', 0, self::ENCODING) === 0

) {

$skeleton = ltrim(

mb_substr($styleAndLocation['style'], 2, null, self::ENCODING),

CodePointHelper::WHITE_SPACE_TOKENS,

);

if ($argType === 'number') {

try {

$numberSkeleton = $this->numberSkeletonParser->parse(

$skeleton,

$styleAndLocation['styleLocation'],

$this->shouldParseSkeletons,

);

return new Result(new Type\ElementCollection([

new Type\NumberElement($value, $location, $numberSkeleton),

]));

} catch (Exception\ParserExceptionInterface $exception) {

return new Result(

null,

new Error(

Error::INVALID_NUMBER_SKELETON,

$this->message,

$styleAndLocation['styleLocation'],

$exception,

),

);

}

} else {

if (mb_strlen($skeleton, self::ENCODING) === 0) {

return $this->error(Error::EXPECT_DATE_TIME_SKELETON, $location);

}

$dateTimeSkeleton = new Type\DateTimeSkeleton(

$skeleton,

$styleAndLocation['styleLocation'],

$this->shouldParseSkeletons ? $this->dateTimeSkeletonParser->parse($skeleton) : null,

);

if ($argType === 'date') {

$element = new Type\DateElement($value, $location, $dateTimeSkeleton);

} else {

$element = new Type\TimeElement($value, $location, $dateTimeSkeleton);

}

return new Result(new Type\ElementCollection([$element]));

}

}

// Regular style or no style.

if ($argType === 'number') {

$element = new Type\NumberElement($value, $location, $styleAndLocation['style'] ?? null);

} elseif ($argType === 'date') {

$element = new Type\DateElement($value, $location, $styleAndLocation['style'] ?? null);

} else {

$element = new Type\TimeElement($value, $location, $styleAndLocation['style'] ?? null);

}

return new Result(new Type\ElementCollection([$element]));

case 'plural':

case 'selectordinal':

case 'select':

// Parse this range:

// {name, plural, options}

// ^---------^

$typeEndPosition = $this->clonePosition();

$this->bumpSpace();

if (!$this->bumpIf(',')) {

return $this->error(

Error::EXPECT_SELECT_ARGUMENT_OPTIONS,

new Type\Location($typeEndPosition, clone $typeEndPosition),

);

}

$this->bumpSpace();

// Parse offset:

// {name, plural, offset:1, options}

// ^-----^

//

// or the first option:

//

// {name, plural, one {...} other {...}}

// ^--^

$identifierAndLocation = $this->parseIdentifierIfPossible();

$pluralOffset = 0;

if ($argType !== 'select' && $identifierAndLocation['value'] === 'offset') {

if (!$this->bumpIf(':')) {

return $this->error(

Error::EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE,

new Type\Location($this->clonePosition(), $this->clonePosition()),

);

}

$this->bumpSpace();

$decimalResult = $this->tryParseDecimalInteger(

Error::EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE,

Error::INVALID_PLURAL_ARGUMENT_OFFSET_VALUE,

);

if ($decimalResult['error'] !== null) {

return new Result(null, $decimalResult['error']);

}

// Parse another identifier for option parsing

$this->bumpSpace();

$identifierAndLocation = $this->parseIdentifierIfPossible();

$pluralOffset = $decimalResult['value'];

}

$optionsResult = $this->tryParsePluralOrSelectOptions(

$nestingLevel,

$argType,

$expectingCloseTag,

$identifierAndLocation,

);

if ($optionsResult['error'] !== null) {

return new Result(null, $optionsResult['error']);

}

$argCloseResult = $this->tryParseArgumentClose($openingBracePosition);

if ($argCloseResult !== null) {

return new Result(null, $argCloseResult);

}

$location = new Type\Location($openingBracePosition, $this->clonePosition());

assert($optionsResult['value'] !== null);

if ($argType === 'select') {

return new Result(new Type\ElementCollection([

new Type\SelectElement(

$value,

array_column($optionsResult['value'], 1, 0),

$location,

),

]));

} else {

return new Result(new Type\ElementCollection([

new Type\PluralElement(

$value,

array_column($optionsResult['value'], 1, 0),

$pluralOffset,

$argType === 'plural' ? 'cardinal' : 'ordinal',

$location,

),

]));

}

}

/** @phpstan-ignore deadCode.unreachable */

return $this->error(

Error::INVALID_ARGUMENT_TYPE,

new Type\Location($typeStartPosition, $typeEndPosition),

);

}

/**

private function tryParseArgumentClose(Type\LocationDetails $openingBracePosition): ?Error

{

// Parse: {value, number, ::currency/GBP }

if ($this->isEof() || $this->char() !== CodePoint::RIGHT_CURLY_BRACE) {

return new Error(

Error::EXPECT_ARGUMENT_CLOSING_BRACE,

$this->message,

new Type\Location($openingBracePosition, $this->clonePosition()),

);

}

$this->bump(); // '}'

return null;

}

/**

private function parseSimpleArgStyleIfPossible(): array

{

$nestedBraces = 0;

$startPosition = $this->clonePosition();

while (!$this->isEof()) {

$char = $this->char();

switch ($char) {

case CodePoint::STRAIGHT_APOSTROPHE:

// Treat apostrophe as quoting but include it in the style part.

// Find the end of the quoted literal text.

$this->bump();

$apostrophePosition = $this->clonePosition();

if (!$this->bumpUntil("'")) {

return [

'value' => null,

'error' => new Error(

Error::UNCLOSED_QUOTE_IN_ARGUMENT_STYLE,

$this->message,

new Type\Location($apostrophePosition, $this->clonePosition()),

),

];

}

$this->bump();

break;

case CodePoint::LEFT_CURLY_BRACE:

++$nestedBraces;

$this->bump();

break;

case CodePoint::RIGHT_CURLY_BRACE:

if ($nestedBraces > 0) {

--$nestedBraces;

} else {

$length = $this->offset() - $startPosition->offset;

return [

'value' => mb_substr($this->message, $startPosition->offset, $length, self::ENCODING),

'error' => null,

];

}

break;

default:

$this->bump();

break;

}

}

$length = $this->offset() - $startPosition->offset;

return [

'value' => mb_substr($this->message, $startPosition->offset, $length, self::ENCODING),

'error' => null,

];

}

/**

private function tryParseDecimalInteger(int $expectNumberError, int $invalidNumberError): array

{

$sign = 1;

$startingPosition = $this->clonePosition();

// phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedIf

if ($this->bumpIf('+')) {

// Empty on purpose.

} elseif ($this->bumpIf('-')) {

$sign = -1;

}

$hasDigits = false;

$decimal = 0;

while (!$this->isEof()) {

$char = $this->char();

if ($char >= CodePoint::ZERO && $char <= CodePoint::NINE) {

$hasDigits = true;

$decimal = $decimal * 10 + $char - CodePoint::ZERO;

$this->bump();

} else {

break;

}

}

$location = new Type\Location($startingPosition, $this->clonePosition());

if (!$hasDigits) {

return [

'value' => null,

'error' => new Error($expectNumberError, $this->message, $location),

];

}

$decimal *= $sign;

if (!$this->isSafeInteger($decimal)) {

return [

'value' => null,

'error' => new Error($invalidNumberError, $this->message, $location),

];

}

return ['value' => $decimal, 'error' => null];

}

/**

private function tryParsePluralOrSelectOptions(

int $nestingLevel,

string $parentArgType,

bool $expectCloseTag,

array $parsedFirstIdentifier

): array {

$hasOtherClause = false;

$parsedSelectors = [];

$selector = $parsedFirstIdentifier['value'];

$selectorLocation = $parsedFirstIdentifier['location'];

/** @var array<array{string, Type\PluralOrSelectOption}> $options */

$options = [];

// Parse:

// one {one apple}

// ^--^

while (true) {

if (mb_strlen($selector, self::ENCODING) === 0) {

$startPosition = $this->clonePosition();

if ($parentArgType !== 'select' && $this->bumpIf('=')) {

// Try parse `={number}` selector

$decimalResult = $this->tryParseDecimalInteger(

Error::EXPECT_PLURAL_ARGUMENT_SELECTOR,

Error::INVALID_PLURAL_ARGUMENT_SELECTOR,

);

if ($decimalResult['error'] !== null) {

return ['value' => null, 'error' => $decimalResult['error']];

}

$selectorLocation = new Type\Location($startPosition, $this->clonePosition());

$length = $this->offset() - $startPosition->offset;

$selector = mb_substr($this->message, $startPosition->offset, $length, self::ENCODING);

} else {

break;

}

}

// Duplicate selector clauses

if (in_array($selector, $parsedSelectors)) {

return [

'value' => null,