@payloadcms/translations 4.0.0-internal.293e026 → 4.0.0-internal.2a3c3bc

package/dist/utilities/getTranslationsByContext.d.ts

@@ -1,5 +1,5 @@
 import type { Language } from '../types.js';
-export declare const getTranslationsByContext: (selectedLanguage: Language, context: "api" | "client") => {
+export declare const getTranslationsByContext: (selectedLanguage: Language, context: 'api' | 'client') => Record<string, unknown> | {
     authentication: {
         account: string;
         accountOfCurrentUser: string;
@@ -53,6 +53,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         notRedirected: string;
         passed: string;
         passwordResetSuccessfully: string;
+        resend: string;
         resetPassword: string;
         resetPasswordExpiration: string;
         resetPasswordToken: string;
@@ -100,7 +101,38 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         editingDashboard: string;
         noItems: string;
         resetLayout: string;
+        resizeWidget: string;
         searchWidgets: string;
+        widgetAddPin: string;
+        widgetCollectionRequired: string;
+        widgetConfigurationError: string;
+        widgetDropFilesToUpload: string;
+        widgetInvalidCollection: string;
+        widgetInvalidFilterField: string;
+        widgetInvalidSortField: string;
+        widgetLimitLabel: string;
+        widgetNonSortableSortField: string;
+        widgetPageCount: string;
+        widgetPagination: string;
+        widgetPinned: string;
+        widgetPinnedEmpty: string;
+        widgetPinnedEmptyDescription: string;
+        widgetPinnedSaveError: string;
+        widgetQueryError: string;
+        widgetRecentlyViewedEmpty: string;
+        widgetRecentlyViewedEmptyDescription: string;
+        widgetRecentlyViewedFilterDescription: string;
+        widgetRecentlyViewedTitle: string;
+        widgetRecentsAndPinned: string;
+        widgetRemovePin: string;
+        widgetSelectCollectionFirst: string;
+        widgetSelectSortField: string;
+        widgetSortDirectionLabel: string;
+        widgetSortFieldLabel: string;
+        widgetTitleFallback: string;
+        widgetTitleLabel: string;
+        widgetUploadDropzoneDescription: string;
+        widgetUploadFiles: string;
     };
     error: {
         accountAlreadyActivated: string;
@@ -112,6 +144,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         emailOrPasswordIncorrect: string;
         failedToResetLayout: string;
         failedToSaveLayout: string;
+        fileFetchFailed: string;
         followingFieldsInvalid_one: string;
         followingFieldsInvalid_other: string;
         incorrectCollection: string;
@@ -128,6 +161,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         missingIDOfDocument: string;
         missingIDOfVersion: string;
         missingRequiredData: string;
+        noFileFoundInClipboard: string;
         noFilesUploaded: string;
         noMatchedField: string;
         notAllowedToAccessPage: string;
@@ -142,6 +176,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         tokenNotProvided: string;
         unableToCopy: string;
         unableToDeleteCount: string;
+        unableToReadClipboard: string;
         unableToReindexCollection: string;
         unableToUpdateCount: string;
         unauthorized: string;
@@ -150,6 +185,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         unPublishingDocument: string;
         unspecific: string;
         unverifiedEmail: string;
+        urlNotAllowed: string;
         userEmailAlreadyRegistered: string;
         userLocked: string;
         usernameAlreadyRegistered: string;
@@ -165,6 +201,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         addRelationship: string;
         addUpload: string;
         block: string;
+        blockName: string;
         blocks: string;
         blockType: string;
         chooseBetweenCustomTextOrDocument: string;
@@ -220,25 +257,30 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         aboutToTrash: string;
         aboutToTrashCount: string;
         accepts: string;
+        access: string;
         addBelow: string;
         addFilter: string;
         adminTheme: string;
         all: string;
         allCollections: string;
         allLocales: string;
+        allowedTypes: string;
         and: string;
         anotherUser: string;
         anotherUserTakenOver: string;
         applyChanges: string;
         ascending: string;
+        auto: string;
         automatic: string;
         backToDashboard: string;
+        breadcrumb: string;
         by: string;
         cancel: string;
         changesNotSaved: string;
         checked: string;
         clear: string;
         clearAll: string;
+        clearSearch: string;
         close: string;
         collapse: string;
         collection: string;
@@ -264,6 +306,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         create: string;
         created: string;
         createdAt: string;
+        createdBy: string;
         createNew: string;
         createNewLabel: string;
         creating: string;
@@ -324,6 +367,8 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         filterWhere: string;
         globals: string;
         goBack: string;
+        goToPage: string;
+        gridLayout: string;
         groupByLabel: string;
         hideSidebar: string;
         import: string;
@@ -356,6 +401,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         newLabel: string;
         newPassword: string;
         next: string;
+        nextPage: string;
         no: string;
         noDateSelected: string;
         noFiltersSet: string;
@@ -369,6 +415,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         notFound: string;
         nothingFound: string;
         noTrashResults: string;
+        notSelectedDocument: string;
         notShownInTable: string;
         noUpcomingEventsScheduled: string;
         noValue: string;
@@ -378,9 +425,12 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         openInNewWindow: string;
         or: string;
         order: string;
+        original: string;
         overwriteExistingData: string;
         pageNotFound: string;
+        pageNumberRange: string;
         password: string;
+        pasteBelow: string;
         pasteField: string;
         pasteRow: string;
         payloadSettings: string;
@@ -388,12 +438,16 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         permanentlyDeletedCountSuccessfully: string;
         perPage: string;
         perPageLabel: string;
+        presets: string;
         previous: string;
+        previousPage: string;
         reindex: string;
         reindexingAll: string;
         reloadDocument: string;
         remove: string;
         rename: string;
+        replaceRow: string;
+        requiredFields: string;
         reset: string;
         resetPreferences: string;
         resetPreferencesDescription: string;
@@ -409,20 +463,28 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         saveChanges: string;
         saving: string;
         schedulePublishFor: string;
+        searchAutomatically: string;
         searchBy: string;
+        searchCleared: string;
         searchColumns: string;
+        searchGroups: string;
+        searchResults: string;
         select: string;
         selectAll: string;
         selectAllRows: string;
         selectedCount: string;
+        selectedDocument: string;
         selectLabel: string;
         selectValue: string;
+        settings: string;
         showAllLabel: string;
         shownInTable: string;
         showSidebar: string;
+        skipToContent: string;
         sorryNotFound: string;
         sort: string;
         sortByLabelDirection: string;
+        sortByOrderToReorder: string;
         stayOnThisPage: string;
         submissionSuccessful: string;
         submit: string;
@@ -431,7 +493,9 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         successfullyCreated: string;
         successfullyDuplicated: string;
         successfullyReindexed: string;
+        tableLayout: string;
         takeOver: string;
+        theme: string;
         thisLanguage: string;
         time: string;
         timezone: string;
@@ -451,6 +515,7 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         upcomingEvents: string;
         updatedAgo: string;
         updatedAt: string;
+        updatedBy: string;
         updatedCountSuccessfully: string;
         updatedLabelSuccessfully: string;
         updatedSuccessfully: string;
@@ -469,13 +534,29 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         yes: string;
     };
     hierarchy: {
+        goTo: string;
         itemsMovedTo: string;
         itemsMovedToRoot: string;
-        moveItemsToRootConfirmation: string;
+        moveTo: string;
         moveToRoot: string;
         noParent: string;
         noResults: string;
+        removeFrom: string;
         searchLabel: string;
+        searchResults: string;
+    };
+    llmInstructions: {
+        additionalInstructions: string;
+        collectionDescription: string;
+        collectionSystemDescription: string;
+        editInstructions: string;
+        global: string;
+        globalDescription: string;
+        globalSystemDescription: string;
+        instructions: string;
+        systemInstructions: string;
+        targetCannotBeChanged: string;
+        title: string;
     };
     localization: {
         cannotCopySameLocale: string;
@@ -509,8 +590,18 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         addFile: string;
         addFiles: string;
         bulkUpload: string;
+        copyLinkToFile: string;
+        copyURL: string;
         crop: string;
+        cropBottom: string;
+        cropBottomLeft: string;
+        cropBottomRight: string;
+        cropLeft: string;
+        cropRight: string;
         cropToolDescription: string;
+        cropTop: string;
+        cropTopLeft: string;
+        cropTopRight: string;
         download: string;
         dragAndDrop: string;
         dragAndDropHere: string;
@@ -521,12 +612,17 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         fileToUpload: string;
         focalPoint: string;
         focalPointDescription: string;
+        fromURL: string;
         height: string;
         lessInfo: string;
+        linkToFile: string;
         moreInfo: string;
         noFile: string;
+        pasteFromClipboard: string;
         pasteURL: string;
         previewSizes: string;
+        renameFile: string;
+        replaceFile: string;
         selectCollectionToBrowse: string;
         selectFile: string;
         setCropArea: string;
@@ -643,5 +739,5 @@ export declare const getTranslationsByContext: (selectedLanguage: Language, cont
         viewingVersions: string;
         viewingVersionsGlobal: string;
     };
-} | Record<string, unknown>;
+};
 //# sourceMappingURL=getTranslationsByContext.d.ts.map

package/dist/utilities/getTranslationsByContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getTranslationsByContext.d.ts","sourceRoot":"","sources":["../../src/utilities/getTranslationsByContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAwD3C,eAAO,MAAM,wBAAwB,GAAI,kBAAkB,QAAQ,EAAE,SAAS,KAAK,GAAG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAM7F,CAAA"}
+{"version":3,"file":"getTranslationsByContext.d.ts","sourceRoot":"","sources":["../../src/utilities/getTranslationsByContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AA6E3C,eAAO,MAAM,wBAAwB,qBAAsB,QAAQ,WAAW,KAAK,GAAG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM7F,CAAA"}

package/dist/utilities/getTranslationsByContext.js

@@ -1,41 +1,49 @@
 import { clientTranslationKeys } from '../clientKeys.js';
-function filterKeys(obj, parentGroupKey = '', keys) {
+/**
+ * The client translation keys, grouped by namespace. For example, the keys `general:cancel`,
+ * `general:item` and `authentication:account` are stored as:
+ *
+ * `Map { 'general' => Set { 'cancel', 'item' }, 'authentication' => Set { 'account' } }`
+ */ const clientKeysByNamespace = new Map();
+for (const clientKey of clientTranslationKeys){
+    const separatorIndex = clientKey.indexOf(':');
+    const namespace = clientKey.slice(0, separatorIndex);
+    const key = clientKey.slice(separatorIndex + 1);
+    const keys = clientKeysByNamespace.get(namespace) ?? new Set();
+    clientKeysByNamespace.set(namespace, keys.add(key));
+}
+/** Plural forms of a key, for example `item_one` and `item_other` for `item` */ const pluralSuffix = /_(?:zero|one|two|few|many|other)$/;
+/**
+ * Keeps only the translations the admin needs in the browser: the keys listed in
+ * `clientTranslationKeys`, plus their plural forms. Namespaces that end up empty are left out.
+ *
+ * @example
+ * // With the client keys `general:cancel` and `general:item`:
+ * filterClientKeys({
+ *   general: { cancel: 'Cancel', item: 'Item', item_other: 'Items', save: 'Save' },
+ *   error: { notFound: 'Not found' },
+ * })
+ * // => { general: { cancel: 'Cancel', item: 'Item', item_other: 'Items' } }
+ */ function filterClientKeys(translations) {
     const result = {};
-    for (const [namespaceKey, value] of Object.entries(obj)){
-        // Skip $schema key
-        if (namespaceKey === '$schema') {
-            result[namespaceKey] = value;
+    for (const [namespace, value] of Object.entries(translations)){
+        if (namespace === '$schema') {
+            result[namespace] = value;
             continue;
         }
-        if (typeof value === 'object') {
-            const filteredObject = filterKeys(value, namespaceKey, keys);
-            if (Object.keys(filteredObject).length > 0) {
-                result[namespaceKey] = filteredObject;
-            }
-        } else {
-            for (const key of keys){
-                const [groupKey, selector] = key.split(':');
-                if (parentGroupKey === groupKey) {
-                    if (namespaceKey === selector) {
-                        result[selector] = value;
-                    } else {
-                        const pluralKeys = [
-                            'zero',
-                            'one',
-                            'two',
-                            'few',
-                            'many',
-                            'other'
-                        ];
-                        pluralKeys.forEach((pluralKey)=>{
-                            if (namespaceKey === `${selector}_${pluralKey}`) {
-                                result[`${selector}_${pluralKey}`] = value;
-                            }
-                        });
-                    }
-                }
+        const clientKeys = clientKeysByNamespace.get(namespace);
+        if (!clientKeys || typeof value !== 'object' || value === null) {
+            continue;
+        }
+        const clientTranslations = {};
+        for (const [key, translation] of Object.entries(value)){
+            if (clientKeys.has(key) || clientKeys.has(key.replace(pluralSuffix, ''))) {
+                clientTranslations[key] = translation;
             }
         }
+        if (Object.keys(clientTranslations).length > 0) {
+            result[namespace] = clientTranslations;
+        }
     }
     return result;
 }
@@ -52,7 +60,7 @@ function sortObject(obj) {
 }
 export const getTranslationsByContext = (selectedLanguage, context)=>{
     if (context === 'client') {
-        return sortObject(filterKeys(selectedLanguage.translations, '', clientTranslationKeys));
+        return sortObject(filterClientKeys(selectedLanguage.translations));
     } else {
         return selectedLanguage.translations;
     }

package/dist/utilities/getTranslationsByContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getTranslationsByContext.ts"],"sourcesContent":["import type { Language } from '../types.js'\n\nimport { clientTranslationKeys } from '../clientKeys.js'\n\nfunction filterKeys(obj: Record<string, unknown>, parentGroupKey = '', keys: string[]) {\n  const result: Record<string, unknown> = {}\n\n  for (const [namespaceKey, value] of Object.entries(obj)) {\n    // Skip $schema key\n    if (namespaceKey === '$schema') {\n      result[namespaceKey] = value\n      continue\n    }\n\n    if (typeof value === 'object') {\n      const filteredObject = filterKeys(value as Record<string, unknown>, namespaceKey, keys)\n      if (Object.keys(filteredObject).length > 0) {\n        result[namespaceKey] = filteredObject\n      }\n    } else {\n      for (const key of keys) {\n        const [groupKey, selector] = key.split(':')\n\n        if (parentGroupKey === groupKey) {\n          if (namespaceKey === selector) {\n            result[selector] = value\n          } else {\n            const pluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other']\n            pluralKeys.forEach((pluralKey) => {\n              if (namespaceKey === `${selector}_${pluralKey}`) {\n                result[`${selector}_${pluralKey}`] = value\n              }\n            })\n          }\n        }\n      }\n    }\n  }\n\n  return result\n}\n\nfunction sortObject(obj: Record<string, unknown>) {\n  const sortedObject: Record<string, unknown> = {}\n  Object.keys(obj)\n    .sort()\n    .forEach((key) => {\n      if (typeof obj[key] === 'object') {\n        sortedObject[key] = sortObject(obj[key] as Record<string, unknown>)\n      } else {\n        sortedObject[key] = obj[key]\n      }\n    })\n  return sortedObject\n}\n\nexport const getTranslationsByContext = (selectedLanguage: Language, context: 'api' | 'client') => {\n  if (context === 'client') {\n    return sortObject(filterKeys(selectedLanguage.translations, '', clientTranslationKeys))\n  } else {\n    return selectedLanguage.translations\n  }\n}\n"],"names":["clientTranslationKeys","filterKeys","obj","parentGroupKey","keys","result","namespaceKey","value","Object","entries","filteredObject","length","key","groupKey","selector","split","pluralKeys","forEach","pluralKey","sortObject","sortedObject","sort","getTranslationsByContext","selectedLanguage","context","translations"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,mBAAkB;AAExD,SAASC,WAAWC,GAA4B,EAAEC,iBAAiB,EAAE,EAAEC,IAAc;IACnF,MAAMC,SAAkC,CAAC;IAEzC,KAAK,MAAM,CAACC,cAAcC,MAAM,IAAIC,OAAOC,OAAO,CAACP,KAAM;QACvD,mBAAmB;QACnB,IAAII,iBAAiB,WAAW;YAC9BD,MAAM,CAACC,aAAa,GAAGC;YACvB;QACF;QAEA,IAAI,OAAOA,UAAU,UAAU;YAC7B,MAAMG,iBAAiBT,WAAWM,OAAkCD,cAAcF;YAClF,IAAII,OAAOJ,IAAI,CAACM,gBAAgBC,MAAM,GAAG,GAAG;gBAC1CN,MAAM,CAACC,aAAa,GAAGI;YACzB;QACF,OAAO;YACL,KAAK,MAAME,OAAOR,KAAM;gBACtB,MAAM,CAACS,UAAUC,SAAS,GAAGF,IAAIG,KAAK,CAAC;gBAEvC,IAAIZ,mBAAmBU,UAAU;oBAC/B,IAAIP,iBAAiBQ,UAAU;wBAC7BT,MAAM,CAACS,SAAS,GAAGP;oBACrB,OAAO;wBACL,MAAMS,aAAa;4BAAC;4BAAQ;4BAAO;4BAAO;4BAAO;4BAAQ;yBAAQ;wBACjEA,WAAWC,OAAO,CAAC,CAACC;4BAClB,IAAIZ,iBAAiB,GAAGQ,SAAS,CAAC,EAAEI,WAAW,EAAE;gCAC/Cb,MAAM,CAAC,GAAGS,SAAS,CAAC,EAAEI,WAAW,CAAC,GAAGX;4BACvC;wBACF;oBACF;gBACF;YACF;QACF;IACF;IAEA,OAAOF;AACT;AAEA,SAASc,WAAWjB,GAA4B;IAC9C,MAAMkB,eAAwC,CAAC;IAC/CZ,OAAOJ,IAAI,CAACF,KACTmB,IAAI,GACJJ,OAAO,CAAC,CAACL;QACR,IAAI,OAAOV,GAAG,CAACU,IAAI,KAAK,UAAU;YAChCQ,YAAY,CAACR,IAAI,GAAGO,WAAWjB,GAAG,CAACU,IAAI;QACzC,OAAO;YACLQ,YAAY,CAACR,IAAI,GAAGV,GAAG,CAACU,IAAI;QAC9B;IACF;IACF,OAAOQ;AACT;AAEA,OAAO,MAAME,2BAA2B,CAACC,kBAA4BC;IACnE,IAAIA,YAAY,UAAU;QACxB,OAAOL,WAAWlB,WAAWsB,iBAAiBE,YAAY,EAAE,IAAIzB;IAClE,OAAO;QACL,OAAOuB,iBAAiBE,YAAY;IACtC;AACF,EAAC"}
+{"version":3,"sources":["../../src/utilities/getTranslationsByContext.ts"],"sourcesContent":["import type { Language } from '../types.js'\n\nimport { clientTranslationKeys } from '../clientKeys.js'\n\n/**\n * The client translation keys, grouped by namespace. For example, the keys `general:cancel`,\n * `general:item` and `authentication:account` are stored as:\n *\n * `Map { 'general' => Set { 'cancel', 'item' }, 'authentication' => Set { 'account' } }`\n */\nconst clientKeysByNamespace = new Map<string, Set<string>>()\nfor (const clientKey of clientTranslationKeys) {\n  const separatorIndex = clientKey.indexOf(':')\n  const namespace = clientKey.slice(0, separatorIndex)\n  const key = clientKey.slice(separatorIndex + 1)\n  const keys = clientKeysByNamespace.get(namespace) ?? new Set<string>()\n  clientKeysByNamespace.set(namespace, keys.add(key))\n}\n\n/** Plural forms of a key, for example `item_one` and `item_other` for `item` */\nconst pluralSuffix = /_(?:zero|one|two|few|many|other)$/\n\n/**\n * Keeps only the translations the admin needs in the browser: the keys listed in\n * `clientTranslationKeys`, plus their plural forms. Namespaces that end up empty are left out.\n *\n * @example\n * // With the client keys `general:cancel` and `general:item`:\n * filterClientKeys({\n *   general: { cancel: 'Cancel', item: 'Item', item_other: 'Items', save: 'Save' },\n *   error: { notFound: 'Not found' },\n * })\n * // => { general: { cancel: 'Cancel', item: 'Item', item_other: 'Items' } }\n */\nfunction filterClientKeys(translations: Record<string, unknown>) {\n  const result: Record<string, unknown> = {}\n\n  for (const [namespace, value] of Object.entries(translations)) {\n    if (namespace === '$schema') {\n      result[namespace] = value\n      continue\n    }\n\n    const clientKeys = clientKeysByNamespace.get(namespace)\n    if (!clientKeys || typeof value !== 'object' || value === null) {\n      continue\n    }\n\n    const clientTranslations: Record<string, unknown> = {}\n    for (const [key, translation] of Object.entries(value)) {\n      if (clientKeys.has(key) || clientKeys.has(key.replace(pluralSuffix, ''))) {\n        clientTranslations[key] = translation\n      }\n    }\n\n    if (Object.keys(clientTranslations).length > 0) {\n      result[namespace] = clientTranslations\n    }\n  }\n\n  return result\n}\n\nfunction sortObject(obj: Record<string, unknown>) {\n  const sortedObject: Record<string, unknown> = {}\n  Object.keys(obj)\n    .sort()\n    .forEach((key) => {\n      if (typeof obj[key] === 'object') {\n        sortedObject[key] = sortObject(obj[key] as Record<string, unknown>)\n      } else {\n        sortedObject[key] = obj[key]\n      }\n    })\n  return sortedObject\n}\n\nexport const getTranslationsByContext = (selectedLanguage: Language, context: 'api' | 'client') => {\n  if (context === 'client') {\n    return sortObject(filterClientKeys(selectedLanguage.translations))\n  } else {\n    return selectedLanguage.translations\n  }\n}\n"],"names":["clientTranslationKeys","clientKeysByNamespace","Map","clientKey","separatorIndex","indexOf","namespace","slice","key","keys","get","Set","set","add","pluralSuffix","filterClientKeys","translations","result","value","Object","entries","clientKeys","clientTranslations","translation","has","replace","length","sortObject","obj","sortedObject","sort","forEach","getTranslationsByContext","selectedLanguage","context"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,mBAAkB;AAExD;;;;;CAKC,GACD,MAAMC,wBAAwB,IAAIC;AAClC,KAAK,MAAMC,aAAaH,sBAAuB;IAC7C,MAAMI,iBAAiBD,UAAUE,OAAO,CAAC;IACzC,MAAMC,YAAYH,UAAUI,KAAK,CAAC,GAAGH;IACrC,MAAMI,MAAML,UAAUI,KAAK,CAACH,iBAAiB;IAC7C,MAAMK,OAAOR,sBAAsBS,GAAG,CAACJ,cAAc,IAAIK;IACzDV,sBAAsBW,GAAG,CAACN,WAAWG,KAAKI,GAAG,CAACL;AAChD;AAEA,8EAA8E,GAC9E,MAAMM,eAAe;AAErB;;;;;;;;;;;CAWC,GACD,SAASC,iBAAiBC,YAAqC;IAC7D,MAAMC,SAAkC,CAAC;IAEzC,KAAK,MAAM,CAACX,WAAWY,MAAM,IAAIC,OAAOC,OAAO,CAACJ,cAAe;QAC7D,IAAIV,cAAc,WAAW;YAC3BW,MAAM,CAACX,UAAU,GAAGY;YACpB;QACF;QAEA,MAAMG,aAAapB,sBAAsBS,GAAG,CAACJ;QAC7C,IAAI,CAACe,cAAc,OAAOH,UAAU,YAAYA,UAAU,MAAM;YAC9D;QACF;QAEA,MAAMI,qBAA8C,CAAC;QACrD,KAAK,MAAM,CAACd,KAAKe,YAAY,IAAIJ,OAAOC,OAAO,CAACF,OAAQ;YACtD,IAAIG,WAAWG,GAAG,CAAChB,QAAQa,WAAWG,GAAG,CAAChB,IAAIiB,OAAO,CAACX,cAAc,MAAM;gBACxEQ,kBAAkB,CAACd,IAAI,GAAGe;YAC5B;QACF;QAEA,IAAIJ,OAAOV,IAAI,CAACa,oBAAoBI,MAAM,GAAG,GAAG;YAC9CT,MAAM,CAACX,UAAU,GAAGgB;QACtB;IACF;IAEA,OAAOL;AACT;AAEA,SAASU,WAAWC,GAA4B;IAC9C,MAAMC,eAAwC,CAAC;IAC/CV,OAAOV,IAAI,CAACmB,KACTE,IAAI,GACJC,OAAO,CAAC,CAACvB;QACR,IAAI,OAAOoB,GAAG,CAACpB,IAAI,KAAK,UAAU;YAChCqB,YAAY,CAACrB,IAAI,GAAGmB,WAAWC,GAAG,CAACpB,IAAI;QACzC,OAAO;YACLqB,YAAY,CAACrB,IAAI,GAAGoB,GAAG,CAACpB,IAAI;QAC9B;IACF;IACF,OAAOqB;AACT;AAEA,OAAO,MAAMG,2BAA2B,CAACC,kBAA4BC;IACnE,IAAIA,YAAY,UAAU;QACxB,OAAOP,WAAWZ,iBAAiBkB,iBAAiBjB,YAAY;IAClE,OAAO;QACL,OAAOiB,iBAAiBjB,YAAY;IACtC;AACF,EAAC"}

package/dist/utilities/init.d.ts

@@ -9,7 +9,7 @@ import type { DefaultTranslationKeys, DefaultTranslationsObject, I18n, Language
 export declare const getTranslationString: <TTranslations = DefaultTranslationsObject, TTranslationKeys = DefaultTranslationKeys>({ count, key, translations, }: {
     count?: number;
     key: TTranslationKeys;
-    translations: Language<TTranslations>["translations"];
+    translations: Language<TTranslations>['translations'];
 }) => string;
 /**
  * @function t
@@ -26,11 +26,11 @@ export declare function t<TTranslations = DefaultTranslationsObject, TTranslatio
 }): string;
 export declare const initI18n: (args: {
     config: import("../types.js").I18nOptions;
-    context: "api";
+    context: 'api';
     language: import("../types.js").AcceptedLanguages;
 } | {
     config: import("../types.js").I18nOptions<import("../types.js").ClientTranslationsObject>;
-    context: "client";
+    context: 'client';
     language: import("../types.js").AcceptedLanguages;
 }) => Promise<I18n>;
 //# sourceMappingURL=init.d.ts.map

package/dist/utilities/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/utilities/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,IAAI,EAGJ,QAAQ,EACT,MAAM,aAAa,CAAA;AAMpB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,aAAa,GAAG,yBAAyB,EACzC,gBAAgB,GAAG,sBAAsB,EACzC,+BAIC;IACD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,gBAAgB,CAAA;IACrB,YAAY,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,cAAc,CAAC,CAAA;CACtD,KAAG,MAyCH,CAAA;AAiCD;;;;;;;GAOG;AACH,wBAAgB,CAAC,CACf,aAAa,GAAG,yBAAyB,EACzC,gBAAgB,GAAG,sBAAsB,EACzC,EACA,GAAG,EACH,YAAY,EACZ,IAAI,GACL,EAAE;IACD,GAAG,EAAE,gBAAgB,CAAA;IACrB,YAAY,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,cAAc,CAAC,CAAA;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC3B,GAAG,MAAM,CAmBT;AA4CD,eAAO,MAAM,QAAQ;;;;;;;;MAjBL,OAAO,CAAC,IAAI,CA+C3B,CAAA"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/utilities/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,IAAI,EAGJ,QAAQ,EACT,MAAM,aAAa,CAAA;AAMpB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,aAAa,GAAG,yBAAyB,EACzC,gBAAgB,GAAG,sBAAsB,iCAKxC;IACD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,gBAAgB,CAAA;IACrB,YAAY,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,cAAc,CAAC,CAAA;CACtD,KAAG,MAyCH,CAAA;AAiCD;;;;;;;GAOG;AACH,wBAAgB,CAAC,CACf,aAAa,GAAG,yBAAyB,EACzC,gBAAgB,GAAG,sBAAsB,EACzC,EACA,GAAG,EACH,YAAY,EACZ,IAAI,GACL,EAAE;IACD,GAAG,EAAE,gBAAgB,CAAA;IACrB,YAAY,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,cAAc,CAAC,CAAA;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC3B,GAAG,MAAM,CAmBT;AA4CD,eAAO,MAAM,QAAQ;;;;;;;;MAjBL,OAAO,CAAC,IAAI,CA+C3B,CAAA"}

package/dist/utilities/languages.d.ts

@@ -1,5 +1,5 @@
 import type { AcceptedLanguages } from '../types.js';
-export declare const rtlLanguages: readonly ["ar", "fa", "he"];
-export declare const acceptedLanguages: readonly ["ar", "az", "bg", "bn-BD", "bn-IN", "ca", "cs", "bn-BD", "bn-IN", "da", "de", "en", "es", "et", "fa", "fr", "he", "hr", "hu", "hy", "id", "is", "it", "ja", "ko", "lt", "lv", "my", "nb", "nl", "pl", "pt", "ro", "rs", "rs-latin", "ru", "sk", "sl", "sv", "ta", "th", "tr", "uk", "vi", "zh", "zh-TW"];
+export declare const rtlLanguages: readonly ['ar', 'fa', 'he'];
+export declare const acceptedLanguages: readonly ['ar', 'az', 'bg', 'bn-BD', 'bn-IN', 'ca', 'cs', 'bn-BD', 'bn-IN', 'da', 'de', 'en', 'es', 'et', 'fa', 'fr', 'he', 'hr', 'hu', 'hy', 'id', 'is', 'it', 'ja', 'ko', 'lt', 'lv', 'my', 'nb', 'nl', 'pl', 'pt', 'ro', 'rs', 'rs-latin', 'ru', 'sk', 'sl', 'sv', 'ta', 'th', 'tr', 'uk', 'vi', 'zh', 'zh-TW'];
 export declare function extractHeaderLanguage(acceptLanguageHeader: string): AcceptedLanguages | undefined;
 //# sourceMappingURL=languages.d.ts.map

package/dist/utilities/languages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../src/utilities/languages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,aAAa,CAAA;AAExE,eAAO,MAAM,YAAY,6BAA8B,CAAA;AAEvD,eAAO,MAAM,iBAAiB,oTAmIpB,CAAA;AAkBV,wBAAgB,qBAAqB,CAAC,oBAAoB,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAuBjG"}
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../src/utilities/languages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,aAAa,CAAA;AAExE,eAAO,MAAM,YAAY,YAAI,IAAI,EAAE,IAAI,EAAE,IAAI,CAAU,CAAA;AAEvD,eAAO,MAAM,iBAAiB,YAC5B,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,OAAO,CAqFC,CAAA;AAkBV,wBAAgB,qBAAqB,CAAC,oBAAoB,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAuBjG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/translations",
-  "version": "4.0.0-internal.293e026",
+  "version": "4.0.0-internal.2a3c3bc",
   "homepage": "https://payloadcms.com",
   "repository": {
     "type": "git",
@@ -46,18 +46,20 @@
     "dist"
   ],
   "dependencies": {
-    "date-fns": "4.1.0"
+    "date-fns": "4.4.0"
   },
   "devDependencies": {
-    "@types/react": "19.2.14",
-    "@types/react-dom": "19.2.3",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
     "dotenv": "16.4.7",
+    "esbuild": "0.27.1",
     "prettier": "3.5.3",
-    "typescript": "6.0.3",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
     "@payloadcms/eslint-config": "3.28.0"
   },
   "scripts": {
-    "build": "pnpm build:types && pnpm build:swc",
+    "build": "pnpm build:types && pnpm build:swc && pnpm build:dateFNS",
+    "build:dateFNS": "node bundleDateFNSLocales.js",
     "build:debug": "pnpm build",
     "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",

package/dist/utilities/deepMergeSimple.spec.js

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deepMergeSimple } from './deepMergeSimple.js';
-describe('deepMergeSimple', ()=>{
-    it('should merge two flat objects', ()=>{
-        const result = deepMergeSimple({
-            a: 1
-        }, {
-            b: 2
-        });
-        expect(result).toEqual({
-            a: 1,
-            b: 2
-        });
-    });
-    it('should let obj2 override obj1 keys', ()=>{
-        const result = deepMergeSimple({
-            a: 1
-        }, {
-            a: 2
-        });
-        expect(result).toEqual({
-            a: 2
-        });
-    });
-    it('should recursively merge nested objects', ()=>{
-        const result = deepMergeSimple({
-            a: {
-                b: 1,
-                c: 2
-            }
-        }, {
-            a: {
-                c: 3,
-                d: 4
-            }
-        });
-        expect(result).toEqual({
-            a: {
-                b: 1,
-                c: 3,
-                d: 4
-            }
-        });
-    });
-    it('should not mutate the input objects', ()=>{
-        const obj1 = {
-            a: 1
-        };
-        const obj2 = {
-            b: 2
-        };
-        deepMergeSimple(obj1, obj2);
-        expect(obj1).toEqual({
-            a: 1
-        });
-        expect(obj2).toEqual({
-            b: 2
-        });
-    });
-    it('should not pollute global Object.prototype via __proto__', ()=>{
-        const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
-        deepMergeSimple({}, malicious);
-        expect({}.isAdmin).toBeUndefined();
-    });
-    it('should not hijack the returned object prototype via __proto__', ()=>{
-        const malicious = JSON.parse('{"__proto__": {"isAdmin": true}}');
-        const result = deepMergeSimple({}, malicious);
-        expect(result.isAdmin).toBeUndefined();
-    });
-    it('should not hijack prototype via nested __proto__ key', ()=>{
-        const malicious = JSON.parse('{"a": {"__proto__": {"isAdmin": true}}}');
-        const base = {
-            a: {}
-        };
-        const result = deepMergeSimple(base, malicious);
-        expect(result.a.isAdmin).toBeUndefined();
-        expect({}.isAdmin).toBeUndefined();
-    });
-});
-
-//# sourceMappingURL=deepMergeSimple.spec.js.map

package/dist/utilities/deepMergeSimple.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utilities/deepMergeSimple.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { deepMergeSimple } from './deepMergeSimple.js'\n\ndescribe('deepMergeSimple', () => {\n  it('should merge two flat objects', () => {\n    const result = deepMergeSimple({ a: 1 }, { b: 2 })\n    expect(result).toEqual({ a: 1, b: 2 })\n  })\n\n  it('should let obj2 override obj1 keys', () => {\n    const result = deepMergeSimple({ a: 1 }, { a: 2 })\n    expect(result).toEqual({ a: 2 })\n  })\n\n  it('should recursively merge nested objects', () => {\n    const result = deepMergeSimple({ a: { b: 1, c: 2 } }, { a: { c: 3, d: 4 } })\n    expect(result).toEqual({ a: { b: 1, c: 3, d: 4 } })\n  })\n\n  it('should not mutate the input objects', () => {\n    const obj1 = { a: 1 }\n    const obj2 = { b: 2 }\n    deepMergeSimple(obj1, obj2)\n    expect(obj1).toEqual({ a: 1 })\n    expect(obj2).toEqual({ b: 2 })\n  })\n\n  it('should not pollute global Object.prototype via __proto__', () => {\n    const malicious = JSON.parse('{\"__proto__\": {\"isAdmin\": true}}')\n    deepMergeSimple({}, malicious)\n    expect(({} as any).isAdmin).toBeUndefined()\n  })\n\n  it('should not hijack the returned object prototype via __proto__', () => {\n    const malicious = JSON.parse('{\"__proto__\": {\"isAdmin\": true}}')\n    const result = deepMergeSimple({}, malicious) as any\n    expect(result.isAdmin).toBeUndefined()\n  })\n\n  it('should not hijack prototype via nested __proto__ key', () => {\n    const malicious = JSON.parse('{\"a\": {\"__proto__\": {\"isAdmin\": true}}}')\n    const base = { a: {} }\n    const result = deepMergeSimple(base, malicious) as any\n    expect(result.a.isAdmin).toBeUndefined()\n    expect(({} as any).isAdmin).toBeUndefined()\n  })\n})\n"],"names":["describe","expect","it","deepMergeSimple","result","a","b","toEqual","c","d","obj1","obj2","malicious","JSON","parse","isAdmin","toBeUndefined","base"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,eAAe,QAAQ,uBAAsB;AAEtDH,SAAS,mBAAmB;IAC1BE,GAAG,iCAAiC;QAClC,MAAME,SAASD,gBAAgB;YAAEE,GAAG;QAAE,GAAG;YAAEC,GAAG;QAAE;QAChDL,OAAOG,QAAQG,OAAO,CAAC;YAAEF,GAAG;YAAGC,GAAG;QAAE;IACtC;IAEAJ,GAAG,sCAAsC;QACvC,MAAME,SAASD,gBAAgB;YAAEE,GAAG;QAAE,GAAG;YAAEA,GAAG;QAAE;QAChDJ,OAAOG,QAAQG,OAAO,CAAC;YAAEF,GAAG;QAAE;IAChC;IAEAH,GAAG,2CAA2C;QAC5C,MAAME,SAASD,gBAAgB;YAAEE,GAAG;gBAAEC,GAAG;gBAAGE,GAAG;YAAE;QAAE,GAAG;YAAEH,GAAG;gBAAEG,GAAG;gBAAGC,GAAG;YAAE;QAAE;QAC1ER,OAAOG,QAAQG,OAAO,CAAC;YAAEF,GAAG;gBAAEC,GAAG;gBAAGE,GAAG;gBAAGC,GAAG;YAAE;QAAE;IACnD;IAEAP,GAAG,uCAAuC;QACxC,MAAMQ,OAAO;YAAEL,GAAG;QAAE;QACpB,MAAMM,OAAO;YAAEL,GAAG;QAAE;QACpBH,gBAAgBO,MAAMC;QACtBV,OAAOS,MAAMH,OAAO,CAAC;YAAEF,GAAG;QAAE;QAC5BJ,OAAOU,MAAMJ,OAAO,CAAC;YAAED,GAAG;QAAE;IAC9B;IAEAJ,GAAG,4DAA4D;QAC7D,MAAMU,YAAYC,KAAKC,KAAK,CAAC;QAC7BX,gBAAgB,CAAC,GAAGS;QACpBX,OAAO,AAAC,CAAC,EAAUc,OAAO,EAAEC,aAAa;IAC3C;IAEAd,GAAG,iEAAiE;QAClE,MAAMU,YAAYC,KAAKC,KAAK,CAAC;QAC7B,MAAMV,SAASD,gBAAgB,CAAC,GAAGS;QACnCX,OAAOG,OAAOW,OAAO,EAAEC,aAAa;IACtC;IAEAd,GAAG,wDAAwD;QACzD,MAAMU,YAAYC,KAAKC,KAAK,CAAC;QAC7B,MAAMG,OAAO;YAAEZ,GAAG,CAAC;QAAE;QACrB,MAAMD,SAASD,gBAAgBc,MAAML;QACrCX,OAAOG,OAAOC,CAAC,CAACU,OAAO,EAAEC,aAAa;QACtCf,OAAO,AAAC,CAAC,EAAUc,OAAO,EAAEC,aAAa;IAC3C;AACF"}

package/dist/utilities/languages.spec.js

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { extractHeaderLanguage } from './languages.js';
-describe('extractHeaderLanguage', ()=>{
-    it('should return exact match when base language tag is supported', ()=>{
-        expect(extractHeaderLanguage('ja')).toBe('ja');
-        expect(extractHeaderLanguage('en')).toBe('en');
-        expect(extractHeaderLanguage('de')).toBe('de');
-    });
-    it('should fall back to base tag when regional tag has no exact match', ()=>{
-        expect(extractHeaderLanguage('ja-JP')).toBe('ja');
-        expect(extractHeaderLanguage('de-AT')).toBe('de');
-        expect(extractHeaderLanguage('fr-BE')).toBe('fr');
-    });
-    it('should match exact regional tag when it is supported', ()=>{
-        // zh-TW is in acceptedLanguages, so it should match directly
-        expect(extractHeaderLanguage('zh-TW')).toBe('zh-TW');
-        // bn-BD is in acceptedLanguages
-        expect(extractHeaderLanguage('bn-BD')).toBe('bn-BD');
-    });
-    it('should fall back to base tag for unsupported regional variant of a supported regional language', ()=>{
-        // zh-CN is not in acceptedLanguages, but zh is
-        expect(extractHeaderLanguage('zh-CN')).toBe('zh');
-    });
-    it('should return undefined for unsupported languages', ()=>{
-        expect(extractHeaderLanguage('xx')).toBeUndefined();
-        expect(extractHeaderLanguage('xx-XX')).toBeUndefined();
-    });
-    it('should respect quality ordering and return highest quality supported language', ()=>{
-        expect(extractHeaderLanguage('ja-JP;q=0.9, en;q=1.0')).toBe('en');
-        expect(extractHeaderLanguage('ja-JP, en;q=0.9')).toBe('ja');
-    });
-    it('should skip unsupported languages and find the next supported one', ()=>{
-        expect(extractHeaderLanguage('xx-XX, ja-JP')).toBe('ja');
-        expect(extractHeaderLanguage('xx, yy, de-DE')).toBe('de');
-    });
-    it('should handle empty string', ()=>{
-        // empty string produces one entry with empty language, which won't match
-        expect(extractHeaderLanguage('')).toBeUndefined();
-    });
-});
-
-//# sourceMappingURL=languages.spec.js.map