@intlayer/core 9.0.2 → 9.1.1

package/dist/esm/transpiler/select/select.mjs

@@ -0,0 +1,41 @@
+import { SELECT, formatNodeType } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/select/select.ts
+/**
+* Function intended to be used to build intlayer dictionaries.
+*
+* Allow to pick a content based on an arbitrary string value — the equivalent
+* of an ICU `{value, select, …}` message, or of a `switch` statement in the
+* application code.
+*
+* Use it when the discriminant is neither a quantity (`enu`), a boolean
+* (`cond`), nor a gender (`gender`).
+*
+* Usage:
+*
+* ```ts
+* select({
+*  draft: 'This post is a draft',
+*  published: 'This post is live',
+*  scheduled: 'This post is scheduled',
+*  fallback: 'Unknown status',
+* });
+* ```
+*
+* When no `fallback` key is provided, the last key declared is used as the
+* fallback value — the same contract as `cond()` and `gender()`.
+*
+* Prefer `select()` over indexing a plain object (`content.status[value]`):
+* a dynamic computed access cannot be resolved statically by the Intlayer
+* compiler, which forces the whole branch to be kept and its keys to stay
+* un-minified.
+*
+* @param content - The map of cases to content.
+* @param variable - Optional name of the variable being selected on. Preserved
+* for the ICU / i18next round-trip; unused at runtime.
+*/
+const select = (content, variable) => formatNodeType(SELECT, content, { variable });
+
+//#endregion
+export { select };
+//# sourceMappingURL=select.mjs.map

package/dist/esm/transpiler/select/select.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.mjs","names":[],"sources":["../../../../src/transpiler/select/select.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, SELECT } from '@intlayer/types/nodeType';\n\n/**\n * Map of arbitrary string cases to their content.\n *\n * Every key is a case the application can switch on (`'Draft'`, `'Published'`,\n * `'Scheduled'`, …). The optional `fallback` key is picked when the provided\n * value matches no declared case.\n */\nexport type SelectContentStates<Content = unknown> = {\n  [caseKey: string]: Content;\n} & {\n  fallback?: Content;\n};\n\nexport type SelectContent<\n  States extends SelectContentStates = SelectContentStates,\n> = TypedNodeModel<\n  typeof SELECT,\n  States,\n  {\n    /**\n     * Name of the variable the cases are selected on.\n     *\n     * Purely informational at runtime — the selector is passed explicitly by\n     * the caller. It is preserved so content imported from, or exported to, an\n     * ICU `{publishType, select, …}` message keeps its variable name across\n     * the round-trip.\n     */\n    variable?: string;\n  }\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on an arbitrary string value — the equivalent\n * of an ICU `{value, select, …}` message, or of a `switch` statement in the\n * application code.\n *\n * Use it when the discriminant is neither a quantity (`enu`), a boolean\n * (`cond`), nor a gender (`gender`).\n *\n * Usage:\n *\n * ```ts\n * select({\n *  draft: 'This post is a draft',\n *  published: 'This post is live',\n *  scheduled: 'This post is scheduled',\n *  fallback: 'Unknown status',\n * });\n * ```\n *\n * When no `fallback` key is provided, the last key declared is used as the\n * fallback value — the same contract as `cond()` and `gender()`.\n *\n * Prefer `select()` over indexing a plain object (`content.status[value]`):\n * a dynamic computed access cannot be resolved statically by the Intlayer\n * compiler, which forces the whole branch to be kept and its keys to stay\n * un-minified.\n *\n * @param content - The map of cases to content.\n * @param variable - Optional name of the variable being selected on. Preserved\n * for the ICU / i18next round-trip; unused at runtime.\n */\nconst select = <const States extends SelectContentStates>(\n  content?: States,\n  variable?: string\n): SelectContent<States> =>\n  formatNodeType(SELECT, content as States, { variable });\n\nexport { select };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,MAAM,UACJ,SACA,aAEA,eAAe,QAAQ,SAAmB,EAAE,SAAS,CAAC"}

package/dist/types/dictionaryManipulator/getNodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;cA4Ca,cAAW,SAAa,gBAAc"}
+{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;cAsDa,cAAW,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/index.d.ts

@@ -8,8 +8,8 @@ import { mergeDictionaries } from "./mergeDictionaries.js";
 import { mergeQualifiedDictionaries } from "./mergeQualifiedDictionaries.js";
 import { normalizeDictionaries, normalizeDictionary } from "./normalizeDictionary.js";
 import { orderDictionaries } from "./orderDictionaries.js";
-import { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./qualifiedDictionary.js";
+import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./qualifiedDictionary.js";
 import { removeContentNodeByKeyPath } from "./removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./updateNodeChildren.js";
-export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, updateNodeChildren };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, updateNodeChildren };

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts

@@ -10,7 +10,10 @@ import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary
  *   `variant → item`). Dictionaries are grouped by their composite id
  *   (one segment per dimension), merged within each group (locale completion /
  *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.
- *   Unqualified siblings act as shared base content merged into every entry.
+ *   Unqualified siblings act as shared base content merged into every entry —
+ *   and, on a variant-only key, also materialize the `default` entry when no
+ *   declaration claims it. Every other variant entry then inherits from that
+ *   `default` entry, so a variant only declares the fields it overrides.
  *
  * Every qualified entry must declare ALL dimensions of the group; an entry that
  * declares only a subset is ambiguous and is rejected with an error log.

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;cA6Ba,6BAA0B,cACvB,iBACb,aAAa"}
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAkCa,6BAA0B,cACvB,iBACb,aAAa"}

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts

@@ -12,6 +12,12 @@ declare const QUALIFIER_ORDER: readonly ["variant", "item"];
  * the chunk path separator in dynamic mode.
  */
 declare const COMPOSITE_ID_SEPARATOR = "/";
+/**
+ * Identity of the implicit fallback variant. A selector that pins no variant
+ * resolves to it, and a variant that declares no entry of its own falls back to
+ * it — so a key only has to ship the entries that actually differ.
+ */
+declare const DEFAULT_VARIANT_ID = "default";
 /**
  * Canonical serialization of a single variant value into its identity string —
  * the variant segment of a composite id, the chunk directory name in dynamic
@@ -86,8 +92,10 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * - Plain dictionary → returned as-is (selector ignored)
  * - `item` declared but not selected → every matching entry ordered by index
  * - `item` selected → the matching entry or null
- * - `variant` defaults to the `default` entry when not selected; an object
- *   variant resolves only when the selector provides an equal object
+ * - `variant` defaults to the `default` entry when not selected, and falls back
+ *   to it when the selected variant declares no entry of its own; an object
+ *   variant resolves only when the selector provides an equal object (or, again,
+ *   through the `default` fallback)
  *
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
@@ -150,11 +158,11 @@ declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is Qualifie
  * loading only the chunk(s) the selector actually targets.
  *
  * Walks the nested loader tree one dimension at a time (canonical order
- * `variant → item`): `variant` defaults to `default` (or descends by the
- * serialized object identity), and `item` either narrows to the selected index
- * or — when no item is given — expands into every sibling chunk (the collection
- * axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and
- * static modes behave alike.
+ * `variant → item`): `variant` descends by the serialized id, falling back to
+ * `default` when the selected variant has no chunk of its own, and `item`
+ * either narrows to the selected index or — when no item is given — expands
+ * into every sibling chunk (the collection axis). Semantics mirror
+ * {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
  *
  * The Suspense mechanism is injected through `loadChunk` so the same logic
  * serves both the client (suspender cache) and the server (`react.use`). Every
@@ -195,5 +203,5 @@ declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   transform: (dictionary: Dictionary) => Content;
 }) => Promise<Content | Content[] | null>;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
+export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;;cAca;;;;;cASA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;cAuBE,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN;;;;;;cAiDL,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;cAgCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cA+BH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;cAef,gCAA6B,WAC7B;;;;;;;cAwBA;;;;KAKD,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cA6GC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;;cAca;;;;;cASA;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;cAuBE,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN;;;;;;cA0EL,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;cAef,gCAA6B,WAC7B;;;;;;;cAwBA;;;;KAKD,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cAkHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

package/dist/types/dictionaryManipulator/qualifiedDictionary.test-d.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/index.d.ts

@@ -13,19 +13,22 @@ import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "./t
 import { MarkdownValidationResult, validateMarkdown } from "./transpiler/markdown/validateMarkdown.js";
 import { DotPath, NestedContent, NestedContentState, ValidDotPathsFor, nest as nesting } from "./transpiler/nesting/nesting.js";
 import { PluralCategory, PluralContent, PluralContentState, plural } from "./transpiler/plural/plural.js";
+import { SelectContent, SelectContentStates, select } from "./transpiler/select/select.js";
 import { TranslationContent, t as translation } from "./transpiler/translation/translation.js";
 import "./transpiler/index.js";
 import { getCondition } from "./interpreter/getCondition.js";
 import { GetNestingResult, getNesting } from "./interpreter/getNesting.js";
-import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, translationPlugin } from "./interpreter/getContent/plugins.js";
+import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin } from "./interpreter/getContent/plugins.js";
 import { deepTransformNode } from "./interpreter/getContent/deepTransform.js";
 import { getBasePlugins, getContent } from "./interpreter/getContent/getContent.js";
 import { getDictionary } from "./interpreter/getDictionary.js";
 import { findMatchingCondition, getEnumeration } from "./interpreter/getEnumeration.js";
+import { getGender } from "./interpreter/getGender.js";
 import { getHTML } from "./interpreter/getHTML.js";
 import { getInsertion } from "./interpreter/getInsertion.js";
 import { getIntlayer } from "./interpreter/getIntlayer.js";
 import { getPlural } from "./interpreter/getPlural.js";
+import { getSelect } from "./interpreter/getSelect.js";
 import { getTranslation } from "./interpreter/getTranslation.js";
 import { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode } from "./interpreter/interpolableNode.js";
 import { splitInsertionTemplate } from "./interpreter/splitAndJoinInsertion.js";
@@ -51,7 +54,7 @@ import { mergeDictionaries } from "./dictionaryManipulator/mergeDictionaries.js"
 import { mergeQualifiedDictionaries } from "./dictionaryManipulator/mergeQualifiedDictionaries.js";
 import { normalizeDictionaries, normalizeDictionary } from "./dictionaryManipulator/normalizeDictionary.js";
 import { orderDictionaries } from "./dictionaryManipulator/orderDictionaries.js";
-import { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./dictionaryManipulator/qualifiedDictionary.js";
+import { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./dictionaryManipulator/qualifiedDictionary.js";
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./dictionaryManipulator/updateNodeChildren.js";
@@ -107,4 +110,4 @@ import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorag
 import { YamlRecord, YamlValue, parseYaml } from "./utils/parseYaml.js";
 import { stringifyYaml } from "./utils/stringifyYaml.js";
 import "./utils/index.js";
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, Priority, PriorityValue, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getReplacedValuesContent, getRewritePath, getRewriteRules, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveMessage, resolveMessageNode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, serializeVariant, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, Priority, PriorityValue, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SelectCond, SelectContent, SelectContentStates, SelectSelector, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveMessage, resolveMessageNode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };

package/dist/types/interpreter/getContent/getContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getContent.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"mappings":";;;;cAqBa,iBAAc,SAChB,eAAa,uBAErB;;;;;;;cAoBU,mBACL,UAAU,mBACV,UAAU,gBAAgB,iBAAe,MAEzC,GAAC,WACI,WAAS,UACX,cAKH,qBAAqB,GAAG,yBAAyB"}
+{"version":3,"file":"getContent.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"mappings":";;;;cAsBa,iBAAc,SAChB,eAAa,uBAErB;;;;;;;cAqBU,mBACL,UAAU,mBACV,UAAU,gBAAgB,iBAAe,MAEzC,GAAC,WACI,WAAS,UACX,cAKH,qBAAqB,GAAG,yBAAyB"}

package/dist/types/interpreter/getContent/index.d.ts

@@ -1,4 +1,4 @@
-import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, translationPlugin } from "./plugins.js";
+import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin } from "./plugins.js";
 import { deepTransformNode } from "./deepTransform.js";
 import { getBasePlugins, getContent } from "./getContent.js";
-export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, getBasePlugins, getContent, insertionPlugin, nestedPlugin, pluralPlugin, translationPlugin };
+export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, getBasePlugins, getContent, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin };

package/dist/types/interpreter/getContent/plugins.d.ts

@@ -94,6 +94,25 @@ type GenderCond<T, S, _L> = T extends {
 } ? (value: Gender) => DeepTransformContent<T[typeof NodeTypes.GENDER][keyof T[typeof NodeTypes.GENDER]], S> : never;
 /** Gender plugin. Replaces node with a function that takes gender => string. */
 declare const genderPlugin: Plugins;
+/** ---------------------------------------------
+ * SELECT PLUGIN
+ * --------------------------------------------- */
+/**
+ * Accepted selector for a select node.
+ *
+ * When the node declares a `fallback` case, any string is accepted (the
+ * fallback covers the unmatched values) while the declared cases still
+ * autocomplete. Without a `fallback`, only the declared cases are accepted.
+ */
+type SelectSelector<States> = 'fallback' extends keyof States ? Exclude<keyof States & string, 'fallback'> | (string & {}) : keyof States & string;
+type SelectCond<T, S, _L> = T extends {
+  nodeType: NodeType | string;
+  [NodeTypes.SELECT]: object;
+} ? (value: SelectSelector<T[typeof NodeTypes.SELECT]> | {
+  value: SelectSelector<T[typeof NodeTypes.SELECT]>;
+}) => DeepTransformContent<T[typeof NodeTypes.SELECT][keyof T[typeof NodeTypes.SELECT]], S> : never;
+/** Select plugin. Replaces node with a function that takes a string => content. */
+declare const selectPlugin: Plugins;
 /** ---------------------------------------------
  * NESTED PLUGIN
  * --------------------------------------------- */
@@ -149,6 +168,7 @@ interface IInterpreterPlugin<T, S, L extends LocalesValues> {
   condition: ConditionCond<T, S, L>;
   insertion: InsertionCond<T, S, L>;
   gender: GenderCond<T, S, L>;
+  select: SelectCond<T, S, L>;
   nested: NestedCond<T, S, L>;
   file: FileCond<T, S, L>;
 }
@@ -162,6 +182,7 @@ type IInterpreterPluginState = {
   condition: true;
   insertion: true;
   gender: true;
+  select: true;
   nested: true;
   file: true;
 };
@@ -179,5 +200,5 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
  */
 type DeepTransformContent<T, S = IInterpreterPluginState, L extends LocalesValues = DeclaredLocales> = IsAny<T> extends true ? T : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never ? Traverse<T, S, L> : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;
 //#endregion
-export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, translationPlugin };
+export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin };
 //# sourceMappingURL=plugins.d.ts.map

package/dist/types/interpreter/getContent/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"mappings":"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"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"mappings":"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"}

package/dist/types/interpreter/getDictionary.d.ts

@@ -1,7 +1,7 @@
 import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
 import "./getContent/index.js";
 import { Dictionary, DictionarySelector, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
-import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, ExtractSelectorLocale } from "@intlayer/types/module_augmentation";
 //#region src/interpreter/getDictionary.d.ts
 /**
  * Transforms a dictionary in a single pass, applying each plugin as needed.
@@ -17,7 +17,7 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
  * @param plugins An array of NodeTransformer that define how to transform recognized nodes.
  *                If omitted, we’ll use a default set of plugins.
  */
-declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
+declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends DeclaredLocales | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
 export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

package/dist/types/interpreter/getDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAqCa,sBACL,UAAU,aAAa,gCACvB,UAAU,gBAAgB,qBAAqB,iBAAe,YAExD,GAAC,mBACM,GAAC,UACV,cACT,qBACD,kCAAkC,GAAG,IACrC,yBACA,sBAAsB"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAoCa,sBACL,UAAU,aAAa,gCACvB,UAAU,kBAAkB,qBAAqB,iBAAe,YAE1D,GAAC,mBACM,GAAC,UACV,cACT,qBACD,kCAAkC,GAAG,IACrC,yBACA,sBAAsB"}

package/dist/types/interpreter/getIntlayer.d.ts

@@ -1,7 +1,7 @@
 import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
 import "./getContent/index.js";
 import { DictionarySelector } from "@intlayer/types/dictionary";
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelectorLocale } from "@intlayer/types/module_augmentation";
 //#region src/interpreter/getIntlayer.d.ts
 /**
  * Picks one dictionary by its key and returns its content for the given
@@ -13,7 +13,7 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant
  * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`
  */
-declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
+declare const getIntlayer: <const T extends DictionaryKeys, const A extends DeclaredLocales | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
 export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

package/dist/types/interpreter/getIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;cAkEa,oBACL,UAAU,sBACV,UAAU,gBAAgB,qBAAqB,iBAAe,KAE/D,GAAC,mBACa,GAAC,UACV,cACT,qBACD,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;cAkEa,oBACL,UAAU,sBACV,UAAU,kBAAkB,qBAAqB,iBAAe,KAEjE,GAAC,mBACa,GAAC,UACV,cACT,qBACD,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}

package/dist/types/interpreter/getSelect.d.ts

@@ -0,0 +1,31 @@
+import { SelectContentStates } from "../transpiler/select/select.js";
+import "../transpiler/index.js";
+//#region src/interpreter/getSelect.d.ts
+/**
+ * Picks content from a select map based on an arbitrary string value.
+ *
+ * Resolution order:
+ * 1. Exact match on the provided value.
+ * 2. The `fallback` key.
+ * 3. The `other` key — kept for content imported from an ICU `select` message,
+ *    where the catch-all case is named `other`.
+ * 4. The last declared key, so a select node never resolves to `undefined`.
+ *
+ * @param selectContent - A map of string cases to content.
+ * @param value - The value to match against the declared cases.
+ * @returns The matching content.
+ *
+ * @example
+ * ```ts
+ * const content = getSelect({
+ *   draft: 'This post is a draft',
+ *   published: 'This post is live',
+ *   fallback: 'Unknown status',
+ * }, 'published');
+ * // 'This post is live'
+ * ```
+ */
+declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
+//#endregion
+export { getSelect };
+//# sourceMappingURL=getSelect.d.ts.map

package/dist/types/interpreter/getSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSelect.d.ts","names":[],"sources":["../../../src/interpreter/getSelect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ba,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,mBAE1C"}

package/dist/types/interpreter/index.d.ts

@@ -1,16 +1,18 @@
 import { getCondition } from "./getCondition.js";
 import { GetNestingResult, getNesting } from "./getNesting.js";
-import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, translationPlugin } from "./getContent/plugins.js";
+import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin } from "./getContent/plugins.js";
 import { deepTransformNode } from "./getContent/deepTransform.js";
 import { getBasePlugins, getContent } from "./getContent/getContent.js";
 import "./getContent/index.js";
 import { getDictionary } from "./getDictionary.js";
 import { findMatchingCondition, getEnumeration } from "./getEnumeration.js";
+import { getGender } from "./getGender.js";
 import { getHTML } from "./getHTML.js";
 import { getInsertion } from "./getInsertion.js";
 import { getIntlayer } from "./getIntlayer.js";
 import { getPlural } from "./getPlural.js";
+import { getSelect } from "./getSelect.js";
 import { getTranslation } from "./getTranslation.js";
 import { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode } from "./interpolableNode.js";
 import { splitInsertionTemplate } from "./splitAndJoinInsertion.js";
-export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, GetNestingResult, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, InterpolableNode, IsAny, NestedCond, NodeProps, Plugins, PluralCond, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, fallbackPlugin, filePlugin, findMatchingCondition, genderPlugin, getBasePlugins, getCondition, getContent, getDictionary, getEnumeration, getHTML, getInsertion, getInterpolableContent, getIntlayer, getNesting, getPlural, getTranslation, insertionPlugin, isInterpolableWrapperNode, nestedPlugin, pluralPlugin, rebuildInterpolableContent, splitInsertionTemplate, transformInterpolableNode, translationPlugin };
+export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, GetNestingResult, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, InterpolableNode, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, deepTransformNode, enumerationPlugin, fallbackPlugin, filePlugin, findMatchingCondition, genderPlugin, getBasePlugins, getCondition, getContent, getDictionary, getEnumeration, getGender, getHTML, getInsertion, getInterpolableContent, getIntlayer, getNesting, getPlural, getSelect, getTranslation, insertionPlugin, isInterpolableWrapperNode, nestedPlugin, pluralPlugin, rebuildInterpolableContent, selectPlugin, splitInsertionTemplate, transformInterpolableNode, translationPlugin };

package/dist/types/messageFormat/ICU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;KAkDY,+CAKR;GACG,cAAc;;cAwlBR,yBAAsB,SACxB,0BACR;cAQU,yBAAsB,SACxB,0BACR"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;KAkDY,+CAKR;GACG,cAAc;;cAknBR,yBAAsB,SACxB,0BACR;cAQU,yBAAsB,SACxB,0BACR"}

package/dist/types/messageFormat/i18next.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;cAsjBa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;cAklBa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}

package/dist/types/messageFormat/resolveMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;KAwBY;;KAGA,gBAAgB;;;;;;;;;cAsFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;cAkCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;;;;;;;;;;cA6IG,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;KAaC;EAEN;EAAa,UAAU;;;;;;;;;cAShB,qBAAkB,oBAAsB"}
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;KAyBY;;KAGA,gBAAgB;;;;;;;;;cAsFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;cAkCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;;;;;;;;;;cA2JG,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;KAaC;EAEN;EAAa,UAAU;;;;;;;;;cAShB,qBAAkB,oBAAsB"}

package/dist/types/messageFormat/vue-i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;cAoUa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;cAoVa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}

package/dist/types/transpiler/index.d.ts

@@ -21,6 +21,8 @@ import { DotPath, NestedContent, NestedContentState, ValidDotPathsFor, nest as n
 import "./nesting/index.js";
 import { PluralCategory, PluralContent, PluralContentState, plural } from "./plural/plural.js";
 import "./plural/index.js";
+import { SelectContent, SelectContentStates, select } from "./select/select.js";
+import "./select/index.js";
 import { TranslationContent, t as translation } from "./translation/translation.js";
 import "./translation/index.js";
-export { ConditionContent, ConditionContentStates, DotPath, EnterFormat, EnumerationContent, EnumerationContentState, type FileContent, type FileContentConstructor, Gender, GenderContent, GenderContentStates, HTMLContent, HTMLContentConstructor, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_TAGS, InsertionContent, InsertionContentConstructor, MarkdownContent, MarkdownContentConstructor, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, NestedContent, NestedContentState, PluralCategory, PluralContent, PluralContentState, TranslationContent, VOID_HTML_ELEMENTS, ValidDotPathsFor, condition as cond, enumeration as enu, type file, type fileContent, gender, getInsertionValues, getMarkdownMetadata, html, insertion as insert, markdown as md, nesting as nest, plural, translation as t, validateHTML, validateMarkdown };
+export { ConditionContent, ConditionContentStates, DotPath, EnterFormat, EnumerationContent, EnumerationContentState, type FileContent, type FileContentConstructor, Gender, GenderContent, GenderContentStates, HTMLContent, HTMLContentConstructor, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_TAGS, InsertionContent, InsertionContentConstructor, MarkdownContent, MarkdownContentConstructor, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, NestedContent, NestedContentState, PluralCategory, PluralContent, PluralContentState, SelectContent, SelectContentStates, TranslationContent, VOID_HTML_ELEMENTS, ValidDotPathsFor, condition as cond, enumeration as enu, type file, type fileContent, gender, getInsertionValues, getMarkdownMetadata, html, insertion as insert, markdown as md, nesting as nest, plural, select, translation as t, validateHTML, validateMarkdown };

package/dist/types/transpiler/select/index.d.ts

@@ -0,0 +1,2 @@
+import { SelectContent, SelectContentStates, select } from "./select.js";
+export { SelectContent, SelectContentStates, select };

package/dist/types/transpiler/select/select.d.ts

@@ -0,0 +1,62 @@
+import { SELECT, TypedNodeModel } from "@intlayer/types/nodeType";
+//#region src/transpiler/select/select.d.ts
+/**
+ * Map of arbitrary string cases to their content.
+ *
+ * Every key is a case the application can switch on (`'Draft'`, `'Published'`,
+ * `'Scheduled'`, …). The optional `fallback` key is picked when the provided
+ * value matches no declared case.
+ */
+type SelectContentStates<Content = unknown> = {
+  [caseKey: string]: Content;
+} & {
+  fallback?: Content;
+};
+type SelectContent<States extends SelectContentStates = SelectContentStates> = TypedNodeModel<typeof SELECT, States, {
+  /**
+   * Name of the variable the cases are selected on.
+   *
+   * Purely informational at runtime — the selector is passed explicitly by
+   * the caller. It is preserved so content imported from, or exported to, an
+   * ICU `{publishType, select, …}` message keeps its variable name across
+   * the round-trip.
+   */
+  variable?: string;
+}>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on an arbitrary string value — the equivalent
+ * of an ICU `{value, select, …}` message, or of a `switch` statement in the
+ * application code.
+ *
+ * Use it when the discriminant is neither a quantity (`enu`), a boolean
+ * (`cond`), nor a gender (`gender`).
+ *
+ * Usage:
+ *
+ * ```ts
+ * select({
+ *  draft: 'This post is a draft',
+ *  published: 'This post is live',
+ *  scheduled: 'This post is scheduled',
+ *  fallback: 'Unknown status',
+ * });
+ * ```
+ *
+ * When no `fallback` key is provided, the last key declared is used as the
+ * fallback value — the same contract as `cond()` and `gender()`.
+ *
+ * Prefer `select()` over indexing a plain object (`content.status[value]`):
+ * a dynamic computed access cannot be resolved statically by the Intlayer
+ * compiler, which forces the whole branch to be kept and its keys to stay
+ * un-minified.
+ *
+ * @param content - The map of cases to content.
+ * @param variable - Optional name of the variable being selected on. Preserved
+ * for the ICU / i18next round-trip; unused at runtime.
+ */
+declare const select: <const States extends SelectContentStates>(content?: States, variable?: string) => SelectContent<States>;
+//#endregion
+export { SelectContent, SelectContentStates, select };
+//# sourceMappingURL=select.d.ts.map

package/dist/types/transpiler/select/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","names":[],"sources":["../../../../src/transpiler/select/select.ts"],"mappings":";;;;;;;;;KAUY,oBAAoB;GAC7B,kBAAkB;;EAEnB,WAAW;;KAGD,cACV,eAAe,sBAAsB,uBACnC,sBACK,QACP;;;;;;;;;EAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,eAAgB,eAAe,qBAAmB,UAC5C,QAAM,sBAEf,cAAc"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.0.2",
+  "version": "9.1.1",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,15 +172,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.0.2",
-    "@intlayer/config": "9.0.2",
-    "@intlayer/dictionaries-entry": "9.0.2",
-    "@intlayer/types": "9.0.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.0.2",
+    "@intlayer/api": "9.1.1",
+    "@intlayer/config": "9.1.1",
+    "@intlayer/dictionaries-entry": "9.1.1",
+    "@intlayer/types": "9.1.1",
+    "@intlayer/unmerged-dictionaries-entry": "9.1.1",
     "defu": "6.1.7"
   },
   "devDependencies": {
-    "@types/node": "26.1.1",
+    "@types/node": "26.1.2",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",