@formatjs/intl-getcanonicallocales 2.0.2 → 2.0.3

package/src/parser.ts

@@ -0,0 +1,259 @@
+import {
+  UnicodeLocaleId,
+  UnicodeLanguageId,
+  UnicodeExtension,
+  TransformedExtension,
+  PuExtension,
+  OtherExtension,
+  KV,
+} from './types'
+
+const ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i
+const ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i
+const ALPHANUM_3_8 = /^[a-z0-9]{3,8}$/i
+
+const KEY_REGEX = /^[a-z0-9][a-z]$/i
+
+const TYPE_REGEX = /^[a-z0-9]{3,8}$/i
+const ALPHA_4 = /^[a-z]{4}$/i
+// alphanum-[tTuUxX]
+const OTHER_EXTENSION_TYPE = /^[0-9a-svwyz]$/i
+const UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i
+const UNICODE_VARIANT_SUBTAG_REGEX = /^([a-z0-9]{5,8}|[0-9][a-z0-9]{3})$/i
+const UNICODE_LANGUAGE_SUBTAG_REGEX = /^([a-z]{2,3}|[a-z]{5,8})$/i
+const TKEY_REGEX = /^[a-z][0-9]$/i
+
+export const SEPARATOR = '-'
+
+export function isUnicodeLanguageSubtag(lang: string): boolean {
+  return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang)
+}
+
+export function isStructurallyValidLanguageTag(tag: string): boolean {
+  try {
+    parseUnicodeLanguageId(tag.split(SEPARATOR))
+  } catch (e) {
+    return false
+  }
+  return true
+}
+
+export function isUnicodeRegionSubtag(region: string): boolean {
+  return UNICODE_REGION_SUBTAG_REGEX.test(region)
+}
+
+export function isUnicodeScriptSubtag(script: string): boolean {
+  return ALPHA_4.test(script)
+}
+
+export function isUnicodeVariantSubtag(variant: string): boolean {
+  return UNICODE_VARIANT_SUBTAG_REGEX.test(variant)
+}
+
+export function parseUnicodeLanguageId(
+  chunks: string[] | string
+): UnicodeLanguageId {
+  if (typeof chunks === 'string') {
+    chunks = chunks.split(SEPARATOR)
+  }
+  const lang = chunks.shift()
+  if (!lang) {
+    throw new RangeError('Missing unicode_language_subtag')
+  }
+  if (lang === 'root') {
+    return {lang: 'root', variants: []}
+  }
+  // unicode_language_subtag
+  if (!isUnicodeLanguageSubtag(lang)) {
+    throw new RangeError('Malformed unicode_language_subtag')
+  }
+  let script
+  // unicode_script_subtag
+  if (chunks.length && isUnicodeScriptSubtag(chunks[0])) {
+    script = chunks.shift()
+  }
+  let region
+  // unicode_region_subtag
+  if (chunks.length && isUnicodeRegionSubtag(chunks[0])) {
+    region = chunks.shift()
+  }
+  const variants: Record<string, any> = {}
+  while (chunks.length && isUnicodeVariantSubtag(chunks[0])) {
+    const variant: string = chunks.shift()!
+    if (variant in variants) {
+      throw new RangeError(`Duplicate variant "${variant}"`)
+    }
+    variants[variant] = 1
+  }
+  return {
+    lang,
+    script,
+    region,
+    variants: Object.keys(variants),
+  }
+}
+
+function parseUnicodeExtension(chunks: string[]): UnicodeExtension {
+  const keywords = []
+  let keyword
+  while (chunks.length && (keyword = parseKeyword(chunks))) {
+    keywords.push(keyword)
+  }
+  if (keywords.length) {
+    return {
+      type: 'u',
+      keywords,
+      attributes: [],
+    }
+  }
+  // Mix of attributes & keywords
+  // Check for attributes first
+  const attributes = []
+  while (chunks.length && ALPHANUM_3_8.test(chunks[0])) {
+    attributes.push(chunks.shift()!)
+  }
+  while (chunks.length && (keyword = parseKeyword(chunks))) {
+    keywords.push(keyword)
+  }
+  if (keywords.length || attributes.length) {
+    return {
+      type: 'u',
+      attributes,
+      keywords,
+    }
+  }
+  throw new RangeError('Malformed unicode_extension')
+}
+
+function parseKeyword(chunks: string[]): KV | undefined {
+  let key
+  if (!KEY_REGEX.test(chunks[0])) {
+    return
+  }
+  key = chunks.shift()!
+
+  const type = []
+  while (chunks.length && TYPE_REGEX.test(chunks[0])) {
+    type.push(chunks.shift())
+  }
+  let value: string = ''
+  if (type.length) {
+    value = type.join(SEPARATOR)
+  }
+  return [key, value]
+}
+
+function parseTransformedExtension(chunks: string[]): TransformedExtension {
+  let lang: UnicodeLanguageId | undefined
+  try {
+    lang = parseUnicodeLanguageId(chunks)
+  } catch (e) {
+    // Try just parsing tfield
+  }
+  const fields: KV[] = []
+  while (chunks.length && TKEY_REGEX.test(chunks[0])) {
+    const key = chunks.shift()!
+    const value = []
+    while (chunks.length && ALPHANUM_3_8.test(chunks[0])) {
+      value.push(chunks.shift())
+    }
+    if (!value.length) {
+      throw new RangeError(`Missing tvalue for tkey "${key}"`)
+    }
+    fields.push([key, value.join(SEPARATOR)])
+  }
+  if (fields.length) {
+    return {
+      type: 't',
+      fields,
+      lang,
+    }
+  }
+  throw new RangeError('Malformed transformed_extension')
+}
+function parsePuExtension(chunks: string[]): PuExtension {
+  const exts = []
+  while (chunks.length && ALPHANUM_1_8.test(chunks[0])) {
+    exts.push(chunks.shift())
+  }
+  if (exts.length) {
+    return {
+      type: 'x',
+      value: exts.join(SEPARATOR),
+    }
+  }
+  throw new RangeError('Malformed private_use_extension')
+}
+function parseOtherExtensionValue(chunks: string[]): string {
+  const exts = []
+  while (chunks.length && ALPHANUM_2_8.test(chunks[0])) {
+    exts.push(chunks.shift())
+  }
+  if (exts.length) {
+    return exts.join(SEPARATOR)
+  }
+  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)
+  const lang = parseUnicodeLanguageId(chunks)
+  return {
+    lang,
+    ...parseExtensions(chunks),
+  }
+}

package/src/types.ts

@@ -0,0 +1,63 @@
+export interface UnicodeLocaleId {
+  lang: UnicodeLanguageId
+  extensions: Array<
+    UnicodeExtension | TransformedExtension | PuExtension | OtherExtension
+  >
+}
+
+export interface UnicodeLanguageId {
+  lang: string
+  script?: string
+  region?: string
+  variants: string[]
+}
+
+export type KV = [string, string] | [string]
+
+export interface Extension {
+  type: string
+}
+
+export interface UnicodeExtension extends Extension {
+  type: 'u'
+  keywords: KV[]
+  attributes: string[]
+}
+
+export interface TransformedExtension extends Extension {
+  type: 't'
+  fields: KV[]
+  lang?: UnicodeLanguageId
+}
+export interface PuExtension extends Extension {
+  type: 'x'
+  value: string
+}
+
+export interface OtherExtension extends Extension {
+  type:
+    | 'a'
+    | 'b'
+    | 'c'
+    | 'd'
+    | 'e'
+    | 'f'
+    | 'g'
+    | 'h'
+    | 'i'
+    | 'j'
+    | 'k'
+    | 'l'
+    | 'm'
+    | 'n'
+    | 'o'
+    | 'p'
+    | 'q'
+    | 'r'
+    | 's'
+    | 'v'
+    | 'w'
+    | 'y'
+    | 'z'
+  value: string
+}

package/tests/index.test.ts

@@ -0,0 +1,24 @@
+import {getCanonicalLocales} from '../'
+
+describe('Intl.getCanonicalLocales', () => {
+  it('regular', function () {
+    expect(
+      getCanonicalLocales('en-u-foo-bar-nu-thai-ca-buddhist-kk-true')
+    ).toEqual(['en-u-bar-foo-ca-buddhist-kk-nu-thai'])
+  })
+  it('und-x-private', function () {
+    expect(getCanonicalLocales('und-x-private')).toEqual(['und-x-private'])
+  })
+  it('should canonicalize casing for zh-hANs-sG', function () {
+    expect(getCanonicalLocales('zh-hANs-sG')).toEqual(['zh-Hans-SG'])
+  })
+  it('should handle twi', function () {
+    expect(getCanonicalLocales('twi')).toEqual(['ak'])
+  })
+  it('should handle ug-Arab-CN ', function () {
+    expect(getCanonicalLocales('ug-Arab-CN')).toEqual(['ug-Arab-CN'])
+  })
+  it('canonicalizes twice', function () {
+    expect(getCanonicalLocales('und-Armn-SU')).toEqual(['und-Armn-AM'])
+  })
+})

package/tests/parser.test.ts

@@ -0,0 +1,204 @@
+import {parseUnicodeLocaleId} from '../src/parser'
+
+describe('parser', () => {
+  const invalidLanguageTags = [
+    // Unicode extension sequence is incomplete.
+    'da-u',
+    'da-u-',
+    'da-u--',
+    'da-u-t-latn',
+    'da-u-x-priv',
+
+    // Duplicate 'u' singleton.
+    'da-u-ca-gregory-u-ca-buddhist',
+
+    // https://github.com/tc39/test262/blob/5124761d2febfe5cc1427920d782219052f29a2c/harness/testIntl.js#L185
+    '', // empty tag
+    'i', // singleton alone
+    'x', // private use without subtag
+    'u', // extension singleton in first place
+    '419', // region code in first place
+    'u-nu-latn-cu-bob', // extension sequence without language
+    'hans-cmn-cn', // "hans" could theoretically be a 4-letter language code,
+    // but those can't be followed by extlang codes.
+    'cmn-hans-cn-u-u', // duplicate singleton
+    'cmn-hans-cn-t-u-ca-u', // duplicate singleton
+    'de-gregory-gregory', // duplicate variant
+    '*', // language range
+    'de-*', // language range
+    '中文', // non-ASCII letters
+    'en-ß', // non-ASCII letters
+    'ıd', // non-ASCII letters
+    'es-Latn-latn', // two scripts
+    'pl-PL-pl', // two regions
+    'u-ca-gregory', // extension in first place
+    'de-1996-1996', // duplicate numeric variant
+    'pt-u-ca-gregory-u-nu-latn', // duplicate singleton subtag
+
+    // Invalid tags starting with: https://github.com/tc39/ecma402/pull/289
+    'no-nyn', // regular grandfathered in BCP47, but invalid in UTS35
+    'i-klingon', // irregular grandfathered in BCP47, but invalid in UTS35
+    'zh-hak-CN', // language with extlang in BCP47, but invalid in UTS35
+    'sgn-ils', // language with extlang in BCP47, but invalid in UTS35
+    'x-foo', // privateuse-only in BCP47, but invalid in UTS35
+    'x-en-US-12345', // more privateuse-only variants.
+    'x-12345-12345-en-US',
+    'x-en-US-12345-12345',
+    'x-en-u-foo',
+    'x-en-u-foo-u-bar',
+    'x-u-foo',
+
+    // underscores in different parts of the language tag
+    'de_DE',
+    'DE_de',
+    'cmn_Hans',
+    'cmn-hans_cn',
+    'es_419',
+    'es-419-u-nu-latn-cu_bob',
+    'i_klingon',
+    'cmn-hans-cn-t-ca-u-ca-x_t-u',
+    'enochian_enochian',
+    'de-gregory_u-ca-gregory',
+
+    'en\u0000', // null-terminator sequence
+    ' en', // leading whitespace
+    'en ', // trailing whitespace
+    'it-IT-Latn', // country before script tag
+    'de-u', // incomplete Unicode extension sequences
+    'de-u-',
+    'de-u-ca-',
+    'de-u-ca-gregory-',
+    'si-x', // incomplete private-use tags
+    'x-',
+    'x-y-',
+  ]
+
+  for (const langtag of invalidLanguageTags) {
+    it(`new Intl.Locale("${langtag}") throws RangeError`, function () {
+      expect(() => parseUnicodeLocaleId(langtag)).toThrowError(RangeError)
+    })
+  }
+
+  it('en-u-foo-bar-nu-thai-ca-buddhist-kk-true', function () {
+    expect(
+      parseUnicodeLocaleId('en-u-foo-bar-nu-thai-ca-buddhist-kk-true')
+    ).toEqual({
+      extensions: [
+        {
+          attributes: ['foo', 'bar'],
+          keywords: [
+            ['nu', 'thai'],
+            ['ca', 'buddhist'],
+            ['kk', 'true'],
+          ],
+          type: 'u',
+        },
+      ],
+      lang: {lang: 'en', region: undefined, script: undefined, variants: []},
+    })
+  })
+  it('da-u-ca-gregory-ca-buddhist', function () {
+    expect(parseUnicodeLocaleId('da-u-ca-gregory-ca-buddhist')).toEqual({
+      extensions: [
+        {
+          attributes: [],
+          keywords: [
+            ['ca', 'gregory'],
+            ['ca', 'buddhist'],
+          ],
+          type: 'u',
+        },
+      ],
+      lang: {lang: 'da', region: undefined, script: undefined, variants: []},
+    })
+  })
+  it('en-Latn-fonipa', function () {
+    expect(parseUnicodeLocaleId('en-Latn-fonipa')).toEqual({
+      extensions: [],
+      lang: {
+        lang: 'en',
+        region: undefined,
+        script: 'Latn',
+        variants: ['fonipa'],
+      },
+    })
+  })
+  it('de-Latn-DE-u-ca-gregory-co-phonebk-hc-h23-kf-kn-false-nu-latn', function () {
+    expect(
+      parseUnicodeLocaleId(
+        'de-Latn-DE-u-ca-gregory-co-phonebk-hc-h23-kf-kn-false-nu-latn'
+      )
+    ).toEqual({
+      extensions: [
+        {
+          attributes: [],
+          keywords: [
+            ['ca', 'gregory'],
+            ['co', 'phonebk'],
+            ['hc', 'h23'],
+            ['kf', ''],
+            ['kn', 'false'],
+            ['nu', 'latn'],
+          ],
+          type: 'u',
+        },
+      ],
+      lang: {lang: 'de', region: 'DE', script: 'Latn', variants: []},
+    })
+  })
+  it('ja-Jpan-JP-u-ca-japanese-co-search-hc-h24-kf-false-kn-nu-jpanfin', function () {
+    expect(
+      parseUnicodeLocaleId(
+        'ja-Jpan-JP-u-ca-japanese-co-search-hc-h24-kf-false-kn-nu-jpanfin'
+      )
+    ).toEqual({
+      extensions: [
+        {
+          attributes: [],
+          keywords: [
+            ['ca', 'japanese'],
+            ['co', 'search'],
+            ['hc', 'h24'],
+            ['kf', 'false'],
+            ['kn', ''],
+            ['nu', 'jpanfin'],
+          ],
+          type: 'u',
+        },
+      ],
+      lang: {lang: 'ja', region: 'JP', script: 'Jpan', variants: []},
+    })
+  })
+  it('fr-Latn-CA-u-ca-gregory-co-standard-hc-h11-kf-kn-false-nu-latn', function () {
+    expect(
+      parseUnicodeLocaleId(
+        'fr-Latn-CA-u-ca-gregory-co-standard-hc-h11-kf-kn-false-nu-latn'
+      )
+    ).toEqual({
+      extensions: [
+        {
+          attributes: [],
+          keywords: [
+            ['ca', 'gregory'],
+            ['co', 'standard'],
+            ['hc', 'h11'],
+            ['kf', ''],
+            ['kn', 'false'],
+            ['nu', 'latn'],
+          ],
+          type: 'u',
+        },
+      ],
+      lang: {lang: 'fr', region: 'CA', script: 'Latn', variants: []},
+    })
+  })
+  it('en-a-bar-x-u-foo', function () {
+    expect(parseUnicodeLocaleId('en-a-bar-x-u-foo')).toEqual({
+      extensions: [
+        {type: 'a', value: 'bar'},
+        {type: 'x', value: 'u-foo'},
+      ],
+      lang: {lang: 'en', region: undefined, script: undefined, variants: []},
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,5 @@
+// @generated
+{
+  // This is purely for IDE, not for compilation
+  "extends": "../../tsconfig.json"
+}

package/index.d.ts

@@ -1,6 +0,0 @@
-export declare function getCanonicalLocales(locales?: string[] | string): string[];
-export { parseUnicodeLocaleId, parseUnicodeLanguageId, isStructurallyValidLanguageTag, isUnicodeRegionSubtag, isUnicodeScriptSubtag, isUnicodeLanguageSubtag, } from './src/parser';
-export * from './src/types';
-export * from './src/emitter';
-export * from './src/likelySubtags.generated';
-//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/intl-getcanonicallocales/index.ts"],"names":[],"mappings":"AA2BA,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAEzE;AAED,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,8BAA8B,EAC9B,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,cAAc,CAAA;AACrB,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAE7B,cAAc,+BAA+B,CAAA"}

package/index.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUnicodeLanguageSubtag = exports.isUnicodeScriptSubtag = exports.isUnicodeRegionSubtag = exports.isStructurallyValidLanguageTag = exports.parseUnicodeLanguageId = exports.parseUnicodeLocaleId = exports.getCanonicalLocales = void 0;
-var tslib_1 = require("tslib");
-var parser_1 = require("./src/parser");
-var emitter_1 = require("./src/emitter");
-var canonicalizer_1 = require("./src/canonicalizer");
-/**
- * https://tc39.es/ecma402/#sec-canonicalizelocalelist
- * @param locales
- */
-function CanonicalizeLocaleList(locales) {
-    if (locales === undefined) {
-        return [];
-    }
-    var seen = [];
-    if (typeof locales === 'string') {
-        locales = [locales];
-    }
-    for (var _i = 0, locales_1 = locales; _i < locales_1.length; _i++) {
-        var locale = locales_1[_i];
-        var canonicalizedTag = (0, emitter_1.emitUnicodeLocaleId)((0, canonicalizer_1.canonicalizeUnicodeLocaleId)((0, parser_1.parseUnicodeLocaleId)(locale)));
-        if (seen.indexOf(canonicalizedTag) < 0) {
-            seen.push(canonicalizedTag);
-        }
-    }
-    return seen;
-}
-function getCanonicalLocales(locales) {
-    return CanonicalizeLocaleList(locales);
-}
-exports.getCanonicalLocales = getCanonicalLocales;
-var parser_2 = require("./src/parser");
-Object.defineProperty(exports, "parseUnicodeLocaleId", { enumerable: true, get: function () { return parser_2.parseUnicodeLocaleId; } });
-Object.defineProperty(exports, "parseUnicodeLanguageId", { enumerable: true, get: function () { return parser_2.parseUnicodeLanguageId; } });
-Object.defineProperty(exports, "isStructurallyValidLanguageTag", { enumerable: true, get: function () { return parser_2.isStructurallyValidLanguageTag; } });
-Object.defineProperty(exports, "isUnicodeRegionSubtag", { enumerable: true, get: function () { return parser_2.isUnicodeRegionSubtag; } });
-Object.defineProperty(exports, "isUnicodeScriptSubtag", { enumerable: true, get: function () { return parser_2.isUnicodeScriptSubtag; } });
-Object.defineProperty(exports, "isUnicodeLanguageSubtag", { enumerable: true, get: function () { return parser_2.isUnicodeLanguageSubtag; } });
-(0, tslib_1.__exportStar)(require("./src/types"), exports);
-(0, tslib_1.__exportStar)(require("./src/emitter"), exports);
-(0, tslib_1.__exportStar)(require("./src/likelySubtags.generated"), exports);

package/lib/index.d.ts

@@ -1,6 +0,0 @@
-export declare function getCanonicalLocales(locales?: string[] | string): string[];
-export { parseUnicodeLocaleId, parseUnicodeLanguageId, isStructurallyValidLanguageTag, isUnicodeRegionSubtag, isUnicodeScriptSubtag, isUnicodeLanguageSubtag, } from './src/parser';
-export * from './src/types';
-export * from './src/emitter';
-export * from './src/likelySubtags.generated';
-//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/intl-getcanonicallocales/index.ts"],"names":[],"mappings":"AA2BA,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAEzE;AAED,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,8BAA8B,EAC9B,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,cAAc,CAAA;AACrB,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAE7B,cAAc,+BAA+B,CAAA"}

package/lib/index.js

@@ -1,31 +0,0 @@
-import { parseUnicodeLocaleId } from './src/parser';
-import { emitUnicodeLocaleId } from './src/emitter';
-import { canonicalizeUnicodeLocaleId } from './src/canonicalizer';
-/**
- * https://tc39.es/ecma402/#sec-canonicalizelocalelist
- * @param locales
- */
-function CanonicalizeLocaleList(locales) {
-    if (locales === undefined) {
-        return [];
-    }
-    var seen = [];
-    if (typeof locales === 'string') {
-        locales = [locales];
-    }
-    for (var _i = 0, locales_1 = locales; _i < locales_1.length; _i++) {
-        var locale = locales_1[_i];
-        var canonicalizedTag = emitUnicodeLocaleId(canonicalizeUnicodeLocaleId(parseUnicodeLocaleId(locale)));
-        if (seen.indexOf(canonicalizedTag) < 0) {
-            seen.push(canonicalizedTag);
-        }
-    }
-    return seen;
-}
-export function getCanonicalLocales(locales) {
-    return CanonicalizeLocaleList(locales);
-}
-export { parseUnicodeLocaleId, parseUnicodeLanguageId, isStructurallyValidLanguageTag, isUnicodeRegionSubtag, isUnicodeScriptSubtag, isUnicodeLanguageSubtag, } from './src/parser';
-export * from './src/types';
-export * from './src/emitter';
-export * from './src/likelySubtags.generated';

package/lib/polyfill.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=polyfill.d.ts.map

package/lib/polyfill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../../../../../packages/intl-getcanonicallocales/polyfill.ts"],"names":[],"mappings":""}

package/lib/polyfill.js

@@ -1,24 +0,0 @@
-import { getCanonicalLocales } from './';
-import { shouldPolyfill } from './should-polyfill';
-if (typeof Intl === 'undefined') {
-    if (typeof window !== 'undefined') {
-        Object.defineProperty(window, 'Intl', {
-            value: {},
-        });
-        // @ts-ignore we don't include @types/node so global isn't a thing
-    }
-    else if (typeof global !== 'undefined') {
-        // @ts-ignore we don't include @types/node so global isn't a thing
-        Object.defineProperty(global, 'Intl', {
-            value: {},
-        });
-    }
-}
-if (shouldPolyfill()) {
-    Object.defineProperty(Intl, 'getCanonicalLocales', {
-        value: getCanonicalLocales,
-        writable: true,
-        enumerable: false,
-        configurable: true,
-    });
-}

package/lib/should-polyfill.d.ts

@@ -1,2 +0,0 @@
-export declare function shouldPolyfill(): boolean;
-//# sourceMappingURL=should-polyfill.d.ts.map