@prisma-next/psl-parser 0.3.0-dev.99 → 0.3.0

package/src/parser.ts

@@ -5,6 +5,7 @@ import type {
   PslAttribute,
   PslAttributeArgument,
   PslAttributeTarget,
+  PslCompositeType,
   PslDiagnostic,
   PslDiagnosticCode,
   PslDocumentAst,
@@ -17,6 +18,7 @@ import type {
   PslNamedTypeDeclaration,
   PslPosition,
   PslSpan,
+  PslTypeConstructorCall,
   PslTypesBlock,
 } from './types';
 
@@ -61,6 +63,7 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
 
   const models: PslModel[] = [];
   const enums: PslEnum[] = [];
+  const compositeTypes: PslCompositeType[] = [];
   let typesBlock: PslTypesBlock | undefined;
 
   let lineIndex = 0;
@@ -98,6 +101,19 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
       continue;
     }
 
+    const compositeTypeMatch = line.match(/^type\s+([A-Za-z_]\w*)\s*\{$/);
+    if (compositeTypeMatch) {
+      const bounds = findBlockBounds(context, lineIndex);
+      const name = compositeTypeMatch[1] ?? '';
+      if (name.length === 0) {
+        lineIndex = bounds.endLine + 1;
+        continue;
+      }
+      compositeTypes.push(parseCompositeTypeBlock(context, name, bounds));
+      lineIndex = bounds.endLine + 1;
+      continue;
+    }
+
     if (/^types\s*\{$/.test(line)) {
       const bounds = findBlockBounds(context, lineIndex);
       typesBlock = parseTypesBlock(context, bounds);
@@ -130,6 +146,7 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
   );
   const modelNames = new Set(models.map((model) => model.name));
   const enumNames = new Set(enums.map((enumBlock) => enumBlock.name));
+  const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
   for (const declaration of typesBlock?.declarations ?? []) {
     if (SCALAR_TYPES.has(declaration.name)) {
       pushDiagnostic(context, {
@@ -168,6 +185,7 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
         hasRelationAttribute ||
         modelNames.has(field.typeName) ||
         enumNames.has(field.typeName) ||
+        compositeTypeNames.has(field.typeName) ||
         SCALAR_TYPES.has(field.typeName)
       ) {
         return field;
@@ -184,6 +202,7 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
     sourceId: input.sourceId,
     models: normalizedModels,
     enums,
+    compositeTypes,
     ...ifDefined('types', typesBlock),
     span: {
       start: createPosition(context, 0, 0),
@@ -236,8 +255,47 @@ function parseModelBlock(context: ParserContext, name: string, bounds: BlockBoun
   };
 }
 
+function parseCompositeTypeBlock(
+  context: ParserContext,
+  name: string,
+  bounds: BlockBounds,
+): PslCompositeType {
+  const fields: PslField[] = [];
+  const attributes: PslAttribute[] = [];
+
+  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
+    const raw = context.lines[lineIndex] ?? '';
+    const line = stripInlineComment(raw).trim();
+    if (line.length === 0) {
+      continue;
+    }
+
+    if (line.startsWith('@@')) {
+      const attribute = parseModelAttribute(context, line, lineIndex);
+      if (attribute) {
+        attributes.push(attribute);
+      }
+      continue;
+    }
+
+    const field = parseField(context, line, lineIndex);
+    if (field) {
+      fields.push(field);
+    }
+  }
+
+  return {
+    kind: 'compositeType',
+    name,
+    fields,
+    attributes,
+    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
+  };
+}
+
 function parseEnumBlock(context: ParserContext, name: string, bounds: BlockBounds): PslEnum {
   const values: PslEnumValue[] = [];
+  const attributes: PslAttribute[] = [];
 
   for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
     const raw = context.lines[lineIndex] ?? '';
@@ -246,6 +304,14 @@ function parseEnumBlock(context: ParserContext, name: string, bounds: BlockBound
       continue;
     }
 
+    if (line.startsWith('@@')) {
+      const attribute = parseEnumAttribute(context, line, lineIndex);
+      if (attribute) {
+        attributes.push(attribute);
+      }
+      continue;
+    }
+
     const valueMatch = line.match(/^([A-Za-z_]\w*)$/);
     if (!valueMatch) {
       pushDiagnostic(context, {
@@ -267,6 +333,7 @@ function parseEnumBlock(context: ParserContext, name: string, bounds: BlockBound
     kind: 'enum',
     name,
     values,
+    attributes,
     span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
   };
 }
@@ -282,7 +349,7 @@ function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesB
       continue;
     }
 
-    const declarationMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*([A-Za-z_]\w*)(.*)$/);
+    const declarationMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
     if (!declarationMatch) {
       pushDiagnostic(context, {
         code: 'PSL_INVALID_TYPES_MEMBER',
@@ -293,17 +360,33 @@ function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesB
     }
 
     const declarationName = declarationMatch[1] ?? '';
-    const baseType = declarationMatch[2] ?? '';
-    const attributePart = declarationMatch[3] ?? '';
     const trimmedStartColumn = firstNonWhitespaceColumn(raw);
-    const attributeOffset = line.length - attributePart.length;
-    const attributeSource = attributePart.trimStart();
-    const leadingAttributeWhitespace = attributePart.length - attributeSource.length;
+    const declarationValue = (declarationMatch[2] ?? '').trim();
+    const valueOffset = line.indexOf(declarationValue);
+    const declarationValueColumn = trimmedStartColumn + Math.max(valueOffset, 0);
+
+    const typeAndAttributeSplit = splitTypeAndAttributes(declarationValue);
+    const typeSource = typeAndAttributeSplit.typeSource.trim();
+    const attributeSource = typeAndAttributeSplit.attributeSource.trimStart();
+    const leadingAttributeWhitespace =
+      typeAndAttributeSplit.attributeSource.length - attributeSource.length;
+
+    const typeConstructor = parseTypeConstructorCall(context, {
+      declarationValue: typeSource,
+      lineIndex,
+      startColumn: declarationValueColumn,
+      invalidCode: 'PSL_INVALID_TYPES_MEMBER',
+      invalidMessage: (value) => `Invalid types declaration "${value}"`,
+    });
+    if (typeConstructor === 'malformed') {
+      continue;
+    }
+
     const attributeParse = extractAttributeTokensWithSpans(
       context,
       lineIndex,
       attributeSource,
-      trimmedStartColumn + attributeOffset + leadingAttributeWhitespace,
+      declarationValueColumn + typeAndAttributeSplit.attributeOffset + leadingAttributeWhitespace,
     );
     if (!attributeParse.ok) {
       continue;
@@ -319,6 +402,29 @@ function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesB
       )
       .filter((attribute): attribute is PslAttribute => Boolean(attribute));
 
+    if (typeConstructor) {
+      declarations.push({
+        kind: 'namedType',
+        name: declarationName,
+        typeConstructor,
+        attributes,
+        span: createTrimmedLineSpan(context, lineIndex),
+      });
+      continue;
+    }
+
+    const baseTypeMatch = typeSource.match(/^([A-Za-z_]\w*)$/);
+    if (!baseTypeMatch) {
+      pushDiagnostic(context, {
+        code: 'PSL_INVALID_TYPES_MEMBER',
+        message: `Invalid types declaration "${line}"`,
+        span: createTrimmedLineSpan(context, lineIndex),
+      });
+      continue;
+    }
+
+    const baseType = baseTypeMatch[1] ?? '';
+
     declarations.push({
       kind: 'namedType',
       name: declarationName,
@@ -335,6 +441,78 @@ function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesB
   };
 }
 
+function parseTypeConstructorCall(
+  context: ParserContext,
+  input: {
+    readonly declarationValue: string;
+    readonly lineIndex: number;
+    readonly startColumn: number;
+    readonly invalidCode: PslDiagnosticCode;
+    readonly invalidMessage: (value: string) => string;
+  },
+): PslTypeConstructorCall | 'malformed' | undefined {
+  const value = input.declarationValue.trim();
+  const constructorMatch = value.match(
+    /^([A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*)\s*\(/,
+  );
+  if (!constructorMatch) {
+    return undefined;
+  }
+
+  // constructorMatch already required `(`; openParen is guaranteed ≥ 0.
+  const openParen = value.indexOf('(');
+  const closeParen = value.lastIndexOf(')');
+
+  if (closeParen !== value.length - 1) {
+    pushDiagnostic(context, {
+      code: input.invalidCode,
+      message: input.invalidMessage(value),
+      span: createInlineSpan(
+        context,
+        input.lineIndex,
+        input.startColumn,
+        input.startColumn + value.length,
+      ),
+    });
+    return 'malformed';
+  }
+
+  const constructorPath = constructorMatch[1] ?? '';
+
+  const argsRaw = value.slice(openParen + 1, closeParen);
+  const args = parseArgumentList(context, {
+    argsRaw,
+    argsOffset: input.startColumn + openParen + 1,
+    lineIndex: input.lineIndex,
+    token: value,
+    span: createInlineSpan(
+      context,
+      input.lineIndex,
+      input.startColumn,
+      input.startColumn + value.length,
+    ),
+    invalidCode: input.invalidCode,
+    invalidEmptyArgumentMessage: `Invalid empty argument in type constructor "${value}"`,
+    invalidNamedArgumentMessage: (part) =>
+      `Invalid named argument syntax "${part}" in type constructor "${value}"`,
+  });
+  if (!args) {
+    return 'malformed';
+  }
+
+  return {
+    kind: 'typeConstructor',
+    path: constructorPath.split('.'),
+    args,
+    span: createInlineSpan(
+      context,
+      input.lineIndex,
+      input.startColumn,
+      input.startColumn + value.length,
+    ),
+  };
+}
+
 function parseModelAttribute(
   context: ParserContext,
   line: string,
@@ -367,8 +545,52 @@ function parseModelAttribute(
   });
 }
 
+function parseEnumAttribute(
+  context: ParserContext,
+  line: string,
+  lineIndex: number,
+): PslAttribute | undefined {
+  const rawLine = context.lines[lineIndex] ?? '';
+  const tokenParse = extractAttributeTokensWithSpans(
+    context,
+    lineIndex,
+    line,
+    firstNonWhitespaceColumn(rawLine),
+  );
+  if (!tokenParse.ok || tokenParse.tokens.length !== 1) {
+    pushDiagnostic(context, {
+      code: 'PSL_INVALID_ENUM_MEMBER',
+      message: `Invalid enum value declaration "${line}"`,
+      span: createTrimmedLineSpan(context, lineIndex),
+    });
+    return undefined;
+  }
+  const token = tokenParse.tokens[0];
+  if (!token) {
+    return undefined;
+  }
+  const parsed = parseAttributeToken(context, {
+    token: token.text,
+    target: 'enum',
+    lineIndex,
+    span: token.span,
+  });
+  if (!parsed) {
+    return undefined;
+  }
+  if (parsed.name !== 'map') {
+    pushDiagnostic(context, {
+      code: 'PSL_INVALID_ENUM_MEMBER',
+      message: `Invalid enum value declaration "${line}"`,
+      span: createTrimmedLineSpan(context, lineIndex),
+    });
+    return undefined;
+  }
+  return parsed;
+}
+
 function parseField(context: ParserContext, line: string, lineIndex: number): PslField | undefined {
-  const fieldMatch = line.match(/^([A-Za-z_]\w*)\s+([A-Za-z_]\w*(?:\[\])?)(\?)?(.*)$/);
+  const fieldMatch = line.match(/^([A-Za-z_]\w*)(\s+)(.+)$/);
   if (!fieldMatch) {
     pushDiagnostic(context, {
       code: 'PSL_INVALID_MODEL_MEMBER',
@@ -379,30 +601,62 @@ function parseField(context: ParserContext, line: string, lineIndex: number): Ps
   }
 
   const fieldName = fieldMatch[1] ?? '';
-  const rawTypeToken = fieldMatch[2] ?? '';
-  const optionalMarker = fieldMatch[3] ?? '';
-  const attributePart = fieldMatch[4] ?? '';
-  const list = rawTypeToken.endsWith('[]');
-  const typeName = list ? rawTypeToken.slice(0, -2) : rawTypeToken;
-  const optional = optionalMarker === '?';
-
-  const attributes: PslFieldAttribute[] = [];
+  const separator = fieldMatch[2] ?? '';
+  const remainder = fieldMatch[3] ?? '';
+  const typeAndAttributeSplit = splitTypeAndAttributes(remainder);
+  const rawTypeSource = typeAndAttributeSplit.typeSource.trim();
+  const attributePart = typeAndAttributeSplit.attributeSource;
+  const optional = rawTypeSource.endsWith('?');
+  const typeSourceWithoutOptional = optional ? rawTypeSource.slice(0, -1).trimEnd() : rawTypeSource;
+  const list = typeSourceWithoutOptional.endsWith('[]');
+  const baseTypeSource = list
+    ? typeSourceWithoutOptional.slice(0, -2).trimEnd()
+    : typeSourceWithoutOptional;
   const rawLine = context.lines[lineIndex] ?? '';
   const trimmedStartColumn = firstNonWhitespaceColumn(rawLine);
-  const attributeOffset = line.length - attributePart.length;
+  const typeStartColumn = trimmedStartColumn + fieldName.length + separator.length;
+
+  const typeConstructor = parseTypeConstructorCall(context, {
+    declarationValue: baseTypeSource,
+    lineIndex,
+    startColumn: typeStartColumn,
+    invalidCode: 'PSL_INVALID_MODEL_MEMBER',
+    invalidMessage: (value) => `Invalid field type constructor "${value}"`,
+  });
+  if (typeConstructor === 'malformed') {
+    return undefined;
+  }
+
+  const simpleTypeMatch = baseTypeSource.match(/^([A-Za-z_]\w*)$/);
+  const typeName = typeConstructor?.path.join('.') ?? simpleTypeMatch?.[1];
+  if (!typeName) {
+    pushDiagnostic(context, {
+      code: 'PSL_INVALID_MODEL_MEMBER',
+      message: `Invalid model member declaration "${line}"`,
+      span: createTrimmedLineSpan(context, lineIndex),
+    });
+    return undefined;
+  }
+
+  const attributes: PslFieldAttribute[] = [];
   const attributeSource = attributePart.trimStart();
   const leadingAttributeWhitespace = attributePart.length - attributeSource.length;
   const tokenParse = extractAttributeTokensWithSpans(
     context,
     lineIndex,
     attributeSource,
-    trimmedStartColumn + attributeOffset + leadingAttributeWhitespace,
+    trimmedStartColumn +
+      fieldName.length +
+      separator.length +
+      typeAndAttributeSplit.attributeOffset +
+      leadingAttributeWhitespace,
   );
   if (!tokenParse.ok) {
     return {
       kind: 'field',
       name: fieldName,
       typeName,
+      ...ifDefined('typeConstructor', typeConstructor),
       optional,
       list,
       attributes,
@@ -426,6 +680,7 @@ function parseField(context: ParserContext, line: string, lineIndex: number): Ps
     kind: 'field',
     name: fieldName,
     typeName,
+    ...ifDefined('typeConstructor', typeConstructor),
     optional,
     list,
     attributes,
@@ -433,6 +688,80 @@ function parseField(context: ParserContext, line: string, lineIndex: number): Ps
   };
 }
 
+function isQuoteEscaped(value: string, quoteIndex: number): boolean {
+  let backslashCount = 0;
+
+  for (let index = quoteIndex - 1; index >= 0 && value[index] === '\\'; index -= 1) {
+    backslashCount += 1;
+  }
+
+  return backslashCount % 2 === 1;
+}
+
+function splitTypeAndAttributes(value: string): {
+  readonly typeSource: string;
+  readonly attributeSource: string;
+  readonly attributeOffset: number;
+} {
+  let depthParen = 0;
+  let depthBracket = 0;
+  let depthBrace = 0;
+  let quote: '"' | "'" | null = null;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index] ?? '';
+    if (quote) {
+      if (character === quote && !isQuoteEscaped(value, index)) {
+        quote = null;
+      }
+      continue;
+    }
+
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === '(') {
+      depthParen += 1;
+      continue;
+    }
+    if (character === ')') {
+      depthParen = Math.max(0, depthParen - 1);
+      continue;
+    }
+    if (character === '[') {
+      depthBracket += 1;
+      continue;
+    }
+    if (character === ']') {
+      depthBracket = Math.max(0, depthBracket - 1);
+      continue;
+    }
+    if (character === '{') {
+      depthBrace += 1;
+      continue;
+    }
+    if (character === '}') {
+      depthBrace = Math.max(0, depthBrace - 1);
+      continue;
+    }
+
+    if (character === '@' && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
+      return {
+        typeSource: value.slice(0, index).trimEnd(),
+        attributeSource: value.slice(index),
+        attributeOffset: index,
+      };
+    }
+  }
+
+  return {
+    typeSource: value.trimEnd(),
+    attributeSource: '',
+    attributeOffset: value.length,
+  };
+}
+
 function parseAttributeToken(
   context: ParserContext,
   input: {
@@ -442,16 +771,17 @@ function parseAttributeToken(
     readonly span: PslSpan;
   },
 ): PslAttribute | undefined {
-  const expectsModelPrefix = input.target === 'model';
-  if (expectsModelPrefix && !input.token.startsWith('@@')) {
+  const expectsBlockPrefix = input.target === 'model' || input.target === 'enum';
+  const targetLabel = input.target === 'enum' ? 'Enum' : 'Model';
+  if (expectsBlockPrefix && !input.token.startsWith('@@')) {
     pushDiagnostic(context, {
       code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-      message: `Model attribute "${input.token}" must use @@ prefix`,
+      message: `${targetLabel} attribute "${input.token}" must use @@ prefix`,
       span: input.span,
     });
     return undefined;
   }
-  if (!expectsModelPrefix && !input.token.startsWith('@')) {
+  if (!expectsBlockPrefix && !input.token.startsWith('@')) {
     pushDiagnostic(context, {
       code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
       message: `Attribute "${input.token}" must use @ prefix`,
@@ -459,7 +789,7 @@ function parseAttributeToken(
     });
     return undefined;
   }
-  if (!expectsModelPrefix && input.token.startsWith('@@')) {
+  if (!expectsBlockPrefix && input.token.startsWith('@@')) {
     pushDiagnostic(context, {
       code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
       message: `Attribute "${input.token}" is not valid in ${input.target} context`,
@@ -468,7 +798,7 @@ function parseAttributeToken(
     return undefined;
   }
 
-  const rawBody = expectsModelPrefix ? input.token.slice(2) : input.token.slice(1);
+  const rawBody = expectsBlockPrefix ? input.token.slice(2) : input.token.slice(1);
   const openParen = rawBody.indexOf('(');
   const closeParen = rawBody.lastIndexOf(')');
   const hasArgs = openParen >= 0 || closeParen >= 0;
@@ -502,12 +832,15 @@ function parseAttributeToken(
       return undefined;
     }
     const argsRaw = rawBody.slice(openParen + 1, closeParen);
-    const parsedArgs = parseAttributeArguments(context, {
+    const parsedArgs = parseArgumentList(context, {
       argsRaw,
-      argsOffset: input.span.start.column - 1 + (expectsModelPrefix ? 2 : 1) + openParen + 1,
+      argsOffset: input.span.start.column - 1 + (expectsBlockPrefix ? 2 : 1) + openParen + 1,
       lineIndex: input.lineIndex,
       token: input.token,
       span: input.span,
+      invalidCode: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
+      invalidEmptyArgumentMessage: `Invalid empty argument in attribute "${input.token}"`,
+      invalidNamedArgumentMessage: (part) => `Invalid named argument syntax "${part}"`,
     });
     if (!parsedArgs) {
       return undefined;
@@ -524,7 +857,7 @@ function parseAttributeToken(
   };
 }
 
-function parseAttributeArguments(
+function parseArgumentList(
   context: ParserContext,
   input: {
     readonly argsRaw: string;
@@ -532,6 +865,9 @@ function parseAttributeArguments(
     readonly lineIndex: number;
     readonly token: string;
     readonly span: PslSpan;
+    readonly invalidCode: PslDiagnosticCode;
+    readonly invalidEmptyArgumentMessage: string;
+    readonly invalidNamedArgumentMessage: (part: string) => string;
   },
 ): readonly PslAttributeArgument[] | undefined {
   const trimmed = input.argsRaw.trim();
@@ -547,8 +883,8 @@ function parseAttributeArguments(
     const trimmedPart = original.trim();
     if (trimmedPart.length === 0) {
       pushDiagnostic(context, {
-        code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-        message: `Invalid empty argument in attribute "${input.token}"`,
+        code: input.invalidCode,
+        message: input.invalidEmptyArgumentMessage,
         span: input.span,
       });
       return undefined;
@@ -564,8 +900,8 @@ function parseAttributeArguments(
       const first = namedSplit[0];
       if (!first) {
         pushDiagnostic(context, {
-          code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-          message: `Invalid named argument syntax "${trimmedPart}"`,
+          code: input.invalidCode,
+          message: input.invalidNamedArgumentMessage(trimmedPart),
           span: partSpan,
         });
         return undefined;
@@ -574,8 +910,8 @@ function parseAttributeArguments(
       const rawValue = trimmedPart.slice(first.end + 1).trim();
       if (!name || rawValue.length === 0) {
         pushDiagnostic(context, {
-          code: 'PSL_INVALID_ATTRIBUTE_SYNTAX',
-          message: `Invalid named argument syntax "${trimmedPart}"`,
+          code: input.invalidCode,
+          message: input.invalidNamedArgumentMessage(trimmedPart),
           span: partSpan,
         });
         return undefined;
@@ -609,19 +945,17 @@ function findBlockBounds(context: ParserContext, startLine: number): BlockBounds
   for (let lineIndex = startLine; lineIndex < context.lines.length; lineIndex += 1) {
     const line = stripInlineComment(context.lines[lineIndex] ?? '');
     let quote: '"' | "'" | null = null;
-    let previousCharacter = '';
-    for (const character of line) {
+    for (let index = 0; index < line.length; index += 1) {
+      const character = line[index] ?? '';
       if (quote) {
-        if (character === quote && previousCharacter !== '\\') {
+        if (character === quote && !isQuoteEscaped(line, index)) {
           quote = null;
         }
-        previousCharacter = character;
         continue;
       }
 
       if (character === '"' || character === "'") {
         quote = character;
-        previousCharacter = character;
         continue;
       }
 
@@ -634,7 +968,6 @@ function findBlockBounds(context: ParserContext, startLine: number): BlockBounds
           return { startLine, endLine: lineIndex, closed: true };
         }
       }
-      previousCharacter = character;
     }
   }
 
@@ -660,13 +993,14 @@ function splitTopLevelSegments(value: string, separator: ',' | ':'): TopLevelSeg
   const parts: TopLevelSegment[] = [];
   let depthParen = 0;
   let depthBracket = 0;
+  let depthBrace = 0;
   let quote: '"' | "'" | null = null;
   let start = 0;
 
   for (let index = 0; index < value.length; index += 1) {
     const character = value[index] ?? '';
     if (quote) {
-      if (character === quote && value[index - 1] !== '\\') {
+      if (character === quote && !isQuoteEscaped(value, index)) {
         quote = null;
       }
       continue;
@@ -693,8 +1027,16 @@ function splitTopLevelSegments(value: string, separator: ',' | ':'): TopLevelSeg
       depthBracket = Math.max(0, depthBracket - 1);
       continue;
     }
+    if (character === '{') {
+      depthBrace += 1;
+      continue;
+    }
+    if (character === '}') {
+      depthBrace = Math.max(0, depthBrace - 1);
+      continue;
+    }
 
-    if (character === separator && depthParen === 0 && depthBracket === 0) {
+    if (character === separator && depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
       parts.push({
         value: value.slice(start, index),
         start,
@@ -763,7 +1105,7 @@ function extractAttributeTokensWithSpans(
       while (index < value.length) {
         const char = value[index] ?? '';
         if (quote) {
-          if (char === quote && value[index - 1] !== '\\') {
+          if (char === quote && !isQuoteEscaped(value, index)) {
             quote = null;
           }
           index += 1;
@@ -836,7 +1178,7 @@ function stripInlineComment(line: string): string {
     const next = line[index + 1] ?? '';
 
     if (quote) {
-      if (current === quote && line[index - 1] !== '\\') {
+      if (current === quote && !isQuoteEscaped(line, index)) {
         quote = null;
       }
       continue;