Function parseExtensions

packages/intl-getcanonicallocales/parser.ts:197–250

(chunks: string[])

  return ''
}
function parseExtensions(chunks: string[]): Omit<UnicodeLocaleId, 'lang'> {
  if (!chunks.length) {
    return {extensions: []}
  }
  const extensions: UnicodeLocaleId['extensions'] = []
  let unicodeExtension
  let transformedExtension
  let puExtension
  const otherExtensionMap: Record<string, OtherExtension> = {}
  do {
    const type = chunks.shift()!
    switch (type) {
      case 'u':
      case 'U':
        if (unicodeExtension) {
          throw new RangeError('There can only be 1 -u- extension')
        }
        unicodeExtension = parseUnicodeExtension(chunks)
        extensions.push(unicodeExtension)
        break
      case 't':
      case 'T':
        if (transformedExtension) {
          throw new RangeError('There can only be 1 -t- extension')
        }
        transformedExtension = parseTransformedExtension(chunks)
        extensions.push(transformedExtension)
        break
      case 'x':
      case 'X':
        if (puExtension) {
          throw new RangeError('There can only be 1 -x- extension')
        }
        puExtension = parsePuExtension(chunks)
        extensions.push(puExtension)
        break
      default:
        if (!OTHER_EXTENSION_TYPE.test(type)) {
          throw new RangeError('Malformed extension type')
        }
        if (type in otherExtensionMap) {
          throw new RangeError(`There can only be 1 -${type}- extension`)
        }
        const extension: OtherExtension = {
          type: type as 'a',
          value: parseOtherExtensionValue(chunks),
        }
        otherExtensionMap[extension.type] = extension
        extensions.push(extension)
        break
    }
  } while (chunks.length)
  return {extensions}
}

export function parseUnicodeLocaleId(locale: string): UnicodeLocaleId {
  const chunks = locale.split(SEPARATOR)