dev-dict 0.7.2 → 0.7.4

package/README.md

@@ -1,40 +1,26 @@
-# dev-dict
+<p align="center">
+  <img src="./demo/public/logo.png" alt="dev-dict" width="125">
+</p>
 
-> A multilingual dictionary of software development terms
+# dev-dict
 
 [![npm version](https://img.shields.io/npm/v/dev-dict.svg)](https://www.npmjs.com/package/dev-dict)
-[![npm downloads](https://img.shields.io/npm/dm/dev-dict.svg)](https://www.npmjs.com/package/dev-dict)
 [![Bundle size](https://img.shields.io/bundlephobia/minzip/dev-dict)](https://bundlephobia.com/package/dev-dict)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](./CONTRIBUTING.md)
 
-**dev-dict** provides an exhaustive, community-driven collection of software industry terms with clear explanations in multiple languages. Perfect for developers, technical writers, educators, and anyone building multilingual developer tools.
-
-**[View Dictionary (Demo)](https://kyco.github.io/dev-dict/)**
+A community-driven collection of software development terms with explanations in multiple languages. Perfect for building multilingual developer tools, documentation sites, and educational platforms.
 
+**[Browse All Terms](https://kyco.github.io/dev-dict/)**
 
 ## Features
 
-- **Multilingual Support** - Terms available in English (US/GB), German, and more
-- **Type-Safe** - Built with TypeScript for excellent IDE support
-- **Flexible API** - Access localised strings or raw translation objects
-- **Comprehensive** - Covering frameworks, libraries, languages, tools, and concepts
+- **Type-Safe** - Full TypeScript support
+- **Multilingual** - English (US/GB), German, and growing
+- **Flexible** - Access localised strings or raw translation objects
 - **Lightweight** - Tree-shakeable ESM and UMD builds
-- **Extensible** - Easy to contribute new terms and translations
-
-
-## Browse Available Terms
-
-Explore the full catalogue of terms, types, and tags:
-
-- **[Terms](./docs/TERMS.md)** - All software development terms
-- **[Types](./docs/TYPES.md)** - Term categories (library, framework, etc.)
-- **[Tags](./docs/TAGS.md)** - Additional classifications (frontend, backend, etc.)
-
 
-## Quick Start
+## Installation
 
-### Installation
+### via Package Manager
 
 ```bash
 npm install dev-dict
@@ -44,168 +30,227 @@ pnpm add dev-dict
 yarn add dev-dict
 ```
 
-### Basic Usage
+### via CDN (unpkg)
+
+```html
+<script src="https://unpkg.com/dev-dict@latest/dist/dev-dict.min.js"></script>
+<script>
+  // Access the library via the global 'devdict' object
+  const { terms, types, tags, locales, utils } = devdict
+
+  // Get all terms for a locale
+  const dictionary = utils.getTerms({ terms, locale: 'en-US' })
+
+  console.log(dictionary)
+</script>
+```
+
+## Quick Start
+
+### Option 1: Full Dictionary
+
+Import the complete dictionary to access all terms.
 
 ```typescript
-import { getTerm, getTerms, getDict } from 'dev-dict'
+import { terms } from 'dev-dict'
+import { getTerms, getTags, getTypes } from 'dev-dict/utils'
 
-// Get a single term
-const react = getTerm({ id: 'react', locale: 'en-US' })
-console.log(react.label)      // "JavaScript Library"
-console.log(react.definition) // "A JavaScript library for building user interfaces..."
+// Get all terms for a locale
+const dictionary = getTerms({ terms, locale: 'en-US' })
 
-// Get all terms as an array
-const terms = getTerms({ locale: 'en-US' })
-console.log(terms) // [{ id: "react", name: "React", ... }, ...]
+// Get types and tags
+const types = getTypes({ terms, locale: 'en-US' })
+const tags = getTags({ terms, locale: 'en-US' })
 
-// Get dictionary object (keyed by ID)
-const dict = getDict({ locale: 'en-US' })
-console.log(dict.react.label) // "JavaScript Library"
-console.log(dict.typescript.label) // "Programming Language"
+// Display terms
+dictionary.forEach(term => {
+  console.log(term.name) // "React"
+  console.log(term.label) // "JavaScript Library"
+})
 ```
 
+### Option 2: Selected Terms Only
+
+Import only the specific terms you need for better tree-shaking and smaller bundle size.
+
+```typescript
+import { react, typescript, node_js } from 'dev-dict/terms'
+import { getTerms } from 'dev-dict/utils'
+
+// Create a custom dictionary with only the terms you need
+const terms = { react, typescript, node_js }
+
+// Then use the same helper functions as Option 1
+const dictionary = getTerms({ terms, locale: 'en-US' })
+```
 
 ## API Reference
 
-### `getTerm(options)`
+### Import Data
+
+```typescript
+import { terms, types, tags, locales } from 'dev-dict'
+```
+
+- `terms` - Raw terms dictionary
+- `types` - Type constants and definitions
+- `tags` - Tag constants and definitions
+- `locales` - Locale constants
 
-Get a single term by ID.
+### Helper Functions
+
+Import from `dev-dict/utils`:
 
 ```typescript
-// Localised (default)
-const reactEn = getTerm({ id: 'react', locale: 'en-US' })
-console.log(reactEn.label) // "JavaScript Library"
+import { getTerms, getTermsDict, getTypes, getTypesDict, getTags, getTagsDict } from 'dev-dict/utils'
+```
 
-const reactDe = getTerm({ id: 'react', locale: 'de-DE' })
-console.log(reactDe.label) // "JavaScript-Bibliothek"
+#### `getTermsDict(options)`
 
-// Raw (all translations)
-const reactRaw = getTerm({ id: 'react', localized: false })
-console.log(reactRaw.label)
-// { "en-US": "JavaScript Library", "de-DE": "JavaScript-Bibliothek", ... }
+Get all terms as a dictionary object.
+
+```typescript
+const termsDict = getTermsDict({
+  terms,
+  locale: 'en-US',
+  populateEmpty: true
+})
+// { react: { id: "react", name: "React", ... }, vue: { id: "vue", name: "Vue", ... } }
 ```
 
 **Options:**
-- `id: string` - Term identifier (required)
+- `terms: TTermsDict` - The terms dictionary (required)
 - `locale?: string` - Target locale (default: `'en-US'`)
-- `localized?: boolean` - Return localised strings (default: `true`)
-- `useFallback?: boolean` - Fall back to en-US for missing translations (default: `true`)
+- `populateEmpty?: boolean` - Populate empty locale records with en-US values (default: `true`)
 
-### `getTerms(options)`
+**Returns:** `Partial<TTermsDictLocalized>` - Dictionary of localised terms
+
+#### `getTerms(options)`
 
 Get all terms as an array.
 
 ```typescript
-// Localised
-const terms = getTerms({ locale: 'en-US' })
-console.log(terms) // [{ id: "react", label: "JavaScript Library" }, ...]
-
-// Raw
-const termsRaw = getTerms({ localized: false })
-console.log(termsRaw)
-// [{ id: "react", label: { "en-US": "...", "de-DE": "..." } }, ...]
+const dictionary = getTerms({
+  terms,
+  locale: 'en-US',
+  populateEmpty: true
+})
 ```
 
 **Options:**
+- `terms: TTermsDict` - The terms dictionary (required)
 - `locale?: string` - Target locale (default: `'en-US'`)
-- `localized?: boolean` - Return localised strings (default: `true`)
-- `useFallback?: boolean` - Fall back to en-US for missing translations (default: `true`)
+- `populateEmpty?: boolean` - Populate empty locale records with en-US values (default: `true`)
+
+**Returns:** `TTermLocalized[]` - Array of localised terms
 
-### `getDict(options)`
+#### `getTypesDict(options)`
 
-Get dictionary as an object keyed by term ID.
+Get all term types as a dictionary object.
 
 ```typescript
-// Localised
-const dict = getDict({ locale: 'en-US' })
-console.log(dict.react.label) // "JavaScript Library"
-
-// Raw
-const dictRaw = getDict({ localized: false })
-console.log(dictRaw.react.label)
-// { "en-US": "JavaScript Library", "de-DE": "JavaScript-Bibliothek", ... }
+const typesDict = getTypesDict({
+  terms,
+  locale: 'en-US'
+})
+// { library: { id: "library", name: "Library" }, framework: { id: "framework", name: "Framework" }, ... }
 ```
 
-**Options:**
-- `locale?: string` - Target locale (default: `'en-US'`)
-- `localized?: boolean` - Return localised strings (default: `true`)
-- `useFallback?: boolean` - Fall back to en-US for missing translations (default: `true`)
-
-### `getTypes(options)`
+#### `getTypes(options)`
 
-Get all term types (e.g., library, framework, language).
+Get all term types as an array.
 
 ```typescript
-const types = getTypes({ locale: 'en-US' })
-console.log(types)
+const types = getTypes({
+  terms,
+  locale: 'en-US'
+})
 // [{ id: "library", name: "Library" }, { id: "framework", name: "Framework" }, ...]
 ```
 
-### `getTags(options)`
+#### `getTagsDict(options)`
+
+Get all term tags as a dictionary object.
+
+```typescript
+const tagsDict = getTagsDict({
+  terms,
+  locale: 'en-US'
+})
+// { frontend: { id: "frontend", name: "Frontend" }, backend: { id: "backend", name: "Backend" }, ... }
+```
+
+#### `getTags(options)`
 
-Get all term tags (e.g., frontend, backend, open_source).
+Get all term tags as an array.
 
 ```typescript
-const tags = getTags({ locale: 'en-US' })
-console.log(tags)
+const tags = getTags({
+  terms,
+  locale: 'en-US'
+})
 // [{ id: "frontend", name: "Frontend" }, { id: "backend", name: "Backend" }, ...]
 ```
 
+### Term Structure
+
+```typescript
+{
+  id: string              // Unique identifier
+  name: string            // Display name
+  altName?: string        // Optional abbreviation/short name
+  label: string           // Descriptive type (e.g., "UI Library")
+  definition: string      // Full explanation
+  type: Array<{           // Categories
+    id: string
+    name: string
+  }>
+  tags: Array<{           // Additional classifications
+    id: string
+    name: string
+  }>
+  links?: {               // Optional external links
+    website: string
+    github?: string
+    npm?: string
+    wikipedia?: string
+  }
+}
+```
 
 ## Supported Languages
 
 | Locale | Language | Status |
 |--------|----------|--------|
-| `en-US` | English (United States) | ✅ Primary (all terms) |
+| `en-US` | English (United States) | ✅ Primary |
 | `en-GB` | English (Great Britain) | ✅ Supported |
 | `de-DE` | German (Germany) | ✅ Supported |
 
-Want to add a new language? Check out the [Contributing Guide](./CONTRIBUTING.md#adding-a-new-language).
+Want to add a language? See [CONTRIBUTING.md](./CONTRIBUTING.md#adding-a-new-language)
 
+## Browse Terms
 
-## Contributing
+- **[Terms](./docs/TERMS.md)** - All software development terms
+- **[Types](./docs/TYPES.md)** - Term categories
+- **[Tags](./docs/TAGS.md)** - Additional classifications
 
-We welcome contributions! Whether you want to:
-- Add a new term
-- Provide translations
-- Fix errors or typos
-- Suggest improvements
+## Contributing
 
-Please read our [Contributing Guide](./CONTRIBUTING.md) to get started.
+Contributions welcome! Add terms, provide translations, fix errors, or suggest improvements.
 
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details.
 
 ## Development
 
 ```bash
-# Install dependencies
-pnpm install
-
-# Build library
-pnpm build
-
-# Run demo site locally
-pnpm demo:dev
-
-# Build demo site
-pnpm demo:build
-
-# Preview demo build
-pnpm demo:preview
-
-# Lint code
-npx eslint .
-
-# Format code
-npx prettier --write .
+pnpm install      # Install dependencies
+pnpm build        # Build library
+pnpm demo:dev     # Run demo site (http://localhost:5173)
+pnpm demo:build   # Build demo site
 ```
 
-For detailed development guidance, see [CLAUDE.md](./CLAUDE.md).
-
+See [CLAUDE.md](./.claude/CLAUDE.md) for detailed development guidance.
 
-## Use Cases
+## License
 
-- **Documentation Sites** - Display term definitions with automatic localisation
-- **Educational Platforms** - Teach developers in their native language
-- **Developer Tools** - Add contextual help for technical terms
-- **Content Management** - Maintain consistent terminology across translations
-- **IDE Extensions** - Provide inline term explanations
+MIT

package/dist/common/index.d.ts

@@ -1,6 +1,8 @@
-export declare const MISC: {};
+export declare const MISC: {
+    TERM_INTERPOLATION_KEYS: string[];
+};
 export declare const CONFIG: {
-    readonly DEFAULT_LOCALE: "en-US";
-    readonly USE_FALLBACK: true;
+    DEFAULT_LOCALE: "en-US";
+    POPULATE_EMPTY: boolean;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,IAAc,CAAA;AAE/B,eAAO,MAAM,MAAM;;;CAGT,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;CAEhB,CAAA;AAED,eAAO,MAAM,MAAM;;;CAGlB,CAAA"}

package/dist/data/sources/index.d.ts

@@ -15,14 +15,6 @@ export declare const RAW_SOURCES: {
             readonly "de-DE": "Gemeinschaftskonsens";
         };
     };
-    readonly inferred: {
-        readonly id: "inferred";
-        readonly name: {
-            readonly "en-US": "Inferred from Context";
-            readonly "en-GB": "en-US";
-            readonly "de-DE": "Aus dem Kontext abgeleitet";
-        };
-    };
     readonly official_website: {
         readonly id: "official_website";
         readonly name: {
@@ -57,14 +49,6 @@ export declare const SOURCES: {
             readonly "de-DE": "Gemeinschaftskonsens";
         };
     };
-    readonly inferred: {
-        readonly id: "inferred";
-        readonly name: {
-            readonly "en-US": "Inferred from Context";
-            readonly "en-GB": "en-US";
-            readonly "de-DE": "Aus dem Kontext abgeleitet";
-        };
-    };
     readonly official_website: {
         readonly id: "official_website";
         readonly name: {

package/dist/data/sources/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/sources/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMd,CAAA;AAEV,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA8E,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/sources/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKd,CAAA;AAEV,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgF,CAAA"}

package/dist/data/tags/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/tags/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYX,CAAA;AAEV,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA2E,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/tags/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYX,CAAA;AAEV,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA6E,CAAA"}

package/dist/data/terms/aes.d.ts

@@ -43,6 +43,28 @@ declare const _default: {
             readonly "de-DE": "Kryptografie";
         };
     }];
+    readonly links: {
+        readonly website: "https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.197-upd1.pdf";
+        readonly wikipedia: "https://en.wikipedia.org/wiki/Advanced_Encryption_Standard";
+    };
+    readonly sources: {
+        readonly label: {
+            readonly id: "community";
+            readonly name: {
+                readonly "en-US": "Community Consensus";
+                readonly "en-GB": "en-US";
+                readonly "de-DE": "Gemeinschaftskonsens";
+            };
+        };
+        readonly definition: {
+            readonly id: "ai_generated";
+            readonly name: {
+                readonly "en-US": "AI Generated";
+                readonly "en-GB": "en-US";
+                readonly "de-DE": "KI-generiert";
+            };
+        };
+    };
 };
 export default _default;
 //# sourceMappingURL=aes.d.ts.map

package/dist/data/terms/aes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aes.d.ts","sourceRoot":"","sources":["../../../src/data/terms/aes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,wBA8B0B"}
+{"version":3,"file":"aes.d.ts","sourceRoot":"","sources":["../../../src/data/terms/aes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,wBAwC0B"}

package/dist/data/terms/index.d.ts

@@ -44,6 +44,28 @@ export declare const RAW_TERMS: {
                 readonly "de-DE": "Kryptografie";
             };
         }];
+        readonly links: {
+            readonly website: "https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.197-upd1.pdf";
+            readonly wikipedia: "https://en.wikipedia.org/wiki/Advanced_Encryption_Standard";
+        };
+        readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
+            readonly definition: {
+                readonly id: "ai_generated";
+                readonly name: {
+                    readonly "en-US": "AI Generated";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "KI-generiert";
+                };
+            };
+        };
     };
     readonly agile: {
         readonly id: "agile";
@@ -2647,13 +2669,17 @@ export declare const RAW_TERMS: {
         readonly id: "react";
         readonly name: {
             readonly "en-US": "React";
+            readonly "en-GB": "en-US";
+            readonly "de-DE": "en-US";
         };
         readonly label: {
             readonly "en-US": "JavaScript Library";
+            readonly "en-GB": "en-US";
             readonly "de-DE": "JavaScript-Bibliothek";
         };
         readonly definition: {
             readonly "en-US": "A JavaScript library for building component-based user interfaces.";
+            readonly "en-GB": "en-US";
             readonly "de-DE": "Eine JavaScript-Bibliothek zum Erstellen komponentenbasierter Benutzeroberflächen.";
         };
         readonly type: [{
@@ -2707,6 +2733,14 @@ export declare const RAW_TERMS: {
             readonly wikipedia: "https://en.wikipedia.org/wiki/React_(software)";
         };
         readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
             readonly definition: {
                 readonly id: "official_website";
                 readonly name: {
@@ -3311,6 +3345,8 @@ export declare const RAW_TERMS: {
         readonly id: "typescript";
         readonly name: {
             readonly "en-US": "TypeScript";
+            readonly "en-GB": "en-US";
+            readonly "de-DE": "en-US";
         };
         readonly label: {
             readonly "en-US": "High-Level Programming Language";
@@ -3363,6 +3399,14 @@ export declare const RAW_TERMS: {
             readonly website: "https://www.typescriptlang.org";
         };
         readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
             readonly definition: {
                 readonly id: "official_website";
                 readonly name: {
@@ -3723,6 +3767,28 @@ export declare const TERMS: {
                 readonly "de-DE": "Kryptografie";
             };
         }];
+        readonly links: {
+            readonly website: "https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.197-upd1.pdf";
+            readonly wikipedia: "https://en.wikipedia.org/wiki/Advanced_Encryption_Standard";
+        };
+        readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
+            readonly definition: {
+                readonly id: "ai_generated";
+                readonly name: {
+                    readonly "en-US": "AI Generated";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "KI-generiert";
+                };
+            };
+        };
     };
     readonly agile: {
         readonly id: "agile";
@@ -6326,13 +6392,17 @@ export declare const TERMS: {
         readonly id: "react";
         readonly name: {
             readonly "en-US": "React";
+            readonly "en-GB": "en-US";
+            readonly "de-DE": "en-US";
         };
         readonly label: {
             readonly "en-US": "JavaScript Library";
+            readonly "en-GB": "en-US";
             readonly "de-DE": "JavaScript-Bibliothek";
         };
         readonly definition: {
             readonly "en-US": "A JavaScript library for building component-based user interfaces.";
+            readonly "en-GB": "en-US";
             readonly "de-DE": "Eine JavaScript-Bibliothek zum Erstellen komponentenbasierter Benutzeroberflächen.";
         };
         readonly type: [{
@@ -6386,6 +6456,14 @@ export declare const TERMS: {
             readonly wikipedia: "https://en.wikipedia.org/wiki/React_(software)";
         };
         readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
             readonly definition: {
                 readonly id: "official_website";
                 readonly name: {
@@ -6990,6 +7068,8 @@ export declare const TERMS: {
         readonly id: "typescript";
         readonly name: {
             readonly "en-US": "TypeScript";
+            readonly "en-GB": "en-US";
+            readonly "de-DE": "en-US";
         };
         readonly label: {
             readonly "en-US": "High-Level Programming Language";
@@ -7042,6 +7122,14 @@ export declare const TERMS: {
             readonly website: "https://www.typescriptlang.org";
         };
         readonly sources: {
+            readonly label: {
+                readonly id: "community";
+                readonly name: {
+                    readonly "en-US": "Community Consensus";
+                    readonly "en-GB": "en-US";
+                    readonly "de-DE": "Gemeinschaftskonsens";
+                };
+            };
             readonly definition: {
                 readonly id: "official_website";
                 readonly name: {